tvf_chain.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/envelope_machine.hpp"
#include "tabulasonora/part_modifiers.hpp"
#include "tabulasonora/partial_parameters.hpp"
#include "tabulasonora/segment_envelope.hpp"
#include "tabulasonora/state_variable_filter.hpp"
#include "tabulasonora/table_set.hpp"
 
#include <array>
#include <cstdint>
#include <span>
#include <vector>
 
namespace ts {

class TvfChain {
public:
    static constexpr int control_block_samples = 320;

    struct Offsets {
        int peak = 0;
        std::array<int, 4> segments{};
        int release = 0;
    };

    struct Envelope {
        SegmentEnvelope offsets;
        int base_cutoff = 0;
    };

    struct Coefficients {
        double frequency = 0.0;
        double damping = 0.0;
    };

    TvfChain(const TableSet& tables, const EnvelopeMachine& envelope);

    [[nodiscard]] FilterTap tap(int filter_type) const noexcept;

    [[nodiscard]] static int resonance_byte(const PartialParameters& partial,
                                            int part_resonance = 0x40,
                                            int part_resonance_default = 0x40) noexcept;

    [[nodiscard]] int cutoff_units(double cutoff15, int resonance_byte) const noexcept;

    [[nodiscard]] double frequency_coefficient(int units) const noexcept;

    [[nodiscard]] double
    damping_coefficient(int units, int resonance_byte, int filter_type) const noexcept;

    [[nodiscard]] Coefficients
    coefficients(int units, int resonance_byte, int filter_type) const noexcept;

    [[nodiscard]] std::span<const std::int32_t> ramp_exp() const noexcept { return ramp_exp_; }

    [[nodiscard]] double
    cutoff_hz(double cutoff15, int resonance_byte, int sample_rate = 32000) const noexcept;

    [[nodiscard]] int effective_velocity(const PartialParameters& partial,
                                         int velocity) const noexcept;

    [[nodiscard]] Offsets
    envelope_offsets(const PartialParameters& partial, int key, int velocity) const;

    [[nodiscard]] Envelope create_envelope(const PartialParameters& partial,
                                           int velocity,
                                           int key,
                                           int sample_rate = 32000,
                                           const PartModifiers& modifiers = {}) const;

    [[nodiscard]] static bool responds_to_env_modifiers(const PartialParameters& partial) noexcept
    {
        return (partial.raw()[0x0E] & 0x10) != 0;
    }

    [[nodiscard]] std::vector<double> envelope(const PartialParameters& partial,
                                               int velocity,
                                               int key,
                                               double hold_seconds,
                                               double tail_seconds,
                                               int sample_rate = 32000) const;

    void apply(std::span<float> signal,
               std::span<const double> cutoff15,
               int filter_type,
               int resonance_byte,
               int block_samples = control_block_samples) const noexcept;
 
private:
    // The env-depth region is addressed by absolute VA in the decompile. Relative to the start of
    // the cached slice (VA 0x1819a2f00) the two sub-tables sit here:
    //   0x1819a3028 - 0x1819a2f00 = 0x128   (depth below neutral)
    //   0x1819a2fa8 - 0x1819a2f00 = 0x0a8   (depth at or above neutral)
    static constexpr int env_depth_low_branch = 0x128;
    static constexpr int env_depth_high_branch = 0x0A8;
 
    // g_pitch_bias lives inside the pitch-envelope export: 0x1819a2890 - 0x1819a2578 = 0x318.
    static constexpr int pitch_bias_offset = 0x318;
 
    [[nodiscard]] int env_depth_word(int offset) const;
    [[nodiscard]] int pitch_bias(int magnitude) const;

    [[nodiscard]] int damping_raw(int units, int resonance_byte, int filter_type) const noexcept;
 
    const EnvelopeMachine* envelope_machine_;
    std::span<const std::uint8_t> env_depth_;
    std::span<const std::uint8_t> pitch_env_;
    std::span<const std::int16_t> env_depth_key_follow_;
    std::span<const std::int16_t> reso_curve_;
    std::span<const std::uint8_t> rate_key_follow_;
    std::span<const std::uint32_t> filter_type_coef_;
    std::span<const std::uint16_t> warp_;
    std::span<const std::uint16_t> ceiling_;
    std::span<const std::uint16_t> q_low_pass_;
    std::span<const std::uint16_t> q_type6_;
    std::span<const std::int32_t> ramp_exp_;
    std::span<const float> f_ceiling_;
    std::span<const std::uint8_t> velocity_sensitivity_;
};
 
} // namespace ts