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.
3959 Commits
16 Branches
16GB
Tree: 510209d0ee
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '510209d0ee'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/Misc/Master.cpp

1710 lines
54KB
Raw Blame History 

  1. /*

  2.   ZynAddSubFX - a software synthesizer

  3. 

  4.   Master.cpp - It sends Midi Messages to Parts, receives samples from parts,

  5.              process them with system/insertion effects and mix them

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

  7.   Author: Nasca Octavian Paul

  8. 

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

  10.   modify it under the terms of the GNU General Public License

  11.   as published by the Free Software Foundation; either version 2

  12.   of the License, or (at your option) any later version.

  13. */

  14. 

  15. #include "Master.h"

  16. 

  17. #include "Part.h"

  18. 

  19. #include "zyn-version.h"

  20. #include "../Misc/Stereo.h"

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

  22. #include "../Params/LFOParams.h"

  23. #include "../Effects/EffectMgr.h"

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

  25. #include "../Misc/Allocator.h"

  26. #include "../Containers/ScratchString.h"

  27. #include "../Nio/Nio.h"

  28. #include "PresetExtractor.h"

  29. 

  30. #include <rtosc/ports.h>

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

  32. #include <rtosc/thread-link.h>

  33. #include <stdio.h>

  34. #include <sys/stat.h>

  35. #include <sys/types.h>

  36. #include <fstream>

  37. #include <iostream>

  38. #include <algorithm>

  39. #include <cmath>

  40. #include <atomic>

  41. #include <unistd.h>

  42. 

  43. using namespace std;

  44. using namespace rtosc;

  45. 

  46. namespace zyncarla {

  47. 

  48. #define rObject Master

  49. 

  50. static const Ports sysefxPort =

  51. {

  52.     {"part#" STRINGIFY(NUM_MIDI_PARTS) "::i", rProp(parameter)

  53.         rDoc("gain on part to sysefx routing"), 0,

  54.         [](const char *m, RtData&d)

  55.         {

  56.             //we know that if we are here the location must

  57.             //be ...Psysefxvol#N/part#M

  58.             //and the number "N" is one or two digits at most

  59. 

  60.             // go backto the '/'

  61.             const char* m_findslash = m + strlen(m),

  62.                       * loc_findslash = d.loc + strlen(d.loc);

  63.             for(;*loc_findslash != '/'; --m_findslash, --loc_findslash)

  64.                 assert(*loc_findslash == *m_findslash);

  65.             assert(m_findslash + 1 == m);

  66. 

  67.             const char *index_1 = loc_findslash-1;

  68.             assert(isdigit(*index_1));

  69.             if(isdigit(index_1[-1]))

  70.                 index_1--;

  71.             int ind1 = atoi(index_1);

  72. 

  73.             //Now get the second index like normal

  74.             while(!isdigit(*m)) m++;

  75.             int ind2 = atoi(m);

  76.             Master &mast = *(Master*)d.obj;

  77. 

  78.             if(rtosc_narguments(m)) {

  79.                 mast.setPsysefxvol(ind2, ind1, rtosc_argument(m,0).i);

  80.                 d.broadcast(d.loc, "i", mast.Psysefxvol[ind1][ind2]);

  81.             } else

  82.                 d.reply(d.loc, "i", mast.Psysefxvol[ind1][ind2]);

  83.         }}

  84. };

  85. 

  86. static const Ports sysefsendto =

  87. {

  88.     {"to#" STRINGIFY(NUM_SYS_EFX) "::i",

  89.         rProp(parameter) rDoc("sysefx to sysefx routing gain"), 0, [](const char *m, RtData&d)

  90.         {

  91.             //same workaround as before

  92.             //go backto the '/'

  93.             const char* m_findslash = m + strlen(m),

  94.                       * loc_findslash = d.loc + strlen(d.loc);

  95.             for(;*loc_findslash != '/'; --m_findslash, --loc_findslash)

  96.                 assert(*loc_findslash == *m_findslash);

  97.             assert(m_findslash + 1 == m);

  98. 

  99.             const char *index_1 = loc_findslash-1;

  100.             assert(isdigit(*index_1));

  101.             if(isdigit(index_1[-1]))

  102.                 index_1--;

  103.             int ind1 = atoi(index_1);

  104. 

  105.             //Now get the second index like normal

  106.             while(!isdigit(*m)) m++;

  107.             int ind2 = atoi(m);

  108.             Master &master = *(Master*)d.obj;

  109. 

  110.             if(rtosc_narguments(m))

  111.                 master.setPsysefxsend(ind1, ind2, rtosc_argument(m,0).i);

  112.             else

  113.                 d.reply(d.loc, "i", master.Psysefxsend[ind1][ind2]);

  114.         }}

  115. };

  116. 

  117. #define rBegin [](const char *msg, RtData &d) { rtosc::AutomationMgr &a = *(AutomationMgr*)d.obj

  118. #define rEnd }

  119. 

  120. static int extract_num(const char *&msg)

  121. {

  122.     while(*msg && !isdigit(*msg)) msg++;

  123.     int num = atoi(msg);

  124.     while(isdigit(*msg)) msg++;

  125.     return num;

  126. }

  127. 

  128. static int get_next_int(const char *msg)

  129. {

  130.     return extract_num(msg);

  131. }

  132. 

  133. static const Ports mapping_ports = {

  134.     {"offset::f", rProp(parameter) rDefault(0) rShort("off") rLinear(-50, 50) rMap(unit, percent), 0,

  135.         rBegin;

  136.         int slot = d.idx[1];

  137.         int param = d.idx[0];

  138.         if(!strcmp("f",rtosc_argument_string(msg))) {

  139.             a.setSlotSubOffset(slot, param, rtosc_argument(msg, 0).f);

  140.             a.updateMapping(slot, param);

  141.             d.broadcast(d.loc, "f", a.getSlotSubOffset(slot, param));

  142.         } else

  143.             d.reply(d.loc, "f", a.getSlotSubOffset(slot, param));

  144.         rEnd},

  145.     {"gain::f", rProp(parameter) rDefault(100) rShort("gain") rLinear(-200, 200) rMap(unit, percent), 0,

  146.         rBegin;

  147.         int slot = d.idx[1];

  148.         int param = d.idx[0];

  149.         if(!strcmp("f",rtosc_argument_string(msg))) {

  150.             a.setSlotSubGain(slot, param, rtosc_argument(msg, 0).f);

  151.             a.updateMapping(slot, param);

  152.             d.broadcast(d.loc, "f", a.getSlotSubGain(slot, param));

  153.         } else

  154.             d.reply(d.loc, "f", a.getSlotSubGain(slot, param));

  155.         rEnd},

  156. };

  157. 

  158. static const Ports auto_param_ports = {

  159.     {"used::T:F", rProp(parameter) rProp(read-only) rDoc("If automation is assigned to anything"), 0,

  160.         rBegin;

  161.         int slot  = d.idx[1];

  162.         int param = d.idx[0];

  163. 

  164.         d.reply(d.loc, a.slots[slot].automations[param].used ? "T" : "F");

  165.         rEnd},

  166.     {"active::T:F", rProp(parameter) rDoc("If automation is being actively used"), 0,

  167.         rBegin;

  168.         int slot  = d.idx[1];

  169.         int param = d.idx[0];

  170.         if(rtosc_narguments(msg))

  171.             a.slots[slot].automations[param].active = rtosc_argument(msg, 0).T;

  172.         else

  173.             d.reply(d.loc, a.slots[slot].automations[param].active ? "T" : "F");

  174.         rEnd},

  175.     {"path::s", rProp(parameter) rProp(read-only) rDoc("Path of parameter"), 0,

  176.         rBegin;

  177.         int slot  = d.idx[1];

  178.         int param = d.idx[0];

  179.         d.reply(d.loc, "s", a.slots[slot].automations[param].param_path);

  180.         rEnd},

  181.     {"clear:", rDoc("Clear automation param"), 0,

  182.         rBegin;

  183.         int slot = d.idx[1];

  184.         int param = d.idx[0];

  185.         a.clearSlotSub(slot, param);

  186.         rEnd},

  187.     {"mapping/", 0, &mapping_ports,

  188.         rBegin;

  189.         (void) a;

  190.         SNIP;

  191.         mapping_ports.dispatch(msg, d);

  192.         rEnd},

  193. 

  194.     //{"mapping", rDoc("Parameter mapping control"), 0,

  195.     //    rBegin;

  196.     //    int slot  = d.idx[1];

  197.     //    int param = d.idx[0];

  198.     //    if(!strcmp("b", rtosc_argument_string(msg))) {

  199.     //        int    len  = rtosc_argument(msg, 0).b.len / sizeof(float);

  200.     //        float *data = (float*)rtosc_argument(msg, 0).b.data;

  201.     //    } else {

  202.     //        d.reply(d.loc, "b",

  203.     //                a.slots[slot].automations[param].map.npoints*sizeof(float),

  204.     //                a.slots[slot].automations[param].map.control_points);

  205.     //    }

  206.     //    rEnd},

  207. };

  208. 

  209. static const Ports slot_ports = {

  210.     //{"learn-binding:s", rDoc("Create binding for automation path with midi-learn"), 0,

  211.     //    rBegin;

  212.     //    (void) m;

  213.     //    //m->automate.createBinding(rtosc_argument(msg, 0).i,

  214.     //    //                          rtosc_argument(msg, 1).s,

  215.     //    //                          rtosc_argument(msg, 2).T);

  216.     //    rEnd},

  217.     //{"create-binding:s", rDoc("Create binding for automation path"), 0,

  218.     //    rBegin;

  219.     //    m->automate.createBinding(rtosc_argument(msg, 0).i,

  220.     //                              rtosc_argument(msg, 1).s,

  221.     //                              rtosc_argument(msg, 2).T);

  222.     //    rEnd},

  223.     {"value::f", rProp(no learn) rProp(parameter) rMap(default, 0.5) rLinear(0, 1) rDoc("Access current value in slot 'i' (0..1)"), 0,

  224.         rBegin;

  225.         int num = d.idx[0];

  226.         if(!strcmp("f",rtosc_argument_string(msg))) {

  227.             a.setSlot(num, rtosc_argument(msg, 0).f);

  228.             d.broadcast(d.loc, "f", a.getSlot(num));

  229.         } else

  230.             d.reply(d.loc, "f", a.getSlot(num));

  231.         rEnd},

  232. 

  233.     {"name::s", rProp(parameter) rDoc("Access name of automation slot"), 0,

  234.         rBegin;

  235.         int num = d.idx[0];

  236.         if(!strcmp("s",rtosc_argument_string(msg))) {

  237.             a.setName(num, rtosc_argument(msg, 0).s);

  238.             d.broadcast(d.loc, "s", a.getName(num));

  239.         } else

  240.             d.reply(d.loc, "s", a.getName(num));

  241.         rEnd},

  242.     {"midi-cc::i", rProp(parameter) rMap(default, -1) rDoc("Access assigned midi CC slot") , 0,

  243.         rBegin;

  244.         int slot = d.idx[0];

  245.         if(rtosc_narguments(msg))

  246.             a.slots[slot].midi_cc = rtosc_argument(msg, 0).i;

  247.         else

  248.             d.reply(d.loc, "i", a.slots[slot].midi_cc);

  249. 

  250.         rEnd},

  251.     {"active::T:F",  rProp(parameter) rMap(default, F) rDoc("If Slot is enabled"), 0,

  252.         rBegin;

  253.         int slot = d.idx[0];

  254.         if(rtosc_narguments(msg))

  255.             a.slots[slot].active = rtosc_argument(msg, 0).T;

  256.         else

  257.             d.reply(d.loc, a.slots[slot].active ? "T" : "F");

  258.         rEnd},

  259.     {"learning::i", rProp(parameter) rMap(default, -1) rDoc("If slot is trying to find a midi learn binding"), 0,

  260.         rBegin;

  261.         int slot = d.idx[0];

  262.         d.reply(d.loc, "i", a.slots[slot].learning);

  263.         rEnd},

  264.     {"clear:", rDoc("Clear automation slot"), 0,

  265.         rBegin;

  266.         int slot = d.idx[0];

  267.         a.clearSlot(slot);

  268.         rEnd},

  269.     {"param#4/", rDoc("Info on individual param mappings"), &auto_param_ports,

  270.         rBegin;

  271.         (void)a;

  272.         d.push_index(get_next_int(msg));

  273.         SNIP;

  274.         auto_param_ports.dispatch(msg, d);

  275.         d.pop_index();

  276.         rEnd},

  277. };

  278. 

  279. static const Ports automate_ports = {

  280.     {"active-slot::i", rProp(parameter) rMap(min, -1) rMap(max, 16) rDoc("Active Slot for macro learning"), 0,

  281.         rBegin;

  282.         if(!strcmp("i",rtosc_argument_string(msg))) {

  283.             a.active_slot = rtosc_argument(msg, 0).i;

  284.             d.broadcast(d.loc, "i", a.active_slot);

  285.         } else

  286.             d.reply(d.loc, "i", a.active_slot);

  287.         rEnd},

  288.     {"learn-binding-new-slot:s", rDoc("Learn a parameter assigned to a new slot"), 0,

  289.         rBegin;

  290.         int free_slot = a.free_slot();

  291.         if(free_slot >= 0) {

  292.             a.createBinding(free_slot, rtosc_argument(msg, 0).s, true);

  293.             a.active_slot = free_slot;

  294.         }

  295.         rEnd},

  296.     {"learn-binding-same-slot:s", rDoc("Learn a parameter appending to the active-slot"), 0,

  297.         rBegin;

  298.         if(a.active_slot >= 0)

  299.             a.createBinding(a.active_slot, rtosc_argument(msg, 0).s, true);

  300.         rEnd},

  301.     // TODO: remove rNoWalk

  302.     {"slot#16/", rNoWalk rDoc("Parameters of individual automation slots"), &slot_ports,

  303.         rBegin;

  304.         (void)a;

  305.         d.push_index(get_next_int(msg));

  306.         SNIP;

  307.         slot_ports.dispatch(msg, d);

  308.         d.pop_index();

  309.         rEnd},

  310.     {"clear", rDoc("Clear all automation slots"), 0,

  311.         rBegin;

  312.         for(int i=0; i<a.nslots; ++i)

  313.             a.clearSlot(i);

  314.         rEnd},

  315.     {"load-blob:b", rProp(internal) rDoc("Load blob from middleware"), 0,

  316.         rBegin;

  317.         auto &b = **(rtosc::AutomationMgr **)rtosc_argument(msg, 0).b.data;

  318.         //XXX this code should likely be in rtosc

  319.         for(int i=0; i<a.nslots; ++i) {

  320.             auto &slota = a.slots[i];

  321.             auto &slotb = b.slots[i];

  322.             std::swap(slota.learning, slotb.learning);

  323.             std::swap(slota.midi_cc,  slotb.midi_cc);

  324.             std::swap(slota.used,     slotb.used);

  325.             std::swap(slota.active,   slotb.active);

  326.             for(int j=0; j<a.per_slot; ++j) {

  327.                 auto &aa = slota.automations[j];

  328.                 auto &ab = slotb.automations[j];

  329.                 std::swap(aa.used, ab.used);

  330.                 std::swap(aa.active, ab.active);

  331.                 std::swap(aa.param_path, ab.param_path);

  332.                 std::swap(aa.param_min, ab.param_min);

  333.                 std::swap(aa.param_max, ab.param_max);

  334.                 std::swap(aa.param_step, ab.param_step);

  335.                 std::swap(aa.param_type, ab.param_type);

  336.                 std::swap(aa.map.offset, ab.map.offset);

  337.                 std::swap(aa.map.gain, ab.map.gain);

  338.                 std::swap(aa.map.upoints, ab.map.upoints);

  339.                 for(int k=0; k<aa.map.npoints; ++k)

  340.                     std::swap(aa.map.control_points[k], ab.map.control_points[k]);

  341.             }

  342.         }

  343.         rEnd},

  344. };

  345. 

  346. #undef  rBegin

  347. #undef  rEnd

  348. #define rBegin [](const char *msg, RtData &d) { Master *m = (Master*)d.obj

  349. #define rEnd }

  350. 

  351. static const Ports watchPorts = {

  352.     {"add:s", rDoc("Add synthesis state to watch"), 0,

  353.         rBegin;

  354.         m->watcher.add_watch(rtosc_argument(msg,0).s);

  355.         rEnd},

  356. };

  357. 

  358. 

  359. extern const Ports bankPorts;

  360. static const Ports master_ports = {

  361.     rString(last_xmz, XMZ_PATH_MAX, "File name for last name loaded if any."),

  362.     rRecursp(part, 16, "Part"),//NUM_MIDI_PARTS

  363.     rRecursp(sysefx, 4, "System Effect"),//NUM_SYS_EFX

  364.     rRecursp(insefx, 8, "Insertion Effect"),//NUM_INS_EFX

  365.     rRecur(microtonal, "Microtonal Mapping Functionality"),

  366.     rRecur(ctl, "Controller"),

  367.     rArrayOption(Pinsparts, NUM_INS_EFX, rOpt(-2, Master), rOpt(-1, Off),

  368.                  rOptions(Part1, Part2, Part3, Part4, Part5, Part6,

  369.                           Part7, Part8, Part9, Part10, Part11, Part12,

  370.                           Part13, Part14, Part15, Part16) rDefault(Off),

  371.                  "Part to insert part onto"),

  372.     {"Pkeyshift::i", rShort("key shift") rProp(parameter) rLinear(0,127)

  373.         rDefault(64) rDoc("Global Key Shift"), 0, [](const char *m, RtData&d) {

  374.         if(rtosc_narguments(m)==0) {

  375.             d.reply(d.loc, "i", ((Master*)d.obj)->Pkeyshift);

  376.         } else if(rtosc_narguments(m)==1 && rtosc_type(m,0)=='i') {

  377.             ((Master*)d.obj)->setPkeyshift(limit<char>(rtosc_argument(m,0).i,0,127));

  378.             d.broadcast(d.loc, "i", ((Master*)d.obj)->Pkeyshift);}}},

  379.     {"echo", rDoc("Hidden port to echo messages"), 0, [](const char *m, RtData&d) {

  380.        d.reply(m-1);}},

  381.     {"get-vu:", rDoc("Grab VU Data"), 0, [](const char *, RtData &d) {

  382.        Master *m = (Master*)d.obj;

  383.        d.reply("/vu-meter", "bb", sizeof(m->vu), &m->vu, sizeof(float)*NUM_MIDI_PARTS, m->vuoutpeakpart);}},

  384.     {"vu-meter:", rDoc("Grab VU Data"), 0, [](const char *, RtData &d) {

  385.        Master *m = (Master*)d.obj;

  386.        char        types[6+NUM_MIDI_PARTS+1] = {0};

  387.        rtosc_arg_t  args[6+NUM_MIDI_PARTS+1];

  388.        for(int i=0; i<6+NUM_MIDI_PARTS; ++i)

  389.            types[i] = 'f';

  390.        args[0].f = m->vu.outpeakl;

  391.        args[1].f = m->vu.outpeakr;

  392.        args[2].f = m->vu.maxoutpeakl;

  393.        args[3].f = m->vu.maxoutpeakr;

  394.        args[4].f = m->vu.rmspeakl;

  395.        args[5].f = m->vu.rmspeakr;

  396.        for(int i=0; i<NUM_MIDI_PARTS; ++i)

  397.            args[6+i].f = m->vuoutpeakpart[i];

  398. 

  399.        d.replyArray("/vu-meter", types, args);}},

  400.     {"reset-vu:", rDoc("Grab VU Data"), 0, [](const char *, RtData &d) {

  401.        Master *m = (Master*)d.obj;

  402.        m->vuresetpeaks();}},

  403.     {"load-part:ib", rProp(internal) rDoc("Load Part From Middleware"), 0, [](const char *msg, RtData &d) {

  404.        Master *m =  (Master*)d.obj;

  405.        Part   *p = *(Part**)rtosc_argument(msg, 1).b.data;

  406.        int     i = rtosc_argument(msg, 0).i;

  407.        m->part[i]->cloneTraits(*p);

  408.        m->part[i]->kill_rt();

  409.        d.reply("/free", "sb", "Part", sizeof(void*), &m->part[i]);

  410.        m->part[i] = p;

  411.        p->initialize_rt();

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

  413.            m->activeNotes[i] = 0;

  414.        }},

  415.     {"active_keys:", rProp("Obtain a list of active notes"), 0,

  416.         rBegin;

  417.         char keys[129] = {0};

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

  419.             keys[i] = m->activeNotes[i] ? 'T' : 'F';

  420.         d.broadcast(d.loc, keys);

  421.         rEnd},

  422.     {"Pvolume::i", rShort("volume") rProp(parameter) rLinear(0,127)

  423.         rDefault(80) rDoc("Master Volume"), 0,

  424.         [](const char *m, rtosc::RtData &d) {

  425.         if(rtosc_narguments(m)==0) {

  426.             d.reply(d.loc, "i", ((Master*)d.obj)->Pvolume);

  427.         } else if(rtosc_narguments(m)==1 && rtosc_type(m,0)=='i') {

  428.             ((Master*)d.obj)->setPvolume(limit<char>(rtosc_argument(m,0).i,0,127));

  429.             d.broadcast(d.loc, "i", ((Master*)d.obj)->Pvolume);}}},

  430.     {"volume::i", rShort("volume") rProp(parameter) rLinear(0,127)

  431.         rDefault(80) rDoc("Master Volume"), 0,

  432.         [](const char *m, rtosc::RtData &d) {

  433.         if(rtosc_narguments(m)==0) {

  434.             d.reply(d.loc, "i", ((Master*)d.obj)->Pvolume);

  435.         } else if(rtosc_narguments(m)==1 && rtosc_type(m,0)=='i') {

  436.             ((Master*)d.obj)->setPvolume(limit<char>(rtosc_argument(m,0).i,0,127));

  437.             d.broadcast(d.loc, "i", ((Master*)d.obj)->Pvolume);}}},

  438.     {"Psysefxvol#" STRINGIFY(NUM_SYS_EFX) "/::i", 0, &sysefxPort,

  439.         [](const char *msg, rtosc::RtData &d) {

  440.             SNIP;

  441.             sysefxPort.dispatch(msg, d);

  442.         }},

  443.     {"sysefxfrom#" STRINGIFY(NUM_SYS_EFX) "/", rDoc("Routing Between System Effects"), &sysefsendto,

  444.         [](const char *msg, RtData&d) {

  445.             SNIP;

  446.             sysefsendto.dispatch(msg, d);

  447.         }},

  448. 

  449.     {"noteOn:iii", rDoc("Noteon Event"), 0,

  450.         [](const char *m,RtData &d){

  451.             Master *M =  (Master*)d.obj;

  452.             M->noteOn(rtosc_argument(m,0).i,rtosc_argument(m,1).i,rtosc_argument(m,2).i);}},

  453. 

  454.     {"noteOff:ii", rDoc("Noteoff Event"), 0,

  455.         [](const char *m,RtData &d){

  456.             Master *M =  (Master*)d.obj;

  457.             M->noteOff(rtosc_argument(m,0).i,rtosc_argument(m,1).i);}},

  458.     {"virtual_midi_cc:iii", rDoc("MIDI CC Event"), 0,

  459.         [](const char *m,RtData &d){

  460.             Master *M =  (Master*)d.obj;

  461.             M->setController(rtosc_argument(m,0).i,rtosc_argument(m,1).i,rtosc_argument(m,2).i);}},

  462. 

  463.     {"setController:iii", rDoc("MIDI CC Event"), 0,

  464.         [](const char *m,RtData &d){

  465.             Master *M =  (Master*)d.obj;

  466.             M->setController(rtosc_argument(m,0).i,rtosc_argument(m,1).i,rtosc_argument(m,2).i);}},

  467.     {"Panic:", rDoc("Stop all sound"), 0,

  468.         [](const char *, RtData &d) {

  469.             Master &M =  *(Master*)d.obj;

  470.             M.ShutUp();

  471.         }},

  472.     {"freeze_state:", rProp(internal) rDoc("Disable OSC event handling\n"

  473.             "This sets up a read-only mode from which it's safe for another"

  474.             " thread to save parameters"), 0,

  475.         [](const char *,RtData &d) {

  476.             Master *M =  (Master*)d.obj;

  477.             std::atomic_thread_fence(std::memory_order_release);

  478.             M->frozenState = true;

  479.             d.reply("/state_frozen", "");}},

  480.     {"thaw_state:", rProp(internal) rDoc("Resume handling OSC messages\n"

  481.             "See /freeze_state for more information"), 0,

  482.         [](const char *,RtData &d) {

  483.             Master *M =  (Master*)d.obj;

  484.             M->frozenState = false;}},

  485.     {"automate/", rDoc("MIDI Learn/Plugin Automation support"), &automate_ports,

  486.         [](const char *msg, RtData &d) {

  487.             SNIP;

  488.             d.obj = (void*)&((Master*)d.obj)->automate;

  489.             automate_ports.dispatch(msg, d);

  490.             }},

  491.     {"close-ui:", rDoc("Request to close any connection named \"GUI\""), 0,

  492.         [](const char *, RtData &d) {

  493.        d.reply("/close-ui", "");}},

  494.     {"add-rt-memory:bi", rProp(internal) rDoc("Add Additional Memory To RT MemPool"), 0,

  495.         [](const char *msg, RtData &d)

  496.         {

  497.             Master &m = *(Master*)d.obj;

  498.             char   *mem = *(char**)rtosc_argument(msg, 0).b.data;

  499.             int     i = rtosc_argument(msg, 1).i;

  500.             m.memory->addMemory(mem, i);

  501.             m.pendingMemory = false;

  502.         }},

  503.     {"samplerate:", rMap(unit, Hz) rDoc("Get synthesizer sample rate"), 0, [](const char *, RtData &d) {

  504.             Master &m = *(Master*)d.obj;

  505.             d.reply("/samplerate", "f", m.synth.samplerate_f);

  506.         }},

  507.     {"oscilsize:", rDoc("Get synthesizer oscillator size"), 0, [](const char *, RtData &d) {

  508.             Master &m = *(Master*)d.obj;

  509.             d.reply("/oscilsize", "f", m.synth.oscilsize_f);

  510.             d.reply("/oscilsize", "i", m.synth.oscilsize);

  511.         }},

  512.     {"undo_pause:",rProp(internal) rDoc("pause undo event recording"),0,

  513.         [](const char *, rtosc::RtData &d) {d.reply("/undo_pause", "");}},

  514.     {"undo_resume:",rProp(internal) rDoc("resume undo event recording"),0,

  515.         [](const char *, rtosc::RtData &d) {d.reply("/undo_resume", "");}},

  516.     {"config/", rNoWalk rDoc("Top Level Application Configuration Parameters"),

  517.         &Config::ports, [](const char *, rtosc::RtData &d){d.forward();}},

  518.     {"presets/", rDoc("Parameter Presets"), &preset_ports, rBOIL_BEGIN

  519.         SNIP

  520.             preset_ports.dispatch(msg, data);

  521.         rBOIL_END},

  522.     {"HDDRecorder/preparefile:s", rDoc("Init WAV file"), 0, [](const char *msg, RtData &d) {

  523.        Master *m = (Master*)d.obj;

  524.        m->HDDRecorder.preparefile(rtosc_argument(msg, 0).s, 1);}},

  525.     {"HDDRecorder/start:", rDoc("Start recording"), 0, [](const char *, RtData &d) {

  526.        Master *m = (Master*)d.obj;

  527.        m->HDDRecorder.start();}},

  528.     {"HDDRecorder/stop:", rDoc("Stop recording"), 0, [](const char *, RtData &d) {

  529.        Master *m = (Master*)d.obj;

  530.        m->HDDRecorder.stop();}},

  531.     {"HDDRecorder/pause:", rDoc("Pause recording"), 0, [](const char *, RtData &d) {

  532.        Master *m = (Master*)d.obj;

  533.        m->HDDRecorder.pause();}},

  534.     {"watch/", rDoc("Interface to grab out live synthesis state"), &watchPorts,

  535.         rBOIL_BEGIN;

  536.         SNIP;

  537.         watchPorts.dispatch(msg, data);

  538.         rBOIL_END},

  539.     {"bank/", rDoc("Controls for instrument banks"), &bankPorts,

  540.             [](const char*,RtData&) {}},

  541.     {"learn:s", rProp(depricated) rDoc("MIDI Learn"), 0,

  542.         rBegin;

  543.         int free_slot = m->automate.free_slot();

  544.         if(free_slot >= 0) {

  545.             m->automate.createBinding(free_slot, rtosc_argument(msg, 0).s, true);

  546.             m->automate.active_slot = free_slot;

  547.         }

  548.         rEnd},

  549. };

  550. 

  551. #undef rBegin

  552. #undef rEnd

  553. 

  554. const Ports &Master::ports = master_ports;

  555. 

  556. class DataObj:public rtosc::RtData

  557. {

  558.     public:

  559.         DataObj(char *loc_, size_t loc_size_, void *obj_, rtosc::ThreadLink *bToU_)

  560.         {

  561.             memset(loc_, 0, loc_size_);

  562.             loc      = loc_;

  563.             loc_size = loc_size_;

  564.             obj      = obj_;

  565.             bToU     = bToU_;

  566.             forwarded = false;

  567.         }

  568. 

  569.         virtual void replyArray(const char *path, const char *args, rtosc_arg_t *vals) override

  570.         {

  571.             char *buffer = bToU->buffer();

  572.             rtosc_amessage(buffer,bToU->buffer_size(),path,args,vals);

  573.             reply(buffer);

  574.         }

  575.         virtual void reply(const char *path, const char *args, ...) override

  576.         {

  577.             va_list va;

  578.             va_start(va,args);

  579.             char *buffer = bToU->buffer();

  580.             rtosc_vmessage(buffer,bToU->buffer_size(),path,args,va);

  581.             reply(buffer);

  582.             va_end(va);

  583.         }

  584.         virtual void reply(const char *msg) override

  585.         {

  586.             if(rtosc_message_length(msg, -1) == 0)

  587.                 fprintf(stderr, "Warning: Invalid Rtosc message '%s'\n", msg);

  588.             bToU->raw_write(msg);

  589.         }

  590.         virtual void broadcast(const char *path, const char *args, ...) override{

  591.             va_list va;

  592.             va_start(va,args);

  593.             reply("/broadcast", "");

  594.             char *buffer = bToU->buffer();

  595.             rtosc_vmessage(buffer,bToU->buffer_size(),path,args,va);

  596.             reply(buffer);

  597.             va_end(va);

  598.         }

  599.         virtual void broadcast(const char *msg) override

  600.         {

  601.             reply("/broadcast", "");

  602.             reply(msg);

  603.         }

  604. 

  605.         virtual void forward(const char *reason) override

  606.         {

  607.             assert(message);

  608.             reply("/forward", "");

  609.             printf("forwarding '%s'\n", message);

  610.             forwarded = true;

  611.         }

  612.         bool forwarded;

  613.     private:

  614.         rtosc::ThreadLink *bToU;

  615. };

  616. 

  617. vuData::vuData(void)

  618.     :outpeakl(0.0f), outpeakr(0.0f), maxoutpeakl(0.0f), maxoutpeakr(0.0f),

  619.       rmspeakl(0.0f), rmspeakr(0.0f), clipped(0)

  620. {}

  621. 

  622. void Master::saveAutomation(XMLwrapper &xml, const rtosc::AutomationMgr &midi)

  623. {

  624.     xml.beginbranch("automation");

  625.     {

  626.         XmlNode metadata("mgr-info");

  627.         metadata["nslots"]       = to_s(midi.nslots);

  628.         metadata["nautomations"] = to_s(midi.per_slot);

  629.         metadata["ncontrol"]     = to_s(midi.slots[0].automations[0].map.npoints);

  630.         xml.add(metadata);

  631. 

  632.         for(int i=0; i<midi.nslots; ++i) {

  633.             const auto &slot = midi.slots[i];

  634.             if(!slot.used)

  635.                 continue;

  636.             xml.beginbranch("slot", i);

  637.             XmlNode params("params");

  638.             params["midi-cc"] = to_s(slot.midi_cc);

  639.             xml.add(params);

  640.             for(int j=0; j<midi.per_slot; ++j) {

  641.                 const auto &au = slot.automations[j];

  642.                 if(!au.used)

  643.                     continue;

  644.                 xml.beginbranch("automation", j);

  645.                 XmlNode automation("params");

  646.                 automation["path"] = au.param_path;

  647.                 XmlNode mapping("mapping");

  648.                 mapping["gain"]   = to_s(au.map.gain);

  649.                 mapping["offset"] = to_s(au.map.offset);

  650.                 xml.add(automation);

  651.                 xml.add(mapping);

  652.                 xml.endbranch();

  653.             }

  654. 

  655.             xml.endbranch();

  656.         }

  657.     }

  658.     xml.endbranch();

  659. }

  660. 

  661. void Master::loadAutomation(XMLwrapper &xml, rtosc::AutomationMgr &midi)

  662. {

  663.     if(xml.enterbranch("automation")) {

  664.         for(int i=0; i<midi.nslots; ++i) {

  665.             auto &slot = midi.slots[i];

  666.             if(xml.enterbranch("slot", i)) {

  667.                 for(int j=0; j<midi.per_slot; ++j) {

  668.                     if(xml.enterbranch("automation", j)) {

  669.                         float gain       = 1.0;

  670.                         float offset     = 0.0;

  671.                         std::string path = "";

  672.                         for(auto node:xml.getBranch()) {

  673.                             if(node.name == "params")

  674.                                 path = node["path"];

  675.                             else if(node.name == "mapping") {

  676.                                 gain   = atof(node["gain"].c_str());

  677.                                 offset = atof(node["offset"].c_str());

  678.                             }

  679.                         }

  680.                         printf("createBinding(%d, %s, false)\n", i, path.c_str());

  681.                         midi.createBinding(i, path.c_str(), false);

  682.                         midi.setSlotSubGain(i, j, gain);

  683.                         midi.setSlotSubOffset(i, j, offset);

  684.                         xml.exitbranch();

  685.                     }

  686.                 }

  687.                 for(auto node:xml.getBranch())

  688.                     if(node.name == "params")

  689.                         slot.midi_cc = atoi(node["midi-cc"].c_str());

  690.                 xml.exitbranch();

  691.             }

  692.         }

  693.         xml.exitbranch();

  694.     }

  695. }

  696. 

  697. Master::Master(const SYNTH_T &synth_, Config* config)

  698.     :HDDRecorder(synth_), time(synth_), ctl(synth_, &time),

  699.     microtonal(config->cfg.GzipCompression), bank(config),

  700.     automate(16,4,8),

  701.     frozenState(false), pendingMemory(false),

  702.     synth(synth_), gzip_compression(config->cfg.GzipCompression)

  703. {

  704.     bToU = NULL;

  705.     uToB = NULL;

  706. 

  707.     //Setup MIDI Learn

  708.     automate.set_ports(master_ports);

  709.     automate.set_instance(this);

  710.     //midi.frontend = [this](const char *msg) {bToU->raw_write(msg);};

  711.     automate.backend  = [this](const char *msg) {applyOscEvent(msg);};

  712. 

  713.     memory = new AllocatorClass();

  714.     swaplr = 0;

  715.     off  = 0;

  716.     smps = 0;

  717.     bufl = new float[synth.buffersize];

  718.     bufr = new float[synth.buffersize];

  719. 

  720.     last_xmz[0] = 0;

  721.     fft = new FFTwrapper(synth.oscilsize);

  722. 

  723.     shutup = 0;

  724.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  725.         vuoutpeakpart[npart] = 1e-9;

  726.         fakepeakpart[npart]  = 0;

  727.     }

  728. 

  729.     ScratchString ss;

  730.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  731.         part[npart] = new Part(*memory, synth, time, config->cfg.GzipCompression,

  732.                                config->cfg.Interpolation, &microtonal, fft, &watcher,

  733.                                (ss+"/part"+npart+"/").c_str);

  734. 

  735.     //Insertion Effects init

  736.     for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx)

  737.         insefx[nefx] = new EffectMgr(*memory, synth, 1, &time);

  738. 

  739.     //System Effects init

  740.     for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx)

  741.         sysefx[nefx] = new EffectMgr(*memory, synth, 0, &time);

  742. 

  743.     //Note Visualization

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

  745.         activeNotes[i] = 0;

  746. 

  747.     defaults();

  748. 

  749.     mastercb = 0;

  750.     mastercb_ptr = 0;

  751. }

  752. 

  753. void Master::applyOscEvent(const char *msg)

  754. {

  755.     char loc_buf[1024];

  756.     DataObj d{loc_buf, 1024, this, bToU};

  757.     memset(loc_buf, 0, sizeof(loc_buf));

  758.     d.matches = 0;

  759. 

  760.     if(strcmp(msg, "/get-vu") && false) {

  761.         fprintf(stdout, "%c[%d;%d;%dm", 0x1B, 0, 5 + 30, 0 + 40);

  762.         fprintf(stdout, "backend[*]: '%s'<%s>\n", msg,

  763.                 rtosc_argument_string(msg));

  764.         fprintf(stdout, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  765.     }

  766. 

  767.     ports.dispatch(msg, d, true);

  768.     if(d.matches == 0 && !d.forwarded)

  769.         fprintf(stderr, "Unknown path '%s:%s'\n", msg, rtosc_argument_string(msg));

  770.     if(d.forwarded)

  771.         bToU->raw_write(msg);

  772. }

  773. 

  774. void Master::defaults()

  775. {

  776.     volume = 1.0f;

  777.     setPvolume(80);

  778.     setPkeyshift(64);

  779. 

  780.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  781.         part[npart]->defaults();

  782.         part[npart]->partno  = npart % NUM_MIDI_CHANNELS;

  783.         part[npart]->Prcvchn = npart % NUM_MIDI_CHANNELS;

  784.     }

  785. 

  786.     partonoff(0, 1); //enable the first part

  787. 

  788.     for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx) {

  789.         insefx[nefx]->defaults();

  790.         Pinsparts[nefx] = -1;

  791.     }

  792. 

  793.     //System Effects init

  794.     for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx) {

  795.         sysefx[nefx]->defaults();

  796.         for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  797.             setPsysefxvol(npart, nefx, 0);

  798. 

  799.         for(int nefxto = 0; nefxto < NUM_SYS_EFX; ++nefxto)

  800.             setPsysefxsend(nefx, nefxto, 0);

  801.     }

  802. 

  803.     microtonal.defaults();

  804.     ShutUp();

  805. }

  806. 

  807. /*

  808.  * Note On Messages (velocity=0 for NoteOff)

  809.  */

  810. void Master::noteOn(char chan, char note, char velocity)

  811. {

  812.     if(velocity) {

  813.         for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  814.             if(chan == part[npart]->Prcvchn) {

  815.                 fakepeakpart[npart] = velocity * 2;

  816.                 if(part[npart]->Penabled)

  817.                     part[npart]->NoteOn(note, velocity, keyshift);

  818.             }

  819.         }

  820.         activeNotes[(int)note] = 1;

  821.     }

  822.     else

  823.         this->noteOff(chan, note);

  824.     HDDRecorder.triggernow();

  825. }

  826. 

  827. /*

  828.  * Note Off Messages

  829.  */

  830. void Master::noteOff(char chan, char note)

  831. {

  832.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  833.         if((chan == part[npart]->Prcvchn) && part[npart]->Penabled)

  834.             part[npart]->NoteOff(note);

  835.     activeNotes[(int)note] = 0;

  836. }

  837. 

  838. /*

  839.  * Pressure Messages (velocity=0 for NoteOff)

  840.  */

  841. void Master::polyphonicAftertouch(char chan, char note, char velocity)

  842. {

  843.     if(velocity) {

  844.         for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  845.             if(chan == part[npart]->Prcvchn)

  846.                 if(part[npart]->Penabled)

  847.                     part[npart]->PolyphonicAftertouch(note, velocity, keyshift);

  848. 

  849.     }

  850.     else

  851.         this->noteOff(chan, note);

  852. }

  853. 

  854. /*

  855.  * Controllers

  856.  */

  857. void Master::setController(char chan, int type, int par)

  858. {

  859.     if(frozenState)

  860.         return;

  861.     automate.handleMidi(chan, type, par);

  862.     if((type == C_dataentryhi) || (type == C_dataentrylo)

  863.        || (type == C_nrpnhi) || (type == C_nrpnlo)) { //Process RPN and NRPN by the Master (ignore the chan)

  864.         ctl.setparameternumber(type, par);

  865. 

  866.         int parhi = -1, parlo = -1, valhi = -1, vallo = -1;

  867.         if(ctl.getnrpn(&parhi, &parlo, &valhi, &vallo) == 0) { //this is NRPN

  868.             switch(parhi) {

  869.                 case 0x04: //System Effects

  870.                     if(parlo < NUM_SYS_EFX)

  871.                         sysefx[parlo]->seteffectparrt(valhi, vallo);

  872.                     break;

  873.                 case 0x08: //Insertion Effects

  874.                     if(parlo < NUM_INS_EFX)

  875.                         insefx[parlo]->seteffectparrt(valhi, vallo);

  876.                     break;

  877.             }

  878.         }

  879.     } else {  //other controllers

  880.         for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) //Send the controller to all part assigned to the channel

  881.             if((chan == part[npart]->Prcvchn) && (part[npart]->Penabled != 0))

  882.                 part[npart]->SetController(type, par);

  883. 

  884.         if(type == C_allsoundsoff) { //cleanup insertion/system FX

  885.             for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx)

  886.                 sysefx[nefx]->cleanup();

  887.             for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx)

  888.                 insefx[nefx]->cleanup();

  889.         }

  890.     }

  891. }

  892. 

  893. void Master::vuUpdate(const float *outl, const float *outr)

  894. {

  895.     //Peak computation (for vumeters)

  896.     vu.outpeakl = 1e-12;

  897.     vu.outpeakr = 1e-12;

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

  899.         if(fabs(outl[i]) > vu.outpeakl)

  900.             vu.outpeakl = fabs(outl[i]);

  901.         if(fabs(outr[i]) > vu.outpeakr)

  902.             vu.outpeakr = fabs(outr[i]);

  903.     }

  904.     if((vu.outpeakl > 1.0f) || (vu.outpeakr > 1.0f))

  905.         vu.clipped = 1;

  906.     if(vu.maxoutpeakl < vu.outpeakl)

  907.         vu.maxoutpeakl = vu.outpeakl;

  908.     if(vu.maxoutpeakr < vu.outpeakr)

  909.         vu.maxoutpeakr = vu.outpeakr;

  910. 

  911.     //RMS Peak computation (for vumeters)

  912.     vu.rmspeakl = 1e-12;

  913.     vu.rmspeakr = 1e-12;

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

  915.         vu.rmspeakl += outl[i] * outl[i];

  916.         vu.rmspeakr += outr[i] * outr[i];

  917.     }

  918.     vu.rmspeakl = sqrt(vu.rmspeakl / synth.buffersize_f);

  919.     vu.rmspeakr = sqrt(vu.rmspeakr / synth.buffersize_f);

  920. 

  921.     //Part Peak computation (for Part vumeters or fake part vumeters)

  922.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  923.         vuoutpeakpart[npart] = 1.0e-12f;

  924.         if(part[npart]->Penabled != 0) {

  925.             float *outl = part[npart]->partoutl,

  926.             *outr = part[npart]->partoutr;

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

  928.                 float tmp = fabs(outl[i] + outr[i]);

  929.                 if(tmp > vuoutpeakpart[npart])

  930.                     vuoutpeakpart[npart] = tmp;

  931.             }

  932.             vuoutpeakpart[npart] *= volume;

  933.         }

  934.         else

  935.         if(fakepeakpart[npart] > 1)

  936.             fakepeakpart[npart]--;

  937.     }

  938. }

  939. 

  940. /*

  941.  * Enable/Disable a part

  942.  */

  943. void Master::partonoff(int npart, int what)

  944. {

  945.     if(npart >= NUM_MIDI_PARTS)

  946.         return;

  947.     if(what == 0) { //disable part

  948.         fakepeakpart[npart]   = 0;

  949.         part[npart]->Penabled = 0;

  950.         part[npart]->cleanup();

  951.         for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx) {

  952.             if(Pinsparts[nefx] == npart)

  953.                 insefx[nefx]->cleanup();

  954.         }

  955.     }

  956.     else {  //enabled

  957.         part[npart]->Penabled = 1;

  958.         fakepeakpart[npart]   = 0;

  959.     }

  960. }

  961. 

  962. void Master::setMasterChangedCallback(void(*cb)(void*,Master*), void *ptr)

  963. {

  964.     mastercb     = cb;

  965.     mastercb_ptr = ptr;

  966. }

  967. 

  968. #if 0

  969. template <class T>

  970. struct def_skip

  971. {

  972. 	static void skip(const char*& argptr) { argptr += sizeof(T); }

  973. };

  974. 

  975. template <class T>

  976. struct str_skip

  977. {

  978. 	static void skip(const char*& argptr) { while(argptr++); /*TODO: 4 padding */ }

  979. };

  980. 

  981. template<class T, class Display = T, template<class TMP> class SkipsizeFunc = def_skip>

  982. void _dump_prim_arg(const char*& argptr, std::ostream& os)

  983. {

  984. 	os << ' ' << (Display)*(const T*)argptr;

  985. 	SkipsizeFunc<T>::skip(argptr);

  986. }

  987. 

  988. void dump_msg(const char* ptr, std::ostream& os = std::cerr)

  989. {

  990. 	assert(*ptr == '/');

  991. 	os << ptr;

  992. 

  993. 	while(*++ptr) ; // skip address

  994. 	while(!*++ptr) ; // skip 0s

  995. 

  996. 	assert(*ptr == ',');

  997. 	os << ' ' << (ptr + 1);

  998. 

  999. 	const char* argptr = ptr;

  1000. 	while(*++argptr) ; // skip type string

  1001. 	while(!*++argptr) ; // skip 0s

  1002. 

  1003. 	char c;

  1004. 	while((c = *++ptr))

  1005. 	{

  1006. 		switch(c)

  1007. 		{

  1008. 			case 'i':

  1009. 				_dump_prim_arg<int32_t>(argptr, os); break;

  1010. 			case 'c':

  1011. 				_dump_prim_arg<int32_t, char>(argptr, os); break;

  1012. 		//	case 's':

  1013. 		//		_dump_prim_arg<char, const char*>(argptr, os); break;

  1014. 			default:

  1015. 				exit(1);

  1016. 		}

  1017. 	}

  1018. 

  1019. }

  1020. #endif

  1021. int msg_id=0;

  1022. 

  1023. bool Master::runOSC(float *outl, float *outr, bool offline)

  1024. {

  1025.     //Handle user events TODO move me to a proper location

  1026.     char loc_buf[1024];

  1027.     DataObj d{loc_buf, 1024, this, bToU};

  1028.     memset(loc_buf, 0, sizeof(loc_buf));

  1029.     int events = 0;

  1030.     while(uToB && uToB->hasNext() && events < 100) {

  1031.         const char *msg = uToB->read();

  1032. 

  1033.         if(!strcmp(msg, "/load-master")) {

  1034.             Master *this_master = this;

  1035.             Master *new_master  = *(Master**)rtosc_argument(msg, 0).b.data;

  1036.             if(!offline)

  1037.                 new_master->AudioOut(outl, outr);

  1038.             Nio::masterSwap(new_master);

  1039.             if (mastercb)

  1040.                 mastercb(mastercb_ptr, new_master);

  1041.             bToU->write("/free", "sb", "Master", sizeof(Master*), &this_master);

  1042.             return false;

  1043.         }

  1044. 

  1045.         //XXX yes, this is not realtime safe, but it is useful...

  1046.         if(strcmp(msg, "/get-vu") && false) {

  1047.             fprintf(stdout, "%c[%d;%d;%dm", 0x1B, 0, 5 + 30, 0 + 40);

  1048.             fprintf(stdout, "backend[%d]: '%s'<%s>\n", msg_id++, msg,

  1049.                     rtosc_argument_string(msg));

  1050.             fprintf(stdout, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  1051.         }

  1052.         ports.dispatch(msg, d, true);

  1053.         events++;

  1054.         if(!d.matches) {

  1055.             //workaround for requesting voice status

  1056.             int a=0, b=0, c=0;

  1057.             char e=0;

  1058.             if(4 == sscanf(msg, "/part%d/kit%d/adpars/VoicePar%d/Enable%c", &a, &b, &c, &e)) {

  1059.                 d.reply(msg, "F");

  1060.                 d.matches++;

  1061.             }

  1062.         }

  1063.         if(!d.matches) {// && !ports.apropos(msg)) {

  1064.             fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 1, 7 + 30, 0 + 40);

  1065.             fprintf(stderr, "Unknown address<BACKEND:%s> '%s:%s'\n",

  1066.                     offline ? "offline" : "online",

  1067.                     uToB->peak(),

  1068.                     rtosc_argument_string(uToB->peak()));

  1069.             fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  1070.         }

  1071.     }

  1072. 

  1073.     if(automate.damaged) {

  1074.         d.broadcast("/damage", "s", "/automate/");

  1075.         automate.damaged = 0;

  1076.     }

  1077. 

  1078.     if(events>1 && false)

  1079.         fprintf(stderr, "backend: %d events per cycle\n",events);

  1080. 

  1081.     return true;

  1082. }

  1083. 

  1084. /*

  1085.  * Master audio out (the final sound)

  1086.  */

  1087. bool Master::AudioOut(float *outr, float *outl)

  1088. {

  1089.     //Danger Limits

  1090.     if(memory->lowMemory(2,1024*1024))

  1091.         printf("QUITE LOW MEMORY IN THE RT POOL BE PREPARED FOR WEIRD BEHAVIOR!!\n");

  1092.     //Normal Limits

  1093.     if(!pendingMemory && memory->lowMemory(4,1024*1024)) {

  1094.         printf("Requesting more memory\n");

  1095.         bToU->write("/request-memory", "");

  1096.         pendingMemory = true;

  1097.     }

  1098. 

  1099.     //work through events

  1100.     if(!runOSC(outl, outr, false))

  1101.         return false;

  1102. 

  1103. 

  1104.     //Handle watch points

  1105.     if(bToU)

  1106.         watcher.write_back = bToU;

  1107.     watcher.tick();

  1108. 

  1109. 

  1110.     //Swaps the Left channel with Right Channel

  1111.     if(swaplr)

  1112.         swap(outl, outr);

  1113. 

  1114.     //clean up the output samples (should not be needed?)

  1115.     memset(outl, 0, synth.bufferbytes);

  1116.     memset(outr, 0, synth.bufferbytes);

  1117. 

  1118.     //Compute part samples and store them part[npart]->partoutl,partoutr

  1119.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  1120.         if(part[npart]->Penabled)

  1121.             part[npart]->ComputePartSmps();

  1122. 

  1123.     //Insertion effects

  1124.     for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx)

  1125.         if(Pinsparts[nefx] >= 0) {

  1126.             int efxpart = Pinsparts[nefx];

  1127.             if(part[efxpart]->Penabled)

  1128.                 insefx[nefx]->out(part[efxpart]->partoutl,

  1129.                                   part[efxpart]->partoutr);

  1130.         }

  1131. 

  1132. 

  1133.     //Apply the part volumes and pannings (after insertion effects)

  1134.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  1135.         if(!part[npart]->Penabled)

  1136.             continue;

  1137. 

  1138.         Stereo<float> newvol(part[npart]->volume),

  1139.         oldvol(part[npart]->oldvolumel,

  1140.                part[npart]->oldvolumer);

  1141. 

  1142.         float pan = part[npart]->panning;

  1143.         if(pan < 0.5f)

  1144.             newvol.l *= pan * 2.0f;

  1145.         else

  1146.             newvol.r *= (1.0f - pan) * 2.0f;

  1147.         //if(npart==0)

  1148.         //printf("[%d]vol = %f->%f\n", npart, oldvol.l, newvol.l);

  1149. 

  1150.         //the volume or the panning has changed and needs interpolation

  1151.         if(ABOVE_AMPLITUDE_THRESHOLD(oldvol.l, newvol.l)

  1152.            || ABOVE_AMPLITUDE_THRESHOLD(oldvol.r, newvol.r)) {

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

  1154.                 Stereo<float> vol(INTERPOLATE_AMPLITUDE(oldvol.l, newvol.l,

  1155.                                                         i, synth.buffersize),

  1156.                                   INTERPOLATE_AMPLITUDE(oldvol.r, newvol.r,

  1157.                                                         i, synth.buffersize));

  1158.                 part[npart]->partoutl[i] *= vol.l;

  1159.                 part[npart]->partoutr[i] *= vol.r;

  1160.             }

  1161.             part[npart]->oldvolumel = newvol.l;

  1162.             part[npart]->oldvolumer = newvol.r;

  1163.         }

  1164.         else {

  1165.             for(int i = 0; i < synth.buffersize; ++i) { //the volume did not changed

  1166.                 part[npart]->partoutl[i] *= newvol.l;

  1167.                 part[npart]->partoutr[i] *= newvol.r;

  1168.             }

  1169.         }

  1170.     }

  1171. 

  1172. 

  1173.     //System effects

  1174.     for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx) {

  1175.         if(sysefx[nefx]->geteffect() == 0)

  1176.             continue;  //the effect is disabled

  1177. 

  1178.         float tmpmixl[synth.buffersize];

  1179.         float tmpmixr[synth.buffersize];

  1180.         //Clean up the samples used by the system effects

  1181.         memset(tmpmixl, 0, synth.bufferbytes);

  1182.         memset(tmpmixr, 0, synth.bufferbytes);

  1183. 

  1184.         //Mix the channels according to the part settings about System Effect

  1185.         for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  1186.             //skip if the part has no output to effect

  1187.             if(Psysefxvol[nefx][npart] == 0)

  1188.                 continue;

  1189. 

  1190.             //skip if the part is disabled

  1191.             if(part[npart]->Penabled == 0)

  1192.                 continue;

  1193. 

  1194.             //the output volume of each part to system effect

  1195.             const float vol = sysefxvol[nefx][npart];

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

  1197.                 tmpmixl[i] += part[npart]->partoutl[i] * vol;

  1198.                 tmpmixr[i] += part[npart]->partoutr[i] * vol;

  1199.             }

  1200.         }

  1201. 

  1202.         // system effect send to next ones

  1203.         for(int nefxfrom = 0; nefxfrom < nefx; ++nefxfrom)

  1204.             if(Psysefxsend[nefxfrom][nefx] != 0) {

  1205.                 const float vol = sysefxsend[nefxfrom][nefx];

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

  1207.                     tmpmixl[i] += sysefx[nefxfrom]->efxoutl[i] * vol;

  1208.                     tmpmixr[i] += sysefx[nefxfrom]->efxoutr[i] * vol;

  1209.                 }

  1210.             }

  1211. 

  1212.         sysefx[nefx]->out(tmpmixl, tmpmixr);

  1213. 

  1214.         //Add the System Effect to sound output

  1215.         const float outvol = sysefx[nefx]->sysefxgetvolume();

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

  1217.             outl[i] += tmpmixl[i] * outvol;

  1218.             outr[i] += tmpmixr[i] * outvol;

  1219.         }

  1220.     }

  1221. 

  1222.     //Mix all parts

  1223.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  1224.         if(part[npart]->Penabled)   //only mix active parts

  1225.             for(int i = 0; i < synth.buffersize; ++i) { //the volume did not changed

  1226.                 outl[i] += part[npart]->partoutl[i];

  1227.                 outr[i] += part[npart]->partoutr[i];

  1228.             }

  1229. 

  1230.     //Insertion effects for Master Out

  1231.     for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx)

  1232.         if(Pinsparts[nefx] == -2)

  1233.             insefx[nefx]->out(outl, outr);

  1234. 

  1235. 

  1236.     //Master Volume

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

  1238.         outl[i] *= volume;

  1239.         outr[i] *= volume;

  1240.     }

  1241. 

  1242.     vuUpdate(outl, outr);

  1243. 

  1244.     //Shutup if it is asked (with fade-out)

  1245.     if(shutup) {

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

  1247.             float tmp = (synth.buffersize_f - i) / synth.buffersize_f;

  1248.             outl[i] *= tmp;

  1249.             outr[i] *= tmp;

  1250.         }

  1251.         ShutUp();

  1252.     }

  1253. 

  1254.     //update the global frame timer

  1255.     time++;

  1256. 

  1257. #ifdef DEMO_VERSION

  1258.     double seconds = time.time()*synth.buffersize_f/synth.samplerate_f;

  1259.     if(seconds > 10*60) {//10 minute trial

  1260.         shutup = true;

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

  1262.             float tmp = (synth.buffersize_f - i) / synth.buffersize_f;

  1263.             outl[i] *= 0.0f;

  1264.             outr[i] *= 0.0f;

  1265.         }

  1266.     }

  1267. #endif

  1268. 

  1269.     //Update pulse

  1270.     last_ack = last_beat;

  1271. 

  1272. 

  1273.     return true;

  1274. }

  1275. 

  1276. //TODO review the respective code from yoshimi for this

  1277. //If memory serves correctly, libsamplerate was used

  1278. void Master::GetAudioOutSamples(size_t nsamples,

  1279.                                 unsigned samplerate,

  1280.                                 float *outl,

  1281.                                 float *outr)

  1282. {

  1283.     off_t out_off = 0;

  1284. 

  1285.     //Fail when resampling rather than doing a poor job

  1286.     if(synth.samplerate != samplerate) {

  1287.         printf("darn it: %d vs %d\n", synth.samplerate, samplerate);

  1288.         return;

  1289.     }

  1290. 

  1291.     while(nsamples) {

  1292.         //use all available samples

  1293.         if(nsamples >= smps) {

  1294.             memcpy(outl + out_off, bufl + off, sizeof(float) * smps);

  1295.             memcpy(outr + out_off, bufr + off, sizeof(float) * smps);

  1296.             nsamples -= smps;

  1297. 

  1298.             //generate samples

  1299.             if (! AudioOut(bufl, bufr))

  1300.                 return;

  1301. 

  1302.             off  = 0;

  1303.             out_off  += smps;

  1304.             smps = synth.buffersize;

  1305.         }

  1306.         else {   //use some samples

  1307.             memcpy(outl + out_off, bufl + off, sizeof(float) * nsamples);

  1308.             memcpy(outr + out_off, bufr + off, sizeof(float) * nsamples);

  1309.             smps    -= nsamples;

  1310.             off     += nsamples;

  1311.             nsamples = 0;

  1312.         }

  1313.     }

  1314. }

  1315. 

  1316. Master::~Master()

  1317. {

  1318.     delete []bufl;

  1319.     delete []bufr;

  1320. 

  1321.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  1322.         delete part[npart];

  1323.     for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx)

  1324.         delete insefx[nefx];

  1325.     for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx)

  1326.         delete sysefx[nefx];

  1327. 

  1328.     delete fft;

  1329.     delete memory;

  1330. }

  1331. 

  1332. 

  1333. /*

  1334.  * Parameter control

  1335.  */

  1336. void Master::setPvolume(char Pvolume_)

  1337. {

  1338.     Pvolume = Pvolume_;

  1339.     volume  = dB2rap((Pvolume - 96.0f) / 96.0f * 40.0f);

  1340. }

  1341. 

  1342. void Master::setPkeyshift(char Pkeyshift_)

  1343. {

  1344.     Pkeyshift = Pkeyshift_;

  1345.     keyshift  = (int)Pkeyshift - 64;

  1346. }

  1347. 

  1348. 

  1349. void Master::setPsysefxvol(int Ppart, int Pefx, char Pvol)

  1350. {

  1351.     Psysefxvol[Pefx][Ppart] = Pvol;

  1352.     sysefxvol[Pefx][Ppart]  = powf(0.1f, (1.0f - Pvol / 96.0f) * 2.0f);

  1353. }

  1354. 

  1355. void Master::setPsysefxsend(int Pefxfrom, int Pefxto, char Pvol)

  1356. {

  1357.     Psysefxsend[Pefxfrom][Pefxto] = Pvol;

  1358.     sysefxsend[Pefxfrom][Pefxto]  = powf(0.1f, (1.0f - Pvol / 96.0f) * 2.0f);

  1359. }

  1360. 

  1361. 

  1362. /*

  1363.  * Panic! (Clean up all parts and effects)

  1364.  */

  1365. void Master::ShutUp()

  1366. {

  1367.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  1368.         part[npart]->cleanup();

  1369.         fakepeakpart[npart] = 0;

  1370.     }

  1371.     for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx)

  1372.         insefx[nefx]->cleanup();

  1373.     for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx)

  1374.         sysefx[nefx]->cleanup();

  1375.     for(int i = 0; i < int(sizeof(activeNotes)/sizeof(activeNotes[0])); ++i)

  1376.         activeNotes[i] = 0;

  1377.     vuresetpeaks();

  1378.     shutup = 0;

  1379. }

  1380. 

  1381. 

  1382. /*

  1383.  * Reset peaks and clear the "cliped" flag (for VU-meter)

  1384.  */

  1385. void Master::vuresetpeaks()

  1386. {

  1387.     vu.outpeakl    = 1e-9;

  1388.     vu.outpeakr    = 1e-9;

  1389.     vu.maxoutpeakl = 1e-9;

  1390.     vu.maxoutpeakr = 1e-9;

  1391.     vu.clipped     = 0;

  1392. }

  1393. 

  1394. void Master::applyparameters(void)

  1395. {

  1396.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart)

  1397.         part[npart]->applyparameters();

  1398. }

  1399. 

  1400. void Master::initialize_rt(void)

  1401. {

  1402.     for(int i=0; i<NUM_SYS_EFX; ++i)

  1403.         sysefx[i]->init();

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

  1405.         insefx[i]->init();

  1406. 

  1407.     for(int i=0; i<NUM_MIDI_PARTS; ++i)

  1408.         part[i]->initialize_rt();

  1409. }

  1410. 

  1411. void Master::add2XML(XMLwrapper& xml)

  1412. {

  1413.     xml.addpar("volume", Pvolume);

  1414.     xml.addpar("key_shift", Pkeyshift);

  1415.     xml.addparbool("nrpn_receive", ctl.NRPN.receive);

  1416. 

  1417.     xml.beginbranch("MICROTONAL");

  1418.     microtonal.add2XML(xml);

  1419.     xml.endbranch();

  1420. 

  1421.     saveAutomation(xml, automate);

  1422. 

  1423.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  1424.         xml.beginbranch("PART", npart);

  1425.         part[npart]->add2XML(xml);

  1426.         xml.endbranch();

  1427.     }

  1428. 

  1429.     xml.beginbranch("SYSTEM_EFFECTS");

  1430.     for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx) {

  1431.         xml.beginbranch("SYSTEM_EFFECT", nefx);

  1432.         xml.beginbranch("EFFECT");

  1433.         sysefx[nefx]->add2XML(xml);

  1434.         xml.endbranch();

  1435. 

  1436.         for(int pefx = 0; pefx < NUM_MIDI_PARTS; ++pefx) {

  1437.             xml.beginbranch("VOLUME", pefx);

  1438.             xml.addpar("vol", Psysefxvol[nefx][pefx]);

  1439.             xml.endbranch();

  1440.         }

  1441. 

  1442.         for(int tonefx = nefx + 1; tonefx < NUM_SYS_EFX; ++tonefx) {

  1443.             xml.beginbranch("SENDTO", tonefx);

  1444.             xml.addpar("send_vol", Psysefxsend[nefx][tonefx]);

  1445.             xml.endbranch();

  1446.         }

  1447. 

  1448. 

  1449.         xml.endbranch();

  1450.     }

  1451.     xml.endbranch();

  1452. 

  1453.     xml.beginbranch("INSERTION_EFFECTS");

  1454.     for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx) {

  1455.         xml.beginbranch("INSERTION_EFFECT", nefx);

  1456.         xml.addpar("part", Pinsparts[nefx]);

  1457. 

  1458.         xml.beginbranch("EFFECT");

  1459.         insefx[nefx]->add2XML(xml);

  1460.         xml.endbranch();

  1461.         xml.endbranch();

  1462.     }

  1463. 

  1464.     xml.endbranch();

  1465. }

  1466. 

  1467. 

  1468. int Master::getalldata(char **data)

  1469. {

  1470.     XMLwrapper xml;

  1471. 

  1472.     xml.beginbranch("MASTER");

  1473. 

  1474.     add2XML(xml);

  1475. 

  1476.     xml.endbranch();

  1477. 

  1478.     *data = xml.getXMLdata();

  1479.     return strlen(*data) + 1;

  1480. }

  1481. 

  1482. void Master::putalldata(const char *data)

  1483. {

  1484.     XMLwrapper xml;

  1485.     if(!xml.putXMLdata(data)) {

  1486.         return;

  1487.     }

  1488. 

  1489.     if(xml.enterbranch("MASTER") == 0)

  1490.         return;

  1491. 

  1492.     getfromXML(xml);

  1493. 

  1494.     xml.exitbranch();

  1495. }

  1496. 

  1497. int Master::saveXML(const char *filename)

  1498. {

  1499.     XMLwrapper xml;

  1500. 

  1501.     xml.beginbranch("MASTER");

  1502.     add2XML(xml);

  1503.     xml.endbranch();

  1504. 

  1505.     return xml.saveXMLfile(filename, gzip_compression);

  1506. }

  1507. 

  1508. 

  1509. int Master::loadXML(const char *filename)

  1510. {

  1511.     XMLwrapper xml;

  1512. 

  1513.     if(xml.loadXMLfile(filename) < 0) {

  1514.         return -1;

  1515.     }

  1516. 

  1517.     if(xml.enterbranch("MASTER") == 0)

  1518.         return -10;

  1519. 

  1520.     getfromXML(xml);

  1521.     xml.exitbranch();

  1522. 

  1523.     initialize_rt();

  1524.     return 0;

  1525. }

  1526. 

  1527. void Master::getfromXML(XMLwrapper& xml)

  1528. {

  1529.     setPvolume(xml.getpar127("volume", Pvolume));

  1530.     setPkeyshift(xml.getpar127("key_shift", Pkeyshift));

  1531.     ctl.NRPN.receive = xml.getparbool("nrpn_receive", ctl.NRPN.receive);

  1532. 

  1533. 

  1534.     part[0]->Penabled = 0;

  1535.     for(int npart = 0; npart < NUM_MIDI_PARTS; ++npart) {

  1536.         if(xml.enterbranch("PART", npart) == 0)

  1537.             continue;

  1538.         part[npart]->getfromXML(xml);

  1539.         xml.exitbranch();

  1540.     }

  1541. 

  1542.     if(xml.enterbranch("MICROTONAL")) {

  1543.         microtonal.getfromXML(xml);

  1544.         xml.exitbranch();

  1545.     }

  1546. 

  1547.     loadAutomation(xml, automate);

  1548. 

  1549.     sysefx[0]->changeeffect(0);

  1550.     if(xml.enterbranch("SYSTEM_EFFECTS")) {

  1551.         for(int nefx = 0; nefx < NUM_SYS_EFX; ++nefx) {

  1552.             if(xml.enterbranch("SYSTEM_EFFECT", nefx) == 0)

  1553.                 continue;

  1554.             if(xml.enterbranch("EFFECT")) {

  1555.                 sysefx[nefx]->getfromXML(xml);

  1556.                 xml.exitbranch();

  1557.             }

  1558. 

  1559.             for(int partefx = 0; partefx < NUM_MIDI_PARTS; ++partefx) {

  1560.                 if(xml.enterbranch("VOLUME", partefx) == 0)

  1561.                     continue;

  1562.                 setPsysefxvol(partefx, nefx,

  1563.                               xml.getpar127("vol", Psysefxvol[partefx][nefx]));

  1564.                 xml.exitbranch();

  1565.             }

  1566. 

  1567.             for(int tonefx = nefx + 1; tonefx < NUM_SYS_EFX; ++tonefx) {

  1568.                 if(xml.enterbranch("SENDTO", tonefx) == 0)

  1569.                     continue;

  1570.                 setPsysefxsend(nefx, tonefx,

  1571.                                xml.getpar127("send_vol",

  1572.                                               Psysefxsend[nefx][tonefx]));

  1573.                 xml.exitbranch();

  1574.             }

  1575.             xml.exitbranch();

  1576.         }

  1577.         xml.exitbranch();

  1578.     }

  1579. 

  1580. 

  1581.     if(xml.enterbranch("INSERTION_EFFECTS")) {

  1582.         for(int nefx = 0; nefx < NUM_INS_EFX; ++nefx) {

  1583.             if(xml.enterbranch("INSERTION_EFFECT", nefx) == 0)

  1584.                 continue;

  1585.             Pinsparts[nefx] = xml.getpar("part",

  1586.                                           Pinsparts[nefx],

  1587.                                           -2,

  1588.                                           NUM_MIDI_PARTS);

  1589.             if(xml.enterbranch("EFFECT")) {

  1590.                 insefx[nefx]->getfromXML(xml);

  1591.                 xml.exitbranch();

  1592.             }

  1593.             xml.exitbranch();

  1594.         }

  1595. 

  1596.         xml.exitbranch();

  1597.     }

  1598. }

  1599. 

  1600. static rtosc_version version_in_rtosc_fmt()

  1601. {

  1602.     return rtosc_version

  1603.     {

  1604.         (unsigned char) version.get_major(),

  1605.         (unsigned char) version.get_minor(),

  1606.         (unsigned char) version.get_revision()

  1607.     };

  1608. }

  1609. 

  1610. char* Master::getXMLData()

  1611. {

  1612.     XMLwrapper xml;

  1613. 

  1614.     xml.beginbranch("MASTER");

  1615.     add2XML(xml);

  1616.     xml.endbranch();

  1617. 

  1618.     return xml.getXMLdata();

  1619. }

  1620. 

  1621. int Master::saveOSC(const char *filename)

  1622. {

  1623.     std::string savefile = rtosc::save_to_file(ports, this,

  1624.                                                "ZynAddSubFX",

  1625.                                                version_in_rtosc_fmt());

  1626. 

  1627.     zyncarla::Config config;

  1628.     zyncarla::SYNTH_T* synth = new zyncarla::SYNTH_T;

  1629.     synth->buffersize = 256;

  1630.     synth->samplerate = 48000;

  1631.     synth->alias();

  1632. 

  1633.     zyncarla::Master master2(*synth, &config);

  1634.     int rval = master2.loadOSCFromStr(savefile.c_str());

  1635. 

  1636. 

  1637.     if(rval < 0)

  1638.     {

  1639.         std::cerr << "invalid savefile!" << std::endl;

  1640.         std::cerr << "complete savefile:" << std::endl;

  1641.         std::cerr << savefile << std::endl;

  1642.         std::cerr << "first entry that could not be parsed:" << std::endl;

  1643. 

  1644.         for(int i = -rval + 1; savefile[i]; ++i)

  1645.         if(savefile[i] == '\n')

  1646.         {

  1647.             savefile.resize(i);

  1648.             break;

  1649.         }

  1650.         std::cerr << (savefile.c_str() - rval) << std::endl;

  1651. 

  1652.         rval = -1;

  1653.     }

  1654.     else

  1655.     {

  1656.         char* xml = getXMLData(),

  1657.             * xml2 = master2.getXMLData();

  1658. 

  1659.         rval = strcmp(xml, xml2) ? -1 : 0;

  1660. 

  1661.         if(rval == 0)

  1662.         {

  1663.             if(filename)

  1664.             {

  1665.                 std::ofstream ofs(filename);

  1666.                 ofs << savefile;

  1667.             }

  1668.             else if(!filename)

  1669.                 std::cout << savefile << std::endl;

  1670.         }

  1671.         else

  1672.         {

  1673.             std::cout << savefile << std::endl;

  1674.             std::cerr << "Can not write OSC savefile!! (see tmp1.txt and tmp2.txt)"

  1675.                       << std::endl;

  1676.             std::ofstream tmp1("tmp1.txt"), tmp2("tmp2.txt");

  1677.             tmp1 << xml;

  1678.             tmp2 << xml2;

  1679.         }

  1680. 

  1681.         free(xml);

  1682.         free(xml2);

  1683.     }

  1684.     return rval;

  1685. }

  1686. 

  1687. int Master::loadOSCFromStr(const char *filename)

  1688. {

  1689.     return rtosc::load_from_file(filename,

  1690.                                  ports, this,

  1691.                                  "ZynAddSubFX", version_in_rtosc_fmt());

  1692. }

  1693. 

  1694. string loadfile(string fname)

  1695. {

  1696.     std::ifstream t(fname.c_str());

  1697.     std::string str((std::istreambuf_iterator<char>(t)),

  1698.                      std::istreambuf_iterator<char>());

  1699.     return str;

  1700. }

  1701. 

  1702. int Master::loadOSC(const char *filename)

  1703. {

  1704.     int rval = loadOSCFromStr(loadfile(filename).c_str());

  1705.     return rval < 0 ? rval : 0;

  1706. }

  1707. 

  1708. 

  1709. }