sequence.hpp

Go to the documentation of this file.

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

class ControllerTimeline {
public:
    void add(std::int64_t position, int value) { points_.push_back(Point{position, value}); }

    [[nodiscard]] int value_at(std::int64_t position, int fallback) const noexcept;

    [[nodiscard]] std::size_t size() const noexcept { return points_.size(); }

    bool fill(std::int64_t start, std::span<int> destination, int fallback) const noexcept;
 
private:
    struct Point {
        std::int64_t position = 0;
        int value = 0;
    };
 
    std::vector<Point> points_;
};

class DrumKeyOverrides {
public:
    static constexpr int centre = 0x40;

    static constexpr int random_pan = 0;
 
    DrumKeyOverrides() { reset(); }

    [[nodiscard]] bool is_empty() const noexcept { return !any_; }

    void reset() noexcept;

    void set_pitch(int note, int entry) noexcept;

    void set_pan(int note, int entry) noexcept;

    void set_play_key(int note, int entry) noexcept;

    void set_level(int note, int entry) noexcept;

    void set_group(int note, int entry) noexcept;

    void set_reverb(int note, int entry) noexcept;
    void set_chorus(int note, int entry) noexcept;
    void set_delay(int note, int entry) noexcept;

    void set_rx_note_off(int note, bool on) noexcept;
    void set_rx_note_on(int note, bool on) noexcept;

    [[nodiscard]] int pitch_offset(int note) const noexcept;

    [[nodiscard]] std::optional<int> pan(int note) const noexcept;

    [[nodiscard]] std::optional<int> play_key(int note) const noexcept;

    [[nodiscard]] std::optional<int> level(int note) const noexcept;

    [[nodiscard]] std::optional<int> group(int note) const noexcept;

    [[nodiscard]] std::optional<bool> rx_note_off(int note) const noexcept;
    [[nodiscard]] std::optional<bool> rx_note_on(int note) const noexcept;

    [[nodiscard]] std::optional<int> pan_for_hit(int note, EngineNoise& noise) const;

    [[nodiscard]] static DrumKey
    apply(DrumKey key, int pitch_offset, std::optional<int> pan) noexcept;
 
private:
    std::array<int, DrumKitTable::key_count> pitch_{};
    std::array<int, DrumKitTable::key_count> pan_{};
    // The drum-setup planes, -1 where the key follows its kit record.
    std::array<int, DrumKitTable::key_count> play_key_{};
    std::array<int, DrumKitTable::key_count> level_{};
    std::array<int, DrumKitTable::key_count> group_{};
    std::array<int, DrumKitTable::key_count> reverb_{};
    std::array<int, DrumKitTable::key_count> chorus_{};
    std::array<int, DrumKitTable::key_count> delay_{};
    std::array<int, DrumKitTable::key_count> rx_note_off_{};
    std::array<int, DrumKitTable::key_count> rx_note_on_{};
    bool any_ = false;
};

struct NoteRecord {
    int channel = 0;
    int note = 0;
    int velocity = 0;
    std::int64_t on = 0;
    std::int64_t off = 0;
    int program = 0;
    int bank = 0;
    int pan = 0;
    int volume = 0;
    int expression = 0;
    int reverb_send = 0;
    int chorus_send = 0;
    int delay_send = 0;
    int drum_pitch = 0;
    std::optional<int> drum_pan;
};

struct PartTimelines {
    ControllerTimeline volume;
    ControllerTimeline expression;
    ControllerTimeline pan;
    ControllerTimeline bend;
    ControllerTimeline bend_range;
    ControllerTimeline damper;
    ControllerTimeline modulation;
    ControllerTimeline reverb_send;
    ControllerTimeline chorus_send;
    ControllerTimeline delay_send;
    ControllerTimeline program;
    ControllerTimeline bank;

    ControllerTimeline vibrato_rate;
    ControllerTimeline vibrato_depth;
    ControllerTimeline vibrato_delay;
    ControllerTimeline tvf_cutoff;
    ControllerTimeline env_attack;
    ControllerTimeline env_decay;
    ControllerTimeline env_release;

    ControllerTimeline velocity_depth;
    ControllerTimeline velocity_offset;

    ControllerTimeline channel_pressure;
    ControllerTimeline matrix_modulation_pitch;
    ControllerTimeline matrix_pressure_pitch;
};

struct Sequence {
    static constexpr int channel_count = 16;

    std::array<PartTimelines, channel_count> parts;
    std::vector<NoteRecord> notes;
    ControllerTimeline master_volume;
    ControllerTimeline reverb_type;
    ControllerTimeline chorus_type;
    ControllerTimeline delay_type;
    std::int64_t last_event_position = 0;
};

namespace sequence_builder {

inline constexpr int default_volume = 100;
inline constexpr int default_expression = 127;
inline constexpr int default_pan = 64;
inline constexpr int default_master = 127;
inline constexpr int default_reverb_send = 40;
inline constexpr int default_chorus_send = 0;

[[nodiscard]] Sequence build(std::span<const MidiEvent> events);

[[nodiscard]] constexpr int channel_from_block(int block) noexcept
{
    return block == 0 ? 9 : block <= 9 ? block - 1 : block;
}
 
} // namespace sequence_builder
} // namespace ts