patch_directory.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/table_set.hpp"
#include "tabulasonora/tone.hpp"
#include "tabulasonora/wave_descriptor.hpp"
 
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace ts {

enum class ToneMap {
    sc55 = 1,
    sc88 = 2,
    sc88pro = 3,
    sc8820 = 4,
    xg = 0x77,
};

[[nodiscard]] const std::vector<std::pair<std::string, int>>& tone_map_choices() noexcept;

[[nodiscard]] std::string_view tone_map_name(ToneMap map) noexcept;

struct ToneZone {
    int partial_index = 0;
    int velocity_low = 0;
    int velocity_high = 0;
    int key_low = 0;
    int key_high = 0;
    int wave = 0;
    WaveDescriptor descriptor;
};

struct ProgramReference {
    int map = 0;
    int bank = 0;
    int program = 0;
};

struct AlternateEntry {
    std::string name;
    int threshold = 0;
    ProgramReference primary;
    ProgramReference alternate;
};

class PatchDirectory {
public:
    static constexpr int melodic_space_end = 0x4000;

    static constexpr int drum_space_start = 0x4000;

    static constexpr int alternate_space_start = 0x6000;

    static constexpr int indirect_only_flag = 0x8000;

    static constexpr int multisample_stride = 0x8C;

    static constexpr int alternate_stride = 0x18;

    static constexpr int unassigned = 0xFFFF;

    explicit PatchDirectory(const TableSet& tables);

    [[nodiscard]] int tone_count() const noexcept { return tone_count_; }

    [[nodiscard]] int multisample_count() const noexcept { return multisample_count_; }

    [[nodiscard]] int wave_count() const noexcept { return wave_count_; }

    [[nodiscard]] int alternate_count() const noexcept { return alternate_count_; }

    [[nodiscard]] std::optional<WaveDescriptor> wave(int wave_number) const;

    [[nodiscard]] std::optional<Tone> tone(int tone_number) const;

    [[nodiscard]] int tone_level(int tone_number) const;

    [[nodiscard]] bool half_damper(int tone_number) const;

    [[nodiscard]] PartialParameters partial_by_slot(int tone_number, int slot) const;

    [[nodiscard]] std::optional<int> multisample_wave(int multisample, int transposed_key) const;

    [[nodiscard]] int zone_level(int multisample, int key, int key_center) const;

    [[nodiscard]] std::vector<MultisampleZone> multisample_zones(int multisample) const;

    [[nodiscard]] std::optional<std::string> tone_zones(int tone_number,
                                                        std::vector<ToneZone>& zones) const;

    [[nodiscard]] std::optional<int> lut3_raw(int program, ToneMap map, int bank) const;

    [[nodiscard]] std::optional<int> lut3_resolved(int program, ToneMap map, int bank) const;

    [[nodiscard]] std::optional<AlternateEntry> alternate(int index) const;

    [[nodiscard]] std::vector<int> program_tones(int program, ToneMap map, int bank) const;

    [[nodiscard]] int alternate_tone(int program, ToneMap map, int bank) const;

    [[nodiscard]] int program_to_tone(int program, ToneMap map, int bank) const;

    [[nodiscard]] ResolvedTone resolve(int tone_number, int note, int velocity) const;

    [[nodiscard]] ResolvedTone
    resolve_midi(int program, int note, int velocity, ToneMap map, int bank) const;
 
private:
    [[nodiscard]] int dereference(const ProgramReference& reference) const;
 
    const TableSet* tables_;
    std::span<const std::uint8_t> tone_;
    std::span<const std::uint8_t> multisample_;
    std::span<const std::uint8_t> wavedesc_;
    std::span<const std::uint8_t> layered_;
 
    int tone_count_ = 0;
    int multisample_count_ = 0;
    int wave_count_ = 0;
    int alternate_count_ = 0;
};
 
} // namespace ts