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

626 lines
22KB
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.       parameters(),

  157.       customData() {}

  158. 

  159. StateSave::~StateSave() noexcept

  160. {

  161.     clear();

  162. }

  163. 

  164. void StateSave::clear() noexcept

  165. {

  166.     if (type != nullptr)

  167.     {

  168.         delete[] type;

  169.         type = nullptr;

  170.     }

  171.     if (name != nullptr)

  172.     {

  173.         delete[] name;

  174.         name = nullptr;

  175.     }

  176.     if (label != nullptr)

  177.     {

  178.         delete[] label;

  179.         label = nullptr;

  180.     }

  181.     if (binary != nullptr)

  182.     {

  183.         delete[] binary;

  184.         binary = nullptr;

  185.     }

  186.     if (currentProgramName != nullptr)

  187.     {

  188.         delete[] currentProgramName;

  189.         currentProgramName = nullptr;

  190.     }

  191.     if (chunk != nullptr)

  192.     {

  193.         delete[] chunk;

  194.         chunk = nullptr;

  195.     }

  196. 

  197.     uniqueId = 0;

  198. #ifndef BUILD_BRIDGE

  199.     active = false;

  200.     dryWet = 1.0f;

  201.     volume = 1.0f;

  202.     balanceLeft  = -1.0f;

  203.     balanceRight = 1.0f;

  204.     panning      = 0.0f;

  205.     ctrlChannel  = -1;

  206.     options      = 0x0;

  207. #endif

  208.     currentProgramIndex = -1;

  209.     currentMidiBank     = -1;

  210.     currentMidiProgram  = -1;

  211. 

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

  213.     {

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

  215.         delete stateParameter;

  216.     }

  217. 

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

  219.     {

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

  221.         delete stateCustomData;

  222.     }

  223. 

  224.     parameters.clear();

  225.     customData.clear();

  226. }

  227. 

  228. // -----------------------------------------------------------------------

  229. // fillFromXmlElement

  230. 

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

  232. {

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

  234. 

  235.     clear();

  236. 

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

  238.     {

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

  240. 

  241.         // ---------------------------------------------------------------

  242.         // Info

  243. 

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

  245.         {

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

  247.             {

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

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

  250. 

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

  252.                     type = xmlSafeStringCharDup(text, false);

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

  254.                     name = xmlSafeStringCharDup(text, false);

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

  256.                     label = xmlSafeStringCharDup(text, false);

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

  258.                     binary = xmlSafeStringCharDup(text, false);

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

  260.                     uniqueId = text.getLargeIntValue();

  261.             }

  262.         }

  263. 

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

  265.         // Data

  266. 

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

  268.         {

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

  270.             {

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

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

  273. 

  274. #ifndef BUILD_BRIDGE

  275.                 // -------------------------------------------------------

  276.                 // Internal Data

  277. 

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

  279.                 {

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

  281.                 }

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

  283.                 {

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

  285.                 }

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

  287.                 {

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

  289.                 }

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

  291.                 {

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

  293.                 }

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

  295.                 {

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

  297.                 }

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

  299.                 {

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

  301.                 }

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

  303.                 {

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

  305.                     {

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

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

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

  309.                     }

  310.                 }

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

  312.                 {

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

  314.                     if (value > 0)

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

  316.                 }

  317. #else

  318.                 if (false) {}

  319. #endif

  320. 

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

  322.                 // Program (current)

  323. 

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

  325.                 {

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

  327.                     if (value >= 1)

  328.                         currentProgramIndex = value-1;

  329.                 }

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

  331.                 {

  332.                     currentProgramName = xmlSafeStringCharDup(text, false);

  333.                 }

  334. 

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

  336.                 // Midi Program (current)

  337. 

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

  339.                 {

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

  341.                     if (value >= 1)

  342.                         currentMidiBank = value-1;

  343.                 }

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

  345.                 {

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

  347.                     if (value >= 1)

  348.                         currentMidiProgram = value-1;

  349.                 }

  350. 

  351.                 // -------------------------------------------------------

  352.                 // Parameters

  353. 

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

  355.                 {

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

  357. 

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

  359.                     {

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

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

  362. 

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

  364.                         {

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

  366.                             if (index >= 0)

  367.                                 stateParameter->index = index;

  368.                         }

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

  370.                         {

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

  372.                         }

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

  374.                         {

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

  376.                         }

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

  378.                         {

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

  380.                         }

  381. 

  382. #ifndef BUILD_BRIDGE

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

  384.                         {

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

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

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

  388.                         }

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

  390.                         {

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

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

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

  394.                         }

  395. #endif

  396.                     }

  397. 

  398.                     parameters.append(stateParameter);

  399.                 }

  400. 

  401.                 // -------------------------------------------------------

  402.                 // Custom Data

  403. 

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

  405.                 {

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

  407. 

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

  409.                     {

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

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

  412. 

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

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

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

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

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

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

  419.                     }

  420. 

  421.                     customData.append(stateCustomData);

  422.                 }

  423. 

  424.                 // -------------------------------------------------------

  425.                 // Chunk

  426. 

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

  428.                 {

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

  430.                     chunk = xmlSafeStringCharDup(nText, false);

  431.                 }

  432.             }

  433.         }

  434.     }

  435. 

  436.     return true;

  437. }

  438. 

  439. // -----------------------------------------------------------------------

  440. // fillXmlStringFromStateSave

  441. 

  442. String StateSave::toString() const

  443. {

  444.     String content;

  445. 

  446.     {

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

  448. 

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

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

  451. 

  452.         switch (getPluginTypeFromString(type))

  453.         {

  454.         case PLUGIN_NONE:

  455.             break;

  456.         case PLUGIN_INTERNAL:

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

  458.             break;

  459.         case PLUGIN_LADSPA:

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

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

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

  463.             break;

  464.         case PLUGIN_DSSI:

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

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

  467.             break;

  468.         case PLUGIN_LV2:

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

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

  471.             break;

  472.         case PLUGIN_VST:

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

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

  475.             break;

  476.         case PLUGIN_VST3:

  477.             // TODO?

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

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

  480.             break;

  481.         case PLUGIN_AU:

  482.             // TODO?

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

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

  485.             break;

  486.         case PLUGIN_GIG:

  487.         case PLUGIN_SF2:

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

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

  490.             break;

  491.         case PLUGIN_SFZ:

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

  493.             break;

  494.         }

  495. 

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

  497. 

  498.         content << infoXml;

  499.     }

  500. 

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

  502. 

  503. #ifndef BUILD_BRIDGE

  504.     {

  505.         String dataXml;

  506. 

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

  508. 

  509.         if (! carla_compareFloats(dryWet, 1.0f))

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

  511.         if (! carla_compareFloats(volume, 1.0f))

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

  513.         if (! carla_compareFloats(balanceLeft, -1.0f))

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

  515.         if (! carla_compareFloats(balanceRight, 1.0f))

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

  517.         if (! carla_compareFloats(panning, 0.0f))

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

  519. 

  520.         if (ctrlChannel < 0)

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

  522.         else

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

  524. 

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

  526. 

  527.         content << dataXml;

  528.     }

  529. #endif

  530. 

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

  532.     {

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

  534. 

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

  536. 

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

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

  539. 

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

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

  542. 

  543.         if (stateParameter->isInput)

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

  545. 

  546. #ifndef BUILD_BRIDGE

  547.         if (stateParameter->midiCC > 0)

  548.         {

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

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

  551.         }

  552. #endif

  553. 

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

  555. 

  556.         content << parameterXml;

  557.     }

  558. 

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

  560.     {

  561.         // ignore 'default' program

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

  563.         {

  564.             String programXml("\n");

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

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

  567. 

  568.             content << programXml;

  569.         }

  570.     }

  571. 

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

  573.     {

  574.         String midiProgramXml("\n");

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

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

  577. 

  578.         content << midiProgramXml;

  579.     }

  580. 

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

  582.     {

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

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

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

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

  587. 

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

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

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

  591. 

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

  593.         {

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

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

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

  597.         }

  598.         else

  599.         {

  600.             customDataXml << "    <Value>";

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

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

  603.         }

  604. 

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

  606. 

  607.         content << customDataXml;

  608.     }

  609. 

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

  611.     {

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

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

  614. 

  615.         content << chunkXml;

  616.     }

  617. 

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

  619. 

  620.     return content;

  621. }

  622. 

  623. // -----------------------------------------------------------------------

  624. 

  625. CARLA_BACKEND_END_NAMESPACE