TimeStretch.h

// DSPark - Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi - MIT License
 
#pragma once
 
#include "../Core/AudioBuffer.h"
#include "../Core/AudioSpec.h"
#include "../Core/DenormalGuard.h"
#include "../Core/DspMath.h"
#include "../Core/StateBlob.h"
#include "detail/PhaseVocoderEngine.h"
#include "detail/StudioVocoder.h"
 
#include <algorithm>
#include <atomic>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <vector>
 
namespace dspark {
 
template <FloatType T>
class TimeStretch final
{
public:
    // The published parameter words must never make the audio thread take a
    // lock to read them.
    static_assert(std::atomic<bool>::is_always_lock_free,
                  "audio-thread stores must not lock");
 
    static constexpr T kMinRatio = T(0.5);
    static constexpr T kMaxRatio = T(2);
 
    enum class Quality { Standard, Studio };
 
    void setQuality(Quality q) noexcept
    {
        quality_.store(q == Quality::Standard ? Quality::Standard : Quality::Studio,
                       std::memory_order_relaxed);
    }
 
    [[nodiscard]] Quality getQuality() const noexcept
    {
        return quality_.load(std::memory_order_relaxed);
    }
 
    // -- Lifecycle ---------------------------------------------------------------
 
    void prepare(const AudioSpec& spec, int fftSize = 0)
    {
        if (!spec.isValid()) return;
        if (fftSize != 0 && ((fftSize & (fftSize - 1)) != 0
                             || fftSize < 256 || fftSize > (1 << 20)))
            return;
 
        prepared_.store(false, std::memory_order_relaxed);
 
        numChannels_ = std::max(1, spec.numChannels);
        // 0 selects each engine's own default frame: 2048 for Standard (its
        // published rendering) and about 85 ms for Studio (4096 at 44.1 and
        // 48 kHz, 8192 at 88.2 and 96 kHz), the span its measurements use.
        fftStandard_ = fftSize != 0 ? fftSize : 2048;
        fftStudio_ = fftSize != 0 ? fftSize : studioDefaultFrame(spec.sampleRate);
 
        // The input queue holds what the stretch has not consumed yet. It
        // needs room for one whole analysis hop (which can be as long as a
        // frame, and for Studio as long as a frame plus its lookahead), for
        // one host block, and for the surplus a ratio above 1 accumulates
        // until the caller stops or the queue refuses more.
        const int widest = std::max(fftStandard_, fftStudio_);
        int capacity = 4 * widest + 4 * studioDefaultFrame(spec.sampleRate) + std::max(1, spec.maxBlockSize);
        queueSize_ = 1;
        while (queueSize_ < capacity) queueSize_ <<= 1;
        queueMask_ = queueSize_ - 1;
 
        // No resample-back stage and no harmonic/percussive split; the
        // locked analysis hop and the spectral-flux onset detector are both
        // asked for, because this owner reads the synthesis stream directly
        // and its hop schedule has to act on strikes the frame-energy test
        // cannot see over sustained material.
        engine_.prepare(spec.sampleRate, numChannels_, fftStandard_, false, false, true, true);
        studio_.prepare(spec.sampleRate, numChannels_, fftStudio_, false);
 
        queue_.assign(static_cast<size_t>(numChannels_), {});
        for (int ch = 0; ch < numChannels_; ++ch)
            queue_[static_cast<size_t>(ch)].assign(static_cast<size_t>(queueSize_), T(0));
        feed_.assign(static_cast<size_t>(capacity), T(0));
 
        publishEngineParams();
        prepared_.store(true, std::memory_order_relaxed);
        reset();
    }
 
    void reset() noexcept
    {
        if (!prepared_.load(std::memory_order_relaxed)) return;
        studioActive_ = quality_.load(std::memory_order_relaxed) == Quality::Studio;
        engine_.reset();
        studio_.reset();
        if (studioActive_)
        {
            fftSize_ = fftStudio_;
            // One frame of analysis-synthesis delay plus the onset
            // detector's lookahead.
            latency_ = fftStudio_ + studio_.lookahead();
            accumMask_ = studio_.olaMask();
        }
        else
        {
            fftSize_ = fftStandard_;
            // The reader trails the completed frontier of the synthesis
            // stream by one synthesis hop. The analysis-synthesis chain
            // itself accounts for fftSize - synthHop samples of delay, so
            // that trailing distance puts the reported latency at exactly
            // one frame.
            latency_ = fftStandard_;
            accumMask_ = engine_.olaMask();
        }
        synthHop_ = fftSize_ / 4;
        for (auto& q : queue_) std::fill(q.begin(), q.end(), T(0));
 
        queueWrite_ = 0;
        queueRead_  = 0;
        queued_     = 0;
        discarded_  = 0;
        path_       = Path::None;
        // Start one synthesis hop behind the write head: those cells are
        // still silent, which is the latency the class reports, and from
        // there the reader stays exactly that far behind.
        readPos_ = eWriteHead() - static_cast<int64_t>(latency_ - fftSize_ + synthHop_);
        openIntake();
    }
 
    // -- Parameters ---------------------------------------------------------------
 
    void setTimeRatio(T ratio) noexcept
    {
        if (!std::isfinite(ratio)) return;
        timeRatio_.store(std::clamp(ratio, kMinRatio, kMaxRatio),
                         std::memory_order_relaxed);
        publishEngineParams();
    }
 
    void setTempoChangePercent(T pct) noexcept
    {
        if (!std::isfinite(pct)) return;
        const T denom = T(1) + pct / T(100);
        if (!(denom > T(0))) { setTimeRatio(kMaxRatio); return; }
        setTimeRatio(T(1) / denom);
    }
 
    void setTransientPreserve(bool on) noexcept
    {
        transientPreserve_.store(on, std::memory_order_relaxed);
        publishEngineParams();
    }
 
    void setPhaseLock(bool on) noexcept
    {
        phaseLock_.store(on, std::memory_order_relaxed);
        publishEngineParams();
    }
 
    [[nodiscard]] T getTimeRatio() const noexcept
    {
        return timeRatio_.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] bool getTransientPreserve() const noexcept
    {
        return transientPreserve_.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] bool getPhaseLock() const noexcept
    {
        return phaseLock_.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] int getLatency() const noexcept
    {
        return prepared_.load(std::memory_order_relaxed) ? latency_ : 0;
    }
 
    [[nodiscard]] int getQueuedInputSamples() const noexcept { return queued_; }
 
    // -- Rate-changing streaming: the correct path at any ratio -------------
 
    [[nodiscard]] int getInputCapacity() const noexcept
    {
        if (!prepared_.load(std::memory_order_relaxed) || path_ == Path::Adaptor)
            return 0;
        return queueSize_ - queued_;
    }
 
    [[nodiscard]] int getAvailableOutput() const noexcept
    {
        if (!prepared_.load(std::memory_order_relaxed) || path_ != Path::Pull)
            return 0;
        return static_cast<int>(std::max<int64_t>(0, eWriteHead() - readPos_));
    }
 
    int feedInput(AudioBufferView<const T> in) noexcept
    {
        if (!prepared_.load(std::memory_order_relaxed) || !claimPullPath()) return 0;
        DenormalGuard guard;
 
        const int nCh   = std::min(in.getNumChannels(), numChannels_);
        const int count = std::min(std::max(0, in.getNumSamples()), queueSize_ - queued_);
        int wp = queueWrite_;
        for (int k = 0; k < count; ++k)
        {
            for (int ch = 0; ch < nCh; ++ch)
                queue_[static_cast<size_t>(ch)][static_cast<size_t>(wp)]
                    = in.getChannel(ch)[k];
            for (int ch = nCh; ch < numChannels_; ++ch)
                queue_[static_cast<size_t>(ch)][static_cast<size_t>(wp)] = T(0);
            wp = (wp + 1) & queueMask_;
        }
        queueWrite_ = wp;
        queued_ += count;
 
        runReadyFrames();
        return count;
    }
 
    int pullOutput(AudioBufferView<T> out) noexcept
    {
        if (!prepared_.load(std::memory_order_relaxed) || !claimPullPath()) return 0;
        DenormalGuard guard;
 
        const int nCh   = std::min(out.getNumChannels(), numChannels_);
        const int count = std::min(std::max(0, out.getNumSamples()),
                                   static_cast<int>(std::max<int64_t>(0, eWriteHead() - readPos_)));
        if (count > 0)
        {
            readSynthesis(out, nCh, 0, count);
            readPos_ += count;
        }
        // Reading frees room in the synthesis ring, which may be what was
        // holding the next analysis frame back.
        runReadyFrames();
        return std::max(0, count);
    }
 
    [[nodiscard]] int64_t getDiscardedInput() const noexcept { return discarded_; }
 
    [[nodiscard]] std::vector<uint8_t> getState() const
    {
        StateWriter w(stateId("TSTR"), 1);
        w.write("ratio", static_cast<float>(timeRatio_.load(std::memory_order_relaxed)));
        w.write("transient", transientPreserve_.load(std::memory_order_relaxed));
        w.write("phaselock", phaseLock_.load(std::memory_order_relaxed));
        w.write("quality", static_cast<int32_t>(quality_.load(std::memory_order_relaxed)));
        return w.blob();
    }
 
    bool setState(const uint8_t* data, size_t size)
    {
        StateReader r(data, size);
        if (!r.isValid() || r.processorId() != stateId("TSTR")) return false;
        setTimeRatio(static_cast<T>(r.read("ratio", 1.0f)));
        setTransientPreserve(r.read("transient", true));
        setPhaseLock(r.read("phaselock", true));
        // A blob written before the quality field existed was rendered by the
        // Standard engine, so that is what it restores.
        setQuality(static_cast<Quality>(std::clamp(r.read("quality", 0), 0, 1)));
        return true;
    }
 
    // -- Processing ----------------------------------------------------------------
 
    void processBlock(AudioBufferView<T> buffer) noexcept
    {
        if (!prepared_.load(std::memory_order_relaxed)) return;
        if (path_ == Path::Pull) return;
        path_ = Path::Adaptor;
        DenormalGuard guard;
 
        const int nCh = std::min(buffer.getNumChannels(), numChannels_);
        const int nS  = buffer.getNumSamples();
        if (nS <= 0) return;
 
        // Input is taken into the queue in step with the output leaving it,
        // never a whole block ahead. That is what the device physically is -
        // one sample in for every sample out - and it is also what makes the
        // result independent of the host's block size: every decision below
        // is taken at a position in the stream where the queue holds exactly
        // the input the stream has delivered by then, whether the host sends
        // one sample at a time or four thousand.
        int taken = 0;    // samples of this block already queued
        int i = 0;        // output samples already written
        while (i < nS)
        {
            takeInput(buffer, nCh, taken, i);
 
            const int64_t avail = eWriteHead() - readPos_;
            if (avail > 0)
            {
                const int take = static_cast<int>(
                    std::min<int64_t>(avail, static_cast<int64_t>(nS - i)));
                takeInput(buffer, nCh, taken, i + take);
                readSynthesis(buffer, nCh, i, take);
                readPos_ += take;
                i += take;
                continue;
            }
 
            // More synthesis is needed: run one analysis frame. Below a ratio
            // of 1 the stretch wants more input than the stream has brought,
            // and no amount of buffering invents it: the output waits, in
            // silence, for exactly as many samples as are missing, and picks
            // up where it left off.
            const int need = eSamplesToNextHop();
            if (need > queued_)
            {
                const int silence = std::min(need - queued_, nS - i);
                // Take the matching input FIRST: the block is about to be
                // overwritten with silence, and a sample the stream delivered
                // must be queued whether or not anything came out against it.
                takeInput(buffer, nCh, taken, i + silence);
                for (int ch = 0; ch < nCh; ++ch)
                    std::fill(buffer.getChannel(ch) + i, buffer.getChannel(ch) + i + silence, T(0));
                i += silence;
                continue;
            }
 
            for (int ch = 0; ch < nCh; ++ch)
            {
                dequeueInto(ch, need);
                ePushInput(ch, feed_.data(), need);
            }
            eCommitInput(need, nCh);
            queueRead_ = (queueRead_ + need) & queueMask_;
            queued_ -= need;
            openIntake();
        }
    }
 
    void process(AudioBufferView<const T> in, AudioBuffer<T>& out)
    {
        const int inLen = in.getNumSamples();
        const int inCh  = in.getNumChannels();
 
        if (!prepared_.load(std::memory_order_relaxed) || inLen <= 0 || inCh <= 0)
        {
            out.resize(std::max(0, inCh), std::max(0, inLen));
            for (int ch = 0; ch < inCh; ++ch)
                std::copy(in.getChannel(ch), in.getChannel(ch) + inLen, out.getChannel(ch));
            return;
        }
 
        const int nCh = std::min(inCh, numChannels_);
        beginOffline(nCh);
        pushOffline(in.getSubView(0, inLen));
        finishOffline();
        const int outLen = static_cast<int>(offlineStop_ - offlineSkip_);
        out.resize(inCh, std::max(0, outLen));
        if (outLen > 0)
        {
            std::vector<T*> ptrs(static_cast<size_t>(nCh));
            for (int ch = 0; ch < nCh; ++ch) ptrs[static_cast<size_t>(ch)] = out.getChannel(ch);
            (void)pullOffline(AudioBufferView<T>(ptrs.data(), nCh, outLen));
        }
        offlineOpen_ = false;
 
        // Channels the stretch does not cover would otherwise be left at the
        // zero resize() gives them; carry them through instead, truncated or
        // silence-padded to the stretched length.
        for (int ch = nCh; ch < inCh; ++ch)
        {
            const T* src = in.getChannel(ch);
            T* dst = out.getChannel(ch);
            const int n = std::min(outLen, inLen);
            std::copy(src, src + n, dst);
            std::fill(dst + n, dst + outLen, T(0));
        }
    }
 
    void beginOffline(int numChannels)
    {
        offlineOpen_ = false;
        if (!prepared_.load(std::memory_order_relaxed)) return;
        reset();
        path_ = Path::Adaptor;   // this path drives the same reader as the adaptor
        offlineChannels_ = std::clamp(numChannels, 1, numChannels_);
        offlineRatio_ = studioActive_ ? studio_.activeRatio() : engine_.activeRatio();
        // A frame carries its content at its centre, so the first output
        // sample that lines up with input sample 0 sits half an input frame
        // plus half a stretched frame into the synthesis stream.
        offlineSkip_ = studioActive_
            ? std::llround(studio_.streamPositionOf(0.0)) - readPos_
            : std::lround(0.5 * static_cast<double>(fftSize_) * (1.0 + offlineRatio_));
        offlineStreamPos_ = 0;
        offlineReceived_ = 0;
        offlineStop_ = offlineSkip_;
        offlineFinished_ = false;
        offlineStaged_.assign(static_cast<size_t>(offlineChannels_), std::vector<T> {});
        offlineStagedHead_ = 0;
        offlineOut_.assign(static_cast<size_t>(offlineChannels_), std::vector<T> {});
        offlineOutHead_ = 0;
        offlineOpen_ = true;
    }
 
    void pushOffline(AudioBufferView<const T> in)
    {
        if (!offlineOpen_ || offlineFinished_) return;
        const int n = in.getNumSamples();
        if (n <= 0) return;
        for (int ch = 0; ch < offlineChannels_; ++ch)
        {
            auto& q = offlineStaged_[static_cast<size_t>(ch)];
            if (ch < in.getNumChannels())
                q.insert(q.end(), in.getChannel(ch), in.getChannel(ch) + n);
            else
                q.insert(q.end(), static_cast<size_t>(n), T(0));
        }
        offlineReceived_ += n;
        runOffline();
    }
 
    void finishOffline()
    {
        if (!offlineOpen_ || offlineFinished_) return;
        offlineFinished_ = true;
        offlineStop_ = offlineSkip_ + static_cast<int64_t>(
            std::lround(static_cast<double>(offlineReceived_) * offlineRatio_));
        runOffline();
    }
 
    [[nodiscard]] int getOfflineAvailable() const noexcept
    {
        if (!offlineOpen_ || offlineOut_.empty()) return 0;
        return static_cast<int>(offlineOut_[0].size() - offlineOutHead_);
    }
 
    int pullOffline(AudioBufferView<T> out)
    {
        const int n = std::min(out.getNumSamples(), getOfflineAvailable());
        if (n <= 0) return 0;
        for (int ch = 0; ch < offlineChannels_ && ch < out.getNumChannels(); ++ch)
        {
            const T* src = offlineOut_[static_cast<size_t>(ch)].data() + offlineOutHead_;
            std::copy(src, src + n, out.getChannel(ch));
        }
        offlineOutHead_ += static_cast<size_t>(n);
        if (offlineOutHead_ > 65536 && offlineOutHead_ * 2 > offlineOut_[0].size())
        {
            for (auto& q : offlineOut_)
                q.erase(q.begin(), q.begin() + static_cast<std::ptrdiff_t>(offlineOutHead_));
            offlineOutHead_ = 0;
        }
        return n;
    }
 
private:
    void runOffline()
    {
        const int nCh = offlineChannels_;
        for (;;)
        {
            if (offlineFinished_ && offlineStreamPos_ >= offlineStop_) break;
            const int64_t avail = eWriteHead() - readPos_;
            if (avail <= 0)
            {
                const int need = eSamplesToNextHop();
                const int64_t staged = static_cast<int64_t>(offlineStaged_[0].size() - offlineStagedHead_);
                if (!offlineFinished_ && staged < need) break;   // wait for input
                // Past the input's end the engine is flushed with silence.
                for (int ch = 0; ch < nCh; ++ch)
                {
                    const auto& q = offlineStaged_[static_cast<size_t>(ch)];
                    for (int k = 0; k < need; ++k)
                    {
                        const size_t idx = offlineStagedHead_ + static_cast<size_t>(k);
                        feed_[static_cast<size_t>(k)] = (idx < q.size()) ? q[idx] : T(0);
                    }
                    ePushInput(ch, feed_.data(), need);
                }
                eCommitInput(need, nCh);
                offlineStagedHead_ = std::min(offlineStagedHead_ + static_cast<size_t>(need),
                                              offlineStaged_[0].size());
                if (offlineStagedHead_ > 65536)
                {
                    for (auto& q : offlineStaged_)
                        q.erase(q.begin(), q.begin() + static_cast<std::ptrdiff_t>(offlineStagedHead_));
                    offlineStagedHead_ = 0;
                }
                continue;
            }
 
            const int64_t limit = offlineFinished_
                ? offlineStop_
                : offlineSkip_ + static_cast<int64_t>(
                      std::lround(static_cast<double>(offlineReceived_) * offlineRatio_));
            const int64_t take = std::min(avail, limit - offlineStreamPos_);
            if (take <= 0) break;
            const int64_t from = std::max(offlineStreamPos_, offlineSkip_);
            const int64_t count = offlineStreamPos_ + take - from;
            if (count > 0)
            {
                for (int ch = 0; ch < nCh; ++ch)
                {
                    const T* acc = eOla(ch);
                    auto& q = offlineOut_[static_cast<size_t>(ch)];
                    const int64_t rp = readPos_ + (from - offlineStreamPos_);
                    for (int64_t k = 0; k < count; ++k)
                        q.push_back(acc[static_cast<size_t>((rp + k) & accumMask_)]);
                }
            }
            readPos_ += take;
            offlineStreamPos_ += take;
        }
    }
 
private:
    void publishEngineParams() noexcept
    {
        typename detail::PhaseVocoderEngine<T>::Params p;
        // The engine carries its stretch target logarithmically, because the
        // same core drives a pitch shifter where semitones are the natural
        // unit. Ratio and semitones are the same number in two spellings.
        p.targetSemitones = 12.0 * std::log2(static_cast<double>(
                                timeRatio_.load(std::memory_order_relaxed)));
        p.transientPreserve = transientPreserve_.load(std::memory_order_relaxed);
        p.formantPreserve = false;   // nothing resamples the output here
        p.phaseLock = phaseLock_.load(std::memory_order_relaxed);
        p.percussiveSplit = false;   // no public switch selects the split here
        engine_.publishParams(p);
 
        typename detail::StudioVocoder<T>::Params q;
        q.targetSemitones = p.targetSemitones;
        q.transientPreserve = p.transientPreserve;
        q.formantPreserve = false;
        studio_.publishParams(q);
    }
 
    void openIntake() noexcept
    {
        intakeSpan_  = std::max(1, synthHop_);
        const double ratio = studioActive_ ? studio_.activeRatio() : engine_.activeRatio();
        // Never wider than the queue: above unity the window is bounded by
        // one analysis hop and the queue holds several frames, so this
        // cannot bind there, and stating it is what keeps the loop below
        // total.
        intakeWant_  = ratio <= 1.0
                     ? queueSize_ - queued_
                     : std::clamp(eSamplesToNextHop() - queued_, 0, queueSize_ - queued_);
        intakeTaken_ = 0;
        intakeErr_   = 0;
    }
 
    [[nodiscard]] bool acceptOffered() noexcept
    {
        if (intakeTaken_ >= intakeWant_) return false;
        if (intakeWant_ < intakeSpan_)
        {
            intakeErr_ += intakeWant_;
            if (intakeErr_ < intakeSpan_) return false;
            intakeErr_ -= intakeSpan_;
        }
        ++intakeTaken_;
        return true;
    }
 
    void takeInput(AudioBufferView<T> buffer, int nCh, int& taken, int upTo) noexcept
    {
        if (upTo <= taken) return;
        int wp = queueWrite_;
        int held = queued_;
        for (int k = taken; k < upTo; ++k)
        {
            if (!acceptOffered()) { ++discarded_; continue; }
            for (int ch = 0; ch < nCh; ++ch)
                queue_[static_cast<size_t>(ch)][static_cast<size_t>(wp)]
                    = buffer.getChannel(ch)[k];
            wp = (wp + 1) & queueMask_;
            ++held;
        }
        queueWrite_ = wp;
        queued_ = held;
        taken = upTo;
    }
 
    [[nodiscard]] bool claimPullPath() noexcept
    {
        if (path_ == Path::Pull) return true;
        if (path_ != Path::None) return false;
        path_ = Path::Pull;
        // This path's output is the stretched timeline itself, so it starts
        // at the first synthesis sample whose overlap-add is complete: one
        // frame past the write head, less the analysis hop the first frame
        // consumes. Nothing has been fed yet, so that hop is the one the
        // engine reports now.
        readPos_ = studioActive_
            ? static_cast<int64_t>(std::llround(studio_.streamPositionOf(0.0)))
            : eWriteHead() + static_cast<int64_t>(fftSize_ - eSamplesToNextHop());
        return true;
    }
 
    void runReadyFrames() noexcept
    {
        for (;;)
        {
            const int need = eSamplesToNextHop();
            if (queued_ < need) return;
            // A frame writes one whole window ahead of the head; stop before
            // it would reach unread output.
            if (eWriteHead() + static_cast<int64_t>(fftSize_) - readPos_
                > static_cast<int64_t>(accumMask_) + 1)
                return;
 
            for (int ch = 0; ch < numChannels_; ++ch)
            {
                dequeueInto(ch, need);
                ePushInput(ch, feed_.data(), need);
            }
            eCommitInput(need, numChannels_);
            queueRead_ = (queueRead_ + need) & queueMask_;
            queued_ -= need;
        }
    }
 
    void dequeueInto(int ch, int count) noexcept
    {
        const auto& q = queue_[static_cast<size_t>(ch)];
        int rp = queueRead_;
        for (int k = 0; k < count; ++k)
        {
            feed_[static_cast<size_t>(k)] = q[static_cast<size_t>(rp)];
            rp = (rp + 1) & queueMask_;
        }
    }
 
    void readSynthesis(AudioBufferView<T> buffer, int nCh, int offset, int count) noexcept
    {
        for (int ch = 0; ch < nCh; ++ch)
        {
            const T* acc = eOla(ch);
            T* dst = buffer.getChannel(ch) + offset;
            const int64_t rp = readPos_;
            for (int k = 0; k < count; ++k)
                dst[k] = acc[static_cast<size_t>((rp + k) & accumMask_)];
        }
    }
 
    // -- Engine dispatch (the engine in force is chosen at reset()) ---------------
 
    [[nodiscard]] int64_t eWriteHead() const noexcept
    {
        return studioActive_ ? studio_.writeHead() : engine_.writeHead();
    }
    [[nodiscard]] int eSamplesToNextHop() const noexcept
    {
        return studioActive_ ? studio_.samplesToNextHop() : engine_.samplesToNextHop();
    }
    void ePushInput(int ch, const T* src, int count) noexcept
    {
        if (studioActive_) studio_.pushInput(ch, src, count);
        else engine_.pushInput(ch, src, count);
    }
    void eCommitInput(int count, int nCh) noexcept
    {
        if (studioActive_) studio_.commitInput(count, nCh);
        else engine_.commitInput(count, nCh);
    }
    [[nodiscard]] const T* eOla(int ch) const noexcept
    {
        return studioActive_ ? studio_.olaData(ch) : engine_.olaData(ch);
    }
 
    [[nodiscard]] static int studioDefaultFrame(double sampleRate) noexcept
    {
        int n = 256;
        while (n < (1 << 16) && static_cast<double>(n) * 1.5 < 0.085 * sampleRate) n <<= 1;
        return n;
    }
 
    // -- Members -------------------------------------------------------------------
    int numChannels_ = 0;
    std::atomic<bool> prepared_ { false };
 
    int fftSize_ = 2048;
    int synthHop_ = 512;
    int latency_ = 2048;
    int64_t accumMask_ = 8191;     
 
    detail::PhaseVocoderEngine<T> engine_;   
    detail::StudioVocoder<T> studio_;        
    bool studioActive_ = true;               
    int fftStandard_ = 2048;                 
    int fftStudio_ = 4096;                   
 
    std::vector<std::vector<T>> queue_;   
    std::vector<T> feed_;                 
    int queueSize_ = 0;
    int queueMask_ = 0;
    int queueWrite_ = 0;
    int queueRead_ = 0;
    int queued_ = 0;
 
    enum class Path { None, Adaptor, Pull };
    Path path_ = Path::None;
 
    int64_t discarded_ = 0;     
    int intakeSpan_ = 0;        
    int intakeWant_ = 0;        
    int intakeTaken_ = 0;       
    int intakeErr_ = 0;         
 
    int64_t readPos_ = 0;       
 
    std::atomic<Quality> quality_ { Quality::Studio };
    std::atomic<T> timeRatio_ { T(1) };
    std::atomic<bool> transientPreserve_ { true };
    std::atomic<bool> phaseLock_ { true };
 
    // Offline session (beginOffline() .. finishOffline(), pullOffline()).
    bool offlineOpen_ = false;
    bool offlineFinished_ = false;
    int offlineChannels_ = 0;
    double offlineRatio_ = 1.0;
    int64_t offlineSkip_ = 0;
    int64_t offlineStop_ = 0;
    int64_t offlineStreamPos_ = 0;
    int64_t offlineReceived_ = 0;
    std::vector<std::vector<T>> offlineStaged_;   
    size_t offlineStagedHead_ = 0;
    std::vector<std::vector<T>> offlineOut_;      
    size_t offlineOutHead_ = 0;
};
 
} // namespace dspark