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

583 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 <QtCore/QString>

  25. #include <QtXml/QDomNode>

  26. 

  27. CARLA_BACKEND_START_NAMESPACE

  28. 

  29. // -----------------------------------------------------------------------

  30. // StateParameter

  31. 

  32. StateParameter::StateParameter() noexcept

  33.     : isInput(true),

  34.       index(-1),

  35.       name(nullptr),

  36.       symbol(nullptr),

  37.       value(0.0f),

  38.       midiChannel(0),

  39.       midiCC(-1) {}

  40. 

  41. StateParameter::~StateParameter() noexcept

  42. {

  43.     if (name != nullptr)

  44.     {

  45.         delete[] name;

  46.         name = nullptr;

  47.     }

  48.     if (symbol != nullptr)

  49.     {

  50.         delete[] symbol;

  51.         symbol = nullptr;

  52.     }

  53. }

  54. 

  55. // -----------------------------------------------------------------------

  56. // StateCustomData

  57. 

  58. StateCustomData::StateCustomData() noexcept

  59.     : type(nullptr),

  60.       key(nullptr),

  61.       value(nullptr) {}

  62. 

  63. StateCustomData::~StateCustomData() noexcept

  64. {

  65.     if (type != nullptr)

  66.     {

  67.         delete[] type;

  68.         type = nullptr;

  69.     }

  70.     if (key != nullptr)

  71.     {

  72.         delete[] key;

  73.         key = nullptr;

  74.     }

  75.     if (value != nullptr)

  76.     {

  77.         delete[] value;

  78.         value = nullptr;

  79.     }

  80. }

  81. 

  82. // -----------------------------------------------------------------------

  83. // SaveState

  84. 

  85. SaveState::SaveState() noexcept

  86.     : type(nullptr),

  87.       name(nullptr),

  88.       label(nullptr),

  89.       binary(nullptr),

  90.       uniqueId(0),

  91.       active(false),

  92.       dryWet(1.0f),

  93.       volume(1.0f),

  94.       balanceLeft(-1.0f),

  95.       balanceRight(1.0f),

  96.       panning(0.0f),

  97.       ctrlChannel(-1),

  98.       currentProgramIndex(-1),

  99.       currentProgramName(nullptr),

  100.       currentMidiBank(-1),

  101.       currentMidiProgram(-1),

  102.       chunk(nullptr) {}

  103. 

  104. SaveState::~SaveState() noexcept

  105. {

  106.     reset();

  107. }

  108. 

  109. void SaveState::reset() noexcept

  110. {

  111.     if (type != nullptr)

  112.     {

  113.         delete[] type;

  114.         type = nullptr;

  115.     }

  116.     if (name != nullptr)

  117.     {

  118.         delete[] name;

  119.         name = nullptr;

  120.     }

  121.     if (label != nullptr)

  122.     {

  123.         delete[] label;

  124.         label = nullptr;

  125.     }

  126.     if (binary != nullptr)

  127.     {

  128.         delete[] binary;

  129.         binary = nullptr;

  130.     }

  131.     if (currentProgramName != nullptr)

  132.     {

  133.         delete[] currentProgramName;

  134.         currentProgramName = nullptr;

  135.     }

  136.     if (chunk != nullptr)

  137.     {

  138.         delete[] chunk;

  139.         chunk = nullptr;

  140.     }

  141. 

  142.     uniqueId = 0;

  143.     active = false;

  144.     dryWet = 1.0f;

  145.     volume = 1.0f;

  146.     balanceLeft  = -1.0f;

  147.     balanceRight = 1.0f;

  148.     panning      = 0.0f;

  149.     ctrlChannel  = -1;

  150.     currentProgramIndex = -1;

  151.     currentMidiBank     = -1;

  152.     currentMidiProgram  = -1;

  153. 

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

  155.     {

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

  157.         delete stateParameter;

  158.     }

  159. 

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

  161.     {

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

  163.         delete stateCustomData;

  164.     }

  165. 

  166.     parameters.clear();

  167.     customData.clear();

  168. }

  169. 

  170. // -----------------------------------------------------------------------

  171. // xmlSafeString

  172. 

  173. static QString xmlSafeString(const QString& string, const bool toXml)

  174. {

  175.     QString newString(string);

  176. 

  177.     if (toXml)

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

  179.     else

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

  181. }

  182. 

  183. static const char* xmlSafeStringCharDup(const QString& string, const bool toXml)

  184. {

  185.     return carla_strdup(xmlSafeString(string, toXml).toUtf8().constData());

  186. }

  187. 

  188. // -----------------------------------------------------------------------

  189. // fillSaveStateFromXmlNode

  190. 

  191. void fillSaveStateFromXmlNode(SaveState& saveState, const QDomNode& xmlNode)

  192. {

  193.     if (xmlNode.isNull())

  194.         return;

  195. 

  196.     for (QDomNode node = xmlNode.firstChild(); ! node.isNull(); node = node.nextSibling())

  197.     {

  198.         QString tagName(node.toElement().tagName());

  199. 

  200.         // ---------------------------------------------------------------

  201.         // Info

  202. 

  203.         if (tagName.compare("info", Qt::CaseInsensitive) == 0)

  204.         {

  205.             for (QDomNode xmlInfo = node.toElement().firstChild(); ! xmlInfo.isNull(); xmlInfo = xmlInfo.nextSibling())

  206.             {

  207.                 const QString tag(xmlInfo.toElement().tagName());

  208.                 const QString text(xmlInfo.toElement().text().trimmed());

  209. 

  210.                 if (tag.compare("type", Qt::CaseInsensitive) == 0)

  211.                 {

  212.                     saveState.type = xmlSafeStringCharDup(text, false);

  213.                 }

  214.                 else if (tag.compare("name", Qt::CaseInsensitive) == 0)

  215.                 {

  216.                     saveState.name = xmlSafeStringCharDup(text, false);

  217.                 }

  218.                 else if (tag.compare("label", Qt::CaseInsensitive) == 0 || tag.compare("uri", Qt::CaseInsensitive) == 0)

  219.                 {

  220.                     saveState.label = xmlSafeStringCharDup(text, false);

  221.                 }

  222.                 else if (tag.compare("binary", Qt::CaseInsensitive) == 0 || tag.compare("bundle", Qt::CaseInsensitive) == 0 || tag.compare("filename", Qt::CaseInsensitive) == 0)

  223.                 {

  224.                     saveState.binary = xmlSafeStringCharDup(text, false);

  225.                 }

  226.                 else if (tag.compare("uniqueid", Qt::CaseInsensitive) == 0)

  227.                 {

  228.                     bool ok;

  229.                     const qlonglong uniqueId(text.toLongLong(&ok));

  230.                     if (ok) saveState.uniqueId = static_cast<int64_t>(uniqueId);

  231.                 }

  232.             }

  233.         }

  234. 

  235.         // ---------------------------------------------------------------

  236.         // Data

  237. 

  238.         else if (tagName.compare("data", Qt::CaseInsensitive) == 0)

  239.         {

  240.             for (QDomNode xmlData = node.toElement().firstChild(); ! xmlData.isNull(); xmlData = xmlData.nextSibling())

  241.             {

  242.                 const QString tag(xmlData.toElement().tagName());

  243.                 const QString text(xmlData.toElement().text().trimmed());

  244. 

  245.                 // -------------------------------------------------------

  246.                 // Internal Data

  247. 

  248.                 if (tag.compare("active", Qt::CaseInsensitive) == 0)

  249.                 {

  250.                     saveState.active = (text.compare("yes", Qt::CaseInsensitive) == 0 || text.compare("true", Qt::CaseInsensitive) == 0);

  251.                 }

  252.                 else if (tag.compare("drywet", Qt::CaseInsensitive) == 0)

  253.                 {

  254.                     bool ok;

  255.                     const float value(text.toFloat(&ok));

  256.                     if (ok) saveState.dryWet = carla_fixValue(0.0f, 1.0f, value);

  257.                 }

  258.                 else if (tag.compare("volume", Qt::CaseInsensitive) == 0)

  259.                 {

  260.                     bool ok;

  261.                     const float value(text.toFloat(&ok));

  262.                     if (ok) saveState.volume = carla_fixValue(0.0f, 1.27f, value);

  263.                 }

  264.                 else if (tag.compare("balanceleft", Qt::CaseInsensitive) == 0 || tag.compare("balance-left", Qt::CaseInsensitive) == 0)

  265.                 {

  266.                     bool ok;

  267.                     const float value(text.toFloat(&ok));

  268.                     if (ok) saveState.balanceLeft = carla_fixValue(-1.0f, 1.0f, value);

  269.                 }

  270.                 else if (tag.compare("balanceright", Qt::CaseInsensitive) == 0 || tag.compare("balance-right", Qt::CaseInsensitive) == 0)

  271.                 {

  272.                     bool ok;

  273.                     const float value(text.toFloat(&ok));

  274.                     if (ok) saveState.balanceRight = carla_fixValue(-1.0f, 1.0f, value);

  275.                 }

  276.                 else if (tag.compare("panning", Qt::CaseInsensitive) == 0)

  277.                 {

  278.                     bool ok;

  279.                     const float value(text.toFloat(&ok));

  280.                     if (ok) saveState.panning = carla_fixValue(-1.0f, 1.0f, value);

  281.                 }

  282.                 else if (tag.compare("controlchannel", Qt::CaseInsensitive) == 0 || tag.compare("control-channel", Qt::CaseInsensitive) == 0)

  283.                 {

  284.                     bool ok;

  285.                     const short value(text.toShort(&ok));

  286.                     if (ok && value >= 1 && value < MAX_MIDI_CHANNELS)

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

  288.                 }

  289. 

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

  291.                 // Program (current)

  292. 

  293.                 else if (tag.compare("currentprogramindex", Qt::CaseInsensitive) == 0 || tag.compare("current-program-index", Qt::CaseInsensitive) == 0)

  294.                 {

  295.                     bool ok;

  296.                     const int value(text.toInt(&ok));

  297.                     if (ok && value >= 1)

  298.                         saveState.currentProgramIndex = value-1;

  299.                 }

  300.                 else if (tag.compare("currentprogramname", Qt::CaseInsensitive) == 0 || tag.compare("current-program-name", Qt::CaseInsensitive) == 0)

  301.                 {

  302.                     saveState.currentProgramName = xmlSafeStringCharDup(text, false);

  303.                 }

  304. 

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

  306.                 // Midi Program (current)

  307. 

  308.                 else if (tag.compare("currentmidibank", Qt::CaseInsensitive) == 0 || tag.compare("current-midi-bank", Qt::CaseInsensitive) == 0)

  309.                 {

  310.                     bool ok;

  311.                     const int value(text.toInt(&ok));

  312.                     if (ok && value >= 1)

  313.                         saveState.currentMidiBank = value-1;

  314.                 }

  315.                 else if (tag.compare("currentmidiprogram", Qt::CaseInsensitive) == 0 || tag.compare("current-midi-program", Qt::CaseInsensitive) == 0)

  316.                 {

  317.                     bool ok;

  318.                     const int value(text.toInt(&ok));

  319.                     if (ok && value >= 1)

  320.                         saveState.currentMidiProgram = value-1;

  321.                 }

  322. 

  323.                 // -------------------------------------------------------

  324.                 // Parameters

  325. 

  326.                 else if (tag.compare("parameter", Qt::CaseInsensitive) == 0)

  327.                 {

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

  329. 

  330.                     for (QDomNode xmlSubData = xmlData.toElement().firstChild(); ! xmlSubData.isNull(); xmlSubData = xmlSubData.nextSibling())

  331.                     {

  332.                         const QString pTag(xmlSubData.toElement().tagName());

  333.                         const QString pText(xmlSubData.toElement().text().trimmed());

  334. 

  335.                         if (pTag.compare("index", Qt::CaseInsensitive) == 0)

  336.                         {

  337.                             bool ok;

  338.                             const int index(pText.toInt(&ok));

  339.                             if (ok && index >= 0) stateParameter->index = index;

  340.                         }

  341.                         else if (pTag.compare("name", Qt::CaseInsensitive) == 0)

  342.                         {

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

  344.                         }

  345.                         else if (pTag.compare("symbol", Qt::CaseInsensitive) == 0)

  346.                         {

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

  348.                         }

  349.                         else if (pTag.compare("value", Qt::CaseInsensitive) == 0)

  350.                         {

  351.                             bool ok;

  352.                             const float value(pText.toFloat(&ok));

  353.                             if (ok) stateParameter->value = value;

  354.                         }

  355.                         else if (pTag.compare("midichannel", Qt::CaseInsensitive) == 0 || pTag.compare("midi-channel", Qt::CaseInsensitive) == 0)

  356.                         {

  357.                             bool ok;

  358.                             const ushort channel(pText.toUShort(&ok));

  359.                             if (ok && channel >= 1 && channel < MAX_MIDI_CHANNELS)

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

  361.                         }

  362.                         else if (pTag.compare("midicc", Qt::CaseInsensitive) == 0 || pTag.compare("midi-cc", Qt::CaseInsensitive) == 0)

  363.                         {

  364.                             bool ok;

  365.                             const int cc(pText.toInt(&ok));

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

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

  368.                         }

  369.                     }

  370. 

  371.                     saveState.parameters.append(stateParameter);

  372.                 }

  373. 

  374.                 // -------------------------------------------------------

  375.                 // Custom Data

  376. 

  377.                 else if (tag.compare("customdata", Qt::CaseInsensitive) == 0 || tag.compare("custom-data", Qt::CaseInsensitive) == 0)

  378.                 {

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

  380. 

  381.                     for (QDomNode xmlSubData = xmlData.toElement().firstChild(); ! xmlSubData.isNull(); xmlSubData = xmlSubData.nextSibling())

  382.                     {

  383.                         const QString cTag(xmlSubData.toElement().tagName());

  384.                         const QString cText(xmlSubData.toElement().text().trimmed());

  385. 

  386.                         if (cTag.compare("type", Qt::CaseInsensitive) == 0)

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

  388.                         else if (cTag.compare("key", Qt::CaseInsensitive) == 0)

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

  390.                         else if (cTag.compare("value", Qt::CaseInsensitive) == 0)

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

  392.                     }

  393. 

  394.                     saveState.customData.append(stateCustomData);

  395.                 }

  396. 

  397.                 // -------------------------------------------------------

  398.                 // Chunk

  399. 

  400.                 else if (tag.compare("chunk", Qt::CaseInsensitive) == 0)

  401.                 {

  402.                     saveState.chunk = xmlSafeStringCharDup(text, false);

  403.                 }

  404.             }

  405.         }

  406.     }

  407. }

  408. 

  409. // -----------------------------------------------------------------------

  410. // fillXmlStringFromSaveState

  411. 

  412. void fillXmlStringFromSaveState(QString& content, const SaveState& saveState)

  413. {

  414.     {

  415.         QString info("  <Info>\n");

  416. 

  417.         info += QString("   <Type>%1</Type>\n").arg(saveState.type);

  418.         info += QString("   <Name>%1</Name>\n").arg(xmlSafeString(saveState.name, true));

  419. 

  420.         switch (getPluginTypeFromString(saveState.type))

  421.         {

  422.         case PLUGIN_NONE:

  423.             break;

  424.         case PLUGIN_INTERNAL:

  425.             info += QString("   <Label>%1</Label>\n").arg(xmlSafeString(saveState.label, true));

  426.             break;

  427.         case PLUGIN_LADSPA:

  428.             info += QString("   <Binary>%1</Binary>\n").arg(xmlSafeString(saveState.binary, true));

  429.             info += QString("   <Label>%1</Label>\n").arg(xmlSafeString(saveState.label, true));

  430.             info += QString("   <UniqueID>%1</UniqueID>\n").arg(saveState.uniqueId);

  431.             break;

  432.         case PLUGIN_DSSI:

  433.             info += QString("   <Binary>%1</Binary>\n").arg(xmlSafeString(saveState.binary, true));

  434.             info += QString("   <Label>%1</Label>\n").arg(xmlSafeString(saveState.label, true));

  435.             break;

  436.         case PLUGIN_LV2:

  437.             info += QString("   <Bundle>%1</Bundle>\n").arg(xmlSafeString(saveState.binary, true));

  438.             info += QString("   <URI>%1</URI>\n").arg(xmlSafeString(saveState.label, true));

  439.             break;

  440.         case PLUGIN_VST:

  441.             info += QString("   <Binary>%1</Binary>\n").arg(xmlSafeString(saveState.binary, true));

  442.             info += QString("   <UniqueID>%1</UniqueID>\n").arg(saveState.uniqueId);

  443.             break;

  444.         case PLUGIN_VST3:

  445.             // TODO?

  446.             info += QString("   <Binary>%1</Binary>\n").arg(xmlSafeString(saveState.binary, true));

  447.             info += QString("   <UniqueID>%1</UniqueID>\n").arg(saveState.uniqueId);

  448.             break;

  449.         case PLUGIN_AU:

  450.             // TODO?

  451.             info += QString("   <Binary>%1</Binary>\n").arg(xmlSafeString(saveState.binary, true));

  452.             info += QString("   <UniqueID>%1</UniqueID>\n").arg(saveState.uniqueId);

  453.             break;

  454.         case PLUGIN_JACK:

  455.             info += QString("   <Binary>%1</Binary>\n").arg(xmlSafeString(saveState.binary, true));

  456.             break;

  457.         case PLUGIN_REWIRE:

  458.             info += QString("   <Label>%1</Label>\n").arg(xmlSafeString(saveState.label, true));

  459.             break;

  460.         case PLUGIN_FILE_CSD:

  461.         case PLUGIN_FILE_GIG:

  462.         case PLUGIN_FILE_SF2:

  463.         case PLUGIN_FILE_SFZ:

  464.             info += QString("   <Filename>%1</Filename>\n").arg(xmlSafeString(saveState.binary, true));

  465.             info += QString("   <Label>%1</Label>\n").arg(xmlSafeString(saveState.label, true));

  466.             break;

  467.         }

  468. 

  469.         info += "  </Info>\n\n";

  470. 

  471.         content += info;

  472.     }

  473. 

  474.     {

  475.         QString data("  <Data>\n");

  476. 

  477.         data += QString("   <Active>%1</Active>\n").arg(saveState.active ? "Yes" : "No");

  478. 

  479.         if (saveState.dryWet != 1.0f)

  480.             data += QString("   <DryWet>%1</DryWet>\n").arg(saveState.dryWet);

  481.         if (saveState.volume != 1.0f)

  482.             data += QString("   <Volume>%1</Volume>\n").arg(saveState.volume);

  483.         if (saveState.balanceLeft != -1.0f)

  484.             data += QString("   <Balance-Left>%1</Balance-Left>\n").arg(saveState.balanceLeft);

  485.         if (saveState.balanceRight != 1.0f)

  486.             data += QString("   <Balance-Right>%1</Balance-Right>\n").arg(saveState.balanceRight);

  487.         if (saveState.panning != 0.0f)

  488.             data += QString("   <Panning>%1</Panning>\n").arg(saveState.panning);

  489. 

  490.         if (saveState.ctrlChannel < 0)

  491.             data += QString("   <ControlChannel>N</ControlChannel>\n");

  492.         else

  493.             data += QString("   <ControlChannel>%1</ControlChannel>\n").arg(saveState.ctrlChannel+1);

  494. 

  495.         content += data;

  496.     }

  497. 

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

  499.     {

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

  501. 

  502.         QString parameter("\n""   <Parameter>\n");

  503. 

  504.         parameter += QString("    <Index>%1</Index>\n").arg(stateParameter->index);

  505.         parameter += QString("    <Name>%1</Name>\n").arg(xmlSafeString(stateParameter->name, true));

  506. 

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

  508.             parameter += QString("    <Symbol>%1</Symbol>\n").arg(xmlSafeString(stateParameter->symbol, true));

  509. 

  510.         if (stateParameter->isInput)

  511.             parameter += QString("    <Value>%1</Value>\n").arg(stateParameter->value);

  512. 

  513.         if (stateParameter->midiCC > 0)

  514.         {

  515.             parameter += QString("    <MidiCC>%1</MidiCC>\n").arg(stateParameter->midiCC);

  516.             parameter += QString("    <MidiChannel>%1</MidiChannel>\n").arg(stateParameter->midiChannel+1);

  517.         }

  518. 

  519.         parameter += "   </Parameter>\n";

  520. 

  521.         content += parameter;

  522.     }

  523. 

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

  525.     {

  526.         // ignore 'default' program

  527.         if (saveState.currentProgramIndex > 0 || QString(saveState.currentProgramName).compare("default", Qt::CaseInsensitive) != 0)

  528.         {

  529.             QString program("\n");

  530.             program += QString("   <CurrentProgramIndex>%1</CurrentProgramIndex>\n").arg(saveState.currentProgramIndex+1);

  531.             program += QString("   <CurrentProgramName>%1</CurrentProgramName>\n").arg(xmlSafeString(saveState.currentProgramName, true));

  532. 

  533.             content += program;

  534.         }

  535.     }

  536. 

  537.     if (saveState.currentMidiBank >= 0 && saveState.currentMidiProgram >= 0)

  538.     {

  539.         QString midiProgram("\n");

  540.         midiProgram += QString("   <CurrentMidiBank>%1</CurrentMidiBank>\n").arg(saveState.currentMidiBank+1);

  541.         midiProgram += QString("   <CurrentMidiProgram>%1</CurrentMidiProgram>\n").arg(saveState.currentMidiProgram+1);

  542. 

  543.         content += midiProgram;

  544.     }

  545. 

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

  547.     {

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

  549. 

  550.         QString customData("\n""   <CustomData>\n");

  551.         customData += QString("    <Type>%1</Type>\n").arg(xmlSafeString(stateCustomData->type, true));

  552.         customData += QString("    <Key>%1</Key>\n").arg(xmlSafeString(stateCustomData->key, true));

  553. 

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

  555.         {

  556.             customData += "    <Value>\n";

  557.             customData += QString("%1\n").arg(xmlSafeString(stateCustomData->value, true));

  558.             customData += "    </Value>\n";

  559.         }

  560.         else

  561.             customData += QString("    <Value>%1</Value>\n").arg(xmlSafeString(stateCustomData->value, true));

  562. 

  563.         customData += "   </CustomData>\n";

  564. 

  565.         content += customData;

  566.     }

  567. 

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

  569.     {

  570.         QString chunk("\n""   <Chunk>\n");

  571.         chunk += QString("%1\n").arg(saveState.chunk);

  572.         chunk += "   </Chunk>\n";

  573. 

  574.         content += chunk;

  575.     }

  576. 

  577.     content += "  </Data>\n";

  578. }

  579. 

  580. // -----------------------------------------------------------------------

  581. 

  582. CARLA_BACKEND_END_NAMESPACE