web_gpu_convolver.hpp

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>
 
#include <pulp/render/gpu_compute.hpp>
 
namespace pulp::gpu_audio {

class WebGpuConvolver {
public:
    static constexpr uint32_t kDefaultDepth = 3;

    using Sink = std::function<void(uint32_t seq, const float* out_planar, bool ok)>;
 
    explicit WebGpuConvolver(uint32_t depth = kDefaultDepth);
    ~WebGpuConvolver();
 
    WebGpuConvolver(const WebGpuConvolver&) = delete;
    WebGpuConvolver& operator=(const WebGpuConvolver&) = delete;

    bool prepare(render::GpuCompute* gpu, int sample_rate, int block, int channels,
                 const float* ir, int ir_len);

    bool submit(uint32_t seq, const float* in_planar, int frames,
                std::chrono::microseconds deadline);

    uint32_t collect(const Sink& sink);
 
    bool prepared() const { return prepared_; }
    bool device_lost() const { return gpu_ != nullptr && gpu_->device_lost(); }
    uint32_t fft_size() const { return fft_size_; }
    uint32_t depth() const { return depth_; }
    uint32_t in_flight() const;
 
    // Per-pipeline counters. GpuCompute::async_stats() counts the same events
    // device-wide; these are this convolver's view of them, plus the one status
    // the device cannot see — a readback that landed non-finite (counted failed).
    uint64_t submits() const;
    uint64_t resolves() const;   
    uint64_t expired() const;    
    uint64_t failed() const;     
 
private:
    enum class SlotState : uint8_t { Free, InFlight, Ready, Bad };
 
    struct Slot {
        SlotState state = SlotState::Free;
        uint32_t seq = 0;
        std::vector<float> in_pad;  
        std::vector<float> time;    
    };

    struct State {
        std::vector<Slot> slots;
        std::vector<uint32_t> pending;  
        uint32_t head = 0;
        uint32_t count = 0;
 
        uint64_t submits = 0;
        uint64_t resolves = 0;
        uint64_t expired = 0;
        uint64_t failed = 0;
    };
 
    std::shared_ptr<State> state_;
    render::GpuCompute* gpu_ = nullptr;
 
    uint32_t depth_ = kDefaultDepth;
    uint32_t channels_ = 0;
    uint32_t block_ = 0;
    uint32_t sample_rate_ = 0;
    uint32_t fft_size_ = 0;
    bool prepared_ = false;
 
    std::vector<float> ir_spec_;             
    std::vector<std::vector<float>> carry_;  
    std::vector<float> out_;                 
};
 
}  // namespace pulp::gpu_audio