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.
1560 Commits
12 Branches
277MB
Tree: e463fa4dfb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e463fa4dfb'
${ noResults }
Cardinal/src/CardinalPlugin.cpp

1352 lines
52KB
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. namespace engine {

  70. void Engine_setAboutToClose(Engine*);

  71. }

  72. }

  73. 

  74. START_NAMESPACE_DISTRHO

  75. 

  76. template<typename T>

  77. static inline

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

  79. {

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

  81. }

  82. 

  83. #if DISTRHO_PLUGIN_HAS_UI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  86. #endif

  87. 

  88. // -----------------------------------------------------------------------------------------------------------

  89. 

  90. #ifdef DISTRHO_OS_WASM

  91. static char* getPatchFileEncodedInURL() {

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

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

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

  95.         if (!patch)

  96.         return null;

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

  98.         var str = _malloc(length);

  99.         stringToUTF8(patch, str, length);

  100.         return str;

  101.     }));

  102. };

  103. 

  104. static char* getPatchRemoteURL() {

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

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

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

  108.         if (!patch)

  109.         return null;

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

  111.         var str = _malloc(length);

  112.         stringToUTF8(patch, str, length);

  113.         return str;

  114.     }));

  115. };

  116. 

  117. static char* getPatchStorageSlug() {

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

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

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

  121.         if (!patch)

  122.         return null;

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

  124.         var str = _malloc(length);

  125.         stringToUTF8(patch, str, length);

  126.         return str;

  127.     }));

  128. };

  129. #endif

  130. 

  131. // -----------------------------------------------------------------------------------------------------------

  132. 

  133. struct ScopedContext {

  134.     ScopedContext(const CardinalBasePlugin* const plugin)

  135.     {

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

  137.     }

  138. 

  139.     ~ScopedContext()

  140.     {

  141.         rack::contextSet(nullptr);

  142.     }

  143. };

  144. 

  145. 

  146. // -----------------------------------------------------------------------------------------------------------

  147. 

  148. class CardinalPlugin : public CardinalBasePlugin

  149. {

  150.    #ifdef DISTRHO_OS_WASM

  151.     ScopedPointer<Initializer> fInitializer;

  152.    #else

  153.     SharedResourcePointer<Initializer> fInitializer;

  154.    #endif

  155. 

  156.    #if DISTRHO_PLUGIN_NUM_INPUTS != 0

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

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

  159.      */

  160.     float** fAudioBufferCopy;

  161.    #endif

  162. 

  163.     std::string fAutosavePath;

  164.     uint64_t fNextExpectedFrame;

  165. 

  166.     struct {

  167.         String comment;

  168.         String screenshot;

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

  170.         String windowSize;

  171.        #endif

  172.     } fState;

  173. 

  174.     // bypass handling

  175.     bool fWasBypassed;

  176.     MidiEvent bypassMidiEvents[16];

  177. 

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

  179.     // real values, not VCV interpreted ones

  180.     float fWindowParameters[kWindowParameterCount];

  181.    #endif

  182.    #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  183.     float fMiniReportValues[kCardinalParameterCountAtMini - kCardinalParameterStartMini];

  184.    #endif

  185. 

  186. public:

  187.     CardinalPlugin()

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

  189.          #ifdef DISTRHO_OS_WASM

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

  191.          #else

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

  193.          #endif

  194.          #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  195.           fAudioBufferCopy(nullptr),

  196.          #endif

  197.           fNextExpectedFrame(0),

  198.           fWasBypassed(false)

  199.     {

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

  201.         fWindowParameters[kWindowParameterShowTooltips] = 1.0f;

  202.         fWindowParameters[kWindowParameterCableOpacity] = 50.0f;

  203.         fWindowParameters[kWindowParameterCableTension] = 75.0f;

  204.         fWindowParameters[kWindowParameterRackBrightness] = 100.0f;

  205.         fWindowParameters[kWindowParameterHaloBrightness] = 25.0f;

  206.         fWindowParameters[kWindowParameterKnobMode] = 0.0f;

  207.         fWindowParameters[kWindowParameterWheelKnobControl] = 0.0f;

  208.         fWindowParameters[kWindowParameterWheelSensitivity] = 1.0f;

  209.         fWindowParameters[kWindowParameterLockModulePositions] = 0.0f;

  210.         fWindowParameters[kWindowParameterUpdateRateLimit] = 0.0f;

  211.         fWindowParameters[kWindowParameterBrowserSort] = 3.0f;

  212.         fWindowParameters[kWindowParameterBrowserZoom] = 50.0f;

  213.         fWindowParameters[kWindowParameterInvertZoom] = 0.0f;

  214.         fWindowParameters[kWindowParameterSqueezeModulePositions] = 1.0f;

  215.        #endif

  216.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

  218.         fMiniReportValues[kCardinalParameterMiniTimeBar - kCardinalParameterStartMini] = 1;

  219.         fMiniReportValues[kCardinalParameterMiniTimeBeat - kCardinalParameterStartMini] = 1;

  220.         fMiniReportValues[kCardinalParameterMiniTimeBeatsPerBar - kCardinalParameterStartMini] = 4;

  221.         fMiniReportValues[kCardinalParameterMiniTimeBeatType - kCardinalParameterStartMini] = 4;

  222.         fMiniReportValues[kCardinalParameterMiniTimeBeatsPerMinute - kCardinalParameterStartMini] = 120;

  223.        #endif

  224. 

  225.         // create unique temporary path for this instance

  226.         try {

  227.             char uidBuf[24];

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

  229. 

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

  231.             {

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

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

  234. 

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

  236.                 {

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

  238.                         fAutosavePath = trypath;

  239.                     break;

  240.                 }

  241.             }

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

  243. 

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

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

  246. 

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

  248.         {

  249.             bypassMidiEvents[i].size = 3;

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

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

  252.         }

  253. 

  254.         const float sampleRate = getSampleRate();

  255.         rack::settings::sampleRate = sampleRate;

  256. 

  257.         context->bufferSize = getBufferSize();

  258.         context->sampleRate = sampleRate;

  259. 

  260.         const ScopedContext sc(this);

  261. 

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

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

  264. 

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

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

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

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

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

  270. 

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

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

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

  274. 

  275.         if (! isDummyInstance())

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

  277. 

  278.        #ifdef DISTRHO_OS_WASM

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

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

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

  282.        #endif

  283.         {

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

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

  286.             // swap to factory template after first load

  287.             context->patch->templatePath = context->patch->factoryTemplatePath;

  288.         }

  289. 

  290.        #ifdef CARDINAL_INIT_OSC_THREAD

  291.         fInitializer->remotePluginInstance = this;

  292.        #endif

  293.     }

  294. 

  295.     ~CardinalPlugin() override

  296.     {

  297.        #ifdef CARDINAL_INIT_OSC_THREAD

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

  299.             fInitializer->remotePluginInstance = nullptr;

  300.        #endif

  301. 

  302.         {

  303.             const ScopedContext sc(this);

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

  305. 

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

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

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

  309.            #endif

  310.             Engine_setAboutToClose(context->engine);

  311.             delete context;

  312.         }

  313. 

  314.         if (! fAutosavePath.empty())

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

  316.     }

  317. 

  318.     CardinalPluginContext* getRackContext() const noexcept

  319.     {

  320.         return context;

  321.     }

  322. 

  323. protected:

  324.    /* --------------------------------------------------------------------------------------------------------

  325.     * Information */

  326. 

  327.     const char* getLabel() const override

  328.     {

  329.         return DISTRHO_PLUGIN_LABEL;

  330.     }

  331. 

  332.     const char* getDescription() const override

  333.     {

  334.         return ""

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

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

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

  338.         "\n"

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

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

  341.     }

  342. 

  343.     const char* getMaker() const override

  344.     {

  345.         return "DISTRHO";

  346.     }

  347. 

  348.     const char* getHomePage() const override

  349.     {

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

  351.     }

  352. 

  353.     const char* getLicense() const override

  354.     {

  355.         return "GPLv3+";

  356.     }

  357. 

  358.     uint32_t getVersion() const override

  359.     {

  360.         return d_version(0, 23, 2);

  361.     }

  362. 

  363.     int64_t getUniqueId() const override

  364.     {

  365.        #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_NATIVE

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

  367.        #elif CARDINAL_VARIANT_MINI

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

  369.        #elif CARDINAL_VARIANT_FX

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

  371.        #elif CARDINAL_VARIANT_SYNTH

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

  373.        #else

  374.         #error cardinal variant not set

  375.        #endif

  376.     }

  377. 

  378.    /* --------------------------------------------------------------------------------------------------------

  379.     * Init */

  380. 

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

  382.     {

  383.        #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

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

  385. 

  386.         if (index < CARDINAL_NUM_AUDIO_INPUTS)

  387.         {

  388.            #if CARDINAL_VARIANT_MINI

  389.             port.groupId = kPortGroupStereo;

  390.            #else

  391.             port.groupId = index / 2;

  392.            #endif

  393.         }

  394.         else

  395.         {

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

  397.             index -= CARDINAL_NUM_AUDIO_INPUTS;

  398.         }

  399.        #elif CARDINAL_VARIANT_NATIVE || CARDINAL_VARIANT_FX || CARDINAL_VARIANT_SYNTH

  400.         if (index < 2)

  401.             port.groupId = kPortGroupStereo;

  402.        #endif

  403. 

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

  405.     }

  406. 

  407.    #if CARDINAL_VARIANT_MAIN

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

  409.     {

  410.         switch (index)

  411.         {

  412.         case 0:

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

  414.             portGroup.symbol = "audio_1_and_2";

  415.             break;

  416.         case 1:

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

  418.             portGroup.symbol = "audio_3_and_4";

  419.             break;

  420.         case 2:

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

  422.             portGroup.symbol = "audio_5_and_6";

  423.             break;

  424.         case 3:

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

  426.             portGroup.symbol = "audio_7_and_8";

  427.             break;

  428.         }

  429.     }

  430.    #endif

  431. 

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

  433.     {

  434.         if (index < kCardinalParameterCountAtModules)

  435.         {

  436.             parameter.name = "Parameter ";

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

  438.             parameter.symbol = "param_";

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

  440.             parameter.unit = "v";

  441.             parameter.hints = kParameterIsAutomatable;

  442.             parameter.ranges.def = 0.0f;

  443.             parameter.ranges.min = 0.0f;

  444.             parameter.ranges.max = 10.0f;

  445.             return;

  446.         }

  447. 

  448.         if (index == kCardinalParameterBypass)

  449.         {

  450.             parameter.initDesignation(kParameterDesignationBypass);

  451.             return;

  452.         }

  453. 

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

  455.         if (index < kCardinalParameterCountAtWindow)

  456.         {

  457.             switch (index - kCardinalParameterStartWindow)

  458.             {

  459.             case kWindowParameterShowTooltips:

  460.                 parameter.name = "Show tooltips";

  461.                 parameter.symbol = "tooltips";

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

  463.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  464.                 parameter.hints |= kParameterIsHidden;

  465.                #endif

  466.                 parameter.ranges.def = 1.0f;

  467.                 parameter.ranges.min = 0.0f;

  468.                 parameter.ranges.max = 1.0f;

  469.                 break;

  470.             case kWindowParameterCableOpacity:

  471.                 parameter.name = "Cable opacity";

  472.                 parameter.symbol = "cableOpacity";

  473.                 parameter.unit = "%";

  474.                 parameter.hints = kParameterIsAutomatable;

  475.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  476.                 parameter.hints |= kParameterIsHidden;

  477.                #endif

  478.                 parameter.ranges.def = 50.0f;

  479.                 parameter.ranges.min = 0.0f;

  480.                 parameter.ranges.max = 100.0f;

  481.                 break;

  482.             case kWindowParameterCableTension:

  483.                 parameter.name = "Cable tension";

  484.                 parameter.symbol = "cableTension";

  485.                 parameter.unit = "%";

  486.                 parameter.hints = kParameterIsAutomatable;

  487.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  488.                 parameter.hints |= kParameterIsHidden;

  489.                #endif

  490.                 parameter.ranges.def = 75.0f;

  491.                 parameter.ranges.min = 0.0f;

  492.                 parameter.ranges.max = 100.0f;

  493.                 break;

  494.             case kWindowParameterRackBrightness:

  495.                 parameter.name = "Room brightness";

  496.                 parameter.symbol = "rackBrightness";

  497.                 parameter.unit = "%";

  498.                 parameter.hints = kParameterIsAutomatable;

  499.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  500.                 parameter.hints |= kParameterIsHidden;

  501.                #endif

  502.                 parameter.ranges.def = 100.0f;

  503.                 parameter.ranges.min = 0.0f;

  504.                 parameter.ranges.max = 100.0f;

  505.                 break;

  506.             case kWindowParameterHaloBrightness:

  507.                 parameter.name = "Light Bloom";

  508.                 parameter.symbol = "haloBrightness";

  509.                 parameter.unit = "%";

  510.                 parameter.hints = kParameterIsAutomatable;

  511.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  512.                 parameter.hints |= kParameterIsHidden;

  513.                #endif

  514.                 parameter.ranges.def = 25.0f;

  515.                 parameter.ranges.min = 0.0f;

  516.                 parameter.ranges.max = 100.0f;

  517.                 break;

  518.             case kWindowParameterKnobMode:

  519.                 parameter.name = "Knob mode";

  520.                 parameter.symbol = "knobMode";

  521.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  522.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  523.                 parameter.hints |= kParameterIsHidden;

  524.                #endif

  525.                 parameter.ranges.def = 0.0f;

  526.                 parameter.ranges.min = 0.0f;

  527.                 parameter.ranges.max = 2.0f;

  528.                 parameter.enumValues.count = 3;

  529.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

  537.                 break;

  538.             case kWindowParameterWheelKnobControl:

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

  540.                 parameter.symbol = "knobScroll";

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

  542.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  543.                 parameter.hints |= kParameterIsHidden;

  544.                #endif

  545.                 parameter.ranges.def = 0.0f;

  546.                 parameter.ranges.min = 0.0f;

  547.                 parameter.ranges.max = 1.0f;

  548.                 break;

  549.             case kWindowParameterWheelSensitivity:

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

  551.                 parameter.symbol = "knobScrollSensitivity";

  552.                 parameter.hints = kParameterIsAutomatable|kParameterIsLogarithmic;

  553.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  554.                 parameter.hints |= kParameterIsHidden;

  555.                #endif

  556.                 parameter.ranges.def = 1.0f;

  557.                 parameter.ranges.min = 0.1f;

  558.                 parameter.ranges.max = 10.0f;

  559.                 break;

  560.             case kWindowParameterLockModulePositions:

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

  562.                 parameter.symbol = "lockModules";

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

  564.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  565.                 parameter.hints |= kParameterIsHidden;

  566.                #endif

  567.                 parameter.ranges.def = 0.0f;

  568.                 parameter.ranges.min = 0.0f;

  569.                 parameter.ranges.max = 1.0f;

  570.                 break;

  571.             case kWindowParameterUpdateRateLimit:

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

  573.                 parameter.symbol = "rateLimit";

  574.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  575.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  576.                 parameter.hints |= kParameterIsHidden;

  577.                #endif

  578.                 parameter.ranges.def = 0.0f;

  579.                 parameter.ranges.min = 0.0f;

  580.                 parameter.ranges.max = 2.0f;

  581.                 parameter.enumValues.count = 3;

  582.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

  590.                 break;

  591.             case kWindowParameterBrowserSort:

  592.                 parameter.name = "Browser sort";

  593.                 parameter.symbol = "browserSort";

  594.                 parameter.hints = kParameterIsAutomatable|kParameterIsInteger;

  595.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  596.                 parameter.hints |= kParameterIsHidden;

  597.                #endif

  598.                 parameter.ranges.def = 3.0f;

  599.                 parameter.ranges.min = 0.0f;

  600.                 parameter.ranges.max = 5.0f;

  601.                 parameter.enumValues.count = 6;

  602.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

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

  611.                 parameter.enumValues.values[3].value = 3.0f;

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

  613.                 parameter.enumValues.values[4].value = 4.0f;

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

  615.                 parameter.enumValues.values[5].value = 5.0f;

  616.                 break;

  617.             case kWindowParameterBrowserZoom:

  618.                 parameter.name = "Browser zoom";

  619.                 parameter.symbol = "browserZoom";

  620.                 parameter.hints = kParameterIsAutomatable;

  621.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  622.                 parameter.hints |= kParameterIsHidden;

  623.                #endif

  624.                 parameter.unit = "%";

  625.                 parameter.ranges.def = 50.0f;

  626.                 parameter.ranges.min = 25.0f;

  627.                 parameter.ranges.max = 200.0f;

  628.                 parameter.enumValues.count = 7;

  629.                 parameter.enumValues.restrictedMode = true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  645.                 break;

  646.             case kWindowParameterInvertZoom:

  647.                 parameter.name = "Invert zoom";

  648.                 parameter.symbol = "invertZoom";

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

  650.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  651.                 parameter.hints |= kParameterIsHidden;

  652.                #endif

  653.                 parameter.ranges.def = 0.0f;

  654.                 parameter.ranges.min = 0.0f;

  655.                 parameter.ranges.max = 1.0f;

  656.                 break;

  657.             case kWindowParameterSqueezeModulePositions:

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

  659.                 parameter.symbol = "squeezeModules";

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

  661.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  662.                 parameter.hints |= kParameterIsHidden;

  663.                #endif

  664.                 parameter.ranges.def = 1.0f;

  665.                 parameter.ranges.min = 0.0f;

  666.                 parameter.ranges.max = 1.0f;

  667.                 break;

  668.             }

  669.         }

  670.        #endif

  671. 

  672.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  673.         switch (index)

  674.         {

  675.         case kCardinalParameterMiniAudioIn1:

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

  677.             parameter.symbol = "r_audio_in_1";

  678.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  679.             parameter.ranges.def = 0.0f;

  680.             parameter.ranges.min = 0.0f;

  681.             parameter.ranges.max = 1.0f;

  682.             break;

  683.         case kCardinalParameterMiniAudioIn2:

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

  685.             parameter.symbol = "r_audio_in_2";

  686.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  687.             parameter.ranges.def = 0.0f;

  688.             parameter.ranges.min = 0.0f;

  689.             parameter.ranges.max = 1.0f;

  690.             break;

  691.         case kCardinalParameterMiniCVIn1:

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

  693.             parameter.symbol = "r_cv_in_1";

  694.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  696.             parameter.ranges.min = 0.0f;

  697.             parameter.ranges.max = 10.0f;

  698.             break;

  699.         case kCardinalParameterMiniCVIn2:

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

  701.             parameter.symbol = "r_cv_in_2";

  702.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  704.             parameter.ranges.min = 0.0f;

  705.             parameter.ranges.max = 10.0f;

  706.             break;

  707.         case kCardinalParameterMiniCVIn3:

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

  709.             parameter.symbol = "r_cv_in_3";

  710.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  712.             parameter.ranges.min = 0.0f;

  713.             parameter.ranges.max = 10.0f;

  714.             break;

  715.         case kCardinalParameterMiniCVIn4:

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

  717.             parameter.symbol = "r_cv_in_4";

  718.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  720.             parameter.ranges.min = 0.0f;

  721.             parameter.ranges.max = 10.0f;

  722.             break;

  723.         case kCardinalParameterMiniCVIn5:

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

  725.             parameter.symbol = "r_cv_in_5";

  726.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

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

  728.             parameter.ranges.min = 0.0f;

  729.             parameter.ranges.max = 10.0f;

  730.             break;

  731.         case kCardinalParameterMiniTimeFlags:

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

  733.             parameter.symbol = "r_time_flags";

  734.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  735.             parameter.ranges.def = 0x0;

  736.             parameter.ranges.min = 0x0;

  737.             parameter.ranges.max = 0x7;

  738.             break;

  739.         case kCardinalParameterMiniTimeBar:

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

  741.             parameter.symbol = "r_time_bar";

  742.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  743.             parameter.ranges.def = 1.0f;

  744.             parameter.ranges.min = 1.0f;

  745.             parameter.ranges.max = FLT_MAX;

  746.             break;

  747.         case kCardinalParameterMiniTimeBeat:

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

  749.             parameter.symbol = "r_time_beat";

  750.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  751.             parameter.ranges.def = 1.0f;

  752.             parameter.ranges.min = 1.0f;

  753.             parameter.ranges.max = 128.0f;

  754.             break;

  755.         case kCardinalParameterMiniTimeBeatsPerBar:

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

  757.             parameter.symbol = "r_time_beatsPerBar";

  758.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  759.             parameter.ranges.def = 4.0f;

  760.             parameter.ranges.min = 0.0f;

  761.             parameter.ranges.max = 128.0f;

  762.             break;

  763.         case kCardinalParameterMiniTimeBeatType:

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

  765.             parameter.symbol = "r_time_beatType";

  766.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  767.             parameter.ranges.def = 4.0f;

  768.             parameter.ranges.min = 0.0f;

  769.             parameter.ranges.max = 128.0f;

  770.             break;

  771.         case kCardinalParameterMiniTimeFrame:

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

  773.             parameter.symbol = "r_time_frame";

  774.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  775.             parameter.ranges.def = 0.0f;

  776.             parameter.ranges.min = 0.0f;

  777.             parameter.ranges.max = FLT_MAX;

  778.             break;

  779.         case kCardinalParameterMiniTimeBarStartTick:

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

  781.             parameter.symbol = "r_time_barStartTick";

  782.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  783.             parameter.ranges.def = 0.0f;

  784.             parameter.ranges.min = 0.0f;

  785.             parameter.ranges.max = FLT_MAX;

  786.             break;

  787.         case kCardinalParameterMiniTimeBeatsPerMinute:

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

  789.             parameter.symbol = "r_time_bpm";

  790.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  791.             parameter.ranges.def = 20.0f;

  792.             parameter.ranges.min = 120.0f;

  793.             parameter.ranges.max = 999.0f;

  794.             break;

  795.         case kCardinalParameterMiniTimeTick:

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

  797.             parameter.symbol = "r_time_tick";

  798.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  799.             parameter.ranges.def = 0.0f;

  800.             parameter.ranges.min = 0.0f;

  801.             parameter.ranges.max = 8192.0f;

  802.             break;

  803.         case kCardinalParameterMiniTimeTicksPerBeat:

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

  805.             parameter.symbol = "r_time_ticksPerBeat";

  806.             parameter.hints = kParameterIsAutomatable|kParameterIsOutput;

  807.             parameter.ranges.def = 0.0f;

  808.             parameter.ranges.min = 0.0f;

  809.             parameter.ranges.max = 8192.0f;

  810.             break;

  811.         }

  812.        #endif

  813.     }

  814. 

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

  816.     {

  817.         switch (index)

  818.         {

  819.         case kCardinalStatePatch:

  820.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  821.             state.hints = kStateIsHostReadable;

  822.            #else

  823.             state.hints = kStateIsOnlyForDSP | kStateIsBase64Blob;

  824.            #endif

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

  826.             {

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

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

  829.                 {

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

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

  832. 

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

  834.                     {

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

  836.                        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  837.                         state.defaultValue = fileContent;

  838.                        #else

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

  840.                        #endif

  841.                     }

  842. 

  843.                     delete[] fileContent;

  844.                 }

  845.                 std::fclose(f);

  846.             }

  847.             state.key = "patch";

  848.             state.label = "Patch";

  849.             break;

  850.         case kCardinalStateScreenshot:

  851.             state.hints = kStateIsHostReadable | kStateIsBase64Blob;

  852.             state.key = "screenshot";

  853.             state.label = "Screenshot";

  854.             break;

  855.         case kCardinalStateComment:

  856.             state.hints = kStateIsHostWritable;

  857.             state.key = "comment";

  858.             state.label = "Comment";

  859.             break;

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

  861.         case kCardinalStateModuleInfos:

  862.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  863.             state.hints = kStateIsHostReadable;

  864.            #else

  865.             state.hints = kStateIsOnlyForDSP;

  866.            #endif

  867.             state.defaultValue = "{}";

  868.             state.key = "moduleInfos";

  869.             state.label = "moduleInfos";

  870.             break;

  871.         case kCardinalStateWindowSize:

  872.             state.hints = kStateIsOnlyForUI;

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

  874.             state.key = "windowSize";

  875.             state.label = "Window size";

  876.             break;

  877.        #endif

  878.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  879.         case kCardinalStateParamChange:

  880.             state.hints = kStateIsHostReadable | kStateIsOnlyForDSP;

  881.             state.key = "param";

  882.             state.label = "ParamChange";

  883.             break;

  884.        #endif

  885.         }

  886.     }

  887. 

  888.    /* --------------------------------------------------------------------------------------------------------

  889.     * Internal data */

  890. 

  891.     float getParameterValue(uint32_t index) const override

  892.     {

  893.         // host mapped parameters

  894.         if (index < kCardinalParameterCountAtModules)

  895.             return context->parameters[index];

  896. 

  897.         // bypass

  898.         if (index == kCardinalParameterBypass)

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

  900. 

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

  902.         if (index < kCardinalParameterCountAtWindow)

  903.             return fWindowParameters[index - kCardinalParameterStartWindow];

  904.        #endif

  905. 

  906.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  907.         if (index < kCardinalParameterCountAtMini)

  908.             return fMiniReportValues[index - kCardinalParameterStartMini];

  909.        #endif

  910. 

  911.         return 0.0f;

  912.     }

  913. 

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

  915.     {

  916.         // host mapped parameters

  917.         if (index < kCardinalParameterCountAtModules)

  918.         {

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

  920.             return;

  921.         }

  922. 

  923.         // bypass

  924.         if (index == kCardinalParameterBypass)

  925.         {

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

  927.             return;

  928.         }

  929. 

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

  931.         if (index < kCardinalParameterCountAtWindow)

  932.         {

  933.             fWindowParameters[index - kCardinalParameterStartWindow] = value;

  934.             return;

  935.         }

  936.        #endif

  937.     }

  938. 

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

  940.     {

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

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

  943.         {

  944.             json_t* const rootJ = json_object();

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

  946. 

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

  948.             {

  949.                 json_t* const pluginJ = json_object();

  950.                 DISTRHO_SAFE_ASSERT_CONTINUE(pluginJ != nullptr);

  951. 

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

  953.                 {

  954.                     json_t* const moduleJ = json_object();

  955.                     DISTRHO_SAFE_ASSERT_CONTINUE(moduleJ != nullptr);

  956. 

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

  958. 

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

  960.                     if (m.favorite)

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

  962.                     if (m.added > 0)

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

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

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

  966. 

  967.                     if (json_object_size(moduleJ))

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

  969.                     else

  970.                         json_decref(moduleJ);

  971.                 }

  972. 

  973.                 if (json_object_size(pluginJ))

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

  975.                 else

  976.                     json_decref(pluginJ);

  977.             }

  978. 

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

  980.             json_decref(rootJ);

  981. 

  982.             return info;

  983.         }

  984. 

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

  986.             return fState.windowSize;

  987.        #endif

  988. 

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

  990.             return fState.comment;

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

  992.             return fState.screenshot;

  993. 

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

  995.             return String();

  996.         if (fAutosavePath.empty())

  997.             return String();

  998. 

  999.         std::vector<uint8_t> data;

  1000. 

  1001.         {

  1002.             const ScopedContext sc(this);

  1003. 

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

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

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

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

  1008. 

  1009.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  1012. 

  1013.             DEFER({

  1014.                 std::fclose(f);

  1015.             });

  1016. 

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

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

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

  1020. 

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

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

  1023. 

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

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

  1026. 

  1027.             return String(fileContent, false);

  1028.            #else

  1029.             try {

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

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

  1032.            #endif

  1033.         }

  1034. 

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

  1036.     }

  1037. 

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

  1039.     {

  1040.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

  1042.         {

  1043.             long long moduleId = 0;

  1044.             int paramId = 0;

  1045.             float paramValue = 0.f;

  1046.             {

  1047.                 const ScopedSafeLocale cssl;

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

  1049.             }

  1050. 

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

  1052.             DISTRHO_SAFE_ASSERT_RETURN(module != nullptr,);

  1053. 

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

  1055.             return;

  1056.         }

  1057.        #endif

  1058. 

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

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

  1061.         {

  1062.             json_error_t error;

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

  1064.             DISTRHO_SAFE_ASSERT_RETURN(rootJ != nullptr,);

  1065. 

  1066.             const char* pluginSlug;

  1067.             json_t* pluginJ;

  1068. 

  1069.             json_object_foreach(rootJ, pluginSlug, pluginJ)

  1070.             {

  1071.                 const char* moduleSlug;

  1072.                 json_t* moduleJ;

  1073. 

  1074.                 json_object_foreach(pluginJ, moduleSlug, moduleJ)

  1075.                 {

  1076.                     rack::settings::ModuleInfo m;

  1077. 

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

  1079.                         m.favorite = json_boolean_value(favoriteJ);

  1080. 

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

  1082.                         m.added = json_integer_value(addedJ);

  1083. 

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

  1085.                         m.lastAdded = json_number_value(lastAddedJ);

  1086. 

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

  1088.                 }

  1089.             }

  1090. 

  1091.             json_decref(rootJ);

  1092.             return;

  1093.         }

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

  1095.         {

  1096.             fState.windowSize = value;

  1097.             return;

  1098.         }

  1099.        #endif

  1100. 

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

  1102.         {

  1103.             fState.comment = value;

  1104.             return;

  1105.         }

  1106. 

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

  1108.         {

  1109.             fState.screenshot = value;

  1110.             return;

  1111.         }

  1112. 

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

  1114.             return;

  1115.         if (fAutosavePath.empty())

  1116.             return;

  1117. 

  1118.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  1121. 

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

  1123.         DISTRHO_SAFE_ASSERT_RETURN(f != nullptr,);

  1124. 

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

  1126.         std::fclose(f);

  1127.        #else

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

  1129. 

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

  1131. 

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

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

  1134. 

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

  1136. 

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

  1138.         {

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

  1140.             DISTRHO_SAFE_ASSERT_RETURN(f != nullptr,);

  1141. 

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

  1143.             std::fclose(f);

  1144.         }

  1145.         else

  1146.         {

  1147.             try {

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

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

  1150.         }

  1151.        #endif

  1152. 

  1153.         const ScopedContext sc(this);

  1154. 

  1155.         try {

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

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

  1158.             d_stderr(e.what());

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

  1160. 

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

  1162.     }

  1163. 

  1164.    /* --------------------------------------------------------------------------------------------------------

  1165.     * Process */

  1166. 

  1167.     void activate() override

  1168.     {

  1169.         context->bufferSize = getBufferSize();

  1170. 

  1171.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1172.         fAudioBufferCopy = new float*[DISTRHO_PLUGIN_NUM_INPUTS];

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

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

  1175.        #endif

  1176. 

  1177.         fNextExpectedFrame = 0;

  1178.     }

  1179. 

  1180.     void deactivate() override

  1181.     {

  1182.        #if DISTRHO_PLUGIN_NUM_INPUTS != 0

  1183.         if (fAudioBufferCopy != nullptr)

  1184.         {

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

  1186.                 delete[] fAudioBufferCopy[i];

  1187.             delete[] fAudioBufferCopy;

  1188.             fAudioBufferCopy = nullptr;

  1189.         }

  1190.        #endif

  1191.     }

  1192. 

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

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

  1195.     {

  1196.         const ScopedDenormalDisable sdd;

  1197. 

  1198.         rack::contextSet(context);

  1199. 

  1200.         const bool bypassed = context->bypassed;

  1201. 

  1202.         {

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

  1204. 

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

  1206. 

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

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

  1209.                 reset = false;

  1210. 

  1211.             context->playing = timePos.playing;

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

  1213.             context->frame = timePos.frame;

  1214. 

  1215.             if (timePos.bbt.valid)

  1216.             {

  1217.                 const double samplesPerTick = 60.0 * getSampleRate()

  1218.                                             / timePos.bbt.beatsPerMinute

  1219.                                             / timePos.bbt.ticksPerBeat;

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

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

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

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

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

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

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

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

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

  1229.                 context->ticksPerFrame = 1.0 / samplesPerTick;

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

  1231.                #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

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

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

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

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

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

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

  1240.                #endif

  1241.             }

  1242. 

  1243.             context->reset = reset;

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

  1245. 

  1246.            #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

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

  1250.             fMiniReportValues[kCardinalParameterMiniTimeFlags - kCardinalParameterStartMini] = flags;

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

  1252.            #endif

  1253.         }

  1254. 

  1255.         // separate buffers, use them

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

  1257.         {

  1258.             context->dataIns = inputs;

  1259.             context->dataOuts = outputs;

  1260.         }

  1261.         // inline processing, use a safe copy

  1262.         else

  1263.         {

  1264.            #if DISTRHO_PLUGIN_NUM_INPUTS != 0

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

  1266.             {

  1267.                #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

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

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

  1270.                #endif

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

  1272.             }

  1273.             context->dataIns = fAudioBufferCopy;

  1274.            #else

  1275.             context->dataIns = nullptr;

  1276.            #endif

  1277.             context->dataOuts = outputs;

  1278.         }

  1279. 

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

  1281.         {

  1282.            #if CARDINAL_VARIANT_MAIN || CARDINAL_VARIANT_MINI

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

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

  1285.            #endif

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

  1287.         }

  1288. 

  1289.        #if CARDINAL_VARIANT_MINI && ! DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

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

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

  1292.        #endif

  1293. 

  1294.         if (bypassed)

  1295.         {

  1296.             if (fWasBypassed != bypassed)

  1297.             {

  1298.                 context->midiEvents = bypassMidiEvents;

  1299.                 context->midiEventCount = 16;

  1300.             }

  1301.             else

  1302.             {

  1303.                 context->midiEvents = nullptr;

  1304.                 context->midiEventCount = 0;

  1305.             }

  1306.         }

  1307.         else

  1308.         {

  1309.             context->midiEvents = midiEvents;

  1310.             context->midiEventCount = midiEventCount;

  1311.         }

  1312. 

  1313.         ++context->processCounter;

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

  1315. 

  1316.         fWasBypassed = bypassed;

  1317.     }

  1318. 

  1319.     void sampleRateChanged(const double newSampleRate) override

  1320.     {

  1321.         rack::contextSet(context);

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

  1323.         context->sampleRate = newSampleRate;

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

  1325.     }

  1326. 

  1327.     // -------------------------------------------------------------------------------------------------------

  1328. 

  1329. private:

  1330.    /**

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

  1332.     */

  1333.     DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CardinalPlugin)

  1334. };

  1335. 

  1336. CardinalPluginContext* getRackContextFromPlugin(void* const ptr)

  1337. {

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

  1339. }

  1340. 

  1341. /* ------------------------------------------------------------------------------------------------------------

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

  1343. 

  1344. Plugin* createPlugin()

  1345. {

  1346.     return new CardinalPlugin();

  1347. }

  1348. 

  1349. // --------------------------------------------------------------------------------------------------------------------

  1350. 

  1351. END_NAMESPACE_DISTRHO