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.
1984 Commits
16 Branches
331MB
Tree: d219ab6c78
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd219ab6c78'
${ noResults }
Carla/source/utils/CarlaStateUtils.cpp

570 lines
20KB
Raw Blame History 

  1. /*

  2.  * Carla State utils

  3.  * Copyright (C) 2012-2014 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. #include "CarlaStateUtils.hpp"

  19. 

  20. #include "CarlaBackendUtils.hpp"

  21. #include "CarlaMathUtils.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "juce_core.h"

  25. using juce::String;

  26. using juce::XmlElement;

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

  30. // -----------------------------------------------------------------------

  31. // xmlSafeString

  32. 

  33. static String xmlSafeString(const String& string, const bool toXml)

  34. {

  35.     String newString(string);

  36. 

  37.     if (toXml)

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

  39.     else

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

  41. }

  42. 

  43. // -----------------------------------------------------------------------

  44. // xmlSafeStringCharDup

  45. 

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

  47. {

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

  49. }

  50. 

  51. // -----------------------------------------------------------------------

  52. // StateParameter

  53. 

  54. StateParameter::StateParameter() noexcept

  55.     : isInput(true),

  56.       index(-1),

  57.       name(nullptr),

  58.       symbol(nullptr),

  59.       value(0.0f),

  60.       midiChannel(0),

  61.       midiCC(-1) {}

  62. 

  63. StateParameter::~StateParameter() noexcept

  64. {

  65.     if (name != nullptr)

  66.     {

  67.         delete[] name;

  68.         name = nullptr;

  69.     }

  70.     if (symbol != nullptr)

  71.     {

  72.         delete[] symbol;

  73.         symbol = nullptr;

  74.     }

  75. }

  76. 

  77. // -----------------------------------------------------------------------

  78. // StateCustomData

  79. 

  80. StateCustomData::StateCustomData() noexcept

  81.     : type(nullptr),

  82.       key(nullptr),

  83.       value(nullptr) {}

  84. 

  85. StateCustomData::~StateCustomData() noexcept

  86. {

  87.     if (type != nullptr)

  88.     {

  89.         delete[] type;

  90.         type = nullptr;

  91.     }

  92.     if (key != nullptr)

  93.     {

  94.         delete[] key;

  95.         key = nullptr;

  96.     }

  97.     if (value != nullptr)

  98.     {

  99.         delete[] value;

  100.         value = nullptr;

  101.     }

  102. }

  103. 

  104. // -----------------------------------------------------------------------

  105. // StateSave

  106. 

  107. StateSave::StateSave() noexcept

  108.     : type(nullptr),

  109.       name(nullptr),

  110.       label(nullptr),

  111.       binary(nullptr),

  112.       uniqueId(0),

  113.       active(false),

  114.       dryWet(1.0f),

  115.       volume(1.0f),

  116.       balanceLeft(-1.0f),

  117.       balanceRight(1.0f),

  118.       panning(0.0f),

  119.       ctrlChannel(-1),

  120.       currentProgramIndex(-1),

  121.       currentProgramName(nullptr),

  122.       currentMidiBank(-1),

  123.       currentMidiProgram(-1),

  124.       chunk(nullptr) {}

  125. 

  126. StateSave::~StateSave() noexcept

  127. {

  128.     clear();

  129. }

  130. 

  131. void StateSave::clear() noexcept

  132. {

  133.     if (type != nullptr)

  134.     {

  135.         delete[] type;

  136.         type = nullptr;

  137.     }

  138.     if (name != nullptr)

  139.     {

  140.         delete[] name;

  141.         name = nullptr;

  142.     }

  143.     if (label != nullptr)

  144.     {

  145.         delete[] label;

  146.         label = nullptr;

  147.     }

  148.     if (binary != nullptr)

  149.     {

  150.         delete[] binary;

  151.         binary = nullptr;

  152.     }

  153.     if (currentProgramName != nullptr)

  154.     {

  155.         delete[] currentProgramName;

  156.         currentProgramName = nullptr;

  157.     }

  158.     if (chunk != nullptr)

  159.     {

  160.         delete[] chunk;

  161.         chunk = nullptr;

  162.     }

  163. 

  164.     uniqueId = 0;

  165.     active = false;

  166.     dryWet = 1.0f;

  167.     volume = 1.0f;

  168.     balanceLeft  = -1.0f;

  169.     balanceRight = 1.0f;

  170.     panning      = 0.0f;

  171.     ctrlChannel  = -1;

  172.     currentProgramIndex = -1;

  173.     currentMidiBank     = -1;

  174.     currentMidiProgram  = -1;

  175. 

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

  177.     {

  178.         StateParameter* const stateParameter(it.getValue());

  179.         delete stateParameter;

  180.     }

  181. 

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

  183.     {

  184.         StateCustomData* const stateCustomData(it.getValue());

  185.         delete stateCustomData;

  186.     }

  187. 

  188.     parameters.clear();

  189.     customData.clear();

  190. }

  191. 

  192. // -----------------------------------------------------------------------

  193. // fillFromXmlElement

  194. 

  195. bool StateSave::fillFromXmlElement(const XmlElement* const xmlElement)

  196. {

  197.     CARLA_SAFE_ASSERT_RETURN(xmlElement != nullptr, false);

  198. 

  199.     clear();

  200. 

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

  202.     {

  203.         const String& tagName(elem->getTagName());

  204. 

  205.         // ---------------------------------------------------------------

  206.         // Info

  207. 

  208.         if (tagName.equalsIgnoreCase("info"))

  209.         {

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

  211.             {

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

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

  214. 

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

  216.                     type = xmlSafeStringCharDup(text, false);

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

  218.                     name = xmlSafeStringCharDup(text, false);

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

  220.                     label = xmlSafeStringCharDup(text, false);

  221.                 else if (tag.equalsIgnoreCase("binary") || tag.equalsIgnoreCase("bundle") || tag.equalsIgnoreCase("filename"))

  222.                     binary = xmlSafeStringCharDup(text, false);

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

  224.                     uniqueId = text.getLargeIntValue();

  225.             }

  226.         }

  227. 

  228.         // ---------------------------------------------------------------

  229.         // Data

  230. 

  231.         else if (tagName.equalsIgnoreCase("data"))

  232.         {

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

  234.             {

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

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

  237. 

  238.                 // -------------------------------------------------------

  239.                 // Internal Data

  240. 

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

  242.                 {

  243.                     active = (text.equalsIgnoreCase("yes") || text.equalsIgnoreCase("true"));

  244.                 }

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

  246.                 {

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

  248.                 }

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

  250.                 {

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

  252.                 }

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

  254.                 {

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

  256.                 }

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

  258.                 {

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

  260.                 }

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

  262.                 {

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

  264.                 }

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

  266.                 {

  267.                     if (! text.startsWithIgnoreCase("n"))

  268.                     {

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

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

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

  272.                     }

  273.                 }

  274. 

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

  276.                 // Program (current)

  277. 

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

  279.                 {

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

  281.                     if (value >= 1)

  282.                         currentProgramIndex = value-1;

  283.                 }

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

  285.                 {

  286.                     currentProgramName = xmlSafeStringCharDup(text, false);

  287.                 }

  288. 

  289.                 // -------------------------------------------------------

  290.                 // Midi Program (current)

  291. 

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

  293.                 {

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

  295.                     if (value >= 1)

  296.                         currentMidiBank = value-1;

  297.                 }

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

  299.                 {

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

  301.                     if (value >= 1)

  302.                         currentMidiProgram = value-1;

  303.                 }

  304. 

  305.                 // -------------------------------------------------------

  306.                 // Parameters

  307. 

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

  309.                 {

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

  311. 

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

  313.                     {

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

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

  316. 

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

  318.                         {

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

  320.                             if (index >= 0)

  321.                                 stateParameter->index = index;

  322.                         }

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

  324.                         {

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

  326.                         }

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

  328.                         {

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

  330.                         }

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

  332.                         {

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

  334.                         }

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

  336.                         {

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

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

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

  340.                         }

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

  342.                         {

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

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

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

  346.                         }

  347.                     }

  348. 

  349.                     parameters.append(stateParameter);

  350.                 }

  351. 

  352.                 // -------------------------------------------------------

  353.                 // Custom Data

  354. 

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

  356.                 {

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

  358. 

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

  360.                     {

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

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

  363. 

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

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

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

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

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

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

  370.                     }

  371. 

  372.                     customData.append(stateCustomData);

  373.                 }

  374. 

  375.                 // -------------------------------------------------------

  376.                 // Chunk

  377. 

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

  379.                 {

  380.                     chunk = xmlSafeStringCharDup(text, false);

  381.                 }

  382.             }

  383.         }

  384.     }

  385. 

  386.     return true;

  387. }

  388. 

  389. // -----------------------------------------------------------------------

  390. // fillXmlStringFromStateSave

  391. 

  392. String StateSave::toString() const

  393. {

  394.     String content;

  395. 

  396.     {

  397.         String infoXml("  <Info>\n");

  398. 

  399.         infoXml << "   <Type>" << String(type != nullptr ? type : "") << "</Type>\n";

  400.         infoXml << "   <Name>" << xmlSafeString(name, true) << "</Name>\n";

  401. 

  402.         switch (getPluginTypeFromString(type))

  403.         {

  404.         case PLUGIN_NONE:

  405.             break;

  406.         case PLUGIN_INTERNAL:

  407.             infoXml << "    <Label>"    << xmlSafeString(label, true)  << "</Label>\n";

  408.             break;

  409.         case PLUGIN_LADSPA:

  410.             infoXml << "    <Binary>"   << xmlSafeString(binary, true) << "</Binary>\n";

  411.             infoXml << "    <Label>"    << xmlSafeString(label, true)  << "</Label>\n";

  412.             infoXml << "    <UniqueID>" << uniqueId                    << "</UniqueID>\n";

  413.             break;

  414.         case PLUGIN_DSSI:

  415.             infoXml << "    <Binary>"   << xmlSafeString(binary, true) << "</Binary>\n";

  416.             infoXml << "    <Label>"    << xmlSafeString(label, true)  << "</Label>\n";

  417.             break;

  418.         case PLUGIN_LV2:

  419.             infoXml << "    <Bundle>"   << xmlSafeString(binary, true) << "</Bundle>\n";

  420.             infoXml << "    <URI>"      << xmlSafeString(label, true)  << "</URI>\n";

  421.             break;

  422.         case PLUGIN_VST:

  423.             infoXml << "    <Binary>"   << xmlSafeString(binary, true) << "</Binary>\n";

  424.             infoXml << "    <UniqueID>" << uniqueId                    << "</UniqueID>\n";

  425.             break;

  426.         case PLUGIN_VST3:

  427.             // TODO?

  428.             infoXml << "    <Binary>"   << xmlSafeString(binary, true) << "</Binary>\n";

  429.             infoXml << "    <UniqueID>" << uniqueId                    << "</UniqueID>\n";

  430.             break;

  431.         case PLUGIN_AU:

  432.             // TODO?

  433.             infoXml << "    <Binary>"   << xmlSafeString(binary, true) << "</Binary>\n";

  434.             infoXml << "    <UniqueID>" << uniqueId                    << "</UniqueID>\n";

  435.             break;

  436.         case PLUGIN_GIG:

  437.         case PLUGIN_SF2:

  438.             infoXml << "    <Filename>"   << xmlSafeString(binary, true) << "</Filename>\n";

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

  440.             break;

  441.         case PLUGIN_SFZ:

  442.             infoXml << "    <Filename>"   << xmlSafeString(binary, true) << "</Filename>\n";

  443.             break;

  444.         }

  445. 

  446.         infoXml << "  </Info>\n\n";

  447. 

  448.         content << infoXml;

  449.     }

  450. 

  451.     content << "  <Data>\n";

  452. 

  453.     {

  454.         String dataXml;

  455. 

  456.         dataXml << "   <Active>" << (active ? "Yes" : "No") << "</Active>\n";

  457. 

  458.         if (dryWet != 1.0f)

  459.             dataXml << "   <DryWet>"        << String(dryWet, 7)       << "</DryWet>\n";

  460.         if (volume != 1.0f)

  461.             dataXml << "   <Volume>"        << String(volume, 7)       << "</Volume>\n";

  462.         if (balanceLeft != -1.0f)

  463.             dataXml << "   <Balance-Left>"  << String(balanceLeft, 7)  << "</Balance-Left>\n";

  464.         if (balanceRight != 1.0f)

  465.             dataXml << "   <Balance-Right>" << String(balanceRight, 7) << "</Balance-Right>\n";

  466.         if (panning != 0.0f)

  467.             dataXml << "   <Panning>"       << String(panning, 7)      << "</Panning>\n";

  468. 

  469.         if (ctrlChannel < 0)

  470.             dataXml << "   <ControlChannel>N</ControlChannel>\n";

  471.         else

  472.             dataXml << "   <ControlChannel>" << int(ctrlChannel+1) << "</ControlChannel>\n";

  473. 

  474.         content << dataXml;

  475.     }

  476. 

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

  478.     {

  479.         StateParameter* const stateParameter(it.getValue());

  480. 

  481.         String parameterXml("\n""   <Parameter>\n");

  482. 

  483.         parameterXml << "    <Index>" << String(stateParameter->index)             << "</Index>\n";

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

  485. 

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

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

  488. 

  489.         if (stateParameter->isInput)

  490.             parameterXml << "    <Value>" << String(stateParameter->value, 15) << "</Value>\n";

  491. 

  492.         if (stateParameter->midiCC > 0)

  493.         {

  494.             parameterXml << "    <MidiCC>"      << stateParameter->midiCC        << "</MidiCC>\n";

  495.             parameterXml << "    <MidiChannel>" << stateParameter->midiChannel+1 << "</MidiChannel>\n";

  496.         }

  497. 

  498.         parameterXml << "   </Parameter>\n";

  499. 

  500.         content << parameterXml;

  501.     }

  502. 

  503.     if (currentProgramIndex >= 0 && currentProgramName != nullptr && currentProgramName[0] != '\0')

  504.     {

  505.         // ignore 'default' program

  506.         if (currentProgramIndex > 0 || ! String(currentProgramName).equalsIgnoreCase("default"))

  507.         {

  508.             String programXml("\n");

  509.             programXml << "   <CurrentProgramIndex>" << currentProgramIndex+1                   << "</CurrentProgramIndex>\n";

  510.             programXml << "   <CurrentProgramName>"  << xmlSafeString(currentProgramName, true) << "</CurrentProgramName>\n";

  511. 

  512.             content << programXml;

  513.         }

  514.     }

  515. 

  516.     if (currentMidiBank >= 0 && currentMidiProgram >= 0)

  517.     {

  518.         String midiProgramXml("\n");

  519.         midiProgramXml << "   <CurrentMidiBank>"    << currentMidiBank+1    << "</CurrentMidiBank>\n";

  520.         midiProgramXml << "   <CurrentMidiProgram>" << currentMidiProgram+1 << "</CurrentMidiProgram>\n";

  521. 

  522.         content << midiProgramXml;

  523.     }

  524. 

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

  526.     {

  527.         StateCustomData* const stateCustomData(it.getValue());

  528.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->type  != nullptr && stateCustomData->type[0] != '\0');

  529.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->key   != nullptr && stateCustomData->key[0]  != '\0');

  530.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->value != nullptr);

  531. 

  532.         String customDataXml("\n""   <CustomData>\n");

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

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

  535. 

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

  537.         {

  538.             customDataXml << "    <Value>\n";

  539.             customDataXml << xmlSafeString(stateCustomData->value, true);

  540.             customDataXml << "\n    </Value>\n";

  541.         }

  542.         else

  543.         {

  544.             customDataXml << "    <Value>";

  545.             customDataXml << xmlSafeString(stateCustomData->value, true);

  546.             customDataXml << "</Value>\n";

  547.         }

  548. 

  549.         customDataXml << "   </CustomData>\n";

  550. 

  551.         content << customDataXml;

  552.     }

  553. 

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

  555.     {

  556.         String chunkXml("\n""   <Chunk>\n");

  557.         chunkXml << chunk << "\n   </Chunk>\n";

  558. 

  559.         content << chunkXml;

  560.     }

  561. 

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

  563. 

  564.     return content;

  565. }

  566. 

  567. // -----------------------------------------------------------------------

  568. 

  569. CARLA_BACKEND_END_NAMESPACE