DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 18 Wiki Activity
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.
1618 Commits
6 Branches
51MB
Tree: e6a799cd4c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e6a799cd4c'
${ noResults }
Cardinal/src/CardinalPlugin.cpp

1393 lines
55KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021-2023 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 3 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 LICENSE file.

  16.  */

  17. 

  18. #include <library.hpp>

  19. #include <midi.hpp>

  20. #include <patch.hpp>

  21. #include <plugin.hpp>

  22. #include <random.hpp>

  23. #include <settings.hpp>

  24. #include <system.hpp>

  25. 

  26. #include <app/Scene.hpp>

  27. #include <engine/Engine.hpp>

  28. #include <ui/common.hpp>

  29. #include <widget/Widget.hpp>

  30. #include <window/Window.hpp>

  31. 

  32. #ifdef NDEBUG

  33. # undef DEBUG

  34. #endif

  35. 

  36. #if defined(HAVE_LIBLO) && defined(HEADLESS)

  37. # include <lo/lo.h>

  38. # include "extra/Thread.hpp"

  39. #endif

  40. 

  41. #include <cfloat>

  42. #include <list>

  43. 

  44. #include "CardinalCommon.hpp"

  45. #include "DistrhoPluginUtils.hpp"

  46. #include "PluginContext.hpp"

  47. #include "extra/Base64.hpp"

  48. #include "extra/ScopedDenormalDisable.hpp"

  49. #include "extra/ScopedSafeLocale.hpp"

  50. 

  51. #ifdef DISTRHO_OS_WASM

  52. # include <emscripten/emscripten.h>

  53. #else

  54. # include "extra/SharedResourcePointer.hpp"

  55. #endif

  56. 

  57. #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  58. # include "extra/ScopedValueSetter.hpp"

  59. #endif

  60. 

  61. extern const std::string CARDINAL_VERSION;

  62. 

  63. namespace rack {

  64. #if (CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS) || defined(HEADLESS)

  65. namespace app {

  66. rack::widget::Widget* createMenuBar() { return new rack::widget::Widget; }

  67. }

  68. #endif

  69. #ifdef DISTRHO_OS_WASM

  70. namespace asset {

  71. std::string patchesPath();

  72. }

  73. #endif

  74. namespace engine {

  75. void Engine_setAboutToClose(Engine*);

  76. }

  77. }

  78. 

  79. START_NAMESPACE_DISTRHO

  80. 

  81. template<typename T>

  82. static inline

  83. bool d_isDiffHigherThanLimit(const T& v1, const T& v2, const T& limit)

  84. {

  85.     return v1 != v2 ? (v1 > v2 ? v1 - v2 : v2 - v1) > limit : false;

  86. }

  87. 

  88. #if DISTRHO_PLUGIN_HAS_UI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  89. const char* UI::getBundlePath() const noexcept { return nullptr; }

  90. void UI::setState(const char*, const char*) {}

  91. #endif

  92. 

  93. // -----------------------------------------------------------------------------------------------------------

  94. 

  95. #ifdef DISTRHO_OS_WASM

  96. static char* getPatchFileEncodedInURL() {

  97.     return static_cast<char*>(EM_ASM_PTR({

  98.         var searchParams = new URLSearchParams(window.location.search);

  99.         var patch = searchParams.get('patch');

  100.         if (!patch)

  101.         return null;

  102.         var length = lengthBytesUTF8(patch) + 1;

  103.         var str = _malloc(length);

  104.         stringToUTF8(patch, str, length);

  105.         return str;

  106.     }));

  107. };

  108. 

  109. static char* getPatchRemoteURL() {

  110.     return static_cast<char*>(EM_ASM_PTR({

  111.         var searchParams = new URLSearchParams(window.location.search);

  112.         var patch = searchParams.get('patchurl');

  113.         if (!patch)

  114.         return null;

  115.         var length = lengthBytesUTF8(patch) + 1;

  116.         var str = _malloc(length);

  117.         stringToUTF8(patch, str, length);

  118.         return str;

  119.     }));

  120. };

  121. 

  122. static char* getPatchStorageSlug() {

  123.     return static_cast<char*>(EM_ASM_PTR({

  124.         var searchParams = new URLSearchParams(window.location.search);

  125.         var patch = searchParams.get('patchstorage');

  126.         if (!patch)

  127.         return null;

  128.         var length = lengthBytesUTF8(patch) + 1;

  129.         var str = _malloc(length);

  130.         stringToUTF8(patch, str, length);

  131.         return str;

  132.     }));

  133. };

  134. #endif

  135. 

  136. #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  137. float RackKnobModeToFloat(const rack::settings::KnobMode knobMode) noexcept

  138. {

  139.     switch (knobMode)

  140.     {

  141.     case rack::settings::KNOB_MODE_LINEAR:

  142.         return 0.f;

  143.     case rack::settings::KNOB_MODE_ROTARY_ABSOLUTE:

  144.         return 1.f;

  145.     case rack::settings::KNOB_MODE_ROTARY_RELATIVE:

  146.         return 2.f;

  147.     // unused in Rack

  148.     case rack::settings::KNOB_MODE_SCALED_LINEAR:

  149.         break;

  150.     }

  151. 

  152.     return 0.f;

  153. }

  154. #endif

  155. 

  156. // -----------------------------------------------------------------------------------------------------------

  157. 

  158. struct ScopedContext {

  159.     ScopedContext(const CardinalBasePlugin* const plugin)

  160.     {

  161.         rack::contextSet(plugin->context);

  162.     }

  163. 

  164.     ~ScopedContext()

  165.     {

  166.         rack::contextSet(nullptr);

  167.     }

  168. };

  169. 

  170. 

  171. // -----------------------------------------------------------------------------------------------------------

  172. 

  173. class CardinalPlugin : public CardinalBasePlugin

  174. {

  175.    #ifdef DISTRHO_OS_WASM

  176.     ScopedPointer<Initializer> fInitializer;

  177.    #else

  178.     SharedResourcePointer<Initializer> fInitializer;

  179.    #endif

  180. 

  181.    #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  182.     /* If host audio ins == outs we can get issues for inplace processing.

  183.      * So allocate a float array that will serve as safe copy for those cases.

  184.      */

  185.     float** fAudioBufferCopy;

  186.    #endif

  187. 

  188.     std::string fAutosavePath;

  189.     uint64_t fNextExpectedFrame;

  190. 

  191.     struct {

  192.         String comment;

  193.         String screenshot;

  194.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  195.         String windowSize;

  196.        #endif

  197.     } fState;

  198. 

  199.     // bypass handling

  200.     bool fWasBypassed;

  201.     MidiEvent bypassMidiEvents[16];

  202. 

  203.    #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  204.     // real values, not VCV interpreted ones

  205.     float fWindowParameters[kWindowParameterCount];

  206.    #endif

  207.    #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  208.     float fMiniReportValues[kCardinalParameterCountAtMini - kCardinalParameterStartMini];

  209.    #endif

  210. 

  211. public:

  212.     CardinalPlugin()

  213.         : CardinalBasePlugin(kCardinalParameterCount, 0, kCardinalStateCount),

  214.          #ifdef DISTRHO_OS_WASM

  215.           fInitializer(new Initializer(this, static_cast<const CardinalBaseUI*>(nullptr))),

  216.          #else

  217.           fInitializer(this, static_cast<const CardinalBaseUI*>(nullptr)),

  218.          #endif

  219.          #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  220.           fAudioBufferCopy(nullptr),

  221.          #endif

  222.           fNextExpectedFrame(0),

  223.           fWasBypassed(false)

  224.     {

  225.         // check if first time loading a real instance

  226.         if (!fInitializer->shouldSaveSettings && !isDummyInstance())

  227.             fInitializer->loadSettings(true);

  228. 

  229.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  230.         fWindowParameters[kWindowParameterShowTooltips] = rack::settings::tooltips ? 1.f : 0.f;

  231.         fWindowParameters[kWindowParameterCableOpacity] = std::min(100.f, std::max(0.f, rack::settings::cableOpacity * 100));

  232.         fWindowParameters[kWindowParameterCableTension] = std::min(100.f, std::max(0.f, rack::settings::cableTension * 100));

  233.         fWindowParameters[kWindowParameterRackBrightness] = std::min(100.f, std::max(0.f, rack::settings::rackBrightness * 100));

  234.         fWindowParameters[kWindowParameterHaloBrightness] = std::min(100.f, std::max(0.f, rack::settings::haloBrightness * 100));

  235.         fWindowParameters[kWindowParameterKnobMode] = RackKnobModeToFloat(rack::settings::knobMode);

  236.         fWindowParameters[kWindowParameterWheelKnobControl] = rack::settings::knobScroll ? 1.f : 0.f;

  237.         fWindowParameters[kWindowParameterWheelSensitivity] = std::min(10.f, std::max(0.1f, rack::settings::knobScrollSensitivity * 1000));

  238.         fWindowParameters[kWindowParameterLockModulePositions] = rack::settings::lockModules ? 1.f : 0.f;

  239.         fWindowParameters[kWindowParameterBrowserSort] = std::min(rack::settings::BROWSER_SORT_RANDOM,

  240.                                                                   std::max(rack::settings::BROWSER_SORT_UPDATED,

  241.                                                                            rack::settings::browserSort));

  242.         fWindowParameters[kWindowParameterBrowserZoom] = std::min(200.f, std::max(25.f, std::pow(2.f, rack::settings::browserZoom) * 100.0f));

  243.         fWindowParameters[kWindowParameterInvertZoom] = rack::settings::invertZoom ? 1.f : 0.f;

  244.         fWindowParameters[kWindowParameterSqueezeModulePositions] = rack::settings::squeezeModules ? 1.f : 0.f;

  245.         // not saved

  246.         fWindowParameters[kWindowParameterUpdateRateLimit] = 0.0f;

  247.        #endif

  248.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  249.         std::memset(fMiniReportValues, 0, sizeof(fMiniReportValues));

  250.         fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = 1;

  251.         fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = 1;

  252.         fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = 4;

  253.         fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = 4;

  254.         fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = 120;

  255.        #endif

  256. 

  257.         // create unique temporary path for this instance

  258.         try {

  259.             char uidBuf[24];

  260.             const std::string tmp = rack::system::getTempDirectory();

  261. 

  262.             for (int i=1;; ++i)

  263.             {

  264.                 std::snprintf(uidBuf, sizeof(uidBuf), "Cardinal.%04d", i);

  265.                 const std::string trypath = rack::system::join(tmp, uidBuf);

  266. 

  267.                 if (! rack::system::exists(trypath))

  268.                 {

  269.                     if (rack::system::createDirectories(trypath))

  270.                         fAutosavePath = trypath;

  271.                     break;

  272.                 }

  273.             }

  274.         } DISTRHO_SAFE_EXCEPTION("create unique temporary path");

  275. 

  276.         // initialize midi events used when entering bypassed state

  277.         std::memset(bypassMidiEvents, 0, sizeof(bypassMidiEvents));

  278. 

  279.         for (uint8_t i=0; i<16; ++i)

  280.         {

  281.             bypassMidiEvents[i].size = 3;

  282.             bypassMidiEvents[i].data[0] = 0xB0 + i;

  283.             bypassMidiEvents[i].data[1] = 0x7B;

  284.         }

  285. 

  286.         const float sampleRate = getSampleRate();

  287.         rack::settings::sampleRate = sampleRate;

  288. 

  289.         context->bufferSize = getBufferSize();

  290.         context->sampleRate = sampleRate;

  291. 

  292.         const ScopedContext sc(this);

  293. 

  294.         context->engine = new rack::engine::Engine;

  295.         context->engine->setSampleRate(sampleRate);

  296. 

  297.         context->history = new rack::history::State;

  298.         context->patch = new rack::patch::Manager;

  299.         context->patch->autosavePath = fAutosavePath;

  300.         context->patch->templatePath = fInitializer->templatePath;

  301.         context->patch->factoryTemplatePath = fInitializer->factoryTemplatePath;

  302. 

  303.         context->event = new rack::widget::EventState;

  304.         context->scene = new rack::app::Scene;

  305.         context->event->rootWidget = context->scene;

  306. 

  307.         if (! isDummyInstance())

  308.             context->window = new rack::window::Window;

  309. 

  310.        #ifdef DISTRHO_OS_WASM

  311.         if ((rack::patchStorageSlug = getPatchStorageSlug()) == nullptr &&

  312.             (rack::patchRemoteURL = getPatchRemoteURL()) == nullptr &&

  313.             (rack::patchFromURL = getPatchFileEncodedInURL()) == nullptr)

  314.        #endif

  315.         {

  316.             context->patch->loadTemplate();

  317.             context->scene->rackScroll->reset();

  318.         }

  319. 

  320.       #ifdef DISTRHO_OS_WASM

  321.         // switch factory template to regular one after first load

  322.        #if CARDINAL_VARIANT_MINI

  323.         context->patch->factoryTemplatePath = rack::system::join(rack::asset::patchesPath(), "templates/mini.vcv");

  324.        #else

  325.         context->patch->factoryTemplatePath = rack::system::join(rack::asset::patchesPath(), "templates/main.vcv");

  326.        #endif

  327.       #endif

  328. 

  329.        #ifdef CARDINAL_INIT_OSC_THREAD

  330.         fInitializer->remotePluginInstance = this;

  331.        #endif

  332.     }

  333. 

  334.     ~CardinalPlugin() override

  335.     {

  336.        #ifdef CARDINAL_INIT_OSC_THREAD

  337.         if (fInitializer->remotePluginInstance == this)

  338.             fInitializer->remotePluginInstance = nullptr;

  339.        #endif

  340. 

  341.         {

  342.             const ScopedContext sc(this);

  343.             context->patch->clear();

  344. 

  345.             // do a little dance to prevent context scene deletion from saving to temp dir

  346.            #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  347.             const ScopedValueSetter<bool> svs(rack::settings::headless, true);

  348.            #endif

  349.             Engine_setAboutToClose(context->engine);

  350.             delete context;

  351.         }

  352. 

  353.         if (! fAutosavePath.empty())

  354.             rack::system::removeRecursively(fAutosavePath);

  355.     }

  356. 

  357.     CardinalPluginContext* getRackContext() const noexcept

  358.     {

  359.         return context;

  360.     }

  361. 

  362. protected:

  363.    /* --------------------------------------------------------------------------------------------------------

  364.     * Information */

  365. 

  366.     const char* getLabel() const override

  367.     {

  368.         return DISTRHO_PLUGIN_LABEL;

  369.     }

  370. 

  371.     const char* getDescription() const override

  372.     {

  373.         return ""

  374.         "Cardinal is a free and open-source virtual modular synthesizer plugin.\n"

  375.         "It is based on the popular VCV Rack but with a focus on being a fully self-contained plugin version.\n"

  376.         "It is not an official VCV project, and it is not affiliated with it in any way.\n"

  377.         "\n"

  378.         "Cardinal contains Rack, some 3rd-party modules and a few internal utilities.\n"

  379.         "It does not load external modules and does not connect to the official Rack library/store.\n";

  380.     }

  381. 

  382.     const char* getMaker() const override

  383.     {

  384.         return "DISTRHO";

  385.     }

  386. 

  387.     const char* getHomePage() const override

  388.     {

  389.         return "https://github.com/DISTRHO/Cardinal";

  390.     }

  391. 

  392.     const char* getLicense() const override

  393.     {

  394.         return "GPLv3+";

  395.     }

  396. 

  397.     uint32_t getVersion() const override

  398.     {

  399.         return d_version(0, 23, 5);

  400.     }

  401. 

  402.     int64_t getUniqueId() const override

  403.     {

  404.        #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_NATIVE

  405.         return d_cconst('d', 'C', 'd', 'n');

  406.        #elif CARDINAL_VARIANT_MINI

  407.         return d_cconst('d', 'C', 'd', 'M');

  408.        #elif CARDINAL_VARIANT_FX

  409.         return d_cconst('d', 'C', 'n', 'F');

  410.        #elif CARDINAL_VARIANT_SYNTH

  411.         return d_cconst('d', 'C', 'n', 'S');

  412.        #else

  413.         #error cardinal variant not set

  414.        #endif

  415.     }

  416. 

  417.    /* --------------------------------------------------------------------------------------------------------

  418.     * Init */

  419. 

  420.     void initAudioPort(const bool input, uint32_t index, AudioPort& port) override

  421.     {

  422.        #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

  423.         static_assert(CARDINAL_NUM_AUDIO_INPUTS == CARDINAL_NUM_AUDIO_OUTPUTS, "inputs == outputs");

  424. 

  425.         if (index < CARDINAL_NUM_AUDIO_INPUTS)

  426.         {

  427.            #if CARDINAL_VARIANT_MINI

  428.             port.groupId = kPortGroupStereo;

  429.            #else

  430.             port.groupId = index / 2;

  431.            #endif

  432.         }

  433.         else

  434.         {

  435.             port.hints = kAudioPortIsCV | kCVPortHasPositiveUnipolarRange | kCVPortHasScaledRange | kCVPortIsOptional;

  436.             index -= CARDINAL_NUM_AUDIO_INPUTS;

  437.         }

  438.        #elif CARDINAL_VARIANT_NATIVE || CARDINAL_VARIANT_FX || CARDINAL_VARIANT_SYNTH

  439.         if (index < 2)

  440.             port.groupId = kPortGroupStereo;

  441.        #endif

  442. 

  443.         CardinalBasePlugin::initAudioPort(input, index, port);

  444.     }

  445. 

  446.    #if CARDINAL_VARIANT_MAIN

  447.     void initPortGroup(const uint32_t index, PortGroup& portGroup) override

  448.     {

  449.         switch (index)

  450.         {

  451.         case 0:

  452.             portGroup.name = "Audio 1+2";

  453.             portGroup.symbol = "audio_1_and_2";

  454.             break;

  455.         case 1:

  456.             portGroup.name = "Audio 3+4";

  457.             portGroup.symbol = "audio_3_and_4";

  458.             break;

  459.         case 2:

  460.             portGroup.name = "Audio 5+6";

  461.             portGroup.symbol = "audio_5_and_6";

  462.             break;

  463.         case 3:

  464.             portGroup.name = "Audio 7+8";

  465.             portGroup.symbol = "audio_7_and_8";

  466.             break;

  467.         }

  468.     }

  469.    #endif

  470. 

  471.     void initParameter(const uint32_t index, Parameter& parameter) override

  472.     {

  473.         if (index < kCardinalParameterCountAtModules)

  474.         {

  475.             parameter.name = "Parameter ";

  476.             parameter.name += String(index + 1);

  477.             parameter.symbol = "param_";

  478.             parameter.symbol += String(index + 1);

  479.             parameter.unit = "v";

  480.             parameter.hints = kParameterIsAutomatable;

  481.             parameter.ranges.def = 0.0f;

  482.             parameter.ranges.min = 0.0f;

  483.             parameter.ranges.max = 10.0f;

  484.             return;

  485.         }

  486. 

  487.         if (index == kCardinalParameterBypass)

  488.         {

  489.             parameter.initDesignation(kParameterDesignationBypass);

  490.             return;

  491.         }

  492. 

  493.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  494.         if (index < kCardinalParameterCountAtWindow)

  495.         {

  496.             switch (index - kCardinalParameterStartWindow)

  497.             {

  498.             case kWindowParameterShowTooltips:

  499.                 parameter.name = "Show tooltips";

  500.                 parameter.symbol = "tooltips";

  501.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;

  502.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  503.                 parameter.hints |= kParameterIsHidden;

  504.                #endif

  505.                 parameter.ranges.def = rack::settings::tooltips ? 1.f : 0.f;

  506.                 parameter.ranges.min = 0.0f;

  507.                 parameter.ranges.max = 1.0f;

  508.                 break;

  509.             case kWindowParameterCableOpacity:

  510.                 parameter.name = "Cable opacity";

  511.                 parameter.symbol = "cableOpacity";

  512.                 parameter.unit = "%";

  513.                 parameter.hints = kParameterIsAutomatable;

  514.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  515.                 parameter.hints |= kParameterIsHidden;

  516.                #endif

  517.                 parameter.ranges.def = std::min(100.f, std::max(0.f, rack::settings::cableOpacity * 100));

  518.                 parameter.ranges.min = 0.0f;

  519.                 parameter.ranges.max = 100.0f;

  520.                 break;

  521.             case kWindowParameterCableTension:

  522.                 parameter.name = "Cable tension";

  523.                 parameter.symbol = "cableTension";

  524.                 parameter.unit = "%";

  525.                 parameter.hints = kParameterIsAutomatable;

  526.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  527.                 parameter.hints |= kParameterIsHidden;

  528.                #endif

  529.                 parameter.ranges.def = std::min(100.f, std::max(0.f, rack::settings::cableTension * 100));

  530.                 parameter.ranges.min = 0.0f;

  531.                 parameter.ranges.max = 100.0f;

  532.                 break;

  533.             case kWindowParameterRackBrightness:

  534.                 parameter.name = "Room brightness";

  535.                 parameter.symbol = "rackBrightness";

  536.                 parameter.unit = "%";

  537.                 parameter.hints = kParameterIsAutomatable;

  538.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  539.                 parameter.hints |= kParameterIsHidden;

  540.                #endif

  541.                 parameter.ranges.def = std::min(100.f, std::max(0.f, rack::settings::rackBrightness * 100));

  542.                 parameter.ranges.min = 0.0f;

  543.                 parameter.ranges.max = 100.0f;

  544.                 break;

  545.             case kWindowParameterHaloBrightness:

  546.                 parameter.name = "Light Bloom";

  547.                 parameter.symbol = "haloBrightness";

  548.                 parameter.unit = "%";

  549.                 parameter.hints = kParameterIsAutomatable;

  550.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  551.                 parameter.hints |= kParameterIsHidden;

  552.                #endif

  553.                 parameter.ranges.def = std::min(100.f, std::max(0.f, rack::settings::haloBrightness * 100));

  554.                 parameter.ranges.min = 0.0f;

  555.                 parameter.ranges.max = 100.0f;

  556.                 break;

  557.             case kWindowParameterKnobMode:

  558.                 parameter.name = "Knob mode";

  559.                 parameter.symbol = "knobMode";

  560.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  561.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  562.                 parameter.hints |= kParameterIsHidden;

  563.                #endif

  564.                 parameter.ranges.def = RackKnobModeToFloat(rack::settings::knobMode);

  565.                 parameter.ranges.min = 0.0f;

  566.                 parameter.ranges.max = 2.0f;

  567.                 parameter.enumValues.count = 3;

  568.                 parameter.enumValues.restrictedMode = true;

  569.                 parameter.enumValues.values = new ParameterEnumerationValue[3];

  570.                 parameter.enumValues.values[0].label = "Linear";

  571.                 parameter.enumValues.values[0].value = 0.0f;

  572.                 parameter.enumValues.values[1].label = "Absolute rotary";

  573.                 parameter.enumValues.values[1].value = 1.0f;

  574.                 parameter.enumValues.values[2].label = "Relative rotary";

  575.                 parameter.enumValues.values[2].value = 2.0f;

  576.                 break;

  577.             case kWindowParameterWheelKnobControl:

  578.                 parameter.name = "Scroll wheel knob control";

  579.                 parameter.symbol = "knobScroll";

  580.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;

  581.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  582.                 parameter.hints |= kParameterIsHidden;

  583.                #endif

  584.                 parameter.ranges.def = rack::settings::knobScroll ? 1.f : 0.f;

  585.                 parameter.ranges.min = 0.0f;

  586.                 parameter.ranges.max = 1.0f;

  587.                 break;

  588.             case kWindowParameterWheelSensitivity:

  589.                 parameter.name = "Scroll wheel knob sensitivity";

  590.                 parameter.symbol = "knobScrollSensitivity";

  591.                 parameter.hints = kParameterIsAutomatable|kParameterIsLogarithmic;

  592.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  593.                 parameter.hints |= kParameterIsHidden;

  594.                #endif

  595.                 parameter.ranges.def = std::min(10.f, std::max(0.1f, rack::settings::knobScrollSensitivity * 1000));

  596.                 parameter.ranges.min = 0.1f;

  597.                 parameter.ranges.max = 10.0f;

  598.                 break;

  599.             case kWindowParameterLockModulePositions:

  600.                 parameter.name = "Lock module positions";

  601.                 parameter.symbol = "lockModules";

  602.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;

  603.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  604.                 parameter.hints |= kParameterIsHidden;

  605.                #endif

  606.                 parameter.ranges.def = rack::settings::lockModules ? 1.f : 0.f;

  607.                 parameter.ranges.min = 0.0f;

  608.                 parameter.ranges.max = 1.0f;

  609.                 break;

  610.             case kWindowParameterUpdateRateLimit:

  611.                 parameter.name = "Update rate limit";

  612.                 parameter.symbol = "rateLimit";

  613.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  614.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  615.                 parameter.hints |= kParameterIsHidden;

  616.                #endif

  617.                 parameter.ranges.def = 0.0f;

  618.                 parameter.ranges.min = 0.0f;

  619.                 parameter.ranges.max = 2.0f;

  620.                 parameter.enumValues.count = 3;

  621.                 parameter.enumValues.restrictedMode = true;

  622.                 parameter.enumValues.values = new ParameterEnumerationValue[3];

  623.                 parameter.enumValues.values[0].label = "None";

  624.                 parameter.enumValues.values[0].value = 0.0f;

  625.                 parameter.enumValues.values[1].label = "2x";

  626.                 parameter.enumValues.values[1].value = 1.0f;

  627.                 parameter.enumValues.values[2].label = "4x";

  628.                 parameter.enumValues.values[2].value = 2.0f;

  629.                 break;

  630.             case kWindowParameterBrowserSort:

  631.                 parameter.name = "Browser sort";

  632.                 parameter.symbol = "browserSort";

  633.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  634.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  635.                 parameter.hints |= kParameterIsHidden;

  636.                #endif

  637.                 parameter.ranges.def = std::min(rack::settings::BROWSER_SORT_RANDOM,

  638.                                                 std::max(rack::settings::BROWSER_SORT_UPDATED,

  639.                                                          rack::settings::browserSort));

  640.                 parameter.ranges.min = rack::settings::BROWSER_SORT_UPDATED;

  641.                 parameter.ranges.max = rack::settings::BROWSER_SORT_RANDOM;

  642.                 parameter.enumValues.count = 6;

  643.                 parameter.enumValues.restrictedMode = true;

  644.                 parameter.enumValues.values = new ParameterEnumerationValue[6];

  645.                 parameter.enumValues.values[0].label = "Updated";

  646.                 parameter.enumValues.values[0].value = rack::settings::BROWSER_SORT_UPDATED;

  647.                 parameter.enumValues.values[1].label = "Last used";

  648.                 parameter.enumValues.values[1].value = rack::settings::BROWSER_SORT_LAST_USED;

  649.                 parameter.enumValues.values[2].label = "Most used";

  650.                 parameter.enumValues.values[2].value = rack::settings::BROWSER_SORT_MOST_USED;

  651.                 parameter.enumValues.values[3].label = "Brand";

  652.                 parameter.enumValues.values[3].value = rack::settings::BROWSER_SORT_BRAND;

  653.                 parameter.enumValues.values[4].label = "Name";

  654.                 parameter.enumValues.values[4].value = rack::settings::BROWSER_SORT_NAME;

  655.                 parameter.enumValues.values[5].label = "Random";

  656.                 parameter.enumValues.values[5].value = rack::settings::BROWSER_SORT_RANDOM;

  657.                 break;

  658.             case kWindowParameterBrowserZoom:

  659.                 parameter.name = "Browser zoom";

  660.                 parameter.symbol = "browserZoom";

  661.                 parameter.hints = kParameterIsAutomatable;

  662.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  663.                 parameter.hints |= kParameterIsHidden;

  664.                #endif

  665.                 parameter.unit = "%";

  666.                 parameter.ranges.def = std::min(200.f, std::max(25.f, std::pow(2.f, rack::settings::browserZoom) * 100.0f));

  667.                 parameter.ranges.min = 25.0f;

  668.                 parameter.ranges.max = 200.0f;

  669.                 parameter.enumValues.count = 7;

  670.                 parameter.enumValues.restrictedMode = true;

  671.                 parameter.enumValues.values = new ParameterEnumerationValue[7];

  672.                 parameter.enumValues.values[0].label = "25";

  673.                 parameter.enumValues.values[0].value = 25.0f;

  674.                 parameter.enumValues.values[1].label = "35";

  675.                 parameter.enumValues.values[1].value = 35.0f;

  676.                 parameter.enumValues.values[2].label = "50";

  677.                 parameter.enumValues.values[2].value = 50.0f;

  678.                 parameter.enumValues.values[3].label = "71";

  679.                 parameter.enumValues.values[3].value = 71.0f;

  680.                 parameter.enumValues.values[4].label = "100";

  681.                 parameter.enumValues.values[4].value = 100.0f;

  682.                 parameter.enumValues.values[5].label = "141";

  683.                 parameter.enumValues.values[5].value = 141.0f;

  684.                 parameter.enumValues.values[6].label = "200";

  685.                 parameter.enumValues.values[6].value = 200.0f;

  686.                 break;

  687.             case kWindowParameterInvertZoom:

  688.                 parameter.name = "Invert zoom";

  689.                 parameter.symbol = "invertZoom";

  690.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;

  691.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  692.                 parameter.hints |= kParameterIsHidden;

  693.                #endif

  694.                 parameter.ranges.def = rack::settings::invertZoom ? 1.f : 0.f;

  695.                 parameter.ranges.min = 0.0f;

  696.                 parameter.ranges.max = 1.0f;

  697.                 break;

  698.             case kWindowParameterSqueezeModulePositions:

  699.                 parameter.name = "Auto-squeeze module positions";

  700.                 parameter.symbol = "squeezeModules";

  701.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger|kParameterIsBoolean;

  702.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  703.                 parameter.hints |= kParameterIsHidden;

  704.                #endif

  705.                 parameter.ranges.def = rack::settings::squeezeModules ? 1.f : 0.f;

  706.                 parameter.ranges.min = 0.0f;

  707.                 parameter.ranges.max = 1.0f;

  708.                 break;

  709.             }

  710.         }

  711.        #endif

  712. 

  713.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  714.         switch (index)

  715.         {

  716.         case kCardinalParameterMiniAudioIn1:

  717.             parameter.name = "Report Audio Input 1";

  718.             parameter.symbol = "r_audio_in_1";

  719.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  720.             parameter.ranges.def = 0.0f;

  721.             parameter.ranges.min = 0.0f;

  722.             parameter.ranges.max = 1.0f;

  723.             break;

  724.         case kCardinalParameterMiniAudioIn2:

  725.             parameter.name = "Report Audio Input 2";

  726.             parameter.symbol = "r_audio_in_2";

  727.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  728.             parameter.ranges.def = 0.0f;

  729.             parameter.ranges.min = 0.0f;

  730.             parameter.ranges.max = 1.0f;

  731.             break;

  732.         case kCardinalParameterMiniCVIn1:

  733.             parameter.name = "Report CV Input 1";

  734.             parameter.symbol = "r_cv_in_1";

  735.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  736.             parameter.ranges.def = -10.0f;

  737.             parameter.ranges.min = 0.0f;

  738.             parameter.ranges.max = 10.0f;

  739.             break;

  740.         case kCardinalParameterMiniCVIn2:

  741.             parameter.name = "Report CV Input 2";

  742.             parameter.symbol = "r_cv_in_2";

  743.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  744.             parameter.ranges.def = -10.0f;

  745.             parameter.ranges.min = 0.0f;

  746.             parameter.ranges.max = 10.0f;

  747.             break;

  748.         case kCardinalParameterMiniCVIn3:

  749.             parameter.name = "Report CV Input 3";

  750.             parameter.symbol = "r_cv_in_3";

  751.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  752.             parameter.ranges.def = -10.0f;

  753.             parameter.ranges.min = 0.0f;

  754.             parameter.ranges.max = 10.0f;

  755.             break;

  756.         case kCardinalParameterMiniCVIn4:

  757.             parameter.name = "Report CV Input 4";

  758.             parameter.symbol = "r_cv_in_4";

  759.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  760.             parameter.ranges.def = -10.0f;

  761.             parameter.ranges.min = 0.0f;

  762.             parameter.ranges.max = 10.0f;

  763.             break;

  764.         case kCardinalParameterMiniCVIn5:

  765.             parameter.name = "Report CV Input 5";

  766.             parameter.symbol = "r_cv_in_5";

  767.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  768.             parameter.ranges.def = -10.0f;

  769.             parameter.ranges.min = 0.0f;

  770.             parameter.ranges.max = 10.0f;

  771.             break;

  772.         case kCardinalParameterMiniTimeFlags:

  773.             parameter.name = "Report Time Flags";

  774.             parameter.symbol = "r_time_flags";

  775.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  776.             parameter.ranges.def = 0x0;

  777.             parameter.ranges.min = 0x0;

  778.             parameter.ranges.max = 0x7;

  779.             break;

  780.         case kCardinalParameterMiniTimeBar:

  781.             parameter.name = "Report Time Bar";

  782.             parameter.symbol = "r_time_bar";

  783.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  784.             parameter.ranges.def = 1.0f;

  785.             parameter.ranges.min = 1.0f;

  786.             parameter.ranges.max = FLT_MAX;

  787.             break;

  788.         case kCardinalParameterMiniTimeBeat:

  789.             parameter.name = "Report Time Beat";

  790.             parameter.symbol = "r_time_beat";

  791.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  792.             parameter.ranges.def = 1.0f;

  793.             parameter.ranges.min = 1.0f;

  794.             parameter.ranges.max = 128.0f;

  795.             break;

  796.         case kCardinalParameterMiniTimeBeatsPerBar:

  797.             parameter.name = "Report Time Beats Per Bar";

  798.             parameter.symbol = "r_time_beatsPerBar";

  799.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  800.             parameter.ranges.def = 4.0f;

  801.             parameter.ranges.min = 0.0f;

  802.             parameter.ranges.max = 128.0f;

  803.             break;

  804.         case kCardinalParameterMiniTimeBeatType:

  805.             parameter.name = "Report Time Beat Type";

  806.             parameter.symbol = "r_time_beatType";

  807.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  808.             parameter.ranges.def = 4.0f;

  809.             parameter.ranges.min = 0.0f;

  810.             parameter.ranges.max = 128.0f;

  811.             break;

  812.         case kCardinalParameterMiniTimeFrame:

  813.             parameter.name = "Report Time Frame";

  814.             parameter.symbol = "r_time_frame";

  815.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  816.             parameter.ranges.def = 0.0f;

  817.             parameter.ranges.min = 0.0f;

  818.             parameter.ranges.max = FLT_MAX;

  819.             break;

  820.         case kCardinalParameterMiniTimeBarStartTick:

  821.             parameter.name = "Report Time BarStartTick";

  822.             parameter.symbol = "r_time_barStartTick";

  823.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  824.             parameter.ranges.def = 0.0f;

  825.             parameter.ranges.min = 0.0f;

  826.             parameter.ranges.max = FLT_MAX;

  827.             break;

  828.         case kCardinalParameterMiniTimeBeatsPerMinute:

  829.             parameter.name = "Report Time Beats Per Minute";

  830.             parameter.symbol = "r_time_bpm";

  831.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  832.             parameter.ranges.def = 20.0f;

  833.             parameter.ranges.min = 120.0f;

  834.             parameter.ranges.max = 999.0f;

  835.             break;

  836.         case kCardinalParameterMiniTimeTick:

  837.             parameter.name = "Report Time Tick";

  838.             parameter.symbol = "r_time_tick";

  839.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  840.             parameter.ranges.def = 0.0f;

  841.             parameter.ranges.min = 0.0f;

  842.             parameter.ranges.max = 8192.0f;

  843.             break;

  844.         case kCardinalParameterMiniTimeTicksPerBeat:

  845.             parameter.name = "Report Time Ticks Per Beat";

  846.             parameter.symbol = "r_time_ticksPerBeat";

  847.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  848.             parameter.ranges.def = 0.0f;

  849.             parameter.ranges.min = 0.0f;

  850.             parameter.ranges.max = 8192.0f;

  851.             break;

  852.         }

  853.        #endif

  854.     }

  855. 

  856.     void initState(const uint32_t index, State& state) override

  857.     {

  858.         switch (index)

  859.         {

  860.         case kCardinalStatePatch:

  861.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  862.             state.hints = kStateIsHostReadable;

  863.            #else

  864.             state.hints = kStateIsOnlyForDSP | kStateIsBase64Blob;

  865.            #endif

  866.             if (FILE* const f = std::fopen(context->patch->factoryTemplatePath.c_str(), "r"))

  867.             {

  868.                 std::fseek(f, 0, SEEK_END);

  869.                 if (const long fileSize = std::ftell(f))

  870.                 {

  871.                     std::fseek(f, 0, SEEK_SET);

  872.                     char* const fileContent = new char[fileSize+1];

  873. 

  874.                     if (std::fread(fileContent, fileSize, 1, f) == 1)

  875.                     {

  876.                         fileContent[fileSize] = '\0';

  877.                        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  878.                         state.defaultValue = fileContent;

  879.                        #else

  880.                         state.defaultValue = String::asBase64(fileContent, fileSize);

  881.                        #endif

  882.                     }

  883. 

  884.                     delete[] fileContent;

  885.                 }

  886.                 std::fclose(f);

  887.             }

  888.             state.key = "patch";

  889.             state.label = "Patch";

  890.             break;

  891.         case kCardinalStateScreenshot:

  892.             state.hints = kStateIsHostReadable | kStateIsBase64Blob;

  893.             state.key = "screenshot";

  894.             state.label = "Screenshot";

  895.             break;

  896.         case kCardinalStateComment:

  897.             state.hints = kStateIsHostWritable;

  898.             state.key = "comment";

  899.             state.label = "Comment";

  900.             break;

  901.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  902.         case kCardinalStateModuleInfos:

  903.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  904.             state.hints = kStateIsHostReadable;

  905.            #else

  906.             state.hints = kStateIsOnlyForDSP;

  907.            #endif

  908.             state.defaultValue = "{}";

  909.             state.key = "moduleInfos";

  910.             state.label = "moduleInfos";

  911.             break;

  912.         case kCardinalStateWindowSize:

  913.             state.hints = kStateIsOnlyForUI;

  914.             // state.defaultValue = String("%d:%d", DISTRHO_UI_DEFAULT_WIDTH, DISTRHO_UI_DEFAULT_HEIGHT);

  915.             state.key = "windowSize";

  916.             state.label = "Window size";

  917.             break;

  918.        #endif

  919.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  920.         case kCardinalStateParamChange:

  921.             state.hints = kStateIsHostReadable | kStateIsOnlyForDSP;

  922.             state.key = "param";

  923.             state.label = "ParamChange";

  924.             break;

  925.        #endif

  926.         }

  927.     }

  928. 

  929.    /* --------------------------------------------------------------------------------------------------------

  930.     * Internal data */

  931. 

  932.     float getParameterValue(uint32_t index) const override

  933.     {

  934.         // host mapped parameters

  935.         if (index < kCardinalParameterCountAtModules)

  936.             return context->parameters[index];

  937. 

  938.         // bypass

  939.         if (index == kCardinalParameterBypass)

  940.             return context->bypassed ? 1.0f : 0.0f;

  941. 

  942.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  943.         if (index < kCardinalParameterCountAtWindow)

  944.             return fWindowParameters[index - kCardinalParameterStartWindow];

  945.        #endif

  946. 

  947.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  948.         if (index < kCardinalParameterCountAtMini)

  949.             return fMiniReportValues[index - kCardinalParameterStartMini];

  950.        #endif

  951. 

  952.         return 0.0f;

  953.     }

  954. 

  955.     void setParameterValue(uint32_t index, float value) override

  956.     {

  957.         // host mapped parameters

  958.         if (index < kCardinalParameterCountAtModules)

  959.         {

  960.             context->parameters[index] = value;

  961.             return;

  962.         }

  963. 

  964.         // bypass

  965.         if (index == kCardinalParameterBypass)

  966.         {

  967.             context->bypassed = value > 0.5f;

  968.             return;

  969.         }

  970. 

  971.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  972.         if (index < kCardinalParameterCountAtWindow)

  973.         {

  974.             fWindowParameters[index - kCardinalParameterStartWindow] = value;

  975.             return;

  976.         }

  977.        #endif

  978.     }

  979. 

  980.     String getState(const char* const key) const override

  981.     {

  982.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  983.         if (std::strcmp(key, "moduleInfos") == 0)

  984.         {

  985.             json_t* const rootJ = json_object();

  986.             DISTRHO_SAFE_ASSERT_RETURN(rootJ != nullptr, String());

  987. 

  988.             for (const auto& pluginPair : rack::settings::moduleInfos)

  989.             {

  990.                 json_t* const pluginJ = json_object();

  991.                 DISTRHO_SAFE_ASSERT_CONTINUE(pluginJ != nullptr);

  992. 

  993.                 for (const auto& modulePair : pluginPair.second)

  994.                 {

  995.                     json_t* const moduleJ = json_object();

  996.                     DISTRHO_SAFE_ASSERT_CONTINUE(moduleJ != nullptr);

  997. 

  998.                     const rack::settings::ModuleInfo& m(modulePair.second);

  999. 

  1000.                     // To make setting.json smaller, only set properties if not default values.

  1001.                     if (m.favorite)

  1002.                         json_object_set_new(moduleJ, "favorite", json_boolean(m.favorite));

  1003.                     if (m.added > 0)

  1004.                         json_object_set_new(moduleJ, "added", json_integer(m.added));

  1005.                     if (std::isfinite(m.lastAdded) && d_isNotZero(m.lastAdded))

  1006.                         json_object_set_new(moduleJ, "lastAdded", json_real(m.lastAdded));

  1007. 

  1008.                     if (json_object_size(moduleJ))

  1009.                         json_object_set_new(pluginJ, modulePair.first.c_str(), moduleJ);

  1010.                     else

  1011.                         json_decref(moduleJ);

  1012.                 }

  1013. 

  1014.                 if (json_object_size(pluginJ))

  1015.                     json_object_set_new(rootJ, pluginPair.first.c_str(), pluginJ);

  1016.                 else

  1017.                     json_decref(pluginJ);

  1018.             }

  1019. 

  1020.             const String info(json_dumps(rootJ, JSON_COMPACT), false);

  1021.             json_decref(rootJ);

  1022. 

  1023.             return info;

  1024.         }

  1025. 

  1026.         if (std::strcmp(key, "windowSize") == 0)

  1027.             return fState.windowSize;

  1028.        #endif

  1029. 

  1030.         if (std::strcmp(key, "comment") == 0)

  1031.             return fState.comment;

  1032.         if (std::strcmp(key, "screenshot") == 0)

  1033.             return fState.screenshot;

  1034. 

  1035.         if (std::strcmp(key, "patch") != 0)

  1036.             return String();

  1037.         if (fAutosavePath.empty())

  1038.             return String();

  1039. 

  1040.         std::vector<uint8_t> data;

  1041. 

  1042.         {

  1043.             const ScopedContext sc(this);

  1044. 

  1045.             context->engine->prepareSave();

  1046.             context->patch->saveAutosave();

  1047.             context->patch->cleanAutosave();

  1048.             // context->history->setSaved();

  1049. 

  1050.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1051.             FILE* const f = std::fopen(rack::system::join(context->patch->autosavePath, "patch.json").c_str(), "r");

  1052.             DISTRHO_SAFE_ASSERT_RETURN(f != nullptr, String());

  1053. 

  1054.             DEFER({

  1055.                 std::fclose(f);

  1056.             });

  1057. 

  1058.             std::fseek(f, 0, SEEK_END);

  1059.             const long fileSize = std::ftell(f);

  1060.             DISTRHO_SAFE_ASSERT_RETURN(fileSize > 0, String());

  1061. 

  1062.             std::fseek(f, 0, SEEK_SET);

  1063.             char* const fileContent = static_cast<char*>(std::malloc(fileSize+1));

  1064. 

  1065.             DISTRHO_SAFE_ASSERT_RETURN(std::fread(fileContent, fileSize, 1, f) == 1, String());

  1066.             fileContent[fileSize] = '\0';

  1067. 

  1068.             return String(fileContent, false);

  1069.            #else

  1070.             try {

  1071.                 data = rack::system::archiveDirectory(fAutosavePath, 1);

  1072.             } DISTRHO_SAFE_EXCEPTION_RETURN("getState archiveDirectory", String());

  1073.            #endif

  1074.         }

  1075. 

  1076.         return String::asBase64(data.data(), data.size());

  1077.     }

  1078. 

  1079.     void setState(const char* const key, const char* const value) override

  1080.     {

  1081.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1082.         if (std::strcmp(key, "param") == 0)

  1083.         {

  1084.             long long moduleId = 0;

  1085.             int paramId = 0;

  1086.             float paramValue = 0.f;

  1087.             {

  1088.                 const ScopedSafeLocale cssl;

  1089.                 std::sscanf(value, "%lld:%d:%f", &moduleId, &paramId, &paramValue);

  1090.             }

  1091. 

  1092.             rack::engine::Module* const module = context->engine->getModule(moduleId);

  1093.             DISTRHO_SAFE_ASSERT_RETURN(module != nullptr,);

  1094. 

  1095.             context->engine->setParamValue(module, paramId, paramValue);

  1096.             return;

  1097.         }

  1098.        #endif

  1099. 

  1100.        #if CARDINAL_VARIANT_MINI || !defined(HEADLESS)

  1101.         if (std::strcmp(key, "moduleInfos") == 0)

  1102.         {

  1103.             json_error_t error;

  1104.             json_t* const rootJ = json_loads(value, 0, &error);

  1105.             DISTRHO_SAFE_ASSERT_RETURN(rootJ != nullptr,);

  1106. 

  1107.             const char* pluginSlug;

  1108.             json_t* pluginJ;

  1109. 

  1110.             json_object_foreach(rootJ, pluginSlug, pluginJ)

  1111.             {

  1112.                 const char* moduleSlug;

  1113.                 json_t* moduleJ;

  1114. 

  1115.                 json_object_foreach(pluginJ, moduleSlug, moduleJ)

  1116.                 {

  1117.                     rack::settings::ModuleInfo m;

  1118. 

  1119.                     if (json_t* const favoriteJ = json_object_get(moduleJ, "favorite"))

  1120.                         m.favorite = json_boolean_value(favoriteJ);

  1121. 

  1122.                     if (json_t* const addedJ = json_object_get(moduleJ, "added"))

  1123.                         m.added = json_integer_value(addedJ);

  1124. 

  1125.                     if (json_t* const lastAddedJ = json_object_get(moduleJ, "lastAdded"))

  1126.                         m.lastAdded = json_number_value(lastAddedJ);

  1127. 

  1128.                     rack::settings::moduleInfos[pluginSlug][moduleSlug] = m;

  1129.                 }

  1130.             }

  1131. 

  1132.             json_decref(rootJ);

  1133.             return;

  1134.         }

  1135.         if (std::strcmp(key, "windowSize") == 0)

  1136.         {

  1137.             fState.windowSize = value;

  1138.             return;

  1139.         }

  1140.        #endif

  1141. 

  1142.         if (std::strcmp(key, "comment") == 0)

  1143.         {

  1144.             fState.comment = value;

  1145.             return;

  1146.         }

  1147. 

  1148.         if (std::strcmp(key, "screenshot") == 0)

  1149.         {

  1150.             fState.screenshot = value;

  1151.             return;

  1152.         }

  1153. 

  1154.         if (std::strcmp(key, "patch") != 0)

  1155.             return;

  1156.         if (fAutosavePath.empty())

  1157.             return;

  1158. 

  1159.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1160.         rack::system::removeRecursively(fAutosavePath);

  1161.         rack::system::createDirectories(fAutosavePath);

  1162. 

  1163.         FILE* const f = std::fopen(rack::system::join(fAutosavePath, "patch.json").c_str(), "w");

  1164.         DISTRHO_SAFE_ASSERT_RETURN(f != nullptr,);

  1165. 

  1166.         std::fwrite(value, std::strlen(value), 1, f);

  1167.         std::fclose(f);

  1168.        #else

  1169.         const std::vector<uint8_t> data(d_getChunkFromBase64String(value));

  1170. 

  1171.         DISTRHO_SAFE_ASSERT_RETURN(data.size() >= 4,);

  1172. 

  1173.         rack::system::removeRecursively(fAutosavePath);

  1174.         rack::system::createDirectories(fAutosavePath);

  1175. 

  1176.         static constexpr const char zstdMagic[] = "\x28\xb5\x2f\xfd";

  1177. 

  1178.         if (std::memcmp(data.data(), zstdMagic, sizeof(zstdMagic)) != 0)

  1179.         {

  1180.             FILE* const f = std::fopen(rack::system::join(fAutosavePath, "patch.json").c_str(), "w");

  1181.             DISTRHO_SAFE_ASSERT_RETURN(f != nullptr,);

  1182. 

  1183.             std::fwrite(data.data(), data.size(), 1, f);

  1184.             std::fclose(f);

  1185.         }

  1186.         else

  1187.         {

  1188.             try {

  1189.                 rack::system::unarchiveToDirectory(data, fAutosavePath);

  1190.             } DISTRHO_SAFE_EXCEPTION_RETURN("setState unarchiveToDirectory",);

  1191.         }

  1192.        #endif

  1193. 

  1194.         const ScopedContext sc(this);

  1195. 

  1196.         try {

  1197.             context->patch->loadAutosave();

  1198.         } catch(const rack::Exception& e) {

  1199.             d_stderr(e.what());

  1200.         } DISTRHO_SAFE_EXCEPTION_RETURN("setState loadAutosave",);

  1201. 

  1202.         // context->history->setSaved();

  1203.     }

  1204. 

  1205.    /* --------------------------------------------------------------------------------------------------------

  1206.     * Process */

  1207. 

  1208.     void activate() override

  1209.     {

  1210.         context->bufferSize = getBufferSize();

  1211. 

  1212.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1213.         fAudioBufferCopy = new float*[DISTRHO_PLUGIN_NUM_INPUTS];

  1214.         for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)

  1215.             fAudioBufferCopy[i] = new float[context->bufferSize];

  1216.        #endif

  1217. 

  1218.         fNextExpectedFrame = 0;

  1219.     }

  1220. 

  1221.     void deactivate() override

  1222.     {

  1223.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1224.         if (fAudioBufferCopy != nullptr)

  1225.         {

  1226.             for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)

  1227.                 delete[] fAudioBufferCopy[i];

  1228.             delete[] fAudioBufferCopy;

  1229.             fAudioBufferCopy = nullptr;

  1230.         }

  1231.        #endif

  1232.     }

  1233. 

  1234.     void run(const float** const inputs, float** const outputs, const uint32_t frames,

  1235.              const MidiEvent* const midiEvents, const uint32_t midiEventCount) override

  1236.     {

  1237.         const ScopedDenormalDisable sdd;

  1238. 

  1239.         rack::contextSet(context);

  1240. 

  1241.         const bool bypassed = context->bypassed;

  1242. 

  1243.         {

  1244.             const TimePosition& timePos(getTimePosition());

  1245. 

  1246.             bool reset = timePos.playing && (timePos.frame == 0 || d_isDiffHigherThanLimit(fNextExpectedFrame, timePos.frame, (uint64_t)2));

  1247. 

  1248.             // ignore hosts which cannot supply time frame position

  1249.             if (context->playing == timePos.playing && timePos.frame == 0 && context->frame == 0)

  1250.                 reset = false;

  1251. 

  1252.             context->playing = timePos.playing;

  1253.             context->bbtValid = timePos.bbt.valid;

  1254.             context->frame = timePos.frame;

  1255. 

  1256.             if (timePos.bbt.valid)

  1257.             {

  1258.                 const double samplesPerTick = 60.0 * getSampleRate()

  1259.                                             / timePos.bbt.beatsPerMinute

  1260.                                             / timePos.bbt.ticksPerBeat;

  1261.                 context->bar = timePos.bbt.bar;

  1262.                 context->beat = timePos.bbt.beat;

  1263.                 context->beatsPerBar = timePos.bbt.beatsPerBar;

  1264.                 context->beatType = timePos.bbt.beatType;

  1265.                 context->barStartTick = timePos.bbt.barStartTick;

  1266.                 context->beatsPerMinute = timePos.bbt.beatsPerMinute;

  1267.                 context->tick = timePos.bbt.tick;

  1268.                 context->ticksPerBeat = timePos.bbt.ticksPerBeat;

  1269.                 context->ticksPerClock = timePos.bbt.ticksPerBeat / timePos.bbt.beatType;

  1270.                 context->ticksPerFrame = 1.0 / samplesPerTick;

  1271.                 context->tickClock = std::fmod(timePos.bbt.tick, context->ticksPerClock);

  1272.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1273.                 fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = timePos.bbt.bar;

  1274.                 fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = timePos.bbt.beat;

  1275.                 fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = timePos.bbt.beatsPerBar;

  1276.                 fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = timePos.bbt.beatType;

  1277.                 fMiniReportValues[kCardinalParameterMiniTimeBarStartTick - kCardinalParameterStartMini] = timePos.bbt.barStartTick;

  1278.                 fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = timePos.bbt.beatsPerMinute;

  1279.                 fMiniReportValues[kCardinalParameterMiniTimeTick - kCardinalParameterStartMini] = timePos.bbt.tick;

  1280.                 fMiniReportValues[kCardinalParameterMiniTimeTicksPerBeat - kCardinalParameterStartMini] = timePos.bbt.ticksPerBeat;

  1281.                #endif

  1282.             }

  1283. 

  1284.             context->reset = reset;

  1285.             fNextExpectedFrame = timePos.playing ? timePos.frame + frames : 0;

  1286. 

  1287.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1288.             const int flags = (timePos.playing ? 0x1 : 0x0)

  1289.                             | (timePos.bbt.valid ? 0x2 : 0x0)

  1290.                             | (reset ? 0x4 : 0x0);

  1291.             fMiniReportValues[kCardinalParameterMiniTimeFlags - kCardinalParameterStartMini] = flags;

  1292.             fMiniReportValues[kCardinalParameterMiniTimeFrame - kCardinalParameterStartMini] = timePos.frame / getSampleRate();

  1293.            #endif

  1294.         }

  1295. 

  1296.         // separate buffers, use them

  1297.         if (inputs != outputs && (inputs == nullptr || inputs[0] != outputs[0]))

  1298.         {

  1299.             context->dataIns = inputs;

  1300.             context->dataOuts = outputs;

  1301.         }

  1302.         // inline processing, use a safe copy

  1303.         else

  1304.         {

  1305.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1306.             for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)

  1307.             {

  1308.                #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

  1309.                 // can be null on main and mini variants

  1310.                 if (inputs[i] != nullptr)

  1311.                #endif

  1312.                     std::memcpy(fAudioBufferCopy[i], inputs[i], sizeof(float)*frames);

  1313.             }

  1314.             context->dataIns = fAudioBufferCopy;

  1315.            #else

  1316.             context->dataIns = nullptr;

  1317.            #endif

  1318.             context->dataOuts = outputs;

  1319.         }

  1320. 

  1321.         for (int i=0; i<DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)

  1322.         {

  1323.            #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

  1324.             // can be null on main and mini variants

  1325.             if (outputs[i] != nullptr)

  1326.            #endif

  1327.                 std::memset(outputs[i], 0, sizeof(float)*frames);

  1328.         }

  1329. 

  1330.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  1331.         for (int i=0; i<DISTRHO_PLUGIN_NUM_INPUTS; ++i)

  1332.             fMiniReportValues[i] = context->dataIns[i][0];

  1333.        #endif

  1334. 

  1335.         if (bypassed)

  1336.         {

  1337.             if (fWasBypassed != bypassed)

  1338.             {

  1339.                 context->midiEvents = bypassMidiEvents;

  1340.                 context->midiEventCount = 16;

  1341.             }

  1342.             else

  1343.             {

  1344.                 context->midiEvents = nullptr;

  1345.                 context->midiEventCount = 0;

  1346.             }

  1347.         }

  1348.         else

  1349.         {

  1350.             context->midiEvents = midiEvents;

  1351.             context->midiEventCount = midiEventCount;

  1352.         }

  1353. 

  1354.         ++context->processCounter;

  1355.         context->engine->stepBlock(frames);

  1356. 

  1357.         fWasBypassed = bypassed;

  1358.     }

  1359. 

  1360.     void sampleRateChanged(const double newSampleRate) override

  1361.     {

  1362.         rack::contextSet(context);

  1363.         rack::settings::sampleRate = newSampleRate;

  1364.         context->sampleRate = newSampleRate;

  1365.         context->engine->setSampleRate(newSampleRate);

  1366.     }

  1367. 

  1368.     // -------------------------------------------------------------------------------------------------------

  1369. 

  1370. private:

  1371.    /**

  1372.       Set our plugin class as non-copyable and add a leak detector just in case.

  1373.     */

  1374.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CardinalPlugin)

  1375. };

  1376. 

  1377. CardinalPluginContext* getRackContextFromPlugin(void* const ptr)

  1378. {

  1379.     return static_cast<CardinalPlugin*>(ptr)->getRackContext();

  1380. }

  1381. 

  1382. /* ------------------------------------------------------------------------------------------------------------

  1383.  * Plugin entry point, called by DPF to create a new plugin instance. */

  1384. 

  1385. Plugin* createPlugin()

  1386. {

  1387.     return new CardinalPlugin();

  1388. }

  1389. 

  1390. // --------------------------------------------------------------------------------------------------------------------

  1391. 

  1392. END_NAMESPACE_DISTRHO