audio_inspector_window.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/audio/audio_probe.hpp>
#include <pulp/audio/audio_scope.hpp>
#include <pulp/audio/audio_stats.hpp>
#include <pulp/audio/buffer.hpp>
#include <pulp/state/properties_file.hpp>
#include <pulp/view/audio_inspector_panel.hpp>
#include <pulp/view/command_registry.hpp>
#include <pulp/view/view.hpp>
#include <pulp/view/window_host.hpp>
#include <pulp/view/window_manager.hpp>
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
 
namespace pulp::view {

class AudioInspectorWindow : private CommandHandler {
  public:
    using HostFactory =
        std::function<std::unique_ptr<WindowHost>(View& root, const WindowOptions& options)>;

    static constexpr CommandID kToggleAudioInspector = 0x504C4149;

    explicit AudioInspectorWindow(WindowManager* mgr = nullptr, WindowHost* parent = nullptr,
                                  HostFactory host_factory = {}, std::string app_name = "Pulp");
    ~AudioInspectorWindow();
 
    AudioInspectorWindow(const AudioInspectorWindow&) = delete;
    AudioInspectorWindow& operator=(const AudioInspectorWindow&) = delete;

    void set_probe(audio::AudioProbe* probe);
    audio::AudioProbe* probe() const {
        return probe_;
    }

    void set_device_stats(const audio::AudioStats& device_stats);

    void poll();
 
    void show();
    void hide();
    void toggle();
    bool is_visible() const;

    void register_command_handler(CommandRegistry& registry);

    const AudioInspectorPanel& panel() const {
        return *panel_;
    }
 
    void set_mode(AudioInspectorMode mode);
    AudioInspectorMode mode() const {
        return mode_;
    }

    void set_preferences(state::PropertiesFile* preferences);

    WindowHost* window_host() const {
        return window_host_.get();
    }
 
  private:
    // CommandHandler (private base) — registry dispatch entry points.
    std::vector<CommandID> commands() const override;
    bool perform_command(CommandID id) override;
 
    void build_ui();
    void load_mode_preference();
    void save_mode_preference();
    void apply_mode(AudioInspectorMode mode, bool persist);
    audio::AudioScopeResult build_scope_result(const audio::AudioProbeSnapshot& snap,
                                               audio::Buffer<float>& capture, int frames) const;
 
    WindowManager* manager_ = nullptr;
    WindowHost* parent_host_ = nullptr;
    HostFactory host_factory_;
    CommandRegistry* registry_ = nullptr;
    std::string app_name_;
    std::unique_ptr<state::ApplicationProperties> app_properties_;
    state::PropertiesFile* preferences_ = nullptr;
    AudioInspectorMode mode_ = AudioInspectorMode::kSignal;
    bool applying_mode_ = false;
 
    audio::AudioProbe* probe_ = nullptr;
    audio::AudioStats device_stats_{};
 
    // Stale detection: the last sequence number we saw advance, and whether a
    // probe has produced at least one snapshot since it was wired.
    std::uint64_t last_sequence_ = 0;
    bool ever_observed_ = false;
 
    // Copied waveform scratch (non-RT; sized to the panel's display capacity).
    std::vector<float> waveform_scratch_;
    audio::Buffer<float> scope_capture_;
 
    std::unique_ptr<View> root_;
    AudioInspectorPanel* panel_ = nullptr;
 
    std::unique_ptr<WindowHost> window_host_;
    WindowId window_id_ = 0;
};
 
} // namespace pulp::view