80 lines
4.3 KiB
C++
80 lines
4.3 KiB
C++
// reaper_bridge.h — the REAPER VST-host bridge (Phase S1 read spike). THIN shell:
|
|
// resolves REAPER API functions by name over the host context and reads the live
|
|
// "reasampler" project ext-state. The fiddly decode lives in bridge_marshal (pure).
|
|
//
|
|
// VERIFIED BRIDGE MECHANISM (corrects §1a's estimate). §1a described the VST2-style
|
|
// hostcb opcode pattern (hostcb(&effect, 0xdeadbeef, 0xdeadf00d, ...)). That is the
|
|
// VST2 path (video_processor.h documents it for a VST2 aEffect). For a VST3 plugin the
|
|
// bridge is exposed differently and more cleanly: REAPER passes an IHostApplication as
|
|
// the `context` to IComponent::initialize(FUnknown* context); querying it for
|
|
// IReaperHostApplication (vendor/reaper-sdk/sdk/reaper_vst3_interfaces.h) yields:
|
|
// * getReaperApi(funcname) -> resolve a REAPER API function pointer by name
|
|
// (the VST3 equivalent of opcode 0xdeadf00d), and
|
|
// * getReaperParent(3) -> the host ReaProject* (the VST3 equivalent of the
|
|
// 0xdeadf00e host-context fetch; 1=track, 2=take, 3=project, 4=fxdsp, 5=trackchan).
|
|
// So a VST3 uses IReaperHostApplication, not the raw hostcb opcodes. Verified against
|
|
// reaper_vst3_interfaces.h + reaper_plugin_functions.h at the spike.
|
|
|
|
#pragma once
|
|
|
|
#include <optional>
|
|
#include <string>
|
|
|
|
#include "pluginterfaces/base/funknown.h"
|
|
|
|
namespace reasampler::vst {
|
|
|
|
// Wraps the REAPER host bridge for a single plugin instance. Constructed cheaply;
|
|
// connect() must be called with the initialize() context before any read. All reads
|
|
// degrade to nullopt (never crash) when the host is not REAPER or a symbol is absent —
|
|
// the instrument must load in non-REAPER hosts too, just without live state.
|
|
class ReaperBridge {
|
|
public:
|
|
ReaperBridge() = default;
|
|
|
|
// Bind to the host. `context` is the FUnknown* REAPER hands IComponent::initialize.
|
|
// Returns true when the REAPER bridge is available (host is REAPER and the ext-state
|
|
// API resolved). Safe to call with a null or non-REAPER context — returns false.
|
|
bool connect(Steinberg::FUnknown* context);
|
|
|
|
// True once connect() found the REAPER host application AND resolved the ext-state
|
|
// functions.
|
|
bool isConnected() const { return getProjExtState_ != nullptr; }
|
|
|
|
// Read a "reasampler" ext-state value by key from the host's active project.
|
|
// Returns nullopt when unconnected, when the project can't be resolved, or when the
|
|
// key is absent. This is the S1 read-spike entry point.
|
|
//
|
|
// NOT REAL-TIME SAFE (it allocates a read buffer and calls into REAPER): callers on
|
|
// the audio thread MUST NOT invoke it. The S4 instrument reads on the main/UI thread
|
|
// and hands a snapshot to the process path (see reasampler_processor.cpp).
|
|
std::optional<std::string> readReasamplerExtState(const std::string& key);
|
|
|
|
// The active project's directory (the folder holding its .rpp), forward-slashed,
|
|
// no trailing slash — the M4 convention persist uses to place the bank alongside
|
|
// the .rpp. Empty for an unsaved project or when unconnected. The instrument
|
|
// resolves relative sample paths against this the SAME way persist does
|
|
// (capture_paths::projectDirOfRpp over EnumProjects(-1)'s .rpp path). Not RT-safe.
|
|
std::string activeProjectDir();
|
|
|
|
private:
|
|
// Resolved REAPER API function pointers (by name via getReaperApi). Signatures
|
|
// verified against reaper_plugin_functions.h.
|
|
using GetProjExtStateFn = int (*)(void* proj, const char* extname, const char* key,
|
|
char* valOutNeedBig, int valOutNeedBig_sz);
|
|
using EnumProjExtStateFn = bool (*)(void* proj, const char* extname, int idx,
|
|
char* keyOut, int keyOut_sz, char* valOut,
|
|
int valOut_sz);
|
|
// EnumProjects(-1, projfnOut, sz) -> active project + its .rpp path (SDK line
|
|
// ~1264). The instrument uses idx=-1 (current tab) so it follows the active project,
|
|
// and reads the .rpp path from the out-buffer exactly as persist.cpp does.
|
|
using EnumProjectsFn = void* (*)(int idx, char* projfnOut, int projfnOut_sz);
|
|
|
|
void* hostApp_ = nullptr; // IReaperHostApplication* (opaque here; used in .cpp)
|
|
GetProjExtStateFn getProjExtState_ = nullptr;
|
|
EnumProjExtStateFn enumProjExtState_ = nullptr;
|
|
EnumProjectsFn enumProjects_ = nullptr;
|
|
};
|
|
|
|
} // namespace reasampler::vst
|