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.
962 Commits
17 Branches
463MB
Tree: cd5896e555
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cd5896e555'
${ noResults }
Carla/source/utils/CarlaStateUtils.hpp

585 lines
21KB
Raw Blame History 

  1. /*

  2.  * Carla State utils

  3.  * Copyright (C) 2012-2013 Filipe Coelho <falktx@falktx.com>

  4.  *

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

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

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

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

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #ifndef CARLA_STATE_UTILS_HPP_INCLUDED

  19. #define CARLA_STATE_UTILS_HPP_INCLUDED

  20. 

  21. #include "CarlaBackendUtils.hpp"

  22. #include "CarlaMIDI.h"

  23. #include "RtList.hpp"

  24. 

  25. #include "juce_core.h"

  26. 

  27. CARLA_BACKEND_START_NAMESPACE

  28. 

  29. // -----------------------------------------------------------------------

  30. 

  31. struct StateParameter {

  32.     uint32_t    index;

  33.     const char* name;

  34.     const char* symbol;

  35.     float       value;

  36.     uint8_t     midiChannel;

  37.     int16_t     midiCC;

  38. 

  39.     StateParameter() noexcept

  40.         : index(0),

  41.           name(nullptr),

  42.           symbol(nullptr),

  43.           value(0.0f),

  44.           midiChannel(0),

  45.           midiCC(-1) {}

  46. 

  47.     ~StateParameter()

  48.     {

  49.         if (name != nullptr)

  50.         {

  51.             delete[] name;

  52.             name = nullptr;

  53.         }

  54.         if (symbol != nullptr)

  55.         {

  56.             delete[] symbol;

  57.             symbol = nullptr;

  58.         }

  59.     }

  60. 

  61.     CARLA_DECLARE_NON_COPY_STRUCT(StateParameter)

  62. };

  63. 

  64. struct StateCustomData {

  65.     const char* type;

  66.     const char* key;

  67.     const char* value;

  68. 

  69.     StateCustomData() noexcept

  70.         : type(nullptr),

  71.           key(nullptr),

  72.           value(nullptr) {}

  73. 

  74.     ~StateCustomData()

  75.     {

  76.         if (type != nullptr)

  77.         {

  78.             delete[] type;

  79.             type = nullptr;

  80.         }

  81.         if (key != nullptr)

  82.         {

  83.             delete[] key;

  84.             key = nullptr;

  85.         }

  86.         if (value != nullptr)

  87.         {

  88.             delete[] value;

  89.             value = nullptr;

  90.         }

  91.     }

  92. 

  93.     CARLA_DECLARE_NON_COPY_STRUCT(StateCustomData)

  94. };

  95. 

  96. typedef NonRtList<StateParameter*> StateParameterList;

  97. typedef NonRtList<StateCustomData*> StateCustomDataList;

  98. 

  99. typedef NonRtList<StateParameter*>::Itenerator StateParameterItenerator;

  100. typedef NonRtList<StateCustomData*>::Itenerator StateCustomDataItenerator;

  101. 

  102. struct SaveState {

  103.     const char* type;

  104.     const char* name;

  105.     const char* label;

  106.     const char* binary;

  107.     long        uniqueID;

  108. 

  109.     bool  active;

  110.     float dryWet;

  111.     float volume;

  112.     float balanceLeft;

  113.     float balanceRight;

  114.     float panning;

  115.     int8_t ctrlChannel;

  116. 

  117.     int32_t     currentProgramIndex;

  118.     const char* currentProgramName;

  119.     int32_t     currentMidiBank;

  120.     int32_t     currentMidiProgram;

  121.     const char* chunk;

  122. 

  123.     StateParameterList parameters;

  124.     StateCustomDataList customData;

  125. 

  126.     SaveState() noexcept

  127.         : type(nullptr),

  128.           name(nullptr),

  129.           label(nullptr),

  130.           binary(nullptr),

  131.           uniqueID(0),

  132.           active(false),

  133.           dryWet(1.0f),

  134.           volume(1.0f),

  135.           balanceLeft(-1.0f),

  136.           balanceRight(1.0f),

  137.           panning(0.0f),

  138.           ctrlChannel(-1),

  139.           currentProgramIndex(-1),

  140.           currentProgramName(nullptr),

  141.           currentMidiBank(-1),

  142.           currentMidiProgram(-1),

  143.           chunk(nullptr) {}

  144. 

  145.     ~SaveState()

  146.     {

  147.         reset();

  148.     }

  149. 

  150.     void reset()

  151.     {

  152.         if (type != nullptr)

  153.         {

  154.             delete[] type;

  155.             type = nullptr;

  156.         }

  157.         if (name != nullptr)

  158.         {

  159.             delete[] name;

  160.             name = nullptr;

  161.         }

  162.         if (label != nullptr)

  163.         {

  164.             delete[] label;

  165.             label = nullptr;

  166.         }

  167.         if (binary != nullptr)

  168.         {

  169.             delete[] binary;

  170.             binary = nullptr;

  171.         }

  172.         if (currentProgramName != nullptr)

  173.         {

  174.             delete[] currentProgramName;

  175.             currentProgramName = nullptr;

  176.         }

  177.         if (chunk != nullptr)

  178.         {

  179.             delete[] chunk;

  180.             chunk = nullptr;

  181.         }

  182. 

  183.         uniqueID = 0;

  184.         active = false;

  185.         dryWet = 1.0f;

  186.         volume = 1.0f;

  187.         balanceLeft  = -1.0f;

  188.         balanceRight = 1.0f;

  189.         panning      = 0.0f;

  190.         ctrlChannel  = -1;

  191.         currentProgramIndex = -1;

  192.         currentMidiBank     = -1;

  193.         currentMidiProgram  = -1;

  194. 

  195.         for (StateParameterItenerator it = parameters.begin(); it.valid(); it.next())

  196.         {

  197.             StateParameter* const stateParameter(*it);

  198.             delete stateParameter;

  199.         }

  200. 

  201.         for (StateCustomDataItenerator it = customData.begin(); it.valid(); it.next())

  202.         {

  203.             StateCustomData* const stateCustomData(*it);

  204.             delete stateCustomData;

  205.         }

  206. 

  207.         parameters.clear();

  208.         customData.clear();

  209.     }

  210. 

  211.     CARLA_DECLARE_NON_COPY_STRUCT(SaveState)

  212. };

  213. 

  214. // -----------------------------------------------------------------------

  215. 

  216. static inline

  217. juce::String xmlSafeString(const juce::String& string, const bool toXml)

  218. {

  219.     juce::String newString(string);

  220. 

  221.     if (toXml)

  222.         return newString.replace("&","&amp;").replace("<","&lt;").replace(">","&gt;").replace("'","&apos;").replace("\"","&quot;");

  223.     else

  224.         return newString.replace("&amp;","&").replace("&lt;","<").replace("&gt;",">").replace("&apos;","'").replace("&quot;","\"");

  225. }

  226. 

  227. static inline

  228. const char* xmlSafeStringCharDup(const juce::String& string, const bool toXml)

  229. {

  230.     return carla_strdup(xmlSafeString(string, toXml).toRawUTF8());

  231. }

  232. 

  233. // -----------------------------------------------------------------------

  234. 

  235. static inline

  236. void fillSaveStateFromXmlElement(SaveState& saveState, const juce::XmlElement* const xmlElement)

  237. {

  238.     using namespace juce;

  239. 

  240.     for (XmlElement* elem = xmlElement->getFirstChildElement(); elem != nullptr; elem = elem->getNextElement())

  241.     {

  242.         // ---------------------------------------------------------------

  243.         // Info

  244. 

  245.         if (elem->getTagName().equalsIgnoreCase("info"))

  246.         {

  247.             for (XmlElement* xmlInfo = elem->getFirstChildElement(); xmlInfo != nullptr; xmlInfo = xmlInfo->getNextElement())

  248.             {

  249.                 const String& tag(xmlInfo->getTagName());

  250.                 const String  text(xmlInfo->getAllSubText().trim());

  251. 

  252.                 if (tag.equalsIgnoreCase("type"))

  253.                     saveState.type = xmlSafeStringCharDup(text, false);

  254.                 else if (tag.equalsIgnoreCase("name"))

  255.                     saveState.name = xmlSafeStringCharDup(text, false);

  256.                 else if (tag.equalsIgnoreCase("label") || tag.equalsIgnoreCase("uri"))

  257.                     saveState.label = xmlSafeStringCharDup(text, false);

  258.                 else if (tag.equalsIgnoreCase("binary") || tag.equalsIgnoreCase("filename"))

  259.                     saveState.binary = xmlSafeStringCharDup(text, false);

  260.                 else if (tag.equalsIgnoreCase("uniqueid"))

  261.                     saveState.uniqueID = text.getLargeIntValue();

  262.             }

  263.         }

  264. 

  265.         // ---------------------------------------------------------------

  266.         // Data

  267. 

  268.         else if (elem->getTagName().equalsIgnoreCase("data"))

  269.         {

  270.             for (XmlElement* xmlData = elem->getFirstChildElement(); xmlData != nullptr; xmlData = xmlData->getNextElement())

  271.             {

  272.                 const String& tag(xmlData->getTagName());

  273.                 const String  text(xmlData->getAllSubText().trim());

  274. 

  275.                 // -------------------------------------------------------

  276.                 // Internal Data

  277. 

  278.                 if (tag.equalsIgnoreCase("active"))

  279.                 {

  280.                     saveState.active = (text.equalsIgnoreCase("yes"));

  281.                 }

  282.                 else if (tag.equalsIgnoreCase("drywet"))

  283.                 {

  284.                     saveState.dryWet = carla_fixValue(0.0f, 1.0f, text.getFloatValue());

  285.                 }

  286.                 else if (tag.equalsIgnoreCase("volume"))

  287.                 {

  288.                     saveState.volume = carla_fixValue(0.0f, 1.27f, text.getFloatValue());

  289.                 }

  290.                 else if (tag.equalsIgnoreCase("balanceleft") || tag.equalsIgnoreCase("balance-left"))

  291.                 {

  292.                     saveState.balanceLeft = carla_fixValue(-1.0f, 1.0f, text.getFloatValue());

  293.                 }

  294.                 else if (tag.equalsIgnoreCase("balanceright") || tag.equalsIgnoreCase("balance-right"))

  295.                 {

  296.                     saveState.balanceRight = carla_fixValue(-1.0f, 1.0f, text.getFloatValue());

  297.                 }

  298.                 else if (tag.equalsIgnoreCase("panning"))

  299.                 {

  300.                     saveState.panning = carla_fixValue(-1.0f, 1.0f, text.getFloatValue());

  301.                 }

  302.                 else if (tag.equalsIgnoreCase("controlchannel") || tag.equalsIgnoreCase("control-channel"))

  303.                 {

  304.                     const int value(text.getIntValue());

  305.                     if (value >= 1 && value <= MAX_MIDI_CHANNELS)

  306.                         saveState.ctrlChannel = static_cast<int8_t>(value-1);

  307.                 }

  308. 

  309.                 // -------------------------------------------------------

  310.                 // Program (current)

  311. 

  312.                 else if (tag.equalsIgnoreCase("currentprogramindex") || tag.equalsIgnoreCase("current-program-index"))

  313.                 {

  314.                     const int value(text.getIntValue());

  315.                     if (value >= 1)

  316.                         saveState.currentProgramIndex = value-1;

  317.                 }

  318.                 else if (tag.equalsIgnoreCase("currentprogramname") || tag.equalsIgnoreCase("current-program-name"))

  319.                 {

  320.                     saveState.currentProgramName = xmlSafeStringCharDup(text, false);

  321.                 }

  322. 

  323.                 // -------------------------------------------------------

  324.                 // Midi Program (current)

  325. 

  326.                 else if (tag.equalsIgnoreCase("currentmidibank") || tag.equalsIgnoreCase("current-midi-bank"))

  327.                 {

  328.                     const int value(text.getIntValue());

  329.                     if (value >= 1)

  330.                         saveState.currentMidiBank = value-1;

  331.                 }

  332.                 else if (tag.equalsIgnoreCase("currentmidiprogram") || tag.equalsIgnoreCase("current-midi-program"))

  333.                 {

  334.                     const int value(text.getIntValue());

  335.                     if (value >= 1)

  336.                         saveState.currentMidiProgram = value-1;

  337.                 }

  338. 

  339.                 // -------------------------------------------------------

  340.                 // Parameters

  341. 

  342.                 else if (tag.equalsIgnoreCase("parameter"))

  343.                 {

  344.                     StateParameter* const stateParameter(new StateParameter());

  345. 

  346.                     for (XmlElement* xmlSubData = xmlData->getFirstChildElement(); xmlSubData != nullptr; xmlSubData = xmlSubData->getNextElement())

  347.                     {

  348.                         const String& pTag(xmlSubData->getTagName());

  349.                         const String  pText(xmlSubData->getAllSubText().trim());

  350. 

  351.                         if (pTag.equalsIgnoreCase("index"))

  352.                         {

  353.                             const int index(pText.getIntValue());

  354.                             if (index >= 0)

  355.                                 stateParameter->index = static_cast<uint32_t>(index);

  356.                         }

  357.                         else if (pTag.equalsIgnoreCase("name"))

  358.                         {

  359.                             stateParameter->name = xmlSafeStringCharDup(pText, false);

  360.                         }

  361.                         else if (pTag.equalsIgnoreCase("symbol"))

  362.                         {

  363.                             stateParameter->symbol = xmlSafeStringCharDup(pText, false);

  364.                         }

  365.                         else if (pTag.equalsIgnoreCase("value"))

  366.                         {

  367.                             stateParameter->value = pText.getFloatValue();

  368.                         }

  369.                         else if (pTag.equalsIgnoreCase("midichannel") || pTag.equalsIgnoreCase("midi-channel"))

  370.                         {

  371.                             const int channel(pText.getIntValue());

  372.                             if (channel >= 1 && channel <= MAX_MIDI_CHANNELS)

  373.                                 stateParameter->midiChannel = static_cast<uint8_t>(channel-1);

  374.                         }

  375.                         else if (pTag.equalsIgnoreCase("midicc") || pTag.equalsIgnoreCase("midi-cc"))

  376.                         {

  377.                             const int cc(pText.getIntValue());

  378.                             if (cc >= 1 && cc < 0x5F)

  379.                                 stateParameter->midiCC = static_cast<int16_t>(cc);

  380.                         }

  381.                     }

  382. 

  383.                     saveState.parameters.append(stateParameter);

  384.                 }

  385. 

  386.                 // -------------------------------------------------------

  387.                 // Custom Data

  388. 

  389.                 else if (tag.equalsIgnoreCase("customdata") || tag.equalsIgnoreCase("custom-data"))

  390.                 {

  391.                     StateCustomData* const stateCustomData(new StateCustomData());

  392. 

  393.                     for (XmlElement* xmlSubData = xmlData->getFirstChildElement(); xmlSubData != nullptr; xmlSubData = xmlSubData->getNextElement())

  394.                     {

  395.                         const String& cTag(xmlSubData->getTagName());

  396.                         const String  cText(xmlSubData->getAllSubText().trim());

  397. 

  398.                         if (cTag.equalsIgnoreCase("type"))

  399.                             stateCustomData->type = xmlSafeStringCharDup(cText, false);

  400.                         else if (cTag.equalsIgnoreCase("key"))

  401.                             stateCustomData->key = xmlSafeStringCharDup(cText, false);

  402.                         else if (cTag.equalsIgnoreCase("value"))

  403.                             stateCustomData->value = xmlSafeStringCharDup(cText, false);

  404.                     }

  405. 

  406.                     saveState.customData.append(stateCustomData);

  407.                 }

  408. 

  409.                 // -------------------------------------------------------

  410.                 // Chunk

  411. 

  412.                 else if (tag.equalsIgnoreCase("chunk"))

  413.                 {

  414.                     saveState.chunk = xmlSafeStringCharDup(text, false);

  415.                 }

  416.             }

  417.         }

  418.     }

  419. }

  420. 

  421. // -----------------------------------------------------------------------

  422. 

  423. static inline

  424. void fillXmlStringFromSaveState(juce::String& content, const SaveState& saveState)

  425. {

  426.     using namespace juce;

  427. 

  428.     {

  429.         String info("  <Info>\n");

  430. 

  431.         info << "   <Type>" << saveState.type                      << "</Type>\n";

  432.         info << "   <Name>" << xmlSafeString(saveState.name, true) << "</Name>\n";

  433. 

  434.         switch (getPluginTypeFromString(saveState.type))

  435.         {

  436.         case PLUGIN_NONE:

  437.             break;

  438.         case PLUGIN_INTERNAL:

  439.             info << "   <Label>"    << xmlSafeString(saveState.label, true)  << "</Label>\n";

  440.             break;

  441.         case PLUGIN_LADSPA:

  442.             info << "   <Binary>"   << xmlSafeString(saveState.binary, true) << "</Binary>\n";

  443.             info << "   <Label>"    << xmlSafeString(saveState.label, true)  << "</Label>\n";

  444.             info << "   <UniqueID>" << saveState.uniqueID                    << "</UniqueID>\n";

  445.             break;

  446.         case PLUGIN_DSSI:

  447.             info << "   <Binary>"   << xmlSafeString(saveState.binary, true) << "</Binary>\n";

  448.             info << "   <Label>"    << xmlSafeString(saveState.label, true)  << "</Label>\n";

  449.             break;

  450.         case PLUGIN_LV2:

  451.             info << "   <URI>"      << xmlSafeString(saveState.label, true)  << "</URI>\n";

  452.             break;

  453.         case PLUGIN_VST:

  454.             info << "   <Binary>"   << xmlSafeString(saveState.binary, true) << "</Binary>\n";

  455.             info << "   <UniqueID>" << saveState.uniqueID                    << "</UniqueID>\n";

  456.             break;

  457.         case PLUGIN_AU:

  458.             // TODO?

  459.             info << "   <Binary>"   << xmlSafeString(saveState.binary, true) << "</Binary>\n";

  460.             info << "   <UniqueID>" << saveState.uniqueID                    << "</UniqueID>\n";

  461.             break;

  462.         case PLUGIN_CSOUND:

  463.         case PLUGIN_GIG:

  464.         case PLUGIN_SF2:

  465.         case PLUGIN_SFZ:

  466.             info << "   <Filename>" << xmlSafeString(saveState.binary, true) << "</Filename>\n";

  467.             info << "   <Label>"    << xmlSafeString(saveState.label, true)  << "</Label>\n";

  468.             break;

  469.         }

  470. 

  471.         info << "  </Info>\n\n";

  472. 

  473.         content << info;

  474.     }

  475. 

  476.     {

  477.         String data("  <Data>\n");

  478. 

  479.         data << "   <Active>" << (saveState.active ? "Yes" : "No") << "</Active>\n";

  480. 

  481.         if (saveState.dryWet != 1.0f)

  482.             data << "   <DryWet>"        << saveState.dryWet       << "</DryWet>\n";

  483.         if (saveState.volume != 1.0f)

  484.             data << "   <Volume>"        << saveState.volume       << "</Volume>\n";

  485.         if (saveState.balanceLeft != -1.0f)

  486.             data << "   <Balance-Left>"  << saveState.balanceLeft  << "</Balance-Left>\n";

  487.         if (saveState.balanceRight != 1.0f)

  488.             data << "   <Balance-Right>" << saveState.balanceRight << "</Balance-Right>\n";

  489.         if (saveState.panning != 0.0f)

  490.             data << "   <Panning>"       << saveState.panning      << "</Panning>\n";

  491. 

  492.         if (saveState.ctrlChannel < 0)

  493.             data << "   <ControlChannel>N</ControlChannel>\n";

  494.         else

  495.             data << "   <ControlChannel>" << saveState.ctrlChannel+1 << "</ControlChannel>\n";

  496. 

  497.         content << data;

  498.     }

  499. 

  500.     for (StateParameterItenerator it = saveState.parameters.begin(); it.valid(); it.next())

  501.     {

  502.         StateParameter* const stateParameter(*it);

  503. 

  504.         String parameter("\n""   <Parameter>\n");

  505. 

  506.         parameter << "    <Index>" << (long)stateParameter->index               << "</Index>\n"; // FIXME

  507.         parameter << "    <Name>"  << xmlSafeString(stateParameter->name, true) << "</Name>\n";

  508. 

  509.         if (stateParameter->symbol != nullptr && stateParameter->symbol[0] != '\0')

  510.             parameter << "    <Symbol>" << xmlSafeString(stateParameter->symbol, true) << "</Symbol>\n";

  511. 

  512.         parameter << "    <Value>" << stateParameter->value << "</Value>\n";

  513. 

  514.         if (stateParameter->midiCC > 0)

  515.         {

  516.             parameter << "    <MidiCC>"      << stateParameter->midiCC        << "</MidiCC>\n";

  517.             parameter << "    <MidiChannel>" << stateParameter->midiChannel+1 << "</MidiChannel>\n";

  518.         }

  519. 

  520.         parameter << "   </Parameter>\n";

  521. 

  522.         content << parameter;

  523.     }

  524. 

  525.     if (saveState.currentProgramIndex >= 0 && saveState.currentProgramName != nullptr)

  526.     {

  527.         // ignore 'default' program

  528. #ifdef __USE_GNU

  529.         if ((saveState.currentProgramIndex > 0 || strcasecmp(saveState.currentProgramName, "default") != 0))

  530. #else

  531.         if ((saveState.currentProgramIndex > 0 || std::strcmp(saveState.currentProgramName, "Default") != 0))

  532. #endif

  533.         {

  534.             String program("\n");

  535.             program << "   <CurrentProgramIndex>" << saveState.currentProgramIndex+1                   << "</CurrentProgramIndex>\n";

  536.             program << "   <CurrentProgramName>"  << xmlSafeString(saveState.currentProgramName, true) << "</CurrentProgramName>\n";

  537. 

  538.             content << program;

  539.         }

  540.     }

  541. 

  542.     if (saveState.currentMidiBank >= 0 && saveState.currentMidiProgram >= 0)

  543.     {

  544.         String midiProgram("\n");

  545.         midiProgram << "   <CurrentMidiBank>"    << saveState.currentMidiBank+1    << "</CurrentMidiBank>\n";

  546.         midiProgram << "   <CurrentMidiProgram>" << saveState.currentMidiProgram+1 << "</CurrentMidiProgram>\n";

  547. 

  548.         content << midiProgram;

  549.     }

  550. 

  551.     for (StateCustomDataItenerator it = saveState.customData.begin(); it.valid(); it.next())

  552.     {

  553.         StateCustomData* const stateCustomData(*it);

  554. 

  555.         String customData("\n""   <CustomData>\n");

  556.         customData << "    <Type>" << xmlSafeString(stateCustomData->type, true) << "</Type>\n";

  557.         customData << "    <Key>"  << xmlSafeString(stateCustomData->key, true)  << "</Key>\n";

  558. 

  559.         if (std::strcmp(stateCustomData->type, CUSTOM_DATA_CHUNK) == 0 || std::strlen(stateCustomData->value) >= 128)

  560.             customData << "    <Value>\n" << xmlSafeString(stateCustomData->value, true) << "\n    </Value>\n";

  561.         else

  562.             customData << "    <Value>"   << xmlSafeString(stateCustomData->value, true) << "</Value>\n";

  563. 

  564.         customData << "   </CustomData>\n";

  565. 

  566.         content << customData;

  567.     }

  568. 

  569.     if (saveState.chunk != nullptr && saveState.chunk[0] != '\0')

  570.     {

  571.         String chunk("\n""   <Chunk>\n");

  572.         chunk << saveState.chunk << "\n   </Chunk>\n";

  573. 

  574.         content << chunk;

  575.     }

  576. 

  577.     content << "  </Data>\n";

  578. }

  579. 

  580. // -----------------------------------------------------------------------

  581. 

  582. CARLA_BACKEND_END_NAMESPACE

  583. 

  584. #endif // CARLA_STATE_UTILS_HPP_INCLUDED