oscillator.h

// Copyright (C) 2025 Alexandre St-Onge
// SPDX-License-Identifier: MIT
#pragma once
 
#include "attributes.h"
#include "audio_buffer.h"
 
namespace sfFDN
{
class Generator
{
  public:
    Generator() = default;
    virtual ~Generator() = default;
 
    virtual void Generate(std::span<float> output) noexcept SFFDN_NONBLOCKING = 0;
 
  protected:
    // Protected so derived generators keep their implicit copy and move operations while slicing a
    // Generator out of a derived object stays impossible.
    Generator(const Generator&) = default;
    Generator& operator=(const Generator&) = default;
    Generator(Generator&&) noexcept = default;
    Generator& operator=(Generator&&) noexcept = default;
};
 
class SineWave : public Generator
{
  public:
    SineWave(float frequency = 0.0f, float initial_phase = 0.0f);
 
    void ResetPhase();
 
    void SetFrequency(float frequency);
 
    void SetAmplitude(float amplitude);
 
    float GetAmplitude() const;
 
    float GetAmplitudeNonBlocking() const noexcept SFFDN_NONBLOCKING
    {
        return amplitude_;
    }
 
    float GetFrequency() const noexcept SFFDN_NONBLOCKING
    {
        return phase_increment_;
    }
 
    void SetOffset(float offset);
 
    float GetOffset() const;
 
    void SetPhaseOffset(float phase_offset);
 
    float GetPhaseOffset() const noexcept SFFDN_NONBLOCKING
    {
        return phase_offset_;
    }
 
    float NextOut() const noexcept SFFDN_NONBLOCKING;
 
    float Tick() noexcept SFFDN_NONBLOCKING;
 
    void Generate(std::span<float> output) noexcept SFFDN_NONBLOCKING override;
 
    void Multiply(std::span<const float> input, std::span<float> output) noexcept SFFDN_NONBLOCKING;
 
    void MultiplyAccumulate(std::span<const float> input, std::span<float> output) noexcept SFFDN_NONBLOCKING;
 
  private:
    float phase_;
    float phase_increment_;
 
    float amplitude_;
    float offset_;
    float phase_offset_;
};
 
} // namespace sfFDN