send_effects.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/effect_presets.hpp"
 
#include <array>
#include <cstdint>
#include <optional>
#include <span>
#include <vector>
 
namespace ts {

class Effect {
public:
    virtual ~Effect() = default;

    virtual void
    process(std::span<const float> input, std::span<float> left, std::span<float> right) = 0;

    virtual void reset() = 0;
};

class DcBlocker {
public:
    static constexpr double input_coefficient = 0.99804;
    static constexpr double state_coefficient = -0.003919;
 
    void reset() noexcept { state_ = 0.0; }
 
    [[nodiscard]] double process(double input) noexcept
    {
        const double output = (input * input_coefficient) + state_;
        state_ += output * state_coefficient;
        return output;
    }
 
private:
    double state_ = 0.0;
};

class Reverb final : public Effect {
public:
    static constexpr int ring_size = 65536;
 
    explicit Reverb(const ReverbPreset& preset) : preset_(preset) {}

    [[nodiscard]] static Reverb for_type(std::optional<int> type);

    [[nodiscard]] static double send_gain(int controller) noexcept
    {
        return ReverbPresets::send_at_full_scale * (controller / 127.0);
    }
 
    void reset() override;
 
    void
    process(std::span<const float> input, std::span<float> left, std::span<float> right) override;

    void process(std::span<const float> input,
                 std::span<const float> chorus_left,
                 std::span<const float> chorus_right,
                 std::span<float> left,
                 std::span<float> right);
 
private:
    static constexpr int ring_mask = ring_size - 1;
    static constexpr int input_tap = 0x1000;
 
    void run_tank(const TankTaps& taps,
                  const ReverbTank& tank,
                  const AllpassStage& first,
                  const AllpassStage& second,
                  double carry,
                  double feedback,
                  double& state) noexcept;
 
    ReverbPreset preset_;
    std::vector<double> ring_ = std::vector<double>(ring_size, 0.0);
 
    double dc_state_ = 0.0;
    double damp_ = 0.0;
    double tank_state_a_ = 0.0;
    double tank_state_b_ = 0.0;
    int write_cursor_ = 0;
};

class Chorus final : public Effect {
public:
    static constexpr int ring_size = 65536;
 
    explicit Chorus(const ChorusPreset& preset) : preset_(preset) {}

    [[nodiscard]] static Chorus for_type(std::optional<int> type);

    [[nodiscard]] static double send_gain(int controller) noexcept
    {
        return ChorusPresets::send_at_full_scale * (controller / 127.0);
    }
 
    void reset() override;
 
    void
    process(std::span<const float> input, std::span<float> left, std::span<float> right) override;
 
private:
    static constexpr int ring_mask = ring_size - 1;
    static constexpr int phase_sign = 1 << 24;
    static constexpr int phase_half = 1 << 23;
 
    [[nodiscard]] double read_tap(int depth, int base_delay, int triangle) const noexcept;
 
    ChorusPreset preset_;
    std::vector<double> ring_ = std::vector<double>(ring_size, 0.0);
 
    int phase_ = 0;
    double dc_state_ = 0.0;
    double lowpass_ = 0.0;
    double feedback_ = 0.0;
    int write_cursor_ = 0;
};

struct DelayParameters {
    int centre_samples = 1;
    int left_samples = 1;
    int right_samples = 1;
    double centre_gain = 0.0;
    double left_gain = 0.0;
    double right_gain = 0.0;
    double feedback = 0.0;
    int pre_low_pass = 0;
    double send_to_reverb = 0.0;
};

class SystemDelay final : public Effect {
public:
    static constexpr int ring_size = 1 << 17;
 
    explicit SystemDelay(const DelayParameters& parameters);

    [[nodiscard]] static SystemDelay for_type(int type);

    [[nodiscard]] static double send_gain(int send) noexcept
    {
        return DelayPresets::send_at_full_scale * (send / 127.0);
    }

    [[nodiscard]] static double time_milliseconds(int raw);

    [[nodiscard]] static double ratio_percent(int raw);

    [[nodiscard]] static DelayParameters compile(std::span<const int> raw, int sample_rate = 32000);
 
    void reset() override;
 
    void
    process(std::span<const float> input, std::span<float> left, std::span<float> right) override;
 
private:
    static constexpr int ring_mask = ring_size - 1;
 
    DelayParameters parameters_;
    std::vector<double> ring_ = std::vector<double>(ring_size, 0.0);
 
    int pre_delay_ = DelayPresets::pre_delay_samples;
    double pre_low_pass_coefficient_ = 0.0;
    std::vector<float> pending_left_;
    std::vector<float> pending_right_;
    int pending_ = 0;
    double lowpass_ = 0.0;
    int write_cursor_ = 0;
};
 
} // namespace ts