daniel
d4ffea6918
FxBypassGuard now snapshots/restores D_VOL, D_PAN, D_WIDTH, D_PANLAW, I_PANMODE alongside I_FXEN for every bypassed track (forcing stereo-pan mode for an unambiguous render), so Track/Item captures are uncolored by parent/folder/master fader and routing. All restored on every path.
668 lines
32 KiB
C++
668 lines
32 KiB
C++
// main.cpp — the SINGLE translation unit that OWNS the REAPER API pointers.
|
|
//
|
|
// This file is the entire contract between REAPER and the extension:
|
|
// * At startup REAPER scans UserPlugins/ for reaper_*.dll|dylib|so and
|
|
// dlopen()s each one, then looks up ONE exported symbol: ReaperPluginEntry
|
|
// (that name is produced by the REAPER_PLUGIN_ENTRYPOINT macro).
|
|
// * REAPER calls it, handing over `rec` — a small dispatch struct.
|
|
// - rec->GetFunc(name) resolves any REAPER API function to a pointer
|
|
// - rec->Register(what,ptr) plugs OUR callbacks into REAPER
|
|
// * REAPERAPI_LoadAPI(rec->GetFunc) walks reaper_plugin_functions.h and
|
|
// fills in every global function pointer (ShowConsoleMsg, InsertMedia...).
|
|
//
|
|
// Exactly ONE .cpp defines REAPERAPI_IMPLEMENT (this one) — that allocates
|
|
// storage for those global pointers. Every other .cpp includes
|
|
// reaper_plugin_functions.h WITHOUT the define and gets `extern` declarations.
|
|
|
|
#define REAPERAPI_IMPLEMENT
|
|
#include "reaper_plugin.h"
|
|
#include "reaper_plugin_functions.h"
|
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
|
|
|
#include "actions.h"
|
|
#include "bank_model.h"
|
|
#include "bank_panel.h"
|
|
#include "capture.h"
|
|
#include "insert.h"
|
|
#include "persist.h"
|
|
#include "render_settings.h"
|
|
#include "track_guid.h"
|
|
#include "view.h"
|
|
|
|
// Persistent action-id prefix for the ReaSampler action family.
|
|
// Every bindable action (capture / insert / slot / verify) mints its command id
|
|
// from a string beginning with this prefix, e.g. "CEREBELLUM_REASAMPLER_CAPTURE_MASTER".
|
|
// FOREVER-STABLE once shipped: user keybindings key off these strings, so the
|
|
// prefix and any minted id must never change after release.
|
|
#define REASAMPLER_ACTION_PREFIX "CEREBELLUM_REASAMPLER_"
|
|
|
|
// Globals other files reference via `extern`.
|
|
REAPER_PLUGIN_HINSTANCE g_hInst = nullptr; // this module's instance handle
|
|
reaper_plugin_info_t* g_rec = nullptr; // REAPER's dispatch struct
|
|
|
|
// ---- Capture action family (three FX scopes) -------------------------------
|
|
// Three bindable SCOPE actions from captureActionTable() (render_settings, pure):
|
|
// capture item / track / master. Each infers its range (razor-else-time) and
|
|
// enforces the FX-scope invariant via FX-bypass-around-render (FxBypassGuard):
|
|
// Item -> take/item FX only (bypass the item's track + ancestors + master).
|
|
// Track -> item FX + track's own FX (bypass ancestors + master).
|
|
// Master -> whole chain (bypass nothing).
|
|
// This REPLACES the retired M7 four-mode family (master / tracks / items / razor).
|
|
// The retired CAPTURE_TRACKS_WET / CAPTURE_ITEMS_WET / CAPTURE_RAZOR_WET ids are
|
|
// mirror-unregistered on unload so old keybindings clear cleanly; CAPTURE_MASTER's
|
|
// id string is preserved.
|
|
//
|
|
// The minted command ids parallel the table rows 1:1 (same index). gaccel storage
|
|
// must outlive registration (REAPER holds each pointer), so both vectors are file-
|
|
// scope and sized to the table. FOREVER-STABLE id strings live in the table.
|
|
static std::vector<int> g_captureCmdIds;
|
|
static std::vector<gaccel_register_t> g_captureAccels;
|
|
|
|
// Retired capture-action command-id strings (M7 four-mode family). Kept ONLY to
|
|
// mirror-unregister them on unload so a user's stale keybindings are cleaned up.
|
|
// Never re-register these. CAPTURE_MASTER is NOT here — its id string carries over
|
|
// to the new master scope action unchanged.
|
|
static const char* const kRetiredCaptureCmdStrings[] = {
|
|
"CEREBELLUM_REASAMPLER_CAPTURE_TRACKS_WET",
|
|
"CEREBELLUM_REASAMPLER_CAPTURE_ITEMS_WET",
|
|
"CEREBELLUM_REASAMPLER_CAPTURE_RAZOR_WET",
|
|
};
|
|
|
|
// Command id for "ReaSampler: toggle bank panel" (M5). FOREVER-STABLE string.
|
|
// The docked grid window is display-only this wave (Wave A) — the action just
|
|
// shows/hides it; it never captures, inserts, or mutates the bank.
|
|
static int g_cmdToggleBankPanel = 0;
|
|
|
|
// Command ids for the M6 insert actions. FOREVER-STABLE strings. Two variants that
|
|
// differ ONLY in the InsertOptions they build: the default inserts at native length
|
|
// (no stretch, no conform); the "conform" variant is the EXPLICIT opt-in to REAPER's
|
|
// try-to-match-project-tempo path (CONTEXT.md §insert: conform is opt-in, never
|
|
// silent). Both read the bank panel's current selection and place at the edit cursor.
|
|
static int g_cmdInsertSelected = 0;
|
|
static int g_cmdInsertSelectedConform = 0;
|
|
|
|
// The persistence session (M4): owns the in-memory BankIndex and bridges it to
|
|
// project ext state. A timer tick drives g_session.poll() to detect project
|
|
// load / Save-As; capture adds Samples to g_session.bank(); after a capture we
|
|
// serialize the bank back into the active project's ext state so it travels with
|
|
// the .rpp. Replaces the M3 session-only g_bank.
|
|
static reasampler::ReaSamplerSession g_session;
|
|
|
|
// The timer callback REAPER runs periodically (registered via "timer"). It only
|
|
// forwards to the session poll — cheap per tick (reads the active project id and
|
|
// its .rpp path, acts only on a change).
|
|
static void OnTimer()
|
|
{
|
|
g_session.poll();
|
|
|
|
// D4 reapply-on-open glue. persist stays MODEL-ONLY (it loads the saved view
|
|
// model but deliberately does NOT apply visibility — that would couple persist
|
|
// to the view shell). Instead poll() raises a one-shot load signal; here — the
|
|
// integration layer that already drives both persist and the view shell — we
|
|
// drain it and reapply the SAVED active mode's visibility/processing so opening a
|
|
// project saved in Design mode parks the Arrange tracks automatically, no manual
|
|
// toggle. Fires exactly once per load (consumeLoadSignal clears it); idle ticks
|
|
// skip it. proj = nullptr -> REAPER's active project (the one poll just loaded).
|
|
if (g_session.consumeLoadSignal())
|
|
reasampler::applyMode(g_session.view(), g_session.view().activeModeId(), nullptr);
|
|
|
|
// Reflect a live bank change (capture / project load) in the docked grid.
|
|
// Cheap when the bank is unchanged (a fingerprint compare); repaints only on
|
|
// an actual change. No-op when the panel is closed.
|
|
reasampler::bankPanelRefresh();
|
|
}
|
|
|
|
// --- Scope-action source resolution -----------------------------------------
|
|
// The three scope actions (item / track / master) each resolve to (1) an exact
|
|
// render range in project seconds — razor-else-time, inferred here — and (2) the
|
|
// set of source TRACKS whose ancestor chains drive the FX-bypass plan. All reads
|
|
// are non-destructive: selection, razor, and time selection are read, never
|
|
// mutated. Returning false means "nothing to capture" (empty selection / no
|
|
// range); the caller reports it and writes nothing.
|
|
|
|
// The resolved source: exact bounds + the source tracks (for FX-bypass + Sample
|
|
// provenance GUIDs). `sourceTracks` is empty for Master scope.
|
|
struct ResolvedSource
|
|
{
|
|
double startSeconds = 0.0;
|
|
double endSeconds = 0.0;
|
|
std::vector<MediaTrack*> sourceTracks; // item's/selected tracks; empty for master
|
|
std::vector<std::string> trackGuids; // canonical GUIDs of sourceTracks
|
|
};
|
|
|
|
// Time selection -> exact bounds (no rounding). GetSet_LoopTimeRange(isSet=false,
|
|
// isLoop=false) reads the current time selection.
|
|
static bool resolveTimeSelection(double& start, double& end)
|
|
{
|
|
start = 0.0; end = 0.0;
|
|
GetSet_LoopTimeRange(false, false, &start, &end, false);
|
|
return end > start;
|
|
}
|
|
|
|
// Reads every track's P_RAZOREDITS (SDK header ~2899: space-separated triples of
|
|
// start, end, envGuidString), parses the track-audio areas (pure parseRazorEdits),
|
|
// and returns the union bound. Reads only — never clears the razor selection.
|
|
// Returns false when no track-audio razor area exists on any track.
|
|
static bool resolveRazorRange(double& start, double& end)
|
|
{
|
|
std::vector<reasampler::RazorRange> allRanges;
|
|
const int n = CountTracks(nullptr);
|
|
for (int i = 0; i < n; ++i)
|
|
{
|
|
MediaTrack* tr = GetTrack(nullptr, i);
|
|
if (!tr) continue;
|
|
std::vector<char> buf(8192, '\0');
|
|
if (!GetSetMediaTrackInfo_String(tr, "P_RAZOREDITS", buf.data(), false))
|
|
continue;
|
|
std::vector<reasampler::RazorRange> ranges =
|
|
reasampler::parseRazorEdits(std::string(buf.data()));
|
|
for (auto& r : ranges) allRanges.push_back(r);
|
|
}
|
|
if (allRanges.empty()) return false;
|
|
reasampler::RazorRange u = reasampler::razorUnionBounds(allRanges);
|
|
start = u.startSeconds;
|
|
end = u.endSeconds;
|
|
return end > start;
|
|
}
|
|
|
|
// Infers the render RANGE for any scope: razor union when a razor area is present,
|
|
// else the time selection (pure inferRangeSource decides which). Orthogonal to
|
|
// scope. Returns false (with a reason) when neither yields a non-empty range.
|
|
static bool resolveRange(double& start, double& end, std::string& why)
|
|
{
|
|
double rzStart = 0.0, rzEnd = 0.0;
|
|
const bool hasRazor = resolveRazorRange(rzStart, rzEnd);
|
|
if (reasampler::inferRangeSource(hasRazor) == reasampler::RangeSource::Razor)
|
|
{
|
|
start = rzStart; end = rzEnd;
|
|
return true; // resolveRazorRange already verified end > start
|
|
}
|
|
if (resolveTimeSelection(start, end)) return true;
|
|
why = "make a razor area or a time selection first";
|
|
return false;
|
|
}
|
|
|
|
// Collects the selected tracks (Track scope) into out.sourceTracks + GUIDs.
|
|
static bool collectSelectedTracks(ResolvedSource& out)
|
|
{
|
|
const int n = CountSelectedTracks(nullptr); // nullptr = active project
|
|
if (n <= 0) return false;
|
|
for (int i = 0; i < n; ++i)
|
|
{
|
|
MediaTrack* tr = GetSelectedTrack(nullptr, i);
|
|
if (!tr) continue;
|
|
out.sourceTracks.push_back(tr);
|
|
std::string g = reasampler::guidString(tr);
|
|
if (!g.empty()) out.trackGuids.push_back(std::move(g));
|
|
}
|
|
return !out.sourceTracks.empty();
|
|
}
|
|
|
|
// Collects the tracks that own the selected items (Item scope) into
|
|
// out.sourceTracks (deduped) — these are the tracks whose FX must be bypassed so an
|
|
// item capture hears take/item FX only. GetMediaItem_Track(item) gives the owning
|
|
// track (SDK header, verify). GUIDs recorded for provenance.
|
|
static bool collectSelectedItemTracks(ResolvedSource& out)
|
|
{
|
|
const int n = CountSelectedMediaItems(nullptr);
|
|
if (n <= 0) return false;
|
|
for (int i = 0; i < n; ++i)
|
|
{
|
|
MediaItem* it = GetSelectedMediaItem(nullptr, i);
|
|
if (!it) continue;
|
|
MediaTrack* tr = GetMediaItem_Track(it);
|
|
if (!tr) continue;
|
|
// Dedup: several selected items can share a track.
|
|
bool seen = false;
|
|
for (MediaTrack* t : out.sourceTracks) if (t == tr) { seen = true; break; }
|
|
if (seen) continue;
|
|
out.sourceTracks.push_back(tr);
|
|
std::string g = reasampler::guidString(tr);
|
|
if (!g.empty()) out.trackGuids.push_back(std::move(g));
|
|
}
|
|
return !out.sourceTracks.empty();
|
|
}
|
|
|
|
// Resolves the source for a scope: the selection tracks (item/track) or none
|
|
// (master), plus the inferred range. Returns false with a reason on nothing to do.
|
|
static bool ResolveScopeSource(reasampler::CaptureScope scope,
|
|
ResolvedSource& out, std::string& why)
|
|
{
|
|
using reasampler::CaptureScope;
|
|
switch (scope)
|
|
{
|
|
case CaptureScope::Item:
|
|
if (!collectSelectedItemTracks(out)) {
|
|
why = "select at least one media item"; return false;
|
|
}
|
|
break;
|
|
case CaptureScope::Track:
|
|
if (!collectSelectedTracks(out)) {
|
|
why = "select at least one track"; return false;
|
|
}
|
|
break;
|
|
case CaptureScope::Master:
|
|
break; // whole chain — no source-track collection
|
|
}
|
|
return resolveRange(out.startSeconds, out.endSeconds, why);
|
|
}
|
|
|
|
// --- FX-bypass + full parent-chain neutralize around render (RAII, non-destr.) --
|
|
// For every track a scope must NOT hear the FX of, this ALSO neutralizes that
|
|
// track's fader gain AND its full pan chain (pan/width/law/mode) for the render —
|
|
// because a Track/Item capture renders via master and would otherwise sum through
|
|
// the parent/folder/master FADERS and PAN/WIDTH/LAW, printing their gain and pan
|
|
// coloring into the file (Daniel: the capture is likely re-routed through that
|
|
// same chain later, so parent/master level and pan must not be baked in). The
|
|
// neutralize set is IDENTICAL to the FX-bypass set:
|
|
// Item -> own track + all ancestors + master (take vol/pan kept: item content).
|
|
// Track -> all ancestors + master (selected track's OWN vol/pan kept).
|
|
// Master-> nothing (full chain, unchanged).
|
|
//
|
|
// Per track in that set we snapshot & set the full parent-chain-independence set,
|
|
// so a Track/Item capture is uncolored by the parent/folder/master it renders
|
|
// through — no FX, no fader, and no pan/width/law/mode coloring:
|
|
// I_FXEN -> 0 (FX bypassed; SDK ~2194)
|
|
// D_VOL -> 1.0 (unity trim volume; SDK ~2226 "1=+0dB")
|
|
// D_PAN -> 0.0 (center; SDK ~2227 "trim pan of track, -1..1")
|
|
// D_WIDTH -> 1.0 (full/neutral stereo width; SDK ~2228 "width, -1..1",
|
|
// 1.0 = full width = no narrowing/collapse)
|
|
// D_PANLAW -> 1.0 (no coloring; SDK ~2232 "1=+0dB" — pan-law applies no gain)
|
|
// I_PANMODE -> 5 (stereo pan; SDK ~2231 "0=classic,3=balance,5=stereo,6=dual")
|
|
// All are restored to their ORIGINAL values on EVERY exit path (RAII).
|
|
//
|
|
// Why also force I_PANMODE (pan mode). D_PAN's effect is mode-dependent. In modes
|
|
// 0/3/5, D_PAN=0 + D_WIDTH=1 is a provable pass-through. But in mode 6 (dual pan)
|
|
// D_PAN/D_WIDTH are ignored — routing is governed instead by D_DUALPANL/D_DUALPANR
|
|
// (SDK ~2229-2230, live only when I_PANMODE==6), whose neutral pass-through the
|
|
// header does not state as such. Rather than snapshot two more mode-conditional
|
|
// params and infer their neutral values, we force I_PANMODE=5 (stereo pan) for the
|
|
// render, where D_PAN=0 + D_WIDTH=1 is unambiguously uncolored, then restore the
|
|
// original mode. This fully neutralizes pan for every original mode with no
|
|
// residual — the "handle it fully" the brief requires. (See Snap dual-pan note.)
|
|
//
|
|
// Structurally non-destructive: no takes, no items, no project restructuring —
|
|
// only transient FX-enable + trim-volume toggles, always restored.
|
|
class FxBypassGuard
|
|
{
|
|
public:
|
|
// scope drives fxBypassPlanFor; sourceTracks are the captured tracks whose
|
|
// ancestor chains (walked via GetParentTrack) + the master are bypassed per the
|
|
// plan. proj is the active project (for GetMasterTrack).
|
|
FxBypassGuard(reasampler::CaptureScope scope,
|
|
const std::vector<MediaTrack*>& sourceTracks,
|
|
ReaProject* proj)
|
|
{
|
|
const reasampler::FxBypassPlan plan = reasampler::fxBypassPlanFor(scope);
|
|
|
|
for (MediaTrack* tr : sourceTracks)
|
|
{
|
|
if (!tr) continue;
|
|
if (plan.bypassSelfFx) bypass(tr);
|
|
if (plan.bypassAncestorFx)
|
|
{
|
|
// Walk parents to the top: GetParentTrack returns the immediate
|
|
// parent (folder) track, nullptr at the outermost level (SDK
|
|
// header ~2407). The master is NOT returned here — handled below.
|
|
for (MediaTrack* p = GetParentTrack(tr); p; p = GetParentTrack(p))
|
|
bypass(p);
|
|
}
|
|
}
|
|
if (plan.bypassMaster)
|
|
{
|
|
// GetMasterTrack(proj) -> the master track (SDK header ~1925). bypass()
|
|
// neutralizes its FX (I_FXEN), gain (D_VOL) AND pan/width/law/mode on it
|
|
// just like any other in-scope track; only the master's summing/routing
|
|
// topology (the mix bus itself) remains — that is not a per-track param.
|
|
if (MediaTrack* master = GetMasterTrack(proj)) bypass(master);
|
|
}
|
|
}
|
|
|
|
~FxBypassGuard()
|
|
{
|
|
// Restore in reverse for symmetry (order is not load-bearing — each track
|
|
// appears once, snapshots are independent). EVERY snapshotted param is
|
|
// restored to its ORIGINAL value on this (every) exit path. Restore
|
|
// I_PANMODE before the pan values so any mode-conditional params (e.g. dual
|
|
// pan) settle under the original mode.
|
|
for (auto it = snapshots_.rbegin(); it != snapshots_.rend(); ++it)
|
|
{
|
|
SetMediaTrackInfo_Value(it->track, "I_FXEN", it->fxen);
|
|
SetMediaTrackInfo_Value(it->track, "D_VOL", it->vol);
|
|
SetMediaTrackInfo_Value(it->track, "I_PANMODE", it->panmode);
|
|
SetMediaTrackInfo_Value(it->track, "D_PAN", it->pan);
|
|
SetMediaTrackInfo_Value(it->track, "D_WIDTH", it->width);
|
|
SetMediaTrackInfo_Value(it->track, "D_PANLAW", it->panlaw);
|
|
}
|
|
}
|
|
|
|
FxBypassGuard(const FxBypassGuard&) = delete;
|
|
FxBypassGuard& operator=(const FxBypassGuard&) = delete;
|
|
|
|
private:
|
|
// One snapshot per bypassed track: all params we neutralize, at their originals.
|
|
// panmode captures I_PANMODE so we can force stereo-pan for the render and put
|
|
// the original mode back — which also makes D_DUALPANL/D_DUALPANR (live only when
|
|
// I_PANMODE==6, SDK ~2229-2230) irrelevant during the render without us having to
|
|
// touch or guess neutral values for them.
|
|
struct Snap
|
|
{
|
|
MediaTrack* track;
|
|
double fxen;
|
|
double vol;
|
|
double pan;
|
|
double width;
|
|
double panlaw;
|
|
double panmode;
|
|
};
|
|
std::vector<Snap> snapshots_;
|
|
|
|
// Snapshot every neutralized param once per track (dedup: an ancestor shared by
|
|
// two selected tracks must be restored to its ORIGINAL values, not to a
|
|
// re-snapshot of the already-neutralized state), then read ALL originals, push
|
|
// one Snap, and set all to neutral — bypass FX, unity gain, uncolored pan chain.
|
|
void bypass(MediaTrack* tr)
|
|
{
|
|
for (const Snap& s : snapshots_) if (s.track == tr) return; // already done
|
|
// Read ALL originals first (atomic snapshot), then push, then neutralize.
|
|
const double fxen = GetMediaTrackInfo_Value(tr, "I_FXEN");
|
|
const double vol = GetMediaTrackInfo_Value(tr, "D_VOL");
|
|
const double pan = GetMediaTrackInfo_Value(tr, "D_PAN");
|
|
const double width = GetMediaTrackInfo_Value(tr, "D_WIDTH");
|
|
const double panlaw = GetMediaTrackInfo_Value(tr, "D_PANLAW");
|
|
const double panmode = GetMediaTrackInfo_Value(tr, "I_PANMODE");
|
|
snapshots_.push_back({tr, fxen, vol, pan, width, panlaw, panmode});
|
|
SetMediaTrackInfo_Value(tr, "I_FXEN", 0.0); // 0 = bypassed (SDK ~2194)
|
|
SetMediaTrackInfo_Value(tr, "D_VOL", 1.0); // 1.0 = unity gain (SDK ~2226)
|
|
SetMediaTrackInfo_Value(tr, "I_PANMODE", 5.0); // 5 = stereo pan (SDK ~2231)
|
|
SetMediaTrackInfo_Value(tr, "D_PAN", 0.0); // 0.0 = center (SDK ~2227)
|
|
SetMediaTrackInfo_Value(tr, "D_WIDTH", 1.0); // 1.0 = full width (SDK ~2228)
|
|
SetMediaTrackInfo_Value(tr, "D_PANLAW", 1.0); // 1.0 = +0dB, no law (SDK ~2232)
|
|
}
|
|
};
|
|
|
|
// Runs one capture-action-table row: resolve its scope source + range, snapshot &
|
|
// clear the out-of-scope FX AND neutralize their fader gain + pan chain (RAII),
|
|
// render via the offline backend, add the Sample to the bank, persist + mark dirty.
|
|
// The load-bearing principle holds structurally — this path writes a file + a bank
|
|
// index entry ONLY; it never calls InsertMedia or touches the arrange/timeline.
|
|
// Non-destructive: FX-enable + fader gain + pan/width/law/mode are fully restored
|
|
// on every path by FxBypassGuard, and the backend restores every RENDER_* setting.
|
|
static void RunCapture(const reasampler::CaptureActionDef& def)
|
|
{
|
|
ResolvedSource src;
|
|
std::string why;
|
|
if (!ResolveScopeSource(def.scope, src, why))
|
|
{
|
|
ShowConsoleMsg(("ReaSampler capture: " + why + ".\n").c_str());
|
|
return;
|
|
}
|
|
|
|
reasampler::CaptureRequest req;
|
|
req.sourceMode = reasampler::sourceModeForScope(def.scope);
|
|
req.startSeconds = src.startSeconds; // exact bounds — no rounding
|
|
req.endSeconds = src.endSeconds;
|
|
req.wetDry = 1.0; // wet post the FX left enabled by the scope
|
|
req.renderTail = false; // exact bounds, no tail (default)
|
|
req.tailMs = 0.0;
|
|
req.sampleRate = 0; // follow project rate
|
|
req.channelCount = 2;
|
|
req.bitDepth = reasampler::WavBitDepth::Float32; // deterministic, no dither
|
|
req.baseName = def.baseName;
|
|
req.trackGuids = src.trackGuids; // recorded on the Sample (provenance)
|
|
|
|
// Bypass the out-of-scope FX and neutralize their fader gain to unity for the
|
|
// duration of the render (so parent/master fader level is not baked into the
|
|
// file). Restored on EVERY exit path below (RAII), including backend failures.
|
|
// proj = active project.
|
|
ReaProject* proj = EnumProjects(-1, nullptr, 0);
|
|
FxBypassGuard fxGuard(def.scope, src.sourceTracks, proj);
|
|
|
|
reasampler::OfflineRenderBackend backend;
|
|
reasampler::CaptureResult res = backend.capture(req);
|
|
|
|
if (res.status != reasampler::CaptureStatus::Ok)
|
|
{
|
|
ShowConsoleMsg(("ReaSampler capture failed: " + res.message + "\n").c_str());
|
|
return;
|
|
}
|
|
|
|
reasampler::AddResult added = g_session.bank().add(res.sample);
|
|
// Persist the updated bank into the active project's ext state so the capture
|
|
// survives Save / close+reopen (M4) and travels with the .rpp. saveToActiveProject
|
|
// also calls MarkProjectDirty. Non-destructive: writes only our own ext-state key.
|
|
g_session.saveToActiveProject();
|
|
|
|
std::string log = "ReaSampler: " + res.message + "\n";
|
|
log += " bank size now " + std::to_string(g_session.bank().size()) +
|
|
(added == reasampler::AddResult::Added ? " (added)\n"
|
|
: added == reasampler::AddResult::Collapsed ? " (collapsed on hash)\n"
|
|
: " (rejected)\n");
|
|
ShowConsoleMsg(log.c_str());
|
|
}
|
|
|
|
// Runs the M6 insert: place the bank panel's selected sample(s) at the edit cursor
|
|
// via InsertMedia, undo-wrapped. `conform` selects the explicit opt-in tempo-match
|
|
// variant (never silent — it fires only from the distinct "conform" action). This
|
|
// is the INTENDED placement path: it adds items to the arrange on purpose
|
|
// (CONTEXT.md §load-bearing principle) and runs only from a user-invoked action.
|
|
static void RunInsertSelected(bool conform)
|
|
{
|
|
reasampler::InsertRequest req;
|
|
// target defaults to CurrentTrack (InsertOptions::target) — inserts onto the
|
|
// user's currently-selected track(s) at the edit cursor.
|
|
req.options.conform =
|
|
conform ? reasampler::TempoConform::Ratio1x : reasampler::TempoConform::None;
|
|
// preservePitch stays true: a tempo conform matches tempo without varispeeding
|
|
// pitch. (A pitch-shifting variant is a later opt-in if wanted — YAGNI now.)
|
|
|
|
reasampler::InsertResult res = reasampler::runInsert(&g_session, req);
|
|
|
|
std::string msg;
|
|
switch (res.status)
|
|
{
|
|
case reasampler::InsertStatus::Ok:
|
|
msg = "ReaSampler: inserted onto " + std::to_string(res.inserted) +
|
|
(res.inserted == 1 ? " track" : " tracks") +
|
|
(conform ? " (conformed to tempo)" : " (native length)") + "\n";
|
|
break;
|
|
case reasampler::InsertStatus::NoSelection:
|
|
// "select a track first" is printed by runInsert when no track is
|
|
// selected; this branch covers the no-panel-selection case.
|
|
msg = "ReaSampler insert: nothing selected in the bank panel.\n";
|
|
break;
|
|
case reasampler::InsertStatus::NoProject:
|
|
msg = "ReaSampler insert: no saved project, so the bank has no location.\n";
|
|
break;
|
|
case reasampler::InsertStatus::NothingResolved:
|
|
msg = "ReaSampler insert: selected sample(s) could not be resolved to a file.\n";
|
|
break;
|
|
}
|
|
ShowConsoleMsg(msg.c_str());
|
|
}
|
|
|
|
// REAPER calls this for EVERY action fired anywhere; claim only our own id,
|
|
// return false otherwise so REAPER keeps looking.
|
|
static bool OnHookCommand(int command, int /*flag*/)
|
|
{
|
|
if (command == 0) return false;
|
|
// Three-scope capture family: command ids parallel captureActionTable() 1:1 by index.
|
|
// Claim the fired id if it is one of ours and route to its table row.
|
|
for (std::size_t i = 0; i < g_captureCmdIds.size(); ++i)
|
|
if (command == g_captureCmdIds[i])
|
|
{
|
|
RunCapture(reasampler::captureActionTable()[i]);
|
|
return true;
|
|
}
|
|
if (command == g_cmdToggleBankPanel) { reasampler::bankPanelToggle(); return true; }
|
|
if (command == g_cmdInsertSelected) { RunInsertSelected(false); return true; }
|
|
if (command == g_cmdInsertSelectedConform) { RunInsertSelected(true); return true; }
|
|
// Design View action family (D4). Claims only its own ids; returns false for the
|
|
// rest so this hook keeps looking (per the contract).
|
|
if (reasampler::designViewHandleCommand(command)) return true;
|
|
return false;
|
|
}
|
|
|
|
// REAPER polls this to render each of OUR actions' checked state in menus/toolbars.
|
|
// Return 1 (on) / 0 (off) for ids we own, -1 for everything else (per the contract).
|
|
static int OnToggleAction(int command)
|
|
{
|
|
if (command == g_cmdToggleBankPanel)
|
|
return reasampler::bankPanelIsOpen() ? 1 : 0;
|
|
return -1; // not ours / non-toggling
|
|
}
|
|
|
|
// gaccel storage must outlive registration — REAPER holds the pointer.
|
|
// (The capture family's accels live in g_captureAccels, sized to the table.)
|
|
static gaccel_register_t g_accelToggleBankPanel{};
|
|
static gaccel_register_t g_accelInsertSelected{};
|
|
static gaccel_register_t g_accelInsertSelectedConform{};
|
|
|
|
extern "C" REAPER_PLUGIN_DLL_EXPORT int REAPER_PLUGIN_ENTRYPOINT(
|
|
REAPER_PLUGIN_HINSTANCE hInstance, reaper_plugin_info_t* rec)
|
|
{
|
|
if (!rec)
|
|
{
|
|
// rec == nullptr => REAPER is UNLOADING us. Mirror-unregister every
|
|
// callback with the same strings prefixed '-' (per the contract).
|
|
if (g_rec)
|
|
{
|
|
g_rec->Register("-timer", (void*)&OnTimer);
|
|
g_rec->Register("-toggleaction", (void*)&OnToggleAction);
|
|
g_rec->Register("-hookcommand", (void*)&OnHookCommand);
|
|
// Tear down the Design View action family (D4) — mirror-unregisters each
|
|
// gaccel + command_id with '-'-prefixed strings. After the hook is gone.
|
|
reasampler::designViewUnregisterActions(g_rec);
|
|
g_rec->Register("-gaccel", (void*)&g_accelInsertSelectedConform);
|
|
g_rec->Register("-command_id",
|
|
(void*)(REASAMPLER_ACTION_PREFIX "INSERT_SELECTED_CONFORM"));
|
|
g_rec->Register("-gaccel", (void*)&g_accelInsertSelected);
|
|
g_rec->Register("-command_id",
|
|
(void*)(REASAMPLER_ACTION_PREFIX "INSERT_SELECTED"));
|
|
g_rec->Register("-gaccel", (void*)&g_accelToggleBankPanel);
|
|
g_rec->Register("-command_id",
|
|
(void*)(REASAMPLER_ACTION_PREFIX "TOGGLE_BANK_PANEL"));
|
|
// Mirror-unregister the capture family: gaccel + command_id per row,
|
|
// with '-'-prefixed strings (per the contract). The FOREVER-STABLE id
|
|
// strings come from the same table used to register them.
|
|
{
|
|
const auto& table = reasampler::captureActionTable();
|
|
for (std::size_t i = 0; i < table.size(); ++i)
|
|
{
|
|
if (i < g_captureAccels.size())
|
|
g_rec->Register("-gaccel", (void*)&g_captureAccels[i]);
|
|
g_rec->Register("-command_id", (void*)table[i].commandString);
|
|
}
|
|
}
|
|
// Retire the removed M7 command ids (command_id only — we never held a
|
|
// gaccel for them this session). Clears stale user keybindings on unload.
|
|
for (const char* id : kRetiredCaptureCmdStrings)
|
|
g_rec->Register("-command_id", (void*)id);
|
|
}
|
|
// Destroy the docked window and release cached thumbnails before we drop
|
|
// the API pointers (DockWindowRemove/DestroyWindow need them live).
|
|
reasampler::bankPanelShutdown();
|
|
g_rec = nullptr;
|
|
return 0;
|
|
}
|
|
|
|
// ABI guard: the struct layout we compiled against must match this REAPER.
|
|
if (rec->caller_version != REAPER_PLUGIN_VERSION)
|
|
return 0;
|
|
|
|
// Resolve every REAPER API function pointer. Returns the number that FAILED
|
|
// to load; 0 == success. Non-zero usually means REAPER is older than our SDK.
|
|
if (REAPERAPI_LoadAPI(rec->GetFunc) != 0)
|
|
return 0;
|
|
|
|
g_hInst = hInstance;
|
|
g_rec = rec;
|
|
|
|
// Register the three-scope capture action family (command_id -> gaccel per table row).
|
|
// The single hookcommand below routes every fired id back to its row by index.
|
|
// g_captureAccels must be sized BEFORE the loop and never reallocated after —
|
|
// REAPER holds a pointer to each element until we mirror-unregister it.
|
|
{
|
|
const auto& table = reasampler::captureActionTable();
|
|
g_captureCmdIds.assign(table.size(), 0);
|
|
g_captureAccels.assign(table.size(), gaccel_register_t{});
|
|
for (std::size_t i = 0; i < table.size(); ++i)
|
|
{
|
|
const int cmd =
|
|
rec->Register("command_id", (void*)table[i].commandString);
|
|
g_captureCmdIds[i] = cmd;
|
|
if (cmd)
|
|
{
|
|
g_captureAccels[i].accel.cmd = cmd;
|
|
g_captureAccels[i].desc = table[i].description;
|
|
rec->Register("gaccel", (void*)&g_captureAccels[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Point the bank panel at the live session BEFORE registering its action, so
|
|
// a toggle firing immediately has a session to read (M5). Does not open the
|
|
// window — only stores the session pointer.
|
|
reasampler::bankPanelInit(&g_session);
|
|
|
|
// Register the M5 "toggle bank panel" action (command_id -> gaccel ->
|
|
// hookcommand + toggleaction for the checked state).
|
|
g_cmdToggleBankPanel = rec->Register(
|
|
"command_id",
|
|
(void*)(REASAMPLER_ACTION_PREFIX "TOGGLE_BANK_PANEL"));
|
|
if (g_cmdToggleBankPanel)
|
|
{
|
|
g_accelToggleBankPanel.accel.cmd = g_cmdToggleBankPanel;
|
|
g_accelToggleBankPanel.desc = "ReaSampler: toggle bank panel";
|
|
rec->Register("gaccel", (void*)&g_accelToggleBankPanel);
|
|
rec->Register("toggleaction", (void*)&OnToggleAction);
|
|
}
|
|
|
|
// Register the M6 insert actions (command_id -> gaccel -> hookcommand). Two
|
|
// variants: native-length (default, no stretch) and the EXPLICIT conform-to-
|
|
// tempo opt-in. Both read the bank panel selection and place at the edit cursor.
|
|
g_cmdInsertSelected = rec->Register(
|
|
"command_id",
|
|
(void*)(REASAMPLER_ACTION_PREFIX "INSERT_SELECTED"));
|
|
if (g_cmdInsertSelected)
|
|
{
|
|
g_accelInsertSelected.accel.cmd = g_cmdInsertSelected;
|
|
g_accelInsertSelected.desc =
|
|
"ReaSampler: insert selected sample at edit cursor";
|
|
rec->Register("gaccel", (void*)&g_accelInsertSelected);
|
|
}
|
|
|
|
g_cmdInsertSelectedConform = rec->Register(
|
|
"command_id",
|
|
(void*)(REASAMPLER_ACTION_PREFIX "INSERT_SELECTED_CONFORM"));
|
|
if (g_cmdInsertSelectedConform)
|
|
{
|
|
g_accelInsertSelectedConform.accel.cmd = g_cmdInsertSelectedConform;
|
|
g_accelInsertSelectedConform.desc =
|
|
"ReaSampler: insert selected sample at edit cursor (conform to tempo)";
|
|
rec->Register("gaccel", (void*)&g_accelInsertSelectedConform);
|
|
}
|
|
|
|
// Register the Design View action family (D4): toggle/activate mode, tag/untag/
|
|
// show-both selected tracks. Each mints its own command_id + gaccel; the single
|
|
// hookcommand below routes them via designViewHandleCommand. Registered before
|
|
// the hook so every id is minted first.
|
|
reasampler::designViewRegisterActions(rec, &g_session);
|
|
|
|
// One hookcommand routes every ReaSampler action (spike + toggle + Design View).
|
|
// Registered once, after all command ids are minted.
|
|
rec->Register("hookcommand", (void*)&OnHookCommand);
|
|
|
|
// Drive project-load / Save-As detection (M4 persist). The timer polls the
|
|
// active project each tick; on a project load it reloads the bank from ext
|
|
// state, on a Save-As it relocates the bank folder under the new .rpp.
|
|
rec->Register("timer", (void*)&OnTimer);
|
|
|
|
ShowConsoleMsg("ReaSampler loaded.\n");
|
|
|
|
return 1; // success — REAPER keeps us loaded
|
|
}
|