gpu_multi_convolver.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
#include <pulp/gpu_audio/gpu_audio_node.hpp>
#include <pulp/gpu_audio/gpu_audio_status.hpp>
#include <pulp/gpu_audio/flow_pans.hpp>
 
#include <pulp/platform/gpu_fwd.hpp>
 
namespace pulp::gpu_audio {
 
class GpuMultiConvolver;
 
namespace detail {
// Test seam: prepare against a supplied compute device instead of a standalone
// one. Not part of the SDK surface.
bool prepare_gpu_multi_convolver_with(GpuMultiConvolver&,
                                      std::unique_ptr<render::GpuCompute>) noexcept;
} // namespace detail

class GpuMultiConvolver : public GpuAudioNode {
public:
    GpuMultiConvolver(uint32_t block_size, uint32_t sample_rate,
                      std::vector<std::vector<float>> irs);
    ~GpuMultiConvolver() override;
 
    GpuAudioNodeDescriptor descriptor() const override;
    bool prepare() override;
    void process_block(const audio::BufferView<const float>& input,
                       audio::BufferView<float>& output, uint32_t n) override;
    void process_cpu_fallback(const audio::BufferView<const float>& input,
                              audio::BufferView<float>& output,
                              uint32_t n) noexcept override;

    bool gpu_available() const { return gpu_ != nullptr; }
    bool device_lost() const noexcept;
    std::string backend() const;

    GpuAudioStatus status_snapshot() const noexcept override;
    GpuAudioRecoveryReason recovery_reason() const noexcept;
    bool fenced() const noexcept;
    uint32_t num_ir() const { return num_ir_; }
    uint32_t fft_size() const { return fft_size_; }

    const std::vector<float>& pan_l() const { return pan_l_; }
    const std::vector<float>& pan_r() const { return pan_r_; }

    void set_flow(float depth, float spread = 1.0f) noexcept {
        flow_depth_.store(depth < 0.f ? 0.f : depth > 1.f ? 1.f : depth,
                          std::memory_order_relaxed);
        flow_spread_.store(spread < 0.f ? 0.f : spread > 1.f ? 1.f : spread,
                           std::memory_order_relaxed);
    }

    bool convolve_stereo(const float* mono_in, float* out_l, float* out_r, uint32_t n);
 
  private:
    friend bool
    detail::prepare_gpu_multi_convolver_with(GpuMultiConvolver&,
                                             std::unique_ptr<render::GpuCompute>) noexcept;
    bool prepare_on(std::unique_ptr<render::GpuCompute> gpu);
 
    uint32_t block_;
    uint32_t sample_rate_;
    std::vector<std::vector<float>> irs_;
    uint32_t num_ir_ = 0;
    uint32_t fft_size_ = 0;
 
    std::unique_ptr<render::GpuCompute> gpu_;
 
    // Per-room constant-power pan gains (linear), built at prepare().
    std::vector<float> pan_l_;
    std::vector<float> pan_r_;
 
    // Per-block host scratch (allocated in prepare()).
    std::vector<float> in_pad_;     // 2*fft_size interleaved complex input
    std::vector<float> out_lr_;     // 2*fft_size: L block then R block (readback)
    std::vector<float> carry_l_;    // overlap-add accumulator, fft_size
    std::vector<float> carry_r_;
 
    // Flow (time-varying pans). flow_depth_/flow_spread_ are set from any thread
    // (atomic); base_theta_ + pan_norm_ are the prepared static layout the drift
    // orbits; block_counter_ advances on the transport worker (owns the phase).
    std::atomic<float> flow_depth_{0.0f};
    std::atomic<float> flow_spread_{1.0f};
    std::vector<float> base_theta_;   // per-room base azimuth, from prepare()
    std::vector<float> pan_l_live_;   // per-block drifting pans (Flow>0 only)
    std::vector<float> pan_r_live_;
    float pan_norm_ = 1.0f;           // 1/sqrt(num_ir)
    std::uint64_t block_counter_ = 0;
 
    bool prepared_ = false;
 
    // Blocks convolve_stereo() has been asked for since prepare(), and the one
    // at which it first found the device lost (UINT64_MAX until then). Atomic
    // because status readers report them from other threads.
    std::atomic<std::uint64_t> blocks_seen_{0};
    std::atomic<std::uint64_t> loss_block_{UINT64_MAX};
};
 
} // namespace pulp::gpu_audio