falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
1991 Commits
17 Branches
263MB
Tree: ab2db68741
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ab2db68741'
${ noResults }
Carla/source/utils/CarlaStateUtils.cpp

603 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.                     options = text.getHexValue32();

  303.                 }

  304. 

  305.                 // -------------------------------------------------------

  306.                 // Program (current)

  307. 

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

  309.                 {

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

  311.                     if (value >= 1)

  312.                         currentProgramIndex = value-1;

  313.                 }

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

  315.                 {

  316.                     currentProgramName = xmlSafeStringCharDup(text, false);

  317.                 }

  318. 

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

  320.                 // Midi Program (current)

  321. 

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

  323.                 {

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

  325.                     if (value >= 1)

  326.                         currentMidiBank = value-1;

  327.                 }

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

  329.                 {

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

  331.                     if (value >= 1)

  332.                         currentMidiProgram = value-1;

  333.                 }

  334. 

  335.                 // -------------------------------------------------------

  336.                 // Parameters

  337. 

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

  339.                 {

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

  341. 

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

  343.                     {

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

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

  346. 

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

  348.                         {

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

  350.                             if (index >= 0)

  351.                                 stateParameter->index = index;

  352.                         }

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

  354.                         {

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

  356.                         }

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

  358.                         {

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

  360.                         }

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

  362.                         {

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

  364.                         }

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

  366.                         {

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

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

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

  370.                         }

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

  372.                         {

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

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

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

  376.                         }

  377.                     }

  378. 

  379.                     parameters.append(stateParameter);

  380.                 }

  381. 

  382.                 // -------------------------------------------------------

  383.                 // Custom Data

  384. 

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

  386.                 {

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

  388. 

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

  390.                     {

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

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

  393. 

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

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

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

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

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

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

  400.                     }

  401. 

  402.                     customData.append(stateCustomData);

  403.                 }

  404. 

  405.                 // -------------------------------------------------------

  406.                 // Chunk

  407. 

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

  409.                 {

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

  411.                     chunk = xmlSafeStringCharDup(nText, false);

  412.                 }

  413.             }

  414.         }

  415.     }

  416. 

  417.     return true;

  418. }

  419. 

  420. // -----------------------------------------------------------------------

  421. // fillXmlStringFromStateSave

  422. 

  423. String StateSave::toString() const

  424. {

  425.     String content;

  426. 

  427.     {

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

  429. 

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

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

  432. 

  433.         switch (getPluginTypeFromString(type))

  434.         {

  435.         case PLUGIN_NONE:

  436.             break;

  437.         case PLUGIN_INTERNAL:

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

  439.             break;

  440.         case PLUGIN_LADSPA:

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

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

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

  444.             break;

  445.         case PLUGIN_DSSI:

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

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

  448.             break;

  449.         case PLUGIN_LV2:

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

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

  452.             break;

  453.         case PLUGIN_VST:

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

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

  456.             break;

  457.         case PLUGIN_VST3:

  458.             // TODO?

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

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

  461.             break;

  462.         case PLUGIN_AU:

  463.             // TODO?

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

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

  466.             break;

  467.         case PLUGIN_GIG:

  468.         case PLUGIN_SF2:

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

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

  471.             break;

  472.         case PLUGIN_SFZ:

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

  474.             break;

  475.         }

  476. 

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

  478. 

  479.         content << infoXml;

  480.     }

  481. 

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

  483. 

  484.     {

  485.         String dataXml;

  486. 

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

  488. 

  489.         if (dryWet != 1.0f)

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

  491.         if (volume != 1.0f)

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

  493.         if (balanceLeft != -1.0f)

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

  495.         if (balanceRight != 1.0f)

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

  497.         if (panning != 0.0f)

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

  499. 

  500.         if (ctrlChannel < 0)

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

  502.         else

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

  504. 

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

  506. 

  507.         content << dataXml;

  508.     }

  509. 

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

  511.     {

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

  513. 

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

  515. 

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

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

  518. 

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

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

  521. 

  522.         if (stateParameter->isInput)

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

  524. 

  525.         if (stateParameter->midiCC > 0)

  526.         {

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

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

  529.         }

  530. 

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

  532. 

  533.         content << parameterXml;

  534.     }

  535. 

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

  537.     {

  538.         // ignore 'default' program

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

  540.         {

  541.             String programXml("\n");

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

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

  544. 

  545.             content << programXml;

  546.         }

  547.     }

  548. 

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

  550.     {

  551.         String midiProgramXml("\n");

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

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

  554. 

  555.         content << midiProgramXml;

  556.     }

  557. 

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

  559.     {

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

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

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

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

  564. 

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

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

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

  568. 

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

  570.         {

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

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

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

  574.         }

  575.         else

  576.         {

  577.             customDataXml << "    <Value>";

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

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

  580.         }

  581. 

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

  583. 

  584.         content << customDataXml;

  585.     }

  586. 

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

  588.     {

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

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

  591. 

  592.         content << chunkXml;

  593.     }

  594. 

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

  596. 

  597.     return content;

  598. }

  599. 

  600. // -----------------------------------------------------------------------

  601. 

  602. CARLA_BACKEND_END_NAMESPACE