filter.h

// Copyright (C) 2025 Alexandre St-Onge
// SPDX-License-Identifier: MIT
#pragma once
 
#include "sffdn/audio_processor.h"
#include "sffdn/delay.h"
#include "sffdn/types.h"
 
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <span>
#include <vector>
 
namespace sfFDN
{
 
class OnePoleFilter : public AudioProcessor
{
  public:
    OnePoleFilter(float b0 = 1.f, float a1 = 0.f);
 
    void SetPole(float pole);
 
    void SetCoefficients(float b0, float a1);
 
    void SetDecayFilter(float decay_db, float time_ms, float sample_rate);
 
    void SetLowpass(float cutoff);
 
    float Tick(float in) noexcept SFFDN_NONBLOCKING;
 
    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:
    float b0_, a1_;
    std::array<float, 2> state_;
};
 
class AllpassFilter : public AudioProcessor
{
  public:
    AllpassFilter(const AllpassFilterOptions& config = {});
 
    void SetCoefficients(float coeff) noexcept SFFDN_NONBLOCKING
    {
        coeff_ = coeff;
    }
 
    void WarpState(float last_in, float coeff) noexcept SFFDN_NONBLOCKING
    {
        last_in_ = last_in;
        coeff_ = coeff;
    }
 
    float Tick(float in) noexcept SFFDN_NONBLOCKING;
 
    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:
    float coeff_;
    float last_in_;
    float last_out_;
};
 
class CascadedBiquads : public AudioProcessor
{
  public:
    CascadedBiquads(const CascadedBiquadsOptions& config = {});
 
    void SetCoefficients(std::span<const FilterCoefficients> coeffs);
 
    float Tick(float in) noexcept SFFDN_NONBLOCKING;
 
    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;
 
    struct IIRState
    {
        float s0, s1;
    };
 
  private:
    uint32_t stage_;
    std::vector<IIRState> states_;
    std::vector<FilterCoefficients> coeffs_;
};
 
class Fir : public AudioProcessor
{
  public:
    Fir(const FirOptions& config = {});
    ~Fir() override;
 
    Fir(const Fir& other);
 
    Fir& operator=(const Fir& other);
 
    Fir(Fir&& other) noexcept;
 
    Fir& operator=(Fir&& other) noexcept;
 
    void SetCoefficients(std::span<const float> coeffs);
 
    float Tick(float in) noexcept SFFDN_NONBLOCKING;
 
    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:
    class FirImpl;
    std::unique_ptr<FirImpl> impl_;
};
 
class SparseFir : public AudioProcessor
{
  public:
    SparseFir(const SparseFirOptions& config = {});
    ~SparseFir() override;
 
    // impl_ is a unique_ptr to an incomplete type, so the destructor must be defined out of line,
    // which suppresses the implicit move operations. Declare them explicitly so a SparseFir can be
    // moved instead of silently failing to compile. The pimpl cannot be copied; use Clone().
    SparseFir(const SparseFir&) = delete;
    SparseFir& operator=(const SparseFir&) = delete;
    SparseFir(SparseFir&& other) noexcept;
    SparseFir& operator=(SparseFir&& other) noexcept;
 
    void SetCoefficients(const SparseFirOptions& config = {});
 
    float Tick(float in) noexcept SFFDN_NONBLOCKING;
 
    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:
    class SparseFirImpl;
    std::unique_ptr<SparseFirImpl> impl_;
 
    SparseFirOptions config_;
};
 
std::unique_ptr<AudioProcessor> MakeFirFilter(const FirOptions& config, float sparse_threshold = 0.25f);
 
} // namespace sfFDN