schroeder_allpass.h

// Copyright (C) 2025 Alexandre St-Onge
// SPDX-License-Identifier: MIT
#pragma once
 
#include "sffdn/audio_buffer.h"
#include "sffdn/audio_processor.h"
#include "sffdn/delay.h"
#include "sffdn/filterbank.h"
#include "sffdn/types.h"
 
#include <cstddef>
#include <cstdint>
#include <span>
 
namespace sfFDN
{
 
class SchroederAllpass
{
  public:
    SchroederAllpass() = default;
 
    SchroederAllpass(uint32_t delay, float g);
 
    SchroederAllpass(const SchroederAllpass&) = delete;
    SchroederAllpass& operator=(const SchroederAllpass&) = delete;
 
    SchroederAllpass(SchroederAllpass&&) = default;
 
    SchroederAllpass& operator=(SchroederAllpass&&) = default;
 
    ~SchroederAllpass() = default;
 
    void SetDelay(uint32_t delay);
 
    void SetG(float g);
 
    uint32_t GetDelay() const
    {
        return delay_.GetDelay();
    }
 
    float GetG() const
    {
        return g_;
    }
 
    float Tick(float input);
 
    void ProcessBlock(std::span<const float> in, std::span<float> out);
 
    void ProcessBlockAccumulate(std::span<const float> in, std::span<float> out);
 
    void Clear();
 
  private:
    Delay delay_;
    float g_{};
 
    void Tick8(std::span<const float, 8> in, std::span<float, 8> out);
};
 
class SchroederAllpassSection : public AudioProcessor
{
  public:
    SchroederAllpassSection() = default;
 
    SchroederAllpassSection(const SchroederAllpassSectionOptions& config);
 
    SchroederAllpassSection(uint32_t filter_count);
 
    SchroederAllpassSection(const SchroederAllpassSection&) = delete;
    SchroederAllpassSection& operator=(const SchroederAllpassSection&) = delete;
 
    SchroederAllpassSection(SchroederAllpassSection&&) noexcept;
 
    SchroederAllpassSection& operator=(SchroederAllpassSection&&) noexcept;
 
    ~SchroederAllpassSection() = default;
 
    void SetFilterCount(uint32_t filter_count);
 
    void SetParallel(bool parallel);
 
    void SetDelays(std::span<const uint32_t> delays);
 
    void SetGains(std::span<const float> gains);
 
    void SetGain(float gain);
 
    std::vector<uint32_t> GetDelays() const;
 
    std::vector<float> GetGains() const;
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept override;
 
    uint32_t InputChannelCount() const override;
 
    uint32_t OutputChannelCount() const override;
 
    void Clear() override;
 
    std::unique_ptr<AudioProcessor> Clone() const override;
 
  private:
    std::vector<SchroederAllpass> allpasses_;
    bool parallel_ = false;
};
 
std::unique_ptr<FilterBank> MakeMultichannelSchroederAllpassSection(
    const MultichannelSchroederAllpassSectionOptions& options);
 
// /** \brief Implements parallel Schroeder allpass sections. */
// class ParallelSchroederAllpassSection : public AudioProcessor
// {
//   public:
//     /** \brief Constructs a ParallelSchroederAllpassSection with a given number of channels and stages.
//      * @param channel_count The number of parallel channels.
//      * @param stage_count The number of allpass filters in each channel.
//      */
//     ParallelSchroederAllpassSection(uint32_t channel_count, uint32_t stage_count);
 
//     ParallelSchroederAllpassSection(const ParallelSchroederAllpassSection&) = delete;
//     ParallelSchroederAllpassSection& operator=(const ParallelSchroederAllpassSection&) = delete;
 
//     ParallelSchroederAllpassSection(ParallelSchroederAllpassSection&&) noexcept;
//     ParallelSchroederAllpassSection& operator=(ParallelSchroederAllpassSection&&) noexcept;
 
//     /** @brief Sets the delays for each allpass filter in the section.
//      * @param delays A span of delay values in samples.
//      * The size of the span must be equal to (channel_count * stage_count).
//      */
//     void SetDelays(std::span<const uint32_t> delays);
 
//     /** @brief Sets the feedback gains for each allpass filter in the section.
//      * @param gains A span of feedback gain values.
//      * The size of the span must be equal to (channel_count * stage_count).
//      */
//     void SetGains(std::span<const float> gains);
 
//     /** @brief Processes a block of audio through the section.
//      * @param input The input audio buffer.
//      * @param output The output audio buffer.
//      * The input and output buffers must have the same number of samples and channels equal to InputChannelCount().
//      */
//     void Process(const AudioBuffer& input, AudioBuffer& output) noexcept override;
 
//     /** @brief Gets the number of input channels supported.*/
//     uint32_t InputChannelCount() const override;
 
//     /** @brief Gets the number of output channels supported.*/
//     uint32_t OutputChannelCount() const override;
 
//     /** @brief Clears the internal state of the processor.
//      * This function resets the internal state of all allpass filters in the section.
//      */
//     void Clear() override;
 
//     /** @brief Creates a copy of the ParallelSchroederAllpassSection.
//      * @return A unique pointer to the cloned ParallelSchroederAllpassSection.
//      */
//     std::unique_ptr<AudioProcessor> Clone() const override;
 
//   private:
//     std::vector<SchroederAllpassSection> allpasses_;
//     uint32_t stage_count_;
// };
} // namespace sfFDN