S4 Tier 0: the bank plays — VST3 marshals MIDI to the S3 core, reads the live bank + resolves WAV the M4 way, mono downmix, lock-free load handoff, LICE sample-pick

src/vst/sample_map.cpp

@@ -0,0 +1,129 @@
+// sample_map — pure implementation. See sample_map.h. NO VST3 / REAPER / SWELL /
+// vendor includes; standard library + the pure bank_book / wav_trim / sampler_core.
+
+#include "sample_map.h"
+
+#include <cstring>  // std::memcpy
+
+namespace reasampler {
+
+namespace {
+
+// Translate a bank_model Sample's S2 intrinsics into the core's SampleLoop. The bank
+// stores loop points as an optional LoopPoints (both-or-neither); the core wants a
+// SampleLoop with an explicit hasLoop. Absent -> no loop.
+SampleLoop loopFromSample(const Sample& s) {
+    SampleLoop out;
+    if (s.loop) {
+        out.hasLoop = true;
+        out.start = s.loop->start;
+        out.end = s.loop->end;
+    }
+    return out;
+}
+
+// A distilled SelectedSample from a bank_model Sample. rootNote defaults to middle C
+// (60) when the bank left the intrinsic empty — Tier 0 still plays, just centered on
+// C rather than a captured pitch (surfaced: an un-rooted sample plays unity at C4).
+SelectedSample distill(const Sample& s) {
+    SelectedSample out;
+    out.relativePath = s.relativePath;
+    out.rootNote = s.rootNote ? *s.rootNote : 60;
+    out.loop = loopFromSample(s);
+    return out;
+}
+
+}  // namespace
+
+std::optional<SelectedSample> selectSample(const std::string& banksJson,
+                                           const std::string& sampleId) {
+    if (banksJson.empty()) return std::nullopt;
+    std::optional<BankBook> book = BankBook::deserialize(banksJson);
+    if (!book) return std::nullopt;  // malformed -> nothing to play (never throw)
+
+    // Search every bank (pool first, then named — banks() is ordinal order) for the
+    // stored id. A sample lives in exactly one bank, so first hit wins.
+    if (!sampleId.empty()) {
+        for (const Bank& b : book->banks()) {
+            if (const Sample* s = b.index.query(sampleId)) {
+                return distill(*s);
+            }
+        }
+    }
+
+    // No stored id, or the id no longer resolves (the sample was deleted/moved out):
+    // fall back to the FIRST sample in ordinal order so a fresh instance plays.
+    for (const Bank& b : book->banks()) {
+        if (!b.index.all().empty()) {
+            return distill(b.index.all().front());
+        }
+    }
+    return std::nullopt;  // bank has zero samples anywhere
+}
+
+std::vector<SampleChoice> listSamples(const std::string& banksJson) {
+    std::vector<SampleChoice> out;
+    if (banksJson.empty()) return out;
+    std::optional<BankBook> book = BankBook::deserialize(banksJson);
+    if (!book) return out;
+    for (const Bank& b : book->banks()) {
+        for (const Sample& s : b.index.all()) {
+            out.push_back(SampleChoice{s.id, s.displayName});
+        }
+    }
+    return out;
+}
+
+std::vector<AudioSample> downmixToMono(const std::vector<AudioSample>& interleaved,
+                                       int channelCount) {
+    std::vector<AudioSample> out;
+    if (channelCount <= 0 || interleaved.empty()) return out;
+    const std::size_t stride = static_cast<std::size_t>(channelCount);
+    const std::size_t frames = interleaved.size() / stride;
+    out.resize(frames);
+    const double inv = 1.0 / static_cast<double>(channelCount);
+    for (std::size_t f = 0; f < frames; ++f) {
+        double acc = 0.0;
+        const std::size_t base = f * stride;
+        for (std::size_t c = 0; c < stride; ++c) {
+            acc += static_cast<double>(interleaved[base + c]);
+        }
+        out[f] = static_cast<AudioSample>(acc * inv);
+    }
+    return out;
+}
+
+Keymap buildTier0Keymap(std::vector<AudioSample> monoFrames, int sampleRate,
+                        int rootNote, const SampleLoop& loop) {
+    SampleData data;
+    data.frames = std::move(monoFrames);
+    data.sampleRate = sampleRate > 0 ? sampleRate : 44100;
+    data.rootNote = rootNote;
+    data.loop = loop;
+    return Keymap::singleSampleChromatic(std::move(data));
+}
+
+std::vector<std::uint8_t> serializeSelection(const std::string& sampleId) {
+    std::vector<std::uint8_t> out;
+    out.resize(4 + sampleId.size());
+    const std::uint32_t v = kSelectionStateVersion;
+    out[0] = static_cast<std::uint8_t>(v & 0xFF);
+    out[1] = static_cast<std::uint8_t>((v >> 8) & 0xFF);
+    out[2] = static_cast<std::uint8_t>((v >> 16) & 0xFF);
+    out[3] = static_cast<std::uint8_t>((v >> 24) & 0xFF);
+    std::memcpy(out.data() + 4, sampleId.data(), sampleId.size());
+    return out;
+}
+
+std::string deserializeSelection(const std::vector<std::uint8_t>& bytes) {
+    if (bytes.size() < 4) return {};  // no version tag -> no selection
+    const std::uint32_t v = static_cast<std::uint32_t>(bytes[0]) |
+                            (static_cast<std::uint32_t>(bytes[1]) << 8) |
+                            (static_cast<std::uint32_t>(bytes[2]) << 16) |
+                            (static_cast<std::uint32_t>(bytes[3]) << 24);
+    if (v != kSelectionStateVersion) return {};  // unknown version -> ignore
+    return std::string(reinterpret_cast<const char*>(bytes.data() + 4),
+                       bytes.size() - 4);
+}
+
+}  // namespace reasampler