add a scratch memory test plugin

Author: abique

plugins/CMakeLists.txt

@@ -75,6 +75,8 @@ add_library(
   plugs/svf/svf-plug.cc
   plugs/undo-test/undo-test.hh
   plugs/undo-test/undo-test.hxx
+  plugs/scratch-memory/scratch-memory.cc
+  plugs/scratch-memory/scratch-memory.hh
   smoothed-value.hh
   sample-delay.cc
   sample-delay.hh

plugins/clap-entry.cc

@@ -18,6 +18,7 @@
 #include "plugs/track-info/track-info.hh"
 #include "plugs/transport/transport-info.hh"
 #include "plugs/undo-test/undo-test.hxx"
+#include "plugs/scratch-memory/scratch-memory.hh"
 
 struct PluginEntry {
    using create_func = std::function<const clap_plugin *(const clap_host &)>;
@@ -57,6 +58,7 @@ static bool clap_init(const char *plugin_path) {
    addPlugin<clap::UndoTest<true, true>>();
    addPlugin<clap::UndoTest<true, false>>();
    addPlugin<clap::UndoTest<false, false>>();
+   addPlugin<clap::ScratchMemory>();
    return true;
 }
 

plugins/core-plugin.hh

@@ -40,11 +40,12 @@ namespace clap {
 #endif
    {
       using super = PluginGlue;
-      friend class Module;
 
       static const constexpr uint32_t max_frames = 256;
 
    public:
+      friend class Module;
+
       CorePlugin(std::unique_ptr<PathProvider> &&pathProvider,
                  const clap_plugin_descriptor *desc,
                  const clap_host &host);
@@ -53,6 +54,8 @@ namespace clap {
       const PathProvider &pathProvider() const noexcept { return *_pathProvider; }
       const TuningProvider &tuningProvider() const noexcept { return _tuningProvider; }
 
+      auto& host() const noexcept { return _host; }
+
    protected:
       bool enableDraftExtensions() const noexcept override { return true; }
 

plugins/modules/module.hh

@@ -37,7 +37,8 @@ namespace clap {
       [[nodiscard]] virtual std::unique_ptr<Module> cloneVoice() const;
 
       bool activate(double sampleRate, uint32_t maxFrameCount, bool isRealTime);
-      [[nodiscard]] virtual bool doActivate(double sampleRate, uint32_t maxFrameCount, bool isRealTime);
+      [[nodiscard]] virtual bool
+      doActivate(double sampleRate, uint32_t maxFrameCount, bool isRealTime);
       void deactivate();
       virtual void doDeactivate();
       [[nodiscard]] bool isActive() const noexcept { return _isActive; }
@@ -63,13 +64,9 @@ namespace clap {
          _voiceModule = voiceModule;
       }
 
-      virtual VoiceExpanderModule *getVoiceExpander() noexcept {
-         return nullptr;
-      }
+      virtual VoiceExpanderModule *getVoiceExpander() noexcept { return nullptr; }
 
-      virtual const VoiceExpanderModule *getVoiceExpander() const noexcept {
-         return nullptr;
-      }
+      virtual const VoiceExpanderModule *getVoiceExpander() const noexcept { return nullptr; }
 
       virtual uint32_t latency() const noexcept { return 0; }
 

plugins/plugs/scratch-memory/scratch-memory.cc

@@ -0,0 +1,62 @@
+#include <cstring>
+
+#include "scratch-memory.hh"
+
+namespace clap {
+   static constexpr size_t SCRATCH_SIZE = 16 * 1024;
+
+   class ScratchMemoryModule final : public Module {
+   public:
+      ScratchMemoryModule(ScratchMemory &plugin) : Module(plugin, "", 0) {}
+
+      [[nodiscard]] virtual bool
+      doActivate(double sampleRate, uint32_t maxFrameCount, bool isRealTime) override {
+         auto &h = _plugin.host();
+
+         _didReserveScratchMemory = false;
+         if (h.canUseScratchMemory())
+            _didReserveScratchMemory = h.scratchMemoryReserve(SCRATCH_SIZE, 0);
+
+         return true;
+      }
+
+      clap_process_status process(const Context &c, uint32_t numFrames) noexcept override {
+         auto &h = _plugin.host();
+         if (_didReserveScratchMemory) {
+            auto scratchPtr = h.scratchMemoryAccess();
+            if (scratchPtr)
+               std::memset(scratchPtr, 0, SCRATCH_SIZE);
+         }
+         return CLAP_PROCESS_CONTINUE;
+      }
+
+      bool _didReserveScratchMemory = false;
+   };
+
+   const clap_plugin_descriptor *ScratchMemory::descriptor() {
+      static const char *features[] = {
+         CLAP_PLUGIN_FEATURE_UTILITY, CLAP_PLUGIN_FEATURE_ANALYZER, nullptr};
+
+      static const clap_plugin_descriptor desc = {CLAP_VERSION,
+                                                  "com.github.free-audio.clap.scratch-memory-test",
+                                                  "Scratch Memory Test",
+                                                  "clap",
+                                                  "https://github.com/free-audio/clap",
+                                                  nullptr,
+                                                  nullptr,
+                                                  "1.0",
+                                                  "Tests scratch memory",
+                                                  features};
+
+      return &desc;
+   }
+
+   enum {
+      kParamIdOffset = 0,
+   };
+
+   ScratchMemory::ScratchMemory(const std::string &pluginPath, const clap_host &host)
+      : CorePlugin(PathProvider::create(pluginPath, "transport-info"), descriptor(), host) {
+      _rootModule = std::make_unique<ScratchMemoryModule>(*this);
+   }
+} // namespace clap

plugins/plugs/scratch-memory/scratch-memory.hh

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../../core-plugin.hh"
+
+namespace clap {
+   class ScratchMemory final : public CorePlugin {
+   private:
+      using super = CorePlugin;
+
+   public:
+      ScratchMemory(const std::string &pluginPath, const clap_host &host);
+
+      static const clap_plugin_descriptor *descriptor();
+   };
+} // namespace clap