ProcessorChain.h

// DSPark -- Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi -- MIT License
 
#pragma once
 
#include "ProcessorTraits.h"
#include "AudioSpec.h"
#include "AudioBuffer.h"
 
#include <cstddef>
#include <concepts>
#include <tuple>
#include <utility>
#include <array>
#include <atomic>
 
namespace dspark {
 
template <typename T, typename... Processors>
class ProcessorChain
{
    static_assert(sizeof...(Processors) > 0, "ProcessorChain requires at least one processor.");
    static_assert((AudioProcessor<Processors, T> && ...),
        "Every ProcessorChain slot must satisfy the dspark::AudioProcessor concept "
        "(prepare(AudioSpec), processBlock(AudioBufferView<T>) noexcept, reset() noexcept).");
 
public:
    void prepare(const AudioSpec& spec)
    {
        std::apply([&spec](auto&... procs) {
            (procs.prepare(spec), ...);
        }, processors_);
    }
 
    void processBlock(AudioBufferView<T> buffer) noexcept
    {
        processBlockImpl(buffer, std::index_sequence_for<Processors...>{});
    }
 
    void reset() noexcept
    {
        std::apply([](auto&... procs) {
            (procs.reset(), ...);
        }, processors_);
    }
 
    template <std::size_t Index>
    [[nodiscard]] auto& get() noexcept
    {
        static_assert(Index < sizeof...(Processors), "Processor index out of bounds.");
        return std::get<Index>(processors_);
    }
 
    template <std::size_t Index>
    [[nodiscard]] const auto& get() const noexcept
    {
        static_assert(Index < sizeof...(Processors), "Processor index out of bounds.");
        return std::get<Index>(processors_);
    }
 
    [[nodiscard]] static constexpr std::size_t size() noexcept
    {
        return sizeof...(Processors);
    }
 
    [[nodiscard]] int getLatency() const noexcept
    {
        return getLatencyImpl(std::index_sequence_for<Processors...>{});
    }
 
    // -- Bypass control ------------------------------------------------------
 
    template <std::size_t Index>
    void setBypassed(bool bypassed) noexcept
    {
        static_assert(Index < sizeof...(Processors), "Index out of range");
        bypassed_[Index].store(bypassed, std::memory_order_relaxed);
    }
 
    template <std::size_t Index>
    [[nodiscard]] bool isBypassed() const noexcept
    {
        static_assert(Index < sizeof...(Processors), "Index out of range");
        return bypassed_[Index].load(std::memory_order_relaxed);
    }
 
private:
    template <std::size_t... Is>
    [[nodiscard]] int getLatencyImpl(std::index_sequence<Is...>) const noexcept
    {
        return (getProcessorLatency<Is>() + ...);
    }
 
    template <std::size_t I>
    [[nodiscard]] int getProcessorLatency() const noexcept
    {
        using P = std::tuple_element_t<I, std::tuple<Processors...>>;
        if constexpr (requires(const P& p) { { p.getLatency() } -> std::convertible_to<int>; })
        {
            return static_cast<int>(std::get<I>(processors_).getLatency());
        }
        else
        {
            // A latency reporter that is not callable on a const processor
            // (or does not return an int-convertible value) would otherwise
            // be skipped silently, desynchronising host delay compensation.
            static_assert(!requires(P& p) { p.getLatency(); },
                "Processor getLatency() must be const and return a value convertible to int "
                "to be summed by ProcessorChain::getLatency().");
            return 0;
        }
    }
 
    template <std::size_t... Is>
    void processBlockImpl(AudioBufferView<T> buffer, std::index_sequence<Is...>) noexcept
    {
        // Uses memory_order_relaxed as we only care about the state, no memory synchronization needed
        ((!bypassed_[Is].load(std::memory_order_relaxed) ? std::get<Is>(processors_).processBlock(buffer) : (void)0), ...);
    }
 
    std::tuple<Processors...> processors_;
    std::array<std::atomic<bool>, sizeof...(Processors)> bypassed_ {};
};
 
} // namespace dspark