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

686 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::MemoryOutputStream;

  27. using juce::String;

  28. using juce::XmlElement;

  29. 

  30. CARLA_BACKEND_START_NAMESPACE

  31. 

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

  33. // getNewLineSplittedString

  34. 

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

  36. {

  37.     static const int kLineWidth = 120;

  38. 

  39.     int i = 0;

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

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

  42. 

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

  44. 

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

  46.     {

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

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

  49.     }

  50. 

  51.     stream << (raw+i);

  52. }

  53. 

  54. // -----------------------------------------------------------------------

  55. // xmlSafeStringFast

  56. 

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

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

  59. 

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

  61. {

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

  63.     std::string retval;

  64. 

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

  66.     {

  67.         retval.append(current, next);

  68.         retval.append(after);

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

  70.     }

  71.     retval.append(current, next);

  72.     return retval;

  73. }

  74. 

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

  76. {

  77.     std::string string(cstring);

  78. 

  79.     if (toXml)

  80.     {

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

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

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

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

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

  86.     }

  87.     else

  88.     {

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

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

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

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

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

  94.     }

  95. 

  96.     return string;

  97. }

  98. 

  99. // -----------------------------------------------------------------------

  100. // xmlSafeStringCharDup

  101. 

  102. /*

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

  104. {

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

  106. }

  107. */

  108. 

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

  110. {

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

  112. }

  113. 

  114. // -----------------------------------------------------------------------

  115. // StateParameter

  116. 

  117. CarlaStateSave::Parameter::Parameter() noexcept

  118.     : dummy(true),

  119.       index(-1),

  120.       name(nullptr),

  121.       symbol(nullptr),

  122. #ifndef BUILD_BRIDGE

  123.       value(0.0f),

  124.       midiChannel(0),

  125.       midiCC(-1) {}

  126. #else

  127.       value(0.0f) {}

  128. #endif

  129. 

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

  131. {

  132.     if (name != nullptr)

  133.     {

  134.         delete[] name;

  135.         name = nullptr;

  136.     }

  137.     if (symbol != nullptr)

  138.     {

  139.         delete[] symbol;

  140.         symbol = nullptr;

  141.     }

  142. }

  143. 

  144. // -----------------------------------------------------------------------

  145. // StateCustomData

  146. 

  147. CarlaStateSave::CustomData::CustomData() noexcept

  148.     : type(nullptr),

  149.       key(nullptr),

  150.       value(nullptr) {}

  151. 

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

  153. {

  154.     if (type != nullptr)

  155.     {

  156.         delete[] type;

  157.         type = nullptr;

  158.     }

  159.     if (key != nullptr)

  160.     {

  161.         delete[] key;

  162.         key = nullptr;

  163.     }

  164.     if (value != nullptr)

  165.     {

  166.         delete[] value;

  167.         value = nullptr;

  168.     }

  169. }

  170. 

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

  172. {

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

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

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

  176.     return true;

  177. }

  178. 

  179. // -----------------------------------------------------------------------

  180. // StateSave

  181. 

  182. CarlaStateSave::CarlaStateSave() noexcept

  183.     : type(nullptr),

  184.       name(nullptr),

  185.       label(nullptr),

  186.       binary(nullptr),

  187.       uniqueId(0),

  188.       options(0x0),

  189. #ifndef BUILD_BRIDGE

  190.       active(false),

  191.       dryWet(1.0f),

  192.       volume(1.0f),

  193.       balanceLeft(-1.0f),

  194.       balanceRight(1.0f),

  195.       panning(0.0f),

  196.       ctrlChannel(-1),

  197. #endif

  198.       currentProgramIndex(-1),

  199.       currentProgramName(nullptr),

  200.       currentMidiBank(-1),

  201.       currentMidiProgram(-1),

  202.       chunk(nullptr),

  203.       parameters(),

  204.       customData() {}

  205. 

  206. CarlaStateSave::~CarlaStateSave() noexcept

  207. {

  208.     clear();

  209. }

  210. 

  211. void CarlaStateSave::clear() noexcept

  212. {

  213.     if (type != nullptr)

  214.     {

  215.         delete[] type;

  216.         type = nullptr;

  217.     }

  218.     if (name != nullptr)

  219.     {

  220.         delete[] name;

  221.         name = nullptr;

  222.     }

  223.     if (label != nullptr)

  224.     {

  225.         delete[] label;

  226.         label = nullptr;

  227.     }

  228.     if (binary != nullptr)

  229.     {

  230.         delete[] binary;

  231.         binary = nullptr;

  232.     }

  233.     if (currentProgramName != nullptr)

  234.     {

  235.         delete[] currentProgramName;

  236.         currentProgramName = nullptr;

  237.     }

  238.     if (chunk != nullptr)

  239.     {

  240.         delete[] chunk;

  241.         chunk = nullptr;

  242.     }

  243. 

  244.     uniqueId = 0;

  245.     options  = 0x0;

  246. 

  247. #ifndef BUILD_BRIDGE

  248.     active = false;

  249.     dryWet = 1.0f;

  250.     volume = 1.0f;

  251.     balanceLeft  = -1.0f;

  252.     balanceRight = 1.0f;

  253.     panning      = 0.0f;

  254.     ctrlChannel  = -1;

  255. #endif

  256. 

  257.     currentProgramIndex = -1;

  258.     currentMidiBank     = -1;

  259.     currentMidiProgram  = -1;

  260. 

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

  262.     {

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

  264.         delete stateParameter;

  265.     }

  266. 

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

  268.     {

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

  270.         delete stateCustomData;

  271.     }

  272. 

  273.     parameters.clear();

  274.     customData.clear();

  275. }

  276. 

  277. // -----------------------------------------------------------------------

  278. // fillFromXmlElement

  279. 

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

  281. {

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

  283. 

  284.     clear();

  285. 

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

  287.     {

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

  289. 

  290.         // ---------------------------------------------------------------

  291.         // Info

  292. 

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

  294.         {

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

  296.             {

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

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

  299. 

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

  301.                     type = xmlSafeStringCharDup(text, false);

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

  303.                     name = xmlSafeStringCharDup(text, false);

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

  305.                     label = xmlSafeStringCharDup(text, false);

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

  307.                     binary = xmlSafeStringCharDup(text, false);

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

  309.                     uniqueId = text.getLargeIntValue();

  310.             }

  311.         }

  312. 

  313.         // ---------------------------------------------------------------

  314.         // Data

  315. 

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

  317.         {

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

  319.             {

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

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

  322. 

  323. #ifndef BUILD_BRIDGE

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

  325.                 // Internal Data

  326. 

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

  328.                 {

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

  330.                 }

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

  332.                 {

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

  334.                 }

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

  336.                 {

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

  338.                 }

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

  340.                 {

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

  342.                 }

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

  344.                 {

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

  346.                 }

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

  348.                 {

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

  350.                 }

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

  352.                 {

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

  354.                     {

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

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

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

  358.                     }

  359.                 }

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

  361.                 {

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

  363.                     if (value > 0)

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

  365.                 }

  366. #else

  367.                 if (false) {}

  368. #endif

  369. 

  370.                 // -------------------------------------------------------

  371.                 // Program (current)

  372. 

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

  374.                 {

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

  376.                     if (value >= 1)

  377.                         currentProgramIndex = value-1;

  378.                 }

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

  380.                 {

  381.                     currentProgramName = xmlSafeStringCharDup(text, false);

  382.                 }

  383. 

  384.                 // -------------------------------------------------------

  385.                 // Midi Program (current)

  386. 

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

  388.                 {

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

  390.                     if (value >= 1)

  391.                         currentMidiBank = value-1;

  392.                 }

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

  394.                 {

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

  396.                     if (value >= 1)

  397.                         currentMidiProgram = value-1;

  398.                 }

  399. 

  400.                 // -------------------------------------------------------

  401.                 // Parameters

  402. 

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

  404.                 {

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

  406. 

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

  408.                     {

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

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

  411. 

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

  413.                         {

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

  415.                             if (index >= 0)

  416.                                 stateParameter->index = index;

  417.                         }

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

  419.                         {

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

  421.                         }

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

  423.                         {

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

  425.                         }

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

  427.                         {

  428.                             stateParameter->dummy = false;

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

  430.                         }

  431. #ifndef BUILD_BRIDGE

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

  433.                         {

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

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

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

  437.                         }

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

  439.                         {

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

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

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

  443.                         }

  444. #endif

  445.                     }

  446. 

  447.                     parameters.append(stateParameter);

  448.                 }

  449. 

  450.                 // -------------------------------------------------------

  451.                 // Custom Data

  452. 

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

  454.                 {

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

  456. 

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

  458.                     {

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

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

  461. 

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

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

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

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

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

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

  468.                     }

  469. 

  470.                     if (stateCustomData->isValid())

  471.                         customData.append(stateCustomData);

  472.                     else

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

  474.                 }

  475. 

  476.                 // -------------------------------------------------------

  477.                 // Chunk

  478. 

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

  480.                 {

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

  482.                 }

  483.             }

  484.         }

  485.     }

  486. 

  487.     return true;

  488. }

  489. 

  490. // -----------------------------------------------------------------------

  491. // fillXmlStringFromStateSave

  492. 

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

  494. {

  495.     {

  496.         MemoryOutputStream infoXml;

  497. 

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

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

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

  501. 

  502.         switch (getPluginTypeFromString(type))

  503.         {

  504.         case PLUGIN_NONE:

  505.             break;

  506.         case PLUGIN_INTERNAL:

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

  508.             break;

  509.         case PLUGIN_LADSPA:

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

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

  512.             infoXml << "   <UniqueID>" << juce::int64(uniqueId)       << "</UniqueID>\n";

  513.             break;

  514.         case PLUGIN_DSSI:

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

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

  517.             break;

  518.         case PLUGIN_LV2:

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

  520.             break;

  521.         case PLUGIN_VST2:

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

  523.             infoXml << "   <UniqueID>" << juce::int64(uniqueId)       << "</UniqueID>\n";

  524.             break;

  525.         case PLUGIN_VST3:

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

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

  528.             break;

  529.         case PLUGIN_AU:

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

  531.             break;

  532.         case PLUGIN_GIG:

  533.         case PLUGIN_SF2:

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

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

  536.             break;

  537.         case PLUGIN_SFZ:

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

  539.             break;

  540.         case PLUGIN_JACK:

  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.         MemoryOutputStream dataXml;

  555. 

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

  557. 

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

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

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

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

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

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

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

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

  566.         if (carla_isNotEqual(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.begin2(); it.valid(); it.next())

  581.     {

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

  583.         CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);

  584. 

  585.         MemoryOutputStream parameterXml;

  586. 

  587.         parameterXml << "\n";

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

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

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

  591. 

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

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

  594. 

  595. #ifndef BUILD_BRIDGE

  596.         if (stateParameter->midiCC > 0)

  597.         {

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

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

  600.         }

  601. #endif

  602. 

  603.         if (! stateParameter->dummy)

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

  605. 

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

  607. 

  608.         content << parameterXml;

  609.     }

  610. 

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

  612.     {

  613.         // ignore 'default' program

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

  615.         {

  616.             MemoryOutputStream programXml;

  617. 

  618.             programXml << "\n";

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

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

  621. 

  622.             content << programXml;

  623.         }

  624.     }

  625. 

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

  627.     {

  628.         MemoryOutputStream midiProgramXml;

  629. 

  630.         midiProgramXml << "\n";

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

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

  633. 

  634.         content << midiProgramXml;

  635.     }

  636. 

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

  638.     {

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

  640.         CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);

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

  642. 

  643.         MemoryOutputStream customDataXml;

  644. 

  645.         customDataXml << "\n";

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

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

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

  649. 

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

  651.         {

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

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

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

  655.         }

  656.         else

  657.         {

  658.             customDataXml << "    <Value>";

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

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

  661.         }

  662. 

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

  664. 

  665.         content << customDataXml;

  666.     }

  667. 

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

  669.     {

  670.         MemoryOutputStream chunkXml, chunkSplt;

  671.         getNewLineSplittedString(chunkSplt, chunk);

  672. 

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

  674.         chunkXml << chunkSplt;

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

  676. 

  677.         content << chunkXml;

  678.     }

  679. 

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

  681. }

  682. 

  683. // -----------------------------------------------------------------------

  684. 

  685. CARLA_BACKEND_END_NAMESPACE