@thedecipherist/claude-packs 0.0.0-stage → 1.1.0

package/packs/sound-design/tools/vst3host/build.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Builds the offline VST3 renderer on macOS or Linux. It links the VST3 SDK a project's JUCE already holds, and must not link JUCE itself: that is the
+# whole point, since a JUCE host cannot load every JUCE plugin. Run it from the project root, after the project's first configure has fetched JUCE.
+#   bash .claude/tools/vst3host/build.sh [out-dir]      VST3_SDK=<dir> names the SDK; otherwise it is looked for under JUCE
+# The source list took finding, so it is written here: the SDK inside JUCE is trimmed, and each of these has to be named.
+set -euo pipefail
+
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+out="${1:-out/vst3host}"
+
+find_sdk() {
+  local root module
+  if [[ -n "${VST3_SDK:-}" ]]; then
+    printf '%s\n' "$VST3_SDK"
+    return 0
+  fi
+  for root in out/*/_deps/juce-src build/_deps/juce-src build/*/_deps/juce-src cmake-build-*/_deps/juce-src JUCE third_party/JUCE; do
+    for module in juce_audio_processors_headless juce_audio_processors; do
+      if [[ -d "$root/modules/$module/format_types/VST3_SDK/public.sdk" ]]; then
+        printf '%s\n' "$PWD/$root/modules/$module/format_types/VST3_SDK"
+        return 0
+      fi
+    done
+  done
+  return 1
+}
+
+if ! sdk="$(find_sdk)"; then
+  echo "build.sh: no VST3 SDK found. Configure the project so JUCE is fetched, or set VST3_SDK to the folder." >&2
+  exit 1
+fi
+
+sources=(
+  public.sdk/source/vst/hosting/module.cpp
+  public.sdk/source/vst/hosting/hostclasses.cpp
+  public.sdk/source/vst/hosting/pluginterfacesupport.cpp
+  public.sdk/source/vst/vstinitiids.cpp
+  public.sdk/source/vst/utility/stringconvert.cpp
+  public.sdk/source/common/commonstringconvert.cpp
+  public.sdk/source/common/memorystream.cpp
+  pluginterfaces/base/funknown.cpp
+  pluginterfaces/base/coreiids.cpp
+  pluginterfaces/base/conststringtable.cpp
+  pluginterfaces/base/ustring.cpp
+  base/source/fobject.cpp
+  base/source/fstring.cpp
+  base/source/fdebug.cpp
+  base/source/fbuffer.cpp
+  base/source/baseiids.cpp
+  base/source/fstreamer.cpp
+  base/thread/source/flock.cpp
+)
+paths=()
+for source in "${sources[@]}"; do
+  paths+=("$sdk/$source")
+done
+
+mkdir -p "$out"
+flags=(-std=c++17 -O2 -DRELEASE=1 -I"$sdk" -I"$here")
+case "$(uname -s)" in
+  Darwin)
+    clang++ "${flags[@]}" -fobjc-arc -c "$sdk/public.sdk/source/vst/hosting/module_mac.mm" -o "$out/module_mac.o"
+    clang++ "${flags[@]}" "$here/render.cpp" "$out/module_mac.o" "${paths[@]}" -framework CoreFoundation -framework Foundation -o "$out/render"
+    ;;
+  Linux)
+    "${CXX:-g++}" "${flags[@]}" "$here/render.cpp" "$sdk/public.sdk/source/vst/hosting/module_linux.cpp" "${paths[@]}" -ldl -lpthread -o "$out/render"
+    ;;
+  *)
+    echo "build.sh: macOS and Linux only. On Windows, build render.cpp with module_win32.cpp and the same sources." >&2
+    exit 1
+    ;;
+esac
+echo "built $out/render"

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

@@ -0,0 +1,101 @@
+// What a VST3 host must supply and the SDK inside JUCE leaves out: the parameter and event lists, and the wire between a plugin's two halves.
+#pragma once
+
+#include "pluginterfaces/vst/ivstevents.h"
+#include "pluginterfaces/vst/ivstmessage.h"
+#include "pluginterfaces/vst/ivstparameterchanges.h"
+
+#include <utility>
+#include <vector>
+
+namespace vst3host {
+
+using namespace Steinberg;
+
+// One parameter's points for one block.
+class ParamQueue final : public Vst::IParamValueQueue {
+public:
+    explicit ParamQueue (Vst::ParamID id) : pid (id) {}
+    Vst::ParamID PLUGIN_API getParameterId() override { return pid; }
+    int32 PLUGIN_API getPointCount() override { return (int32) points.size(); }
+    tresult PLUGIN_API getPoint (int32 i, int32& offset, Vst::ParamValue& value) override {
+        if (i < 0 || i >= (int32) points.size()) return kResultFalse;
+        offset = points[(size_t) i].first;
+        value = points[(size_t) i].second;
+        return kResultOk;
+    }
+    tresult PLUGIN_API addPoint (int32 offset, Vst::ParamValue value, int32& i) override {
+        points.emplace_back (offset, value);
+        i = (int32) points.size() - 1;
+        return kResultOk;
+    }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    Vst::ParamID pid;
+    std::vector<std::pair<int32, Vst::ParamValue>> points;
+};
+IMPLEMENT_FUNKNOWN_METHODS (ParamQueue, Vst::IParamValueQueue, Vst::IParamValueQueue::iid)
+
+class ParamChanges final : public Vst::IParameterChanges {
+public:
+    ~ParamChanges() { clear(); }
+    int32 PLUGIN_API getParameterCount() override { return (int32) queues.size(); }
+    Vst::IParamValueQueue* PLUGIN_API getParameterData (int32 i) override {
+        return (i >= 0 && i < (int32) queues.size()) ? queues[(size_t) i] : nullptr;
+    }
+    Vst::IParamValueQueue* PLUGIN_API addParameterData (const Vst::ParamID& id, int32& i) override {
+        for (size_t k = 0; k < queues.size(); ++k) {
+            if (queues[k]->getParameterId() != id) continue;
+            i = (int32) k;
+            return queues[k];
+        }
+        auto* queue = new ParamQueue (id);
+        queue->addRef();
+        queues.push_back (queue);
+        i = (int32) queues.size() - 1;
+        return queue;
+    }
+    void clear() {
+        for (auto* queue : queues) queue->release();
+        queues.clear();
+    }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    std::vector<ParamQueue*> queues;
+};
+IMPLEMENT_FUNKNOWN_METHODS (ParamChanges, Vst::IParameterChanges, Vst::IParameterChanges::iid)
+
+class EventList final : public Vst::IEventList {
+public:
+    int32 PLUGIN_API getEventCount() override { return (int32) events.size(); }
+    tresult PLUGIN_API getEvent (int32 i, Vst::Event& e) override {
+        if (i < 0 || i >= (int32) events.size()) return kResultFalse;
+        e = events[(size_t) i];
+        return kResultOk;
+    }
+    tresult PLUGIN_API addEvent (Vst::Event& e) override {
+        events.push_back (e);
+        return kResultOk;
+    }
+    void clear() { events.clear(); }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    std::vector<Vst::Event> events;
+};
+IMPLEMENT_FUNKNOWN_METHODS (EventList, Vst::IEventList, Vst::IEventList::iid)
+
+// A plugin's component and controller talk through connection points, and the host is the wire. Some plugins build their parameter list
+// on the controller only after the component tells them to: without this a controller reports no parameters.
+class ConnectionProxy final : public Vst::IConnectionPoint {
+public:
+    explicit ConnectionProxy (Vst::IConnectionPoint* target) : other (target) {}
+    tresult PLUGIN_API connect (Vst::IConnectionPoint*) override { return kResultOk; }
+    tresult PLUGIN_API disconnect (Vst::IConnectionPoint*) override { return kResultOk; }
+    tresult PLUGIN_API notify (Vst::IMessage* message) override { return other ? other->notify (message) : kResultFalse; }
+    DECLARE_FUNKNOWN_METHODS
+private:
+    Vst::IConnectionPoint* other;
+};
+IMPLEMENT_FUNKNOWN_METHODS (ConnectionProxy, Vst::IConnectionPoint, Vst::IConnectionPoint::iid)
+
+} // namespace vst3host

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;
+    }
+}