waveform_headless_render_backend.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/audio/waveform_overview.hpp>
#include <pulp/view/waveform_gpu_render_controller.hpp>
 
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
 
namespace pulp::view {
 
struct WaveformHeadlessRenderConfig {
    std::size_t cache_capacity = 8;
    std::size_t max_staging_vertices = 4096;
};
 
enum class WaveformHeadlessRenderStatus : std::uint8_t {
    NoOp,
    CpuFallbackReady,
    UploadedStaticLayer,
    DrawCachedStaticLayer,
    PlayheadOnlyRedraw,
    MissingCachedResource,
    ResourceAllocationFailed,
    ResourceCommitRejected,
};
 
struct WaveformHeadlessRenderFrame {
    WaveformHeadlessRenderStatus status = WaveformHeadlessRenderStatus::NoOp;
    WaveformGpuRenderDecision decision{};
    // Non-owning view into backend-owned staging or cached static-layer
    // vertices. Valid until the next non-const backend call, clear(), prepare(),
    // resource eviction/replacement, or backend destruction.
    std::span<const WaveformPeakVertex> static_vertices{};
    WaveformPlayheadOverlay playhead{};
    std::uint64_t resource_id = 0;
    bool used_cached_resource = false;
 
    [[nodiscard]] bool has_static_vertices() const noexcept {
        return !static_vertices.empty();
    }
};

class WaveformHeadlessRenderBackend {
  public:
    explicit WaveformHeadlessRenderBackend(WaveformHeadlessRenderConfig config = {});
    ~WaveformHeadlessRenderBackend();
 
    bool prepare(WaveformHeadlessRenderConfig config);
    [[nodiscard]] WaveformHeadlessRenderFrame render(const pulp::audio::WaveformOverview& thumbnail,
                                                     const WaveformGpuLayerPlan& plan,
                                                     const WaveformGpuRenderContext& context = {});
 
    void clear();
 
    [[nodiscard]] WaveformGpuResourceCacheStats stats() const noexcept;
    [[nodiscard]] std::size_t resource_count() const noexcept {
        return resources_.size();
    }
    [[nodiscard]] std::size_t released_resource_count() const noexcept {
        return released_resource_count_;
    }
    [[nodiscard]] std::uint64_t last_released_resource_id() const noexcept {
        return last_released_resource_id_;
    }
    [[nodiscard]] std::size_t staging_vertex_capacity() const noexcept {
        return staging_vertices_.size();
    }
 
  private:
    struct ResourcePayload {
        WaveformGpuUploadKey key{};
        std::uint64_t resource_id = 0;
        std::uint64_t backend_generation = 0;
        std::vector<WaveformPeakVertex> vertices;
    };
 
    [[nodiscard]] WaveformHeadlessRenderFrame
    make_noop_frame(const WaveformGpuRenderDecision& decision) const noexcept;
    [[nodiscard]] WaveformHeadlessRenderFrame
    make_cached_frame(const WaveformGpuRenderDecision& decision,
                      WaveformHeadlessRenderStatus status) const noexcept;
    [[nodiscard]] WaveformHeadlessRenderFrame
    upload_static_layer(const WaveformGpuRenderDecision& decision);
 
    const ResourcePayload* find_resource(const WaveformGpuResourceRecord& record) const noexcept;
    ResourcePayload* find_resource_by_id(std::uint64_t resource_id) noexcept;
    bool release_record(const WaveformGpuResourceRecord& record) noexcept;
    bool release_resource_by_id(std::uint64_t resource_id) noexcept;
    void release_all_resources() noexcept;
    void release_commit_records(const WaveformGpuResourcePutResult& result) noexcept;
 
    WaveformGpuRenderController controller_;
    std::vector<WaveformPeakVertex> staging_vertices_;
    std::vector<ResourcePayload> resources_;
    std::uint64_t next_resource_id_ = 1;
    std::size_t released_resource_count_ = 0;
    std::uint64_t last_released_resource_id_ = 0;
};
 
} // namespace pulp::view