waveform_overview_view.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/audio/waveform_overview.hpp>
#include <pulp/canvas/canvas.hpp>
#include <pulp/view/view.hpp>
 
#include <algorithm>
#include <cstdint>
 
namespace pulp::view {

class WaveformOverviewView : public View {
  public:
    WaveformOverviewView() = default;

    void set_overview(const pulp::audio::WaveformOverview* overview,
                      uint32_t channel = pulp::audio::WaveformOverview::kAllChannels) {
        overview_ = overview;
        channel_ = channel;
        view_all();
    }
 
    void clear_overview() {
        overview_ = nullptr;
        vp_start_ = 0;
        vp_end_ = 0;
    }
 
    bool has_overview() const {
        return overview_ != nullptr && !overview_->empty();
    }

    uint64_t source_frames() const {
        return overview_ ? overview_->info().num_source_frames : 0;
    }
 
    // ── Viewport ─────────────────────────────────────────────────────────

    void set_viewport(uint64_t start_frame, uint64_t end_frame) {
        const uint64_t total = source_frames();
        vp_start_ = std::min(start_frame, total);
        vp_end_ = std::min(end_frame, total);
        if (vp_end_ < vp_start_)
            vp_end_ = vp_start_;
    }
 
    uint64_t viewport_start() const {
        return vp_start_;
    }
    uint64_t viewport_end() const {
        return vp_end_;
    }

    void view_all() {
        vp_start_ = 0;
        vp_end_ = source_frames();
    }
 
    // ── Styling ──────────────────────────────────────────────────────────
    void set_line_color(canvas::Color c) {
        line_color_ = c;
    }
    void set_background_color(canvas::Color c) {
        bg_color_ = c;
    }
    canvas::Color line_color() const {
        return line_color_;
    }
    canvas::Color background_color() const {
        return bg_color_;
    }

    bool column_peak(uint64_t f0, uint64_t f1, float& out_min, float& out_max) const {
        if (!has_overview() || f1 <= f0)
            return false;
        const auto& lvl = overview_->level(0);
        if (lvl.samples_per_peak == 0 || lvl.peaks.empty())
            return false;
 
        uint64_t p0 = f0 / lvl.samples_per_peak;
        uint64_t p1 = (f1 + lvl.samples_per_peak - 1) / lvl.samples_per_peak;
        if (p1 <= p0)
            p1 = p0 + 1;
        if (p0 >= lvl.peaks_per_channel)
            return false;
        p1 = std::min<uint64_t>(p1, lvl.peaks_per_channel);
 
        float lo = 1.0f, hi = -1.0f;
        const auto fold = [&](uint32_t ch) {
            if (ch >= lvl.peaks.size())
                return;
            const auto& col = lvl.peaks[ch];
            for (uint64_t i = p0; i < p1 && i < col.size(); ++i) {
                lo = std::min(lo, col[i].min());
                hi = std::max(hi, col[i].max());
            }
        };
        if (channel_ == pulp::audio::WaveformOverview::kAllChannels) {
            for (uint32_t ch = 0; ch < lvl.peaks.size(); ++ch)
                fold(ch);
        } else {
            fold(channel_);
        }
        if (hi < lo)
            return false; // no peaks landed in the window
        out_min = lo;
        out_max = hi;
        return true;
    }
 
    void paint(canvas::Canvas& canvas) override {
        const Rect b = local_bounds();
 
        canvas.set_fill_color(bg_color_);
        canvas.fill_rect(0.0f, 0.0f, b.width, b.height);
 
        if (!has_overview() || vp_end_ <= vp_start_ || b.width < 1.0f)
            return;
 
        const float cy = b.height * 0.5f;
        const float half_h = b.height * 0.5f;
        canvas.set_stroke_color(line_color_);
        canvas.set_line_width(1.0f);
 
        const uint64_t span = vp_end_ - vp_start_;
        const int cols = static_cast<int>(b.width);
        for (int px = 0; px < cols; ++px) {
            const uint64_t cf0 =
                vp_start_ + span * static_cast<uint64_t>(px) / static_cast<uint64_t>(cols);
            uint64_t cf1 =
                vp_start_ + span * static_cast<uint64_t>(px + 1) / static_cast<uint64_t>(cols);
            if (cf1 <= cf0)
                cf1 = cf0 + 1;
 
            float lo = 0.0f, hi = 0.0f;
            if (!column_peak(cf0, cf1, lo, hi))
                continue;
 
            const float x = static_cast<float>(px) + 0.5f;
            const float y_top = cy - hi * half_h;
            float y_bot = cy - lo * half_h;
            if (y_bot - y_top < 1.0f)
                y_bot = y_top + 1.0f; // keep 1px minimum
            canvas.stroke_line(x, y_top, x, y_bot);
        }
    }
 
  private:
    const pulp::audio::WaveformOverview* overview_ = nullptr;
    uint32_t channel_ = pulp::audio::WaveformOverview::kAllChannels;
    uint64_t vp_start_ = 0;
    uint64_t vp_end_ = 0;
    canvas::Color line_color_ = canvas::Color::rgba8(100, 180, 250);
    canvas::Color bg_color_ = canvas::Color::rgba8(20, 20, 30);
};
 
} // namespace pulp::view