diff --git a/src/vst/reasampler_editor.cpp b/src/vst/reasampler_editor.cpp index 231015b..32d7664 100644 --- a/src/vst/reasampler_editor.cpp +++ b/src/vst/reasampler_editor.cpp @@ -6,6 +6,7 @@ #include #include +#include // snprintf (Phase S voice-count readout) #include #include #include @@ -63,6 +64,7 @@ constexpr UINT kSyncTimerIntervalMs = 500; constexpr int kTitleHeight = 26; constexpr int kHeroWaveformHeight = 150; // the enlarged Sample-face hero (was a 72px strip) constexpr int kClusterHeight = 52; // root strip + preview + channel toggle +constexpr int kVoiceDeckHeight = 26; // Phase S provisional voice deck band constexpr int kStripBandHeight = 40; // the keyboard-strip band height (root strip + zone strip) constexpr int kNavButtonWidth = 62; // Browse / Zone / Back title-band buttons @@ -161,6 +163,9 @@ void ReaSamplerEditor::refreshFromBank() { selectedId_ = processor_->selectedSampleId(); map_ = processor_->performanceMap(); channelMode_ = processor_->channelMode(); + voiceCount_ = processor_->voiceCount(); // Phase S voice-deck snapshot + voiceMode_ = processor_->voiceMode(); + monoTrigger_ = processor_->monoTrigger(); if (selectedZone_ >= static_cast(map_.zones.size())) selectedZone_ = -1; // Drop a filter that names a bank no longer present. if (!activeFilterBankId_.empty()) { @@ -728,6 +733,7 @@ struct SampleBands { Rect hero; // the hero waveform + S-VIEW-3 envelope overlay Rect velCurve; // the S-VIEW-10 velocity-curve editor box (empty when suppressed) Rect cluster; // root strip + preview-trigger + velocity knob + channel toggle + Rect voice; // Phase S voice deck (PROVISIONAL): voice count + Poly/Mono + Retrig/Legato Rect control; // the param control strip (Mode / Pitch / AHDSR|Trigger / AD pitch / keyTrack) }; SampleBands computeSampleBands(int w, int h) { @@ -759,6 +765,12 @@ SampleBands computeSampleBands(int w, int h) { const int clusterH = (std::min)(kClusterHeight, (std::max)(0, h - y)); b.cluster = Rect{0, y, w, y + clusterH}; y += clusterH; + // Phase S voice deck: a narrow PROVISIONAL band between the cluster and the param strip + // (voice count stepper + Poly/Mono + Retrig/Legato). The Wave B recompose owns the final + // placement; carving a distinct band keeps the wiring self-contained and easy to relocate. + const int voiceH = (std::min)(kVoiceDeckHeight, (std::max)(0, h - y)); + b.voice = Rect{0, y, w, y + voiceH}; + y += voiceH; b.control = Rect{kPad, y, w - kPad, h}; return b; } @@ -868,6 +880,43 @@ ChannelToggleRects channelToggleRects(const Rect& area) { return {mono, stereo}; } +// Phase S voice deck (PROVISIONAL — the Wave B recompose owns the final placement): one row of +// per-instance voice-system controls inside the `voice` band. Left to right: a "Voices" label, +// a [-] step-down button, the count readout, a [+] step-up button, then a two-segment +// [Poly|Mono] toggle, then a two-segment [Retrig|Legato] toggle (live only in Mono). Both draw +// + hit-test derive from this ONE formula so they never drift (the channelToggleRects pattern). +constexpr int kVoiceSegW = 52; +constexpr int kVoiceSegH = 18; +constexpr int kVoiceStepW = 18; // the [-] / [+] stepper buttons +constexpr int kVoiceCountW = 30; // the numeric readout between them +constexpr int kVoiceLabelW = 44; // the "Voices" caption +constexpr int kVoiceGap = 16; // gap between the stepper / toggle groups +struct VoiceDeckRects { + Rect label; // "Voices" caption (decorative) + Rect minus; // step the count down + Rect count; // the numeric readout (decorative) + Rect plus; // step the count up + Rect poly; // VoiceMode::Poly segment + Rect mono; // VoiceMode::Mono segment + Rect retrig; // MonoTrigger::Retrigger segment + Rect legato; // MonoTrigger::Legato segment +}; +VoiceDeckRects voiceDeckRects(const Rect& band) { + const int top = band.top + (band.height() - kVoiceSegH) / 2; + const int bot = top + kVoiceSegH; + int x = band.left + kPad; + VoiceDeckRects r; + r.label = Rect{x, top, x + kVoiceLabelW, bot}; x = r.label.right; + r.minus = Rect{x, top, x + kVoiceStepW, bot}; x = r.minus.right + 2; + r.count = Rect{x, top, x + kVoiceCountW, bot}; x = r.count.right + 2; + r.plus = Rect{x, top, x + kVoiceStepW, bot}; x = r.plus.right + kVoiceGap; + r.poly = Rect{x, top, x + kVoiceSegW, bot}; x = r.poly.right; + r.mono = Rect{x, top, x + kVoiceSegW, bot}; x = r.mono.right + kVoiceGap; + r.retrig = Rect{x, top, x + kVoiceSegW, bot}; x = r.retrig.right; + r.legato = Rect{x, top, x + kVoiceSegW, bot}; + return r; +} + // Draw the pastel spectral keyboard-strip background (Phase L, L3) — the signature surface. // Fills each MIDI key column with its spectral hue (spectralColor over note/127), then draws // faint per-octave hairline ticks for orientation. Shared by the setup face + the Zones strip @@ -1115,6 +1164,55 @@ void ReaSamplerEditor::paintSample(LICE_IBitmap* bmp, int w, int h) { kitTextCentered(bmp, chan.stereo, "Stereo", Font::Label, isStereo ? Role::BgBase : Role::TextPrimary); } + // --- Phase S voice deck (PROVISIONAL placement; Wave B owns the final composition) ----- + if (bands.voice.height() > 0) { + fillSurface(bmp, toKitBox(bands.voice), Role::BgPanel, InteractionState::Rest); + const VoiceDeckRects vd = voiceDeckRects(bands.voice); + kitTextCentered(bmp, vd.label, "Voices", Font::Micro, Role::TextDim); + // Count stepper: [-] N [+]. The steppers grey out at the range edges (the shared + // pure-core kMin/kMaxVoiceCount — one spelling with the engine + the state bytes). + const bool canDown = voiceCount_ > kMinVoiceCount; + const bool canUp = voiceCount_ < kMaxVoiceCount; + fillSurface(bmp, toKitBox(vd.minus), Role::BgCell, + canDown ? InteractionState::Rest : InteractionState::Disabled); + fillSurface(bmp, toKitBox(vd.plus), Role::BgCell, + canUp ? InteractionState::Rest : InteractionState::Disabled); + kitTextCentered(bmp, vd.minus, "-", Font::Label, + canDown ? Role::TextPrimary : Role::TextDim); + kitTextCentered(bmp, vd.plus, "+", Font::Label, + canUp ? Role::TextPrimary : Role::TextDim); + char countBuf[8]; + snprintf(countBuf, sizeof(countBuf), "%d", voiceCount_); + kitTextCentered(bmp, vd.count, countBuf, Font::ValueMono, Role::TextPrimary); + // Poly | Mono voice-mode toggle (the channel-toggle grammar: active segment lit). + const bool isMono = (voiceMode_ == VoiceMode::Mono); + fillSurface(bmp, toKitBox(vd.poly), Role::BgCell, + !isMono ? InteractionState::Active : InteractionState::Rest); + fillSurface(bmp, toKitBox(vd.mono), Role::BgCell, + isMono ? InteractionState::Active : InteractionState::Rest); + kitTextCentered(bmp, vd.poly, "Poly", Font::Label, + !isMono ? Role::BgBase : Role::TextPrimary); + kitTextCentered(bmp, vd.mono, "Mono", Font::Label, + isMono ? Role::BgBase : Role::TextPrimary); + // Retrig | Legato mono-takeover toggle — meaningful only in Mono; drawn Disabled + // (inert) in Poly so the dependency reads at a glance. + const bool isLegato = (monoTrigger_ == MonoTrigger::Legato); + const InteractionState retrigState = + !isMono ? InteractionState::Disabled + : (!isLegato ? InteractionState::Active : InteractionState::Rest); + const InteractionState legatoState = + !isMono ? InteractionState::Disabled + : (isLegato ? InteractionState::Active : InteractionState::Rest); + fillSurface(bmp, toKitBox(vd.retrig), Role::BgCell, retrigState); + fillSurface(bmp, toKitBox(vd.legato), Role::BgCell, legatoState); + kitTextCentered(bmp, vd.retrig, "Retrig", Font::Label, + !isMono ? Role::TextDim + : (!isLegato ? Role::BgBase : Role::TextPrimary)); + kitTextCentered(bmp, vd.legato, "Legato", Font::Label, + !isMono ? Role::TextDim + : (isLegato ? Role::BgBase : Role::TextPrimary)); + } + // --- The "Modes-and-down" control strip (S-VIEW-2: moved from Zone) -------------------- paintControls(bmp, bands.control, zone); } @@ -1873,6 +1971,39 @@ void ReaSamplerEditor::onMouseDown(int x, int y) { return; } + // Phase S voice deck (PROVISIONAL). Every edit writes through the processor setter, + // which rebuilds the engine off-thread via the drain-slot swap (ringing tails survive); + // the local snapshot updates in step so the deck repaints without waiting for a sync tick. + if (bands.voice.height() > 0 && contains(bands.voice, x, y)) { + const VoiceDeckRects vd = voiceDeckRects(bands.voice); + if (contains(vd.minus, x, y) && voiceCount_ > kMinVoiceCount) { + voiceCount_ -= 1; + processor_->setVoiceCount(voiceCount_); + invalidate(); + } else if (contains(vd.plus, x, y) && voiceCount_ < kMaxVoiceCount) { + voiceCount_ += 1; + processor_->setVoiceCount(voiceCount_); + invalidate(); + } else if (contains(vd.poly, x, y)) { + voiceMode_ = VoiceMode::Poly; + processor_->setVoiceMode(VoiceMode::Poly); + invalidate(); + } else if (contains(vd.mono, x, y)) { + voiceMode_ = VoiceMode::Mono; + processor_->setVoiceMode(VoiceMode::Mono); + invalidate(); + } else if (voiceMode_ == VoiceMode::Mono && contains(vd.retrig, x, y)) { + monoTrigger_ = MonoTrigger::Retrigger; // inert (Disabled) in Poly + processor_->setMonoTrigger(MonoTrigger::Retrigger); + invalidate(); + } else if (voiceMode_ == VoiceMode::Mono && contains(vd.legato, x, y)) { + monoTrigger_ = MonoTrigger::Legato; + processor_->setMonoTrigger(MonoTrigger::Legato); + invalidate(); + } + return; // the deck band swallows its clicks (no fall-through to the hero/markers) + } + // S-VIEW-10: the velocity-curve editor beside the hero. Every in-box click is an edit // (grab / Alt-delete / add-at-cursor), so materialize the one-zone site first (the // mirror of the control strip's ensureSampleZone path). diff --git a/src/vst/reasampler_editor.h b/src/vst/reasampler_editor.h index cf64810..73d57fb 100644 --- a/src/vst/reasampler_editor.h +++ b/src/vst/reasampler_editor.h @@ -347,6 +347,14 @@ private: PerformanceMap map_; // the opt-in zones (empty = no zones) ChannelMode channelMode_ = ChannelMode::Mono; // S7 mono/stereo toggle snapshot + // --- Phase S voice-deck snapshot (PROVISIONAL controls — the Wave B recompose owns the + // final deck). Mirrors of the processor's persisted voice-system params, refreshed with + // the rest of the live snapshot; every edit writes through the processor setters (which + // rebuild the engine off-thread via the drain-slot swap). + int voiceCount_ = kDefaultVoiceCount; + VoiceMode voiceMode_ = VoiceMode::Poly; + MonoTrigger monoTrigger_ = MonoTrigger::Retrigger; + // --- Transient UI state (not persisted; component state carries selection + zones) --- View view_ = View::kSample; // default face is the loaded-sample home (S-VIEW-1) std::string activeFilterBankId_; // "" = All; else a bank id from banks_ diff --git a/src/vst/reasampler_processor.cpp b/src/vst/reasampler_processor.cpp index d5801bf..c81832d 100644 --- a/src/vst/reasampler_processor.cpp +++ b/src/vst/reasampler_processor.cpp @@ -13,6 +13,7 @@ #include "pluginterfaces/vst/ivstaudioprocessor.h" #include "pluginterfaces/vst/ivsteditcontroller.h" // RestartFlags::kIoChanged (S7 re-negotiate) #include "pluginterfaces/vst/ivstevents.h" +#include "pluginterfaces/vst/ivstmidicontrollers.h" // kCtrlAllNotesOff / kCtrlAllSoundsOff (panic) #include "pluginterfaces/vst/vstspeaker.h" #include "public.sdk/source/vst/vstbus.h" // Vst::AudioBus::setArrangement (S7 output arr) @@ -33,17 +34,12 @@ namespace reasampler::vst { namespace { -// Tier-0 fixed instrument shape (Tier 2 makes these editable). A gentle amp envelope so -// notes neither click on nor cut off abruptly; sustain at unity (velocity does the -// dynamics), a short release for a natural tail. Times are in seconds, converted to -// frames against the live sample rate at build time. -constexpr std::size_t kMaxVoices = 16; - // S16 Preserve-mode voice cap: a Preserve voice runs a per-voice OLA pitch shifter and is -// materially heavier than a Varispeed voice. Below the Varispeed polyphony bound so a chord of -// Preserve notes stays within the RT budget; a Preserve note-on past the cap is dropped rather +// materially heavier than a Varispeed voice. A Preserve note-on past the cap is dropped rather // than glitching (Varispeed notes are unaffected). Set from the measured/estimated per-voice -// cost — see the handoff CPU note. 8 is a conservative half of kMaxVoices pending DAW profiling. +// cost — see the handoff CPU note. 8 is conservative pending DAW profiling. Phase S: the +// polyphony bound itself is now the USER-SET voiceCount (1..32, persisted) — this cap stays +// FIXED so raising the voice count never multiplies shifter CPU past the profiled budget. constexpr std::size_t kPreserveVoiceCap = 8; // Read a whole file into a byte buffer. Off-thread only (blocking file I/O). Empty on @@ -130,10 +126,12 @@ tresult PLUGIN_API ReaSamplerProcessor::initialize(FUnknown* context) { } tresult PLUGIN_API ReaSamplerProcessor::terminate() { - // process() is not running at terminate. Free the live instrument and drain the - // graveyard. Take the pointer out of the atomic first so nothing else races it. + // process() is not running at terminate. Free the live + draining instruments and + // drain the graveyard. Take the pointers out of the atomics first so nothing else + // races them. std::lock_guard lock(reloadMutex_); delete live_.exchange(nullptr); + delete draining_.exchange(nullptr); graveyard_.clear(); return SingleComponentEffect::terminate(); } @@ -148,6 +146,13 @@ tresult PLUGIN_API ReaSamplerProcessor::setActive(TBool state) { reloadFromBank(); } else { std::lock_guard lock(reloadMutex_); + // process is guaranteed stopped: free EVERYTHING. The live instrument too — its + // voices are frozen mid-flight, and if it survived deactivation the reactivate + // reload would displace it into the DRAIN slot, resurrecting stale sustained + // voices as ghosts. Reactivation rebuilds from scratch (reloadFromBank above), + // so nothing is lost by clearing here. + delete live_.exchange(nullptr); + delete draining_.exchange(nullptr); graveyard_.clear(); } return kResultOk; @@ -210,6 +215,15 @@ tresult PLUGIN_API ReaSamplerProcessor::setState(IBStream* state) { std::lock_guard lock(previewMutex_); previewVelocity_ = cs.previewVelocity; } + // Phase S: restore the voice-system parameters (v7; older blobs lift to {16, Poly, + // Retrigger} in deserializeComponentState — pre-Phase-S behavior). Restored BEFORE the + // reload below so the rebuilt engine is born with the saved polyphony/mode. + { + std::lock_guard lock(voiceParamsMutex_); + voiceCount_ = cs.voiceCount; + voiceMode_ = cs.voiceMode; + monoTrigger_ = cs.monoTrigger; + } // Rebuild from the restored state (off-thread — setState is a load-time call). reloadFromBank(); return kResultOk; @@ -231,6 +245,13 @@ tresult PLUGIN_API ReaSamplerProcessor::getState(IBStream* state) { state_out.lastConsumedAssignGeneration = lastConsumedAssignGeneration_; // S8 reader marker } state_out.previewVelocity = previewVelocity(); // S-VIEW-4: persist the preview strike velocity + { + // Phase S: persist the voice-system parameters (component state v7). + std::lock_guard lock(voiceParamsMutex_); + state_out.voiceCount = voiceCount_; + state_out.voiceMode = voiceMode_; + state_out.monoTrigger = monoTrigger_; + } const std::vector bytes = serializeComponentState(state_out); if (!bytes.empty()) { const tresult wr = state->write(const_cast(bytes.data()), @@ -279,6 +300,57 @@ void ReaSamplerProcessor::setPreviewVelocity(std::uint8_t velocity) { previewVelocity_ = velocity; } +int ReaSamplerProcessor::voiceCount() { + std::lock_guard lock(voiceParamsMutex_); + return voiceCount_; +} + +void ReaSamplerProcessor::setVoiceCount(int count) { + // Clamp to the shared pure-core range so the engine, the state bytes, and the editor's + // control can never disagree about the legal polyphony span. + if (count < kMinVoiceCount) count = kMinVoiceCount; + if (count > kMaxVoiceCount) count = kMaxVoiceCount; + { + std::lock_guard lock(voiceParamsMutex_); + if (voiceCount_ == count) return; // no-op: don't churn a rebuild + voiceCount_ = count; + } + // LIGHT rebuild OFF-thread through the drain-slot swap: the engine is reconstructed from + // the already-decoded keymap (no bridge re-read, no WAV re-decode — a polyphony change + // touches no audio data) and the displaced instrument keeps rendering its ringing tails, + // so a voice-param change never cuts a sounding note NOR stalls the UI re-decoding every + // zone from disk. Same contract for the mode/trigger setters below. + rebuildVoiceEngine(); +} + +VoiceMode ReaSamplerProcessor::voiceMode() { + std::lock_guard lock(voiceParamsMutex_); + return voiceMode_; +} + +void ReaSamplerProcessor::setVoiceMode(VoiceMode mode) { + { + std::lock_guard lock(voiceParamsMutex_); + if (voiceMode_ == mode) return; + voiceMode_ = mode; + } + rebuildVoiceEngine(); +} + +MonoTrigger ReaSamplerProcessor::monoTrigger() { + std::lock_guard lock(voiceParamsMutex_); + return monoTrigger_; +} + +void ReaSamplerProcessor::setMonoTrigger(MonoTrigger trigger) { + { + std::lock_guard lock(voiceParamsMutex_); + if (monoTrigger_ == trigger) return; + monoTrigger_ = trigger; + } + rebuildVoiceEngine(); +} + void ReaSamplerProcessor::previewNoteOn(int note) { if (note < 0) note = 0; if (note > 127) note = 127; @@ -366,6 +438,17 @@ std::string ReaSamplerProcessor::reloadFromBank() { // The active channel mode (S7) governs how each WAV decodes (mono downmix vs 2-channel). // Read once under its mutex, off the audio thread, before the decode loop. const ChannelMode mode = channelMode(); + // Phase S: snapshot the voice-system parameters once — they are baked into the built + // engine's construction (the engine's config is immutable; a later change rebuilds). + int builtVoiceCount = kDefaultVoiceCount; + VoiceMode builtVoiceMode = VoiceMode::Poly; + MonoTrigger builtMonoTrigger = MonoTrigger::Retrigger; + { + std::lock_guard vp(voiceParamsMutex_); + builtVoiceCount = voiceCount_; + builtVoiceMode = voiceMode_; + builtMonoTrigger = monoTrigger_; + } std::string resolvedId; std::unique_ptr built; @@ -431,33 +514,105 @@ std::string ReaSamplerProcessor::reloadFromBank() { kPreserveWindowMs * sampleRate_ / 1000.0 + 0.5); if (preserveWindow < 2) preserveWindow = 2; built = std::make_unique( - std::move(km), kMaxVoices, gen, kPreserveVoiceCap, - preserveWindow); + std::move(km), static_cast(builtVoiceCount), gen, + kPreserveVoiceCap, preserveWindow, builtVoiceMode, builtMonoTrigger); } } - // 4. Publish. Atomically install the new instrument; the DISPLACED one goes to the - // graveyard tagged with this generation (process may still be mid-block reading - // it). A null `built` (no bank / unreadable WAV) installs silence. - // `built` is heap-owned; release() hands ownership to the atomic, and the - // exchanged pointer is re-owned by the graveyard. + // 4. Publish. Atomically install the new instrument; the DISPLACED one moves into the + // DRAIN slot (FA1, bug 3b) where process() keeps rendering its ringing voices — + // a reload never cuts a sounding note; the next note-on plays the new state. The + // instrument evicted FROM the drain slot (two reloads old) goes to the graveyard + // (process may still be mid-block reading it). A null `built` (no bank / unreadable + // WAV) installs silence while the displaced tails still ring out via the drain. + // `built` is heap-owned; release() hands ownership to the atomic; the drain-evicted + // pointer is re-owned by the graveyard. // - // Bounded reclaim: prune graveyard entries where displacedAt <= seen, where seen - // is the last generation process() published. process() publishes inst->installedAt - // (not a re-read of reloadGeneration_), so seen == D means process holds the - // instrument installed at gen D. An entry with displacedAt == D was displaced by - // reload D, which installed that very successor — process cannot be holding the - // displaced entry. The pruning condition is therefore <= (see header for the full - // proof). Remaining entries drain at setActive(false) / terminate() when process - // is guaranteed stopped. + publishBuiltLocked(std::move(built)); + return resolvedId; +} + +void ReaSamplerProcessor::publishBuiltLocked(std::unique_ptr built) { + // REQUIRES reloadMutex_ held (single-writer over both slots + the graveyard). Shared by + // reloadFromBank and rebuildVoiceEngine — the one safety-critical swap dance. + // + // Bounded reclaim: free graveyard entries whose installedAt < seen, where seen is + // the minimum installedAt process() published over the pointers it holds. Both + // slots are monotone in installedAt, so seen is monotone and any future process() + // load yields installedAt >= seen — an entry below seen is provably unreachable + // (see the header proof). Remaining entries drain at setActive(false) / terminate() + // when process is guaranteed stopped. const std::uint64_t seen = processGeneration_.load(std::memory_order_acquire); graveyard_.erase( std::remove_if(graveyard_.begin(), graveyard_.end(), - [seen](const GraveyardEntry& e) { return e.displacedAt <= seen; }), + [seen](const std::unique_ptr& e) { + return e->installedAt < seen; + }), graveyard_.end()); LoadedInstrument* prev = live_.exchange(built.release()); - if (prev) graveyard_.push_back({gen, std::unique_ptr(prev)}); - return resolvedId; + LoadedInstrument* evicted = draining_.exchange(prev); + if (evicted) graveyard_.push_back(std::unique_ptr(evicted)); +} + +void ReaSamplerProcessor::rebuildVoiceEngine() { + // OFF THE AUDIO THREAD (the editor's voice-deck click handlers). See the header contract: + // a voice-param change touches NO audio data, so this rebuilds the engine + preview card + // around a COPY of the live instrument's already-decoded keymap — no bridge, no disk — + // and publishes through the same drain-slot swap, so ringing tails survive. + std::lock_guard lock(reloadMutex_); + LoadedInstrument* cur = live_.load(std::memory_order_acquire); + if (!cur) return; // nothing loaded: the new params bake into the next real reload. + + int builtVoiceCount = kDefaultVoiceCount; + VoiceMode builtVoiceMode = VoiceMode::Poly; + MonoTrigger builtMonoTrigger = MonoTrigger::Retrigger; + { + std::lock_guard vp(voiceParamsMutex_); + builtVoiceCount = voiceCount_; + builtVoiceMode = voiceMode_; + builtMonoTrigger = monoTrigger_; + } + + const std::uint64_t gen = reloadGeneration_.fetch_add(1, std::memory_order_relaxed) + 1; + // Same Preserve-window derivation as reloadFromBank (kPreserveWindowMs at the host rate). + std::int64_t preserveWindow = static_cast( + kPreserveWindowMs * sampleRate_ / 1000.0 + 0.5); + if (preserveWindow < 2) preserveWindow = 2; + + // Deep-copy the decoded PCM + zones. Safe to read concurrently with process(): the keymap + // is immutable after construction, and under reloadMutex_ nobody can free `cur`. + Keymap km = cur->keymap; + auto built = std::make_unique( + std::move(km), static_cast(builtVoiceCount), gen, + kPreserveVoiceCap, preserveWindow, builtVoiceMode, builtMonoTrigger); + publishBuiltLocked(std::move(built)); +} + +void ReaSamplerProcessor::retireIdleDrain() { + // Phase S (FA1-review Major #2). Cheap early-out BEFORE the lock: 0 means "no drain, or + // it still sounds" — the common case costs one relaxed load and no mutex. + const std::uint64_t idleGen = drainIdleGeneration_.load(std::memory_order_acquire); + if (idleGen == 0) return; + std::lock_guard lock(reloadMutex_); + LoadedInstrument* drain = draining_.load(std::memory_order_acquire); + // Retire ONLY if the publication names the drain currently in the slot. A stale value + // (about an already-evicted, older drain) can never match the newer occupant's + // installedAt — the slot is monotone in generation — so a mid-swap race is closed by + // this identity check, not by timing. + if (!drain || drain->installedAt != idleGen) return; + draining_.store(nullptr, std::memory_order_release); + graveyard_.push_back(std::unique_ptr(drain)); + // Prune what is now provably unreachable — the same monotone-generation proof as the + // reload path's reclaim (see reloadFromBank): an entry with installedAt < seen cannot be + // held by process() now or ever again. The just-parked drain frees here immediately when + // process() has already published past it; otherwise on the next reload/retire/deactivate. + const std::uint64_t seen = processGeneration_.load(std::memory_order_acquire); + graveyard_.erase( + std::remove_if(graveyard_.begin(), graveyard_.end(), + [seen](const std::unique_ptr& e) { + return e->installedAt < seen; + }), + graveyard_.end()); } ReaSamplerProcessor::BankSyncResult @@ -467,6 +622,11 @@ ReaSamplerProcessor::pollBankSync(bool isFocusedTarget) { // host, or before connect) yields nullopt for both reads, so this no-ops cleanly. BankSyncResult result; + // Phase S: park an idle drain snapshot in the graveyard (and prune) on the same UI-timer + // cadence that drives reloads — an edited-away instrument stops costing memory as soon + // as its tails die instead of squatting in the drain slot until the next reload. + retireIdleDrain(); + // --- S8: assignment-request consume FIRST ------------------------------------- // Decode the pending assignment request (nullopt when absent/malformed). Resolve its // (bankId, sampleId) against the live bank blob: selectSample returns non-nullopt only when @@ -543,24 +703,52 @@ ReaSamplerProcessor::pollBankSync(bool isFocusedTarget) { } tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) { - // REAL-TIME: no allocation, no IO, no locks. Load the live instrument once for the - // whole block (a single atomic acquire), then publish inst->installedAt so the off- - // thread graveyard pruner knows exactly which generation this block is holding. + // REAL-TIME: no allocation, no IO, no locks. Load the live AND draining instruments + // once for the whole block (two atomic acquires), then publish the MINIMUM installedAt + // over the pointers held so the off-thread graveyard pruner knows exactly which + // generations this block is holding (see the header proof). // // We publish installedAt — not a fresh re-read of reloadGeneration_ — to close an - // ordering race: reading reloadGeneration_ after live_ could observe a generation - // newer than the pointer we actually hold, causing the pruner to free an instrument + // ordering race: reading reloadGeneration_ after the slots could observe a generation + // newer than the pointers we actually hold, causing the pruner to free an instrument // process is still reading. installedAt was set on the reload path before the atomic - // exchange that made the instrument visible, so it is always <= the generation of any - // instrument that could have been loaded after our acquire above. + // exchange that made the instrument visible. + // + // The DRAIN instrument (FA1, bug 3b) is the previously-live snapshot displaced by the + // last reload: its already-sounding voices keep rendering (and receive note-offs) so a + // curve/param edit or bank refresh never cuts a ringing note. It receives NO note-ons. + // A racing reload can briefly leave the same pointer in both slots (live_ was loaded + // before the swap, draining_ after); collapse that to live-only so one engine is never + // advanced twice per frame. LoadedInstrument* inst = live_.load(std::memory_order_acquire); - const std::uint64_t heldGen = inst ? inst->installedAt : 0; + LoadedInstrument* drain = draining_.load(std::memory_order_acquire); + if (drain == inst) drain = nullptr; + std::uint64_t heldGen = 0; + if (inst && drain) { + heldGen = inst->installedAt < drain->installedAt ? inst->installedAt + : drain->installedAt; + } else if (inst) { + heldGen = inst->installedAt; + } else if (drain) { + heldGen = drain->installedAt; + } processGeneration_.store(heldGen, std::memory_order_release); + // Phase S drain retirement: publish whether the drain snapshot is FULLY idle (every engine + // voice AND its preview card silent) by naming its OWN installedAt (0 = no drain / still + // sounding). Evaluated at block START — idleness is monotone for a drain (it receives no + // note-ons), so a snapshot observed idle here stays idle; a tail that dies mid-block simply + // publishes one block later. Bounded scan (<= maxVoices), relaxed store — RT-safe. + drainIdleGeneration_.store( + (drain && drain->fullyIdle()) ? drain->installedAt : 0, + std::memory_order_relaxed); + // Marshal MIDI note-on/off from the event input into the voice engine. Tier 0 maps // events at block granularity (no per-event sample-offset split) — audible timing is // within one block, adequate for Tier 0; sample-accurate scheduling is a later tier. - if (inst && data.inputEvents) { + // Note-offs also route to the DRAIN engine so a note held across a reload releases + // its old-snapshot voice too (otherwise it would sustain until the next reload). + if (data.inputEvents) { const int32 count = data.inputEvents->getEventCount(); for (int32 i = 0; i < count; ++i) { Event e; @@ -569,12 +757,46 @@ tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) { // A note-on with velocity 0 is a note-off by MIDI convention. const int vel = static_cast(e.noteOn.velocity * 127.0f + 0.5f); if (vel <= 0) { - inst->engine.noteOff(e.noteOn.pitch); - } else { + if (inst) inst->engine.noteOff(e.noteOn.pitch); + if (drain) drain->engine.noteOff(e.noteOn.pitch); + } else if (inst) { inst->engine.noteOn(e.noteOn.pitch, vel); } } else if (e.type == Event::kNoteOffEvent) { - inst->engine.noteOff(e.noteOff.pitch); + if (inst) inst->engine.noteOff(e.noteOff.pitch); + if (drain) drain->engine.noteOff(e.noteOff.pitch); + } else if (e.type == Event::kLegacyMIDICCOutEvent) { + // PANIC (Phase S voice-review Major #2): REAPER delivers raw input MIDI CC to a + // VST3 instrument as kLegacyMIDICCOut events on the INPUT event list (a REAPER-ism + // — the type is nominally an output event; DAW-verify, see handoff). + // CC 123 (All Notes Off): release semantics — Gate voices enter their AHDSR + // release tail; Trigger one-shots play through their bounded play length. + // CC 120 (All Sounds Off): hard-stop semantics — immediate silence regardless + // of play mode, including Trigger one-shots that ignore CC 123. This is the + // true "panic" for a ringing one-shot (e.g. a full-length capture). + // Both clear the mono held stack. Both apply to live AND drain, engine AND preview. + // allNotesOff / allSoundsOff / releaseAll / hardStop are RT-safe (no allocation, + // bounded scans). + const auto cc = static_cast(e.midiCCOut.controlNumber); + if (cc == kCtrlAllSoundsOff) { + if (inst) { + inst->engine.allSoundsOff(); + inst->preview.hardStop(); + } + if (drain) { + drain->engine.allSoundsOff(); + drain->preview.hardStop(); + } + } else if (cc == kCtrlAllNotesOff) { + if (inst) { + inst->engine.allNotesOff(); + inst->preview.releaseAll(); + } + if (drain) { + drain->engine.allNotesOff(); + drain->preview.releaseAll(); + } + } } } } @@ -582,8 +804,10 @@ tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) { // S-VIEW-4 preview mailbox: drain the off-thread preview-trigger requests (a single relaxed // atomic load each — RT-safe). A request is NEW when its packed sequence differs from the last // one we consumed; fire it once, then latch the sequence so the same request never re-fires. - // Preview note-on/off drive the SAME voice engine as host MIDI (a preview is just a note with - // no MIDI wire) — off-thread posted, audio-thread consumed, no lock, no allocation. + // Phase S: preview note-on/off drive the dedicated PREVIEW CARD — a single voice structurally + // OUTSIDE the MIDI pool, so a full pool can never drop a preview and a preview can never + // steal a playing MIDI voice (the FA1-review isolation fix). Host MIDI routes ONLY to the + // engine (above); the card is summed alongside it in the render below. // Consume (advance the sequence) even when inst is null so a note-on posted while no instrument // is loaded does not re-fire stale on the next instrument load. { @@ -594,16 +818,20 @@ tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) { if (inst) { const int vel = static_cast((on >> 8) & 0xFF); const int note = static_cast(on & 0xFF); - if (vel > 0) inst->engine.noteOn(note, vel); + if (vel > 0) inst->preview.noteOn(note, vel); } } } - if (inst) { + if (inst || drain) { const std::uint32_t off = previewOffRequest_.load(std::memory_order_acquire); const std::uint16_t offSeq = static_cast(off >> 16); if (offSeq != 0 && offSeq != previewOffConsumed_) { previewOffConsumed_ = offSeq; - inst->engine.noteOff(static_cast(off & 0xFF)); + // Route the preview note-off to BOTH cards (mirror of the host note-off): a + // preview held across a reload — e.g. a curve edit committed mid-press — must + // release the old-snapshot card now draining, not just the (fresh) live one. + if (inst) inst->preview.noteOff(static_cast(off & 0xFF)); + if (drain) drain->preview.noteOff(static_cast(off & 0xFF)); } } @@ -639,9 +867,15 @@ tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) { if (ch0 && ch1) { // Stereo: clear both, render L/R. A mono sample plays dual-mono via the engine's stereo // path (both channels equal), so a mono capture in stereo mode is centered, not silent. + // The DRAIN engine's ringing tails ADD on top (render mixes into the cleared buffer). for (int32 i = 0; i < frames; ++i) { ch0[i] = 0.f; ch1[i] = 0.f; } if (inst) { inst->engine.render(ch0, ch1, static_cast(frames)); + inst->preview.render(ch0, ch1, static_cast(frames)); + } + if (drain) { + drain->engine.render(ch0, ch1, static_cast(frames)); + drain->preview.render(ch0, ch1, static_cast(frames)); } // Any channels beyond the first two mirror ch0 (defensive — REAPER negotiates 1 or 2). for (int32 ch = 2; ch < out.numChannels; ++ch) { @@ -664,6 +898,11 @@ tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) { for (int32 i = 0; i < frames; ++i) ch0[i] = 0.f; if (inst) { inst->engine.render(ch0, static_cast(frames)); + inst->preview.render(ch0, static_cast(frames)); + } + if (drain) { + drain->engine.render(ch0, static_cast(frames)); + drain->preview.render(ch0, static_cast(frames)); } float peak = 0.f; for (int32 i = 0; i < frames; ++i) { @@ -679,10 +918,12 @@ tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) { } // Report silence only when nothing is loaded (lets the host optimize when idle). - // With an instrument loaded we clear the flag so a ringing voice is not skipped. - out.silenceFlags = inst ? 0 : ((out.numChannels >= 64) - ? ~0ULL - : ((1ULL << out.numChannels) - 1)); + // With an instrument loaded — or a drain snapshot still ringing out — we clear the + // flag so a ringing voice is not skipped. + out.silenceFlags = (inst || drain) ? 0 + : ((out.numChannels >= 64) + ? ~0ULL + : ((1ULL << out.numChannels) - 1)); return kResultOk; } diff --git a/src/vst/reasampler_processor.h b/src/vst/reasampler_processor.h index 3df4d13..c228dc3 100644 --- a/src/vst/reasampler_processor.h +++ b/src/vst/reasampler_processor.h @@ -35,11 +35,12 @@ namespace reasampler::vst { class ReaSamplerEmbed; // S6 embedded TCP/MCP UI shell (owned below; see queryInterface) -// One fully-built, ready-to-play instrument snapshot: the decoded keymap and the voice -// engine that plays it. The engine holds a reference into the keymap, so the two MUST -// live and die together at a STABLE address — hence this is heap-allocated and neither -// copyable nor movable. The audio thread only ever reads it through an atomic pointer; -// it is built and destroyed off the audio thread. +// One fully-built, ready-to-play instrument snapshot: the decoded keymap, the voice +// engine that plays it, and the isolated PREVIEW CARD (Phase S) summed alongside it. +// Engine and card both hold references into the keymap, so the three MUST live and die +// together at a STABLE address — hence this is heap-allocated and neither copyable nor +// movable. The audio thread only ever reads it through an atomic pointer; it is built +// and destroyed off the audio thread. // // installedAt: the reloadGeneration_ value at which this instrument was atomically // installed into live_. Set on the reload path before the exchange. process() publishes @@ -48,15 +49,25 @@ class ReaSamplerEmbed; // S6 embedded TCP/MCP UI shell (owned below; see queryI struct LoadedInstrument { Keymap keymap; VoiceEngine engine; + PreviewCard preview; // Phase S: the isolated preview voice — never part of the pool std::uint64_t installedAt = 0; // reload generation at which this was installed LoadedInstrument(Keymap km, std::size_t maxVoices, std::uint64_t gen, std::size_t preserveVoiceCap = 0, - std::int64_t preserveWindowFrames = 0) + std::int64_t preserveWindowFrames = 0, + VoiceMode voiceMode = VoiceMode::Poly, + MonoTrigger monoTrigger = MonoTrigger::Retrigger) : keymap(std::move(km)), - engine(maxVoices, keymap, preserveVoiceCap, preserveWindowFrames), + engine(maxVoices, keymap, preserveVoiceCap, preserveWindowFrames, + voiceMode, monoTrigger), + preview(keymap, preserveWindowFrames), installedAt(gen) {} + // True when nothing in this snapshot is sounding — engine voices AND the preview card. + // process() publishes this for the drain slot so the off-thread retirer can park an + // idle drain in the graveyard early (FA1-review Major #2). Bounded scan (<= maxVoices). + bool fullyIdle() const { return engine.activeVoiceCount() == 0 && !preview.active(); } + LoadedInstrument(const LoadedInstrument&) = delete; LoadedInstrument& operator=(const LoadedInstrument&) = delete; }; @@ -186,13 +197,28 @@ public: std::uint8_t previewVelocity(); void setPreviewVelocity(std::uint8_t velocity); - // Fire a one-shot PREVIEW note-on / note-off through the live voice engine (S-VIEW-4), OFF - // the audio thread (the editor's preview-trigger button drives these on the UI thread). The - // request is handed to process() via a lock-free single-slot mailbox drained at block start — - // no allocation, no lock on the audio thread. previewNoteOn plays `note` at the current - // previewVelocity(); previewNoteOff releases it (Gate) — Trigger zones ignore note-off and - // play through. A momentary button (down = on, up = off) reads as a natural key press. This - // is PLAYBACK ONLY: it never captures, never inserts a timeline item. + // --- Phase S voice-system parameters (per-instance, persisted in component state v7) --- + // Read/written on the UI thread (the editor's voice deck) and by getState/setState; guarded + // by voiceParamsMutex_. NOT read on the audio thread — each setter rebuilds the VoiceEngine + // OFF-thread via rebuildVoiceEngine (a LIGHT rebuild around the already-decoded keymap; no + // bridge read, no WAV re-decode) published through the same tail-preserving drain-slot swap, + // so changing polyphony / mode / the retrigger toggle never cuts a ringing tail. + int voiceCount(); + void setVoiceCount(int count); // clamped to kMinVoiceCount..kMaxVoiceCount + VoiceMode voiceMode(); + void setVoiceMode(VoiceMode mode); + MonoTrigger monoTrigger(); + void setMonoTrigger(MonoTrigger trigger); + + // Fire a one-shot PREVIEW note-on / note-off through the live instrument's PREVIEW CARD + // (S-VIEW-4; Phase S isolation) — a dedicated single voice structurally OUTSIDE the MIDI + // pool, so a full pool never drops a preview and a preview never steals a playing voice. + // OFF the audio thread (the editor's preview-trigger button drives these on the UI thread). + // The request is handed to process() via a lock-free single-slot mailbox drained at block + // start — no allocation, no lock on the audio thread. previewNoteOn plays `note` at the + // current previewVelocity(); previewNoteOff releases it (Gate) — Trigger zones ignore + // note-off and play through. A momentary button (down = on, up = off) reads as a natural + // key press. This is PLAYBACK ONLY: it never captures, never inserts a timeline item. void previewNoteOn(int note); void previewNoteOff(int note); @@ -202,41 +228,80 @@ private: // caller drives restartComponent when appropriate. void applyOutputArrangement(ChannelMode mode); + // Phase S drain retirement (FA1-review Major #2): if process() has published that the + // CURRENT drain instrument is fully idle (every engine voice + the preview card silent), + // move it out of the drain slot into the graveyard and prune — so an edited-away snapshot + // stops costing resident memory as soon as its tails die, instead of squatting in the slot + // until the NEXT reload. Off the audio thread only (takes reloadMutex_); driven from + // pollBankSync's UI-timer tick (the same cadence that drives reloads — an idle drain with + // no editor open simply waits for the next reload/deactivate, exactly the pre-fix bound). + // Safe against a racing process(): idleness is monotone (the drain receives no note-ons) + // and the published value names the drain's OWN installedAt, so a stale publication about + // an OLDER drain can never retire a newer one; the graveyard prune's monotone-generation + // proof (see below) covers the free. + void retireIdleDrain(); + + // Phase S voice-param LIGHT rebuild (voice-review Major #3): rebuild the engine + preview + // card around a COPY of the LIVE instrument's already-decoded Keymap — no bridge read, no + // filesystem, no WAV re-decode — and publish through the same tail-preserving drain-slot + // swap as a full reload. A polyphony/mode/trigger change touches no audio data, so the + // full reloadFromBank (which re-decodes every zone WAV from disk on the UI thread) was + // pure waste — a visible UI stall on a many-zone instrument. Copying the keymap is safe: + // it is immutable after construction and, under reloadMutex_, the live instrument can + // neither be swapped nor freed while we read it. When nothing is loaded this is a no-op — + // the new params bake into the next real reload. Off the audio thread only. + void rebuildVoiceEngine(); + + // Publish `built` (null = install silence) into live_: prune the graveyard by the last + // process()-published generation, swap `built` into live_, displace the previous live into + // the drain slot, and park the drain-evicted instrument in the graveyard. REQUIRES + // reloadMutex_ held — factored out so reloadFromBank and rebuildVoiceEngine share the ONE + // safety-critical swap dance (see the handoff proof below). + void publishBuiltLocked(std::unique_ptr built); + ReaperBridge bridge_; - // --- The audio-thread handoff (S4 real-time discipline) ----------------- - // process() atomically loads `live_` at block start and marshals/renders against it — - // a single atomic acquire, no lock, no free on the audio thread. + // --- The audio-thread handoff (S4 real-time discipline, FA1 drain slot) -- + // process() atomically loads `live_` AND `draining_` at block start and marshals/renders + // against them — two atomic acquires, no lock, no free on the audio thread. // // reloadFromBank() (off-thread, serialized by reloadMutex_) builds a new // LoadedInstrument and atomically swaps it into `live_`. The DISPLACED instrument is - // NOT freed on the reload path: process() may still be mid-block reading it, and two - // rapid reloads could otherwise free a pointer process is using. Instead it is parked - // in `graveyard_` tagged with the reload generation at which it was displaced. + // NOT freed and NOT silenced: it moves into `draining_`, where process() keeps + // rendering its already-sounding voices (and routes note-offs to it) so a reload — + // a curve/param edit, a bank-generation refresh, an applied assignment — never cuts a + // ringing note (FA1, bug 3b). New note-ons go ONLY to the live instrument, so the next + // trigger plays the new state. The instrument evicted FROM the drain slot (two reloads + // old) is parked in `graveyard_` for reclaim — a rapid second reload hard-cuts only the + // oldest edit's tails (bounded compromise, documented). // - // Bounded reclaim: process() publishes inst->installedAt (the generation at which the - // held instrument was installed) via processGeneration_ — a single atomic store, RT- - // safe. The reload path prunes graveyard entries where displacedAt <= seen (where seen - // is the last published processGeneration_). + // Bounded reclaim: process() publishes the MINIMUM installedAt over the (non-null) + // pointers it holds this block via processGeneration_ — a single atomic store, RT-safe. + // The reload path frees graveyard entries whose installedAt < seen (the last published + // value). // - // Safety argument: an entry with displacedAt == D was displaced by reload D, which - // simultaneously installed its successor with installedAt == D. process() publishing - // seen == D means it holds that successor (or a later one). In either case, the - // displaced entry is not the pointer process is using, so freeing it is safe. The - // pruning condition is therefore <= (not strict <): an entry displaced at exactly the - // published generation is also provably unreachable. + // Safety argument: both slots are monotone in installedAt over time (live_ receives + // successively newer builds; draining_ receives successively newer displaced lives), so + // the published minimum is monotone across blocks, and any future process() load yields + // installedAt >= seen. An entry only reaches the graveyard by leaving BOTH slots + // (single-writer under reloadMutex_), so a graveyard entry with installedAt < seen can + // never again be loaded and is not currently held — freeing it is safe. process() + // publishes BEFORE rendering, so the pointers it renders with are covered by the value + // the pruner reads (a stale lower read is merely conservative). // // The graveyard's upper bound is the number of reloads since process last ran // (typically 0–1 in normal use). Remaining entries drain at setActive(false) / // terminate(), when the host guarantees process is stopped. std::atomic live_{nullptr}; + std::atomic draining_{nullptr}; // displaced instrument still rendering its tails std::atomic reloadGeneration_{0}; // incremented by each reload (off-thread, under reloadMutex_; read atomically by process) - std::atomic processGeneration_{0}; // generation last seen by process (written on audio thread, read off-thread) - struct GraveyardEntry { - std::uint64_t displacedAt = 0; // reloadGeneration_ value when this was displaced - std::unique_ptr instrument; - }; - std::vector graveyard_; // drained on reclaim + setActive(false) + terminate + std::atomic processGeneration_{0}; // min installedAt held by process (written on audio thread, read off-thread) + // Phase S: the installedAt of the drain instrument process() last observed FULLY IDLE + // (0 = none / the current drain still sounds). Written relaxed on the audio thread each + // block; read by retireIdleDrain() off-thread. Naming the generation (not a bool) closes + // the swap race: a publication about an old drain can never retire its successor. + std::atomic drainIdleGeneration_{0}; + std::vector> graveyard_; // drained on reclaim + setActive(false) + terminate std::mutex reloadMutex_; // serializes off-thread reloads + graveyard access // The single-capture selection id (S10: the ONE picked capture; "" = no pick -> silence). @@ -281,9 +346,19 @@ private: std::mutex previewMutex_; std::uint8_t previewVelocity_ = kPreviewVelocityDefault; + // Phase S voice-system parameters (per-instance, persisted in component state v7). Off-thread + // only (UI voice deck + getState/setState + reloadFromBank); guarded against a getState/editor + // race. Defaults {16, Poly, Retrigger} reproduce pre-Phase-S behavior. NOT read on the audio + // thread — reloadFromBank bakes them into the LoadedInstrument's engine off-thread. + std::mutex voiceParamsMutex_; + int voiceCount_ = kDefaultVoiceCount; + VoiceMode voiceMode_ = VoiceMode::Poly; + MonoTrigger monoTrigger_ = MonoTrigger::Retrigger; + // --- S-VIEW-4 preview-trigger mailbox (off-thread -> audio thread, lock-free) --------- // The editor's preview-trigger button posts a note-on/off request from the UI thread; process() - // drains it at block start and drives the live engine. ONE slot per direction, each a packed + // drains it at block start and drives the live instrument's PREVIEW CARD (Phase S — never the + // MIDI pool). ONE slot per direction, each a packed // request whose high bits are a monotonically-incrementing sequence so process() detects a NEW // request by comparing against the last sequence it consumed (never re-firing a stale one). The // low 8 bits carry the note (on) / note (off); the on request also carries the velocity in the diff --git a/src/vst/sample_map.cpp b/src/vst/sample_map.cpp index 961507c..dbcc2b5 100644 --- a/src/vst/sample_map.cpp +++ b/src/vst/sample_map.cpp @@ -606,6 +606,15 @@ std::vector serializeComponentState(const ComponentState& state) { // v6 envelope addition (S-VIEW-4): the preview-trigger velocity, 1 byte (MIDI 1..127). Follows // the marker so a v5 blob is a strict prefix of a v6 blob up to this byte (see the v5 lift). out.push_back(state.previewVelocity); + // v7 envelope addition (Phase S voice system): voice count (1..32), voice mode (0 = Poly, + // 1 = Mono), mono trigger (0 = Retrigger, 1 = Legato) — one byte each, following the + // velocity byte so a v6 blob is a strict prefix up to here (see the v6 lift). + const int vc = state.voiceCount < kMinVoiceCount ? kDefaultVoiceCount + : state.voiceCount > kMaxVoiceCount ? kMaxVoiceCount + : state.voiceCount; + out.push_back(static_cast(vc)); + out.push_back(state.voiceMode == VoiceMode::Mono ? 1 : 0); + out.push_back(state.monoTrigger == MonoTrigger::Legato ? 1 : 0); // Length-prefixed selection id (it precedes the zones payload, so it MUST be framed — // unlike the v1 selection blob where the id ran to end-of-stream). putU32le(out, static_cast(state.selectionId.size())); @@ -681,11 +690,15 @@ ComponentState deserializeComponentState(const std::vector& bytes, readZonesPayload(r, out.map, projectRate); return out; // previewVelocity stays at the mid default (pre-S-VIEW-4) } - if (version != kComponentStateVersion) return out; // unknown -> empty + if (version != kComponentStateVersion && + version != kSelectionZonesModeMarkerVelV6Version) { + return out; // unknown -> empty + } - // v6: the channel-mode byte, then the 8-byte consumed-assignment marker, then the 1-byte - // preview velocity, precede the v3 body. A non-{0,1} mode byte is treated as mono - // (conservative default) rather than rejected — a corrupt mode never silences the instance. + // v6/v7 shared prefix: the channel-mode byte, then the 8-byte consumed-assignment marker, + // then the 1-byte preview velocity, precede the v3 body. A non-{0,1} mode byte is treated + // as mono (conservative default) rather than rejected — a corrupt mode never silences the + // instance. const std::uint8_t modeByte = r.u8(); if (!r.ok) return out; // truncated before the mode byte -> empty (mono default holds) out.channelMode = (modeByte == 1) ? ChannelMode::Stereo : ChannelMode::Mono; @@ -698,6 +711,21 @@ ComponentState deserializeComponentState(const std::vector& bytes, out.previewVelocity = (previewVel >= 1 && previewVel <= 127) ? previewVel : kPreviewVelocityDefault; + // v7 (Phase S): the three voice-system bytes. A v6 blob (pre-Phase-S) skips them — the + // construction defaults {16, Poly, Retrigger} hold, reproducing pre-Phase-S behavior. + if (version == kComponentStateVersion) { + const std::uint8_t vc = r.u8(); + const std::uint8_t vm = r.u8(); + const std::uint8_t mt = r.u8(); + if (!r.ok) return out; // truncated inside the voice bytes -> empty (defaults hold) + // Out-of-range bytes fall back to the field's DEFAULT (the previewVelocity precedent + // for a corrupt blob) rather than clamping to an edge the user never chose. + out.voiceCount = (vc >= kMinVoiceCount && vc <= kMaxVoiceCount) + ? static_cast(vc) + : kDefaultVoiceCount; + out.voiceMode = (vm == 1) ? VoiceMode::Mono : VoiceMode::Poly; + out.monoTrigger = (mt == 1) ? MonoTrigger::Legato : MonoTrigger::Retrigger; + } const std::uint32_t idLen = r.u32(); out.selectionId = r.str(idLen); if (!r.ok) { out.selectionId.clear(); return out; } // truncated id -> empty diff --git a/src/vst/sample_map.h b/src/vst/sample_map.h index 14980eb..c08d419 100644 --- a/src/vst/sample_map.h +++ b/src/vst/sample_map.h @@ -447,17 +447,23 @@ PerformanceMap deserializePerformance(const std::vector& bytes, // instance with NO pick and NO zones restores EMPTY (silence + the "pick a capture" empty // state), never auto-playing sample #1. // -// Format (envelope v6): 4-byte LE version tag (== 6), then a 1-byte channel-mode field (0 = mono, +// Format (envelope v7): 4-byte LE version tag (== 7), then a 1-byte channel-mode field (0 = mono, // 1 = stereo), then an 8-byte LE last-consumed-assignment generation (S8/S9 reader marker), then a -// 1-byte preview-trigger velocity (S-VIEW-4, MIDI 1..127), then a 4-byte LE selection-id length + -// id bytes, then the CURRENT zones payload (identical to serializePerformance's body — its own -// self-describing version, see the ZONES-PAYLOAD block). The 1-byte preview velocity is the ONLY -// envelope-v6 addition over envelope-v5 — the envelope grew a field, the zones payload is untouched -// (a PARALLEL track owns zone-record extension under its own versioning; the two version numbers -// are independent axes). BACK-COMPAT on read (every older blob lifts to channelMode = MONO, -// lastConsumedAssignGeneration = 0, and previewVelocity = kPreviewVelocityDefault, preserving -// current behavior for already-saved instances): -// * v6 blob -> {channelMode, lastConsumedAssignGeneration, previewVelocity, selectionId, zones} direct. +// 1-byte preview-trigger velocity (S-VIEW-4, MIDI 1..127), then the THREE Phase-S voice-system +// bytes: a 1-byte voice count (1..32), a 1-byte voice mode (0 = Poly, 1 = Mono), a 1-byte mono +// trigger (0 = Retrigger, 1 = Legato), then a 4-byte LE selection-id length + id bytes, then the +// CURRENT zones payload (identical to serializePerformance's body — its own self-describing +// version, see the ZONES-PAYLOAD block). The three voice bytes are the ONLY envelope-v7 addition +// over envelope-v6 — the envelope grew fields, the zones payload is untouched (a PARALLEL track +// owns zone-record extension under its own versioning; the two version numbers are independent +// axes — do NOT bump the zones-payload version for an envelope field). An out-of-range voice +// byte (a corrupt blob) falls back to the field's default rather than silencing the instance +// (the previewVelocity precedent). BACK-COMPAT on read (every older blob lifts to channelMode = +// MONO, lastConsumedAssignGeneration = 0, previewVelocity = kPreviewVelocityDefault, and the +// Phase-S voice defaults {16 voices, Poly, Retrigger} — which reproduce pre-Phase-S behavior +// exactly — preserving current behavior for already-saved instances): +// * v7 blob -> {channelMode, marker, previewVelocity, voiceCount, voiceMode, monoTrigger, selectionId, zones} direct. +// * v6 blob -> {channelMode, marker, previewVelocity, selectionId, zones}: pre-Phase-S (voice defaults). // * v5 blob -> {channelMode, lastConsumedAssignGeneration, mid, selectionId, zones}: pre-S-VIEW-4 (no velocity). // * v4 blob -> {channelMode, 0, mid, selectionId, zones}: pre-S8/S9 reader (no marker). // * v3 blob -> {mono, 0, mid, selectionId, zones}: pre-S7 had no channel mode. @@ -485,9 +491,20 @@ struct ComponentState { // of channelMode, NOT per-zone), persisted so the Sample-view preview button retains the user's // chosen strike velocity across saves. Defaults to kPreviewVelocityDefault. std::uint8_t previewVelocity = kPreviewVelocityDefault; + // Phase S voice system: PER-INSTANCE performance choices (siblings of channelMode, NOT + // per-zone). Defaults {16, Poly, Retrigger} reproduce pre-Phase-S behavior exactly, so an + // older blob lifting to these plays byte-identically. + int voiceCount = kDefaultVoiceCount; // polyphony bound, kMinVoiceCount..kMaxVoiceCount + VoiceMode voiceMode = VoiceMode::Poly; // Poly | Mono (last-note-priority held stack) + MonoTrigger monoTrigger = MonoTrigger::Retrigger; // mono takeover: Retrigger | Legato }; -inline constexpr std::uint32_t kComponentStateVersion = 6; +inline constexpr std::uint32_t kComponentStateVersion = 7; + +// The pre-Phase-S combined-state version (selection + zones + channel mode + consumed marker + +// preview velocity, no voice-system fields). Retained so deserializeComponentState can lift a +// v6 blob to the voice defaults {16, Poly, Retrigger}. +inline constexpr std::uint32_t kSelectionZonesModeMarkerVelV6Version = 6; // The pre-S-VIEW-4 combined-state version (selection + zones + channel mode + consumed marker, no // preview velocity). Retained so deserializeComponentState can lift a v5 blob to a mid velocity. diff --git a/src/vst/sampler_core.cpp b/src/vst/sampler_core.cpp index 22222c3..c48b546 100644 --- a/src/vst/sampler_core.cpp +++ b/src/vst/sampler_core.cpp @@ -260,7 +260,8 @@ void Voice::presizePreserveShifters(std::int64_t windowFrames) { } void Voice::start(int note, int velocity, const SampleData& sample, int rootNote, - double keyTrack, const vst::VelocityCurve& velocityCurve) { + double keyTrack, const vst::VelocityCurve& velocityCurve, + bool unityVarispeedBypass) { active_ = true; releasing_ = false; amplitudeDone_ = false; @@ -280,6 +281,20 @@ void Voice::start(int note, int velocity, const SampleData& sample, int rootNote playMode_ = p.playMode; pitchEngine_ = p.pitchEngine; + // FA1 unity bypass, RE-SCOPED (Phase S): a UNITY-SHIFT Preserve voice — note at the + // effective root (baseRatio_ == 1.0, exact per keyTrackedRatio) with the pitch envelope + // off — is demoted to the Varispeed read path ONLY when the caller opted in. At ratio 1.0 + // the two engines are byte-identical EXCEPT the OLA shifter's structural onset cost (a + // half-window delay + Hann fade-in), which buys nothing at unity — but skipping it makes + // the root note speak ~25 ms EARLIER than its neighbors, an audible timing step in a + // chromatic MIDI line (the FA1-review Major). So: the PREVIEW card (always at root, + // latency-critical, no line to be uneven against) passes true; the MIDI VoiceEngine + // passes false and keeps one uniform onset across the keyboard. + if (unityVarispeedBypass && pitchEngine_ == PitchEngine::Preserve && + baseRatio_ == 1.0 && !p.pitchEnv.enabled) { + pitchEngine_ = PitchEngine::Varispeed; + } + // Initial read position honors the sample's start-point offset (S11), in BOTH modes. Clamp // into [0, frames): a start at or past the end degrades to 0 (play from the top) rather than // starting a voice already off the end. A negative start (shouldn't occur) is pinned to 0. @@ -339,6 +354,17 @@ void Voice::start(int note, int velocity, const SampleData& sample, int rootNote ratio_ = baseRatio_; // seeded; advanceFrame recomputes per frame under the active engine. } +void Voice::retune(int note, int rootNote, double keyTrack) { + // Mono legato takeover: move the pitch, touch NOTHING else — the amplitude envelope keeps + // running (no re-attack), the read head keeps its position, the shifter keeps its ring + // (Preserve picks the new baseRatio_ up via next frame's setShiftRatio; Varispeed via the + // per-frame ratio_ recompute). Velocity gain deliberately stays the first note's — a legato + // phrase is one gesture, one strike (classic mono-synth behavior). + if (!active_) return; + note_ = note; + baseRatio_ = keyTrackedRatio(note, rootNote, keyTrack); +} + void Voice::release() { if (!active_) return; // TRIGGER ignores note-off entirely (S15): the one-shot plays through to its play length. @@ -347,6 +373,12 @@ void Voice::release() { env_.noteOff(); } +void Voice::hardStop() { + // CC 120 (All Sounds Off): immediate silence regardless of play mode. Stops Trigger one-shots + // that ignore release(), and short-circuits Gate release tails. RT-safe: no allocation. + active_ = false; +} + double Voice::tickAmplitude() { double amp; if (playMode_ == PlayMode::Gate) { @@ -500,17 +532,26 @@ void Voice::renderFrameStereo(AudioSample& l, AudioSample& r) { VoiceEngine::VoiceEngine(std::size_t maxVoices, const Keymap& keymap, std::size_t preserveVoiceCap, - std::int64_t preserveWindowFrames) - : voices_(maxVoices == 0 ? 1 : maxVoices), keymap_(keymap), - preserveVoiceCap_(preserveVoiceCap) { - // maxVoices == 0 would mean "no polyphony at all", which cannot service a note-on; - // clamp to a single voice so the engine is always usable (documented degenerate). - // + std::int64_t preserveWindowFrames, + VoiceMode voiceMode, MonoTrigger monoTrigger) + // MONO always uses voices_[0] only (last-note priority, single voice); size to 1 so + // the "only voices_[0] is ever driven" invariant is structurally enforced — no latent + // RT-discipline risk if a future mono path touched voices_[1..]. maxVoices == 0 clamps + // to 1 (documented degenerate: at least one voice so a note-on is always serviceable). + : voices_(voiceMode == VoiceMode::Mono ? 1 + : (maxVoices == 0 ? 1 : maxVoices)), + keymap_(keymap), + preserveVoiceCap_(preserveVoiceCap), + voiceMode_(voiceMode), monoTrigger_(monoTrigger) { // Pre-size every voice's Preserve shifters HERE (construction is off the audio thread), so // note-on never allocates. A 0 window leaves them pass-through (no ring). This is the one // allocation point for the shifter rings across the engine's lifetime. + // MONO: voices_.size() == 1, so the loop below sizes exactly one voice regardless of + // maxVoices — the Poly path sizes the whole pool as before. if (preserveWindowFrames > 1) { - for (Voice& v : voices_) v.presizePreserveShifters(preserveWindowFrames); + for (std::size_t i = 0; i < voices_.size(); ++i) { + voices_[i].presizePreserveShifters(preserveWindowFrames); + } } } @@ -549,7 +590,92 @@ std::size_t VoiceEngine::allocateVoice() { return bestReleasing != kNoVoice ? bestReleasing : bestOverall; } +void VoiceEngine::removeHeld(int note) { + for (std::size_t i = 0; i < heldCount_; ++i) { + if (heldStack_[i].note == static_cast(note)) { + // Shift the notes above it down one slot (press order preserved). + for (std::size_t j = i + 1; j < heldCount_; ++j) heldStack_[j - 1] = heldStack_[j]; + --heldCount_; + return; + } + } +} + +std::size_t VoiceEngine::monoNoteOn(int note, int velocity) { + // Reject out-of-range notes BEFORE touching the held stack: HeldNote stores the note as a + // uint8, so an unguarded value (e.g. 256, or a negative) would alias mod 256 onto a real + // held note and corrupt the stack. Mirrored in monoNoteOff. + if (note < 0 || note > 127) return kNoVoice; + const ZoneResolution res = keymap_.resolve(note, velocity); + if (!res.matched) return kNoVoice; // out-of-zone: defined no-play, never joins the stack. + const KeyZone& zone = keymap_.zones[res.zoneIndex]; + if (zone.sampleIndex >= keymap_.samples.size()) return kNoVoice; + const SampleData& sample = keymap_.samples[zone.sampleIndex]; + + // The note joins (or moves to) the top of the held stack. Velocity is clamped into the + // byte for storage only; the voice start below receives the caller's value untouched. + removeHeld(note); + if (heldCount_ < heldStack_.size()) { + const int vclamped = velocity < 0 ? 0 : (velocity > 127 ? 127 : velocity); + heldStack_[heldCount_++] = HeldNote{static_cast(note), + static_cast(vclamped)}; + } + + Voice& v = voices_[0]; + // LEGATO takeover, keyed on the HELD-STACK DEPTH: after the push above, heldCount_ >= 2 + // means another note was already physically held — the exact "takeover within a phrase" + // predicate. (The previous guard, `active && !releasing`, broke for TRIGGER zones: + // Voice::release() is a no-op in Trigger, so releasing_ never latches, and a one-shot + // still ringing after the last key-up was silently RETUNED in place instead of + // re-attacked. NOTE: a one-held-note same-note re-press (heldCount_ becomes 1 after the + // removeHeld/re-push above — so heldCount_ < 2) re-attacks rather than retuning, which is + // the correct fresh-phrase behavior for that edge case.) Same-sample requirement unchanged. + if (v.active() && heldCount_ >= 2 && monoTrigger_ == MonoTrigger::Legato && + v.playingSample() == &sample) { + v.retune(note, zone.rootNote, zone.keyTrack); + return 0; + } + // RETRIGGER takeover / first note of a phrase / cross-sample legato: (re)start the voice. + v.start(note, velocity, sample, zone.rootNote, zone.keyTrack, zone.velocityCurve); + v.setStartOrder(nextStartOrder_++); + return 0; +} + +void VoiceEngine::monoNoteOff(int note) { + // Same range guard as monoNoteOn: removeHeld compares against the uint8-cast note, so an + // unguarded out-of-range off (e.g. 256 -> 0 mod 256) would evict a legitimately held note. + if (note < 0 || note > 127) return; + removeHeld(note); + Voice& v = voices_[0]; + // Releasing a note that is not the sounding one (a lower held note or an already-released + // note) changes nothing audible. + if (!v.active() || v.releasing() || v.note() != note) return; + + if (heldCount_ == 0) { + v.release(); // last finger up: gate off (Trigger zones ignore this and play through). + return; + } + // FALLBACK: the most-recent still-held note takes the voice back (last-note priority). + const HeldNote fb = heldStack_[heldCount_ - 1]; + const ZoneResolution res = keymap_.resolve(fb.note, fb.velocity); + if (!res.matched || keymap_.zones[res.zoneIndex].sampleIndex >= keymap_.samples.size()) { + v.release(); // defensive: only resolving notes are pushed, so this shouldn't happen. + return; + } + const KeyZone& zone = keymap_.zones[res.zoneIndex]; + const SampleData& sample = keymap_.samples[zone.sampleIndex]; + if (monoTrigger_ == MonoTrigger::Legato && v.playingSample() == &sample) { + v.retune(fb.note, zone.rootNote, zone.keyTrack); // glide back, no re-attack + return; + } + // Retrigger (or cross-sample) fallback: re-strike the fallen-back-to note at its own + // original velocity. + v.start(fb.note, fb.velocity, sample, zone.rootNote, zone.keyTrack, zone.velocityCurve); + v.setStartOrder(nextStartOrder_++); +} + std::size_t VoiceEngine::noteOn(int note, int velocity) { + if (voiceMode_ == VoiceMode::Mono) return monoNoteOn(note, velocity); const ZoneResolution res = keymap_.resolve(note, velocity); if (!res.matched) return kNoVoice; // out-of-zone: defined no-play. @@ -578,6 +704,7 @@ std::size_t VoiceEngine::noteOn(int note, int velocity) { } void VoiceEngine::noteOff(int note) { + if (voiceMode_ == VoiceMode::Mono) { monoNoteOff(note); return; } // Release the NEWEST active, non-releasing voice on this note (largest startOrder), // so a re-triggered note releases its newest instance first and older tails ring. std::size_t target = kNoVoice; @@ -595,6 +722,28 @@ void VoiceEngine::noteOff(int note) { if (target != kNoVoice) voices_[target].release(); } +void VoiceEngine::allNotesOff() { + // CC 123. Clear the mono held stack so no fallback can resurrect a phantom note (the + // stuck-note scenario: a lost note-off leaves an entry that monoNoteOff's fallback + // restarts and sustains forever with no key held), then gate off every active voice. + // Gate voices enter their release tail; Trigger one-shots ignore release by design and + // play through their bounded play length. RT-safe: no allocation, bounded by the pool size. + heldCount_ = 0; + for (Voice& v : voices_) { + if (v.active()) v.release(); + } +} + +void VoiceEngine::allSoundsOff() { + // CC 120. Hard-stop EVERY voice immediately (no release ramp — silences Trigger one-shots + // that allNotesOff() cannot stop) and clear the mono held stack. RT-safe: no allocation, + // bounded by the pool size. + heldCount_ = 0; + for (Voice& v : voices_) { + v.hardStop(); + } +} + void VoiceEngine::render(AudioSample* out, std::size_t frameCount) { // Real-time safe: no allocation, no resize — mix straight into the caller's buffer. // The VST3 process callback hands us the host's output channel buffer here, so the @@ -644,4 +793,67 @@ std::size_t VoiceEngine::activeVoiceCount() const { return n; } +// --------------------------------------------------------------------------- +// PreviewCard (Phase S) — the isolated preview voice. See the header contract. +// --------------------------------------------------------------------------- + +PreviewCard::PreviewCard(const Keymap& keymap, std::int64_t preserveWindowFrames) + : keymap_(keymap) { + // Construction is off the audio thread (the shell builds the card inside its + // LoadedInstrument) — the one allocation point for the preview voice's shifter rings, + // mirroring VoiceEngine's constructor. <= 1 leaves them pass-through. + if (preserveWindowFrames > 1) voice_.presizePreserveShifters(preserveWindowFrames); +} + +void PreviewCard::noteOn(int note, int velocity) { + const ZoneResolution res = keymap_.resolve(note, velocity); + if (!res.matched) return; // out-of-zone: defined no-play + const KeyZone& zone = keymap_.zones[res.zoneIndex]; + if (zone.sampleIndex >= keymap_.samples.size()) return; + const SampleData& sample = keymap_.samples[zone.sampleIndex]; + // One voice, one finger: a new preview replaces the ringing one. The unity-Varispeed + // bypass is OPTED IN here (and only here) — the preview fires at the effective root, so + // this is its zero-added-latency path (the FA1 fix, re-scoped off the MIDI engine). No + // Preserve cap and no stealing interplay: the card is structurally outside the pool. + voice_.start(note, velocity, sample, zone.rootNote, zone.keyTrack, zone.velocityCurve, + /*unityVarispeedBypass=*/true); +} + +void PreviewCard::noteOff(int note) { + // Release only the note that is actually sounding — an off for a replaced (stale) preview + // note must not cut the new one. + if (voice_.active() && voice_.note() == note) voice_.release(); +} + +void PreviewCard::releaseAll() { + // CC 123 peer of VoiceEngine::allNotesOff: unconditional release, whatever note rings. + // Gate enters release; Trigger plays through (bounded, cannot be stuck). RT-safe. + if (voice_.active()) voice_.release(); +} + +void PreviewCard::hardStop() { + // CC 120 peer of VoiceEngine::allSoundsOff: immediate silence, no release ramp. + // Silences Trigger one-shots that releaseAll() cannot stop. RT-safe. + voice_.hardStop(); +} + +void PreviewCard::render(AudioSample* out, std::size_t frameCount) { + if (out == nullptr || frameCount == 0 || !voice_.active()) return; + for (std::size_t f = 0; f < frameCount; ++f) { + if (!voice_.active()) break; + out[f] += voice_.renderFrame(); + } +} + +void PreviewCard::render(AudioSample* left, AudioSample* right, std::size_t frameCount) { + if (left == nullptr || right == nullptr || frameCount == 0 || !voice_.active()) return; + for (std::size_t f = 0; f < frameCount; ++f) { + if (!voice_.active()) break; + AudioSample l = 0.0f, r = 0.0f; + voice_.renderFrameStereo(l, r); + left[f] += l; + right[f] += r; + } +} + } // namespace reasampler diff --git a/src/vst/sampler_core.h b/src/vst/sampler_core.h index adee55c..2207a84 100644 --- a/src/vst/sampler_core.h +++ b/src/vst/sampler_core.h @@ -17,6 +17,7 @@ // S2 seam fields (root note, loop points) enter as plain int / frame-index inputs; the // core does no file I/O — it is handed decoded sample frames and produces audio frames. +#include #include #include #include @@ -35,6 +36,30 @@ namespace reasampler { // itself never branches on it — the mode only picks which render overload the shell drives. enum class ChannelMode { Mono, Stereo }; +// The instrument's per-instance VOICE MODE (Phase S voice redesign). POLY is today's +// polyphonic engine (fixed pool + bounded stealing); MONO is a single voice with LAST-NOTE +// priority over a held-note stack (classic mono synth: a new note takes the voice over; the +// release of the top note falls back to the most-recent still-held note). A PERFORMANCE +// choice the instrument owns (component state), never a bank fact. Default Poly preserves +// current behavior. +enum class VoiceMode { Poly, Mono }; + +// How a MONO takeover treats the envelopes (Phase S — Daniel: explicitly toggleable). +// RETRIGGER restarts the amplitude (and pitch) envelope on every new mono note. LEGATO keeps +// the envelope running when a note is taken over while another is held — pitch moves without +// a re-attack (and the fallback on top-note release glides back the same way). Legato applies +// only to a SAME-SAMPLE takeover: crossing into a zone playing a different sample restarts +// the voice (one read head cannot glide between two PCM streams; a re-attack on a sample +// change is the deterministic, documented fallback). Meaningless in Poly. Default Retrigger. +enum class MonoTrigger { Retrigger, Legato }; + +// The user-parameterized polyphony bound (Phase S): a per-instance persisted voice count. +// One spelling shared by the engine, the component-state (de)serializer, and the editor's +// control so the range can never drift apart. Default 16 == the pre-Phase-S fixed pool. +inline constexpr int kMinVoiceCount = 1; +inline constexpr int kMaxVoiceCount = 32; +inline constexpr int kDefaultVoiceCount = 16; + // --------------------------------------------------------------------------- // S15/S16 per-zone play PARAMETERS (plain data). Defined up here (before SampleData) because // SampleData carries a ZonePlayParams by value — a voice reads it at start(). The matching @@ -379,14 +404,35 @@ public: // 1.0 (the default) is standard 12-tone-ET, bit-identical to the pre-S-VIEW-6 baseRatio_. // `velocityCurve` (S-VIEW-9) maps the note-on velocity to the voice's amp gain, evaluated ONCE // here (off the per-frame path); defaults to flat y=1 (R10-F1) — every velocity plays at unity. + // `unityVarispeedBypass` (Phase S, re-scoping FA1): when TRUE, a Preserve voice started at + // UNITY shift (baseRatio_ == 1.0, pitch env off) is demoted to the Varispeed read path — at + // unity the two engines are byte-identical except the OLA shifter's structural half-window + // onset delay, which buys nothing when there is no shift to preserve duration against. The + // PREVIEW card opts in (it fires at the root, so this is its zero-added-latency path); the + // MIDI VoiceEngine does NOT (default false) — a chromatic line must not step ~25 ms faster + // at the root note than one semitone away (the FA1-review timing-step finding). void start(int note, int velocity, const SampleData& sample, int rootNote, double keyTrack = 1.0, - const vst::VelocityCurve& velocityCurve = vst::VelocityCurve::flat()); + const vst::VelocityCurve& velocityCurve = vst::VelocityCurve::flat(), + bool unityVarispeedBypass = false); + + // MONO LEGATO takeover (Phase S): re-pitch this ACTIVE voice to `note` without touching the + // amplitude envelope, the read position, or the shifter state — pitch moves, no re-attack. + // Both engines pick the new baseRatio_ up on the next frame (Varispeed via the read rate, + // Preserve via the per-frame setShiftRatio). No-op on an idle voice. The caller guarantees + // the voice is playing the SAME SampleData the (note-resolved) zone names — a cross-sample + // takeover must restart the voice instead (see MonoTrigger). + void retune(int note, int rootNote, double keyTrack = 1.0); // Gate off — begins the amplitude release. In GATE mode this enters the AHDSR release; in // TRIGGER mode it is a NO-OP (Trigger ignores note-off and plays through to its play length). void release(); + // HARD STOP — CC 120 (All Sounds Off) semantics. Immediately silences this voice regardless + // of play mode: sets active_ = false with no release ramp. Stops a ringing Trigger one-shot + // instantly (which release() cannot do). RT-safe: no allocation, no lock. + void hardStop(); + // True while this voice is producing (or about to produce) sound. bool active() const { return active_; } // The note this voice was started on (for note-off routing). Meaningless if idle. @@ -397,8 +443,15 @@ public: void setStartOrder(std::uint64_t order) { startOrder_ = order; } bool releasing() const { return releasing_; } // The S16 pitch engine this voice is running (for the engine's Preserve-voice tally). Only - // meaningful while active(). + // meaningful while active(). NOTE (Phase S re-scope of FA1): the unity-shift demotion to + // Varispeed is now OPT-IN via start()'s unityVarispeedBypass — only the preview card takes + // it; a MIDI Preserve voice keeps its shifter at every note so a chromatic line has one + // uniform onset (no ~25 ms step at the root). PitchEngine pitchEngine() const { return pitchEngine_; } + // The SampleData this voice is playing (nullptr when never started). The engine's mono + // legato path compares it against the new note's resolved sample — a same-sample takeover + // retunes; a cross-sample one restarts. Identity only; callers never mutate through it. + const SampleData* playingSample() const { return sample_; } // Pre-SIZE this voice's Preserve pitch shifters (both channels) to `windowFrames`, OFF the // audio thread (this allocates). The engine calls it once at construction so start() — which @@ -497,8 +550,17 @@ public: // Varispeed-only instrument pays no ring cost). The processor derives it from the host // sample rate (kPreserveWindowMs). Defaulted so existing callers (and the pure-core tests) // are unaffected. + // + // `voiceMode` (Phase S): POLY is the pool-with-stealing engine above; MONO drives a single + // voice (voices_[0]) with last-note priority over the held-note stack, per `monoTrigger` + // (Retrigger restarts the envelopes on every takeover/fallback; Legato retunes a same-sample + // takeover without a re-attack). Both default to today's behavior (Poly / Retrigger). The + // engine's config is immutable — a mode/count change rebuilds the engine off-thread through + // the processor's drain-slot reload, so ringing tails survive the swap. VoiceEngine(std::size_t maxVoices, const Keymap& keymap, - std::size_t preserveVoiceCap = 0, std::int64_t preserveWindowFrames = 0); + std::size_t preserveVoiceCap = 0, std::int64_t preserveWindowFrames = 0, + VoiceMode voiceMode = VoiceMode::Poly, + MonoTrigger monoTrigger = MonoTrigger::Retrigger); // MIDI note-on. Resolves the note+velocity to a zone; if none matches (out of // zone) it is a defined no-op (no voice consumed). Otherwise allocates a free @@ -511,6 +573,19 @@ public: // the older tail to ring — matches hardware behavior). No-op if none match. void noteOff(int note); + // CC 123 — MIDI All-Notes-Off: clears the MONO held stack and RELEASES every active voice + // (Gate voices enter their AHDSR release tail; Trigger one-shots ignore release and play + // through their bounded play length). This is the mono stack's ONLY reset path — a phantom + // entry left by a lost note-off would otherwise be resurrected by the fallback and sustain + // forever with no key held. RT-safe (no allocation, bounded by maxVoices). + void allNotesOff(); + + // CC 120 — MIDI All-Sounds-Off: hard-stops EVERY voice immediately (active_ = false, no + // release ramp), clears the MONO held stack, and silences even Trigger one-shots that would + // ignore a release. Use for panic; CC 123 for the softer "let gates release" behavior. + // RT-safe (no allocation, bounded by maxVoices); callable from the audio thread. + void allSoundsOff(); + // REAL-TIME render (S4): sums all active voices into the caller-provided buffer // `out[0..frameCount)`, ADDING to whatever is there (the caller clears or mixes — // this never touches memory it does not own and NEVER allocates). This is the @@ -552,10 +627,86 @@ private: // (cheap: bounded by maxVoices) rather than maintained as a running tally. std::size_t activePreserveVoices() const; + // --- MONO mode (Phase S): last-note priority over a held-note stack ------------ + // The stack holds every currently-held, ZONE-RESOLVING note in press order (top = most + // recent = the sounding note while the voice is gated). An out-of-zone note never joins + // (it cannot sound, so it must not later take the voice back on a fallback). Re-pressing + // a held note moves it to the top. Fixed-capacity (128 distinct MIDI notes) — no + // allocation on the audio thread. Velocity is kept per held note so a RETRIGGER fallback + // re-strikes the fallen-back-to note at ITS original velocity. + struct HeldNote { std::uint8_t note; std::uint8_t velocity; }; + + // Mono note-on: push to the stack and take the voice over (legato retune on a same-sample + // takeover, else a fresh start). Returns 0 (the mono voice) or kNoVoice for out-of-zone + // or out-of-range (note outside [0,127] — rejected BEFORE the stack, which stores uint8). + // The S16 Preserve cap is NOT applied in mono — a single voice runs at most one shifter, + // inherently within any cap; applying it would wrongly drop a Preserve->Preserve takeover. + std::size_t monoNoteOn(int note, int velocity); + // Mono note-off: pop from the stack; if the released note was sounding, fall back to the + // most-recent still-held note (retrigger or legato per monoTrigger_), else release. + void monoNoteOff(int note); + // Drops `note` from the held stack (order of the remaining notes preserved). No-op if absent. + void removeHeld(int note); + std::vector voices_; const Keymap& keymap_; std::size_t preserveVoiceCap_ = 0; // S16: max simultaneous Preserve voices (0 = no separate cap) std::uint64_t nextStartOrder_ = 1; // monotonic; 0 reserved for "never started" + VoiceMode voiceMode_ = VoiceMode::Poly; + MonoTrigger monoTrigger_ = MonoTrigger::Retrigger; + std::array heldStack_{}; // mono held notes, press order; top = heldCount_-1 + std::size_t heldCount_ = 0; +}; + +// --------------------------------------------------------------------------- +// PREVIEW VOICE CARD (Phase S). A dedicated single voice ENTIRELY ISOLATED from the MIDI +// VoiceEngine pool: the editor's preview trigger routes ONLY here, host MIDI ONLY to the +// engine, and the two are summed by the shell — neither can steal from, drop, or cap the +// other (the FA1 "preview dropped when voices are full" bug is structurally impossible). +// +// The card plays the loaded zone through its REAL params (the same Keymap resolution and +// Voice machinery — you hear the actual sound), but with the FA1 unity-Varispeed bypass +// OPTED IN: the preview fires at the effective root (unity shift), where the Preserve +// shifter's half-window onset delay buys nothing, so the preview speaks on frame one. A +// transposed preview (if ever fired off-root) keeps the genuine shifter path — the +// shifters are pre-sized at construction (off-thread), so noteOn stays RT-safe. +// +// PLAYBACK ONLY (load-bearing principle): the card never captures, never writes the bank, +// never inserts a timeline item. Pure — no VST3/REAPER types; the shell owns the mailbox +// cadence and the output summation. +// --------------------------------------------------------------------------- + +class PreviewCard { +public: + // `keymap` must outlive the card (same lifetime contract as VoiceEngine — both live on + // the shell's LoadedInstrument next to the Keymap they read). `preserveWindowFrames` + // pre-sizes the voice's Preserve shifters off-thread (0/1 = pass-through), mirroring the + // engine's constructor, so an off-root Preserve preview never allocates at note-on. + explicit PreviewCard(const Keymap& keymap, std::int64_t preserveWindowFrames = 0); + + // Fire the preview note (RT-safe: no allocation). A new preview replaces the ringing one + // (single voice — the card is one finger, not a pool). Out-of-zone is a defined no-play. + void noteOn(int note, int velocity); + // Release the preview IF `note` is the one sounding (a stale off for a replaced note is a + // no-op). Gate zones enter release; Trigger zones ignore note-off and play through. + void noteOff(int note); + // CC 123 peer of VoiceEngine::allNotesOff: release the ringing preview UNCONDITIONALLY, + // whatever note it is on. Gate enters release; Trigger plays through (bounded). RT-safe. + void releaseAll(); + // CC 120 peer of VoiceEngine::allSoundsOff: HARD-STOP the preview immediately (no release + // ramp, silences Trigger one-shots too). RT-safe. + void hardStop(); + + bool active() const { return voice_.active(); } + + // Sum the card's contribution into the caller's buffer(s), ADDING (mirror of the engine's + // RT render contract — no allocation, no lock; null/zero-count is a no-op). + void render(AudioSample* out, std::size_t frameCount); + void render(AudioSample* left, AudioSample* right, std::size_t frameCount); + +private: + Voice voice_; + const Keymap& keymap_; }; } // namespace reasampler diff --git a/tests/test_sample_map.cpp b/tests/test_sample_map.cpp index a25d818..f5e2aa8 100644 --- a/tests/test_sample_map.cpp +++ b/tests/test_sample_map.cpp @@ -1105,6 +1105,121 @@ static void testComponentStateV6TruncatedVelocity() { CHECK(back.selectionId.empty() && back.map.zones.empty()); } +// --- v7 component state: the Phase S voice-system fields (count / mode / trigger) ------------- + +static void testComponentStateVoiceSystemRoundTrip() { + // Non-default values on all three fields prove the bytes are read back, not defaulted; the + // envelope neighbours (mode, marker, velocity, selection, zones) ride alongside intact. + ComponentState s; + s.selectionId = "pick"; + s.channelMode = ChannelMode::Stereo; + s.lastConsumedAssignGeneration = 42; + s.previewVelocity = 99; + s.voiceCount = 5; + s.voiceMode = VoiceMode::Mono; + s.monoTrigger = MonoTrigger::Legato; + s.map.zones.push_back(zone("z0", 0, 127, /*override=*/std::nullopt)); + const ComponentState back = deserializeComponentState(serializeComponentState(s), 44100.0); + CHECK(back.voiceCount == 5); + CHECK(back.voiceMode == VoiceMode::Mono); + CHECK(back.monoTrigger == MonoTrigger::Legato); + CHECK(back.channelMode == ChannelMode::Stereo); + CHECK(back.lastConsumedAssignGeneration == 42); + CHECK(back.previewVelocity == 99); + CHECK(back.selectionId == "pick"); + CHECK(back.map.zones.size() == 1 && back.map.zones[0].sampleId == "z0"); +} + +static void testComponentStateVoiceDefaultsRoundTrip() { + // A default-constructed state carries {16, Poly, Retrigger} — the pre-Phase-S behavior — + // and round-trips it. Locks the constants the engine + editor share. + const ComponentState back = + deserializeComponentState(serializeComponentState(ComponentState{}), 44100.0); + CHECK(back.voiceCount == kDefaultVoiceCount); + CHECK(kDefaultVoiceCount == 16 && kMinVoiceCount == 1 && kMaxVoiceCount == 32); + CHECK(back.voiceMode == VoiceMode::Poly); + CHECK(back.monoTrigger == MonoTrigger::Retrigger); +} + +static void testComponentStateVoiceCountExtremesRoundTrip() { + // Both range edges survive the single-byte field exactly. + for (int vc : {kMinVoiceCount, kMaxVoiceCount}) { + ComponentState s; + s.voiceCount = vc; + const ComponentState back = deserializeComponentState(serializeComponentState(s), 44100.0); + CHECK(back.voiceCount == vc); + } +} + +static void testComponentStateVoiceCountWriterClamps() { + // The WRITER never emits an out-of-range byte: above-max clamps to max; a nonsensical + // below-min value (a programming error upstream) falls back to the default. + ComponentState hi; + hi.voiceCount = 99; + CHECK(deserializeComponentState(serializeComponentState(hi), 44100.0).voiceCount == + kMaxVoiceCount); + ComponentState lo; + lo.voiceCount = 0; + CHECK(deserializeComponentState(serializeComponentState(lo), 44100.0).voiceCount == + kDefaultVoiceCount); +} + +static void testComponentStateV6LiftsVoiceDefaults() { + // A GENUINE v6 blob (version tag 6: mode, marker, velocity, id, zones — NO voice bytes) + // lifts to the Phase S voice defaults {16, Poly, Retrigger}, its other fields intact. + // Hand-built (serializeComponentState now emits v7, so it cannot make a v6 blob). This + // proves an already-saved pre-Phase-S instance restores playing exactly as it did. + std::vector v6; + v6.push_back(6); v6.push_back(0); v6.push_back(0); v6.push_back(0); // version 6 + v6.push_back(1); // channel mode = stereo + for (int i = 0; i < 8; ++i) v6.push_back(0); // marker = 0 + v6.push_back(111); // preview velocity + const std::string id = "saved"; + v6.push_back(static_cast(id.size())); v6.push_back(0); v6.push_back(0); v6.push_back(0); + v6.insert(v6.end(), id.begin(), id.end()); + v6.push_back(0); v6.push_back(0); v6.push_back(0); v6.push_back(0); // zone count 0 + const ComponentState back = deserializeComponentState(v6, 44100.0); + CHECK(back.voiceCount == kDefaultVoiceCount); + CHECK(back.voiceMode == VoiceMode::Poly); + CHECK(back.monoTrigger == MonoTrigger::Retrigger); + CHECK(back.previewVelocity == 111); // the v6 byte still honored + CHECK(back.channelMode == ChannelMode::Stereo); + CHECK(back.selectionId == "saved"); + CHECK(back.map.zones.empty()); +} + +static void testComponentStateV7CorruptVoiceBytesFallBack() { + // Out-of-range voice bytes in a v7 blob fall back to each field's DEFAULT (the + // previewVelocity corrupt-byte precedent) — a corrupt blob never silences or distorts the + // instance to an edge the user never chose. Build v7 by serializing, then vandalize the + // three voice bytes in place (offsets: 4 version + 1 mode + 8 marker + 1 velocity = 14). + ComponentState s; + s.voiceCount = 7; + s.voiceMode = VoiceMode::Mono; + s.monoTrigger = MonoTrigger::Legato; + std::vector bytes = serializeComponentState(s); + bytes[14] = 0; // voice count 0: below kMinVoiceCount + bytes[15] = 7; // voice mode: not a legal {0,1} value + bytes[16] = 9; // mono trigger: not a legal {0,1} value + const ComponentState back = deserializeComponentState(bytes, 44100.0); + CHECK(back.voiceCount == kDefaultVoiceCount); + CHECK(back.voiceMode == VoiceMode::Poly); // non-1 mode byte -> Poly default + CHECK(back.monoTrigger == MonoTrigger::Retrigger); +} + +static void testComponentStateV7TruncatedVoiceBytes() { + // A v7 blob cut INSIDE the three voice bytes -> empty, defaults holding (bounded read). + std::vector t{7, 0, 0, 0, 1}; // version 7, mode byte + for (int i = 0; i < 8; ++i) t.push_back(0); // full marker + t.push_back(64); // velocity byte + t.push_back(16); // voice count only — + const ComponentState back = deserializeComponentState(t, 44100.0); // mode/trigger cut + CHECK(back.voiceCount == kDefaultVoiceCount); + CHECK(back.voiceMode == VoiceMode::Poly); + CHECK(back.monoTrigger == MonoTrigger::Retrigger); + CHECK(back.selectionId.empty() && back.map.zones.empty()); +} + // --- MERGE COMPOSITION (S9 v5 marker envelope x S15/S16 v3 play-param payload) ---------------- // // The merge of ps-w9-t1-sync (envelope v5, adds the consumed-assignment marker) and @@ -1419,6 +1534,50 @@ static void testVelocityCurveResolvesToZone() { CHECK(r.zones[0].velocityCurve.equals(vst::VelocityCurve::linear())); } +// FA1 bug 3a — the COMPOSED end-to-end regression, mirroring the processor's reload composition +// exactly: an authored curve survives the component-state round-trip (the save/load seam), then +// resolvePerformance -> buildZonedKeymap -> VoiceEngine (constructed with a Preserve window, the +// DAW configuration) -> render, and the rendered level tracks velocity through the curve. This +// is the full pure slice of the click-to-sound path; only the bridge read + WAV decode (shell +// I/O) are outside it. A y=x curve at velocity 1 must be near-silent — NOT max volume. +static void testVelocityCurveEndToEndThroughReloadComposition() { + // 1. The instrument's own state: one full-keyboard zone with a LINEAR curve (the exact edit + // Daniel made), round-tripped through the v7 component-state wire (save -> load). + ComponentState s; + s.selectionId = "a"; + PerformanceZone z = zone("a", 0, 127); + z.velocityCurve = vst::VelocityCurve::linear(); + s.map.zones.push_back(z); + const ComponentState back = deserializeComponentState(serializeComponentState(s), 48000.0); + CHECK(back.map.zones.size() == 1); + if (back.map.zones.size() != 1) return; + + // 2. Resolve against a live bank blob (the shared bank_book parse, root 60 intrinsic). + const std::string json = bookJson({makeSample("a", "Kick", "reasampler_bank/a.wav", 60)}, {}); + const ResolvedPerformance rp = resolvePerformance(json, back.map); + CHECK(rp.zones.size() == 1); + if (rp.zones.size() != 1) return; + // The round-tripped zone still runs the PRESERVE product default (the DAW engine config). + CHECK(rp.zones[0].play.pitchEngine == PitchEngine::Preserve); + + // 3. Build the zoned keymap from decoded DC-1 PCM and play it through an engine constructed + // the way reloadFromBank constructs it (Preserve voices pre-sized to a real window). + auto steadyLevelAt = [&](int vel) -> double { + DecodedZonePcm pcm; + pcm.monoFrames.assign(4000, 1.0f); + pcm.sampleRate = 48000; + const Keymap km = buildZonedKeymap(rp.zones, {pcm}); + VoiceEngine eng(16, km, /*preserveCap=*/8, /*window=*/256); + eng.noteOn(62, vel); // transposed: the genuine OLA shifter path + std::vector out; + eng.render(out, 1000); + return static_cast(out[900]); // steady state (ring fully DC past the window) + }; + CHECK(approx(steadyLevelAt(127), 1.0)); + CHECK(approx(steadyLevelAt(64), 64.0 / 127.0)); + CHECK(steadyLevelAt(1) < 0.02); // velocity 1 through y=x: near-silent, never max volume +} + static void testVelocityCurveV6BackCompatLiftsToFlat() { // A v6 PAYLOAD blob (marker + version 6 + full play tail + keyTrack, but NO velocity-curve field) // lifts every zone to VelocityCurve::flat() (R10-F1 Option A — flat y=1). This is the DELIBERATE @@ -1822,6 +1981,7 @@ int main() { testVelocityCurveRoundTrip(); testVelocityCurveThroughComponentEnvelope(); testVelocityCurveResolvesToZone(); + testVelocityCurveEndToEndThroughReloadComposition(); testVelocityCurveV6BackCompatLiftsToFlat(); testPlayParamsV2BackCompatLiftsToDefaults(); testPlayParamsThroughComponentEnvelope(); @@ -1863,6 +2023,13 @@ int main() { testComponentStateV5LiftsVelocityToMid(); testComponentStateV4LiftsVelocityToMid(); testComponentStateV6TruncatedVelocity(); + testComponentStateVoiceSystemRoundTrip(); + testComponentStateVoiceDefaultsRoundTrip(); + testComponentStateVoiceCountExtremesRoundTrip(); + testComponentStateVoiceCountWriterClamps(); + testComponentStateV6LiftsVoiceDefaults(); + testComponentStateV7CorruptVoiceBytesFallBack(); + testComponentStateV7TruncatedVoiceBytes(); testV5EnvelopeWithMarkerAndPlayParamsRoundTrip(); testV4BlobWithPlayParamsLiftsMarkerZeroKeepsPlay(); testReconcileKeepsOnlySelectedFullRangeZone(); diff --git a/tests/test_sampler_core.cpp b/tests/test_sampler_core.cpp index 341aaf0..2ea67c7 100644 --- a/tests/test_sampler_core.cpp +++ b/tests/test_sampler_core.cpp @@ -19,6 +19,7 @@ #include "../src/vst/sampler_core.h" +#include #include #include #include @@ -1291,18 +1292,155 @@ static void testPreserveGateStereoLoopComposes() { } // --- Preserve voice cap: a Preserve note-on past the cap is dropped; Varispeed unaffected. --- +// Since the Phase S re-scope EVERY engine Preserve voice (root included) runs the shifter and +// counts toward the cap — the unity demotion is preview-card-only (see the Phase S section). static void testPreserveVoiceCap() { SampleData s = dcSample(2000, 60); s.play.pitchEngine = PitchEngine::Preserve; // held (Gate, no loop -> runs long enough) Keymap km = Keymap::singleSampleChromatic(std::move(s)); // 8 voices total, Preserve cap of 2. VoiceEngine eng(8, km, /*preserveCap=*/2, /*window=*/256); - CHECK(eng.noteOn(60, 127) != VoiceEngine::kNoVoice); // 1st Preserve voice - CHECK(eng.noteOn(62, 127) != VoiceEngine::kNoVoice); // 2nd Preserve voice (at the cap) + CHECK(eng.noteOn(62, 127) != VoiceEngine::kNoVoice); // 1st Preserve voice + CHECK(eng.noteOn(64, 127) != VoiceEngine::kNoVoice); // 2nd Preserve voice (at the cap) + CHECK(eng.noteOn(65, 127) == VoiceEngine::kNoVoice); // 3rd DROPPED by the Preserve cap + CHECK(eng.activeVoiceCount() == 2); +} + +// --------------------------------------------------------------------------- +// FA1 (re-scoped by Phase S) — the Preserve unity-Varispeed bypass now belongs to the PREVIEW +// CARD ONLY. The MIDI engine keeps the shifter at EVERY Preserve note so a chromatic line has +// one uniform onset (the FA1-review ~25 ms root-note timing-step finding); the card — always +// fired at the effective root, latency-critical, with no line to be uneven against — opts in +// and speaks on frame one. +// --------------------------------------------------------------------------- + +// The ENGINE'S root-note Preserve voice now keeps the OLA path: frame 0 is the shifter's fill +// (near-silent), full level once the ring fills — the SAME onset as its transposed neighbors. +// Pre-re-scope this voice was demoted and spoke at 1.0 on frame 0. +static void testPreserveUnityEngineVoiceKeepsUniformOnset() { + SampleData s = dcSample(4000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(1, km, /*preserveCap=*/0, /*window=*/512); + eng.noteOn(60, 127); // at root: unity shift — NO demotion in the MIDI engine + std::vector out; + eng.render(out, 1500); + double early = 0.0; + for (std::size_t i = 0; i < 8; ++i) { + early = (std::max)(early, static_cast(std::fabs(out[i]))); + } + CHECK(early < 0.1); // shifter onset, exactly like a transposed note + double late = 0.0; + for (std::size_t i = 600; i < 1500; ++i) { + late = (std::max)(late, static_cast(std::fabs(out[i]))); + } + CHECK(late > 0.9); // and the ring fills to full level +} + +// The PREVIEW CARD at unity speaks on frame ONE — the FA1 latency fix, now scoped to the card. +static void testPreviewCardUnitySpeaksImmediately() { + SampleData s = dcSample(2000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + s.play.adsr = flatAdsr(); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + PreviewCard card(km, /*preserveWindowFrames=*/512); + card.noteOn(60, 127); // at root: unity shift -> demoted inside the card, zero onset delay + std::vector buf(4, 0.0f); + card.render(buf.data(), buf.size()); + CHECK(approx(buf[0], 1.0, 1e-6)); // the DC sample, on the very first frame +} + +// keyTrack 0 collapses EVERY note to unity — an off-root preview also demotes, speaks at once. +static void testPreviewCardKeyTrackZeroAlsoSpeaksImmediately() { + SampleData s = dcSample(2000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + s.play.adsr = flatAdsr(); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + km.zones[0].keyTrack = 0.0; // no tracking: all keys play root pitch (unity) + PreviewCard card(km, /*preserveWindowFrames=*/512); + card.noteOn(67, 127); + std::vector buf(4, 0.0f); + card.render(buf.data(), buf.size()); + CHECK(approx(buf[0], 1.0, 1e-6)); +} + +// A TRANSPOSED preview keeps the genuine OLA path — the card's demotion is unity-ONLY. +static void testPreviewCardTransposedKeepsShifter() { + SampleData s = dcSample(4000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + s.play.adsr = flatAdsr(); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + PreviewCard card(km, /*preserveWindowFrames=*/512); + card.noteOn(62, 127); // +2 semitones: a real shift, NOT demoted + std::vector buf(8, 0.0f); + card.render(buf.data(), buf.size()); + double early = 0.0; + for (std::size_t i = 0; i < 8; ++i) { + early = (std::max)(early, static_cast(std::fabs(buf[i]))); + } + CHECK(early < 0.1); // shifter fill — duration preservation kept for off-root previews +} + +// A TRANSPOSED Preserve note keeps the genuine OLA path: onset is shifter-delayed (the inherent +// half-window cost of preserving duration) and the voice reaches full level once the ring fills. +// Also proves the demotion is unity-ONLY — the shifter still transposes off-root notes. +static void testPreserveTransposedVoiceKeepsOlaPath() { + SampleData s = dcSample(4000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(1, km, /*preserveCap=*/0, /*window=*/512); + eng.noteOn(62, 127); // +2 semitones: a real shift, NOT demoted + std::vector out; + eng.render(out, 1500); + // Early frames are the shifter's fill (near-silent) — the structural OLA onset. + double early = 0.0; + for (std::size_t i = 0; i < 8; ++i) { + early = (std::max)(early, static_cast(std::fabs(out[i]))); + } + CHECK(early < 0.1); + // Once the ring is full of the DC source (>= window frames in), output reaches the sample + // level (Hann taps partition unity, so DC passes at gain 1). + double late = 0.0; + for (std::size_t i = 600; i < 1500; ++i) { + late = (std::max)(late, static_cast(std::fabs(out[i]))); + } + CHECK(late > 0.9); +} + +// Phase S re-scope consequence: a ROOT-note engine Preserve voice keeps its shifter, so it +// COUNTS toward the Preserve cap like any other (pre-re-scope it was demoted and exempt). +static void testPreserveUnityVoiceCountsTowardCap() { + SampleData s = dcSample(2000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(8, km, /*preserveCap=*/2, /*window=*/256); + CHECK(eng.noteOn(60, 127) != VoiceEngine::kNoVoice); // root: a genuine Preserve voice now + CHECK(eng.noteOn(62, 127) != VoiceEngine::kNoVoice); // 2nd (at the cap) CHECK(eng.noteOn(64, 127) == VoiceEngine::kNoVoice); // 3rd DROPPED by the Preserve cap CHECK(eng.activeVoiceCount() == 2); } +// FA1 bug 3a regression, in the DAW's ACTUAL configuration: the velocity curve must drive the +// gain under the PRESERVE product-default engine with a CONFIGURED shifter window (every prior +// velocity test ran the bare Varispeed core). A linear y=x curve at velocity 1 must be +// near-silent — NOT max volume. +static void testVelocityCurveAppliesUnderPreserve() { + auto steadyLevelAt = [&](int vel) -> double { + SampleData s = dcSample(4000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + km.zones[0].velocityCurve = vst::VelocityCurve::linear(); + VoiceEngine eng(1, km, /*preserveCap=*/0, /*window=*/256); + eng.noteOn(62, vel); // transposed: the genuine shifter path (not the unity demotion) + std::vector out; + eng.render(out, 1000); + return static_cast(out[900]); // steady state: ring is fully DC by frame 256 + }; + CHECK(approx(steadyLevelAt(127), 1.0, 0.02)); + CHECK(approx(steadyLevelAt(64), 64.0 / 127.0, 0.02)); + CHECK(steadyLevelAt(1) < 0.02); // y=x at velocity 1: near-silent, the Daniel repro case +} + // --- Per-zone A/D/S/R actually reaches the voice envelope (S12). --- // // Every AHDSR field rides on SampleData.play.adsr (frames, resolved from the stored seconds at @@ -1353,6 +1491,457 @@ static void testZeroAdsrIsInstantSustain() { for (std::size_t i = 0; i < out.size(); ++i) CHECK(approx(out[i], 1.0, 1e-9)); } +// --------------------------------------------------------------------------- +// Phase S — parameterized voice count, MONO mode (last-note held stack, Retrigger/Legato), +// and the isolated PREVIEW CARD. +// --------------------------------------------------------------------------- + +// A DC sample at `level` with a flat (instant, fully-open) envelope — rendered output equals +// level * velocity gain, so WHICH sample is sounding is directly observable in the mix. +static SampleData dcLevelSample(std::size_t frames, float level, int rootNote) { + SampleData s; + s.frames.assign(frames, level); + s.rootNote = rootNote; + s.play.adsr = flatAdsr(); + return s; +} + +// Two-zone keymap with DISTINCT DC levels (0.25 / 0.75) so the mono tests can read which zone +// holds the voice off the rendered value: zone A = notes [40,59] root 50 -> 0.25; zone B = +// notes [60,80] root 70 -> 0.75. +static Keymap twoLevelKeymap() { + Keymap km; + km.samples.push_back(dcLevelSample(200000, 0.25f, 50)); + km.samples.push_back(dcLevelSample(200000, 0.75f, 70)); + KeyZone a; a.lowNote = 40; a.highNote = 59; a.rootNote = 50; a.sampleIndex = 0; + KeyZone b; b.lowNote = 60; b.highNote = 80; b.rootNote = 70; b.sampleIndex = 1; + km.zones.push_back(a); + km.zones.push_back(b); + return km; +} + +// The rendered value on the next frame — one-frame probe of "what is sounding right now". +static double probeFrame(VoiceEngine& eng) { + std::vector out; + eng.render(out, 1); + return static_cast(out[0]); +} + +// MONO last-note priority: a new note TAKES the single voice; releasing the top note falls +// back to the most-recent still-held note; releasing the last note gates off. Also: mono uses +// ONE voice regardless of the pool size. +static void testMonoLastNotePriorityAndFallback() { + Keymap km = twoLevelKeymap(); + VoiceEngine eng(4, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + CHECK(eng.noteOn(50, 127) == 0); // zone A sounds + CHECK(approx(probeFrame(eng), 0.25, 1e-6)); + CHECK(eng.noteOn(70, 127) == 0); // zone B TAKES the voice (last-note priority) + CHECK(eng.activeVoiceCount() == 1); // mono: one voice even with 4 in the pool + CHECK(approx(probeFrame(eng), 0.75, 1e-6)); + eng.noteOff(70); // top released -> FALLBACK to still-held 50 + CHECK(approx(probeFrame(eng), 0.25, 1e-6)); + eng.noteOff(50); // last finger up -> gate off (release 0 = instant) + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); + CHECK(eng.activeVoiceCount() == 0); +} + +// Releasing a LOWER held note (not the sounding one) changes nothing audible; the released +// note also leaves the stack, so the final note-off truly empties it. +static void testMonoReleaseOfLowerHeldNoteIsInaudible() { + Keymap km = twoLevelKeymap(); + VoiceEngine eng(4, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + eng.noteOn(50, 127); + eng.noteOn(70, 127); // 70 sounds, 50 held beneath + eng.noteOff(50); // releasing the buried note: inaudible + CHECK(approx(probeFrame(eng), 0.75, 1e-6)); + eng.noteOff(70); // 50 already left the stack -> silence, no fallback + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); +} + +// Re-pressing a HELD note moves it to the top of the stack (it sounds again), and the note +// beneath becomes the fallback. +static void testMonoRepressHeldNoteMovesToTop() { + Keymap km = twoLevelKeymap(); + VoiceEngine eng(4, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + eng.noteOn(50, 127); + eng.noteOn(70, 127); + CHECK(eng.noteOn(50, 127) == 0); // re-press while held: back on top + CHECK(approx(probeFrame(eng), 0.25, 1e-6)); + eng.noteOff(50); // falls back to 70 (now the most recent held) + CHECK(approx(probeFrame(eng), 0.75, 1e-6)); + eng.noteOff(70); + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); +} + +// A RETRIGGER fallback re-strikes the fallen-back-to note at ITS ORIGINAL velocity (kept per +// held note on the stack), not the departing note's. +static void testMonoRetriggerFallbackUsesOriginalVelocity() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + km.zones[0].velocityCurve = vst::VelocityCurve::linear(); // gain = velocity/127 + VoiceEngine eng(4, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + eng.noteOn(60, 32); // soft first note + CHECK(approx(probeFrame(eng), 32.0 / 127.0, 1e-4)); + eng.noteOn(64, 127); // loud takeover + CHECK(approx(probeFrame(eng), 1.0, 1e-6)); + eng.noteOff(64); // fallback re-strikes 60 at ITS velocity (32) + CHECK(approx(probeFrame(eng), 32.0 / 127.0, 1e-4)); +} + +// An OUT-OF-ZONE note in mono is a defined no-play: it consumes nothing, never joins the +// stack (so it can never take the voice back on a fallback), and its note-off is inert. +static void testMonoOutOfZoneNeverJoinsStack() { + Keymap km = twoLevelKeymap(); // zones cover [40,59] + [60,80] only + VoiceEngine eng(4, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + eng.noteOn(70, 127); + CHECK(eng.noteOn(20, 127) == VoiceEngine::kNoVoice); // out of every zone + CHECK(eng.activeVoiceCount() == 1); + CHECK(approx(probeFrame(eng), 0.75, 1e-6)); // 70 undisturbed + eng.noteOff(20); // inert + CHECK(approx(probeFrame(eng), 0.75, 1e-6)); + eng.noteOff(70); + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); +} + +// RETRIGGER restarts the amplitude envelope on a mono takeover: mid-attack level drops back +// to the ramp's origin when the new note takes the voice. +static void testMonoRetriggerRestartsEnvelope() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + s.play.adsr.attackFrames = 100; // slow linear attack: level at frame i = i/100 + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + eng.noteOn(60, 127); + std::vector out; + eng.render(out, 50); // mid-attack: level ~0.49 at frame 49 + CHECK(approx(out[49], 0.49, 1e-6)); + eng.noteOn(62, 127); // takeover: envelope RESTARTS + CHECK(approx(probeFrame(eng), 0.0, 1e-6)); // back at the attack origin +} + +// LEGATO keeps the envelope running through a same-sample takeover: pitch moves, NO re-attack. +static void testMonoLegatoContinuesEnvelope() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + s.play.adsr.attackFrames = 100; + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Legato); + eng.noteOn(60, 127); + std::vector out; + eng.render(out, 50); + CHECK(approx(out[49], 0.49, 1e-6)); + eng.noteOn(62, 127); // legato takeover: envelope KEEPS running + CHECK(approx(probeFrame(eng), 0.50, 1e-6)); // frame 50 of the SAME attack ramp +} + +// LEGATO retunes without restarting the read head, and the velocity gain stays the FIRST +// note's (a legato phrase is one gesture, one strike). Observed on a ramp sample: values +// continue from the current read position at the NEW pitch ratio; a soft second strike does +// not duck the level. +static void testMonoLegatoRetunesWithoutReadRestart() { + SampleData s; + s.frames.resize(200000); + for (std::size_t i = 0; i < s.frames.size(); ++i) { + s.frames[i] = static_cast(i); // ramp: output value == read position + } + s.rootNote = 60; + s.play.adsr = flatAdsr(); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + km.zones[0].velocityCurve = vst::VelocityCurve::linear(); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Legato); + eng.noteOn(60, 127); // unity: read advances 1/frame, full gain + std::vector out; + eng.render(out, 10); + CHECK(approx(out[9], 9.0, 1e-4)); + eng.noteOn(72, 1); // legato to +1 octave at a WHISPER velocity + CHECK(approx(probeFrame(eng), 10.0, 1e-3)); // read CONTINUES at 10 — no restart, gain kept + CHECK(approx(probeFrame(eng), 12.0, 1e-3)); // and now advances at ratio 2 (the new pitch) +} + +// LEGATO applies only to a SAME-SAMPLE takeover: crossing into a zone playing a DIFFERENT +// sample restarts the voice (one read head cannot glide between two PCM streams). +static void testMonoLegatoCrossSampleRestarts() { + Keymap km = twoLevelKeymap(); + km.samples[1].play.adsr.attackFrames = 100; // zone B has a slow attack to expose a restart + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Legato); + eng.noteOn(50, 127); // zone A (flat env): 0.25 at once + CHECK(approx(probeFrame(eng), 0.25, 1e-6)); + eng.noteOn(70, 127); // cross-sample: RESTART (attack from 0), no retune + CHECK(approx(probeFrame(eng), 0.0, 1e-6)); // zone B's fresh attack origin — not 0.25 held over +} + +// LEGATO after the last note was RELEASED re-attacks: a releasing voice's note has left the +// stack, so the next press is a fresh phrase, not a takeover. +static void testMonoLegatoAfterReleaseReattacks() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + s.play.adsr.attackFrames = 100; + s.play.adsr.releaseFrames = 1000; // long release keeps the voice audibly ringing + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Legato); + eng.noteOn(60, 127); + std::vector out; + eng.render(out, 150); // through the attack: at full level + eng.noteOff(60); // release begins (stack now empty) + out.clear(); + eng.render(out, 10); + eng.noteOn(62, 127); // a NEW phrase: re-attacks even in Legato + CHECK(approx(probeFrame(eng), 0.0, 1e-6)); // fresh attack origin, not the ringing level +} + +// MONO does not apply the S16 Preserve cap: a single voice runs at most one shifter — a +// Preserve->Preserve takeover must never be dropped by the cap. +static void testMonoIgnoresPreserveCap() { + SampleData s = dcSample(4000, 60); + s.play.pitchEngine = PitchEngine::Preserve; + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(4, km, /*preserveCap=*/1, /*window=*/256, + VoiceMode::Mono, MonoTrigger::Retrigger); + CHECK(eng.noteOn(62, 127) == 0); // 1st Preserve note: at the cap + CHECK(eng.noteOn(64, 127) == 0); // takeover NOT dropped (poly cap would drop it) + CHECK(eng.activeVoiceCount() == 1); +} + +// A ramp sample (output value == read position) so a re-attack (read restarts at 0) is +// directly distinguishable from a legato retune (read continues) on the rendered value. +static SampleData rampSample(std::size_t frames, int rootNote) { + SampleData s; + s.frames.resize(frames); + for (std::size_t i = 0; i < frames; ++i) s.frames[i] = static_cast(i); + s.rootNote = rootNote; + s.play.adsr = flatAdsr(); + return s; +} + +// MAJOR-1 regression: MONO+LEGATO with a TRIGGER zone RE-ATTACKS after the last key is up. +// Trigger ignores note-off (Voice::release() is a no-op, so releasing_ never latches), so a +// legato guard keyed on `active && !releasing` saw a ringing one-shot as "still held" and +// silently RETUNED it in place. The correct predicate is the HELD-STACK depth: with no other +// key down, the next note is a fresh phrase and must restart the read head. +static void testMonoLegatoTriggerReattacksAfterKeyUp() { + SampleData s = rampSample(200000, 60); + s.play.playMode = PlayMode::Trigger; // default TriggerParams: full length, no fades + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Legato); + eng.noteOn(60, 127); // unity: read advances 1/frame + std::vector out; + eng.render(out, 10); + eng.noteOff(60); // Trigger ignores the gate: keeps ringing... + CHECK(approx(probeFrame(eng), 10.0, 1e-4)); // ...read head still advancing past 10 + eng.noteOn(62, 127); // NO key held -> fresh phrase: RE-ATTACK + CHECK(approx(probeFrame(eng), 0.0, 1e-4)); // read RESTARTED at 0 (a retune would read ~11) + // And it is genuinely playing from the top at the new pitch (ratio 2^(2/12) ~ 1.1225), + // not merely silent: the next frame reads at the advanced position. + CHECK(approx(probeFrame(eng), std::pow(2.0, 2.0 / 12.0), 1e-3)); +} + +// Companion boundary: with another key STILL physically held, a same-sample Trigger takeover +// under Legato still RETUNES (read continues) — the held-stack predicate matches the old +// behavior everywhere except the ringing-but-unheld case above. +static void testMonoLegatoTriggerHeldKeyStillRetunes() { + SampleData s = rampSample(200000, 60); + s.play.playMode = PlayMode::Trigger; + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Legato); + eng.noteOn(60, 127); + std::vector out; + eng.render(out, 10); + eng.noteOn(62, 127); // 60 still held -> legato takeover + CHECK(approx(probeFrame(eng), 10.0, 1e-4)); // read CONTINUES at 10 — no re-attack +} + +// MAJOR-2: allNotesOff releases every gated poly voice (flat release -> instant silence). +static void testAllNotesOffReleasesPolyVoices() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(4, km); + eng.noteOn(60, 127); + eng.noteOn(62, 127); + eng.noteOn(64, 127); + CHECK(eng.activeVoiceCount() == 3); + eng.allNotesOff(); + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); // all gated off (release 0 = instant) + CHECK(eng.activeVoiceCount() == 0); +} + +// MAJOR-2, the STUCK-NOTE path: allNotesOff clears the mono held stack, so a phantom entry +// (simulating a LOST note-off) can never be resurrected by the fallback afterwards. +static void testAllNotesOffClearsMonoHeldStack() { + Keymap km = twoLevelKeymap(); + VoiceEngine eng(4, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + eng.noteOn(50, 127); // 50's note-off will never arrive (phantom) + eng.noteOn(70, 127); // 70 sounds, phantom 50 buried on the stack + eng.allNotesOff(); // PANIC + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); + CHECK(eng.activeVoiceCount() == 0); + // The stack is empty: a fresh press + release gates off cleanly, with NO fallback + // restart of the phantom (pre-fix, noteOff(70) here re-struck 50 -> 0.25 forever). + eng.noteOn(70, 127); + CHECK(approx(probeFrame(eng), 0.75, 1e-6)); + eng.noteOff(70); + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); + CHECK(eng.activeVoiceCount() == 0); +} + +// MAJOR-2 companion: the preview card's unconditional releaseAll (the panic peer). +static void testPreviewCardReleaseAll() { + Keymap km = twoLevelKeymap(); + PreviewCard card(km); + card.noteOn(70, 127); + CHECK(card.active()); + card.releaseAll(); // no note argument: quiets whatever rings + std::vector buf(1, 0.0f); + card.render(buf.data(), buf.size()); + CHECK(approx(buf[0], 0.0, 1e-9)); + CHECK(!card.active()); +} + +// CC 120 (allSoundsOff) hard-stops a ringing TRIGGER one-shot that would otherwise play to +// its bounded playEnd (minutes on a full-length capture). This is the primary repro: allNotesOff +// (CC 123) is a NO-OP on a Trigger voice — only allSoundsOff provides the actual hard stop. +static void testAllSoundsOffStopsTriggerOneShot() { + // A Trigger sample with a very long play length (all-1 DC, flat velocity). After noteOn the + // voice is active and ringing; allSoundsOff must silence it immediately. + SampleData s = dcLevelSample(200000, 1.0f, 60); + s.play.playMode = PlayMode::Trigger; + s.play.trigger.lengthFraction = 1.0; // full length — would ring for 200000 frames + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(1, km); + eng.noteOn(60, 127); + CHECK(eng.activeVoiceCount() == 1); + // CC 123 (release) must be a NO-OP on a Trigger voice — the one-shot plays through. + eng.allNotesOff(); + CHECK(eng.activeVoiceCount() == 1); // still ringing (Trigger ignores release) + std::vector out; + eng.render(out, 1); + CHECK(out[0] > 0.5f); // still sounding + // CC 120 (hard-stop) must silence it instantly. + eng.allSoundsOff(); + CHECK(eng.activeVoiceCount() == 0); // immediately idle + out.clear(); + eng.render(out, 1); + CHECK(approx(out[0], 0.0, 1e-9)); // silent +} + +// CC 123 (allNotesOff) still releases Gate voices — the existing release behavior is unchanged. +static void testAllNotesOffStillReleasesGateVoices() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + // Default Gate mode, instant release (releaseFrames 0). + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(4, km); + eng.noteOn(60, 127); + eng.noteOn(62, 127); + CHECK(eng.activeVoiceCount() == 2); + eng.allNotesOff(); + std::vector out; + eng.render(out, 1); + CHECK(approx(out[0], 0.0, 1e-9)); // Gate with 0-release: instant silence + CHECK(eng.activeVoiceCount() == 0); +} + +// MONO LEGATO same-note re-press (one-held-note edge case): with only that note on the +// stack, heldCount_ after the re-push is 1 (not >= 2), so it falls through to re-attack +// rather than retune. This is the correct fresh-phrase behavior documented in the comment. +static void testMonoLegatoSameNoteRepressReattacks() { + SampleData s = rampSample(200000, 60); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Legato); + eng.noteOn(60, 127); // first press; read starts at 0 + std::vector out; + eng.render(out, 10); // advance the read head to ~10 + // Re-press the SAME note while it is the only held note: heldCount_ after removeHeld+push = 1 + // -> does NOT satisfy heldCount_ >= 2 -> re-attack (not a legato retune). + eng.noteOn(60, 127); + CHECK(approx(probeFrame(eng), 0.0, 1e-4)); // read RESTARTED at 0 (re-attack, not retune) +} + +// GREEN: out-of-range notes are rejected at BOTH mono entry points. The held stack stores +// uint8, so an unguarded off for note 256 (== 0 mod 256) would alias-evict held note 0 — +// losing its fallback. Note-ons out of [0,127] are a defined no-play. +static void testMonoOutOfRangeNotesRejected() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km, 0, 0, VoiceMode::Mono, MonoTrigger::Retrigger); + CHECK(eng.noteOn(128, 127) == VoiceEngine::kNoVoice); + CHECK(eng.noteOn(-1, 127) == VoiceEngine::kNoVoice); + CHECK(eng.activeVoiceCount() == 0); + eng.noteOn(0, 127); // hold the aliasing target (note 0) + eng.noteOn(62, 127); // 62 takes the voice; 0 held beneath + eng.noteOff(256); // MUST NOT alias-evict held note 0 + eng.noteOff(-256); // likewise for the negative wrap + CHECK(approx(probeFrame(eng), 1.0, 1e-6)); // 62 undisturbed + eng.noteOff(62); // falls back to STILL-HELD note 0 + CHECK(approx(probeFrame(eng), 1.0, 1e-6)); // (alias-evicted pre-fix -> silence here) + eng.noteOff(0); + CHECK(approx(probeFrame(eng), 0.0, 1e-9)); +} + +// The user-parameterized polyphony bound: an N-voice engine holds exactly N simultaneous +// notes and steals (never grows) on the N+1th; 0 clamps to the documented 1-voice degenerate. +static void testVoiceCountBoundsPolyphony() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine e3(3, km); + CHECK(e3.maxVoices() == 3); + e3.noteOn(60, 127); + e3.noteOn(62, 127); + e3.noteOn(64, 127); + CHECK(e3.activeVoiceCount() == 3); + e3.noteOn(65, 127); // 4th: steals within the pool + CHECK(e3.activeVoiceCount() == 3); + + VoiceEngine e1(1, km); + e1.noteOn(60, 127); + e1.noteOn(62, 127); + CHECK(e1.activeVoiceCount() == 1); // 1-voice pool: every note steals the one voice + + VoiceEngine e0(0, km); + CHECK(e0.maxVoices() == 1); // documented degenerate: clamped to 1 +} + +// PREVIEW-CARD ISOLATION: the card never consumes a pool voice, a FULL pool never drops a +// preview, and pool stealing never touches the ringing preview. The two sum independently. +static void testPreviewCardIsolatedFromPool() { + SampleData s = dcLevelSample(200000, 1.0f, 60); + Keymap km = Keymap::singleSampleChromatic(std::move(s)); + VoiceEngine eng(2, km); + PreviewCard card(km); + eng.noteOn(60, 127); + eng.noteOn(62, 127); // the pool is now FULL + card.noteOn(64, 127); // preview fires anyway — its own voice + CHECK(eng.activeVoiceCount() == 2); // no pool voice consumed + CHECK(card.active()); + std::vector buf(4, 0.0f); + eng.render(buf.data(), buf.size()); // engine sums 2 voices... + card.render(buf.data(), buf.size()); // ...card ADDS its own on top + CHECK(approx(buf[0], 3.0, 1e-6)); + eng.noteOn(64, 127); // pool steals INTERNALLY... + CHECK(eng.activeVoiceCount() == 2); + CHECK(card.active()); // ...the preview is untouched + card.noteOff(64); // flat release: card gates off instantly + std::vector buf2(1, 0.0f); + card.render(buf2.data(), buf2.size()); + CHECK(approx(buf2[0], 0.0, 1e-9)); + CHECK(eng.activeVoiceCount() == 2); // and the pool never noticed +} + +// The card is ONE voice: a new preview replaces the ringing one, a STALE note-off (for the +// replaced note) is a no-op, and an out-of-zone preview is a defined no-play. +static void testPreviewCardReplaceStaleOffAndOutOfZone() { + Keymap km = twoLevelKeymap(); // zones [40,59] + [60,80] + PreviewCard card(km); + card.noteOn(50, 127); + card.noteOn(70, 127); // replaces the first preview + std::vector buf(1, 0.0f); + card.render(buf.data(), buf.size()); + CHECK(approx(buf[0], 0.75, 1e-6)); // zone B is what rings + card.noteOff(50); // STALE off for the replaced note: no-op + CHECK(card.active()); + card.noteOff(70); // the sounding note's off gates it (release 0) + std::vector buf2(1, 0.0f); + card.render(buf2.data(), buf2.size()); + CHECK(approx(buf2[0], 0.0, 1e-9)); + card.noteOn(20, 127); // out of every zone: defined no-play + CHECK(!card.active()); +} + int main() { testChromaticSingleRoot(); testZonedRangesBoundaries(); @@ -1409,10 +1998,45 @@ int main() { testPreserveGateStereoLoopComposes(); testPreserveVoiceCap(); + // FA1 (re-scoped by Phase S) — the unity bypass is preview-card-only; the engine keeps a + // uniform Preserve onset. Velocity under Preserve unchanged. + testPreserveUnityEngineVoiceKeepsUniformOnset(); + testPreviewCardUnitySpeaksImmediately(); + testPreviewCardKeyTrackZeroAlsoSpeaksImmediately(); + testPreviewCardTransposedKeepsShifter(); + testPreserveTransposedVoiceKeepsOlaPath(); + testPreserveUnityVoiceCountsTowardCap(); + testVelocityCurveAppliesUnderPreserve(); + // S12 review fix — per-zone A/D/S/R reaches the voice envelope. testPerZoneAdsrReachesVoiceEnvelope(); testZeroAdsrIsInstantSustain(); + // Phase S — voice count, MONO mode (held stack + Retrigger/Legato), preview card. + testMonoLastNotePriorityAndFallback(); + testMonoReleaseOfLowerHeldNoteIsInaudible(); + testMonoRepressHeldNoteMovesToTop(); + testMonoRetriggerFallbackUsesOriginalVelocity(); + testMonoOutOfZoneNeverJoinsStack(); + testMonoRetriggerRestartsEnvelope(); + testMonoLegatoContinuesEnvelope(); + testMonoLegatoRetunesWithoutReadRestart(); + testMonoLegatoCrossSampleRestarts(); + testMonoLegatoAfterReleaseReattacks(); + testMonoIgnoresPreserveCap(); + testMonoLegatoTriggerReattacksAfterKeyUp(); + testMonoLegatoTriggerHeldKeyStillRetunes(); + testAllNotesOffReleasesPolyVoices(); + testAllNotesOffClearsMonoHeldStack(); + testPreviewCardReleaseAll(); + testAllSoundsOffStopsTriggerOneShot(); + testAllNotesOffStillReleasesGateVoices(); + testMonoLegatoSameNoteRepressReattacks(); + testMonoOutOfRangeNotesRejected(); + testVoiceCountBoundsPolyphony(); + testPreviewCardIsolatedFromPool(); + testPreviewCardReplaceStaleOffAndOutOfZone(); + if (g_fail == 0) { std::printf("all sampler_core tests passed\n"); return 0;