@thedecipherist/claude-packs 1.0.0 → 1.1.0

package/packs/sound-design/tools/vst3host/options.h

@@ -0,0 +1,172 @@
+// The renderer's command line. One row per flag: a new flag is one new row.
+#pragma once
+
+#include <cstdint>
+#include <cstdlib>
+#include <functional>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace vst3host {
+
+struct Axis {
+    uint32_t offset = 0;
+    int steps = 0;
+    int max = 127;
+};
+
+struct Options {
+    std::string plugin;
+    std::string out = "render.wav";
+    std::string dir = ".";
+    double sampleRate = 44100.0;
+    double boot = 1.0;
+    double hold = 1.5;
+    double tail = 0.6;
+    double settle = 0.4;
+    int note = 60;
+    int velocity = 100;
+    int block = 512;
+    int program = -1;
+    int bankMsb = -1;
+    int bankLsb = -1;
+    bool list = false;
+    bool dumpParams = false;
+    std::map<uint32_t, double> params;
+    uint32_t sweepId = 0;
+    int sweepSteps = 0;
+    std::vector<std::string> sysexFiles;
+    // A Roland DT1 message is `F0 <head> 12 <address> <value> <sum> F7`. <head> is the maker, device and model: `41 10 00 06`.
+    std::vector<unsigned char> dt1Head;
+    uint32_t dt1Base = 0;
+    std::map<uint32_t, int> dt1;
+    Axis dt1Sweep;
+    std::vector<Axis> axes;
+    int probeLo = -1;
+    int probeHi = -1;
+    std::vector<int> probeValues { 0, 127 };
+    int mapLo = -1;
+    int mapHi = -1;
+    int mapValue = 100;
+};
+
+inline std::vector<std::string> split (const std::string& text, char by) {
+    std::vector<std::string> parts;
+    std::stringstream stream (text);
+    for (std::string part; std::getline (stream, part, by);) parts.push_back (part);
+    return parts;
+}
+
+inline uint32_t hex (const std::string& text) { return (uint32_t) std::stoul (text, nullptr, 16); }
+
+// OFFSET:STEPS[:MAX], the offset in hex.
+inline Axis axisOf (const std::string& text) {
+    const auto parts = split (text, ':');
+    if (parts.size() < 2) throw std::invalid_argument ("expected OFFSET:STEPS[:MAX], got " + text);
+    return { hex (parts[0]), std::stoi (parts[1]), parts.size() > 2 ? std::stoi (parts[2]) : 127 };
+}
+
+// LO-HI, in hex, into two ints.
+inline void rangeOf (const std::string& text, int& lo, int& hi) {
+    const auto parts = split (text, '-');
+    if (parts.size() != 2) throw std::invalid_argument ("expected LO-HI, got " + text);
+    lo = (int) hex (parts[0]);
+    hi = (int) hex (parts[1]);
+}
+
+inline void bytesOf (const std::string& text, std::vector<unsigned char>& into) {
+    for (const auto& part : split (text, ' ')) into.push_back ((unsigned char) hex (part));
+}
+
+inline void probeOf (Options& o, const std::string& text) {
+    const auto parts = split (text, ':');
+    rangeOf (parts[0], o.probeLo, o.probeHi);
+    if (parts.size() < 2) return;
+    o.probeValues.clear();
+    for (const auto& value : split (parts[1], ',')) o.probeValues.push_back (std::stoi (value));
+}
+
+inline void mapOf (Options& o, const std::string& text) {
+    const auto parts = split (text, ':');
+    rangeOf (parts[0], o.mapLo, o.mapHi);
+    if (parts.size() > 1) o.mapValue = std::stoi (parts[1]);
+}
+
+inline void paramOf (Options& o, const std::string& text) {
+    const auto parts = split (text, '=');
+    if (parts.size() != 2) throw std::invalid_argument ("expected ID=VALUE, got " + text);
+    o.params[(uint32_t) std::stoul (parts[0])] = std::stod (parts[1]);
+}
+
+inline void dt1Of (Options& o, const std::string& text) {
+    const auto parts = split (text, '=');
+    if (parts.size() != 2) throw std::invalid_argument ("expected OFFSET=VALUE, got " + text);
+    o.dt1[hex (parts[0])] = std::stoi (parts[1]);
+}
+
+inline void sweepOf (Options& o, const std::string& text) {
+    const auto parts = split (text, ':');
+    if (parts.size() != 2) throw std::invalid_argument ("expected ID:STEPS, got " + text);
+    o.sweepId = (uint32_t) std::stoul (parts[0]);
+    o.sweepSteps = std::stoi (parts[1]);
+}
+
+inline void bankOf (Options& o, const std::string& text) {
+    const auto parts = split (text, ':');
+    if (parts.size() != 2) throw std::invalid_argument ("expected MSB:LSB, got " + text);
+    o.bankMsb = std::stoi (parts[0]);
+    o.bankLsb = std::stoi (parts[1]);
+}
+
+using Row = std::function<void (Options&, const std::string&)>;
+
+inline const std::map<std::string, Row>& valueFlags() {
+    static const std::map<std::string, Row> rows {
+        { "--vst3", [] (Options& o, const std::string& v) { o.plugin = v; } },
+        { "--out", [] (Options& o, const std::string& v) { o.out = v; } },
+        { "--dir", [] (Options& o, const std::string& v) { o.dir = v; } },
+        { "--sr", [] (Options& o, const std::string& v) { o.sampleRate = std::stod (v); } },
+        { "--boot", [] (Options& o, const std::string& v) { o.boot = std::stod (v); } },
+        { "--hold", [] (Options& o, const std::string& v) { o.hold = std::stod (v); } },
+        { "--tail", [] (Options& o, const std::string& v) { o.tail = std::stod (v); } },
+        { "--settle", [] (Options& o, const std::string& v) { o.settle = std::stod (v); } },
+        { "--note", [] (Options& o, const std::string& v) { o.note = std::stoi (v); } },
+        { "--vel", [] (Options& o, const std::string& v) { o.velocity = std::stoi (v); } },
+        { "--block", [] (Options& o, const std::string& v) { o.block = std::stoi (v); } },
+        { "--program", [] (Options& o, const std::string& v) { o.program = std::stoi (v); } },
+        { "--bank", bankOf },
+        { "--param", paramOf },
+        { "--sweep", sweepOf },
+        { "--sysex", [] (Options& o, const std::string& v) { o.sysexFiles.push_back (v); } },
+        { "--dt1-head", [] (Options& o, const std::string& v) { bytesOf (v, o.dt1Head); } },
+        { "--dt1-base", [] (Options& o, const std::string& v) { o.dt1Base = hex (v); } },
+        { "--dt1", dt1Of },
+        { "--sweep-dt1", [] (Options& o, const std::string& v) { o.dt1Sweep = axisOf (v); } },
+        { "--axis", [] (Options& o, const std::string& v) { o.axes.push_back (axisOf (v)); } },
+        { "--probe", probeOf },
+        { "--map", mapOf },
+    };
+    return rows;
+}
+
+inline Options parseOptions (int argc, char** argv) {
+    Options o;
+    for (int i = 1; i < argc; ++i) {
+        const std::string flag = argv[i];
+        if (flag == "--list") o.list = true;
+        else if (flag == "--dump-params") o.dumpParams = true;
+        else {
+            const auto row = valueFlags().find (flag);
+            if (row == valueFlags().end()) throw std::invalid_argument ("unknown flag " + flag);
+            if (i + 1 >= argc) throw std::invalid_argument (flag + " needs a value");
+            row->second (o, argv[++i]);
+        }
+    }
+    if (o.plugin.empty()) throw std::invalid_argument ("name the plugin: --vst3 <path>");
+    return o;
+}
+
+} // namespace vst3host

package/packs/sound-design/tools/vst3host/render.cpp

@@ -0,0 +1,245 @@
+// Offline VST3 renderer: play a known note through a plugin and write what comes out, with no DAW, audio device or window.
+//   render --vst3 Plugin.vst3 --list                                  every parameter, with its id
+//   render --vst3 Plugin.vst3 --out a.wav --note 60 --hold 1.5        one note
+//   render --vst3 Plugin.vst3 --sweep 38:9 --dir out/                 one note per value of parameter 38
+//   render --vst3 Plugin.vst3 --sysex patch.syx --dump-params         send a patch, and read whether it was taken
+// The `bounce-a-plugin` skill says how to use it and what it took to learn.
+#include "session.h"
+
+#include <fstream>
+#include <iterator>
+#include <stdexcept>
+
+using namespace vst3host;
+
+namespace {
+
+template <typename T> void put (FILE* f, T value) { std::fwrite (&value, sizeof value, 1, f); }
+
+// 32-bit float, so a plugin that peaks over 1.0 is measured and never clipped.
+void writeWav (const std::string& path, Session& session, double sampleRate) {
+    const auto& left = session.keptLeft();
+    const auto& right = session.keptRight();
+    const auto bytes = (uint32_t) (left.size() * 2 * sizeof (float));
+    FILE* f = std::fopen (path.c_str(), "wb");
+    if (! f) throw std::runtime_error ("cannot write " + path);
+    std::fwrite ("RIFF", 1, 4, f);
+    put<uint32_t> (f, 36 + bytes);
+    std::fwrite ("WAVEfmt ", 1, 8, f);
+    put<uint32_t> (f, 16);
+    put<uint16_t> (f, 3);
+    put<uint16_t> (f, 2);
+    put<uint32_t> (f, (uint32_t) sampleRate);
+    put<uint32_t> (f, (uint32_t) sampleRate * 8);
+    put<uint16_t> (f, 8);
+    put<uint16_t> (f, 32);
+    std::fwrite ("data", 1, 4, f);
+    put<uint32_t> (f, bytes);
+    for (size_t i = 0; i < left.size(); ++i) {
+        put<float> (f, left[i]);
+        put<float> (f, right[i]);
+    }
+    std::fclose (f);
+}
+
+void oneNote (Session& session, const Options& o, const std::string& file) {
+    session.clearKept();
+    session.run (o.settle, false); // let the DSP finish slewing its coefficients
+    session.noteOn (o.note, o.velocity);
+    session.run (o.hold, true);
+    session.noteOff (o.note);
+    session.run (o.tail, true);
+    double peak = 0;
+    double sum = 0;
+    const auto& left = session.keptLeft();
+    const auto& right = session.keptRight();
+    for (size_t i = 0; i < left.size(); ++i) {
+        const double mid = 0.5 * (left[i] + right[i]);
+        peak = std::max (peak, std::abs (mid));
+        sum += mid * mid;
+    }
+    writeWav (file, session, o.sampleRate);
+    std::printf ("  %s  %.2fs  peak %.5f  rms %.6f\n", file.c_str(), left.size() / o.sampleRate, peak, std::sqrt (sum / std::max<size_t> (1, left.size())));
+}
+
+std::vector<unsigned char> dt1Message (const Options& o, uint32_t address, int value) {
+    if (o.dt1Head.empty()) throw std::invalid_argument ("a DT1 flag needs --dt1-head, the maker, device and model: `41 10 00 06`");
+    std::vector<unsigned char> message { 0xF0 };
+    message.insert (message.end(), o.dt1Head.begin(), o.dt1Head.end());
+    message.push_back (0x12);
+    int sum = 0;
+    for (int shift = 24; shift >= 0; shift -= 8) {
+        const auto byte = (unsigned char) ((address >> shift) & 0x7F);
+        message.push_back (byte);
+        sum += byte;
+    }
+    const auto byte = (unsigned char) (value & 0x7F);
+    message.push_back (byte);
+    message.push_back ((unsigned char) ((128 - ((sum + byte) % 128)) & 0x7F));
+    message.push_back (0xF7);
+    return message;
+}
+
+void sendDt1 (Session& session, const Options& o, uint32_t offset, int value) { session.sendBytes (dt1Message (o, o.dt1Base + offset, value)); }
+
+// One batch, then one settle, then the note: writes spread one per block made levels wander 8 dB between steps of a sweep.
+void sendBaseline (Session& session, const Options& o) {
+    for (const auto& [offset, value] : o.dt1) sendDt1 (session, o, offset, value);
+}
+
+void sendProgram (Session& session, const Options& o) {
+    if (o.program < 0) return;
+    if (o.bankMsb >= 0) {
+        session.sendBytes ({ 0xB0, 0x00, (unsigned char) o.bankMsb });
+        session.sendBytes ({ 0xB0, 0x20, (unsigned char) o.bankLsb });
+    }
+    session.sendBytes ({ 0xC0, (unsigned char) (o.program & 0x7F) });
+    session.run (0.6, false);
+}
+
+// A file may hold several messages: split on F0..F7 and sent one per settle, since a synth's MIDI input is a byte stream and a dump is long.
+void sendSysexFile (Session& session, const std::string& path) {
+    std::ifstream in (path, std::ios::binary);
+    if (! in) throw std::runtime_error ("cannot read " + path);
+    const std::vector<unsigned char> all ((std::istreambuf_iterator<char> (in)), std::istreambuf_iterator<char>());
+    size_t sent = 0;
+    for (size_t i = 0; i < all.size();) {
+        const auto start = std::find (all.begin() + (long) i, all.end(), (unsigned char) 0xF0);
+        const auto end = std::find (start, all.end(), (unsigned char) 0xF7);
+        if (end == all.end()) break;
+        session.sendBytes (std::vector<unsigned char> (start, end + 1));
+        session.run (0.05, false);
+        sent += 1;
+        i = (size_t) (end - all.begin()) + 1;
+    }
+    std::printf ("  sent %zu sysex message(s) from %s\n", sent, path.c_str());
+    session.run (0.5, false);
+}
+
+std::string named (const Options& o, const char* format, unsigned a, int b) {
+    char name[256];
+    std::snprintf (name, sizeof name, format, a, b);
+    return o.dir + "/" + name;
+}
+
+// Which parameter is this address? Ask the plugin: what it reports, or else what moved on the controller.
+void mapOffsets (Session& session, const Options& o) {
+    auto* controller = session.editController();
+    std::printf ("  offset -> parameter, as the plugin reports it\n");
+    std::vector<double> was;
+    const int32 count = controller ? controller->getParameterCount() : 0;
+    const auto valueOf = [&] (int32 i) {
+        Vst::ParameterInfo info {};
+        return controller->getParameterInfo (i, info) == kResultOk ? controller->getParamNormalized (info.id) : 0.0;
+    };
+    for (int32 i = 0; i < count; ++i) was.push_back (valueOf (i));
+    for (int offset = o.mapLo; offset <= o.mapHi; ++offset) {
+        session.reported().clear();
+        sendDt1 (session, o, (uint32_t) offset, o.mapValue);
+        session.run (0.25, false);
+        std::printf ("    0x%02x ", offset);
+        int moved = session.reported().getParameterCount();
+        for (int32 i = 0; i < count; ++i) {
+            const double now = valueOf (i);
+            if (std::abs (now - was[(size_t) i]) <= 1e-6) continue;
+            Vst::ParameterInfo info {};
+            controller->getParameterInfo (i, info);
+            std::printf (" %s = %.4f", titleOf (info).c_str(), now);
+            was[(size_t) i] = now;
+            moved += 1;
+        }
+        std::printf (moved ? "\n" : " (nothing reported, nothing moved)\n");
+    }
+}
+
+// Which offset IS the control? Each render puts the whole range back to rest first: without it the loop is cumulative, and each offset is measured on the last.
+void probeOffsets (Session& session, const Options& o) {
+    for (int offset = o.probeLo; offset <= o.probeHi; ++offset) {
+        for (const int value : o.probeValues) {
+            for (int other = o.probeLo; other <= o.probeHi; ++other) sendDt1 (session, o, (uint32_t) other, o.probeValues.front());
+            sendBaseline (session, o);
+            sendDt1 (session, o, (uint32_t) offset, value);
+            session.run (0.3, false);
+            oneNote (session, o, named (o, "probe_%02x_%03d.wav", (unsigned) offset, value));
+        }
+    }
+}
+
+int stepValue (const Axis& axis, int step) { return axis.steps == 1 ? 0 : step * axis.max / (axis.steps - 1); }
+
+// Every combination of the axes, outermost first.
+void walkAxes (Session& session, const Options& o, size_t depth, std::string name) {
+    if (depth == o.axes.size()) {
+        session.run (0.3, false);
+        return oneNote (session, o, o.dir + "/ax" + name + ".wav");
+    }
+    const auto& axis = o.axes[depth];
+    for (int step = 0; step < axis.steps; ++step) {
+        const int value = stepValue (axis, step);
+        if (depth == 0) sendBaseline (session, o);
+        sendDt1 (session, o, axis.offset, value);
+        walkAxes (session, o, depth + 1, name + "_" + std::to_string (axis.offset) + "-" + std::to_string (value));
+    }
+}
+
+void sweepDt1 (Session& session, const Options& o) {
+    for (int step = 0; step < o.dt1Sweep.steps; ++step) {
+        const int value = stepValue (o.dt1Sweep, step);
+        sendBaseline (session, o);
+        sendDt1 (session, o, o.dt1Sweep.offset, value);
+        session.run (0.3, false);
+        oneNote (session, o, named (o, "dt1_%02x_%03d.wav", o.dt1Sweep.offset, value));
+    }
+}
+
+// One note per value, never a knob turned under a sounding note: a swept knob measures a ramp, and a host may drop the note-off.
+void sweepParam (Session& session, const Options& o) {
+    for (int step = 0; step < o.sweepSteps; ++step) {
+        const double value = o.sweepSteps > 1 ? (double) step / (o.sweepSteps - 1) : 0.0;
+        for (const auto& [id, frozen] : o.params) session.setParam (id, frozen);
+        session.setParam (o.sweepId, value);
+        oneNote (session, o, named (o, "param%u_step%02d.wav", o.sweepId, step));
+    }
+}
+
+void render (Session& session, const Options& o) {
+    if (o.mapLo >= 0) mapOffsets (session, o);
+    else if (o.probeLo >= 0) probeOffsets (session, o);
+    else if (! o.axes.empty()) walkAxes (session, o, 0, "");
+    else if (o.dt1Sweep.steps > 0) sweepDt1 (session, o);
+    else if (o.sweepSteps > 0) sweepParam (session, o);
+    else oneNote (session, o, o.out);
+}
+
+int run (const Options& o) {
+    Session session (o);
+    if (const auto failed = session.open (o.plugin); ! failed.empty()) throw std::runtime_error (failed);
+    if (o.list) {
+        session.printParameters (false);
+        return 0;
+    }
+    if (const auto failed = session.start(); ! failed.empty()) throw std::runtime_error (failed);
+    session.run (o.boot, false); // an emulated firmware boots on a clock: it needs real samples before it answers a note
+    for (const auto& [id, value] : o.params) session.setParam (id, value);
+    sendProgram (session, o);
+    for (const auto& file : o.sysexFiles) sendSysexFile (session, file);
+    if (! o.dt1.empty()) {
+        sendBaseline (session, o);
+        session.run (0.3, false);
+    }
+    if (o.dumpParams) session.printParameters (true);
+    render (session, o);
+    session.stop();
+    return 0;
+}
+
+} // namespace
+
+int main (int argc, char** argv) {
+    try {
+        return run (parseOptions (argc, argv));
+    } catch (const std::exception& e) {
+        std::fprintf (stderr, "render: %s\n", e.what());
+        return 1;
+    }
+}

package/packs/sound-design/tools/vst3host/session.h

@@ -0,0 +1,241 @@
+// One plugin, loaded and running offline: no audio device, no window, no JUCE. A JUCE host cannot load every JUCE plugin (an allocator clash across
+// the boundary aborted one inside its own parameter loader), and every audio path through an operating system can fail differently, one of them by
+// returning silence instead of an error. A renderer that never opens a device has none of those failures, and runs faster than real time.
+#pragma once
+
+#include "host_events.h"
+#include "options.h"
+
+#include "pluginterfaces/vst/ivstaudioprocessor.h"
+#include "pluginterfaces/vst/ivstcomponent.h"
+#include "pluginterfaces/vst/ivsteditcontroller.h"
+#include "pluginterfaces/vst/ivstprocesscontext.h"
+#include "public.sdk/source/common/memorystream.h"
+#include "public.sdk/source/vst/hosting/hostclasses.h"
+#include "public.sdk/source/vst/hosting/module.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdio>
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace vst3host {
+
+inline std::string titleOf (const Vst::ParameterInfo& info) {
+    std::string name;
+    for (int k = 0; k < 128 && info.title[k]; ++k) name += (char) info.title[k];
+    return name;
+}
+
+class Session {
+public:
+    Session (const Options& options) : sampleRate (options.sampleRate), block (options.block) {}
+
+    // Loads the module and wires the two halves. An empty return is success; anything else is why it failed.
+    std::string open (const std::string& path) {
+        std::string error;
+        module = VST3::Hosting::Module::create (path, error);
+        if (! module) return "load failed: " + error;
+        auto factory = module->getFactory();
+        for (auto& info : factory.classInfos()) {
+            if (info.category() != kVstAudioEffectClass) continue;
+            component = factory.createInstance<Vst::IComponent> (info.ID()).take();
+            break;
+        }
+        if (! component) return "no audio class";
+        host = new Vst::HostApplication();
+        if (component->initialize (host) != kResultOk) return "initialize failed";
+        component->queryInterface (Vst::IAudioProcessor::iid, (void**) &processor);
+        if (! processor) return "no IAudioProcessor";
+        openController (factory);
+        return {};
+    }
+
+    void printParameters (bool withValues) {
+        if (! controller) return void (std::printf ("  no controller, so no parameters to read\n"));
+        const int32 count = controller->getParameterCount();
+        std::printf ("  %d parameters\n", count);
+        for (int32 i = 0; i < count; ++i) {
+            Vst::ParameterInfo info {};
+            if (controller->getParameterInfo (i, info) != kResultOk) continue;
+            if (withValues) std::printf ("    %-40s %.6f\n", titleOf (info).c_str(), controller->getParamNormalized (info.id));
+            else std::printf ("    %5d  id %-10u  %s\n", i, info.id, titleOf (info).c_str());
+        }
+    }
+
+    // Every output bus is activated and given a buffer: a plugin handed fewer buses than it declares may write nothing at all.
+    std::string start() {
+        Vst::ProcessSetup setup {};
+        setup.processMode = Vst::kOffline;
+        setup.symbolicSampleSize = Vst::kSample32;
+        setup.maxSamplesPerBlock = block;
+        setup.sampleRate = sampleRate;
+        if (processor->setupProcessing (setup) != kResultOk) return "setupProcessing failed";
+        activateBuses();
+        component->setActive (true);
+        processor->setProcessing (true);
+        prepareBuffers();
+        return {};
+    }
+
+    void stop() {
+        processor->setProcessing (false);
+        component->setActive (false);
+    }
+
+    // Renders this long. Events and parameter changes go in the first block.
+    void run (double seconds, bool keep) {
+        const int64 total = (int64) (seconds * sampleRate);
+        for (int64 done = 0; done < total; done += block) {
+            const auto count = (int32) std::min<int64> (block, total - done);
+            processBlock (count);
+            if (! keep) continue;
+            left.insert (left.end(), buffers[0].begin(), buffers[0].begin() + count);
+            right.insert (right.end(), buffers[1].begin(), buffers[1].begin() + count);
+        }
+    }
+
+    // Both routes. A firmware emulator's parameters may talk to it only through the controller, and a plain plugin reads inputParameterChanges.
+    void setParam (Vst::ParamID id, double value) {
+        if (controller) controller->setParamNormalized (id, value);
+        int32 index = 0;
+        int32 point = 0;
+        if (auto* queue = changes.addParameterData (id, index)) queue->addPoint (0, value, point);
+    }
+
+    // VST3 has no event for sysex or a program change: raw MIDI goes in a data event, which a plugin's own MIDI parser reads.
+    void sendBytes (std::vector<unsigned char> bytes) {
+        kept.push_back (std::move (bytes));
+        Vst::Event e {};
+        e.type = Vst::Event::kDataEvent;
+        e.data.type = Vst::DataEvent::kMidiSysEx;
+        e.data.size = (uint32) kept.back().size();
+        e.data.bytes = kept.back().data();
+        events.addEvent (e);
+    }
+
+    void noteOn (int pitch, int velocity) {
+        Vst::Event e {};
+        e.type = Vst::Event::kNoteOnEvent;
+        e.noteOn.pitch = (int16) pitch;
+        e.noteOn.velocity = (float) velocity / 127.0f;
+        e.noteOn.noteId = -1;
+        events.addEvent (e);
+    }
+
+    void noteOff (int pitch) {
+        Vst::Event e {};
+        e.type = Vst::Event::kNoteOffEvent;
+        e.noteOff.pitch = (int16) pitch;
+        e.noteOff.noteId = -1;
+        events.addEvent (e);
+    }
+
+    void clearKept() {
+        left.clear();
+        right.clear();
+    }
+
+    const std::vector<float>& keptLeft() const { return left; }
+    const std::vector<float>& keptRight() const { return right; }
+    Vst::IEditController* editController() { return controller; }
+    ParamChanges& reported() { return outChanges; }
+
+private:
+    // State first, then the wire: the controller mirrors the component, so it needs the state before its parameters mean anything.
+    void openController (VST3::Hosting::PluginFactory& factory) {
+        if (component->queryInterface (Vst::IEditController::iid, (void**) &controller) != kResultOk) {
+            TUID id;
+            if (component->getControllerClassId (id) == kResultOk) controller = factory.createInstance<Vst::IEditController> (VST3::UID (id)).take();
+            if (controller) controller->initialize (host);
+        }
+        if (! controller) return;
+        wireHalves();
+        MemoryStream state;
+        if (component->getState (&state) != kResultOk) return;
+        state.seek (0, IBStream::kIBSeekSet, nullptr);
+        controller->setComponentState (&state);
+    }
+
+    void wireHalves() {
+        Vst::IConnectionPoint* fromComponent = nullptr;
+        Vst::IConnectionPoint* fromController = nullptr;
+        component->queryInterface (Vst::IConnectionPoint::iid, (void**) &fromComponent);
+        controller->queryInterface (Vst::IConnectionPoint::iid, (void**) &fromController);
+        if (! fromComponent || ! fromController) return;
+        fromComponent->connect (new ConnectionProxy (fromController));
+        fromController->connect (new ConnectionProxy (fromComponent));
+    }
+
+    void activateBuses() {
+        const int32 outputs = component->getBusCount (Vst::kAudio, Vst::kOutput);
+        const int32 eventBuses = component->getBusCount (Vst::kEvent, Vst::kInput);
+        std::printf ("  buses: %d audio out, %d event in\n", outputs, eventBuses);
+        for (int32 bus = 0; bus < outputs; ++bus) component->activateBus (Vst::kAudio, Vst::kOutput, bus, true);
+        for (int32 bus = 0; bus < eventBuses; ++bus) component->activateBus (Vst::kEvent, Vst::kInput, bus, true);
+        if (component->getBusCount (Vst::kAudio, Vst::kInput) > 0) component->activateBus (Vst::kAudio, Vst::kInput, 0, true);
+    }
+
+    void prepareBuffers() {
+        const auto outputs = (size_t) std::max (1, component->getBusCount (Vst::kAudio, Vst::kOutput));
+        buffers.assign ((outputs + 1) * 2, std::vector<float> ((size_t) block, 0.0f)); // the last pair is the silent input
+        pointers.resize (outputs + 1);
+        busBuffers.assign (outputs + 1, Vst::AudioBusBuffers {});
+        for (size_t bus = 0; bus <= outputs; ++bus) {
+            pointers[bus] = { buffers[bus * 2].data(), buffers[bus * 2 + 1].data() };
+            busBuffers[bus].numChannels = 2;
+            busBuffers[bus].channelBuffers32 = pointers[bus].data();
+        }
+        context.state = Vst::ProcessContext::kPlaying | Vst::ProcessContext::kTempoValid;
+        context.sampleRate = sampleRate;
+        context.tempo = 120.0;
+        data.processMode = Vst::kOffline;
+        data.symbolicSampleSize = Vst::kSample32;
+        data.numInputs = component->getBusCount (Vst::kAudio, Vst::kInput) > 0 ? 1 : 0;
+        data.numOutputs = (int32) outputs;
+        data.inputs = data.numInputs ? &busBuffers[outputs] : nullptr;
+        data.outputs = busBuffers.data();
+        data.inputEvents = &events;
+        data.inputParameterChanges = &changes;
+        data.outputParameterChanges = &outChanges; // left null, a change a plugin's own sysex handler made stays invisible
+        data.processContext = &context;
+    }
+
+    void processBlock (int32 count) {
+        data.numSamples = count;
+        std::fill (buffers[0].begin(), buffers[0].end(), 0.0f);
+        std::fill (buffers[1].begin(), buffers[1].end(), 0.0f);
+        context.projectTimeSamples = position;
+        processor->process (data);
+        events.clear();
+        changes.clear();
+        kept.clear();
+        position += count;
+    }
+
+    double sampleRate;
+    int block;
+    VST3::Hosting::Module::Ptr module;
+    Vst::HostApplication* host = nullptr;
+    Vst::IComponent* component = nullptr;
+    Vst::IAudioProcessor* processor = nullptr;
+    Vst::IEditController* controller = nullptr;
+    std::vector<std::vector<float>> buffers;
+    std::vector<std::array<float*, 2>> pointers;
+    std::vector<Vst::AudioBusBuffers> busBuffers;
+    Vst::ProcessContext context {};
+    Vst::ProcessData data {};
+    EventList events;
+    ParamChanges changes;
+    ParamChanges outChanges;
+    std::deque<std::vector<unsigned char>> kept;
+    std::vector<float> left;
+    std::vector<float> right;
+    int64 position = 0;
+};
+
+} // namespace vst3host