processor_chain.hpp

Go to the documentation of this file.

#pragma once

 
#include <tuple>
#include <cstddef>
 
namespace pulp::signal {

template<typename SampleType, typename... Processors>
class ProcessorChainT {
public:
    ProcessorChainT() = default;

    template<std::size_t Index>
    auto& get() { return std::get<Index>(processors_); }
 
    template<std::size_t Index>
    const auto& get() const { return std::get<Index>(processors_); }

    SampleType process(SampleType input) {
        return process_impl(input, std::index_sequence_for<Processors...>{});
    }

    void process(SampleType* data, int num_samples) {
        for (int i = 0; i < num_samples; ++i) {
            data[i] = process(data[i]);
        }
    }

    void reset() {
        reset_impl(std::index_sequence_for<Processors...>{});
    }

    static constexpr std::size_t size() { return sizeof...(Processors); }
 
private:
    std::tuple<Processors...> processors_;
 
    template<std::size_t... Is>
    SampleType process_impl(SampleType input, std::index_sequence<Is...>) {
        SampleType value = input;
        ((value = std::get<Is>(processors_).process(value)), ...);
        return value;
    }
 
    template<std::size_t I>
    void reset_one() {
        if constexpr (requires { std::get<I>(processors_).reset(); }) {
            std::get<I>(processors_).reset();
        }
    }
 
    template<std::size_t... Is>
    void reset_impl(std::index_sequence<Is...>) {
        (reset_one<Is>(), ...);
    }
};
 
template<typename... Processors>
using ProcessorChain = ProcessorChainT<float, Processors...>;
 
template<typename... Processors>
using ProcessorChain64 = ProcessorChainT<double, Processors...>;
 
} // namespace pulp::signal