effect_presets.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
 
namespace ts {

struct AllpassStage {
    int write_tap = 0;
    int read_tap = 0;
    double coef_a = 0.0;
    double coef_b = 0.0;
};

struct TankTaps {
    int tap10 = 0;
    int tap14 = 0;
    int tap18 = 0;
    int tap1c = 0;
    int tap20 = 0;
    int tap24 = 0;
    int tap28 = 0;
    int tap2c = 0;
};

struct ReverbTank {
    TankTaps taps;
    double coef_a = 0.0;
    double coef_b = 0.0;
};

struct TankAllpasses {
    AllpassStage a0;
    AllpassStage a1;
    AllpassStage b0;
    AllpassStage b1;
};

struct ReverbPreset {
    std::array<AllpassStage, 4> diffusers;
    ReverbTank tank_a;
    ReverbTank tank_b;
    TankAllpasses tank_allpasses;
    int injection_tap = 0;
    double damp_feedback = 0.0;
    double damp_input = 0.0;
    double gain_input = 0.0;
    double gain_injection = 0.0;
    double gain_feedback = 0.0;
    double gain_output = 0.0;
};

struct ChorusPreset {
    int lfo_increment = 0;
    double lpf_a = 0.0;
    double lpf_b = 0.0;
    int tap1_depth = 0;
    int tap1_base = 0;
    int tap2_depth = 0;
    int tap2_base = 0;
    double feedback = 0.0;
    double gain_write = 0.0;
    double gain_tap = 0.0;
};

struct ReverbPresets {
    static constexpr double send_at_full_scale = 1.02;
 
    std::vector<std::string> type_names;
    ReverbPreset defaults;
    std::vector<ReverbPreset> types;
};

struct ChorusPresets {
    static constexpr double send_at_full_scale = 0.3428;
 
    std::vector<std::string> type_names;
    ChorusPreset defaults;
    std::vector<ChorusPreset> types;
};

struct DelayPresets {
    static constexpr double send_at_full_scale = 0.356;

    static constexpr int pre_delay_samples = 1920;

    static constexpr std::array<double, 8> pre_low_pass_coefficients{
        0.0, 0.10, 0.18, 0.28, 0.40, 0.55, 0.70, 0.84};
 
    std::vector<std::string> type_names;
    std::vector<double> time_milliseconds;
    std::vector<double> ratio_percent;
    std::vector<std::array<int, 10>> raw_presets;
};

struct EqBand {
    double b0 = 1.0;
    double b1 = 0.0;
    double a1 = 0.0;
};

struct EqPresets {
    static constexpr int gain_count = 25;

    static constexpr int gain_base = 0x34;

    static constexpr std::array<int, 2> low_frequencies{200, 400};
    static constexpr std::array<int, 2> high_frequencies{3000, 6000};

    std::array<std::array<EqBand, gain_count>, 2> low{};
    std::array<std::array<EqBand, gain_count>, 2> high{};

    [[nodiscard]] const EqBand& low_band(int frequency, int gain) const noexcept;
    [[nodiscard]] const EqBand& high_band(int frequency, int gain) const noexcept;
};
 
class RomImage;

class EffectPresets {
public:
    static constexpr std::string_view path_variable = "TABULASONORA_PRESETS";

    [[nodiscard]] static const EffectPresets& defaults();

    static void ensure_from(const RomImage& rom);

    static void use(EffectPresets presets);

    [[nodiscard]] static bool available();

    [[nodiscard]] static EffectPresets
    from_parts(ReverbPresets reverb, ChorusPresets chorus, DelayPresets delay, EqPresets eq = {});

    [[nodiscard]] static EffectPresets parse(std::string_view json);
 
    [[nodiscard]] const ReverbPresets& reverb() const noexcept { return reverb_; }
 
    [[nodiscard]] const ChorusPresets& chorus() const noexcept { return chorus_; }
 
    [[nodiscard]] const DelayPresets& delay() const noexcept { return delay_; }

    [[nodiscard]] const EqPresets& eq() const noexcept { return eq_; }

    [[nodiscard]] bool has_eq() const noexcept { return has_eq_; }
 
private:
    ReverbPresets reverb_;
    ChorusPresets chorus_;
    DelayPresets delay_;
    EqPresets eq_;
    bool has_eq_ = false;
};
 
} // namespace ts