Crossfade.h

// DSPark - Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi - MIT License
 
#pragma once
 
#include "../Core/AudioSpec.h"
#include "../Core/DspMath.h"
 
#include <algorithm>
#include <atomic>
#include <cassert>
#include <cmath>
 
namespace dspark {
 
template <FloatType T>
class Crossfade final
{
public:
    enum class Curve
    {
        Linear,     
        EqualPower, 
        SCurve      
    };
 
    Crossfade() = default;
    ~Crossfade() = default;
 
    void prepare(double sampleRate) noexcept
    {
        if (!(sampleRate > 0.0) || !std::isfinite(sampleRate)) return;
        maxPosStep_ = static_cast<T>(1.0 / (sampleRate * kMinGlideSeconds));
        reset();
    }
 
    void prepare(const AudioSpec& spec) noexcept { prepare(spec.sampleRate); }
 
    void reset() noexcept
    {
        settle();
        needsSettle_ = true;
    }
 
    void setCurve(Curve curve) noexcept
    {
        curve = static_cast<Curve>(std::clamp(static_cast<int>(curve), 0,
                                              static_cast<int>(Curve::SCurve)));
        curve_.store(curve, std::memory_order_relaxed);
    }
 
    void setPosition(T position) noexcept
    {
        if (!std::isfinite(position)) return;
        position_.store(std::clamp(position, T(0), T(1)), std::memory_order_relaxed);
    }
 
    [[nodiscard]] T getPosition() const noexcept
    {
        return position_.load(std::memory_order_relaxed);
    }
 
    static void gainsFor(Curve curve, T position, T& gainA, T& gainB) noexcept
    {
        // min/max with this argument order also resolves NaN to 0.
        position = std::min(T(1), std::max(T(0), position));
        fillGains(curve, &position, &gainA, &gainB, 1);
    }
 
    [[nodiscard]] inline T process(T a, T b) noexcept
    {
        settleIfFresh();
        const T target = position_.load(std::memory_order_relaxed);
        const Curve curve = curve_.load(std::memory_order_relaxed);
        if (target != curPos_ || curve != lastCurve_)
        {
            curPos_ = maxPosStep_ > T(0) ? moveTowards(curPos_, target, maxPosStep_) : target;
            lastCurve_ = curve;
            gainsFor(curve, curPos_, gainA_, gainB_);
            publishGains();
        }
        return a * gainA_ + b * gainB_;
    }
 
    void process(const T* inputA, const T* inputB, T* output, int numSamples) noexcept
    {
        assert(inputA != nullptr && inputB != nullptr && output != nullptr);
        assert(numSamples > 0);
        if (numSamples <= 0) return;
 
        settleIfFresh();
        const T target = position_.load(std::memory_order_relaxed);
        const Curve curve = curve_.load(std::memory_order_relaxed);
 
        if (target == curPos_ && curve == lastCurve_)
        {
            // Hot path: settled. Ideal for SIMD autovectorization.
            const T gA = gainA_;
            const T gB = gainB_;
            for (int i = 0; i < numSamples; ++i)
                output[i] = inputA[i] * gA + inputB[i] * gB;
            return;
        }
 
        const T startPos = curPos_;
        const Curve oldCurve = lastCurve_;
        const bool prepared = maxPosStep_ > T(0);
        const T step = prepared ? maxPosStep_
                                : std::abs(target - startPos) / static_cast<T>(numSamples);
        const T invSamples = T(1) / static_cast<T>(numSamples);
 
        T pos[kChunk], gA[kChunk], gB[kChunk], oldA[kChunk], oldB[kChunk];
        for (int start = 0; start < numSamples; start += kChunk)
        {
            const int n = std::min(kChunk, numSamples - start);
            for (int i = 0; i < n; ++i)
                pos[i] = moveTowards(startPos, target, step * static_cast<T>(start + i + 1));
            fillGains(curve, pos, gA, gB, n);
 
            if (curve != oldCurve)
            {
                fillGains(oldCurve, pos, oldA, oldB, n);
                for (int i = 0; i < n; ++i)
                {
                    const T w = static_cast<T>(start + i + 1) * invSamples;
                    gA[i] = oldA[i] + w * (gA[i] - oldA[i]);
                    gB[i] = oldB[i] + w * (gB[i] - oldB[i]);
                }
            }
 
            for (int i = 0; i < n; ++i)
                output[start + i] = inputA[start + i] * gA[i] + inputB[start + i] * gB[i];
        }
 
        // The block ramp of an unprepared crossfader always lands on the target.
        curPos_ = prepared ? moveTowards(startPos, target, step * static_cast<T>(numSamples))
                           : target;
        lastCurve_ = curve;
        gainsFor(curve, curPos_, gainA_, gainB_);
        publishGains();
    }
 
    void processAutomated(const T* inputA, const T* inputB,
                          const T* positions, T* output, int numSamples) noexcept
    {
        assert(inputA && inputB && positions && output);
        assert(numSamples > 0);
        if (numSamples <= 0) return;
 
        const Curve curve = curve_.load(std::memory_order_relaxed);
 
        T pos[kChunk], gA[kChunk], gB[kChunk];
        for (int start = 0; start < numSamples; start += kChunk)
        {
            const int n = std::min(kChunk, numSamples - start);
            // min/max with this argument order also resolves a NaN in the
            // automation buffer to 0 (100% A) instead of poisoning the output.
            for (int i = 0; i < n; ++i)
                pos[i] = std::min(T(1), std::max(T(0), positions[start + i]));
            fillGains(curve, pos, gA, gB, n);
            for (int i = 0; i < n; ++i)
                output[start + i] = inputA[start + i] * gA[i] + inputB[start + i] * gB[i];
        }
 
        // Update the audio-thread state to the end of the automation block.
        // The atomic position_ is NOT written back: that would race with the
        // GUI thread.
        needsSettle_ = false;
        curPos_ = std::min(T(1), std::max(T(0), positions[numSamples - 1]));
        lastCurve_ = curve;
        gainsFor(curve, curPos_, gainA_, gainB_);
        publishGains();
    }
 
    [[nodiscard]] T getGainA() const noexcept
    {
        return publishedGainA_.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] T getGainB() const noexcept
    {
        return publishedGainB_.load(std::memory_order_relaxed);
    }
 
private:
    static constexpr int kChunk = 64;
    static constexpr double kMinGlideSeconds = 0.02;
 
    static inline void equalPowerGains(T t, T& gA, T& gB) noexcept
    {
        const bool upper = t > T(0.5);
        const T u  = upper ? T(1) - t : t;
        const T x  = halfPi<T> * u;
        const T x2 = x * x;
        const T s = x * (T(1) + x2 * (T(-1.0 / 6.0) + x2 * (T(1.0 / 120.0)
                  + x2 * (T(-1.0 / 5040.0) + x2 * T(1.0 / 362880.0)))));
        const T c = T(1) + x2 * (T(-0.5) + x2 * (T(1.0 / 24.0) + x2 * (T(-1.0 / 720.0)
                  + x2 * (T(1.0 / 40320.0) + x2 * T(-1.0 / 3628800.0)))));
        gB = upper ? c : s;
        gA = upper ? s : c;
    }
 
    static void fillGains(Curve curve, const T* pos, T* gA, T* gB, int n) noexcept
    {
        switch (curve)
        {
            case Curve::EqualPower:
                for (int i = 0; i < n; ++i)
                    equalPowerGains(pos[i], gA[i], gB[i]);
                break;
 
            case Curve::SCurve:
                for (int i = 0; i < n; ++i)
                {
                    const T t = pos[i] * pos[i] * (T(3) - T(2) * pos[i]);
                    gA[i] = T(1) - t;
                    gB[i] = t;
                }
                break;
 
            case Curve::Linear:
            default:
                // default: unreachable through the clamped setter; keeps the
                // outputs defined if the enum ever grows without a case.
                for (int i = 0; i < n; ++i)
                {
                    gA[i] = T(1) - pos[i];
                    gB[i] = pos[i];
                }
                break;
        }
    }
 
    void settle() noexcept
    {
        curPos_    = position_.load(std::memory_order_relaxed);
        lastCurve_ = curve_.load(std::memory_order_relaxed);
        gainsFor(lastCurve_, curPos_, gainA_, gainB_);
        publishGains();
    }
 
    void settleIfFresh() noexcept
    {
        if (!needsSettle_) return;
        needsSettle_ = false;
        settle();
    }
 
    void publishGains() noexcept
    {
        publishedGainA_.store(gainA_, std::memory_order_relaxed);
        publishedGainB_.store(gainB_, std::memory_order_relaxed);
    }
 
    // Communication: GUI -> Audio Thread
    std::atomic<Curve> curve_ { Curve::EqualPower };
    std::atomic<T> position_ { T(0) };
 
    // Audio-thread state: the applied (gliding) position, its curve and gains.
    // The working pair stays audio-thread-private; the getters read the
    // published copies.
    T curPos_ = T(0);
    Curve lastCurve_ = Curve::EqualPower;
    T gainA_ = T(1);
    T gainB_ = T(0);
    T maxPosStep_ = T(0);   
    bool needsSettle_ = true;   
    std::atomic<T> publishedGainA_ { T(1) };
    std::atomic<T> publishedGainB_ { T(0) };
};
 
} // namespace dspark