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.
2889 Commits
16 Branches
14GB
Tree: 1aa4c4211e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1aa4c4211e'
${ noResults }
Carla/source/utils/CarlaStateUtils.cpp

675 lines
23KB
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 <string>

  25. 

  26. using juce::String;

  27. using juce::XmlElement;

  28. 

  29. CARLA_BACKEND_START_NAMESPACE

  30. 

  31. // -----------------------------------------------------------------------

  32. // getNewLineSplittedString

  33. 

  34. static String getNewLineSplittedString(const String& string)

  35. {

  36.     static const int kLineWidth = 120;

  37. 

  38.     int i=0;

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

  40. 

  41.     String newString;

  42.     newString.preallocateBytes(static_cast<size_t>(length + length/120 + 2));

  43. 

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

  45.     {

  46.         newString += string.substring(i, i+kLineWidth);

  47.         newString += "\n";

  48.     }

  49. 

  50.     newString += string.substring(i);

  51. 

  52.     return newString;

  53. }

  54. 

  55. // -----------------------------------------------------------------------

  56. // xmlSafeStringFast

  57. 

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

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

  60. 

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

  62. {

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

  64.     std::string retval;

  65. 

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

  67.     {

  68.         retval.append(current, next);

  69.         retval.append(after);

  70.         current = next + static_cast<std::ssize_t>(before.size());

  71.     }

  72.     retval.append(current, next);

  73.     return retval;

  74. }

  75. 

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

  77. {

  78.     std::string string(cstring);

  79. 

  80.     if (toXml)

  81.     {

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

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

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

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

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

  87.     }

  88.     else

  89.     {

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

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

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

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

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

  95.     }

  96. 

  97.     return string;

  98. }

  99. 

  100. // -----------------------------------------------------------------------

  101. // xmlSafeStringCharDup

  102. 

  103. /*

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

  105. {

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

  107. }

  108. */

  109. 

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

  111. {

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

  113. }

  114. 

  115. // -----------------------------------------------------------------------

  116. // StateParameter

  117. 

  118. CarlaStateSave::Parameter::Parameter() noexcept

  119.     : dummy(true),

  120.       index(-1),

  121.       name(nullptr),

  122.       symbol(nullptr),

  123. #ifndef BUILD_BRIDGE

  124.       value(0.0f),

  125.       midiChannel(0),

  126.       midiCC(-1) {}

  127. #else

  128.       value(0.0f) {}

  129. #endif

  130. 

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

  132. {

  133.     if (name != nullptr)

  134.     {

  135.         delete[] name;

  136.         name = nullptr;

  137.     }

  138.     if (symbol != nullptr)

  139.     {

  140.         delete[] symbol;

  141.         symbol = nullptr;

  142.     }

  143. }

  144. 

  145. // -----------------------------------------------------------------------

  146. // StateCustomData

  147. 

  148. CarlaStateSave::CustomData::CustomData() noexcept

  149.     : type(nullptr),

  150.       key(nullptr),

  151.       value(nullptr) {}

  152. 

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

  154. {

  155.     if (type != nullptr)

  156.     {

  157.         delete[] type;

  158.         type = nullptr;

  159.     }

  160.     if (key != nullptr)

  161.     {

  162.         delete[] key;

  163.         key = nullptr;

  164.     }

  165.     if (value != nullptr)

  166.     {

  167.         delete[] value;

  168.         value = nullptr;

  169.     }

  170. }

  171. 

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

  173. {

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

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

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

  177.     return true;

  178. }

  179. 

  180. // -----------------------------------------------------------------------

  181. // StateSave

  182. 

  183. CarlaStateSave::CarlaStateSave() noexcept

  184.     : type(nullptr),

  185.       name(nullptr),

  186.       label(nullptr),

  187.       binary(nullptr),

  188.       uniqueId(0),

  189.       options(0x0),

  190. #ifndef BUILD_BRIDGE

  191.       active(false),

  192.       dryWet(1.0f),

  193.       volume(1.0f),

  194.       balanceLeft(-1.0f),

  195.       balanceRight(1.0f),

  196.       panning(0.0f),

  197.       ctrlChannel(-1),

  198. #endif

  199.       currentProgramIndex(-1),

  200.       currentProgramName(nullptr),

  201.       currentMidiBank(-1),

  202.       currentMidiProgram(-1),

  203.       chunk(nullptr),

  204.       parameters(),

  205.       customData() {}

  206. 

  207. CarlaStateSave::~CarlaStateSave() noexcept

  208. {

  209.     clear();

  210. }

  211. 

  212. void CarlaStateSave::clear() noexcept

  213. {

  214.     if (type != nullptr)

  215.     {

  216.         delete[] type;

  217.         type = nullptr;

  218.     }

  219.     if (name != nullptr)

  220.     {

  221.         delete[] name;

  222.         name = nullptr;

  223.     }

  224.     if (label != nullptr)

  225.     {

  226.         delete[] label;

  227.         label = nullptr;

  228.     }

  229.     if (binary != nullptr)

  230.     {

  231.         delete[] binary;

  232.         binary = nullptr;

  233.     }

  234.     if (currentProgramName != nullptr)

  235.     {

  236.         delete[] currentProgramName;

  237.         currentProgramName = nullptr;

  238.     }

  239.     if (chunk != nullptr)

  240.     {

  241.         delete[] chunk;

  242.         chunk = nullptr;

  243.     }

  244. 

  245.     uniqueId = 0;

  246.     options  = 0x0;

  247. 

  248. #ifndef BUILD_BRIDGE

  249.     active = false;

  250.     dryWet = 1.0f;

  251.     volume = 1.0f;

  252.     balanceLeft  = -1.0f;

  253.     balanceRight = 1.0f;

  254.     panning      = 0.0f;

  255.     ctrlChannel  = -1;

  256. #endif

  257. 

  258.     currentProgramIndex = -1;

  259.     currentMidiBank     = -1;

  260.     currentMidiProgram  = -1;

  261. 

  262.     for (ParameterItenerator it = parameters.begin(); it.valid(); it.next())

  263.     {

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

  265.         delete stateParameter;

  266.     }

  267. 

  268.     for (CustomDataItenerator it = customData.begin(); it.valid(); it.next())

  269.     {

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

  271.         delete stateCustomData;

  272.     }

  273. 

  274.     parameters.clear();

  275.     customData.clear();

  276. }

  277. 

  278. // -----------------------------------------------------------------------

  279. // fillFromXmlElement

  280. 

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

  282. {

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

  284. 

  285.     clear();

  286. 

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

  288.     {

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

  290. 

  291.         // ---------------------------------------------------------------

  292.         // Info

  293. 

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

  295.         {

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

  297.             {

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

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

  300. 

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

  302.                     type = xmlSafeStringCharDup(text, false);

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

  304.                     name = xmlSafeStringCharDup(text, false);

  305.                 else if (tag.equalsIgnoreCase("label") || tag.equalsIgnoreCase("identifier") || tag.equalsIgnoreCase("uri"))

  306.                     label = xmlSafeStringCharDup(text, false);

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

  308.                     binary = xmlSafeStringCharDup(text, false);

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

  310.                     uniqueId = text.getLargeIntValue();

  311.             }

  312.         }

  313. 

  314.         // ---------------------------------------------------------------

  315.         // Data

  316. 

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

  318.         {

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

  320.             {

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

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

  323. 

  324. #ifndef BUILD_BRIDGE

  325.                 // -------------------------------------------------------

  326.                 // Internal Data

  327. 

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

  329.                 {

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

  331.                 }

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

  333.                 {

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

  335.                 }

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

  337.                 {

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

  339.                 }

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

  341.                 {

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

  343.                 }

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

  345.                 {

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

  347.                 }

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

  349.                 {

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

  351.                 }

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

  353.                 {

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

  355.                     {

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

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

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

  359.                     }

  360.                 }

  361.                 else if (tag.equalsIgnoreCase("options"))

  362.                 {

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

  364.                     if (value > 0)

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

  366.                 }

  367. #else

  368.                 if (false) {}

  369. #endif

  370. 

  371.                 // -------------------------------------------------------

  372.                 // Program (current)

  373. 

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

  375.                 {

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

  377.                     if (value >= 1)

  378.                         currentProgramIndex = value-1;

  379.                 }

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

  381.                 {

  382.                     currentProgramName = xmlSafeStringCharDup(text, false);

  383.                 }

  384. 

  385.                 // -------------------------------------------------------

  386.                 // Midi Program (current)

  387. 

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

  389.                 {

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

  391.                     if (value >= 1)

  392.                         currentMidiBank = value-1;

  393.                 }

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

  395.                 {

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

  397.                     if (value >= 1)

  398.                         currentMidiProgram = value-1;

  399.                 }

  400. 

  401.                 // -------------------------------------------------------

  402.                 // Parameters

  403. 

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

  405.                 {

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

  407. 

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

  409.                     {

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

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

  412. 

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

  414.                         {

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

  416.                             if (index >= 0)

  417.                                 stateParameter->index = index;

  418.                         }

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

  420.                         {

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

  422.                         }

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

  424.                         {

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

  426.                         }

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

  428.                         {

  429.                             stateParameter->dummy = false;

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

  431.                         }

  432. #ifndef BUILD_BRIDGE

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

  434.                         {

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

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

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

  438.                         }

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

  440.                         {

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

  442.                             if (cc >= -1 && cc < MAX_MIDI_CONTROL)

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

  444.                         }

  445. #endif

  446.                     }

  447. 

  448.                     parameters.append(stateParameter);

  449.                 }

  450. 

  451.                 // -------------------------------------------------------

  452.                 // Custom Data

  453. 

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

  455.                 {

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

  457. 

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

  459.                     {

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

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

  462. 

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

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

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

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

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

  468.                             stateCustomData->value = carla_strdup(cText.toRawUTF8()); //xmlSafeStringCharDup(cText, false);

  469.                     }

  470. 

  471.                     if (stateCustomData->isValid())

  472.                         customData.append(stateCustomData);

  473.                     else

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

  475.                 }

  476. 

  477.                 // -------------------------------------------------------

  478.                 // Chunk

  479. 

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

  481.                 {

  482.                     const String nText(text.replace("\n", ""));

  483.                     chunk = xmlSafeStringCharDup(nText, false);

  484.                 }

  485.             }

  486.         }

  487.     }

  488. 

  489.     return true;

  490. }

  491. 

  492. // -----------------------------------------------------------------------

  493. // fillXmlStringFromStateSave

  494. 

  495. String CarlaStateSave::toString() const

  496. {

  497.     String content;

  498. 

  499.     {

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

  501. 

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

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

  504. 

  505.         switch (getPluginTypeFromString(type))

  506.         {

  507.         case PLUGIN_NONE:

  508.             break;

  509.         case PLUGIN_INTERNAL:

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

  511.             break;

  512.         case PLUGIN_LADSPA:

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

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

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

  516.             break;

  517.         case PLUGIN_DSSI:

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

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

  520.             break;

  521.         case PLUGIN_LV2:

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

  523.             break;

  524.         case PLUGIN_VST2:

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

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

  527.             break;

  528.         case PLUGIN_VST3:

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

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

  531.             break;

  532.         case PLUGIN_AU:

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

  534.             break;

  535.         case PLUGIN_GIG:

  536.         case PLUGIN_SF2:

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

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

  539.             break;

  540.         case PLUGIN_SFZ:

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

  542.             break;

  543.         }

  544. 

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

  546. 

  547.         content << infoXml;

  548.     }

  549. 

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

  551. 

  552. #ifndef BUILD_BRIDGE

  553.     {

  554.         String dataXml;

  555. 

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

  557. 

  558.         if (! carla_compareFloats(dryWet, 1.0f))

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

  560.         if (! carla_compareFloats(volume, 1.0f))

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

  562.         if (! carla_compareFloats(balanceLeft, -1.0f))

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

  564.         if (! carla_compareFloats(balanceRight, 1.0f))

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

  566.         if (! carla_compareFloats(panning, 0.0f))

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

  568. 

  569.         if (ctrlChannel < 0)

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

  571.         else

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

  573. 

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

  575. 

  576.         content << dataXml;

  577.     }

  578. #endif

  579. 

  580.     for (ParameterItenerator it = parameters.begin(); it.valid(); it.next())

  581.     {

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

  583.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  584. 

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

  586. 

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

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

  589. 

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

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

  592. 

  593. #ifndef BUILD_BRIDGE

  594.         if (stateParameter->midiCC > 0)

  595.         {

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

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

  598.         }

  599. #endif

  600. 

  601.         if (! stateParameter->dummy)

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

  603. 

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

  605. 

  606.         content << parameterXml;

  607.     }

  608. 

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

  610.     {

  611.         // ignore 'default' program

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

  613.         {

  614.             String programXml("\n");

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

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

  617. 

  618.             content << programXml;

  619.         }

  620.     }

  621. 

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

  623.     {

  624.         String midiProgramXml("\n");

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

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

  627. 

  628.         content << midiProgramXml;

  629.     }

  630. 

  631.     for (CustomDataItenerator it = customData.begin(); it.valid(); it.next())

  632.     {

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

  634.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  636. 

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

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

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

  640. 

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

  642.         {

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

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

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

  646.         }

  647.         else

  648.         {

  649.             customDataXml << "    <Value>";

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

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

  652.         }

  653. 

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

  655. 

  656.         content << customDataXml;

  657.     }

  658. 

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

  660.     {

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

  662.         chunkXml << getNewLineSplittedString(chunk) << "\n   </Chunk>\n";

  663. 

  664.         content << chunkXml;

  665.     }

  666. 

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

  668. 

  669.     return content;

  670. }

  671. 

  672. // -----------------------------------------------------------------------

  673. 

  674. CARLA_BACKEND_END_NAMESPACE