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

624 lines
21KB
Raw Blame History 

  1. /*

  2.  * Carla State utils

  3.  * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaStateUtils.hpp"

  19. 

  20. #include "CarlaBackendUtils.hpp"

  21. #include "CarlaMathUtils.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "juce_core.h"

  25. using juce::String;

  26. using juce::XmlElement;

  27. 

  28. CARLA_BACKEND_START_NAMESPACE

  29. 

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

  31. // getNewLineSplittedString

  32. 

  33. static String getNewLineSplittedString(const String& string)

  34. {

  35.     static const int kLineWidth = 120;

  36. 

  37.     int i=0;

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

  39. 

  40.     String newString;

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

  42. 

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

  44.     {

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

  46.         newString += "\n";

  47.     }

  48. 

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

  50. 

  51.     return newString;

  52. }

  53. 

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

  55. // xmlSafeString

  56. 

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

  58. {

  59.     String newString(string);

  60. 

  61.     if (toXml)

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

  63.     else

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

  65. }

  66. 

  67. // -----------------------------------------------------------------------

  68. // xmlSafeStringCharDup

  69. 

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

  71. {

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

  73. }

  74. 

  75. // -----------------------------------------------------------------------

  76. // StateParameter

  77. 

  78. StateParameter::StateParameter() noexcept

  79.     : isInput(true),

  80.       index(-1),

  81.       name(nullptr),

  82.       symbol(nullptr),

  83. #ifndef BUILD_BRIDGE

  84.       value(0.0f),

  85.       midiChannel(0),

  86.       midiCC(-1) {}

  87. #else

  88.       value(0.0f) {}

  89. #endif

  90. 

  91. StateParameter::~StateParameter() noexcept

  92. {

  93.     if (name != nullptr)

  94.     {

  95.         delete[] name;

  96.         name = nullptr;

  97.     }

  98.     if (symbol != nullptr)

  99.     {

  100.         delete[] symbol;

  101.         symbol = nullptr;

  102.     }

  103. }

  104. 

  105. // -----------------------------------------------------------------------

  106. // StateCustomData

  107. 

  108. StateCustomData::StateCustomData() noexcept

  109.     : type(nullptr),

  110.       key(nullptr),

  111.       value(nullptr) {}

  112. 

  113. StateCustomData::~StateCustomData() noexcept

  114. {

  115.     if (type != nullptr)

  116.     {

  117.         delete[] type;

  118.         type = nullptr;

  119.     }

  120.     if (key != nullptr)

  121.     {

  122.         delete[] key;

  123.         key = nullptr;

  124.     }

  125.     if (value != nullptr)

  126.     {

  127.         delete[] value;

  128.         value = nullptr;

  129.     }

  130. }

  131. 

  132. // -----------------------------------------------------------------------

  133. // StateSave

  134. 

  135. StateSave::StateSave() noexcept

  136.     : type(nullptr),

  137.       name(nullptr),

  138.       label(nullptr),

  139.       binary(nullptr),

  140.       uniqueId(0),

  141. #ifndef BUILD_BRIDGE

  142.       active(false),

  143.       dryWet(1.0f),

  144.       volume(1.0f),

  145.       balanceLeft(-1.0f),

  146.       balanceRight(1.0f),

  147.       panning(0.0f),

  148.       ctrlChannel(-1),

  149.       options(0x0),

  150. #endif

  151.       currentProgramIndex(-1),

  152.       currentProgramName(nullptr),

  153.       currentMidiBank(-1),

  154.       currentMidiProgram(-1),

  155.       chunk(nullptr) {}

  156. 

  157. StateSave::~StateSave() noexcept

  158. {

  159.     clear();

  160. }

  161. 

  162. void StateSave::clear() noexcept

  163. {

  164.     if (type != nullptr)

  165.     {

  166.         delete[] type;

  167.         type = nullptr;

  168.     }

  169.     if (name != nullptr)

  170.     {

  171.         delete[] name;

  172.         name = nullptr;

  173.     }

  174.     if (label != nullptr)

  175.     {

  176.         delete[] label;

  177.         label = nullptr;

  178.     }

  179.     if (binary != nullptr)

  180.     {

  181.         delete[] binary;

  182.         binary = nullptr;

  183.     }

  184.     if (currentProgramName != nullptr)

  185.     {

  186.         delete[] currentProgramName;

  187.         currentProgramName = nullptr;

  188.     }

  189.     if (chunk != nullptr)

  190.     {

  191.         delete[] chunk;

  192.         chunk = nullptr;

  193.     }

  194. 

  195.     uniqueId = 0;

  196. #ifndef BUILD_BRIDGE

  197.     active = false;

  198.     dryWet = 1.0f;

  199.     volume = 1.0f;

  200.     balanceLeft  = -1.0f;

  201.     balanceRight = 1.0f;

  202.     panning      = 0.0f;

  203.     ctrlChannel  = -1;

  204.     options      = 0x0;

  205. #endif

  206.     currentProgramIndex = -1;

  207.     currentMidiBank     = -1;

  208.     currentMidiProgram  = -1;

  209. 

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

  211.     {

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

  213.         delete stateParameter;

  214.     }

  215. 

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

  217.     {

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

  219.         delete stateCustomData;

  220.     }

  221. 

  222.     parameters.clear();

  223.     customData.clear();

  224. }

  225. 

  226. // -----------------------------------------------------------------------

  227. // fillFromXmlElement

  228. 

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

  230. {

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

  232. 

  233.     clear();

  234. 

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

  236.     {

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

  238. 

  239.         // ---------------------------------------------------------------

  240.         // Info

  241. 

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

  243.         {

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

  245.             {

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

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

  248. 

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

  250.                     type = xmlSafeStringCharDup(text, false);

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

  252.                     name = xmlSafeStringCharDup(text, false);

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

  254.                     label = xmlSafeStringCharDup(text, false);

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

  256.                     binary = xmlSafeStringCharDup(text, false);

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

  258.                     uniqueId = text.getLargeIntValue();

  259.             }

  260.         }

  261. 

  262.         // ---------------------------------------------------------------

  263.         // Data

  264. 

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

  266.         {

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

  268.             {

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

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

  271. 

  272. #ifndef BUILD_BRIDGE

  273.                 // -------------------------------------------------------

  274.                 // Internal Data

  275. 

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

  277.                 {

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

  279.                 }

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

  281.                 {

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

  283.                 }

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

  285.                 {

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

  287.                 }

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

  289.                 {

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

  291.                 }

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

  293.                 {

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

  295.                 }

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

  297.                 {

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

  299.                 }

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

  301.                 {

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

  303.                     {

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

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

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

  307.                     }

  308.                 }

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

  310.                 {

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

  312.                     if (value > 0)

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

  314.                 }

  315. #else

  316.                 if (false) {}

  317. #endif

  318. 

  319.                 // -------------------------------------------------------

  320.                 // Program (current)

  321. 

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

  323.                 {

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

  325.                     if (value >= 1)

  326.                         currentProgramIndex = value-1;

  327.                 }

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

  329.                 {

  330.                     currentProgramName = xmlSafeStringCharDup(text, false);

  331.                 }

  332. 

  333.                 // -------------------------------------------------------

  334.                 // Midi Program (current)

  335. 

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

  337.                 {

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

  339.                     if (value >= 1)

  340.                         currentMidiBank = value-1;

  341.                 }

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

  343.                 {

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

  345.                     if (value >= 1)

  346.                         currentMidiProgram = value-1;

  347.                 }

  348. 

  349.                 // -------------------------------------------------------

  350.                 // Parameters

  351. 

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

  353.                 {

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

  355. 

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

  357.                     {

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

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

  360. 

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

  362.                         {

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

  364.                             if (index >= 0)

  365.                                 stateParameter->index = index;

  366.                         }

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

  368.                         {

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

  370.                         }

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

  372.                         {

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

  374.                         }

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

  376.                         {

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

  378.                         }

  379. 

  380. #ifndef BUILD_BRIDGE

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

  382.                         {

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

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

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

  386.                         }

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

  388.                         {

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

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

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

  392.                         }

  393. #endif

  394.                     }

  395. 

  396.                     parameters.append(stateParameter);

  397.                 }

  398. 

  399.                 // -------------------------------------------------------

  400.                 // Custom Data

  401. 

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

  403.                 {

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

  405. 

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

  407.                     {

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

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

  410. 

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

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

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

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

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

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

  417.                     }

  418. 

  419.                     customData.append(stateCustomData);

  420.                 }

  421. 

  422.                 // -------------------------------------------------------

  423.                 // Chunk

  424. 

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

  426.                 {

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

  428.                     chunk = xmlSafeStringCharDup(nText, false);

  429.                 }

  430.             }

  431.         }

  432.     }

  433. 

  434.     return true;

  435. }

  436. 

  437. // -----------------------------------------------------------------------

  438. // fillXmlStringFromStateSave

  439. 

  440. String StateSave::toString() const

  441. {

  442.     String content;

  443. 

  444.     {

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

  446. 

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

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

  449. 

  450.         switch (getPluginTypeFromString(type))

  451.         {

  452.         case PLUGIN_NONE:

  453.             break;

  454.         case PLUGIN_INTERNAL:

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

  456.             break;

  457.         case PLUGIN_LADSPA:

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

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

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

  461.             break;

  462.         case PLUGIN_DSSI:

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

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

  465.             break;

  466.         case PLUGIN_LV2:

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

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

  469.             break;

  470.         case PLUGIN_VST:

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

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

  473.             break;

  474.         case PLUGIN_VST3:

  475.             // TODO?

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

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

  478.             break;

  479.         case PLUGIN_AU:

  480.             // TODO?

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

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

  483.             break;

  484.         case PLUGIN_GIG:

  485.         case PLUGIN_SF2:

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

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

  488.             break;

  489.         case PLUGIN_SFZ:

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

  491.             break;

  492.         }

  493. 

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

  495. 

  496.         content << infoXml;

  497.     }

  498. 

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

  500. 

  501. #ifndef BUILD_BRIDGE

  502.     {

  503.         String dataXml;

  504. 

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

  506. 

  507.         if (dryWet != 1.0f)

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

  509.         if (volume != 1.0f)

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

  511.         if (balanceLeft != -1.0f)

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

  513.         if (balanceRight != 1.0f)

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

  515.         if (panning != 0.0f)

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

  517. 

  518.         if (ctrlChannel < 0)

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

  520.         else

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

  522. 

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

  524. 

  525.         content << dataXml;

  526.     }

  527. #endif

  528. 

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

  530.     {

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

  532. 

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

  534. 

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

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

  537. 

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

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

  540. 

  541.         if (stateParameter->isInput)

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

  543. 

  544. #ifndef BUILD_BRIDGE

  545.         if (stateParameter->midiCC > 0)

  546.         {

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

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

  549.         }

  550. #endif

  551. 

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

  553. 

  554.         content << parameterXml;

  555.     }

  556. 

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

  558.     {

  559.         // ignore 'default' program

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

  561.         {

  562.             String programXml("\n");

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

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

  565. 

  566.             content << programXml;

  567.         }

  568.     }

  569. 

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

  571.     {

  572.         String midiProgramXml("\n");

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

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

  575. 

  576.         content << midiProgramXml;

  577.     }

  578. 

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

  580.     {

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

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

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

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

  585. 

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

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

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

  589. 

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

  591.         {

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

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

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

  595.         }

  596.         else

  597.         {

  598.             customDataXml << "    <Value>";

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

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

  601.         }

  602. 

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

  604. 

  605.         content << customDataXml;

  606.     }

  607. 

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

  609.     {

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

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

  612. 

  613.         content << chunkXml;

  614.     }

  615. 

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

  617. 

  618.     return content;

  619. }

  620. 

  621. // -----------------------------------------------------------------------

  622. 

  623. CARLA_BACKEND_END_NAMESPACE