Crossfade.h

Go to the documentation of this file.

// DSPark - Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi - MIT License
 
#pragma once
 
#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 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); 
    }
 
    [[nodiscard]] inline T process(T a, T b) noexcept
    {
        refreshGainsFromAtomics();
        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);
 
        const T oldGainA = gainA_;
        const T oldGainB = gainB_;
 
        refreshGainsFromAtomics();
 
        if (oldGainA == gainA_ && oldGainB == gainB_)
        {
            // Hot-path: No parameter change. 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;
        }
        else
        {
            // Parameter change detected: Apply linear block smoothing (De-zippering)
            const T invSamples = T(1) / static_cast<T>(numSamples);
            const T stepA = (gainA_ - oldGainA) * invSamples;
            const T stepB = (gainB_ - oldGainB) * invSamples;
 
            T currentA = oldGainA;
            T currentB = oldGainB;
 
            for (int i = 0; i < numSamples; ++i)
            {
                currentA += stepA;
                currentB += stepB;
                output[i] = inputA[i] * currentA + inputB[i] * currentB;
            }
        }
    }
 
    void processAutomated(const T* inputA, const T* inputB,
                          const T* positions, T* output, int numSamples) noexcept
    {
        assert(inputA && inputB && positions && output);
        assert(numSamples > 0);
 
        Curve curv = curve_.load(std::memory_order_relaxed);
        T gA = gainA_, gB = gainB_;
 
        for (int i = 0; i < numSamples; ++i)
        {
            // min/max with this argument order also resolves a NaN in the
            // automation buffer to 0 (100% A) instead of poisoning the output.
            T pos = std::min(T(1), std::max(T(0), positions[i]));
            computeGains(curv, pos, gA, gB);
            output[i] = inputA[i] * gA + inputB[i] * gB;
        }
 
        // Update internal state to match the end of the automation block.
        // NOTE: We DO NOT write back to the atomic position_ to avoid Data Races
        // with the GUI thread. We only update the audio-thread local cache.
        lastPos_ = std::min(T(1), std::max(T(0), positions[numSamples - 1]));
        lastCurve_ = curv;
        gainA_ = gA;
        gainB_ = gB;
    }
 
    [[nodiscard]] T getGainA() const noexcept { return gainA_; }
 
    [[nodiscard]] T getGainB() const noexcept { return gainB_; }
 
private:
    static inline void computeGains(Curve curve, T pos, T& gA, T& gB) noexcept
    {
        switch (curve)
        {
            case Curve::Linear:
                gA = T(1) - pos;
                gB = pos;
                break;
 
            case Curve::EqualPower:
                // SIMD Optimization: Replaced std::cos/sin with hardware-accelerated std::sqrt.
                // sqrt(1-x)^2 + sqrt(x)^2 = (1-x) + x = 1.0 (Constant Power).
                // Avoids heavy trigonometric penalties while maintaining identical energetic response.
                gA = std::sqrt(T(1) - pos);
                gB = std::sqrt(pos);
                break;
 
            case Curve::SCurve:
            {
                T t = pos * pos * (T(3) - T(2) * pos);
                gA = T(1) - t;
                gB = t;
                break;
            }
 
            default:
                // Unreachable through the clamped setter; keeps the out
                // parameters defined if the enum ever grows without a case.
                gA = T(1) - pos;
                gB = pos;
                break;
        }
    }
 
    inline void refreshGainsFromAtomics() noexcept
    {
        T pos = position_.load(std::memory_order_relaxed);
        Curve curv = curve_.load(std::memory_order_relaxed);
        
        if (pos != lastPos_ || curv != lastCurve_)
        {
            computeGains(curv, pos, gainA_, gainB_);
            lastPos_   = pos;
            lastCurve_ = curv;
        }
    }
 
    // Communication: GUI -> Audio Thread
    std::atomic<Curve> curve_ { Curve::EqualPower };
    std::atomic<T> position_ { T(0) };
    
    // Audio Thread Local State (Cache)
    T gainA_ = T(1);
    T gainB_ = T(0);
    T lastPos_ = T(-1);  // Sentinel to force initial compute
    Curve lastCurve_ = Curve::EqualPower;
};
 
} // namespace dspark