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);
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept override;
 
    uint32_t InputChannelCount() const override;
 
    uint32_t OutputChannelCount() const 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)
    {
        coeff_ = coeff;
    }
 
    float Tick(float in);
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept override;
 
    uint32_t InputChannelCount() const override;
 
    uint32_t OutputChannelCount() const 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 = {});
    ~CascadedBiquads() = default;
 
    void SetCoefficients(std::span<const FilterCoefficients> coeffs);
 
    float Tick(float in);
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept override;
 
    uint32_t InputChannelCount() const override;
 
    uint32_t OutputChannelCount() const 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();
 
    Fir(const Fir&);
 
    Fir& operator=(const Fir&);
 
    Fir(Fir&&) noexcept;
 
    Fir& operator=(Fir&&) noexcept;
 
    void SetCoefficients(std::span<const float> coeffs);
 
    float Tick(float in);
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept override;
 
    uint32_t InputChannelCount() const override;
 
    uint32_t OutputChannelCount() const 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();
 
    void SetCoefficients(const SparseFirOptions& config = {});
 
    float Tick(float in);
 
    void Process(const AudioBuffer& input, AudioBuffer& output) noexcept override;
 
    uint32_t InputChannelCount() const override;
 
    uint32_t OutputChannelCount() const 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