host_parameter_edit.hpp

Go to the documentation of this file.

#pragma once
 
// host_parameter_edit.hpp — format-neutral provenance for editor parameter
// writes (WAH-5).
//
// The problem this replaces: the VST3 adapter decided a StateStore write came
// from the editor by checking whether a GESTURE was open. That is an inference,
// not a fact, and it is wrong in a case users hit routinely — host automation
// arriving while the user holds a knob. The automation write landed in the
// store, the "is a gesture open?" test said yes, and the adapter echoed the
// host's own value back at it through performEdit(). It also read
// `get_normalized(id)` twice per reported edit, so a write landing between the
// two reads produced a performEdit and a setParamNormalized carrying DIFFERENT
// values for one logical change.
//
// The fix is to record provenance where it is known — at the write — instead of
// guessing at it afterwards:
//
//   * host-originated writes run inside `ScopedHostParameterWrite`;
//   * processor-originated writes run inside `ScopedProcessorParameterWrite`;
//   * everything else on the editor thread is, by elimination, an editor write.
//
// This is the model CLAP already used (thread id + explicit host/process
// flags), lifted out of clap_adapter.cpp so VST3 gets it too. CLAP keeps its
// own outbound SPSC queue for DELIVERY — the protocol needs events placed in
// the process block — and only shares the provenance DECISION. That split is
// deliberate: absorbing CLAP's queue here would weaken its ordering guarantees
// for no gain.
 
#include <pulp/state/listener_token.hpp>
#include <pulp/state/store.hpp>
 
#include <functional>
#include <thread>
 
namespace pulp::format {

class ScopedHostParameterWrite {
public:
    ScopedHostParameterWrite() noexcept { ++depth(); }
    ScopedHostParameterWrite(const ScopedHostParameterWrite&) = delete;
    ScopedHostParameterWrite& operator=(const ScopedHostParameterWrite&) = delete;
    ~ScopedHostParameterWrite() noexcept { --depth(); }
 
    static bool active() noexcept { return depth() > 0; }
 
private:
    static int& depth() noexcept {
        thread_local int d = 0;
        return d;
    }
};

class ScopedProcessorParameterWrite {
public:
    ScopedProcessorParameterWrite() noexcept { ++depth(); }
    ScopedProcessorParameterWrite(const ScopedProcessorParameterWrite&) = delete;
    ScopedProcessorParameterWrite& operator=(const ScopedProcessorParameterWrite&) = delete;
    ~ScopedProcessorParameterWrite() noexcept { --depth(); }
 
    static bool active() noexcept { return depth() > 0; }
 
private:
    static int& depth() noexcept {
        thread_local int d = 0;
        return d;
    }
};

inline bool in_non_editor_parameter_write() noexcept {
    return ScopedHostParameterWrite::active() ||
           ScopedProcessorParameterWrite::active();
}

class HostParameterEditBridge {
public:
    struct Callbacks {
        std::function<void(state::ParamID)> begin;
        std::function<void(state::ParamID, float normalized, float plain)> value;
        std::function<void(state::ParamID)> end;
    };
 
    HostParameterEditBridge(state::StateStore& store, Callbacks callbacks);
    ~HostParameterEditBridge();
 
    HostParameterEditBridge(const HostParameterEditBridge&) = delete;
    HostParameterEditBridge& operator=(const HostParameterEditBridge&) = delete;

    std::thread::id editor_thread() const noexcept { return editor_thread_; }

    bool would_report() const noexcept;
 
private:
    void on_begin(state::ParamID id);
    void on_end(state::ParamID id);
    void on_value(state::ParamID id, float plain);
    void report(state::ParamID id, float plain);
 
    state::StateStore& store_;
    Callbacks callbacks_;
    std::thread::id editor_thread_;
    state::ListenerToken listener_;
};
 
}  // namespace pulp::format