fdn.h

// Copyright (C) 2025 Alexandre St-Onge
// SPDX-License-Identifier: MIT
#pragma once
 
#include "attributes.h"
#include "audio_buffer.h"
#include "audio_processor.h"
#include "delaybank.h"
 
#include <cstddef>
#include <cstdint>
#include <span>
 
namespace sfFDN
{
 
class FDN : public AudioProcessor
{
  public:
    FDN(uint32_t order, uint32_t block_size, bool transpose = false);
 
    ~FDN() override = default;
 
    FDN(const FDN&) = delete;
    FDN& operator=(const FDN&) = delete;
 
    FDN(FDN&& other) noexcept;
 
    FDN& operator=(FDN&& other) noexcept;
 
    void SetOrder(uint32_t order);
 
    uint32_t GetOrder() const;
 
    void SetTranspose(bool transpose);
 
    bool GetTranspose() const;
 
    bool SetInputGains(std::unique_ptr<AudioProcessor> gains);
 
    bool SetOutputGains(std::unique_ptr<AudioProcessor> gains);
 
    bool SetInputGains(std::span<const float> gains);
 
    bool SetOutputGains(std::span<const float> gains);
 
    AudioProcessor* GetInputGains() const;
 
    AudioProcessor* GetOutputGains() const;
 
    void SetDirectGain(float gain);
 
    bool SetLoopFilter(std::unique_ptr<AudioProcessor> filter_bank);
 
    AudioProcessor* GetLoopFilter() const;
 
    bool SetDelayBank(const DelayBankOptions& config);
 
    bool SetDelays(std::span<const float> delays,
                   DelayInterpolationType interpolation_type = DelayInterpolationType::None);
 
    const DelayBank& GetDelayBank() const;
 
    bool SetFeedbackMatrix(std::unique_ptr<AudioProcessor> mixing_matrix);
 
    AudioProcessor* GetFeedbackMatrix() const;
 
    bool SetTCFilter(std::unique_ptr<AudioProcessor> filter);
 
    AudioProcessor* GetTCFilter() const;
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING override;
 
    uint32_t InputChannelCount() const noexcept SFFDN_NONBLOCKING override
    {
        return 1;
    }
 
    uint32_t OutputChannelCount() const noexcept SFFDN_NONBLOCKING override
    {
        return 1;
    }
 
    void Clear() override;
 
    std::unique_ptr<AudioProcessor> Clone() const override;
 
    std::unique_ptr<FDN> CloneFDN() const;
 
  private:
    void TickInternal(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING;
    void Tick(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING;
    void TickTranspose(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING;
    void TickTransposeInternal(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING;
 
    DelayBank delay_bank_;
    std::unique_ptr<AudioProcessor> filter_bank_;
    std::unique_ptr<AudioProcessor> mixing_matrix_;
 
    std::unique_ptr<AudioProcessor> input_gains_;
    std::unique_ptr<AudioProcessor> output_gains_;
 
    uint32_t order_;
    uint32_t block_size_;
    float direct_gain_;
 
    std::vector<float> feedback_;
    std::vector<float> temp_buffer_;
 
    std::unique_ptr<AudioProcessor> tc_filter_;
 
    bool transpose_;
};
} // namespace sfFDN