pitch_chain.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/engine_noise.hpp"
#include "tabulasonora/envelope_machine.hpp"
#include "tabulasonora/partial_parameters.hpp"
#include "tabulasonora/table_set.hpp"
#include "tabulasonora/wave_descriptor.hpp"
 
#include <array>
#include <cstdint>
#include <optional>
#include <vector>
 
namespace ts {

struct PitchEnvelope {
    int start = 0;
    std::array<int, 4> targets{};
    int release = 0;
    std::array<double, 4> times{};
    double release_ms = 0.0;
};

class PitchEnvelopeRunner {
public:
    explicit PitchEnvelopeRunner(const PitchEnvelope& envelope, bool ignore_note_off = false);

    [[nodiscard]] static PitchEnvelopeRunner constant(double level);

    [[nodiscard]] double level() const noexcept { return level_; }

    void set_release_damper(int damper) noexcept;

    double tick(bool released) noexcept;
 
private:
    PitchEnvelopeRunner() = default;
 
    [[nodiscard]] int scaled_release_rate() const noexcept;
 
    std::vector<int> targets_;
    std::vector<int> rates_;
    int release_ = 0;
    int release_rate_ = 0;
    bool ignore_note_off_ = false;
 
    double segment_start_ = 0.0;
    double level_ = 0.0;
    int segment_ = 0;
    int phase_ = 0;
    bool released_ = false;
    int release_damper_ = 0;
};

class PitchChain {
public:
    static constexpr int max_pitch_milli_semitones = 0x1F018;

    static constexpr int drum_key_centre = 60;

    struct KeyFollow {
        int key = 0;
        int weight = 0;
    };

    PitchChain(const TableSet& tables,
               const EnvelopeMachine& envelope,
               EngineNoise* noise = nullptr);

    [[nodiscard]] static KeyFollow
    key_follow_key(const PartialParameters& partial, int note, int key_center = 0x3C) noexcept;

    [[nodiscard]] int base_pitch_milli_semitones(const PartialParameters& partial,
                                                 int note,
                                                 int key_center = 0x3C) const noexcept;

    [[nodiscard]] static int drum_pitch_milli_semitones(const PartialParameters& partial,
                                                        int coarse_pitch) noexcept;

    [[nodiscard]] int portamento_step(int time) const noexcept;

    [[nodiscard]] static int portamento_offset(int from_key, int target_pitch) noexcept;

    [[nodiscard]] static double bend_offset_milli_semitones(int bend = 8192,
                                                            double semitone_range = 2.0) noexcept;

    [[nodiscard]] std::optional<PitchEnvelope>
    envelope_offsets(const PartialParameters& partial, int key, int velocity) const noexcept;

    [[nodiscard]] static int segment_rate_word(double milliseconds) noexcept;

    [[nodiscard]] std::optional<std::vector<double>>
    envelope_ticks(const PartialParameters& partial,
                   int key,
                   int velocity,
                   double hold_seconds,
                   int tick_count) const;

    [[nodiscard]] static int start_jitter_milli_semitones(int depth, std::uint16_t draw) noexcept;

    [[nodiscard]] std::optional<PitchEnvelopeRunner>
    create_envelope_runner(const PartialParameters& partial, int key, int velocity) const;

    [[nodiscard]] static double ratio(const PartialParameters& partial,
                                      const WaveDescriptor& descriptor,
                                      double pitch_milli_semitones) noexcept;

    [[nodiscard]] static double clamp(double milli_semitones) noexcept;
 
private:
    const EnvelopeMachine* envelope_;
    EngineNoise* noise_;
    EngineNoise owned_noise_;
 
    std::span<const std::uint16_t> portamento_step_;
    std::span<const std::uint8_t> pitch_bias_;
    std::span<const std::uint16_t> depth_velocity_sensitivity_;
    std::span<const std::uint8_t> rate_key_follow0_;
    std::span<const std::uint8_t> rate_key_follow1_;
    std::span<const std::int16_t> key_follow_;
    std::span<const std::uint16_t> rate_curve_;

    std::array<std::int16_t, 0x80> depth_slope_{};
};
 
} // namespace ts