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.
7040 Commits
17 Branches
940MB
Tree: 5e505428f3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5e505428f3'
${ noResults }
Carla/source/utils/CarlaStateUtils.cpp

763 lines
27KB
Raw Blame History 

  1. // SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>

  2. // SPDX-License-Identifier: GPL-2.0-or-later

  3. 

  4. #include "CarlaStateUtils.hpp"

  5. 

  6. #include "CarlaBackendUtils.hpp"

  7. #include "CarlaMathUtils.hpp"

  8. #include "CarlaMIDI.h"

  9. 

  10. #include "water/streams/MemoryOutputStream.h"

  11. #include "water/xml/XmlElement.h"

  12. 

  13. #include <string>

  14. 

  15. using water::MemoryOutputStream;

  16. using water::XmlElement;

  17. 

  18. CARLA_BACKEND_START_NAMESPACE

  19. 

  20. // -----------------------------------------------------------------------

  21. // getNewLineSplittedString

  22. 

  23. static void getNewLineSplittedString(MemoryOutputStream& stream, const water::String& string)

  24. {

  25.     static const int kLineWidth = 120;

  26. 

  27.     int i = 0;

  28.     const int length = string.length();

  29.     const char* const raw = string.toUTF8();

  30. 

  31.     stream.preallocate(static_cast<std::size_t>(length + length/kLineWidth + 3));

  32. 

  33.     for (; i+kLineWidth < length; i += kLineWidth)

  34.     {

  35.         stream.write(raw+i, kLineWidth);

  36.         stream.writeByte('\n');

  37.     }

  38. 

  39.     stream << (raw+i);

  40. }

  41. 

  42. // -----------------------------------------------------------------------

  43. // xmlSafeStringFast

  44. 

  45. /* Based on some code by James Kanze from stackoverflow

  46.  * https://stackoverflow.com/questions/7724011/in-c-whats-the-fastest-way-to-replace-all-occurrences-of-a-substring-within */

  47. 

  48. static std::string replaceStdString(const std::string& original, const std::string& before, const std::string& after)

  49. {

  50.     std::string::const_iterator current = original.begin(), end = original.end(), next;

  51.     std::string retval;

  52. 

  53.     for (; (next = std::search(current, end, before.begin(), before.end())) != end;)

  54.     {

  55.         retval.append(current, next);

  56.         retval.append(after);

  57.         current = next + static_cast<ssize_t>(before.size());

  58.     }

  59.     retval.append(current, next);

  60.     return retval;

  61. }

  62. 

  63. static std::string xmlSafeStringFast(const char* const cstring, const bool toXml)

  64. {

  65.     std::string string(cstring);

  66. 

  67.     if (toXml)

  68.     {

  69.         string = replaceStdString(string, "&","&amp;");

  70.         string = replaceStdString(string, "<","&lt;");

  71.         string = replaceStdString(string, ">","&gt;");

  72.         string = replaceStdString(string, "'","&apos;");

  73.         string = replaceStdString(string, "\"","&quot;");

  74.     }

  75.     else

  76.     {

  77.         string = replaceStdString(string, "&lt;","<");

  78.         string = replaceStdString(string, "&gt;",">");

  79.         string = replaceStdString(string, "&apos;","'");

  80.         string = replaceStdString(string, "&quot;","\"");

  81.         string = replaceStdString(string, "&amp;","&");

  82.     }

  83. 

  84.     return string;

  85. }

  86. 

  87. // -----------------------------------------------------------------------

  88. // xmlSafeStringCharDup

  89. 

  90. /*

  91. static const char* xmlSafeStringCharDup(const char* const cstring, const bool toXml)

  92. {

  93.     return carla_strdup(xmlSafeString(cstring, toXml).toRawUTF8());

  94. }

  95. */

  96. 

  97. static const char* xmlSafeStringCharDup(const water::String& string, const bool toXml)

  98. {

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

  100. }

  101. 

  102. // -----------------------------------------------------------------------

  103. // StateParameter

  104. 

  105. CarlaStateSave::Parameter::Parameter() noexcept

  106.     : dummy(true),

  107.       index(-1),

  108.       name(nullptr),

  109.       symbol(nullptr),

  110.      #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  111.       value(0.0f),

  112.       mappedControlIndex(CONTROL_INDEX_NONE),

  113.       midiChannel(0),

  114.       mappedRangeValid(false),

  115.       mappedMinimum(0.0f),

  116.       mappedMaximum(1.0f) {}

  117.      #else

  118.       value(0.0f) {}

  119.      #endif

  120. 

  121. CarlaStateSave::Parameter::~Parameter() noexcept

  122. {

  123.     if (name != nullptr)

  124.     {

  125.         delete[] name;

  126.         name = nullptr;

  127.     }

  128.     if (symbol != nullptr)

  129.     {

  130.         delete[] symbol;

  131.         symbol = nullptr;

  132.     }

  133. }

  134. 

  135. // -----------------------------------------------------------------------

  136. // StateCustomData

  137. 

  138. CarlaStateSave::CustomData::CustomData() noexcept

  139.     : type(nullptr),

  140.       key(nullptr),

  141.       value(nullptr) {}

  142. 

  143. CarlaStateSave::CustomData::~CustomData() noexcept

  144. {

  145.     if (type != nullptr)

  146.     {

  147.         delete[] type;

  148.         type = nullptr;

  149.     }

  150.     if (key != nullptr)

  151.     {

  152.         delete[] key;

  153.         key = nullptr;

  154.     }

  155.     if (value != nullptr)

  156.     {

  157.         delete[] value;

  158.         value = nullptr;

  159.     }

  160. }

  161. 

  162. bool CarlaStateSave::CustomData::isValid() const noexcept

  163. {

  164.     if (type  == nullptr || type[0] == '\0') return false;

  165.     if (key   == nullptr || key [0] == '\0') return false;

  166.     if (value == nullptr)                    return false;

  167.     return true;

  168. }

  169. 

  170. // -----------------------------------------------------------------------

  171. // StateSave

  172. 

  173. CarlaStateSave::CarlaStateSave() noexcept

  174.     : type(nullptr),

  175.       name(nullptr),

  176.       label(nullptr),

  177.       binary(nullptr),

  178.       uniqueId(0),

  179.       options(PLUGIN_OPTIONS_NULL),

  180.       temporary(false),

  181.      #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  182.       active(false),

  183.       dryWet(1.0f),

  184.       volume(1.0f),

  185.       balanceLeft(-1.0f),

  186.       balanceRight(1.0f),

  187.       panning(0.0f),

  188.       ctrlChannel(-1),

  189.      #endif

  190.       currentProgramIndex(-1),

  191.       currentProgramName(nullptr),

  192.       currentMidiBank(-1),

  193.       currentMidiProgram(-1),

  194.       chunk(nullptr),

  195.       parameters(),

  196.       customData() {}

  197. 

  198. CarlaStateSave::~CarlaStateSave() noexcept

  199. {

  200.     clear();

  201. }

  202. 

  203. void CarlaStateSave::clear() noexcept

  204. {

  205.     if (type != nullptr)

  206.     {

  207.         delete[] type;

  208.         type = nullptr;

  209.     }

  210.     if (name != nullptr)

  211.     {

  212.         delete[] name;

  213.         name = nullptr;

  214.     }

  215.     if (label != nullptr)

  216.     {

  217.         delete[] label;

  218.         label = nullptr;

  219.     }

  220.     if (binary != nullptr)

  221.     {

  222.         delete[] binary;

  223.         binary = nullptr;

  224.     }

  225.     if (currentProgramName != nullptr)

  226.     {

  227.         delete[] currentProgramName;

  228.         currentProgramName = nullptr;

  229.     }

  230.     if (chunk != nullptr)

  231.     {

  232.         delete[] chunk;

  233.         chunk = nullptr;

  234.     }

  235. 

  236.     uniqueId = 0;

  237.     options  = PLUGIN_OPTIONS_NULL;

  238. 

  239.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  240.     active = false;

  241.     dryWet = 1.0f;

  242.     volume = 1.0f;

  243.     balanceLeft  = -1.0f;

  244.     balanceRight = 1.0f;

  245.     panning      = 0.0f;

  246.     ctrlChannel  = -1;

  247.    #endif

  248. 

  249.     currentProgramIndex = -1;

  250.     currentMidiBank     = -1;

  251.     currentMidiProgram  = -1;

  252. 

  253.     for (ParameterItenerator it = parameters.begin2(); it.valid(); it.next())

  254.     {

  255.         Parameter* const stateParameter(it.getValue(nullptr));

  256.         delete stateParameter;

  257.     }

  258. 

  259.     for (CustomDataItenerator it = customData.begin2(); it.valid(); it.next())

  260.     {

  261.         CustomData* const stateCustomData(it.getValue(nullptr));

  262.         delete stateCustomData;

  263.     }

  264. 

  265.     parameters.clear();

  266.     customData.clear();

  267. }

  268. 

  269. // -----------------------------------------------------------------------

  270. // fillFromXmlElement

  271. 

  272. bool CarlaStateSave::fillFromXmlElement(const XmlElement* const xmlElement)

  273. {

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

  275. 

  276.     clear();

  277. 

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

  279.     {

  280.         const water::String& tagName(elem->getTagName());

  281. 

  282.         // ---------------------------------------------------------------

  283.         // Info

  284. 

  285.         if (tagName == "Info")

  286.         {

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

  288.             {

  289.                 const water::String& tag(xmlInfo->getTagName());

  290.                 const water::String  text(xmlInfo->getAllSubText().trim());

  291. 

  292.                 /**/ if (tag == "Type")

  293.                     type = xmlSafeStringCharDup(text, false);

  294.                 else if (tag == "Name")

  295.                     name = xmlSafeStringCharDup(text, false);

  296.                 else if (tag == "Label" || tag == "URI" || tag == "Identifier" || tag == "Setup")

  297.                     label = xmlSafeStringCharDup(text, false);

  298.                 else if (tag == "Binary" || tag == "Bundle" || tag == "Filename")

  299.                     binary = xmlSafeStringCharDup(text, false);

  300.                 else if (tag == "UniqueID")

  301.                     uniqueId = text.getLargeIntValue();

  302.             }

  303.         }

  304. 

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

  306.         // Data

  307. 

  308.         else if (tagName == "Data")

  309.         {

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

  311.             {

  312.                 const water::String& tag(xmlData->getTagName());

  313.                 const water::String  text(xmlData->getAllSubText().trim());

  314. 

  315.                 // -------------------------------------------------------

  316.                 // Internal Data

  317. 

  318.                 /**/ if (tag == "Options")

  319.                 {

  320.                     const int value(text.getHexValue32());

  321.                     if (value > 0)

  322.                         options = static_cast<uint>(value);

  323.                 }

  324.                #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  325.                 else if (tag == "Active")

  326.                 {

  327.                     active = (text == "Yes");

  328.                 }

  329.                 else if (tag == "DryWet")

  330.                 {

  331.                     dryWet = carla_fixedValue(0.0f, 1.0f, text.getFloatValue());

  332.                 }

  333.                 else if (tag == "Volume")

  334.                 {

  335.                     volume = carla_fixedValue(0.0f, 1.27f, text.getFloatValue());

  336.                 }

  337.                 else if (tag == "Balance-Left")

  338.                 {

  339.                     balanceLeft = carla_fixedValue(-1.0f, 1.0f, text.getFloatValue());

  340.                 }

  341.                 else if (tag == "Balance-Right")

  342.                 {

  343.                     balanceRight = carla_fixedValue(-1.0f, 1.0f, text.getFloatValue());

  344.                 }

  345.                 else if (tag == "Panning")

  346.                 {

  347.                     panning = carla_fixedValue(-1.0f, 1.0f, text.getFloatValue());

  348.                 }

  349.                 else if (tag == "ControlChannel")

  350.                 {

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

  352.                     {

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

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

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

  356.                     }

  357.                 }

  358.                #endif

  359. 

  360.                 // -------------------------------------------------------

  361.                 // Program (current)

  362. 

  363.                 else if (tag == "CurrentProgramIndex")

  364.                 {

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

  366.                     if (value >= 1)

  367.                         currentProgramIndex = value-1;

  368.                 }

  369.                 else if (tag == "CurrentProgramName")

  370.                 {

  371.                     currentProgramName = xmlSafeStringCharDup(text, false);

  372.                 }

  373. 

  374.                 // -------------------------------------------------------

  375.                 // Midi Program (current)

  376. 

  377.                 else if (tag == "CurrentMidiBank")

  378.                 {

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

  380.                     if (value >= 1)

  381.                         currentMidiBank = value-1;

  382.                 }

  383.                 else if (tag == "CurrentMidiProgram")

  384.                 {

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

  386.                     if (value >= 1)

  387.                         currentMidiProgram = value-1;

  388.                 }

  389. 

  390.                 // -------------------------------------------------------

  391.                 // Parameters

  392. 

  393.                 else if (tag == "Parameter")

  394.                 {

  395.                     Parameter* const stateParameter(new Parameter());

  396.                    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  397.                     bool hasMappedMinimum = false, hasMappedMaximum = false;

  398.                    #endif

  399. 

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

  401.                     {

  402.                         const water::String& pTag(xmlSubData->getTagName());

  403.                         const water::String  pText(xmlSubData->getAllSubText().trim());

  404. 

  405.                         /**/ if (pTag == "Index")

  406.                         {

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

  408.                             if (index >= 0)

  409.                                 stateParameter->index = index;

  410.                         }

  411.                         else if (pTag == "Name")

  412.                         {

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

  414.                         }

  415.                         else if (pTag == "Symbol" || pTag == "Identifier")

  416.                         {

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

  418.                         }

  419.                         else if (pTag == "Value")

  420.                         {

  421.                             stateParameter->dummy = false;

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

  423.                         }

  424.                        #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  425.                         else if (pTag == "MidiChannel")

  426.                         {

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

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

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

  430.                         }

  431.                         else if (pTag == "MidiCC")

  432.                         {

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

  434.                             if (cc > 0 && cc < MAX_MIDI_CONTROL)

  435.                                 stateParameter->mappedControlIndex = static_cast<int16_t>(cc);

  436.                         }

  437.                         else if (pTag == "MappedControlIndex")

  438.                         {

  439.                             const int ctrl(pText.getIntValue());

  440.                             if (ctrl > CONTROL_INDEX_NONE && ctrl <= CONTROL_INDEX_MAX_ALLOWED)

  441.                                 if (ctrl != CONTROL_INDEX_MIDI_LEARN)

  442.                                     stateParameter->mappedControlIndex = static_cast<int16_t>(ctrl);

  443.                         }

  444.                         else if (pTag == "MappedMinimum")

  445.                         {

  446.                             hasMappedMinimum = true;

  447.                             stateParameter->mappedMinimum = pText.getFloatValue();

  448.                         }

  449.                         else if (pTag == "MappedMaximum")

  450.                         {

  451.                             hasMappedMaximum = true;

  452.                             stateParameter->mappedMaximum = pText.getFloatValue();

  453.                         }

  454.                        #endif

  455.                     }

  456. 

  457.                    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  458.                     if (hasMappedMinimum && hasMappedMaximum)

  459.                         stateParameter->mappedRangeValid = true;

  460.                    #endif

  461. 

  462.                     parameters.append(stateParameter);

  463.                 }

  464. 

  465.                 // -------------------------------------------------------

  466.                 // Custom Data

  467. 

  468.                 else if (tag == "CustomData")

  469.                 {

  470.                     CustomData* const stateCustomData(new CustomData());

  471. 

  472.                     // find type first

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

  474.                     {

  475.                         const water::String& cTag(xmlSubData->getTagName());

  476. 

  477.                         if (cTag != "Type")

  478.                             continue;

  479. 

  480.                         stateCustomData->type = xmlSafeStringCharDup(xmlSubData->getAllSubText().trim(), false);

  481.                         break;

  482.                     }

  483. 

  484.                     if (stateCustomData->type == nullptr || stateCustomData->type[0] == '\0')

  485.                     {

  486.                         carla_stderr("Reading CustomData type failed");

  487.                         delete stateCustomData;

  488.                         continue;

  489.                     }

  490. 

  491.                     // now fill in key and value, knowing what the type is

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

  493.                     {

  494.                         const water::String& cTag(xmlSubData->getTagName());

  495.                         water::String cText(xmlSubData->getAllSubText());

  496. 

  497.                         /**/ if (cTag == "Key")

  498.                         {

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

  500.                         }

  501.                         else if (cTag == "Value")

  502.                         {

  503.                             // save operation adds a newline and newline+space around the string in some cases

  504.                             const int len = cText.length();

  505.                             if (std::strcmp(stateCustomData->type, CUSTOM_DATA_TYPE_CHUNK) == 0 || len >= 128+6)

  506.                             {

  507.                                 CARLA_SAFE_ASSERT_CONTINUE(len >= 6);

  508.                                 cText = cText.substring(1, len - 5);

  509.                             }

  510. 

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

  512.                         }

  513.                     }

  514. 

  515.                     if (stateCustomData->isValid())

  516.                     {

  517.                         customData.append(stateCustomData);

  518.                     }

  519.                     else

  520.                     {

  521.                         carla_stderr("Reading CustomData property failed, missing data");

  522.                         delete stateCustomData;

  523.                     }

  524.                 }

  525. 

  526.                 // -------------------------------------------------------

  527.                 // Chunk

  528. 

  529.                 else if (tag == "Chunk")

  530.                 {

  531.                     chunk = carla_strdup(text.toRawUTF8());

  532.                 }

  533.             }

  534.         }

  535.     }

  536. 

  537.     return true;

  538. }

  539. 

  540. // -----------------------------------------------------------------------

  541. // fillXmlStringFromStateSave

  542. 

  543. void CarlaStateSave::dumpToMemoryStream(MemoryOutputStream& content) const

  544. {

  545.     const PluginType pluginType = getPluginTypeFromString(type);

  546. 

  547.     {

  548.         MemoryOutputStream infoXml;

  549. 

  550.         infoXml << "  <Info>\n";

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

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

  553. 

  554.         switch (pluginType)

  555.         {

  556.         case PLUGIN_NONE:

  557.             break;

  558.         case PLUGIN_INTERNAL:

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

  560.             break;

  561.         case PLUGIN_LADSPA:

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

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

  564.             infoXml << "   <UniqueID>" << water::int64(uniqueId)       << "</UniqueID>\n";

  565.             break;

  566.         case PLUGIN_DSSI:

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

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

  569.             break;

  570.         case PLUGIN_LV2:

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

  572.             break;

  573.         case PLUGIN_VST2:

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

  575.             infoXml << "   <UniqueID>" << water::int64(uniqueId)       << "</UniqueID>\n";

  576.             break;

  577.         case PLUGIN_VST3:

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

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

  580.             break;

  581.         case PLUGIN_AU:

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

  583.             infoXml << "   <Identifier>" << xmlSafeString(label, true) << "</Identifier>\n";

  584.             break;

  585.         case PLUGIN_CLAP:

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

  587.             infoXml << "   <Identifier>" << xmlSafeString(label, true)  << "</Identifier>\n";

  588.             break;

  589.         case PLUGIN_DLS:

  590.         case PLUGIN_GIG:

  591.         case PLUGIN_SF2:

  592.         case PLUGIN_JSFX:

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

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

  595.             break;

  596.         case PLUGIN_SFZ:

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

  598.             break;

  599.         case PLUGIN_JACK:

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

  601.             infoXml << "   <Setup>"      << xmlSafeString(label, true)  << "</Setup>\n";

  602.             break;

  603.         case PLUGIN_TYPE_COUNT:

  604.             break;

  605.         }

  606. 

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

  608. 

  609.         content << infoXml;

  610.     }

  611. 

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

  613. 

  614.    #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  615.     {

  616.         MemoryOutputStream dataXml;

  617. 

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

  619. 

  620.         if (carla_isNotEqual(dryWet, 1.0f))

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

  622.         if (carla_isNotEqual(volume, 1.0f))

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

  624.         if (carla_isNotEqual(balanceLeft, -1.0f))

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

  626.         if (carla_isNotEqual(balanceRight, 1.0f))

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

  628.         if (carla_isNotEqual(panning, 0.0f))

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

  630. 

  631.         if (ctrlChannel < 0)

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

  633.         else

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

  635. 

  636.         dataXml << "   <Options>0x" << water::String::toHexString(static_cast<int>(options)) << "</Options>\n";

  637. 

  638.         content << dataXml;

  639.     }

  640.    #endif

  641. 

  642.     for (ParameterItenerator it = parameters.begin2(); it.valid(); it.next())

  643.     {

  644.         Parameter* const stateParameter(it.getValue(nullptr));

  645.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  646. 

  647.         MemoryOutputStream parameterXml;

  648. 

  649.         parameterXml << "\n";

  650.         parameterXml << "   <Parameter>\n";

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

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

  653. 

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

  655.         {

  656.             if (pluginType == PLUGIN_CLAP)

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

  658.             else

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

  660.         }

  661. 

  662.        #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  663.         if (stateParameter->mappedControlIndex > CONTROL_INDEX_NONE && stateParameter->mappedControlIndex <= CONTROL_INDEX_MAX_ALLOWED)

  664.         {

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

  666.             parameterXml << "    <MappedControlIndex>" << stateParameter->mappedControlIndex << "</MappedControlIndex>\n";

  667. 

  668.             if (stateParameter->mappedRangeValid)

  669.             {

  670.                 parameterXml << "    <MappedMinimum>" << water::String(stateParameter->mappedMinimum, 15) << "</MappedMinimum>\n";

  671.                 parameterXml << "    <MappedMaximum>" << water::String(stateParameter->mappedMaximum, 15) << "</MappedMaximum>\n";

  672.             }

  673. 

  674.             // backwards compatibility for older carla versions

  675.             if (stateParameter->mappedControlIndex > 0 && stateParameter->mappedControlIndex < MAX_MIDI_CONTROL)

  676.                 parameterXml << "    <MidiCC>" << stateParameter->mappedControlIndex << "</MidiCC>\n";

  677.         }

  678.        #endif

  679. 

  680.         if (! stateParameter->dummy)

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

  682. 

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

  684. 

  685.         content << parameterXml;

  686.     }

  687. 

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

  689.     {

  690.         // ignore 'default' program

  691.         if (currentProgramIndex > 0 || ! water::String(currentProgramName).equalsIgnoreCase("default"))

  692.         {

  693.             MemoryOutputStream programXml;

  694. 

  695.             programXml << "\n";

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

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

  698. 

  699.             content << programXml;

  700.         }

  701.     }

  702. 

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

  704.     {

  705.         MemoryOutputStream midiProgramXml;

  706. 

  707.         midiProgramXml << "\n";

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

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

  710. 

  711.         content << midiProgramXml;

  712.     }

  713. 

  714.     for (CustomDataItenerator it = customData.begin2(); it.valid(); it.next())

  715.     {

  716.         CustomData* const stateCustomData(it.getValue(nullptr));

  717.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

  718.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->isValid());

  719. 

  720.         MemoryOutputStream customDataXml;

  721. 

  722.         customDataXml << "\n";

  723.         customDataXml << "   <CustomData>\n";

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

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

  726. 

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

  728.         {

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

  730.             customDataXml << xmlSafeStringFast(stateCustomData->value, true);

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

  732.         }

  733.         else

  734.         {

  735.             customDataXml << "    <Value>";

  736.             customDataXml << xmlSafeStringFast(stateCustomData->value, true);

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

  738.         }

  739. 

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

  741. 

  742.         content << customDataXml;

  743.     }

  744. 

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

  746.     {

  747.         MemoryOutputStream chunkXml, chunkSplt;

  748.         getNewLineSplittedString(chunkSplt, chunk);

  749. 

  750.         chunkXml << "\n   <Chunk>\n";

  751.         chunkXml << chunkSplt;

  752.         chunkXml << "\n   </Chunk>\n";

  753. 

  754.         content << chunkXml;

  755.     }

  756. 

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

  758. }

  759. 

  760. // -----------------------------------------------------------------------

  761. 

  762. CARLA_BACKEND_END_NAMESPACE