nonlinear.h

// Copyright (C) 2026 Alexandre St-Onge
// SPDX-License-Identifier: MIT
#pragma once
 
#include "sffdn/attributes.h"
#include "sffdn/audio_buffer.h"
#include "sffdn/audio_processor.h"
#include "sffdn/filterbank.h"
#include "sffdn/oscillator.h"
#include "sffdn/types.h"
 
#include <cstdint>
#include <memory>
 
namespace sfFDN
{
 
class DcBlocker;
 
class ControllableFullWaveRectifier : public AudioProcessor
{
  public:
    static constexpr float kAntialiasingEpsilon = 1e-5f;
 
    explicit ControllableFullWaveRectifier(const ControllableFullWaveRectifierOptions& options = {});
 
    ControllableFullWaveRectifier(const ControllableFullWaveRectifier& other);
    ControllableFullWaveRectifier& operator=(const ControllableFullWaveRectifier& other);
    ControllableFullWaveRectifier(ControllableFullWaveRectifier&&) noexcept;
    ControllableFullWaveRectifier& operator=(ControllableFullWaveRectifier&&) noexcept;
    ~ControllableFullWaveRectifier() override;
 
    void SetAlpha(float alpha);
 
    float GetAlpha() const noexcept SFFDN_NONBLOCKING;
 
    float GetCompensationGain() const noexcept SFFDN_NONBLOCKING;
 
    float Tick(float input) 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 Rectify(float input) const noexcept SFFDN_NONBLOCKING;
 
    std::unique_ptr<DcBlocker> dc_blocker_;
 
    float alpha_;
    float compensation_gain_;
    bool antialiasing_;
 
    float prev_input_{0.f};
};
 
class SignalDependentFractionalDelay : public AudioProcessor
{
  public:
    explicit SignalDependentFractionalDelay(const SignalDependentFractionalDelayOptions& options = {});
 
    void SetD(float d);
 
    float GetD() const noexcept SFFDN_NONBLOCKING;
 
    float Tick(float input) 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 d_;
 
    float prev_positive_{0.f};
    float prev_prev_positive_{0.f};
    float prev_negative_{0.f};
};
 
class RingModulator : public AudioProcessor
{
  public:
    explicit RingModulator(const RingModulatorOptions& options = {});
 
    float GetFrequency() const noexcept SFFDN_NONBLOCKING;
 
    float GetAmplitude() const noexcept SFFDN_NONBLOCKING;
 
    float Tick(float input) 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:
    SineWave lfo_;
};
 
std::unique_ptr<FilterBank> MakeMultichannelControllableFullWaveRectifier(
    const MultichannelControllableFullWaveRectifierOptions& options);
 
MultichannelControllableFullWaveRectifierOptions MakeMultichannelControllableFullWaveRectifierOptions(
    float alpha, float sample_rate, uint32_t channel_count, uint32_t active_channel_count = 0);
 
std::unique_ptr<FilterBank> MakeMultichannelSignalDependentFractionalDelay(
    const MultichannelSignalDependentFractionalDelayOptions& options);
 
MultichannelSignalDependentFractionalDelayOptions MakeMultichannelSignalDependentFractionalDelayOptions(
    float d, uint32_t channel_count, uint32_t active_channel_count = 0);
 
std::unique_ptr<FilterBank> MakeMultichannelRingModulator(const MultichannelRingModulatorOptions& options);
 
MultichannelRingModulatorOptions MakeMultichannelRingModulatorOptions(float frequency, float amplitude,
                                                                     uint32_t channel_count,
                                                                     uint32_t active_channel_count = 0);
 
} // namespace sfFDN