pulp::gpu_audio Namespace Reference

Namespaces
namespace	detail

Classes
struct	GpuAudioCapabilityReport
	Backend-neutral, allocation-free capability snapshot for installed SDK consumers. More...
struct	GpuAudioCapabilityValidation
struct	GpuAudioStatusValidation
struct	GpuAudioNodeDescriptor
	Declared, fixed scheduling properties of a GPU audio node. More...
class	GpuAudioNode
	A unit of audio work the transport schedules onto a non-real-time worker. More...
struct	GpuAudioProgramDescriptor
	Backend-neutral metadata for a typed program prepared for a fixed audio stream. More...
struct	GpuAudioProgramValidation
class	GpuAudioProviderPool
	Host-owned cache of prepared GPU-audio providers that survive a node's release, so the next prepare() of a node with the same program skips device, pipeline and resident-weight creation. More...
struct	GpuAudioStatus
	Versioned, allocation-free status shared by native hosts and UI adapters. More...
class	GpuAudioTransport
	Fixed-latency real-time transport between the audio thread and a non-RT worker that runs a GpuAudioNode. More...
struct	GpuConvolutionReverbConfig
	Configuration for the opt-in GPU realization of Forge's stereo convolution reverb. More...
struct	GpuConvolutionReverbLaneReport
	Per-lane evidence. More...
struct	GpuConvolutionReverbReport
class	GpuConvolutionReverb
	Optional, control-parity GPU route for the two-channel Forge convolution reverb. More...
struct	GpuConvolverTraceConfig
	Opt-in diagnostics for the shared-I/O path. More...
struct	GpuConvolverStagedBreaker
	Circuit breaker for the staged GPU readback. More...
class	GpuConvolver
	First real GPU audio node: FFT-based (overlap-add) convolution of the input with a fixed impulse response, computed on the GPU via render::GpuCompute on the transport's non-RT worker. More...
class	GpuMultiConvolver
	Massive multi-IR ("multi-room") convolution: convolves one mono input against MANY distinct impulse responses at once and pans the results into a stereo field — the whole bank in ONE batched GPU submit per block. More...
struct	GpuNeuralCpuKernel
	One channel's CPU model step, supplied and owned by the caller. More...
struct	GpuNeuralModelManifest
	Provenance and compatibility metadata for a model artifact. More...
struct	GpuNeuralModelShape
	The family's state shape: one layer per family (a single scalar TCN layer, one LSTM/GRU layer, one diagonal SSM). More...
struct	GpuNeuralModelRequest
struct	GpuNeuralModelResult
class	GpuNeuralRealtimeNode
	Architecture-neutral realtime neural node with a built-in CPU shadow. More...
class	GpuSpectralFreeze
	Phase-vocoder spectral freeze: capture one analysis frame and sustain it indefinitely with a SEAMLESS, evolving loop — no loop boundary, no click. More...
class	GpuSpectralMaskSession
class	GpuSpectralMorph
	Spectral morph: capture two spectra (A and B) and render a blend at position t ∈ [0,1] — the signature "morph between two sounds" effect. More...
class	GpuStft
	GPU short-time Fourier transform primitive (spectral toolkit). More...
struct	GpuWaveNetLayerDescriptor
struct	GpuWaveNetDescriptor
struct	GpuWaveNetValidation
struct	GpuWaveNetBlockResult
class	GpuWaveNetSession
	A prepared, one-stream shared-memory WaveNet session. More...
struct	GpuWaveNetTraceConfig
	Experimental stamped WaveNet bridge. More...
class	GpuWaveNetRealtimeNode
class	SpectralStack
	A stack of N captured spectral "moments" (layers) that can be sustained and morphed. More...
class	CpuSpectralStack
	CPU reference + always-available fallback. More...
class	GpuSpectralStack
	GPU-resident engine: the captured layer spectra live on the GPU and every hop runs advance + smear + weighted-sum + one inverse FFT on the device, reading back only the single synthesized frame. More...
struct	SpectralFreezeControls
	Per-hop control values handed to the framer (read on whatever thread drives the framer — the audio thread for the CPU engine, the GPU worker for the GPU engine). More...
class	SpectralFreezeFramer
	STFT freeze framer: turns an arbitrary-length input stream into hop-spaced analysis frames, drives a SpectralStack (capture on a Freeze rising edge, render every hop), and overlap-adds the synthesized frames back into an arbitrary-length output stream. More...
class	WebGpuConvolver
	Submit/collect FFT convolver for a single-threaded event loop. More...

Typedefs
using	GpuConvolutionReverbNode = GpuConvolutionReverb
	Name used by host/catalog integrations that treat the route as a node.
using	GpuNeuralModelHandle = std::shared_ptr<GpuNeuralModel>
using	GpuWaveNetLayerArrayDescriptor = GpuWaveNetLayerDescriptor

Enumerations
enum class	GpuAudioExecutionPath : std::uint8_t { Unavailable = 0 , Staged = 1 , SharedMemory = 2 , Cpu = 3 }
	The transport path selected for a prepared audio node. More...
enum class	GpuAudioProvider : std::uint8_t { Unknown = 0 , Dawn = 1 , Metal = 2 , Cpu = 3 }
	Provider identity when the selected path can establish it without exposing backend handles. More...
enum class	GpuAudioEligibility : std::uint8_t { Unavailable = 0 , Eligible = 1 }
	Eligibility of the configured transport path. More...
enum class	GpuAudioRecoveryPolicy : std::uint8_t { Manual = 0 , AutoReacquire = 1 }
	Whether a node may re-acquire a lost provider on its own. More...
enum class	GpuAudioCapabilityError : std::uint8_t {   None = 0 , InvalidEnumValue = 1 , UnpreparedStateHasPreparation = 2 , PreparedPathUnavailable = 3 ,   PreparedPathIneligible = 4 , CpuPathWithoutCpuProvider = 5 , CpuProviderOnGpuPath = 6 , CpuPathWithGpuKernel = 7 ,   SharedLeadMissing = 8 , FallbackUnavailable = 9 }
	Why a capability snapshot is not self-consistent. More...
enum class	GpuAudioStatusError : std::uint8_t {   None = 0 , SchemaVersionMismatch = 1 , InvalidEnumValue = 2 , RecoverySequenceMismatch = 3 ,   UninitializedStateHasPreparation = 4 , UninitializedStateHasRecovery = 5 , PreparedShapeMissing = 6 , ReadyWithoutEngine = 7 ,   GpuEngineWithoutProvider = 8 , DegradedOrUnavailableOnGpu = 9 , LostProviderNotUnavailable = 10 , SustainedMissesNotDegraded = 11 ,   CpuProviderWithGpuState = 12 , ShadowCountsWithoutShadow = 13 , TerminalCountsInconsistent = 14 , FallbackUnavailable = 15 ,   ReacquireSuccessesExceedAttempts = 16 , ReacquiredWithoutSuccess = 17 , ReacquiredNotDelivering = 18 , ReacquireTimingWithoutSuccess = 19 ,   GpuEngineWithoutKernel = 20 , FencingCauseReportedReady = 21 , ReadyWithoutDeliveryEpoch = 22 }
	Why a host-visible status snapshot is inconsistent. More...
enum class	MissPolicy { Silence , PassthroughDry , CpuFallback }
	What the transport does for a block when the GPU result is not ready in time (the worker fell behind, the device was lost, or the node is priming). More...
enum class	GpuAudioProgramKind : std::uint8_t {   Unknown = 0 , Convolution = 1 , Spectral = 2 , Neural = 3 ,   Custom = 255 }
	The typed workload family selected during host-side preparation. More...
enum class	GpuAudioTerminalDisposition : std::uint8_t {   Unknown = 0 , GpuDelivered = 1 , CpuFallback = 2 , Silence = 3 ,   StaleRejected = 4 , LateRejected = 5 , DeviceLost = 6 , Cancelled = 7 ,   kCount }
	One terminal audio disposition for an admitted block. More...
enum class	GpuAudioProgramError : std::uint8_t {   None = 0 , MissingKind = 1 , InvalidShape = 2 , PathUnavailable = 3 ,   MissingAlgorithmicLead = 4 , MissingPipelineDepth = 5 , InsufficientPipelineDepth = 6 , MissingProviderSlots = 7 ,   MissingProviderIdentity = 8 , ProviderResourcesNotOwned = 9 , ProviderResourcesOnCpu = 10 , ProviderResourcesOnStaged = 11 ,   ProviderOnCpu = 12 , CpuPipelineOnCpu = 13 , CpuFallbackNotPrepared = 14 , CapabilityNotPrepared = 15 ,   CapabilityIneligible = 16 , CapabilityPathMismatch = 17 , CapabilityProviderMismatch = 18 , CapabilityLeadMismatch = 19 ,   CapabilityFallbackPolicyMismatch = 20 , CapabilityFallbackUnavailable = 21 , InvalidEnumValue = 22 , CapabilityInvalid = 23 ,   CpuProviderOnGpuPath = 24 }
	Why a prepared program descriptor was rejected. More...
enum class	GpuAudioEngine : std::uint8_t { Unknown = 0 , Cpu = 1 , Gpu = 2 }
	The engine a host asked the audio provider to use. More...
enum class	GpuAudioProviderState : std::uint8_t { Uninitialized = 0 , Ready = 1 , Degraded = 2 , Unavailable = 3 }
	Lifecycle state suitable for UI, trace, and host diagnostics. More...
enum class	GpuAudioRecoveryReason : std::uint8_t {   None = 0 , SequenceGap = 1 , InputSaturated = 2 , ProviderFailure = 3 ,   ProviderLost = 4 , OfflineFence = 5 , InvalidCallback = 6 , ProviderUnresponsive = 7 ,   ProviderReacquired = 8 , SustainedDeadlineMisses = 9 }
	First latched reason that a node entered recovery. More...
enum class	GpuAudioCompletionMode : std::uint8_t { Unknown = 0 , ProcessEvents = 1 , WaitAny = 2 , TimedWaitAny = 3 }
	How the non-realtime dispatcher services provider completions. More...
enum class	GpuAudioShadowMode : std::uint8_t { None = 0 , Inline = 1 , Worker = 2 }
	How a node runs its CPU shadow alongside the GPU path. More...
enum class	GpuNeuralModelError : std::uint8_t {   None , UnsupportedFamily , InvalidManifest , InvalidBlockSize ,   MissingKernels , ShapeMismatch , UnsupportedBackend , AllocationFailed }
enum class	NeuralFamily : std::uint8_t {   Unknown = 0 , WaveNet = 1 , Tcn = 2 , Ssm = 3 ,   Lstm = 4 , Gru = 5 , Custom = 255 }
	Architecture family of a neural model hosted by GpuNeuralRealtimeNode. More...
enum class	GpuWaveNetError : std::uint8_t {   None = 0 , InvalidShape , UnsupportedTopology , UnsupportedActivation ,   WeightBlobMismatch , ResourceOverflow }
enum class	GpuWaveNetSessionError : std::uint8_t {   None = 0 , InvalidDescriptor , InvalidWeights , ProviderUnavailable ,   ProgramUnavailable , PreparationFailed , NotPrepared , InvalidBlock ,   NoSlot , SubmissionRejected , OutputTooSmall , ReleaseFailed }
	Errors returned while constructing or operating a one-stream shared WaveNet session. More...
enum class	GpuWaveNetBlockStatus : std::uint8_t { GpuDelivered = 0 , ProviderFailed }
enum class	GpuWaveNetCompletionPolicy : std::uint8_t { ProcessEvents , WaitAny , TimedWaitAny }
	How the serialized, non-realtime dispatcher services provider completions. More...

Functions
float	flow_hash (std::uint32_t k)
float	flow_base_azimuth (std::uint32_t k, std::uint32_t n)
void	flow_pan_room (float base_theta, std::uint32_t room_index, float depth, float spread, double t_seconds, float norm, float &pan_l, float &pan_r)
void	flow_pans_from_base (const float *base_theta, std::uint32_t n, float depth, float spread, double t_seconds, float norm, float *pan_l, float *pan_r)
void	fill_flow_pans (std::uint32_t n, double t_seconds, float depth, float spread, float *pan_l, float *pan_r)
constexpr GpuAudioCapabilityValidation	validate_gpu_audio_capability (const GpuAudioCapabilityReport &capability) noexcept
	Validate a capability snapshot.
constexpr GpuAudioStatusValidation	validate_gpu_audio_status (const GpuAudioStatus &status) noexcept
	Validate a status snapshot taken at a quiescent point.
constexpr GpuAudioProgramValidation	validate_gpu_audio_program (const GpuAudioProgramDescriptor &program) noexcept
	Validate the backend-neutral prepared-program contract.
constexpr GpuAudioProgramValidation	validate_gpu_audio_program (const GpuAudioProgramDescriptor &program, const GpuAudioCapabilityReport &capability) noexcept
	Validate a prepared program against the capability snapshot returned by the host transport.
GpuNeuralModelResult	make_gpu_neural_model (const GpuNeuralModelRequest &request) noexcept
	Host thread only.
constexpr GpuWaveNetValidation	validate_gpu_wavenet_descriptor (const GpuWaveNetDescriptor &descriptor) noexcept
float	spectral_phase_hash (std::uint32_t bin, std::uint32_t seed)
	Integer hash → float in [-0.5, 0.5], deterministic per (bin, seed).
std::uint32_t	advance_spectral_seed (std::uint32_t seed)
	Advance the jitter seed one render hop (the classic Numerical-Recipes LCG).

Variables
constexpr float	kSpectralTwoPi = 6.2831853071795864f
constexpr std::uint32_t	kSpectralSeedInit = 0x9E3779B9u
	Shared initial jitter seed so every engine starts the same wander sequence.

Typedef Documentation

GpuConvolutionReverbNode

using pulp::gpu_audio::GpuConvolutionReverbNode = GpuConvolutionReverb

Name used by host/catalog integrations that treat the route as a node.

GpuNeuralModelHandle

using pulp::gpu_audio::GpuNeuralModelHandle = std::shared_ptr<GpuNeuralModel>

GpuWaveNetLayerArrayDescriptor

using pulp::gpu_audio::GpuWaveNetLayerArrayDescriptor = GpuWaveNetLayerDescriptor

Enumeration Type Documentation

GpuAudioCapabilityError

enum class pulp::gpu_audio::GpuAudioCapabilityError : std::uint8_t

strong

Why a capability snapshot is not self-consistent.

Like the status validator below, this is backend-neutral: it checks enum domains and the relationships a report can witness on its own, never a provider handle, and it does not imply that a prepared path will meet a real-time deadline.

Enumerator
None
InvalidEnumValue
UnpreparedStateHasPreparation
PreparedPathUnavailable
PreparedPathIneligible
CpuPathWithoutCpuProvider
CpuProviderOnGpuPath
CpuPathWithGpuKernel
SharedLeadMissing
FallbackUnavailable

GpuAudioCompletionMode

enum class pulp::gpu_audio::GpuAudioCompletionMode : std::uint8_t

strong

How the non-realtime dispatcher services provider completions.

Unknown means the node does not report its completion servicing.

Enumerator
Unknown
ProcessEvents
WaitAny
TimedWaitAny

GpuAudioEligibility

enum class pulp::gpu_audio::GpuAudioEligibility : std::uint8_t

strong

Eligibility of the configured transport path.

This is not a hard real-time scheduling guarantee.

Enumerator
Unavailable
Eligible

GpuAudioEngine

enum class pulp::gpu_audio::GpuAudioEngine : std::uint8_t

strong

The engine a host asked the audio provider to use.

Unknown is used when the host did not make an explicit selection; it is deliberately distinct from the engine selected by a prepared transport.

Enumerator
Unknown
Cpu
Gpu

GpuAudioExecutionPath

enum class pulp::gpu_audio::GpuAudioExecutionPath : std::uint8_t

strong

The transport path selected for a prepared audio node.

Enumerator
Unavailable
Staged
SharedMemory
Cpu	A prepared CPU implementation with no GPU provider resources. Appended to preserve the established numeric values above.

GpuAudioProgramError

enum class pulp::gpu_audio::GpuAudioProgramError : std::uint8_t

strong

Why a prepared program descriptor was rejected.

Validation is constexpr so providers and SDK consumers can use the same fail-closed rules without allocating or calling into Dawn/Metal.

Enumerator
None
MissingKind
InvalidShape
PathUnavailable
MissingAlgorithmicLead
MissingPipelineDepth
InsufficientPipelineDepth
MissingProviderSlots
MissingProviderIdentity
ProviderResourcesNotOwned
ProviderResourcesOnCpu
ProviderResourcesOnStaged
ProviderOnCpu
CpuPipelineOnCpu
CpuFallbackNotPrepared
CapabilityNotPrepared
CapabilityIneligible
CapabilityPathMismatch
CapabilityProviderMismatch
CapabilityLeadMismatch
CapabilityFallbackPolicyMismatch
CapabilityFallbackUnavailable
InvalidEnumValue
CapabilityInvalid
CpuProviderOnGpuPath

GpuAudioProgramKind

enum class pulp::gpu_audio::GpuAudioProgramKind : std::uint8_t

strong

The typed workload family selected during host-side preparation.

A program kind is deliberately descriptive. It does not expose a shader, queue, device, or other backend object to an SDK consumer. Providers may add an implementation behind the same Pulp-owned kind in a later release.

Enumerator
Unknown
Convolution
Spectral
Neural
Custom

GpuAudioProvider

enum class pulp::gpu_audio::GpuAudioProvider : std::uint8_t

strong

Provider identity when the selected path can establish it without exposing backend handles.

Unknown is honest for a generic staged node.

Enumerator
Unknown
Dawn
Metal
Cpu	A CPU implementation with no GPU provider. Appended to preserve the established numeric values above.

GpuAudioProviderState

enum class pulp::gpu_audio::GpuAudioProviderState : std::uint8_t

strong

Lifecycle state suitable for UI, trace, and host diagnostics.

This is a provider state, not a real-time guarantee. Ready means an authenticated execution provider is active, or a CPU-only neural node runs its CPU model as requested (provider Cpu). Degraded means the transport is prepared but its provider or execution engine cannot be established. Scheduling and deadline behavior are reported by the counters and timings below.

Enumerator
Uninitialized
Ready
Degraded
Unavailable

GpuAudioRecoveryPolicy

enum class pulp::gpu_audio::GpuAudioRecoveryPolicy : std::uint8_t

strong

Whether a node may re-acquire a lost provider on its own.

Manual leaves a fenced node on its fallback until the host prepares it again.

Enumerator
Manual
AutoReacquire

GpuAudioRecoveryReason

enum class pulp::gpu_audio::GpuAudioRecoveryReason : std::uint8_t

strong

First latched reason that a node entered recovery.

Stamped shared-I/O nodes latch it; so do the staged GpuConvolver (ProviderFailure, ProviderLost, SustainedDeadlineMisses) and GpuMultiConvolver (ProviderLost). None means that no recovery has been requested. This is diagnostic state; it does not itself promise that the next callback will use the GPU.

Enumerator
None
SequenceGap
InputSaturated
ProviderFailure
ProviderLost
OfflineFence
InvalidCallback
ProviderUnresponsive	The provider stopped completing work within its watchdog budget.
ProviderReacquired	Informational: a lost provider was re-acquired under an automatic recovery policy and delivery resumed on a new epoch.
SustainedDeadlineMisses	The GPU is alive but repeatedly late; the node switched to CPU with periodic GPU probes. Maps to Degraded, not Unavailable.

GpuAudioShadowMode

enum class pulp::gpu_audio::GpuAudioShadowMode : std::uint8_t

strong

How a node runs its CPU shadow alongside the GPU path.

None means the node keeps no shadow; Inline runs it on the audio callback; Worker runs it off the callback and delivers it only when it is ready in time.

Enumerator
None
Inline
Worker

GpuAudioStatusError

enum class pulp::gpu_audio::GpuAudioStatusError : std::uint8_t

strong

Why a host-visible status snapshot is inconsistent.

Backend-neutral: it checks relationships between the projected engine, provider, lifecycle, recovery and counters, never provider handles, and it does not imply that a ready provider met a real-time deadline.

Enumerator
None
SchemaVersionMismatch
InvalidEnumValue
RecoverySequenceMismatch
UninitializedStateHasPreparation
UninitializedStateHasRecovery
PreparedShapeMissing
ReadyWithoutEngine
GpuEngineWithoutProvider
DegradedOrUnavailableOnGpu
LostProviderNotUnavailable
SustainedMissesNotDegraded
CpuProviderWithGpuState
ShadowCountsWithoutShadow
TerminalCountsInconsistent
FallbackUnavailable
ReacquireSuccessesExceedAttempts
ReacquiredWithoutSuccess
ReacquiredNotDelivering
ReacquireTimingWithoutSuccess
GpuEngineWithoutKernel
FencingCauseReportedReady
ReadyWithoutDeliveryEpoch

GpuAudioTerminalDisposition

enum class pulp::gpu_audio::GpuAudioTerminalDisposition : std::uint8_t

strong

One terminal audio disposition for an admitted block.

A GPU rejection and the audio delivered for that block are intentionally represented by one stable, host-visible value so a trace cannot leave an admitted block orphaned between provider completion and callback delivery.

Enumerator
Unknown
GpuDelivered
CpuFallback
Silence
StaleRejected
LateRejected
DeviceLost
Cancelled
kCount	Not a disposition: the number of values above. Append new values before it, and raise GpuAudioStatus::kTerminalDispositionCount to match, or the assert below fails.

GpuNeuralModelError

enum class pulp::gpu_audio::GpuNeuralModelError : std::uint8_t

strong

Enumerator
None
UnsupportedFamily
InvalidManifest
InvalidBlockSize
MissingKernels
ShapeMismatch
UnsupportedBackend	A GPU session was requested for a family without a GPU kernel.
AllocationFailed

GpuWaveNetBlockStatus

enum class pulp::gpu_audio::GpuWaveNetBlockStatus : std::uint8_t

strong

Enumerator
GpuDelivered
ProviderFailed

GpuWaveNetCompletionPolicy

enum class pulp::gpu_audio::GpuWaveNetCompletionPolicy : std::uint8_t

strong

How the serialized, non-realtime dispatcher services provider completions.

No policy ever waits on, or calls into, the provider from an audio callback.

Enumerator
ProcessEvents	Let the provider deliver finished work through its event pump on each service step.
WaitAny	Check the submitted work's completion handles directly, without waiting.
TimedWaitAny	As WaitAny, but wait on the handles up to the configured bound.

GpuWaveNetError

enum class pulp::gpu_audio::GpuWaveNetError : std::uint8_t

strong

Enumerator
None
InvalidShape
UnsupportedTopology
UnsupportedActivation
WeightBlobMismatch
ResourceOverflow

GpuWaveNetSessionError

enum class pulp::gpu_audio::GpuWaveNetSessionError : std::uint8_t

strong

Errors returned while constructing or operating a one-stream shared WaveNet session.

A missing provider is a normal capability result on platforms that do not ship the authenticated Dawn backend.

Enumerator
None
InvalidDescriptor
InvalidWeights
ProviderUnavailable
ProgramUnavailable
PreparationFailed
NotPrepared
InvalidBlock
NoSlot
SubmissionRejected
OutputTooSmall
ReleaseFailed

MissPolicy

enum class pulp::gpu_audio::MissPolicy

strong

What the transport does for a block when the GPU result is not ready in time (the worker fell behind, the device was lost, or the node is priming).

Enumerator
Silence	Output silence for the missed block (+ telemetry). The safe default: a dropout is obvious, bounded, and does not corrupt the timeline.
PassthroughDry	Output the dry input for the missed block. Timing-discontinuous — do not use in new nodes. The transport's output is delayed by latency_blocks * block_size, so at output time t the correct sample is the wet result for t - latency. This policy substitutes the dry sample for t instead, which jumps the stream FORWARD by the whole latency for one block and then jumps back. That is audible as a glitch and, worse, it is a timeline break rather than an honest dropout. A correct dry substitute would be the dry input delayed by the same latency. Nothing here holds that history, so there is no correct dry substitute to give. Prefer Silence, or CpuFallback with a continuously-primed, latency-aligned fallback (see prime_fallback).
CpuFallback	Run the node's CPU fallback for the missed block. Requires supports_cpu_fallback, a true cpu_fallback_prepared() witness after host preparation, and a fallback that is kept continuously fed and latency-aligned via prime_fallback() — otherwise the substitute is a stale block with a torn history.

NeuralFamily

enum class pulp::gpu_audio::NeuralFamily : std::uint8_t

strong

Architecture family of a neural model hosted by GpuNeuralRealtimeNode.

The family is a descriptor field, not a class: every family runs the same realtime contract, and only WaveNet currently has a GPU kernel.

Enumerator
Unknown
WaveNet
Tcn
Ssm
Lstm
Gru
Custom

Function Documentation

advance_spectral_seed()

std::uint32_t pulp::gpu_audio::advance_spectral_seed ( std::uint32_t seed )

inline

Advance the jitter seed one render hop (the classic Numerical-Recipes LCG).

The seed a render uses is the value BEFORE this advance, so successive hops draw a fresh, deterministic wander. Matches the GPU seed advance.

fill_flow_pans()

void pulp::gpu_audio::fill_flow_pans ( std::uint32_t n, double t_seconds, float depth, float spread, float * pan_l, float * pan_r )

inline

flow_base_azimuth()

float pulp::gpu_audio::flow_base_azimuth ( std::uint32_t k, std::uint32_t n )

inline

flow_hash()

float pulp::gpu_audio::flow_hash ( std::uint32_t k )

inline

flow_pan_room()

void pulp::gpu_audio::flow_pan_room ( float base_theta, std::uint32_t room_index, float depth, float spread, double t_seconds, float norm, float & pan_l, float & pan_r )

inline

flow_pans_from_base()

void pulp::gpu_audio::flow_pans_from_base ( const float * base_theta, std::uint32_t n, float depth, float spread, double t_seconds, float norm, float * pan_l, float * pan_r )

inline

make_gpu_neural_model()

GpuNeuralModelResult pulp::gpu_audio::make_gpu_neural_model ( const GpuNeuralModelRequest & request )

noexcept

Host thread only.

Validates the manifest, derives the family's state schema from its shape, and builds a model for one GpuNeuralRealtimeNode. Never throws; a failure is reported in the result.

spectral_phase_hash()

float pulp::gpu_audio::spectral_phase_hash ( std::uint32_t bin, std::uint32_t seed )

inline

Integer hash → float in [-0.5, 0.5], deterministic per (bin, seed).

Matches the hash01 function in the GPU spectral_advance shader bit-for-bit.

validate_gpu_audio_capability()

GpuAudioCapabilityValidation pulp::gpu_audio::validate_gpu_audio_capability ( const GpuAudioCapabilityReport & capability )

constexprnoexcept

Validate a capability snapshot.

An unprepared report must be the default snapshot. A prepared report must name an eligible path; the CPU path and the CPU provider imply each other, and a CPU path has no GPU kernel. A shared-memory path declares its algorithmic lead.

Known gaps, deliberately not checked because a shipped producer emits the state today:

• A staged or shared-memory path with gpu_kernel_available == false. A transport reports the kernel only from a node's health sample, so a staged node with no health hook never reports one. A shared-memory path also keeps its path after its kernel is gone: GpuConvolver hosted after an offline fence, GpuWaveNetRealtimeNode hosted after its fence or a failed re-acquire, and GpuNeuralRealtimeNode::capability_report() while its backend is quiesced.
• A shared-memory path with provider Unknown. GpuNeuralRealtimeNode::capability_report() reports this while its backend runs without an authenticated provider.
• A CPU path with a non-zero lead. Both producers report the delay of a latency-aligned CPU stream there.
• A staged path carrying a provider or a lead. No producer emits one, but validate_gpu_audio_program() requires a staged lead and checks a named staged provider against this report, so forbidding them would make every staged program unbindable. recovery_policy is checked for its domain and for the unprepared default only.

validate_gpu_audio_program() [1/2]

GpuAudioProgramValidation pulp::gpu_audio::validate_gpu_audio_program ( const GpuAudioProgramDescriptor & program )

constexprnoexcept

Validate the backend-neutral prepared-program contract.

validate_gpu_audio_program() [2/2]

GpuAudioProgramValidation pulp::gpu_audio::validate_gpu_audio_program ( const GpuAudioProgramDescriptor & program, const GpuAudioCapabilityReport & capability )

constexprnoexcept

Validate a prepared program against the capability snapshot returned by the host transport.

The descriptor alone is a declaration and can be authored by an SDK consumer; this overload is the fail-closed preparation boundary that proves the selected transport actually accepted the same path, provider identity, lead, and fallback policy. It still carries no backend handle and performs no provider or callback operation.

validate_gpu_audio_status()

GpuAudioStatusValidation pulp::gpu_audio::validate_gpu_audio_status ( const GpuAudioStatus & status )

constexprnoexcept

Validate a status snapshot taken at a quiescent point.

Counters sampled while a node runs may be momentarily inconsistent with one another, so a live caller should treat TerminalCountsInconsistent as advisory.

validate_gpu_wavenet_descriptor()

GpuWaveNetValidation pulp::gpu_audio::validate_gpu_wavenet_descriptor ( const GpuWaveNetDescriptor & descriptor )

constexprnoexcept

Variable Documentation

kSpectralSeedInit

std::uint32_t pulp::gpu_audio::kSpectralSeedInit = 0x9E3779B9u

constexpr

Shared initial jitter seed so every engine starts the same wander sequence.

kSpectralTwoPi

float pulp::gpu_audio::kSpectralTwoPi = 6.2831853071795864f

constexpr