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

1316 lines
51KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021-2024 Filipe Coelho <falktx@falktx.com>

  4.  * SPDX-License-Identifier: GPL-3.0-or-later

  5.  */

  6. 

  7. #include <library.hpp>

  8. #include <midi.hpp>

  9. #include <patch.hpp>

  10. #include <plugin.hpp>

  11. #include <random.hpp>

  12. #include <settings.hpp>

  13. #include <system.hpp>

  14. 

  15. #include <app/Scene.hpp>

  16. #include <engine/Engine.hpp>

  17. #include <ui/common.hpp>

  18. #include <widget/Widget.hpp>

  19. #include <window/Window.hpp>

  20. 

  21. #ifdef NDEBUG

  22. # undef DEBUG

  23. #endif

  24. 

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

  26. # include <lo/lo.h>

  27. # include "extra/Thread.hpp"

  28. #endif

  29. 

  30. #include <cfloat>

  31. #include <list>

  32. 

  33. #include "CardinalCommon.hpp"

  34. #include "DistrhoPluginUtils.hpp"

  35. #include "CardinalPluginContext.hpp"

  36. #include "extra/Base64.hpp"

  37. #include "extra/ScopedDenormalDisable.hpp"

  38. #include "extra/ScopedSafeLocale.hpp"

  39. 

  40. #ifdef DISTRHO_OS_WASM

  41. # include <emscripten/emscripten.h>

  42. #else

  43. # include "extra/SharedResourcePointer.hpp"

  44. #endif

  45. 

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

  47. # include "extra/ScopedValueSetter.hpp"

  48. #endif

  49. 

  50. extern const std::string CARDINAL_VERSION;

  51. 

  52. namespace rack {

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

  54. namespace app {

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

  56. }

  57. #endif

  58. #ifdef DISTRHO_OS_WASM

  59. namespace asset {

  60. std::string patchesPath();

  61. }

  62. #endif

  63. namespace engine {

  64. void Engine_setAboutToClose(Engine*);

  65. }

  66. }

  67. 

  68. START_NAMESPACE_DISTRHO

  69. 

  70. template<typename T>

  71. static inline

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

  73. {

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

  75. }

  76. 

  77. #if DISTRHO_PLUGIN_HAS_UI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  80. #endif

  81. 

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

  83. 

  84. #ifdef DISTRHO_OS_WASM

  85. static char* getPatchFileEncodedInURL() {

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

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

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

  89.         if (!patch)

  90.         return null;

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

  92.         var str = _malloc(length);

  93.         stringToUTF8(patch, str, length);

  94.         return str;

  95.     }));

  96. };

  97. 

  98. static char* getPatchRemoteURL() {

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

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

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

  102.         if (!patch)

  103.         return null;

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

  105.         var str = _malloc(length);

  106.         stringToUTF8(patch, str, length);

  107.         return str;

  108.     }));

  109. };

  110. 

  111. static char* getPatchStorageSlug() {

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

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

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

  115.         if (!patch)

  116.         return null;

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

  118.         var str = _malloc(length);

  119.         stringToUTF8(patch, str, length);

  120.         return str;

  121.     }));

  122. };

  123. #endif

  124. 

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

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

  127. {

  128.     switch (knobMode)

  129.     {

  130.     case rack::settings::KNOB_MODE_LINEAR:

  131.         return 0.f;

  132.     case rack::settings::KNOB_MODE_ROTARY_ABSOLUTE:

  133.         return 1.f;

  134.     case rack::settings::KNOB_MODE_ROTARY_RELATIVE:

  135.         return 2.f;

  136.     // unused in Rack

  137.     case rack::settings::KNOB_MODE_SCALED_LINEAR:

  138.         break;

  139.     }

  140. 

  141.     return 0.f;

  142. }

  143. #endif

  144. 

  145. // -----------------------------------------------------------------------------------------------------------

  146. 

  147. struct ScopedContext {

  148.     ScopedContext(const CardinalBasePlugin* const plugin)

  149.     {

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

  151.     }

  152. 

  153.     ~ScopedContext()

  154.     {

  155.         rack::contextSet(nullptr);

  156.     }

  157. };

  158. 

  159. // -----------------------------------------------------------------------------------------------------------

  160. 

  161. class CardinalPlugin : public CardinalBasePlugin

  162. {

  163.    #ifdef DISTRHO_OS_WASM

  164.     ScopedPointer<Initializer> fInitializer;

  165.    #else

  166.     SharedResourcePointer<Initializer> fInitializer;

  167.    #endif

  168. 

  169.    #if DISTRHO_PLUGIN_NUM_INPUTS != 0

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

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

  172.      */

  173.     float** fAudioBufferCopy;

  174.    #endif

  175. 

  176.     std::string fAutosavePath;

  177.     uint64_t fNextExpectedFrame;

  178. 

  179.     struct {

  180.         String comment;

  181.         String screenshot;

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

  183.         String windowSize;

  184.        #endif

  185.     } fState;

  186. 

  187.     // bypass handling

  188.     bool fWasBypassed;

  189.     MidiEvent bypassMidiEvents[16];

  190. 

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

  192.     // real values, not VCV interpreted ones

  193.     float fWindowParameters[kWindowParameterCount];

  194.    #endif

  195.    #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  196.     float fMiniReportValues[kCardinalParameterCountAtMini - kCardinalParameterStartMini];

  197.    #endif

  198. 

  199. public:

  200.     CardinalPlugin()

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

  202.          #ifdef DISTRHO_OS_WASM

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

  204.          #else

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

  206.          #endif

  207.          #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  208.           fAudioBufferCopy(nullptr),

  209.          #endif

  210.           fNextExpectedFrame(0),

  211.           fWasBypassed(false)

  212.     {

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

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

  215.             fInitializer->loadSettings(true);

  216. 

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

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

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

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

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

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

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

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

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

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

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

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

  229.                                                                            rack::settings::browserSort));

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

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

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

  233.         // not saved

  234.         fWindowParameters[kWindowParameterUpdateRateLimit] = 0.0f;

  235.        #endif

  236.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

  238.         fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = 1;

  239.         fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = 1;

  240.         fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = 4;

  241.         fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = 4;

  242.         fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = 120;

  243.        #endif

  244. 

  245.         // create unique temporary path for this instance

  246.         try {

  247.             char uidBuf[24];

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

  249. 

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

  251.             {

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

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

  254. 

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

  256.                 {

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

  258.                         fAutosavePath = trypath;

  259.                     break;

  260.                 }

  261.             }

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

  263. 

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

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

  266. 

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

  268.         {

  269.             bypassMidiEvents[i].size = 3;

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

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

  272.         }

  273. 

  274.         const float sampleRate = getSampleRate();

  275.         rack::settings::sampleRate = sampleRate;

  276. 

  277.         context->bufferSize = getBufferSize();

  278.         context->sampleRate = sampleRate;

  279. 

  280.         const ScopedContext sc(this);

  281. 

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

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

  284. 

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

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

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

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

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

  290. 

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

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

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

  294. 

  295.         if (! isDummyInstance())

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

  297. 

  298.        #ifdef DISTRHO_OS_WASM

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

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

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

  302.        #endif

  303.         {

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

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

  306.         }

  307. 

  308.        #ifdef CARDINAL_INIT_OSC_THREAD

  309.         fInitializer->remotePluginInstance = this;

  310.        #endif

  311.     }

  312. 

  313.     ~CardinalPlugin() override

  314.     {

  315.        #ifdef HAVE_LIBLO

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

  317.             fInitializer->remotePluginInstance = nullptr;

  318.        #endif

  319. 

  320.         {

  321.             const ScopedContext sc(this);

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

  323. 

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

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

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

  327.            #endif

  328.             Engine_setAboutToClose(context->engine);

  329.             delete context;

  330.         }

  331. 

  332.         if (! fAutosavePath.empty())

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

  334.     }

  335. 

  336.     CardinalPluginContext* getRackContext() const noexcept

  337.     {

  338.         return context;

  339.     }

  340. 

  341.    #ifdef HAVE_LIBLO

  342.     bool startRemoteServer(const char* const port) override

  343.     {

  344.         if (fInitializer->remotePluginInstance != nullptr)

  345.             return false;

  346.         

  347.         if (fInitializer->startRemoteServer(port))

  348.         {

  349.             fInitializer->remotePluginInstance = this;

  350.             return true;

  351.         }

  352. 

  353.         return false;

  354.     }

  355. 

  356.     void stopRemoteServer() override

  357.     {

  358.         DISTRHO_SAFE_ASSERT_RETURN(fInitializer->remotePluginInstance == this,);

  359. 

  360.         fInitializer->remotePluginInstance = nullptr;

  361.         fInitializer->stopRemoteServer();

  362.     }

  363.     

  364.     void stepRemoteServer() override

  365.     {

  366.         DISTRHO_SAFE_ASSERT_RETURN(fInitializer->remotePluginInstance == this,);

  367. 

  368.         fInitializer->stepRemoteServer();

  369.     }

  370.    #endif

  371. 

  372. protected:

  373.    /* --------------------------------------------------------------------------------------------------------

  374.     * Information */

  375. 

  376.     const char* getLabel() const override

  377.     {

  378.         return DISTRHO_PLUGIN_LABEL;

  379.     }

  380. 

  381.     const char* getDescription() const override

  382.     {

  383.         return ""

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

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

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

  387.         "\n"

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

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

  390.     }

  391. 

  392.     const char* getMaker() const override

  393.     {

  394.         return "DISTRHO";

  395.     }

  396. 

  397.     const char* getHomePage() const override

  398.     {

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

  400.     }

  401. 

  402.     const char* getLicense() const override

  403.     {

  404.         return "GPLv3+";

  405.     }

  406. 

  407.     uint32_t getVersion() const override

  408.     {

  409.         return d_version(0, 24, 4);

  410.     }

  411. 

  412.     int64_t getUniqueId() const override

  413.     {

  414.        #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_NATIVE

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

  416.        #elif CARDINAL_VARIANT_MINI

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

  418.        #elif CARDINAL_VARIANT_FX

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

  420.        #elif CARDINAL_VARIANT_SYNTH

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

  422.        #else

  423.         #error cardinal variant not set

  424.        #endif

  425.     }

  426. 

  427.    /* --------------------------------------------------------------------------------------------------------

  428.     * Init */

  429. 

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

  431.     {

  432.        #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

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

  434. 

  435.         if (index < CARDINAL_NUM_AUDIO_INPUTS)

  436.         {

  437.            #if CARDINAL_VARIANT_MINI

  438.             port.groupId = kPortGroupStereo;

  439.            #else

  440.             port.groupId = index / 2;

  441.            #endif

  442.         }

  443.         else

  444.         {

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

  446.             index -= CARDINAL_NUM_AUDIO_INPUTS;

  447.         }

  448.        #elif CARDINAL_VARIANT_NATIVE || CARDINAL_VARIANT_FX || CARDINAL_VARIANT_SYNTH

  449.         if (index < 2)

  450.             port.groupId = kPortGroupStereo;

  451.        #endif

  452. 

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

  454.     }

  455. 

  456.    #if CARDINAL_VARIANT_MAIN

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

  458.     {

  459.         switch (index)

  460.         {

  461.         case 0:

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

  463.             portGroup.symbol = "audio_1_and_2";

  464.             break;

  465.         case 1:

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

  467.             portGroup.symbol = "audio_3_and_4";

  468.             break;

  469.         case 2:

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

  471.             portGroup.symbol = "audio_5_and_6";

  472.             break;

  473.         case 3:

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

  475.             portGroup.symbol = "audio_7_and_8";

  476.             break;

  477.         }

  478.     }

  479.    #endif

  480. 

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

  482.     {

  483.         if (index < kCardinalParameterCountAtModules)

  484.         {

  485.             parameter.name = "Parameter ";

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

  487.             parameter.symbol = "param_";

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

  489.             parameter.unit = "v";

  490.             parameter.hints = kParameterIsAutomatable;

  491.             parameter.ranges.def = 0.0f;

  492.             parameter.ranges.min = 0.0f;

  493.             parameter.ranges.max = 10.0f;

  494.             return;

  495.         }

  496. 

  497.         if (index == kCardinalParameterBypass)

  498.         {

  499.             parameter.initDesignation(kParameterDesignationBypass);

  500.             return;

  501.         }

  502. 

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

  504.         if (index < kCardinalParameterCountAtWindow)

  505.         {

  506.             switch (index - kCardinalParameterStartWindow)

  507.             {

  508.             case kWindowParameterShowTooltips:

  509.                 parameter.name = "Show tooltips";

  510.                 parameter.symbol = "tooltips";

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

  512.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  513.                 parameter.hints |= kParameterIsHidden;

  514.                #endif

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

  516.                 parameter.ranges.min = 0.0f;

  517.                 parameter.ranges.max = 1.0f;

  518.                 break;

  519.             case kWindowParameterCableOpacity:

  520.                 parameter.name = "Cable opacity";

  521.                 parameter.symbol = "cableOpacity";

  522.                 parameter.unit = "%";

  523.                 parameter.hints = kParameterIsAutomatable;

  524.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  525.                 parameter.hints |= kParameterIsHidden;

  526.                #endif

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

  528.                 parameter.ranges.min = 0.0f;

  529.                 parameter.ranges.max = 100.0f;

  530.                 break;

  531.             case kWindowParameterCableTension:

  532.                 parameter.name = "Cable tension";

  533.                 parameter.symbol = "cableTension";

  534.                 parameter.unit = "%";

  535.                 parameter.hints = kParameterIsAutomatable;

  536.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  537.                 parameter.hints |= kParameterIsHidden;

  538.                #endif

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

  540.                 parameter.ranges.min = 0.0f;

  541.                 parameter.ranges.max = 100.0f;

  542.                 break;

  543.             case kWindowParameterRackBrightness:

  544.                 parameter.name = "Room brightness";

  545.                 parameter.symbol = "rackBrightness";

  546.                 parameter.unit = "%";

  547.                 parameter.hints = kParameterIsAutomatable;

  548.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  549.                 parameter.hints |= kParameterIsHidden;

  550.                #endif

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

  552.                 parameter.ranges.min = 0.0f;

  553.                 parameter.ranges.max = 100.0f;

  554.                 break;

  555.             case kWindowParameterHaloBrightness:

  556.                 parameter.name = "Light Bloom";

  557.                 parameter.symbol = "haloBrightness";

  558.                 parameter.unit = "%";

  559.                 parameter.hints = kParameterIsAutomatable;

  560.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  561.                 parameter.hints |= kParameterIsHidden;

  562.                #endif

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

  564.                 parameter.ranges.min = 0.0f;

  565.                 parameter.ranges.max = 100.0f;

  566.                 break;

  567.             case kWindowParameterKnobMode:

  568.                 parameter.name = "Knob mode";

  569.                 parameter.symbol = "knobMode";

  570.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  571.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  572.                 parameter.hints |= kParameterIsHidden;

  573.                #endif

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

  575.                 parameter.ranges.min = 0.0f;

  576.                 parameter.ranges.max = 2.0f;

  577.                 parameter.enumValues.count = 3;

  578.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

  586.                 break;

  587.             case kWindowParameterWheelKnobControl:

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

  589.                 parameter.symbol = "knobScroll";

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

  591.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  592.                 parameter.hints |= kParameterIsHidden;

  593.                #endif

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

  595.                 parameter.ranges.min = 0.0f;

  596.                 parameter.ranges.max = 1.0f;

  597.                 break;

  598.             case kWindowParameterWheelSensitivity:

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

  600.                 parameter.symbol = "knobScrollSensitivity";

  601.                 parameter.hints = kParameterIsAutomatable|kParameterIsLogarithmic;

  602.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  603.                 parameter.hints |= kParameterIsHidden;

  604.                #endif

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

  606.                 parameter.ranges.min = 0.1f;

  607.                 parameter.ranges.max = 10.0f;

  608.                 break;

  609.             case kWindowParameterLockModulePositions:

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

  611.                 parameter.symbol = "lockModules";

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

  613.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  614.                 parameter.hints |= kParameterIsHidden;

  615.                #endif

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

  617.                 parameter.ranges.min = 0.0f;

  618.                 parameter.ranges.max = 1.0f;

  619.                 break;

  620.             case kWindowParameterUpdateRateLimit:

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

  622.                 parameter.symbol = "rateLimit";

  623.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  624.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  625.                 parameter.hints |= kParameterIsHidden;

  626.                #endif

  627.                 parameter.ranges.def = 0.0f;

  628.                 parameter.ranges.min = 0.0f;

  629.                 parameter.ranges.max = 2.0f;

  630.                 parameter.enumValues.count = 3;

  631.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

  639.                 break;

  640.             case kWindowParameterBrowserSort:

  641.                 parameter.name = "Browser sort";

  642.                 parameter.symbol = "browserSort";

  643.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  644.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  645.                 parameter.hints |= kParameterIsHidden;

  646.                #endif

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

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

  649.                                                          rack::settings::browserSort));

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

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

  652.                 parameter.enumValues.count = 6;

  653.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

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

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

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

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

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

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

  667.                 break;

  668.             case kWindowParameterBrowserZoom:

  669.                 parameter.name = "Browser zoom";

  670.                 parameter.symbol = "browserZoom";

  671.                 parameter.hints = kParameterIsAutomatable;

  672.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  673.                 parameter.hints |= kParameterIsHidden;

  674.                #endif

  675.                 parameter.unit = "%";

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

  677.                 parameter.ranges.min = 25.0f;

  678.                 parameter.ranges.max = 200.0f;

  679.                 parameter.enumValues.count = 7;

  680.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  696.                 break;

  697.             case kWindowParameterInvertZoom:

  698.                 parameter.name = "Invert zoom";

  699.                 parameter.symbol = "invertZoom";

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

  701.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  702.                 parameter.hints |= kParameterIsHidden;

  703.                #endif

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

  705.                 parameter.ranges.min = 0.0f;

  706.                 parameter.ranges.max = 1.0f;

  707.                 break;

  708.             case kWindowParameterSqueezeModulePositions:

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

  710.                 parameter.symbol = "squeezeModules";

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

  712.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  713.                 parameter.hints |= kParameterIsHidden;

  714.                #endif

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

  716.                 parameter.ranges.min = 0.0f;

  717.                 parameter.ranges.max = 1.0f;

  718.                 break;

  719.             }

  720.         }

  721.        #endif

  722. 

  723.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  724.         switch (index)

  725.         {

  726.         case kCardinalParameterMiniAudioIn1:

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

  728.             parameter.symbol = "r_audio_in_1";

  729.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  730.             parameter.ranges.def = 0.0f;

  731.             parameter.ranges.min = 0.0f;

  732.             parameter.ranges.max = 1.0f;

  733.             break;

  734.         case kCardinalParameterMiniAudioIn2:

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

  736.             parameter.symbol = "r_audio_in_2";

  737.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  738.             parameter.ranges.def = 0.0f;

  739.             parameter.ranges.min = 0.0f;

  740.             parameter.ranges.max = 1.0f;

  741.             break;

  742.         case kCardinalParameterMiniCVIn1:

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

  744.             parameter.symbol = "r_cv_in_1";

  745.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  747.             parameter.ranges.min = 0.0f;

  748.             parameter.ranges.max = 10.0f;

  749.             break;

  750.         case kCardinalParameterMiniCVIn2:

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

  752.             parameter.symbol = "r_cv_in_2";

  753.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  755.             parameter.ranges.min = 0.0f;

  756.             parameter.ranges.max = 10.0f;

  757.             break;

  758.         case kCardinalParameterMiniCVIn3:

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

  760.             parameter.symbol = "r_cv_in_3";

  761.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  763.             parameter.ranges.min = 0.0f;

  764.             parameter.ranges.max = 10.0f;

  765.             break;

  766.         case kCardinalParameterMiniCVIn4:

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

  768.             parameter.symbol = "r_cv_in_4";

  769.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  771.             parameter.ranges.min = 0.0f;

  772.             parameter.ranges.max = 10.0f;

  773.             break;

  774.         case kCardinalParameterMiniCVIn5:

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

  776.             parameter.symbol = "r_cv_in_5";

  777.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  779.             parameter.ranges.min = 0.0f;

  780.             parameter.ranges.max = 10.0f;

  781.             break;

  782.         case kCardinalParameterMiniTimeFlags:

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

  784.             parameter.symbol = "r_time_flags";

  785.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  786.             parameter.ranges.def = 0x0;

  787.             parameter.ranges.min = 0x0;

  788.             parameter.ranges.max = 0x7;

  789.             break;

  790.         case kCardinalParameterMiniTimeBar:

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

  792.             parameter.symbol = "r_time_bar";

  793.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  794.             parameter.ranges.def = 1.0f;

  795.             parameter.ranges.min = 1.0f;

  796.             parameter.ranges.max = FLT_MAX;

  797.             break;

  798.         case kCardinalParameterMiniTimeBeat:

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

  800.             parameter.symbol = "r_time_beat";

  801.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  802.             parameter.ranges.def = 1.0f;

  803.             parameter.ranges.min = 1.0f;

  804.             parameter.ranges.max = 128.0f;

  805.             break;

  806.         case kCardinalParameterMiniTimeBeatsPerBar:

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

  808.             parameter.symbol = "r_time_beatsPerBar";

  809.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  810.             parameter.ranges.def = 4.0f;

  811.             parameter.ranges.min = 0.0f;

  812.             parameter.ranges.max = 128.0f;

  813.             break;

  814.         case kCardinalParameterMiniTimeBeatType:

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

  816.             parameter.symbol = "r_time_beatType";

  817.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  818.             parameter.ranges.def = 4.0f;

  819.             parameter.ranges.min = 0.0f;

  820.             parameter.ranges.max = 128.0f;

  821.             break;

  822.         case kCardinalParameterMiniTimeFrame:

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

  824.             parameter.symbol = "r_time_frame";

  825.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  826.             parameter.ranges.def = 0.0f;

  827.             parameter.ranges.min = 0.0f;

  828.             parameter.ranges.max = FLT_MAX;

  829.             break;

  830.         case kCardinalParameterMiniTimeBarStartTick:

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

  832.             parameter.symbol = "r_time_barStartTick";

  833.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  834.             parameter.ranges.def = 0.0f;

  835.             parameter.ranges.min = 0.0f;

  836.             parameter.ranges.max = FLT_MAX;

  837.             break;

  838.         case kCardinalParameterMiniTimeBeatsPerMinute:

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

  840.             parameter.symbol = "r_time_bpm";

  841.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  842.             parameter.ranges.def = 20.0f;

  843.             parameter.ranges.min = 120.0f;

  844.             parameter.ranges.max = 999.0f;

  845.             break;

  846.         case kCardinalParameterMiniTimeTick:

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

  848.             parameter.symbol = "r_time_tick";

  849.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  850.             parameter.ranges.def = 0.0f;

  851.             parameter.ranges.min = 0.0f;

  852.             parameter.ranges.max = 8192.0f;

  853.             break;

  854.         case kCardinalParameterMiniTimeTicksPerBeat:

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

  856.             parameter.symbol = "r_time_ticksPerBeat";

  857.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  858.             parameter.ranges.def = 0.0f;

  859.             parameter.ranges.min = 0.0f;

  860.             parameter.ranges.max = 8192.0f;

  861.             break;

  862.         }

  863.        #endif

  864.     }

  865. 

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

  867.     {

  868.         switch (index)

  869.         {

  870.         case kCardinalStatePatch:

  871.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  872.             state.hints = kStateIsHostReadable;

  873.            #else

  874.             state.hints = kStateIsOnlyForDSP | kStateIsBase64Blob;

  875.            #endif

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

  877.             {

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

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

  880.                 {

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

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

  883. 

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

  885.                     {

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

  887.                        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  888.                         state.defaultValue = fileContent;

  889.                        #else

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

  891.                        #endif

  892.                     }

  893. 

  894.                     delete[] fileContent;

  895.                 }

  896.                 std::fclose(f);

  897.             }

  898.             state.key = "patch";

  899.             state.label = "Patch";

  900.             break;

  901.         case kCardinalStateScreenshot:

  902.             state.hints = kStateIsHostReadable | kStateIsBase64Blob;

  903.             state.key = "screenshot";

  904.             state.label = "Screenshot";

  905.             break;

  906.         case kCardinalStateComment:

  907.             state.hints = kStateIsHostWritable;

  908.             state.key = "comment";

  909.             state.label = "Comment";

  910.             break;

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

  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, "windowSize") == 0)

  984.             return fState.windowSize;

  985.        #endif

  986. 

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

  988.             return fState.comment;

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

  990.             return fState.screenshot;

  991. 

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

  993.             return String();

  994.         if (fAutosavePath.empty())

  995.             return String();

  996. 

  997.         std::vector<uint8_t> data;

  998. 

  999.         {

  1000.             const ScopedContext sc(this);

  1001. 

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

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

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

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

  1006. 

  1007.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  1010. 

  1011.             DEFER({

  1012.                 std::fclose(f);

  1013.             });

  1014. 

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

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

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

  1018. 

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

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

  1021. 

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

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

  1024. 

  1025.             return String(fileContent, false);

  1026.            #else

  1027.             try {

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

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

  1030.            #endif

  1031.         }

  1032. 

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

  1034.     }

  1035. 

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

  1037.     {

  1038.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

  1040.         {

  1041.             long long moduleId = 0;

  1042.             int paramId = 0;

  1043.             float paramValue = 0.f;

  1044.             {

  1045.                 const ScopedSafeLocale cssl;

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

  1047.             }

  1048. 

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

  1050.             DISTRHO_SAFE_ASSERT_RETURN(module != nullptr,);

  1051. 

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

  1053.             return;

  1054.         }

  1055.        #endif

  1056. 

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

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

  1059.         {

  1060.             fState.windowSize = value;

  1061.             return;

  1062.         }

  1063.        #endif

  1064. 

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

  1066.         {

  1067.             fState.comment = value;

  1068.             return;

  1069.         }

  1070. 

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

  1072.         {

  1073.             fState.screenshot = value;

  1074.             return;

  1075.         }

  1076. 

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

  1078.             return;

  1079.         if (fAutosavePath.empty())

  1080.             return;

  1081. 

  1082.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  1085. 

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

  1087.         DISTRHO_SAFE_ASSERT_RETURN(f != nullptr,);

  1088. 

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

  1090.         std::fclose(f);

  1091.        #else

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

  1093. 

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

  1095. 

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

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

  1098. 

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

  1100. 

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

  1102.         {

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

  1104.             DISTRHO_SAFE_ASSERT_RETURN(f != nullptr,);

  1105. 

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

  1107.             std::fclose(f);

  1108.         }

  1109.         else

  1110.         {

  1111.             try {

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

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

  1114.         }

  1115.        #endif

  1116. 

  1117.         const ScopedContext sc(this);

  1118. 

  1119.         try {

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

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

  1122.             d_stderr(e.what());

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

  1124. 

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

  1126.     }

  1127. 

  1128.    /* --------------------------------------------------------------------------------------------------------

  1129.     * Process */

  1130. 

  1131.     void activate() override

  1132.     {

  1133.         context->bufferSize = getBufferSize();

  1134. 

  1135.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1136.         fAudioBufferCopy = new float*[DISTRHO_PLUGIN_NUM_INPUTS];

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

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

  1139.        #endif

  1140. 

  1141.         fNextExpectedFrame = 0;

  1142.     }

  1143. 

  1144.     void deactivate() override

  1145.     {

  1146.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1147.         if (fAudioBufferCopy != nullptr)

  1148.         {

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

  1150.                 delete[] fAudioBufferCopy[i];

  1151.             delete[] fAudioBufferCopy;

  1152.             fAudioBufferCopy = nullptr;

  1153.         }

  1154.        #endif

  1155.     }

  1156. 

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

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

  1159.     {

  1160.         const ScopedDenormalDisable sdd;

  1161. 

  1162.         rack::contextSet(context);

  1163. 

  1164.         const bool bypassed = context->bypassed;

  1165. 

  1166.         {

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

  1168. 

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

  1170. 

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

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

  1173.                 reset = false;

  1174. 

  1175.             context->playing = timePos.playing;

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

  1177.             context->frame = timePos.frame;

  1178. 

  1179.             if (timePos.bbt.valid)

  1180.             {

  1181.                 const double samplesPerTick = 60.0 * getSampleRate()

  1182.                                             / timePos.bbt.beatsPerMinute

  1183.                                             / timePos.bbt.ticksPerBeat;

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

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

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

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

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

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

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

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

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

  1193.                 context->ticksPerFrame = 1.0 / samplesPerTick;

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

  1195.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

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

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

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

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

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

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

  1204.                #endif

  1205.             }

  1206. 

  1207.             context->reset = reset;

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

  1209. 

  1210.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

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

  1214.             fMiniReportValues[kCardinalParameterMiniTimeFlags - kCardinalParameterStartMini] = flags;

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

  1216.            #endif

  1217.         }

  1218. 

  1219.         // separate buffers, use them

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

  1221.         {

  1222.             context->dataIns = inputs;

  1223.             context->dataOuts = outputs;

  1224.         }

  1225.         // inline processing, use a safe copy

  1226.         else

  1227.         {

  1228.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

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

  1230.             {

  1231.                #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

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

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

  1234.                #endif

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

  1236.             }

  1237.             context->dataIns = fAudioBufferCopy;

  1238.            #else

  1239.             context->dataIns = nullptr;

  1240.            #endif

  1241.             context->dataOuts = outputs;

  1242.         }

  1243. 

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

  1245.         {

  1246.            #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

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

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

  1249.            #endif

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

  1251.         }

  1252. 

  1253.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  1256.        #endif

  1257. 

  1258.         if (bypassed)

  1259.         {

  1260.             if (fWasBypassed != bypassed)

  1261.             {

  1262.                 context->midiEvents = bypassMidiEvents;

  1263.                 context->midiEventCount = 16;

  1264.             }

  1265.             else

  1266.             {

  1267.                 context->midiEvents = nullptr;

  1268.                 context->midiEventCount = 0;

  1269.             }

  1270.         }

  1271.         else

  1272.         {

  1273.             context->midiEvents = midiEvents;

  1274.             context->midiEventCount = midiEventCount;

  1275.         }

  1276. 

  1277.         ++context->processCounter;

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

  1279. 

  1280.         fWasBypassed = bypassed;

  1281.     }

  1282. 

  1283.     void sampleRateChanged(const double newSampleRate) override

  1284.     {

  1285.         rack::contextSet(context);

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

  1287.         context->sampleRate = newSampleRate;

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

  1289.     }

  1290. 

  1291.     // -------------------------------------------------------------------------------------------------------

  1292. 

  1293. private:

  1294.    /**

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

  1296.     */

  1297.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CardinalPlugin)

  1298. };

  1299. 

  1300. CardinalPluginContext* getRackContextFromPlugin(void* const ptr)

  1301. {

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

  1303. }

  1304. 

  1305. /* ------------------------------------------------------------------------------------------------------------

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

  1307. 

  1308. Plugin* createPlugin()

  1309. {

  1310.     return new CardinalPlugin();

  1311. }

  1312. 

  1313. // --------------------------------------------------------------------------------------------------------------------

  1314. 

  1315. END_NAMESPACE_DISTRHO