gpu_wavenet_realtime_node.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <pulp/gpu_audio/gpu_audio_capability.hpp>
#include <pulp/gpu_audio/gpu_audio_node.hpp>
#include <pulp/gpu_audio/gpu_audio_status.hpp>
#include <pulp/gpu_audio/gpu_wavenet.hpp>
 
namespace pulp::gpu_audio {
class GpuAudioProviderPool;
namespace detail {
struct WaveNetRealtimeTestAccess;
struct SharedIoCompletionNotifier;
} // namespace detail

struct GpuWaveNetTraceConfig {
    bool enabled = false;
    bool capture_admissions = false;
    bool capture_callback_timing = false;
    std::uint32_t success_stride = 1;
};
#define PULP_GPU_WAVENET_TRACE_CONFIG_API 1
 
class GpuWaveNetRealtimeNode : public GpuAudioNode {
  public:
    struct Config {
        GpuWaveNetSession::Config session;
        std::uint32_t channels = 1;
        std::uint32_t lead_blocks = 2;
        std::uint32_t capacity = 8;
        std::uint32_t max_inflight = 0;
        std::uint32_t prewarm_blocks = 0;
        std::uint64_t completion_service_wait_ns = 0;
        MissPolicy miss_policy = MissPolicy::Silence;
        bool supports_cpu_fallback = false;
        std::uint32_t watchdog_blocks = 0;
        GpuAudioProviderPool* provider_pool = nullptr;
    };

    explicit GpuWaveNetRealtimeNode(const Config&);
    ~GpuWaveNetRealtimeNode() override;
    GpuWaveNetRealtimeNode(const GpuWaveNetRealtimeNode&) = delete;
    GpuWaveNetRealtimeNode& operator=(const GpuWaveNetRealtimeNode&) = delete;
 
    GpuAudioNodeDescriptor descriptor() const override;
    bool prepare() override;
    bool configure_trace(const GpuWaveNetTraceConfig&) noexcept;
    bool release() noexcept;
    bool release_bounded(std::uint64_t budget_ns) noexcept override;
    bool fenced() const noexcept;
    GpuAudioRecoveryReason recovery_reason() const noexcept;
    std::uint64_t recovery_sequence() const noexcept;
    std::uint64_t sanitized_input_samples() const noexcept;
    GpuAudioStatus status_snapshot() const noexcept override;
    bool bind_realtime_path(detail::RealtimeGpuNodeBinding& binding) noexcept override;
    void process_block(const audio::BufferView<const float>&, audio::BufferView<float>&,
                       std::uint32_t) final;
 
  private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
    friend struct detail::WaveNetRealtimeTestAccess;
    bool authenticated_provider() const noexcept;
    static std::uint8_t process(void*, const audio::BufferView<const float>&,
                                audio::BufferView<float>&, std::uint32_t, std::uint64_t, bool,
                                std::uint64_t) noexcept;
    static std::uint32_t service(void*, std::uint64_t) noexcept;
    static bool fence(void*) noexcept;
    static void delivered(void*, std::uint64_t, std::uint8_t, std::uint64_t,
                          std::uint64_t) noexcept;
    static std::uint64_t next_sequence(void*) noexcept;
    static bool reprepare(void*, std::uint64_t) noexcept;
    // Host only, while no service step runs: route every channel's provider
    // completion events to the transport worker, or clear them.
    static bool set_notifier(void*, detail::SharedIoCompletionNotifier) noexcept;
    bool ready() const noexcept;
};
} // namespace pulp::gpu_audio