audio_inspector_panel.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/audio/audio_probe_snapshot.hpp>
#include <pulp/audio/audio_scope.hpp>
#include <pulp/audio/audio_stats.hpp>
#include <pulp/view/view.hpp>
#include <pulp/view/widgets.hpp>
 
#include <array>
#include <cstdint>
#include <memory>
#include <vector>
 
namespace pulp::view {
 
enum class AudioInspectorMode {
    kSignal,
    kScope,
};

class AudioWaveformView : public View {
  public:
    static constexpr int kCapacity = 512;

    enum class TriggerMode {
        kRaw,
        kRisingZero,
    };
 
    AudioWaveformView();

    void set_samples(const float* samples, int count);

    void clear_samples();
 
    int sample_count() const {
        return count_;
    }
    float sample_at(int i) const {
        return (i >= 0 && i < count_) ? data_[i] : 0.0f;
    }
 
    void set_show_grid(bool show);
    bool show_grid() const {
        return show_grid_;
    }
 
    void set_trigger_mode(TriggerMode mode);
    TriggerMode trigger_mode() const {
        return trigger_mode_;
    }

    void set_horizontal_scale(float scale);
    float horizontal_scale() const {
        return horizontal_scale_;
    }

    int display_start_index() const;
    int display_sample_count() const;

    void set_live(bool live) {
        live_ = live;
    }
    bool is_live() const {
        return live_;
    }
 
    void paint(canvas::Canvas& canvas) override;
 
  private:
    int find_rising_zero_crossing() const;
 
    std::array<float, kCapacity> data_{};
    int count_ = 0;
    bool live_ = false;
    bool show_grid_ = true;
    TriggerMode trigger_mode_ = TriggerMode::kRaw;
    float horizontal_scale_ = 1.0f;
};

inline constexpr float kInspectorMeterFloorDb = -60.0f;

float dbfs_meter_fill(float linear);

class AudioInspectorPanel : public View {
  public:
    enum class Status {
        kNoProbe, 
        kStale,   
        kLive,    
    };
 
    AudioInspectorPanel();

    void update(Status status, const audio::AudioProbeSnapshot& snap,
                const audio::AudioStats& stats, const float* waveform, int waveform_count);
 
    void set_mode(AudioInspectorMode mode);
    AudioInspectorMode mode() const {
        return mode_;
    }
 
    void set_scope_result(const audio::AudioScopeResult& result);
    void clear_scope_result();
 
    std::function<void(AudioInspectorMode)> on_mode_changed;
 
    // ── State accessors (for headless tests; no GPU/window needed) ──────────
 
    Status status() const {
        return status_;
    }
    audio::AudioProbeStage observed_stage() const {
        return snapshot_.stage_id;
    }
    float peak() const {
        return snapshot_.peak_max;
    }
    float rms() const {
        return snapshot_.rms_max;
    }
    std::uint64_t clip_count() const {
        return snapshot_.clip_count;
    }
    std::uint64_t nan_inf_count() const {
        return snapshot_.nan_inf_count;
    }
    std::uint64_t silence_run_blocks() const {
        return snapshot_.silence_run_blocks;
    }
    std::uint64_t sequence_number() const {
        return snapshot_.sequence_number;
    }

    float lr_match() const {
        return lr_match_;
    }

    float balance() const {
        return balance_;
    }
 
    const AudioWaveformView& waveform() const {
        return *waveform_view_;
    }
    AudioWaveformView& waveform() {
        return *waveform_view_;
    }
 
    void set_waveform_grid_visible(bool visible);
    void set_waveform_trigger_mode(AudioWaveformView::TriggerMode mode);
    void set_waveform_horizontal_scale(float scale);
 
    float peak_meter_display_peak() const;
    float peak_meter_held_peak() const;
    float rms_meter_held_peak() const;
 
    // ── Rendered-text accessors (for headless tests) ────────────────────────
    // The exact strings the labels paint. A test can assert these are
    // populated (e.g. the status reads "live", the level reads "dBFS") so a
    // regression that leaves the panel visually blank is caught in CI, not
    // only by eye.
    const std::string& status_text() const {
        return status_label_->text();
    }
    const std::string& level_text() const {
        return level_label_->text();
    }
    const std::string& content_text() const {
        return content_label_->text();
    }

    canvas::Color status_color() const {
        return status_label_->text_color();
    }
 
  private:
    void build_ui();
    void refresh_labels();
 
    Status status_ = Status::kNoProbe;
    AudioInspectorMode mode_ = AudioInspectorMode::kSignal;
    audio::AudioProbeSnapshot snapshot_{};
    audio::AudioStats stats_{};
    audio::AudioScopeResult scope_result_{};
    bool has_scope_result_ = false;
    float lr_match_ = 0.0f;
    float balance_ = 0.0f;
    float meter_dt_seconds_ = 1.0f / 60.0f;
 
    // Widget pointers (owned by the view tree).
    Label* status_label_ = nullptr;
    ToggleButton* signal_button_ = nullptr;
    ToggleButton* scope_button_ = nullptr;
    Label* stage_label_ = nullptr;
    Meter* peak_meter_ = nullptr;
    Meter* rms_meter_ = nullptr;
    Label* level_label_ = nullptr;
    Label* content_label_ = nullptr; 
    Label* phase_label_ = nullptr;   
    Label* device_label_ = nullptr;  
    AudioWaveformView* waveform_view_ = nullptr;
};
 
} // namespace pulp::view