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/oscillator.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) noexcept SFFDN_NONBLOCKING;
 
    void ProcessBlock(std::span<const float> in, std::span<float> out) noexcept SFFDN_NONBLOCKING;
 
    void ProcessBlockAccumulate(std::span<const float> in, std::span<float> out) noexcept SFFDN_NONBLOCKING;
 
    void Clear();
 
  private:
    Delay delay_;
    float g_{};
 
    void Tick8(std::span<const float, 8> in, std::span<float, 8> out) noexcept SFFDN_NONBLOCKING;
};
 
class TimeVaryingSchroederAllpass
{
  public:
    TimeVaryingSchroederAllpass(uint32_t delay, float gain, const ModulationOptions& modulation);
 
    void SetDelay(uint32_t delay);
 
    uint32_t GetDelay() const noexcept SFFDN_NONBLOCKING
    {
        return delay_.GetDelay();
    }
 
    float GetG() const noexcept SFFDN_NONBLOCKING
    {
        return gain_;
    }
 
    float Tick(float input) noexcept SFFDN_NONBLOCKING;
 
    float Tick(float input, float gain) noexcept SFFDN_NONBLOCKING;
 
    void ProcessBlock(std::span<const float> in, std::span<float> out) noexcept SFFDN_NONBLOCKING;
 
    void ProcessBlockAccumulate(std::span<const float> in, std::span<float> out) noexcept SFFDN_NONBLOCKING;
 
    void Clear();
 
  private:
    Delay delay_;
    SineWave lfo_;
    float gain_;
};
 
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&& other) noexcept;
 
    SchroederAllpassSection& operator=(SchroederAllpassSection&& other) noexcept;
 
    ~SchroederAllpassSection() override = 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 SFFDN_NONBLOCKING override;
 
    uint32_t InputChannelCount() const noexcept SFFDN_NONBLOCKING override;
 
    uint32_t OutputChannelCount() const noexcept SFFDN_NONBLOCKING 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);
 
class TimeVaryingSchroederAllpassSection : public AudioProcessor
{
  public:
    explicit TimeVaryingSchroederAllpassSection(const TimeVaryingSchroederAllpassSectionOptions& config);
 
    TimeVaryingSchroederAllpassSection(const TimeVaryingSchroederAllpassSection&) = default;
    TimeVaryingSchroederAllpassSection& operator=(const TimeVaryingSchroederAllpassSection&) = default;
    TimeVaryingSchroederAllpassSection(TimeVaryingSchroederAllpassSection&&) noexcept = default;
    TimeVaryingSchroederAllpassSection& operator=(TimeVaryingSchroederAllpassSection&&) noexcept = default;
    ~TimeVaryingSchroederAllpassSection() override = default;
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING override;
    uint32_t InputChannelCount() const noexcept SFFDN_NONBLOCKING override;
    uint32_t OutputChannelCount() const noexcept SFFDN_NONBLOCKING override;
    void Clear() override;
    std::unique_ptr<AudioProcessor> Clone() const override;
 
  private:
    std::vector<TimeVaryingSchroederAllpass> allpasses_;
    bool parallel_{false};
};
 
std::unique_ptr<FilterBank> MakeMultichannelTimeVaryingSchroederAllpassSection(
    const MultichannelTimeVaryingSchroederAllpassSectionOptions& options);
 
} // namespace sfFDN