midi_parameter_map.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <pulp/runtime/spsc_queue.hpp>
#include <pulp/state/store.hpp>
 
namespace pulp::state {

struct MidiMapScale {
    float min = 0.0f;
    float max = 1.0f;

    float apply(uint8_t value) const {
        return min + (value / 127.0f) * (max - min);
    }
};
 
class MidiParameterMap {
  public:
    static constexpr uint8_t kOmni = 0xFF;
 
    // ── UI thread ──

    void set_mapping(uint8_t channel, uint8_t cc, ParamID id) {
        set_mapping(channel, cc, id, MidiMapScale{});
    }

    void set_mapping(uint8_t channel, uint8_t cc, ParamID id, MidiMapScale scale) {
        commands_.try_push({Command::Set, channel, cc, id, clamp_scale(scale)});
    }

    void arm_learn(ParamID id) {
        arm_learn(id, MidiMapScale{});
    }

    void arm_learn(ParamID id, MidiMapScale scale) {
        commands_.try_push({Command::Arm, kOmni, 0, id, clamp_scale(scale)});
    }

    void clear(ParamID id) {
        commands_.try_push({Command::Clear, kOmni, 0, id, MidiMapScale{}});
    }
 
    // ── audio thread ──

    void pump() {
        while (auto cmd = commands_.try_pop()) {
            switch (cmd->type) {
            case Command::Set:
                insert(cmd->channel, cmd->cc, cmd->id, cmd->scale);
                break;
            case Command::Arm:
                learn_armed_ = true;
                learn_target_ = cmd->id;
                learn_scale_ = cmd->scale;
                break;
            case Command::Clear:
                remove_target(cmd->id);
                break;
            }
        }
    }

    void handle_cc(StateStore& store, uint8_t channel, uint8_t cc, uint8_t value) {
        if (learn_armed_) {
            insert(channel, cc, learn_target_, learn_scale_);
            learn_armed_ = false;
        }
        for (std::size_t i = 0; i < count_; ++i) {
            const auto& m = map_[i];
            if (m.cc == cc && (m.channel == kOmni || m.channel == channel))
                store.set_normalized_rt(m.id, m.scale.apply(value));
        }
    }
 
    bool learn_armed() const {
        return learn_armed_;
    }
 
  private:
    struct Command {
        enum Type { Set, Arm, Clear } type;
        uint8_t channel;
        uint8_t cc;
        ParamID id;
        MidiMapScale scale;
    };
    struct Mapping {
        uint8_t channel;
        uint8_t cc;
        ParamID id;
        MidiMapScale scale;
    };
 
    static MidiMapScale clamp_scale(MidiMapScale scale) {
        scale.min = std::isfinite(scale.min) ? std::clamp(scale.min, 0.0f, 1.0f) : 0.0f;
        scale.max = std::isfinite(scale.max) ? std::clamp(scale.max, 0.0f, 1.0f) : 1.0f;
        return scale;
    }
 
    void insert(uint8_t channel, uint8_t cc, ParamID id, MidiMapScale scale) {
        for (std::size_t i = 0; i < count_; ++i) {
            if (map_[i].channel == channel && map_[i].cc == cc) {
                map_[i].id = id;
                map_[i].scale = scale;
                return;
            }
        }
        if (count_ < kMaxMappings)
            map_[count_++] = {channel, cc, id, scale};
    }
 
    void remove_target(ParamID id) {
        std::size_t w = 0;
        for (std::size_t i = 0; i < count_; ++i)
            if (map_[i].id != id)
                map_[w++] = map_[i];
        count_ = w;
    }
 
    static constexpr std::size_t kMaxMappings = 64;
    std::array<Mapping, kMaxMappings> map_{};
    std::size_t count_ = 0;
    bool learn_armed_ = false;
    ParamID learn_target_ = 0;
    MidiMapScale learn_scale_{};
    pulp::runtime::SpscQueue<Command, 64> commands_;
};
 
} // namespace pulp::state