osc_parameter_map.hpp

Go to the documentation of this file.

#pragma once

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

struct OscMapScale {
    float in_min = 0.0f;
    float in_max = 1.0f;
    float out_min = 0.0f;
    float out_max = 1.0f;

    float apply(float value) const {
        if (!std::isfinite(value))
            return out_min;
        const float span = in_max - in_min;
        if (span == 0.0f)
            return out_min;
        const float t = std::clamp((value - in_min) / span, 0.0f, 1.0f);
        return out_min + t * (out_max - out_min);
    }
};

inline constexpr std::size_t kOscPatternCapacity = 96;
 
class OscParameterMap {
  public:
    static constexpr std::size_t kMaxMappings = 64;

    static bool pattern_fits(std::string_view pattern) {
        return pattern.size() + 1 <= kOscPatternCapacity
               && pattern.find('\0') == std::string_view::npos;
    }

    static bool is_wildcard(std::string_view pattern) {
        return pattern.find_first_of("*?[{") != std::string_view::npos;
    }
 
    // ── UI thread ──

    bool set_mapping(std::string_view pattern, pulp::state::ParamID id) {
        return set_mapping(pattern, id, OscMapScale{});
    }

    bool set_mapping(std::string_view pattern, pulp::state::ParamID id, OscMapScale scale) {
        Command cmd{Command::Set, id, clamp_scale(scale), {}};
        if (!store_pattern(cmd.pattern, pattern))
            return false;
        return commands_.try_push(cmd);
    }

    void arm_learn(pulp::state::ParamID id) {
        arm_learn(id, OscMapScale{});
    }

    void arm_learn(pulp::state::ParamID id, OscMapScale scale) {
        commands_.try_push(Command{Command::Arm, id, clamp_scale(scale), {}});
    }

    void clear(pulp::state::ParamID id) {
        commands_.try_push(Command{Command::Clear, id, OscMapScale{}, {}});
    }
 
    // ── dispatching thread ──

    void pump() {
        Command cmd{};
        while (commands_.try_pop(cmd)) {
            switch (cmd.type) {
            case Command::Set:
                insert(std::string_view{cmd.pattern.data()}, 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;
            }
        }
    }

    template <typename Apply>
    void route(std::string_view address, float value, Apply&& apply) {
        if (learn_armed_ && pattern_fits(address)) {
            insert(address, learn_target_, learn_scale_);
            learn_armed_ = false;
        }
        for (std::size_t i = 0; i < count_; ++i) {
            const auto& m = map_[i];
            if (matches(m, address))
                apply(m.id, m.scale.apply(value));
        }
    }

    void handle_value(pulp::state::StateStore& store, std::string_view address, float value) {
        route(address, value, [&store](pulp::state::ParamID id, float normalized) {
            store.set_normalized(id, normalized);
        });
    }

    void handle_message(pulp::state::StateStore& store, const Message& msg) {
        float value = 0.0f;
        if (!numeric_argument(msg, value))
            return;
        handle_value(store, msg.address, value);
    }

    bool learn_armed() const {
        return learn_armed_;
    }

    std::size_t mapping_count() const {
        return count_;
    }
 
  private:
    using Pattern = std::array<char, kOscPatternCapacity>;
 
    struct Command {
        enum Type : std::uint8_t { Set, Arm, Clear } type;
        pulp::state::ParamID id;
        OscMapScale scale;
        Pattern pattern;
    };
    struct Mapping {
        Pattern pattern;
        pulp::state::ParamID id;
        OscMapScale scale;
        bool wildcard;
    };

    static bool numeric_argument(const Message& msg, float& out) {
        if (msg.args.empty())
            return false;
        if (const auto* f = std::get_if<float>(&msg.args[0])) {
            out = *f;
            return true;
        }
        if (const auto* i = std::get_if<std::int32_t>(&msg.args[0])) {
            out = static_cast<float>(*i);
            return true;
        }
        return false;
    }
 
    static OscMapScale clamp_scale(OscMapScale scale) {
        scale.in_min = std::isfinite(scale.in_min) ? scale.in_min : 0.0f;
        scale.in_max = std::isfinite(scale.in_max) ? scale.in_max : 1.0f;
        scale.out_min =
            std::isfinite(scale.out_min) ? std::clamp(scale.out_min, 0.0f, 1.0f) : 0.0f;
        scale.out_max =
            std::isfinite(scale.out_max) ? std::clamp(scale.out_max, 0.0f, 1.0f) : 1.0f;
        return scale;
    }
 
    static bool store_pattern(Pattern& dest, std::string_view pattern) {
        if (!pattern_fits(pattern))
            return false;
        dest.fill('\0');
        std::memcpy(dest.data(), pattern.data(), pattern.size());
        return true;
    }
 
    static bool matches(const Mapping& m, std::string_view address) {
        const std::string_view pattern{m.pattern.data()};
        // A literal address is a byte compare; only wildcard syntax needs the
        // pattern matcher, which is not allocation-free.
        return m.wildcard ? address_matches(pattern, address) : pattern == address;
    }
 
    void insert(std::string_view pattern, pulp::state::ParamID id, OscMapScale scale) {
        for (std::size_t i = 0; i < count_; ++i) {
            if (std::string_view{map_[i].pattern.data()} == pattern) {
                map_[i].id = id;
                map_[i].scale = scale;
                return;
            }
        }
        if (count_ >= kMaxMappings)
            return;
        Mapping& m = map_[count_];
        if (!store_pattern(m.pattern, pattern))
            return;
        m.id = id;
        m.scale = scale;
        m.wildcard = is_wildcard(pattern);
        ++count_;
    }
 
    void remove_target(pulp::state::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;
    }
 
    std::array<Mapping, kMaxMappings> map_{};
    std::size_t count_ = 0;
    bool learn_armed_ = false;
    pulp::state::ParamID learn_target_ = 0;
    OscMapScale learn_scale_{};
    pulp::runtime::SpscQueue<Command, 64> commands_;
};
 
} // namespace pulp::osc