ModulationRouter.h

// DSPark -- Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi -- MIT License
 
#pragma once
 
#include "DspMath.h"
 
#include <algorithm>
#include <array>
#include <atomic>
#include <cmath>
#include <functional>
 
namespace dspark {
 
template <FloatType T, int MaxRoutes = 16>
class ModulationRouter
{
public:
    int addRoute(std::function<T()> source, std::function<void(T)> target,
                 T depth = T(1), T base = T(0), T smoothMs = T(20))
    {
        // Empty callables would raise std::bad_function_call inside the
        // noexcept audio-thread update() -- reject them at the door.
        if (numRoutes_ >= MaxRoutes || !source || !target) return -1;
        auto& r = routes_[static_cast<size_t>(numRoutes_)];
        r.source = std::move(source);
        r.target = std::move(target);
        r.depth.store(depth, std::memory_order_relaxed);
        r.base = base;
        r.smoothMs = std::max(smoothMs, T(0));
        r.state = T(0);
        r.primed = false;
        return numRoutes_++;
    }
 
    void setDepth(int route, T depth) noexcept
    {
        if (route >= 0 && route < numRoutes_)
            routes_[static_cast<size_t>(route)].depth.store(depth, std::memory_order_relaxed);
    }
 
    void clear() noexcept
    {
        for (int i = 0; i < numRoutes_; ++i)
        {
            routes_[static_cast<size_t>(i)].source = nullptr;
            routes_[static_cast<size_t>(i)].target = nullptr;
        }
        numRoutes_ = 0;
    }
 
    [[nodiscard]] int getNumRoutes() const noexcept { return numRoutes_; }
 
    void update(int numSamples, double sampleRate) noexcept
    {
        const double dt = static_cast<double>(numSamples) / std::max(sampleRate, 1.0);
        for (int i = 0; i < numRoutes_; ++i)
        {
            auto& r = routes_[static_cast<size_t>(i)];
            const T depth = r.depth.load(std::memory_order_relaxed);
            const T value = r.base + r.source() * depth;
            // Defensive: a transiently non-finite source would otherwise poison
            // r.state permanently (NaN is sticky through the one-pole). Hold the
            // last good value instead, matching DryWetMixer's isnan guard.
            if (!std::isfinite(value))
            {
                r.target(r.state);
                continue;
            }
            if (!r.primed || r.smoothMs <= T(0))
            {
                r.state = value;     // no sweep-in from zero on the first hit
                r.primed = true;
            }
            else
            {
                const double a = std::exp(-dt * 1000.0 / static_cast<double>(r.smoothMs));
                r.state = static_cast<T>(a * static_cast<double>(r.state)
                                         + (1.0 - a) * static_cast<double>(value));
            }
            r.target(r.state);
        }
    }
 
private:
    struct Route
    {
        std::function<T()> source;
        std::function<void(T)> target;
        std::atomic<T> depth { T(1) };
        T base = T(0);
        T smoothMs = T(20);
        T state = T(0);
        bool primed = false;
    };
 
    std::array<Route, static_cast<size_t>(MaxRoutes)> routes_ {};
    int numRoutes_ = 0;
};
 
} // namespace dspark