daniel/reasampler
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

S5 Tier-1: zoned keymap editor + performance-map playback/persistence

Browse Source 
Zone editor in the IPlugView LICE surface, zoned resolution built off-thread into the
LoadedInstrument keymap with Tier-0 fallback, performance map in VST3 component state
with v1 back-compat. Pure resolve/build/serialize + geometry with CTest coverage.
This commit is contained in:
Daniel Harvey
2026-07-26 17:28:15 -04:00
parent 6ae843345c
commit 2356958930
10 changed files with 1063 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/vst/reasampler_processor.cpp
+99 -33
View File
@@ -5,6 +5,8 @@
#include <algorithm>
#include <cstdint>
#include <fstream>
#include <optional>
#include <utility>
#include <vector>
#include "pluginterfaces/base/ibstream.h"
@@ -15,7 +17,7 @@
#include "capture_paths.h" // resolveBankFile (shared M4 path resolution)
#include "ext_keys.h" // kProjExtBanksKey (shared wire contract)
#include "reasampler_editor.h"
#include "sample_map.h" // selectSample, downmixToMono, buildTier0Keymap, state (de)ser
#include "sample_map.h" // selectSample, resolvePerformance, buildZonedKeymap, state (de)ser
#include "wav_trim.h" // parseWavLayout, extractFloatFrames (shared WAV parse)
using namespace Steinberg;
@@ -59,6 +61,28 @@ std::vector<std::uint8_t> readFileBytes(const std::string& path) {
return bytes;
}
// Resolve a project-relative WAV path (the M4 way persist does), read + decode it (file
// I/O — off-thread only), and downmix to the core's mono contract. Returns nullopt when
// the path fails to resolve, the file is unreadable, the WAV is malformed, or the decode
// yields no frames — the caller drops the zone (Tier 1) or plays silence (Tier 0). Shared
// by the zoned build and the Tier-0 fallback so both decode identically.
std::optional<DecodedZonePcm> decodeRelative(const std::string& projectDir,
const std::string& relativePath) {
const std::string abs = resolveBankFile(projectDir, relativePath);
if (abs.empty()) return std::nullopt;
const std::vector<std::uint8_t> bytes = readFileBytes(abs);
const WavLayout layout = parseWavLayout(bytes);
if (!layout.valid) return std::nullopt;
std::vector<AudioSample> interleaved =
extractFloatFrames(bytes, layout, 0, layout.frameCount());
std::vector<AudioSample> mono = downmixToMono(interleaved, layout.channelCount);
if (mono.empty()) return std::nullopt;
DecodedZonePcm out;
out.monoFrames = std::move(mono);
out.sampleRate = static_cast<int>(layout.sampleRate);
return out;
}
} // namespace
FUnknown* ReaSamplerProcessor::createInstance(void* /*context*/) {
@@ -115,23 +139,33 @@ tresult PLUGIN_API ReaSamplerProcessor::setupProcessing(ProcessSetup& setup) {
tresult PLUGIN_API ReaSamplerProcessor::setState(IBStream* state) {
if (!state) return kResultFalse;
// Read the whole component-state blob (the selected sample id, versioned). The blob
// is small; read in one shot into a growable buffer.
// Read the whole component-state blob (the performance map, versioned). The blob is
// small; read in one shot into a growable buffer.
std::vector<std::uint8_t> bytes;
std::uint8_t chunk[256];
int32 got = 0;
while (state->read(chunk, sizeof(chunk), &got) == kResultOk && got > 0) {
bytes.insert(bytes.end(), chunk, chunk + got);
}
setSelectedSampleId(deserializeSelection(bytes));
// Rebuild from the restored selection (off-thread — setState is a load-time call).
// Component state IS the performance map (Tier 1, D-B). deserializePerformance lifts a
// v1 (S4 single-selection) blob to a one-zone map, so already-saved Tier-0 instances
// restore cleanly. When the restored map is empty, the instrument falls back to the
// Tier-0 first-sample in reloadFromBank; if the v1 lift produced a single zone we also
// seed the fallback selection from it so the editor reflects the restored pick.
const PerformanceMap map = deserializePerformance(bytes);
setPerformanceMap(map);
if (map.zones.size() == 1) setSelectedSampleId(map.zones.front().sampleId);
// Rebuild from the restored state (off-thread — setState is a load-time call).
reloadFromBank();
return kResultOk;
}
tresult PLUGIN_API ReaSamplerProcessor::getState(IBStream* state) {
if (!state) return kResultFalse;
const std::vector<std::uint8_t> bytes = serializeSelection(selectedSampleId());
// Persist the performance map (the instrument's own Tier-1 state, D-B — NEVER written
// to the "reasampler" bank ext-state). An empty map serializes to just the version +
// zero-count header (restores as empty -> Tier-0 fallback).
const std::vector<std::uint8_t> bytes = serializePerformance(performanceMap());
if (!bytes.empty()) {
const tresult wr = state->write(const_cast<std::uint8_t*>(bytes.data()),
static_cast<int32>(bytes.size()), nullptr);
@@ -150,6 +184,16 @@ void ReaSamplerProcessor::setSelectedSampleId(const std::string& id) {
selectedSampleId_ = id;
}
PerformanceMap ReaSamplerProcessor::performanceMap() {
std::lock_guard<std::mutex> lock(performanceMutex_);
return performanceMap_;
}
void ReaSamplerProcessor::setPerformanceMap(const PerformanceMap& map) {
std::lock_guard<std::mutex> lock(performanceMutex_);
performanceMap_ = map;
}
std::string ReaSamplerProcessor::reloadFromBank() {
// OFF THE AUDIO THREAD. Serialize concurrent reloads (editor click + setState) so
// the retired-slot free is single-writer. This mutex is NEVER taken on the audio
@@ -170,36 +214,58 @@ std::string ReaSamplerProcessor::reloadFromBank() {
std::unique_ptr<LoadedInstrument> built;
if (banksJson) {
// 2. Pick the sample (shared bank_book JSON parse — NOT a second parser).
std::optional<SelectedSample> sel =
selectSample(*banksJson, selectedSampleId());
if (sel) {
// 3. Resolve the project-relative WAV path the M4 way persist does, read +
// decode it (file I/O off-thread), downmix to the core's mono contract.
const std::string abs = resolveBankFile(projectDir, sel->relativePath);
if (!abs.empty()) {
const std::vector<std::uint8_t> bytes = readFileBytes(abs);
const WavLayout layout = parseWavLayout(bytes);
if (layout.valid) {
const std::size_t frames = layout.frameCount();
std::vector<AudioSample> interleaved =
extractFloatFrames(bytes, layout, 0, frames);
std::vector<AudioSample> mono =
downmixToMono(interleaved, layout.channelCount);
if (!mono.empty()) {
Keymap km = buildTier0Keymap(
std::move(mono),
static_cast<int>(layout.sampleRate), sel->rootNote,
sel->loop);
built = std::make_unique<LoadedInstrument>(
std::move(km), kMaxVoices, tier0Adsr(sampleRate_), gen);
// Record which id actually resolved so a first-sample fallback
// (empty stored id) becomes the concrete selection.
resolvedId = selectedSampleId();
}
// 2. Tier 1 first: if the instrument's performance map is non-empty, resolve its
// zones against the live bank (STALE ids drop cleanly), decode each zone's WAV
// off-thread, and build the ZONED keymap. Each surviving zone plays its bank
// sample repitched from its effective root note (override > bank intrinsic > C4).
// A zone whose WAV fails to decode is dropped (not the whole map).
const PerformanceMap map = performanceMap();
Keymap km;
bool haveKeymap = false;
if (!map.empty()) {
const ResolvedPerformance resolved = resolvePerformance(*banksJson, map);
if (!resolved.zones.empty()) {
std::vector<DecodedZonePcm> decoded;
std::vector<ResolvedZone> kept;
decoded.reserve(resolved.zones.size());
kept.reserve(resolved.zones.size());
for (const ResolvedZone& rz : resolved.zones) {
std::optional<DecodedZonePcm> pcm =
decodeRelative(projectDir, rz.relativePath);
if (!pcm) continue; // unreadable WAV -> drop this zone
kept.push_back(rz);
decoded.push_back(std::move(*pcm));
}
km = buildZonedKeymap(kept, decoded);
haveKeymap = !km.zones.empty();
}
}
// 3. Tier-0 fallback: an empty (or fully-unresolvable) performance map plays the
// selected fallback sample chromatically across the whole keyboard — preserving
// the S4 "the bank plays" behavior for an un-authored instrument.
if (!haveKeymap) {
std::optional<SelectedSample> sel =
selectSample(*banksJson, selectedSampleId());
if (sel) {
std::optional<DecodedZonePcm> pcm =
decodeRelative(projectDir, sel->relativePath);
if (pcm) {
km = buildTier0Keymap(std::move(pcm->monoFrames), pcm->sampleRate,
sel->rootNote, sel->loop);
haveKeymap = true;
// Record which id actually resolved so a first-sample fallback
// (empty stored id) becomes the concrete selection.
resolvedId = selectedSampleId();
}
}
}
if (haveKeymap) {
built = std::make_unique<LoadedInstrument>(
std::move(km), kMaxVoices, tier0Adsr(sampleRate_), gen);
}
}
// 4. Publish. Atomically install the new instrument; the DISPLACED one goes to the