audio_processor.h

// Copyright (C) 2025 Alexandre St-Onge
// SPDX-License-Identifier: MIT
#pragma once
 
#include "attributes.h"
#include "audio_buffer.h"
 
#include <nlohmann/json.hpp>
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace sfFDN
{
class AudioProcessor
{
  public:
    AudioProcessor() = default;
    virtual ~AudioProcessor() = default;
 
    virtual void Process(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING = 0;
 
    virtual uint32_t InputChannelCount() const noexcept SFFDN_NONBLOCKING = 0;
 
    virtual uint32_t OutputChannelCount() const noexcept SFFDN_NONBLOCKING = 0;
 
    virtual void Clear() = 0;
 
    virtual std::unique_ptr<AudioProcessor> Clone() const = 0;
 
  protected:
    // Polymorphic copying goes through Clone(). These are protected rather than public so that a
    // derived class still gets its implicit copy and move operations, while slicing an
    // AudioProcessor out of a derived object stays impossible. Declaring them here also stops the
    // destructor above from suppressing the implicit move operations of derived classes.
    AudioProcessor(const AudioProcessor&) = default;
    AudioProcessor& operator=(const AudioProcessor&) = default;
    AudioProcessor(AudioProcessor&&) noexcept = default;
    AudioProcessor& operator=(AudioProcessor&&) noexcept = default;
};
 
class AudioProcessorChain : public AudioProcessor
{
  public:
    AudioProcessorChain(uint32_t block_size);
 
    bool AddProcessor(std::unique_ptr<AudioProcessor>&& processor);
 
    uint32_t GetProcessorCount() const;
 
    AudioProcessor* GetProcessor(uint32_t index) 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:
    uint32_t block_size_ = 0;
    std::vector<std::unique_ptr<AudioProcessor>> processors_;
 
    std::vector<float> work_buffer_a_;
    std::vector<float> work_buffer_b_;
    uint32_t max_work_buffer_size_ = 0;
 
    void ProcessInternal(const AudioBuffer& input, AudioBuffer& output) noexcept SFFDN_NONBLOCKING;
};
} // namespace sfFDN