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

683 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 "water/streams/MemoryOutputStream.h"

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

  26. 

  27. #include <string>

  28. 

  29. using water::MemoryOutputStream;

  30. using water::String;

  31. using water::XmlElement;

  32. 

  33. CARLA_BACKEND_START_NAMESPACE

  34. 

  35. // -----------------------------------------------------------------------

  36. // getNewLineSplittedString

  37. 

  38. static void getNewLineSplittedString(MemoryOutputStream& stream, const String& string)

  39. {

  40.     static const int kLineWidth = 120;

  41. 

  42.     int i = 0;

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

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

  45. 

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

  47. 

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

  49.     {

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

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

  52.     }

  53. 

  54.     stream << (raw+i);

  55. }

  56. 

  57. // -----------------------------------------------------------------------

  58. // xmlSafeStringFast

  59. 

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

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

  62. 

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

  64. {

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

  66.     std::string retval;

  67. 

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

  69.     {

  70.         retval.append(current, next);

  71.         retval.append(after);

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

  73.     }

  74.     retval.append(current, next);

  75.     return retval;

  76. }

  77. 

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

  79. {

  80.     std::string string(cstring);

  81. 

  82.     if (toXml)

  83.     {

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

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

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

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

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

  89.     }

  90.     else

  91.     {

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

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

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

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

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

  97.     }

  98. 

  99.     return string;

  100. }

  101. 

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

  103. // xmlSafeStringCharDup

  104. 

  105. /*

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

  107. {

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

  109. }

  110. */

  111. 

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

  113. {

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

  115. }

  116. 

  117. // -----------------------------------------------------------------------

  118. // StateParameter

  119. 

  120. CarlaStateSave::Parameter::Parameter() noexcept

  121.     : dummy(true),

  122.       index(-1),

  123.       name(nullptr),

  124.       symbol(nullptr),

  125. #ifndef BUILD_BRIDGE

  126.       value(0.0f),

  127.       midiChannel(0),

  128.       midiCC(-1) {}

  129. #else

  130.       value(0.0f) {}

  131. #endif

  132. 

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

  134. {

  135.     if (name != nullptr)

  136.     {

  137.         delete[] name;

  138.         name = nullptr;

  139.     }

  140.     if (symbol != nullptr)

  141.     {

  142.         delete[] symbol;

  143.         symbol = nullptr;

  144.     }

  145. }

  146. 

  147. // -----------------------------------------------------------------------

  148. // StateCustomData

  149. 

  150. CarlaStateSave::CustomData::CustomData() noexcept

  151.     : type(nullptr),

  152.       key(nullptr),

  153.       value(nullptr) {}

  154. 

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

  156. {

  157.     if (type != nullptr)

  158.     {

  159.         delete[] type;

  160.         type = nullptr;

  161.     }

  162.     if (key != nullptr)

  163.     {

  164.         delete[] key;

  165.         key = nullptr;

  166.     }

  167.     if (value != nullptr)

  168.     {

  169.         delete[] value;

  170.         value = nullptr;

  171.     }

  172. }

  173. 

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

  175. {

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

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

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

  179.     return true;

  180. }

  181. 

  182. // -----------------------------------------------------------------------

  183. // StateSave

  184. 

  185. CarlaStateSave::CarlaStateSave() noexcept

  186.     : type(nullptr),

  187.       name(nullptr),

  188.       label(nullptr),

  189.       binary(nullptr),

  190.       uniqueId(0),

  191.       options(0x0),

  192. #ifndef BUILD_BRIDGE

  193.       active(false),

  194.       dryWet(1.0f),

  195.       volume(1.0f),

  196.       balanceLeft(-1.0f),

  197.       balanceRight(1.0f),

  198.       panning(0.0f),

  199.       ctrlChannel(-1),

  200. #endif

  201.       currentProgramIndex(-1),

  202.       currentProgramName(nullptr),

  203.       currentMidiBank(-1),

  204.       currentMidiProgram(-1),

  205.       chunk(nullptr),

  206.       parameters(),

  207.       customData() {}

  208. 

  209. CarlaStateSave::~CarlaStateSave() noexcept

  210. {

  211.     clear();

  212. }

  213. 

  214. void CarlaStateSave::clear() noexcept

  215. {

  216.     if (type != nullptr)

  217.     {

  218.         delete[] type;

  219.         type = nullptr;

  220.     }

  221.     if (name != nullptr)

  222.     {

  223.         delete[] name;

  224.         name = nullptr;

  225.     }

  226.     if (label != nullptr)

  227.     {

  228.         delete[] label;

  229.         label = nullptr;

  230.     }

  231.     if (binary != nullptr)

  232.     {

  233.         delete[] binary;

  234.         binary = nullptr;

  235.     }

  236.     if (currentProgramName != nullptr)

  237.     {

  238.         delete[] currentProgramName;

  239.         currentProgramName = nullptr;

  240.     }

  241.     if (chunk != nullptr)

  242.     {

  243.         delete[] chunk;

  244.         chunk = nullptr;

  245.     }

  246. 

  247.     uniqueId = 0;

  248.     options  = 0x0;

  249. 

  250. #ifndef BUILD_BRIDGE

  251.     active = false;

  252.     dryWet = 1.0f;

  253.     volume = 1.0f;

  254.     balanceLeft  = -1.0f;

  255.     balanceRight = 1.0f;

  256.     panning      = 0.0f;

  257.     ctrlChannel  = -1;

  258. #endif

  259. 

  260.     currentProgramIndex = -1;

  261.     currentMidiBank     = -1;

  262.     currentMidiProgram  = -1;

  263. 

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

  265.     {

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

  267.         delete stateParameter;

  268.     }

  269. 

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

  271.     {

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

  273.         delete stateCustomData;

  274.     }

  275. 

  276.     parameters.clear();

  277.     customData.clear();

  278. }

  279. 

  280. // -----------------------------------------------------------------------

  281. // fillFromXmlElement

  282. 

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

  284. {

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

  286. 

  287.     clear();

  288. 

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

  290.     {

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

  292. 

  293.         // ---------------------------------------------------------------

  294.         // Info

  295. 

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

  297.         {

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

  299.             {

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

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

  302. 

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

  304.                     type = xmlSafeStringCharDup(text, false);

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

  306.                     name = xmlSafeStringCharDup(text, false);

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

  308.                     label = xmlSafeStringCharDup(text, false);

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

  310.                     binary = xmlSafeStringCharDup(text, false);

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

  312.                     uniqueId = text.getLargeIntValue();

  313.             }

  314.         }

  315. 

  316.         // ---------------------------------------------------------------

  317.         // Data

  318. 

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

  320.         {

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

  322.             {

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

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

  325. 

  326. #ifndef BUILD_BRIDGE

  327.                 // -------------------------------------------------------

  328.                 // Internal Data

  329. 

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

  331.                 {

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

  333.                 }

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

  335.                 {

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

  337.                 }

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

  339.                 {

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

  341.                 }

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

  343.                 {

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

  345.                 }

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

  347.                 {

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

  349.                 }

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

  351.                 {

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

  353.                 }

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

  355.                 {

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

  357.                     {

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

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

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

  361.                     }

  362.                 }

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

  364.                 {

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

  366.                     if (value > 0)

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

  368.                 }

  369. #else

  370.                 if (false) {}

  371. #endif

  372. 

  373.                 // -------------------------------------------------------

  374.                 // Program (current)

  375. 

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

  377.                 {

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

  379.                     if (value >= 1)

  380.                         currentProgramIndex = value-1;

  381.                 }

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

  383.                 {

  384.                     currentProgramName = xmlSafeStringCharDup(text, false);

  385.                 }

  386. 

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

  388.                 // Midi Program (current)

  389. 

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

  391.                 {

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

  393.                     if (value >= 1)

  394.                         currentMidiBank = value-1;

  395.                 }

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

  397.                 {

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

  399.                     if (value >= 1)

  400.                         currentMidiProgram = value-1;

  401.                 }

  402. 

  403.                 // -------------------------------------------------------

  404.                 // Parameters

  405. 

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

  407.                 {

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

  409. 

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

  411.                     {

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

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

  414. 

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

  416.                         {

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

  418.                             if (index >= 0)

  419.                                 stateParameter->index = index;

  420.                         }

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

  422.                         {

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

  424.                         }

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

  426.                         {

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

  428.                         }

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

  430.                         {

  431.                             stateParameter->dummy = false;

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

  433.                         }

  434. #ifndef BUILD_BRIDGE

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

  436.                         {

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

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

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

  440.                         }

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

  442.                         {

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

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

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

  446.                         }

  447. #endif

  448.                     }

  449. 

  450.                     parameters.append(stateParameter);

  451.                 }

  452. 

  453.                 // -------------------------------------------------------

  454.                 // Custom Data

  455. 

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

  457.                 {

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

  459. 

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

  461.                     {

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

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

  464. 

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

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

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

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

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

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

  471.                     }

  472. 

  473.                     if (stateCustomData->isValid())

  474.                         customData.append(stateCustomData);

  475.                     else

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

  477.                 }

  478. 

  479.                 // -------------------------------------------------------

  480.                 // Chunk

  481. 

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

  483.                 {

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

  485.                 }

  486.             }

  487.         }

  488.     }

  489. 

  490.     return true;

  491. }

  492. 

  493. // -----------------------------------------------------------------------

  494. // fillXmlStringFromStateSave

  495. 

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

  497. {

  498.     {

  499.         MemoryOutputStream infoXml;

  500. 

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

  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>" << water::int64(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>" << water::int64(uniqueId)       << "</UniqueID>\n";

  527.             break;

  528.         case PLUGIN_GIG:

  529.         case PLUGIN_SF2:

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

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

  532.             break;

  533.         case PLUGIN_SFZ:

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

  535.             break;

  536.         case PLUGIN_JACK:

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

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

  539.             break;

  540.         }

  541. 

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

  543. 

  544.         content << infoXml;

  545.     }

  546. 

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

  548. 

  549. #ifndef BUILD_BRIDGE

  550.     {

  551.         MemoryOutputStream dataXml;

  552. 

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

  554. 

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

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

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

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

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

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

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

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

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

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

  565. 

  566.         if (ctrlChannel < 0)

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

  568.         else

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

  570. 

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

  572. 

  573.         content << dataXml;

  574.     }

  575. #endif

  576. 

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

  578.     {

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

  580.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  581. 

  582.         MemoryOutputStream parameterXml;

  583. 

  584.         parameterXml << "\n";

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

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

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

  588. 

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

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

  591. 

  592. #ifndef BUILD_BRIDGE

  593.         if (stateParameter->midiCC > 0)

  594.         {

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

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

  597.         }

  598. #endif

  599. 

  600.         if (! stateParameter->dummy)

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

  602. 

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

  604. 

  605.         content << parameterXml;

  606.     }

  607. 

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

  609.     {

  610.         // ignore 'default' program

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

  612.         {

  613.             MemoryOutputStream programXml;

  614. 

  615.             programXml << "\n";

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

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

  618. 

  619.             content << programXml;

  620.         }

  621.     }

  622. 

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

  624.     {

  625.         MemoryOutputStream midiProgramXml;

  626. 

  627.         midiProgramXml << "\n";

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

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

  630. 

  631.         content << midiProgramXml;

  632.     }

  633. 

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

  635.     {

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

  637.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  639. 

  640.         MemoryOutputStream customDataXml;

  641. 

  642.         customDataXml << "\n";

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

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

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

  646. 

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

  648.         {

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

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

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

  652.         }

  653.         else

  654.         {

  655.             customDataXml << "    <Value>";

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

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

  658.         }

  659. 

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

  661. 

  662.         content << customDataXml;

  663.     }

  664. 

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

  666.     {

  667.         MemoryOutputStream chunkXml, chunkSplt;

  668.         getNewLineSplittedString(chunkSplt, chunk);

  669. 

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

  671.         chunkXml << chunkSplt;

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

  673. 

  674.         content << chunkXml;

  675.     }

  676. 

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

  678. }

  679. 

  680. // -----------------------------------------------------------------------

  681. 

  682. CARLA_BACKEND_END_NAMESPACE