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.
907 Commits
16 Branches
294MB
Tree: 30fd6d7140
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '30fd6d7140'
${ noResults }
Carla/source/utils/CarlaStateUtils.hpp

584 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. using juce::String;

  28. using juce::XmlElement;

  29. 

  30. CARLA_BACKEND_START_NAMESPACE

  31. 

  32. // -----------------------------------------------------------------------

  33. 

  34. struct StateParameter {

  35.     uint32_t    index;

  36.     const char* name;

  37.     const char* symbol;

  38.     float       value;

  39.     uint8_t     midiChannel;

  40.     int16_t     midiCC;

  41. 

  42.     StateParameter() noexcept

  43.         : index(0),

  44.           name(nullptr),

  45.           symbol(nullptr),

  46.           value(0.0f),

  47.           midiChannel(0),

  48.           midiCC(-1) {}

  49. 

  50.     ~StateParameter()

  51.     {

  52.         if (name != nullptr)

  53.         {

  54.             delete[] name;

  55.             name = nullptr;

  56.         }

  57.         if (symbol != nullptr)

  58.         {

  59.             delete[] symbol;

  60.             symbol = nullptr;

  61.         }

  62.     }

  63. 

  64.     CARLA_DECLARE_NON_COPY_STRUCT(StateParameter)

  65. };

  66. 

  67. struct StateCustomData {

  68.     const char* type;

  69.     const char* key;

  70.     const char* value;

  71. 

  72.     StateCustomData() noexcept

  73.         : type(nullptr),

  74.           key(nullptr),

  75.           value(nullptr) {}

  76. 

  77.     ~StateCustomData()

  78.     {

  79.         if (type != nullptr)

  80.         {

  81.             delete[] type;

  82.             type = nullptr;

  83.         }

  84.         if (key != nullptr)

  85.         {

  86.             delete[] key;

  87.             key = nullptr;

  88.         }

  89.         if (value != nullptr)

  90.         {

  91.             delete[] value;

  92.             value = nullptr;

  93.         }

  94.     }

  95. 

  96.     CARLA_DECLARE_NON_COPY_STRUCT(StateCustomData)

  97. };

  98. 

  99. typedef NonRtList<StateParameter*> StateParameterList;

  100. typedef NonRtList<StateCustomData*> StateCustomDataList;

  101. 

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

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

  104. 

  105. struct SaveState {

  106.     const char* type;

  107.     const char* name;

  108.     const char* label;

  109.     const char* binary;

  110.     long        uniqueID;

  111. 

  112.     bool  active;

  113.     float dryWet;

  114.     float volume;

  115.     float balanceLeft;

  116.     float balanceRight;

  117.     float panning;

  118.     int8_t ctrlChannel;

  119. 

  120.     int32_t     currentProgramIndex;

  121.     const char* currentProgramName;

  122.     int32_t     currentMidiBank;

  123.     int32_t     currentMidiProgram;

  124.     const char* chunk;

  125. 

  126.     StateParameterList parameters;

  127.     StateCustomDataList customData;

  128. 

  129.     SaveState() noexcept

  130.         : type(nullptr),

  131.           name(nullptr),

  132.           label(nullptr),

  133.           binary(nullptr),

  134.           uniqueID(0),

  135.           active(false),

  136.           dryWet(1.0f),

  137.           volume(1.0f),

  138.           balanceLeft(-1.0f),

  139.           balanceRight(1.0f),

  140.           panning(0.0f),

  141.           ctrlChannel(-1),

  142.           currentProgramIndex(-1),

  143.           currentProgramName(nullptr),

  144.           currentMidiBank(-1),

  145.           currentMidiProgram(-1),

  146.           chunk(nullptr) {}

  147. 

  148.     ~SaveState()

  149.     {

  150.         reset();

  151.     }

  152. 

  153.     void reset()

  154.     {

  155.         if (type != nullptr)

  156.         {

  157.             delete[] type;

  158.             type = nullptr;

  159.         }

  160.         if (name != nullptr)

  161.         {

  162.             delete[] name;

  163.             name = nullptr;

  164.         }

  165.         if (label != nullptr)

  166.         {

  167.             delete[] label;

  168.             label = nullptr;

  169.         }

  170.         if (binary != nullptr)

  171.         {

  172.             delete[] binary;

  173.             binary = nullptr;

  174.         }

  175.         if (currentProgramName != nullptr)

  176.         {

  177.             delete[] currentProgramName;

  178.             currentProgramName = nullptr;

  179.         }

  180.         if (chunk != nullptr)

  181.         {

  182.             delete[] chunk;

  183.             chunk = nullptr;

  184.         }

  185. 

  186.         uniqueID = 0;

  187.         active = false;

  188.         dryWet = 1.0f;

  189.         volume = 1.0f;

  190.         balanceLeft  = -1.0f;

  191.         balanceRight = 1.0f;

  192.         panning      = 0.0f;

  193.         ctrlChannel  = -1;

  194.         currentProgramIndex = -1;

  195.         currentMidiBank     = -1;

  196.         currentMidiProgram  = -1;

  197. 

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

  199.         {

  200.             StateParameter* const stateParameter(*it);

  201.             delete stateParameter;

  202.         }

  203. 

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

  205.         {

  206.             StateCustomData* const stateCustomData(*it);

  207.             delete stateCustomData;

  208.         }

  209. 

  210.         parameters.clear();

  211.         customData.clear();

  212.     }

  213. 

  214.     CARLA_DECLARE_NON_COPY_STRUCT(SaveState)

  215. };

  216. 

  217. // -----------------------------------------------------------------------

  218. 

  219. static inline

  220. String xmlSafeString(const String& string, const bool toXml)

  221. {

  222.     String newString(string);

  223. 

  224.     if (toXml)

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

  226.     else

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

  228. }

  229. 

  230. static inline

  231. const char* xmlSafeStringCharDup(const String& string, const bool toXml)

  232. {

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

  234. }

  235. 

  236. // -----------------------------------------------------------------------

  237. 

  238. static inline

  239. void fillSaveStateFromXmlElement(SaveState& saveState, const XmlElement& xmlElement)

  240. {

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

  242.     {

  243.         // ---------------------------------------------------------------

  244.         // Info

  245. 

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

  247.         {

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

  249.             {

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

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

  252. 

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

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

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

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

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

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

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

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

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

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

  263.             }

  264.         }

  265. 

  266.         // ---------------------------------------------------------------

  267.         // Data

  268. 

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

  270.         {

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

  272.             {

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

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

  275. 

  276.                 // -------------------------------------------------------

  277.                 // Internal Data

  278. 

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

  280.                 {

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

  282.                 }

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

  284.                 {

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

  286.                 }

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

  288.                 {

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

  290.                 }

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

  292.                 {

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

  294.                 }

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

  296.                 {

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

  298.                 }

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

  300.                 {

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

  302.                 }

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

  304.                 {

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

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

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

  308.                 }

  309. 

  310.                 // -------------------------------------------------------

  311.                 // Program (current)

  312. 

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

  314.                 {

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

  316.                     if (value >= 1)

  317.                         saveState.currentProgramIndex = value-1;

  318.                 }

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

  320.                 {

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

  322.                 }

  323. 

  324.                 // -------------------------------------------------------

  325.                 // Midi Program (current)

  326. 

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

  328.                 {

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

  330.                     if (value >= 1)

  331.                         saveState.currentMidiBank = value-1;

  332.                 }

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

  334.                 {

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

  336.                     if (value >= 1)

  337.                         saveState.currentMidiProgram = value-1;

  338.                 }

  339. 

  340.                 // -------------------------------------------------------

  341.                 // Parameters

  342. 

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

  344.                 {

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

  346. 

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

  348.                     {

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

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

  351. 

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

  353.                         {

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

  355.                             if (index >= 0)

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

  357.                         }

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

  359.                         {

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

  361.                         }

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

  363.                         {

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

  365.                         }

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

  367.                         {

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

  369.                         }

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

  371.                         {

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

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

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

  375.                         }

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

  377.                         {

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

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

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

  381.                         }

  382.                     }

  383. 

  384.                     saveState.parameters.append(stateParameter);

  385.                 }

  386. 

  387.                 // -------------------------------------------------------

  388.                 // Custom Data

  389. 

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

  391.                 {

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

  393. 

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

  395.                     {

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

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

  398. 

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

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

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

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

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

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

  405.                     }

  406. 

  407.                     saveState.customData.append(stateCustomData);

  408.                 }

  409. 

  410.                 // -------------------------------------------------------

  411.                 // Chunk

  412. 

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

  414.                 {

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

  416.                 }

  417.             }

  418.         }

  419.     }

  420. }

  421. 

  422. // -----------------------------------------------------------------------

  423. 

  424. static inline

  425. void fillXmlStringFromSaveState(String& content, const SaveState& saveState)

  426. {

  427.     {

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

  429. 

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

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

  432. 

  433.         switch (getPluginTypeFromString(saveState.type))

  434.         {

  435.         case PLUGIN_NONE:

  436.             break;

  437.         case PLUGIN_INTERNAL:

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

  439.             break;

  440.         case PLUGIN_LADSPA:

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

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

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

  444.             break;

  445.         case PLUGIN_DSSI:

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

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

  448.             break;

  449.         case PLUGIN_LV2:

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

  451.             break;

  452.         case PLUGIN_VST:

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

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

  455.             break;

  456.         case PLUGIN_AU:

  457.             // TODO?

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

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

  460.             break;

  461.         case PLUGIN_CSOUND:

  462.         case PLUGIN_GIG:

  463.         case PLUGIN_SF2:

  464.         case PLUGIN_SFZ:

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

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

  467.             break;

  468.         }

  469. 

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

  471. 

  472.         content << info;

  473.     }

  474. 

  475.     {

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

  477. 

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

  479. 

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

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

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

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

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

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

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

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

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

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

  490. 

  491.         if (saveState.ctrlChannel < 0)

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

  493.         else

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

  495. 

  496.         content << data;

  497.     }

  498. 

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

  500.     {

  501.         StateParameter* const stateParameter(*it);

  502. 

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

  504. 

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

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

  507. 

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

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

  510. 

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

  512. 

  513.         if (stateParameter->midiCC > 0)

  514.         {

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

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

  517.         }

  518. 

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

  520. 

  521.         content << parameter;

  522.     }

  523. 

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

  525.     {

  526.         // ignore 'default' program

  527. #ifdef __USE_GNU

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

  529. #else

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

  531. #endif

  532.         {

  533.             String program("\n");

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

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

  536. 

  537.             content << program;

  538.         }

  539.     }

  540. 

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

  542.     {

  543.         String midiProgram("\n");

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

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

  546. 

  547.         content << midiProgram;

  548.     }

  549. 

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

  551.     {

  552.         StateCustomData* const stateCustomData(*it);

  553. 

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

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

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

  557. 

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

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

  560.         else

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

  562. 

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

  564. 

  565.         content << customData;

  566.     }

  567. 

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

  569.     {

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

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

  572. 

  573.         content << chunk;

  574.     }

  575. 

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

  577. }

  578. 

  579. // -----------------------------------------------------------------------

  580. 

  581. CARLA_BACKEND_END_NAMESPACE

  582. 

  583. #endif // CARLA_STATE_UTILS_HPP_INCLUDED