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

605 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.       value(0.0f),

  84.       midiChannel(0),

  85.       midiCC(-1) {}

  86. 

  87. StateParameter::~StateParameter() noexcept

  88. {

  89.     if (name != nullptr)

  90.     {

  91.         delete[] name;

  92.         name = nullptr;

  93.     }

  94.     if (symbol != nullptr)

  95.     {

  96.         delete[] symbol;

  97.         symbol = nullptr;

  98.     }

  99. }

  100. 

  101. // -----------------------------------------------------------------------

  102. // StateCustomData

  103. 

  104. StateCustomData::StateCustomData() noexcept

  105.     : type(nullptr),

  106.       key(nullptr),

  107.       value(nullptr) {}

  108. 

  109. StateCustomData::~StateCustomData() noexcept

  110. {

  111.     if (type != nullptr)

  112.     {

  113.         delete[] type;

  114.         type = nullptr;

  115.     }

  116.     if (key != nullptr)

  117.     {

  118.         delete[] key;

  119.         key = nullptr;

  120.     }

  121.     if (value != nullptr)

  122.     {

  123.         delete[] value;

  124.         value = nullptr;

  125.     }

  126. }

  127. 

  128. // -----------------------------------------------------------------------

  129. // StateSave

  130. 

  131. StateSave::StateSave() noexcept

  132.     : type(nullptr),

  133.       name(nullptr),

  134.       label(nullptr),

  135.       binary(nullptr),

  136.       uniqueId(0),

  137.       active(false),

  138.       dryWet(1.0f),

  139.       volume(1.0f),

  140.       balanceLeft(-1.0f),

  141.       balanceRight(1.0f),

  142.       panning(0.0f),

  143.       ctrlChannel(-1),

  144.       options(0x0),

  145.       currentProgramIndex(-1),

  146.       currentProgramName(nullptr),

  147.       currentMidiBank(-1),

  148.       currentMidiProgram(-1),

  149.       chunk(nullptr) {}

  150. 

  151. StateSave::~StateSave() noexcept

  152. {

  153.     clear();

  154. }

  155. 

  156. void StateSave::clear() noexcept

  157. {

  158.     if (type != nullptr)

  159.     {

  160.         delete[] type;

  161.         type = nullptr;

  162.     }

  163.     if (name != nullptr)

  164.     {

  165.         delete[] name;

  166.         name = nullptr;

  167.     }

  168.     if (label != nullptr)

  169.     {

  170.         delete[] label;

  171.         label = nullptr;

  172.     }

  173.     if (binary != nullptr)

  174.     {

  175.         delete[] binary;

  176.         binary = nullptr;

  177.     }

  178.     if (currentProgramName != nullptr)

  179.     {

  180.         delete[] currentProgramName;

  181.         currentProgramName = nullptr;

  182.     }

  183.     if (chunk != nullptr)

  184.     {

  185.         delete[] chunk;

  186.         chunk = nullptr;

  187.     }

  188. 

  189.     uniqueId = 0;

  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.     options      = 0x0;

  198.     currentProgramIndex = -1;

  199.     currentMidiBank     = -1;

  200.     currentMidiProgram  = -1;

  201. 

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

  203.     {

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

  205.         delete stateParameter;

  206.     }

  207. 

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

  209.     {

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

  211.         delete stateCustomData;

  212.     }

  213. 

  214.     parameters.clear();

  215.     customData.clear();

  216. }

  217. 

  218. // -----------------------------------------------------------------------

  219. // fillFromXmlElement

  220. 

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

  222. {

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

  224. 

  225.     clear();

  226. 

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

  228.     {

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

  230. 

  231.         // ---------------------------------------------------------------

  232.         // Info

  233. 

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

  235.         {

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

  237.             {

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

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

  240. 

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

  242.                     type = xmlSafeStringCharDup(text, false);

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

  244.                     name = xmlSafeStringCharDup(text, false);

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

  246.                     label = xmlSafeStringCharDup(text, false);

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

  248.                     binary = xmlSafeStringCharDup(text, false);

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

  250.                     uniqueId = text.getLargeIntValue();

  251.             }

  252.         }

  253. 

  254.         // ---------------------------------------------------------------

  255.         // Data

  256. 

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

  258.         {

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

  260.             {

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

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

  263. 

  264.                 // -------------------------------------------------------

  265.                 // Internal Data

  266. 

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

  268.                 {

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

  270.                 }

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

  272.                 {

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

  274.                 }

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

  276.                 {

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

  278.                 }

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

  280.                 {

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

  282.                 }

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

  284.                 {

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

  286.                 }

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

  288.                 {

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

  290.                 }

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

  292.                 {

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

  294.                     {

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

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

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

  298.                     }

  299.                 }

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

  301.                 {

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

  303.                     if (value > 0)

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

  305.                 }

  306. 

  307.                 // -------------------------------------------------------

  308.                 // Program (current)

  309. 

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

  311.                 {

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

  313.                     if (value >= 1)

  314.                         currentProgramIndex = value-1;

  315.                 }

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

  317.                 {

  318.                     currentProgramName = xmlSafeStringCharDup(text, false);

  319.                 }

  320. 

  321.                 // -------------------------------------------------------

  322.                 // Midi Program (current)

  323. 

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

  325.                 {

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

  327.                     if (value >= 1)

  328.                         currentMidiBank = value-1;

  329.                 }

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

  331.                 {

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

  333.                     if (value >= 1)

  334.                         currentMidiProgram = value-1;

  335.                 }

  336. 

  337.                 // -------------------------------------------------------

  338.                 // Parameters

  339. 

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

  341.                 {

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

  343. 

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

  345.                     {

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

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

  348. 

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

  350.                         {

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

  352.                             if (index >= 0)

  353.                                 stateParameter->index = index;

  354.                         }

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

  356.                         {

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

  358.                         }

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

  360.                         {

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

  362.                         }

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

  364.                         {

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

  366.                         }

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

  368.                         {

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

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

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

  372.                         }

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

  374.                         {

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

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

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

  378.                         }

  379.                     }

  380. 

  381.                     parameters.append(stateParameter);

  382.                 }

  383. 

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

  385.                 // Custom Data

  386. 

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

  388.                 {

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

  390. 

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

  392.                     {

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

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

  395. 

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

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

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

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

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

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

  402.                     }

  403. 

  404.                     customData.append(stateCustomData);

  405.                 }

  406. 

  407.                 // -------------------------------------------------------

  408.                 // Chunk

  409. 

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

  411.                 {

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

  413.                     chunk = xmlSafeStringCharDup(nText, false);

  414.                 }

  415.             }

  416.         }

  417.     }

  418. 

  419.     return true;

  420. }

  421. 

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

  423. // fillXmlStringFromStateSave

  424. 

  425. String StateSave::toString() const

  426. {

  427.     String content;

  428. 

  429.     {

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

  431. 

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

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

  434. 

  435.         switch (getPluginTypeFromString(type))

  436.         {

  437.         case PLUGIN_NONE:

  438.             break;

  439.         case PLUGIN_INTERNAL:

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

  441.             break;

  442.         case PLUGIN_LADSPA:

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

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

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

  446.             break;

  447.         case PLUGIN_DSSI:

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

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

  450.             break;

  451.         case PLUGIN_LV2:

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

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

  454.             break;

  455.         case PLUGIN_VST:

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

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

  458.             break;

  459.         case PLUGIN_VST3:

  460.             // TODO?

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

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

  463.             break;

  464.         case PLUGIN_AU:

  465.             // TODO?

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

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

  468.             break;

  469.         case PLUGIN_GIG:

  470.         case PLUGIN_SF2:

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

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

  473.             break;

  474.         case PLUGIN_SFZ:

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

  476.             break;

  477.         }

  478. 

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

  480. 

  481.         content << infoXml;

  482.     }

  483. 

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

  485. 

  486.     {

  487.         String dataXml;

  488. 

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

  490. 

  491.         if (dryWet != 1.0f)

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

  493.         if (volume != 1.0f)

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

  495.         if (balanceLeft != -1.0f)

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

  497.         if (balanceRight != 1.0f)

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

  499.         if (panning != 0.0f)

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

  501. 

  502.         if (ctrlChannel < 0)

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

  504.         else

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

  506. 

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

  508. 

  509.         content << dataXml;

  510.     }

  511. 

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

  513.     {

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

  515. 

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

  517. 

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

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

  520. 

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

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

  523. 

  524.         if (stateParameter->isInput)

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

  526. 

  527.         if (stateParameter->midiCC > 0)

  528.         {

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

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

  531.         }

  532. 

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

  534. 

  535.         content << parameterXml;

  536.     }

  537. 

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

  539.     {

  540.         // ignore 'default' program

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

  542.         {

  543.             String programXml("\n");

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

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

  546. 

  547.             content << programXml;

  548.         }

  549.     }

  550. 

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

  552.     {

  553.         String midiProgramXml("\n");

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

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

  556. 

  557.         content << midiProgramXml;

  558.     }

  559. 

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

  561.     {

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

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

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

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

  566. 

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

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

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

  570. 

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

  572.         {

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

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

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

  576.         }

  577.         else

  578.         {

  579.             customDataXml << "    <Value>";

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

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

  582.         }

  583. 

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

  585. 

  586.         content << customDataXml;

  587.     }

  588. 

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

  590.     {

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

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

  593. 

  594.         content << chunkXml;

  595.     }

  596. 

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

  598. 

  599.     return content;

  600. }

  601. 

  602. // -----------------------------------------------------------------------

  603. 

  604. CARLA_BACKEND_END_NAMESPACE