Sampler.h

// DSPark - Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi - MIT License
 
#pragma once
 
#include "DspMath.h"
#include "AudioBuffer.h"
#include "AudioSpec.h"
#include "EnvelopeGenerator.h"
 
#include <algorithm>
#include <array>
#include <atomic>
#include <cmath>
#include <cstdint>
#include <memory>
#include <new>
#include <span>
#include <vector>
 
namespace dspark {
 
template <FloatType T>
class Sampler
{
public:
    enum class LoopMode
    {
        None,        
        Continuous,  
        Sustain      
    };
 
    struct ZoneSpec
    {
        AudioBufferView<const T> audio;  
        double sampleRate = 48000.0;     
        int rootKey = 60;                
        double tuneCents = 0.0;          
        int keyLow = 0;                  
        int keyHigh = 127;               
        double velocityLow = 0.0;        
        double velocityHigh = 1.0;       
        double gainDb = 0.0;             
        double pan = 0.0;                
        int64_t startOffset = 0;         
        LoopMode loopMode = LoopMode::None;
        int64_t loopStart = 0;           
        int64_t loopEnd = 0;             
        int64_t loopCrossfade = 0;       
        bool equalPowerCrossfade = false;
    };
 
    Sampler() = default;
    ~Sampler()
    {
        delete pending_.exchange(nullptr, std::memory_order_acq_rel);
        delete retired_.exchange(nullptr, std::memory_order_acq_rel);
        delete fading_;
        delete active_;
    }
    Sampler(const Sampler&) = delete;
    Sampler& operator=(const Sampler&) = delete;
 
    // -- Lifecycle ---------------------------------------------------------------
 
    void prepare(const AudioSpec& spec, int maxVoices = 32)
    {
        if (!(spec.sampleRate > 0.0) || !std::isfinite(spec.sampleRate) || spec.numChannels < 1)
            return;
        sampleRate_ = spec.sampleRate;
        polyphony_ = std::clamp(maxVoices, 1, 256);
        voices_.assign(static_cast<size_t>(polyphony_ + polyphony_ / 4 + 2), Voice {});
        for (auto& v : voices_)
        {
            v.env.prepare(sampleRate_);
            for (auto& a : v.acc) a.assign(static_cast<size_t>(kAccLength), T(0));
        }
        weights_.assign(static_cast<size_t>(2 * kMaxHalfTaps + 2), T(0));
        (void)polyphaseTable();   // build the shared tables here, never on the audio thread
        stealFadeSamples_ = std::max(1, static_cast<int>(std::lround(0.003 * sampleRate_)));
        reset();
        prepared_ = true;
    }
 
    void reset() noexcept
    {
        for (auto& v : voices_) { v.active = false; v.env.reset(); }
        eventCount_ = 0;
        sustainPedal_ = false;
        pitchBend_ = 0.0;
        activeVoices_.store(0, std::memory_order_relaxed);
    }
 
    // -- Zones (control thread) --------------------------------------------------
 
    bool setZones(std::span<const ZoneSpec> zones)
    {
        reclaim();
        auto set = std::make_unique<ZoneSet>();
        set->zones.reserve(zones.size());
        for (const ZoneSpec& z : zones)
        {
            ZoneData d;
            if (!buildZone(z, d)) return false;
            set->zones.push_back(std::move(d));
        }
        publish(set.release());
        return true;
    }
 
    bool loadSample(AudioBufferView<const T> audio, double sampleRate, int rootKey = 60)
    {
        ZoneSpec z;
        z.audio = audio;
        z.sampleRate = sampleRate;
        z.rootKey = rootKey;
        return setZones(std::span<const ZoneSpec>(&z, 1));
    }
 
    void clearZones() { reclaim(); publish(new ZoneSet {}); }
 
    // -- Parameters (any thread) --------------------------------------------------
 
    void setEnvelope(T attackMs, T decayMs, T sustain, T releaseMs) noexcept
    {
        if (!std::isfinite(attackMs) || !std::isfinite(decayMs)
            || !std::isfinite(sustain) || !std::isfinite(releaseMs)) return;
        attackMs_.store(std::max(0.01, static_cast<double>(attackMs)), std::memory_order_relaxed);
        decayMs_.store(std::max(0.01, static_cast<double>(decayMs)), std::memory_order_relaxed);
        sustain_.store(std::clamp(static_cast<double>(sustain), 0.0, 1.0), std::memory_order_relaxed);
        releaseMs_.store(std::max(0.01, static_cast<double>(releaseMs)), std::memory_order_relaxed);
    }
 
    void setVelocityRange(T rangeDb) noexcept
    {
        if (!std::isfinite(rangeDb)) return;
        velocityRangeDb_.store(std::clamp(static_cast<double>(rangeDb), 0.0, 96.0),
                               std::memory_order_relaxed);
    }
 
    void setGain(T dB) noexcept
    {
        if (!std::isfinite(dB)) return;
        outputGain_.store(std::pow(10.0, std::clamp(static_cast<double>(dB), -120.0, 24.0) / 20.0),
                          std::memory_order_relaxed);
    }
 
    // -- Events (audio thread) ----------------------------------------------------
 
    void noteOn(int key, T velocity, int offset = 0) noexcept
    {
        if (!std::isfinite(velocity)) return;
        if (velocity <= T(0)) { noteOff(key, offset); return; }
        push({ EventType::NoteOn, std::clamp(key, 0, 127),
               std::clamp(static_cast<double>(velocity), 0.0, 1.0), offset });
    }
 
    void noteOff(int key, int offset = 0) noexcept
    {
        push({ EventType::NoteOff, std::clamp(key, 0, 127), 0.0, offset });
    }
 
    void setSustainPedal(bool down, int offset = 0) noexcept
    {
        push({ EventType::Pedal, 0, down ? 1.0 : 0.0, offset });
    }
 
    void setPitchBend(T semitones, int offset = 0) noexcept
    {
        if (!std::isfinite(semitones)) return;
        push({ EventType::Bend, 0, std::clamp(static_cast<double>(semitones), -48.0, 48.0), offset });
    }
 
    void allNotesOff(int offset = 0) noexcept
    {
        push({ EventType::AllOff, 0, 0.0, offset });
    }
 
    // -- Processing (audio thread) -------------------------------------------------
 
    void processBlock(AudioBufferView<T> out) noexcept
    {
        const int n = out.getNumSamples();
        const int nCh = out.getNumChannels();
        for (int c = 0; c < nCh; ++c)
            std::fill_n(out.getChannel(c), n, T(0));
        if (!prepared_ || n <= 0) { eventCount_ = 0; return; }
 
        adoptPending();
 
        int cursor = 0;
        for (int e = 0; e < eventCount_; ++e)
        {
            const int at = std::clamp(events_[static_cast<size_t>(e)].offset, 0, n);
            if (at > cursor) { render(out, cursor, at); cursor = at; }
            apply(events_[static_cast<size_t>(e)]);
        }
        eventCount_ = 0;
        if (cursor < n) render(out, cursor, n);
 
        const double g = outputGain_.load(std::memory_order_relaxed);
        if (g != 1.0)
            for (int c = 0; c < std::min(nCh, 2); ++c)
            {
                T* d = out.getChannel(c);
                for (int i = 0; i < n; ++i) d[i] = static_cast<T>(d[i] * g);
            }
 
        retireFadedSet();
        int count = 0;
        for (const auto& v : voices_) count += v.active ? 1 : 0;
        activeVoices_.store(count, std::memory_order_relaxed);
    }
 
    [[nodiscard]] int getActiveVoiceCount() const noexcept
    {
        return activeVoices_.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] int getPolyphony() const noexcept { return polyphony_; }
 
private:
    // -- Interpolation kernel -------------------------------------------------------
 
    static constexpr int kHalfTaps = 32;
    static constexpr int kTablePerUnit = 2048;
    static constexpr double kMaxRate = 8.0;
    static constexpr int kMaxHalfTaps = static_cast<int>(kHalfTaps * kMaxRate);
    static constexpr double kCutoff = 0.9;
    static constexpr double kBeta = 10.06;
 
    static const std::vector<double>& kernelTable()
    {
        static const std::vector<double> table = [] {
            std::vector<double> t(static_cast<size_t>(kHalfTaps * kTablePerUnit + 2), 0.0);
            auto i0 = [](double x) {
                double sum = 1.0, term = 1.0;
                for (int k = 1; k < 64; ++k)
                {
                    term *= (x / (2.0 * k)) * (x / (2.0 * k));
                    sum += term;
                    if (term < sum * 1e-17) break;
                }
                return sum;
            };
            const double norm = i0(kBeta);
            for (size_t j = 0; j + 1 < t.size(); ++j)
            {
                const double x = static_cast<double>(j) / kTablePerUnit;
                if (x >= kHalfTaps) break;
                const double arg = pi<double> * kCutoff * x;
                const double sinc = (x == 0.0) ? 1.0 : std::sin(arg) / arg;
                const double r = x / kHalfTaps;
                t[j] = kCutoff * sinc * i0(kBeta * std::sqrt(std::max(0.0, 1.0 - r * r))) / norm;
            }
            return t;
        }();
        return table;
    }
 
    static constexpr int kPhases = 2048;
    static constexpr int kTaps = 2 * kHalfTaps;
 
    static const std::vector<T>& polyphaseTable()
    {
        static const std::vector<T> rows = [] {
            const auto& h = kernelTable();
            std::vector<T> r(static_cast<size_t>((kPhases + 1) * kTaps), T(0));
            for (int q = 0; q <= kPhases; ++q)
                for (int t = 0; t < kTaps; ++t)
                {
                    // |k - frac| in table units, exactly: (t - 31) * P - q.
                    const long u = std::labs(static_cast<long>(t - (kHalfTaps - 1)) * kTablePerUnit - q);
                    r[static_cast<size_t>(q * kTaps + t)] =
                        (static_cast<size_t>(u) < h.size()) ? static_cast<T>(h[static_cast<size_t>(u)]) : T(0);
                }
            return r;
        }();
        return rows;
    }
 
    // -- Zones -----------------------------------------------------------------------
 
    struct ZoneData
    {
        std::vector<T> audio;        
        std::vector<T> baked;        
        int channels = 0;
        int64_t length = 0;
        double sampleRate = 48000.0;
        int rootKey = 60;
        double tuneCents = 0.0;
        int keyLow = 0, keyHigh = 127;
        double velLow = 0.0, velHigh = 1.0;
        double gain = 1.0;
        double pan = 0.0;
        int64_t start = 0;
        LoopMode loop = LoopMode::None;
        int64_t loopStart = 0, loopEnd = 0, xfade = 0;
    };
 
    struct ZoneSet { std::vector<ZoneData> zones; };
 
    static bool buildZone(const ZoneSpec& z, ZoneData& d)
    {
        const int ch = z.audio.getNumChannels();
        const int64_t len = z.audio.getNumSamples();
        if (ch < 1 || len < 1 || !(z.sampleRate > 0.0) || !std::isfinite(z.sampleRate))
            return false;
        for (int c = 0; c < ch; ++c)
            if (z.audio.getChannel(c) == nullptr) return false;
        if (z.keyLow > z.keyHigh || z.velocityLow > z.velocityHigh
            || !std::isfinite(z.tuneCents) || !std::isfinite(z.gainDb) || !std::isfinite(z.pan))
            return false;
 
        d.channels = ch;
        d.length = len;
        d.sampleRate = z.sampleRate;
        d.rootKey = z.rootKey;
        d.tuneCents = z.tuneCents;
        d.keyLow = std::clamp(z.keyLow, 0, 127);
        d.keyHigh = std::clamp(z.keyHigh, 0, 127);
        d.velLow = std::clamp(z.velocityLow, 0.0, 1.0);
        d.velHigh = std::clamp(z.velocityHigh, 0.0, 1.0);
        d.gain = std::pow(10.0, std::clamp(z.gainDb, -120.0, 24.0) / 20.0);
        d.pan = std::clamp(z.pan, -1.0, 1.0);
        d.start = std::clamp<int64_t>(z.startOffset, 0, len - 1);
        d.audio.resize(static_cast<size_t>(ch) * static_cast<size_t>(len));
        for (int c = 0; c < ch; ++c)
        {
            const T* src = z.audio.getChannel(c);
            T* dst = d.audio.data() + static_cast<size_t>(c) * static_cast<size_t>(len);
            for (int64_t i = 0; i < len; ++i)
                dst[i] = std::isfinite(src[i]) ? src[i] : T(0);
        }
 
        d.loop = z.loopMode;
        d.loopStart = std::clamp<int64_t>(z.loopStart, 0, len);
        d.loopEnd = std::clamp<int64_t>(z.loopEnd, 0, len);
        if (d.loop != LoopMode::None && d.loopEnd - d.loopStart < 2)
            d.loop = LoopMode::None;
        if (d.loop == LoopMode::None) return true;
 
        d.xfade = std::clamp<int64_t>(z.loopCrossfade, 0,
                                      std::min(d.loopStart, d.loopEnd - d.loopStart));
        if (d.xfade > 0)
        {
            d.baked.resize(static_cast<size_t>(ch) * static_cast<size_t>(d.xfade));
            for (int c = 0; c < ch; ++c)
            {
                const T* src = d.audio.data() + static_cast<size_t>(c) * static_cast<size_t>(len);
                T* dst = d.baked.data() + static_cast<size_t>(c) * static_cast<size_t>(d.xfade);
                for (int64_t i = 0; i < d.xfade; ++i)
                {
                    // Fade the loop's tail out into the audio that precedes the
                    // loop start, so the jump lands on continuous material.
                    const double x = (static_cast<double>(i) + 0.5) / static_cast<double>(d.xfade);
                    const double fin = z.equalPowerCrossfade ? std::sin(0.5 * pi<double> * x) : x;
                    const double fout = z.equalPowerCrossfade ? std::cos(0.5 * pi<double> * x) : 1.0 - x;
                    const double tail = static_cast<double>(src[d.loopEnd - d.xfade + i]);
                    const double lead = static_cast<double>(src[d.loopStart - d.xfade + i]);
                    dst[i] = static_cast<T>(fout * tail + fin * lead);
                }
            }
        }
        return true;
    }
 
    // -- Publication -------------------------------------------------------------------
 
    void reclaim() noexcept
    {
        delete retired_.exchange(nullptr, std::memory_order_acq_rel);
    }
 
    void publish(ZoneSet* set) noexcept
    {
        delete pending_.exchange(set, std::memory_order_acq_rel);
    }
 
    void adoptPending() noexcept
    {
        if (fading_ != nullptr) return;   // one handover at a time
        ZoneSet* next = pending_.exchange(nullptr, std::memory_order_acq_rel);
        if (next == nullptr) return;
        fading_ = active_;
        active_ = next;
    }
 
    void retireFadedSet() noexcept
    {
        if (fading_ == nullptr) return;
        for (const auto& v : voices_)
            if (v.active && v.set == fading_) return;
        if (retired_.load(std::memory_order_acquire) != nullptr) return;
        retired_.store(fading_, std::memory_order_release);
        fading_ = nullptr;
    }
 
    // -- Voices --------------------------------------------------------------------------
 
    struct Voice
    {
        bool active = false;
        const ZoneSet* set = nullptr;
        const ZoneData* zone = nullptr;
        int key = 0;
        double pos = 0.0;         
        double baseRatio = 1.0;   
        bool loopEngaged = false;
        bool releaseLoop = false; 
        bool held = true;         
        bool sustained = false;   
        double gainL = 1.0, gainR = 1.0, gainMono = 1.0;
        int stealLeft = -1;       
        uint64_t age = 0;
        ADSREnvelope<double> env;
        // Scatter form: the next recording sample to spread, the output time
        // it falls on (relative to the next output sample), and the output
        // accumulators it is spread into.
        bool scatter = false;
        bool inputDone = false;
        int drainLeft = 0;
        int64_t jIn = 0;
        double tNext = 0.0;
        int accPos = 0;
        std::array<std::vector<T>, 2> acc;
    };
 
    enum class EventType { NoteOn, NoteOff, Pedal, Bend, AllOff };
    struct Event { EventType type; int key; double value; int offset; };
 
    void push(const Event& e) noexcept
    {
        if (!prepared_ || eventCount_ >= kMaxEvents) return;
        // Keep the queue ordered by offset; events with equal offsets keep
        // their call order.
        int i = eventCount_++;
        while (i > 0 && events_[static_cast<size_t>(i - 1)].offset > e.offset)
        {
            events_[static_cast<size_t>(i)] = events_[static_cast<size_t>(i - 1)];
            --i;
        }
        events_[static_cast<size_t>(i)] = e;
    }
 
    void apply(const Event& e) noexcept
    {
        switch (e.type)
        {
            case EventType::NoteOn:  startNote(e.key, e.value); break;
            case EventType::NoteOff: releaseKey(e.key); break;
            case EventType::Bend:    pitchBend_ = e.value; break;
            case EventType::Pedal:
                sustainPedal_ = e.value > 0.5;
                if (!sustainPedal_)
                    for (auto& v : voices_)
                        if (v.active && v.sustained) release(v);
                break;
            case EventType::AllOff:
                sustainPedal_ = false;
                for (auto& v : voices_)
                    if (v.active && v.stealLeft < 0) release(v);
                break;
        }
    }
 
    void release(Voice& v) noexcept
    {
        v.held = false;
        v.sustained = false;
        v.env.setRelease(static_cast<double>(releaseMs_.load(std::memory_order_relaxed)));
        v.env.noteOff();
        if (v.zone->loop == LoopMode::Sustain) v.releaseLoop = true;
    }
 
    void releaseKey(int key) noexcept
    {
        for (auto& v : voices_)
            if (v.active && v.held && v.key == key && v.stealLeft < 0)
            {
                if (sustainPedal_) { v.held = false; v.sustained = true; }
                else release(v);
            }
    }
 
    void startNote(int key, double velocity) noexcept
    {
        if (active_ == nullptr) return;
        // A retriggered key releases what it was playing.
        for (auto& v : voices_)
            if (v.active && v.key == key && v.stealLeft < 0 && (v.held || v.sustained))
                release(v);
 
        const double velGain = std::pow(10.0, velocityRangeDb_.load(std::memory_order_relaxed)
                                                  * (velocity - 1.0) / 20.0);
        for (const ZoneData& z : active_->zones)
        {
            if (key < z.keyLow || key > z.keyHigh || velocity < z.velLow || velocity > z.velHigh)
                continue;
            Voice* v = freeVoice();
            if (v == nullptr) return;
            v->active = true;
            v->set = active_;
            v->zone = &z;
            v->key = key;
            v->pos = static_cast<double>(z.start);
            v->baseRatio = z.sampleRate / sampleRate_
                         * std::pow(2.0, (key - z.rootKey + z.tuneCents / 100.0) / 12.0);
            v->scatter = v->baseRatio * std::pow(2.0, pitchBend_ / 12.0) > 1.0;
            v->inputDone = false;
            v->drainLeft = 0;
            v->jIn = z.start;
            v->tNext = 0.0;
            v->accPos = 0;
            if (v->scatter)
                for (auto& a : v->acc) std::fill(a.begin(), a.end(), T(0));
            v->loopEngaged = z.loop != LoopMode::None;
            v->releaseLoop = false;
            v->held = true;
            v->sustained = false;
            v->stealLeft = -1;
            v->age = ++clock_;
            const double g = z.gain * velGain;
            const double theta = 0.25 * pi<double> * (z.pan + 1.0);
            v->gainMono = g;
            if (z.channels == 1)
            {
                // Constant power, unity at centre.
                v->gainL = g * std::cos(theta) * sqrt2<double>;
                v->gainR = g * std::sin(theta) * sqrt2<double>;
            }
            else
            {
                v->gainL = g * std::min(1.0, 1.0 - z.pan);
                v->gainR = g * std::min(1.0, 1.0 + z.pan);
            }
            v->env.setParameters(attackMs_.load(std::memory_order_relaxed),
                                 decayMs_.load(std::memory_order_relaxed),
                                 sustain_.load(std::memory_order_relaxed),
                                 releaseMs_.load(std::memory_order_relaxed));
            v->env.reset();
            v->env.noteOn();
        }
    }
 
    Voice* freeVoice() noexcept
    {
        int sounding = 0;
        Voice* idle = nullptr;
        for (auto& v : voices_)
        {
            if (!v.active) { if (idle == nullptr) idle = &v; }
            else if (v.stealLeft < 0) ++sounding;
        }
        if (sounding < polyphony_ && idle != nullptr) return idle;
 
        // Steal: the oldest released voice, else the quietest, else the oldest.
        Voice* victim = nullptr;
        for (auto& v : voices_)
        {
            if (!v.active || v.stealLeft >= 0) continue;
            if (victim == nullptr) { victim = &v; continue; }
            const bool vr = !v.held && !v.sustained, cr = !victim->held && !victim->sustained;
            if (vr != cr) { if (vr) victim = &v; continue; }
            const double va = v.env.getCurrentValue(), ca = victim->env.getCurrentValue();
            if (va < ca - 1e-9 || (std::abs(va - ca) <= 1e-9 && v.age < victim->age)) victim = &v;
        }
        if (victim != nullptr) victim->stealLeft = stealFadeSamples_;
        if (idle != nullptr) return idle;
        // No spare slot left: the oldest stealing fade is cut short.
        Voice* oldest = nullptr;
        for (auto& v : voices_)
            if (v.active && v.stealLeft >= 0 && (oldest == nullptr || v.age < oldest->age)) oldest = &v;
        if (oldest != nullptr) oldest->active = false;
        return oldest;
    }
 
    // -- Rendering --------------------------------------------------------------------------
 
    [[nodiscard]] static double dot(const T* w, const T* x, int n) noexcept
    {
        T a[8] = { T(0), T(0), T(0), T(0), T(0), T(0), T(0), T(0) };
        int t = 0;
        for (; t + 8 <= n; t += 8)
            for (int l = 0; l < 8; ++l)
                a[l] += w[t + l] * x[t + l];
        T sum = ((a[0] + a[4]) + (a[1] + a[5])) + ((a[2] + a[6]) + (a[3] + a[7]));
        for (; t < n; ++t) sum += w[t] * x[t];
        return static_cast<double>(sum);
    }
 
    [[nodiscard]] static double fetch(const ZoneData& z, const T* chan, const T* baked,
                                      int64_t j, bool loopEngaged) noexcept
    {
        if (loopEngaged && j >= z.loopEnd)
            j = z.loopStart + (j - z.loopEnd) % (z.loopEnd - z.loopStart);
        if (j < 0 || j >= z.length) return 0.0;
        if (loopEngaged && baked != nullptr && j >= z.loopEnd - z.xfade && j < z.loopEnd)
            return static_cast<double>(baked[j - (z.loopEnd - z.xfade)]);
        return static_cast<double>(chan[j]);
    }
 
    int kernelWeights(double frac, double fc, int half) noexcept
    {
        if (fc >= 1.0)
        {
            const T* rows = polyphaseTable().data();
            const double qf = frac * kPhases;
            const int q = std::min(static_cast<int>(qf), kPhases - 1);
            const T g = static_cast<T>(qf - static_cast<double>(q));
            const T* r0 = rows + static_cast<size_t>(q) * kTaps;
            const T* r1 = r0 + kTaps;
            T* w = weights_.data();
            for (int t = 0; t < kTaps; ++t)
                w[t] = r0[t] + g * (r1[t] - r0[t]);
            return kTaps;
        }
        // Stretched kernel: |k - frac| * fc in table units, one step of fc per tap.
        const auto& table = kernelTable();
        const double step = fc * kTablePerUnit;
        double x = (static_cast<double>(-half + 1) - frac) * step;
        const size_t last = table.size() - 1;
        for (int t = 0; t < 2 * half; ++t, x += step)
        {
            const double u = std::abs(x);
            const size_t iu = static_cast<size_t>(u);
            double w = 0.0;
            if (iu < last)
            {
                const double f = u - static_cast<double>(iu);
                w = table[iu] + f * (table[iu + 1] - table[iu]);
            }
            weights_[static_cast<size_t>(t)] = static_cast<T>(w * fc);
        }
        return 2 * half;
    }
 
    static bool advanceGain(Voice& v, int stealFade, double& gain) noexcept
    {
        gain = v.env.getNextValue();
        if (v.stealLeft >= 0)
        {
            gain *= static_cast<double>(v.stealLeft) / static_cast<double>(stealFade);
            if (--v.stealLeft < 0) { v.active = false; return false; }
        }
        if (!v.env.isActive()) { v.active = false; return false; }
        return true;
    }
 
    void emit(AudioBufferView<T> out, int s, const Voice& v, double a0, double a1, double gain) noexcept
    {
        const int nCh = out.getNumChannels();
        if (nCh == 1)
            out.getChannel(0)[s] += static_cast<T>(a0 * v.gainMono * gain);
        else
        {
            out.getChannel(0)[s] += static_cast<T>(a0 * v.gainL * gain);
            out.getChannel(1)[s] += static_cast<T>((v.zone->channels == 1 ? a0 : a1) * v.gainR * gain);
        }
    }
 
    void render(AudioBufferView<T> out, int from, int to) noexcept
    {
        const double bendRatio = std::pow(2.0, pitchBend_ / 12.0);
        for (auto& v : voices_)
        {
            if (!v.active) continue;
            const double ratio = std::clamp(v.baseRatio * bendRatio, 1.0 / kMaxRate, kMaxRate);
            if (v.scatter) renderScatter(v, out, from, to, ratio);
            else renderGather(v, out, from, to, ratio);
        }
    }
 
    void renderGather(Voice& v, AudioBufferView<T> out, int from, int to, double ratio) noexcept
    {
        const ZoneData& z = *v.zone;
        const int nCh = out.getNumChannels();
        const double fc = std::min(1.0, 1.0 / ratio);
        const int half = static_cast<int>(std::ceil(kHalfTaps / fc));
        const double loopLen = static_cast<double>(z.loopEnd - z.loopStart);
        const int zc = z.channels;
        const int used = (nCh == 1) ? zc : std::min(zc, 2);
 
        for (int s = from; s < to; ++s)
        {
            // Sustain loop released: leave the loop once the kernel is clear
            // of the crossfade region, so no read jumps sources.
            if (v.releaseLoop && v.pos + half < static_cast<double>(z.loopEnd - z.xfade))
            {
                v.loopEngaged = false;
                v.releaseLoop = false;
            }
            if (!v.loopEngaged && v.pos >= static_cast<double>(z.length)) { v.active = false; return; }
 
            const double fl = std::floor(v.pos);
            const int64_t ip = static_cast<int64_t>(fl);
            const int taps = kernelWeights(v.pos - fl, fc, half);
 
            double gain = 0.0;
            if (!advanceGain(v, stealFadeSamples_, gain)) return;
 
            const int64_t first = ip - half + 1;
            const bool direct = first >= 0 && first + taps <= z.length
                             && (!v.loopEngaged || first + taps <= z.loopEnd - z.xfade);
            double acc[2] = { 0.0, 0.0 };
            for (int c = 0; c < used; ++c)
            {
                const T* chan = z.audio.data() + static_cast<size_t>(c) * static_cast<size_t>(z.length);
                const T* baked = z.baked.empty() ? nullptr
                               : z.baked.data() + static_cast<size_t>(c) * static_cast<size_t>(z.xfade);
                double sum = 0.0;
                if (direct)
                    sum = dot(weights_.data(), chan + first, taps);
                else
                    for (int t = 0; t < taps; ++t)
                        sum += static_cast<double>(weights_[static_cast<size_t>(t)])
                             * fetch(z, chan, baked, first + t, v.loopEngaged);
                if (nCh == 1) acc[0] += sum / zc;
                else acc[c] = sum;
            }
            emit(out, s, v, acc[0], acc[1], gain);
 
            v.pos += ratio;
            if (v.loopEngaged && v.pos >= static_cast<double>(z.loopEnd))
                v.pos -= loopLen;
        }
    }
 
    void renderScatter(Voice& v, AudioBufferView<T> out, int from, int to, double ratio) noexcept
    {
        const ZoneData& z = *v.zone;
        const int nCh = out.getNumChannels();
        const double fc = std::min(1.0, ratio);          // output-time kernel scale
        const int half = static_cast<int>(std::ceil(kHalfTaps / fc));
        const double spacing = 1.0 / ratio;             // output samples per input sample
        const int zc = z.channels;
        const int used = (nCh == 1) ? zc : std::min(zc, 2);
        const int rings = (nCh == 1 || zc == 1) ? 1 : 2;
 
        for (int s = from; s < to; ++s)
        {
            // Spread every input whose support reaches this output sample.
            while (!v.inputDone && v.tNext < static_cast<double>(half))
            {
                if (v.releaseLoop && v.jIn < z.loopEnd - z.xfade)
                {
                    v.loopEngaged = false;
                    v.releaseLoop = false;
                }
                double x[2] = { 0.0, 0.0 };
                for (int c = 0; c < used; ++c)
                {
                    const T* chan = z.audio.data() + static_cast<size_t>(c) * static_cast<size_t>(z.length);
                    const T* baked = z.baked.empty() ? nullptr
                                   : z.baked.data() + static_cast<size_t>(c) * static_cast<size_t>(z.xfade);
                    const double sample = fetch(z, chan, baked, v.jIn, v.loopEngaged);
                    if (rings == 1) x[0] += sample / used;
                    else x[c] = sample;
                }
                const double fl = std::floor(v.tNext);
                const int taps = kernelWeights(v.tNext - fl, fc, half);
                const int base = v.accPos + static_cast<int>(fl) - half + 1;
                for (int r = 0; r < rings; ++r)
                {
                    const T xs = static_cast<T>(x[r] * spacing);
                    T* acc = v.acc[static_cast<size_t>(r)].data();
                    const T* w = weights_.data();
                    for (int t = 0; t < taps; ++t)
                    {
                        const int idx = base + t;
                        if (idx >= v.accPos) acc[idx] += w[t] * xs;   // earlier outputs are gone
                    }
                }
                ++v.jIn;
                if (v.loopEngaged && v.jIn >= z.loopEnd) v.jIn = z.loopStart;
                if (!v.loopEngaged && v.jIn >= z.length) { v.inputDone = true; v.drainLeft = 2 * half; }
                v.tNext += spacing;
            }
 
            double gain = 0.0;
            if (!advanceGain(v, stealFadeSamples_, gain)) return;
            const double a0 = static_cast<double>(v.acc[0][static_cast<size_t>(v.accPos)]);
            const double a1 = (rings == 2) ? static_cast<double>(v.acc[1][static_cast<size_t>(v.accPos)]) : a0;
            emit(out, s, v, a0, a1, gain);
 
            // Advance the output: the accumulator slides once it nears its end.
            for (int r = 0; r < rings; ++r) v.acc[static_cast<size_t>(r)][static_cast<size_t>(v.accPos)] = T(0);
            ++v.accPos;
            v.tNext -= 1.0;
            if (v.accPos + 2 * kMaxHalfTaps + 2 >= kAccLength)
            {
                const int keep = kAccLength - v.accPos;
                for (int r = 0; r < rings; ++r)
                {
                    T* acc = v.acc[static_cast<size_t>(r)].data();
                    std::copy(acc + v.accPos, acc + kAccLength, acc);
                    std::fill(acc + keep, acc + kAccLength, T(0));
                }
                v.accPos = 0;
            }
            if (v.inputDone && --v.drainLeft <= 0) { v.active = false; return; }
        }
    }
 
    // -- Members ------------------------------------------------------------------------------
 
    static constexpr int kMaxEvents = 1024;
    static constexpr int kAccLength = 4 * kMaxHalfTaps + 256;
 
    double sampleRate_ = 48000.0;
    int polyphony_ = 0;
    bool prepared_ = false;
    int stealFadeSamples_ = 144;
    uint64_t clock_ = 0;
 
    std::vector<Voice> voices_;
    std::vector<T> weights_;
    std::array<Event, kMaxEvents> events_ {};
    int eventCount_ = 0;
    bool sustainPedal_ = false;
    double pitchBend_ = 0.0;
 
    ZoneSet* active_ = nullptr;                 
    ZoneSet* fading_ = nullptr;                 
    std::atomic<ZoneSet*> pending_ { nullptr }; 
    std::atomic<ZoneSet*> retired_ { nullptr }; 
 
    std::atomic<double> attackMs_ { 1.0 };
    std::atomic<double> decayMs_ { 100.0 };
    std::atomic<double> sustain_ { 1.0 };
    std::atomic<double> releaseMs_ { 100.0 };
    std::atomic<double> velocityRangeDb_ { 24.0 };
    std::atomic<double> outputGain_ { 1.0 };
    std::atomic<int> activeVoices_ { 0 };
};
 
} // namespace dspark