audio_device_manager.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/audio/device.hpp>
#include <pulp/audio/load_measurer.hpp>
#include <pulp/midi/device.hpp>
#include <pulp/midi/message.hpp>
 
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace pulp::state { class ApplicationProperties; }
 
namespace pulp::audio {

struct DeviceSelection {
    std::string output_device;
    std::string input_device;
    double      sample_rate = 0.0;   
    int         buffer_size = 0;     
    uint64_t    output_channel_mask = 0;
    uint64_t    input_channel_mask  = 0;
};

namespace adm_keys {
constexpr const char* kPrefix             = "audio_device_manager.";
constexpr const char* kOutputDevice       = "audio_device_manager.output_device";
constexpr const char* kInputDevice        = "audio_device_manager.input_device";
constexpr const char* kSampleRate         = "audio_device_manager.sample_rate";
constexpr const char* kBufferSize         = "audio_device_manager.buffer_size";
constexpr const char* kOutputChannelMask  = "audio_device_manager.output_channel_mask";
constexpr const char* kInputChannelMask   = "audio_device_manager.input_channel_mask";
constexpr const char* kEnabledMidiInputs = "audio_device_manager.enabled_midi_inputs";
}  // namespace adm_keys
 
class AudioDeviceManager;

class MidiSubscriptionToken {
public:
    MidiSubscriptionToken() = default;
    MidiSubscriptionToken(const MidiSubscriptionToken&) = delete;
    MidiSubscriptionToken& operator=(const MidiSubscriptionToken&) = delete;
    MidiSubscriptionToken(MidiSubscriptionToken&& other) noexcept;
    MidiSubscriptionToken& operator=(MidiSubscriptionToken&& other) noexcept;
    ~MidiSubscriptionToken();
 
    bool active() const noexcept { return id_ != 0 && !manager_.expired(); }

    void reset() noexcept;
 
private:
    friend class AudioDeviceManager;
    MidiSubscriptionToken(std::weak_ptr<void> manager_ptr,
                          AudioDeviceManager* manager_raw,
                          uint64_t id) noexcept
        : manager_(std::move(manager_ptr)), manager_raw_(manager_raw), id_(id) {}
 
    std::weak_ptr<void>    manager_;       
    AudioDeviceManager*    manager_raw_ = nullptr;
    uint64_t               id_ = 0;
};

class AudioDeviceManager {
public:
    using MidiHandler = std::function<void(const pulp::midi::MidiEvent&)>;
 
    AudioDeviceManager();
    ~AudioDeviceManager();
 
    AudioDeviceManager(const AudioDeviceManager&) = delete;
    AudioDeviceManager& operator=(const AudioDeviceManager&) = delete;
 
    // ── Persistence ─────────────────────────────────────────────────

    static std::optional<DeviceSelection> load_selection(
        const pulp::state::ApplicationProperties& props);

    static bool save_selection(pulp::state::ApplicationProperties& props,
                               const DeviceSelection& sel);

    struct ResolveResult {
        DeviceSelection resolved;
        bool fallback_used_output = false;
        bool fallback_used_input  = false;
    };
    static ResolveResult resolve_selection(
        const DeviceSelection& sel,
        const std::vector<DeviceInfo>& available,
        const std::string& fallback_output_id,
        const std::string& fallback_input_id);

    static DeviceConfig selection_to_config(
        const DeviceSelection& sel,
        int default_output_channels = 2,
        int default_input_channels  = 0);
 
    // ── MIDI hub ────────────────────────────────────────────────────

    [[nodiscard]] MidiSubscriptionToken subscribe_midi(MidiHandler handler);

    void dispatch_midi_event(const pulp::midi::MidiEvent& event);

    std::size_t midi_subscriber_count() const;
 
    // ── CPU load ────────────────────────────────────────────────────

    void begin_cpu_measure(int num_frames, float sample_rate);

    void end_cpu_measure();

    float cpu_load() const;

    float peak_cpu_load() const;

    AudioProcessLoadSnapshot process_load_snapshot() const;

    void reset_peak_cpu_load();

    struct RuntimeTelemetrySnapshot {
        AudioProcessLoadSnapshot process_load;
        std::uint64_t xrun_count = 0;
    };
 
    RuntimeTelemetrySnapshot runtime_telemetry_snapshot() const;
 
    // ── Lifecycle / hotplug / recovery (1.2b) ───────────────────────

    enum class DeviceChangeKind {
        Unknown,   
        Added,     
        Removed,   
        Replaced,  
    };
 
    struct DeviceChangeEvent {
        DeviceChangeKind kind = DeviceChangeKind::Unknown;
        std::vector<DeviceInfo> devices;  
        std::string device_id;            
    };
 
    using DeviceChangeHandler = std::function<void(const DeviceChangeEvent&)>;

    class DeviceChangeToken {
    public:
        DeviceChangeToken() = default;
        DeviceChangeToken(const DeviceChangeToken&) = delete;
        DeviceChangeToken& operator=(const DeviceChangeToken&) = delete;
        DeviceChangeToken(DeviceChangeToken&& other) noexcept;
        DeviceChangeToken& operator=(DeviceChangeToken&& other) noexcept;
        ~DeviceChangeToken();
 
        bool active() const noexcept {
            return id_ != 0 && !manager_.expired();
        }
        void reset() noexcept;
 
    private:
        friend class AudioDeviceManager;
        DeviceChangeToken(std::weak_ptr<void> manager_ptr,
                          AudioDeviceManager* manager_raw,
                          uint64_t id) noexcept
            : manager_(std::move(manager_ptr)), manager_raw_(manager_raw), id_(id) {}
 
        std::weak_ptr<void>  manager_;
        AudioDeviceManager*  manager_raw_ = nullptr;
        uint64_t             id_ = 0;
    };

    [[nodiscard]] DeviceChangeToken subscribe_device_changes(DeviceChangeHandler handler);

    std::size_t device_change_subscriber_count() const;

    void attach_audio_system(AudioSystem* system);

    void dispatch_device_change(const DeviceChangeEvent& event);

    using DefaultDeviceChangeHandler =
        std::function<void(bool is_input, const std::string& new_device_id)>;

    void set_default_device_change_handler(DefaultDeviceChangeHandler handler);

    void dispatch_default_device_change(bool is_input,
                                        const std::string& new_device_id);

    using SampleRateChangeHandler = std::function<void(double new_rate)>;
 
    void set_sample_rate_change_handler(SampleRateChangeHandler handler);

    void dispatch_sample_rate_change(double new_rate);

    std::uint64_t sample_rate_change_count() const;

    double last_sample_rate() const;
 
    // ── xrun tracking ──────────────────────────────────────────────

    void bump_xrun_counter(std::uint64_t delta = 1);

    std::uint64_t xrun_count() const;

    void reset_xrun_counter();
 
    // ── MIDI endpoint tracking ─────────────────────────────────────
 
    struct MidiEndpoint {
        std::string id;
        std::string name;
        bool is_input = false;  
    };
 
    enum class MidiEndpointChangeKind {
        Added,
        Removed,
    };
 
    struct MidiEndpointChange {
        MidiEndpointChangeKind kind;
        MidiEndpoint endpoint;
    };
 
    using MidiEndpointChangeHandler = std::function<void(const MidiEndpointChange&)>;

    [[nodiscard]] MidiSubscriptionToken subscribe_midi_endpoints(
        MidiEndpointChangeHandler handler);
 
    std::size_t midi_endpoint_subscriber_count() const;

    void set_midi_endpoints(std::vector<MidiEndpoint> endpoints);

    std::vector<MidiEndpoint> midi_endpoints() const;
 
    // ── Enabled MIDI inputs and reconnection ───────────────────────

    void attach_midi_system(pulp::midi::MidiSystem* system,
                            bool install_port_change_callback = true);

    void refresh_midi_endpoints();

    bool set_midi_input_enabled(const std::string& id, bool enabled);

    bool is_midi_input_enabled(const std::string& id) const;

    bool is_midi_input_open(const std::string& id) const;

    std::vector<std::string> enabled_midi_inputs() const;

    void bind_settings(pulp::state::ApplicationProperties* props);

    static std::vector<std::string>
    load_enabled_midi_inputs(const pulp::state::ApplicationProperties& props);

    static bool save_enabled_midi_inputs(pulp::state::ApplicationProperties& props,
                                         const std::vector<std::string>& ids);
 
    // ── Concurrent-callback shutdown ───────────────────────────────

    void latch_close();

    bool is_closed() const noexcept;
 
private:
    friend class MidiSubscriptionToken;
    friend class DeviceChangeToken;
 
    void unsubscribe_midi(uint64_t id) noexcept;
    void unsubscribe_device_change(uint64_t id) noexcept;
    void unsubscribe_midi_endpoint(uint64_t id) noexcept;
    void reconcile_midi_inputs();

    struct MidiPortLink;
 
    // RAII guard used by every dispatcher; blocks latch_close() until
    // all in-flight dispatches return.
    class DispatchGuard;

    std::shared_ptr<void>                        lifetime_;

    std::atomic<uint64_t>                        next_token_id_{1};
 
    mutable std::mutex                           midi_mu_;
    std::unordered_map<uint64_t, MidiHandler>    midi_subs_;
 
    mutable std::mutex                                          device_change_mu_;
    std::unordered_map<uint64_t, DeviceChangeHandler>           device_change_subs_;
 
    mutable std::mutex                              default_dev_mu_;
    DefaultDeviceChangeHandler                      default_dev_handler_;
 
    mutable std::mutex                              sr_mu_;
    SampleRateChangeHandler                         sr_handler_;
    std::atomic<std::uint64_t>                      sr_change_count_{0};
    std::atomic<double>                             last_sr_{0.0};
 
    std::atomic<std::uint64_t>                      xrun_counter_{0};
 
    mutable std::mutex                                                midi_ep_mu_;
    std::unordered_map<uint64_t, MidiEndpointChangeHandler>           midi_ep_subs_;
    std::vector<MidiEndpoint>                                         midi_endpoints_;
    bool endpoints_known_ = false; 
 
    AudioSystem*                                    attached_system_ = nullptr;

    struct EnabledInput {
        std::string id;
        std::unique_ptr<pulp::midi::MidiInput> device; 
    };
    mutable std::mutex input_mu_;
    std::vector<EnabledInput> enabled_inputs_;
    pulp::midi::MidiSystem* midi_system_ = nullptr;
    std::shared_ptr<MidiPortLink> midi_link_;
    std::recursive_mutex refresh_mu_;
    bool midi_port_callback_installed_ = false;
    pulp::state::ApplicationProperties* settings_ = nullptr;
 
    AudioProcessLoadMeasurer                     load_;

    std::atomic<bool>                            closed_{false};
    mutable std::mutex                           latch_mu_;
    std::condition_variable                      latch_cv_;
    int                                          in_flight_ = 0;
};
 
}  // namespace pulp::audio