time_varying_feedback_matrix.h

// Copyright (C) 2026 Alexandre St-Onge
// SPDX-License-Identifier: MIT
#pragma once
 
#include "sffdn/audio_processor.h"
#include "sffdn/oscillator.h"
#include "sffdn/types.h"
 
#include <cstdint>
#include <memory>
#include <span>
#include <vector>
 
namespace sfFDN
{
 
namespace detail
{
class TimeVaryingFeedbackMatrixTestAccess;
}
 
class TimeVaryingFeedbackMatrix : public AudioProcessor
{
  public:
    explicit TimeVaryingFeedbackMatrix(const TimeVaryingFeedbackMatrixOptions& options);
 
    void SetModulation(std::span<const ModulationOptions> modulation_configs);
 
    void SetLfoFrequency(std::span<const float> frequencies);
 
    void SetLfoAmplitude(std::span<const float> amplitudes);
 
    void SetLfoPhaseOffset(std::span<const float> phase_offsets);
 
    void SetBaseAngles(std::span<const float> radians);
 
    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;
 
    uint32_t RotationBlockCount() const noexcept SFFDN_NONBLOCKING;
 
    bool GetMatrix(std::span<float> matrix, uint64_t sample_index = 0) const;
 
    void Clear() override;
 
    std::unique_ptr<AudioProcessor> Clone() const override;
 
  private:
    friend class detail::TimeVaryingFeedbackMatrixTestAccess;
 
    TimeVaryingFeedbackMatrix(const TimeVaryingFeedbackMatrixOptions& options,
                              std::span<const float> custom_base_matrix);
 
    uint32_t order_;
    TimeVaryingMatrixMode mode_;
    std::vector<float> base_angles_;
    std::vector<SineWave> lfos_;
    std::vector<float> lfo_phases_;
    std::vector<float> schur_basis_;
    std::vector<uint32_t> rotation_starts_;
    std::vector<float> scalar_signs_;
    std::vector<float> scratch_;
};
 
} // namespace sfFDN