pulp::audio Namespace Reference

Namespaces
namespace	adm_keys
	Keys used under ApplicationProperties::user_settings().
namespace	buffer_ops
namespace	detail

Classes
struct	AnalyzerDescriptor
struct	AnalyzerSelectionPolicy
struct	PackageAnalyzerDescriptorInput
struct	AnalyzerProvenance
struct	AnalyzerMarkerProvenance
struct	KeyTempoAnalysisConfig
struct	KeyTempoAnalysisResult
struct	TransientClassification
struct	TimePitchPrepareConfig
struct	TimePitchProcessSpec
struct	TimePitchPrepareResult
struct	TimePitchProcessResult
class	KeyTempoAnalyzer
class	TransientClassifier
class	TimePitchProcessor
class	AnalyzerProviderRegistry
struct	AsyncBlockEvent
	A timed event handed to or produced by the worker. More...
struct	AsyncBlockWorkerConfig
struct	AsyncBlockWorkerStats
class	AsyncBlockWorker
	Plays audio that a worker thread renders, at an exact, fixed latency, for a host whose blocks vary in size. More...
struct	DeviceStatsView
	Device-side facts the report mirrors (owned by AudioDeviceManager / the CoreAudio overload listener — never by the probe). More...
struct	BoundaryReport
struct	BoundaryReportInputs
	Inputs to the report. More...
struct	DeviceSelection
	Persisted audio-device selection. More...
class	MidiSubscriptionToken
	RAII subscription token. More...
class	AudioDeviceManager
	AudioDeviceManager — persistence + MIDI hub. More...
struct	AudioFileInfo
struct	AudioFileData
class	AudioFocusRegistry
struct	AudioIoTiming
	Immutable control-thread snapshot of one audio route's I/O timing. More...
struct	LatencySnapshot
	Control-thread composition of backend I/O timing with the graph's already computed total latency. More...
struct	AudioProbeCaptureConfig
	Configuration for the optional last-N-frames capture ring. More...
class	AudioProbe
	Realtime output-boundary probe. More...
struct	AudioProbeSnapshot
	Realtime-produced, fixed-capacity, trivially-copyable probe summary. More...
struct	AudioScopeAcquisitionConfig
struct	AudioScopeAcquisition
struct	AudioScopeMeasurements
struct	AudioScopeResult
struct	AudioStats
	Minimal release-safe audio counter aggregate. More...
struct	AudioStreamHandoffConfig
struct	AudioStreamHandoffPullResult
struct	AudioStreamHandoffStats
class	AudioStreamHandoff
class	AudioTap
	Fixed-capacity, single-producer/single-consumer audio analysis tap. More...
class	BufferView
	Non-owning view over multi-channel audio sample data. More...
class	Buffer
	Owning multi-channel audio buffer with contiguous storage. More...
class	BufferingReader
	Background-thread audio file reader for gapless streaming playback. More...
class	BuiltInKeyTempoAnalyzer
class	BuiltInTransientClassifier
struct	ChannelSet
	Named channel layout — maps channel indices to speaker positions. More...
struct	DeviceInfo
struct	DeviceConfig
struct	CallbackContext
class	AudioDevice
class	AudioSystem
struct	ExcerptQuery
struct	ExcerptWindow
struct	ExcerptCandidate
struct	ExcerptSearchSummary
struct	FiniteTimeStretchConfig
class	FiniteTimeStretchJob
	Control-thread-only, bounded finite SRC + time-stretch job. More...
class	AudioFormatReaderSource
	Plays back a MemoryMappedAudioReader as a PositionableAudioSource. More...
struct	DecodeLimits
	Resource ceilings a reader enforces on decoded output. More...
class	FormatReader
	Audio format reader interface. More...
class	FormatWriter
	Audio format writer interface. More...
class	FormatRegistry
	Registry of audio format readers and writers. More...
struct	ImpulseResponseLoadOptions
struct	AhdsrEnvelopeConfig
class	AhdsrEnvelope
struct	InstrumentTriggerResult
class	InstrumentRuntime
struct	InstrumentVoice
struct	VoiceTermination
struct	InstrumentVoiceTrigger
struct	VoiceAllocationResult
class	InstrumentVoiceAllocator
struct	LiveDspNodeInfo
	Immutable per-node identity, supplied to prepare() and copied into the store. More...
struct	LiveDspTelemetryConfig
struct	LiveDspSpectralDiagnostic
struct	LiveDspNodeSummary
	Per-node rolling summary produced by drain(). More...
struct	LiveDspTelemetrySnapshot
	Latest published summary. Owned by the store; valid until the next drain(). More...
class	LiveDspTelemetryNodeScope
	RAII per-node timing scope, constructed inside begin_block()'s active block. More...
class	LiveDspTelemetryBlockWriter
	Handle for one audio block. More...
class	LiveDspTelemetryStore
	The store. One producer (audio thread) and one consumer (drain/owner thread). More...
struct	AudioProcessLoadSnapshot
	Snapshot published by AudioProcessLoadMeasurer. More...
struct	AudioRuntimeOverloadPolicy
struct	AudioRuntimeOverloadReport
struct	LoadClockRatio
	Converts a span of monotonic clock ticks to nanoseconds. More...
class	AudioProcessLoadMeasurer
	Measures the CPU load of an audio processing callback. More...
struct	LoopFrameReadPlan
struct	LoopPlaybackAdvanceResult
class	LoopPlaybackCursor
	Allocation-free loop traversal state independent of sample storage. More...
struct	LoopPointAnalysisConfig
struct	LoopPointCandidate
struct	LoopEndpointSnapResult
struct	LoopPointAnalysisResult
class	LoopPointAnalyzer
class	LoopReader
struct	LoopRenderResult
class	LoopRenderer
struct	LoopRegion
struct	LoopValidationResult
struct	MidiVoiceModulationState
class	MidiVoiceModulationAdapter
class	MemoryMappedAudioReader
	Memory-mapped audio file reader. More...
struct	OfflineRenderBlockContext
	Per-block metadata for deterministic offline renders. More...
struct	OfflineRenderComputePolicy
struct	OfflineRenderComputeDecision
struct	OfflineRenderResourceRef
struct	OfflineRenderOptions
	Advanced offline render options. More...
struct	OfflineRenderStem
struct	OfflineRenderedStem
struct	OfflineRenderStemResult
struct	OfflineRenderComparison
struct	OfflineRenderManifestChunk
struct	OfflineRenderArtifactManifest
struct	OnsetDetectionConfig
struct	OnsetMarker
struct	OnsetDetectionResult
class	OnsetDetector
struct	PcmCapabilities
	What one direction (playback or capture) of a device can do. More...
struct	PcmDeviceSummary
	The lists and channel counts a DeviceInfo carries for one device. More...
struct	PlanarAudioRingBufferStats
class	PlanarAudioRingBuffer
struct	PublishedSampleStoreConfig
class	PublishedSampleStore
class	PullRateDetector
	Detects a host that calls the audio callback faster than real time. More...
struct	RealtimeSampleRecorderTiming
struct	RealtimeSampleRecorderCommand
struct	RealtimeSampleRecorderEvent
struct	RealtimeSampleRecorderConfig
struct	RealtimeSampleRecorderStats
class	RealtimeSampleRecorder
struct	RealtimeTimeStretchStreamFinalizePlan
struct	RealtimeTimeStretchConfig
struct	RealtimeTimeStretchPreparedGeometry
class	RealtimeTimeStretchProcessor
	Move-only prepared stream. More...
struct	RollingAudioCaptureBufferConfig
struct	RollingAudioCapturePrepareResult
struct	RollingAudioCaptureSnapshot
struct	RollingAudioCaptureMaterializeResult
class	RollingAudioCaptureHold
class	RollingAudioCaptureBuffer
struct	RtSafetyContract
struct	SampleAssetToken
struct	SampleAssetConfig
class	SampleAssetRegistrationProof
struct	SampleAssetView
	Immutable audio-thread snapshot borrowed from one SampleAsset owner. More...
class	SampleAsset
	Off-audio-thread owner for immutable sampler metadata and resident preload. More...
struct	SampleAssetPolicy
struct	SampleAssetDescriptor
struct	SampleAssetImportResult
struct	SampleAssetExportResult
struct	SampleAssetDropItem
class	SampleAssetImporter
class	SampleAssetExporter
struct	SampleBankSample
struct	SampleBankZone
struct	SampleBankManifest
struct	SampleBankParseResult
struct	SampleBankWriteResult
struct	SampleBankContentIssue
struct	SampleBankContentValidationResult
struct	SampleBankMaterializePolicy
class	PreparedSampleBank
struct	SampleBankMaterializeResult
class	SampleBankMaterializer
	Control/background-thread loader. More...
class	SampleConverter
	Run-time PCM converter. More...
struct	EditableSampleSource
struct	EditableSampleState
struct	SampleEditOperation
class	EditableSampleDocument
class	SampleEditHistory
class	SampleHeritageBusDsp
	Stateful post-mix processor for typed heritage bus blocks. More...
struct	SampleHeritagePrepareConfig
struct	SampleHeritageProcessPlan
class	SampleHeritageEngine
struct	SampleHeritageJsonParseResult
struct	SampleHeritageJsonWriteResult
struct	SampleHeritageRuntimeStateJsonParseResult
struct	SampleHeritageRuntimeStateJsonWriteResult
struct	SampleHeritageTypedRuntimeStateJsonParseResult
struct	SampleHeritageTypedRuntimeStateJsonWriteResult
struct	SampleHeritageLiveCyclicConfig
struct	SampleHeritageLiveCyclicResources
struct	SampleHeritageLiveCyclicPlan
struct	SampleHeritageLiveCyclicRngContinuation
class	SampleHeritageLiveCyclicStretch
	Fixed-capacity cyclic resynthesis for realtime sample playback. More...
struct	SampleHeritagePitchPlan
class	SampleHeritagePitchProcessor
	Streaming pitch-family mechanism for one sampler voice. More...
struct	SampleHeritageAutoCycleOptions
struct	SampleHeritageAutoCycleResult
struct	SampleHeritageRecordProvenance
struct	SampleHeritageCommittedAssetMetadata
class	SampleHeritageCommittedAsset
	Immutable result of the allocating, off-audio-thread record-commit path. More...
struct	SampleHeritageRecordCommitResult
struct	SampleHeritageRuntimeRngState
struct	SampleHeritageRuntimeState
	Fixed-capacity continuation payload for seeded stages. More...
struct	SampleHeritageRuntimeEngineState
struct	SampleHeritageVoiceRuntimeState
struct	SampleHeritageTypedRuntimeState
	Fixed-capacity continuation envelope for the typed sampler topology. More...
struct	SampleHeritageRuntimeStateCapture
struct	SampleHeritageTypedRuntimeStateCapture
struct	SampleHeritageVoiceMachineDomainBlock
struct	SampleHeritageVoiceClockBlock
struct	SampleHeritageVoicePitchBlock
struct	SampleHeritageVoiceConverterBlock
struct	SampleHeritageVoiceHoldDroopBlock
struct	SampleHeritageVoiceReconstructionBlock
struct	SampleHeritageVoiceAnalogColorBlock
struct	SampleHeritageVoiceLiveCyclicStretchBlock
struct	SampleHeritageVoiceBlockSpec
struct	SampleHeritageBusNoiseIdleBlock
struct	SampleHeritageBusOutputDriveBlock
struct	SampleHeritageBusBlockSpec
struct	SampleHeritageRecordInputDriveClipBlock
struct	SampleHeritageRecordRateBlock
struct	SampleHeritageRecordConverterBlock
struct	SampleHeritageRecordCommitCyclicStretchBlock
struct	SampleHeritageRecordCommitAdaptiveStretchBlock
struct	SampleHeritageRecordCommitBlockSpec
struct	SampleHeritageMachineDomainStage
struct	SampleHeritageQuantizationStage
struct	SampleHeritageClockPitchStage
struct	SampleHeritageDacHoldStage
struct	SampleHeritageReconstructionFilterStage
struct	SampleHeritageNoiseStage
struct	SampleHeritageOutputStage
struct	SampleHeritageStageSpec
struct	SampleHeritageProfile
	Authoring/serialization schema. More...
struct	SampleHeritagePreparedProfile
struct	SampleHeritageProfileValidation
struct	SampleHeritageSrcPlan
class	SampleHeritageCausalSrc
	Bounded causal streaming sample-rate converter for the heritage pipeline. More...
class	SampleHeritageVoiceDsp
	Prepared, fixed-memory processor for the typed per-voice heritage blocks. More...
struct	SampleInterpolationPolicyInfo
	Stable serialization/UI metadata for one interpolation policy. More...
struct	SampleInterpolationFootprint
struct	PreparedSampleInterpolation
struct	ResolvedSampleInterpolationPosition
struct	SampleKeyMapConfig
struct	SampleKeySliceResolution
class	SampleKeyMap
class	SampleMemoryGovernorEpoch
struct	SampleMemoryGovernorStats
class	SampleMemoryLease
	Move-only reservation against one shared sampler-memory cap. More...
struct	SampleMemoryReserveResult
class	SampleMemoryGovernorHandle
	Copyable lifetime-safe reservation/stats endpoint. More...
class	SampleMemoryGovernor
	Shared off-audio-thread admission governor for resident preload heads and stream-cache pages. More...
struct	SampleMipSidecar
struct	SampleMipBuildOptions
struct	SampleMipBuildResult
struct	SamplePoolEntry
struct	SamplePoolResolution
class	SamplePool
struct	SamplePreloadContract
struct	SamplePreloadContractResult
class	PreparedSampleRateConversion
	Immutable, allocation-free read kernel after control-thread construction. More...
class	SampleRateConversionBuilder
class	VariableRateConversionBuilder
class	PreparedVariableRateConversion
struct	SampleResourceSnapshot
struct	SampleResourceDiagnostics
class	SampleResourceHandle
struct	SampleResourceCacheLimits
struct	SampleResourceCacheStats
class	SampleResourceCache
	Control-thread decoded sample cache for samplers and loopers. More...
struct	SampleResourcePage
struct	SampleResourcePageWindow
struct	SampleResourcePageHandoffDiagnostics
class	SampleResourcePageHandoff
	Render-thread view of immutable decoded sample pages. More...
struct	SampleResourceLoadOptions
struct	SampleResourceServiceStats
class	SampleResourceService
	Non-RT service for background sample decode and cache prefetch. More...
struct	SampleSincKernelConfig
class	SampleSincKernelView
class	SampleSincKernel
struct	SampleSincKernelSelection
struct	SampleSincKernelBankView
class	SampleSincKernelBank
struct	PublishedSampleView
class	SampleSlotBank
struct	SampleStarvationEnvelopeConfig
struct	SampleStarvationEnvelopeStats
class	SampleStarvationEnvelope
struct	SampleStreamAsyncServiceConfig
struct	SampleStreamAsyncPrepareResult
struct	SampleStreamAsyncDispatchResult
struct	SampleStreamAsyncServiceTelemetry
struct	SampleStreamAsyncNoopDispatchCutpoint
class	SampleStreamAsyncService
	Owner-thread integration for cache reservations and background decode workers. More...
struct	SampleStreamConsumptionFactors
struct	SampleStreamConsumptionEvaluation
struct	SampleStreamConsumptionDeclaration
struct	SampleStreamDecodePoolConfig
struct	SampleStreamDecodeJob
struct	SampleStreamDecodeCompletion
struct	SampleStreamDecodeSourceAddResult
struct	SampleStreamDecodePoolTelemetry
struct	SampleStreamDecodeCompletionView
class	SampleStreamDecodePool
	Fixed-storage owner/worker decode pool. More...
struct	SampleStreamLoopBlockPlan
class	SampleStreamLoopVoiceReader
	Allocation-free paged adapter for LoopPlaybackCursor. More...
struct	SampleStreamPageRequest
struct	SampleStreamSchedulerStats
class	SampleStreamRequestInbox
class	SampleStreamScheduler
	Single-owner background scheduler for shared sample-cache page fills. More...
struct	SampleStreamSourceToken
struct	SampleStreamRequesterToken
struct	SampleStreamCacheServiceConfig
struct	SampleStreamCacheSourceConfig
struct	SampleStreamPageDemand
struct	SampleStreamCommand
struct	SampleStreamCommandInboxTelemetry
class	SampleStreamCommandInbox
	Prepared bounded command port from one RT producer to the service owner. More...
struct	SampleStreamCommandDrainResult
class	SampleStreamSourceRegistrationProof
struct	SampleStreamCacheSourceView
struct	SampleStreamSourceAddResult
struct	SampleStreamAsyncReservation
struct	SampleStreamAsyncReserveResult
struct	SampleStreamCacheServiceStats
class	SampleStreamCacheService
	Bounded shared-page cache with deterministic caller-driven servicing. More...
struct	SampleStreamVoiceBlockPlan
struct	SampleStreamVoiceBlockResult
struct	SampleStreamVoiceDemandEnqueueResult
class	SampleStreamVoiceReader
	Allocation-free linear forward one-shot reader over immutable sample assets. More...
struct	SampleStreamWindowConfig
struct	SampleStreamPageDescriptor
struct	SampleStreamPageView
struct	SampleStreamWindowReadRequest
struct	SampleStreamWindowReadResult
struct	SampleStreamWindowStats
class	SampleStreamWindow
struct	SampleVoiceRenderState
struct	SampleVoiceRenderOptions
struct	SampleVoiceRenderResult
class	SampleVoiceRenderer
struct	SampleZone
struct	ZoneSelectionRequest
struct	ZoneSelection
class	SampleZoneMap
class	ZoneSelector
struct	SamplerLooperMetricsSnapshot
class	SignalsmithTimePitchProcessor
struct	SliceMarker
struct	SliceRegion
struct	SliceMap
struct	SliceMarkerClassification
struct	SlicePointAnalysisConfig
struct	SlicePointAnalysisResult
struct	SliceSelectionOptions
class	SlicePointAnalyzer
class	AudioSource
	Abstract base — host-callable audio source. More...
class	PositionableAudioSource
	AudioSource with a notion of position. More...
class	AudioSourcePlayer
	Drives an AudioSource from a host audio callback. More...
class	FrameReaderStopToken
	Cooperative cancellation signal passed to a streaming frame reader. More...
struct	FrameReaderBinding
struct	StreamingSampleSourceConfig
class	StreamingSampleSource
struct	FileFrameReader
	A FrameReader plus the opened file's properties, ready to feed into a StreamingSampleSourceConfig (channels / total_frames / sample_rate). More...
class	StreamingWriter
	Streaming audio writer — writes audio in chunks to a file. More...
class	AudioSubsectionReader
	A view into a sub-range of an AudioFileData. More...
class	AudioTransportSource
	Wraps a PositionableAudioSource with transport-level control: More...
struct	UnisonVoiceStackTrigger
struct	UnisonVoiceChild
struct	UnisonVoiceTermination
struct	UnisonVoiceStackResult
struct	UnisonVoiceStackTerminationResult
class	UnisonVoiceStackManager
struct	VoiceModulationResult
struct	VoiceModulationAudioRateReservation
struct	VoiceModulationBufferConfig
struct	VoiceModulationLane
struct	VoiceModulationBlock
class	VoiceModulationBuffer
struct	VoiceLfoSourceSpec
struct	VoiceEnvelopeSourceSpec
struct	VoiceModulationSourcesConfig
class	VoiceModulationSources
	A fixed-capacity bank of per-voice modulation sources. More...
struct	VoiceNoteModulationResult
struct	VoiceNoteModulationInput
	Note/controller state translated to constant per-voice modulation lanes. More...
struct	VoiceNoteModulationRouting
	Explicit mapping from note semantics to VoiceModulationBuffer targets. More...
class	VoiceNoteModulationBridge
struct	AllocatedVoiceRuntimeTriggerResult
class	VoiceRuntimeFacade
	Primary template intentionally rejects unsupported owners. More...
class	VoiceRuntimeFacade< midi::Synthesiser< Voice > >
	Plain-MIDI facade. More...
class	VoiceRuntimeFacade< InstrumentVoiceAllocator >
	Prepared slot facade. More...
struct	VoiceSumInput
struct	VoiceSumOptions
struct	VoiceSumResult
class	VoiceSumMixer
struct	WavDecodeLimits
	Resource ceilings checked before the decoder allocates output storage. More...
struct	BwavMetadata
struct	AcidMetadata
struct	WavMetadata
struct	AudioPeak
struct	OverviewLevel
struct	WaveformOverviewInfo
class	WaveformOverview
struct	WaveformOverviewCacheStats
class	WaveformOverviewCache
struct	WavetableCycleSelection
struct	WavetableAuthoringRecipe
struct	WavetableAuthoringProvenance
struct	WavetableCompileResult
struct	WindowEnumerationResult
class	AudioWorkgroup
	Manages real-time thread priority for audio processing threads. More...

Typedefs
using	AudioCallback
using	FiniteTimeStretchRatioAtInputFrame
using	OfflineProcessCallback
	Callback for processing a block of audio.
using	OfflineRenderCallback
	Callback for deterministic offline render blocks.
using	OnsetDetectionMethod = signal::OnsetDetectionMethod
using	SampleHeritageVoiceBlockParameters
using	SampleHeritageBusBlockParameters
using	SampleHeritageRecordCommitBlockParameters
using	SampleHeritageStageParameters
using	SampleResourceDecodeFunction
using	FrameReader
	Caller-supplied random-access frame reader.
using	StoppableFrameReader

Enumerations
enum class	AnalyzerCapability : std::uint8_t {   OnsetDetection = 0 , BeatDetection = 1 , SliceAnalysis = 2 , LoopPointAnalysis = 3 ,   KeyDetection = 4 , TempoDetection = 5 , TransientClassification = 6 , TimeStretch = 7 ,   PitchShift = 8 , PitchDetection = 9 }
enum class	AnalyzerBackend : std::uint8_t { BuiltIn , Package , ExternalProcess , ImportedMetadata }
enum class	AnalyzerAvailability : std::uint8_t {   Available , MissingPackage , LicenseNotAccepted , UnsupportedPlatform ,   Disabled , Unavailable }
enum class	AnalyzerLicensePolicy : std::uint8_t {   Permissive , NoticeRequired , Copyleft , Commercial ,   Unknown }
enum class	AnalyzerExecutionContext : std::uint8_t { OfflineOnly , BackgroundThread , RealtimeSafe }
enum class	AnalyzerDescriptorStatus : std::uint8_t {   ok , empty_id , empty_display_name , missing_capability ,   package_id_required , duplicate_id }
enum class	TimePitchPrepareStatus : std::uint8_t {   ok , unavailable , invalid_config , allocation_failed ,   setup_failed }
enum class	TimePitchProcessStatus : std::uint8_t {   ok , unavailable , invalid_config , not_prepared ,   channel_mismatch , frame_budget_exceeded , processing_failed }
enum class	MusicalKeyMode : std::uint8_t { Unknown , Major , Minor }
enum class	TransientClass : std::uint8_t {   Unknown , Kick , Snare , Clap ,   Hat , Cymbal , Tom , Bass ,   Vocal , Percussion , Tonal , Noise }
enum class	AsyncBlockMode : std::uint8_t { Realtime , Offline , Auto }
	How a process() call may treat a worker that has not finished the audio the callback is about to play. More...
enum class	BoundaryDiagnosis {   kNoProbeData , kSignalPresent , kProcessorSilent , kStandaloneBoundarySilent ,   kDeviceProblem }
	Coarse classification of where audio was lost (or that it was fine). More...
enum class	WavBitDepth { Int16 , Int24 , Float32 }
enum class	AudioFocusState : std::uint8_t { gained = 0 , duck = 1 , lost = 2 , lost_transient = 3 }
	Audio-focus state reported to listeners. More...
enum class	AudioTimestampDomain : std::uint8_t { unspecified , device_sample_frames , monotonic_host_time }
	Clock domain used by the backend's audio timestamps. More...
enum class	AudioTimingSource : std::uint8_t { unspecified , device_clock , os_estimate , user_calibration }
	Authority behind the reported I/O timing. More...
enum class	AudioTimingConfidence : std::uint8_t { unavailable , estimated , reported , calibrated }
	How strongly callers may rely on the reported values. More...
enum class	AudioProbeStage : std::uint32_t {   kUnknown = 0 , kProcessorOutput = 1 , kStandaloneOutputBoundary = 2 , kMeterBridge = 3 ,   kDeviceCallback = 4 , kGraphNode = 5 }
	Identifies which audio boundary a snapshot was produced at. More...
enum class	AudioScopeTriggerMode : std::uint8_t { kNone = 0 , kRisingZero = 1 }
enum class	Speaker : uint8_t {   FrontLeft = 0 , FrontRight , FrontCenter , LFE ,   BackLeft , BackRight , SideLeft , SideRight ,   TopFrontLeft , TopFrontRight , TopBackLeft , TopBackRight ,   TopCenter , Discrete }
	Speaker position identifiers. More...
enum class	ShareMode { shared , exclusive }
enum class	FiniteTimeStretchPrepareStatus : std::uint8_t {   Prepared , InvalidSource , InvalidSlice , InvalidSampleRate ,   InvalidBlockSize , InvalidTarget , InvalidRatio , CapacityExceeded ,   SampleRateConverterPrepareFailed , ProcessorPrepareFailed }
enum class	FiniteTimeStretchStepStatus : std::uint8_t { Progress , Complete , Failed }
enum class	FiniteTimeStretchFailure : std::uint8_t {   None , AllocationFailed , InvalidRatio , OutputTooShort ,   OutputTooLong , ProcessorProtocolError }
enum class	FiniteTimeStretchStage : std::uint8_t {   PrepareSampleRateConverter , MaterializeTimelineInput , PrepareStretch , Stretch ,   ConvertOutput , Complete , Failed }
enum class	EnvelopeStage : std::uint8_t {   Idle , Attack , Hold , Decay ,   Sustain , Release }
enum class	VoiceStealPolicy : std::uint8_t { Oldest , PreferSameVoiceGroupOldest }
enum class	VoiceState : std::uint8_t { Free , Active , Released }
enum class	VoiceTerminationReason : std::uint8_t { Choked , Stolen }
enum class	LiveDspNodeKind : std::uint8_t {   Unknown = 0 , AudioInput , AudioOutput , Plugin ,   Gain , MidiInput , MidiOutput , Custom ,   Utility }
	Coarse node classification, interned at prepare() time (never on the RT thread). More...
enum class	AudioRuntimeOverloadSeverity : uint8_t { Nominal = 0 , Watch , Overloaded , Critical }
enum class	LoopEndpointRole : std::uint8_t { StartFrame , ExclusiveEndFrame }
enum class	LoopPlaybackMode : std::uint8_t {   OneShot , Forward , Reverse , PingPong ,   ReverseOnce }
enum class	LoopCrossfadeCurve : std::uint8_t { Linear , EqualPower }
enum class	LoopInterpolationMode : std::uint8_t { None , Linear , Cubic }
enum class	LoopSnapPolicy : std::uint8_t { None , NearestZeroCrossing , SlopeMatchedZeroCrossing , ValueDirection }
enum class	LoopValidationStatus : std::uint8_t {   Ok , EmptySource , InvalidRange , TooShort ,   CrossfadeTooLong , InvalidSampleRate }
enum class	OfflineRenderTailPolicy : uint8_t { Truncate = 0 , RenderTail }
enum class	OfflineRenderExecutionScope : uint8_t { RealtimeAudioThread = 0 , OfflineAnalysis , BackgroundAnalysis }
enum class	OfflineRenderComputeBackend : uint8_t { Cpu = 0 , Gpu }
enum class	RealtimeSampleRecorderState : std::uint8_t {   Idle , Armed , Recording , Completing ,   Completed , Cancelled , Failed }
enum class	RealtimeSampleRecorderCommandType : std::uint8_t {   Arm , Start , Stop , Cancel ,   Reset }
enum class	RealtimeSampleRecorderTimingType : std::uint8_t { Immediate , BlockOffset }
enum class	RealtimeSampleRecorderEventType : std::uint8_t {   CommandAccepted , CommandRejected , Started , Completed ,   Cancelled , Failed }
enum class	RealtimeTimeStretchQuality : std::uint8_t { quality , low_latency }
enum class	RealtimeTimeStretchPrepareStatus : std::uint8_t {   prepared , invalid_sample_rate , invalid_channel_count , invalid_max_block ,   invalid_max_time_ratio , invalid_spectral_geometry , unrepresentable_capacity }
enum class	RealtimeTimeStretchStreamFeedStatus : std::uint8_t { accepted , backpressure , input_closed , invalid_request }
enum class	RealtimeTimeStretchStreamFinalizeStatus : std::uint8_t { draining , backpressure , complete , invalid_request }
enum class	RealtimeTimeStretchStreamFinalizePlanStatus : std::uint8_t { ready , needs_drain , complete , invalid_request }
enum class	RollingAudioCaptureMaterializeStatus : std::uint8_t { Ok , InvalidSnapshot , Overwritten , DestinationTooSmall }
enum class	RtSafetyClass : std::uint8_t {   AudioCallbackSafe , AudioCallbackSafeAfterPrepare , AudioCallbackSafeWithImmutableInputs , RealtimeTelemetryOnly ,   ControlThreadOnly , BackgroundThreadOnly , OfflineOnly }
enum class	SampleAssetKind : std::uint8_t { unknown , audio , midi }
enum class	SampleAssetStatus : std::uint8_t {   ok , empty_path , unsupported_extension , unsupported_asset_kind ,   metadata_read_failed , read_failed , write_failed , invalid_audio ,   channel_budget_exceeded , frame_budget_exceeded , byte_budget_exceeded , sample_rate_not_allowed }
enum class	SampleBankStatus : std::uint8_t {   ok , invalid_json , root_not_object , unknown_field ,   duplicate_field , missing_field , wrong_type , unsupported_schema ,   invalid_identifier , invalid_sample_id , invalid_path , invalid_hash ,   duplicate_sample_id , duplicate_sample_path , invalid_zone , missing_sample_reference ,   filesystem_error , path_escape , hash_mismatch , import_failed ,   preparation_failed , resource_limit_exceeded , unsupported_materialization_policy }
enum class	SampleFormat : uint8_t {   Int8 , Int16 , Int24 , Int32 ,   Float32 , Float64 }
	Packed-PCM sample format the bytes are encoded in. More...
enum class	Endianness : uint8_t { Little , Big , Native }
	Byte order. More...
enum class	Layout : uint8_t { Interleaved , Planar }
	Memory layout of the byte stream relative to channels. More...
enum class	SampleEditOperationKind : std::uint8_t {   none , set_trim , set_fades , set_loop ,   clear_loop , set_reverse , set_normalize_gain }
enum class	SampleHeritageBusDspStatus : std::uint8_t { Ok , NotPrepared , InvalidProfile , InvalidDimensions }
enum class	SampleHeritagePrepareStatus : std::uint8_t {   Ok , InvalidProfile , InvalidDimensions , UnsupportedRateConversion ,   SizeOverflow , AllocationFailed , KernelBuildFailed }
enum class	SampleHeritagePlanStatus : std::uint8_t { Ok , NotPrepared , OutputTooLarge , SizeOverflow }
enum class	SampleHeritageProcessStatus : std::uint8_t {   Ok , NotPrepared , InvalidPlan , InvalidDimensions ,   InputFrameMismatch , TailInputNotSilent , InternalContractFailure }
enum class	SampleHeritageJsonStatus : std::uint8_t {   Ok , InvalidJson , RootNotObject , UnknownField ,   DuplicateField , MissingField , WrongType , InvalidEnum ,   NumberOutOfRange , ProfileValidationFailed }
	Strict errors for the versioned sample-heritage JSON boundary. More...
enum class	SampleHeritageLiveCyclicShuffle : std::uint8_t { Identity , FisherYates }
enum class	SampleHeritageLiveCyclicStatus : std::uint8_t {   Ok , NotPrepared , InvalidConfiguration , SizeOverflow ,   AllocationFailed , InvalidDimensions , InputFrameMismatch , SourceUnavailable }
enum class	SampleHeritagePitchStatus : std::uint8_t {   Ok , NotPrepared , InvalidConfiguration , SizeOverflow ,   AllocationFailed , InvalidDimensions , InputFrameMismatch , HistoryUnavailable }
enum class	SampleHeritageRecordCommitStatus : std::uint8_t {   Ok , InvalidProfile , InvalidSource , InvalidProvenance ,   InvalidRecordChain , SizeOverflow , AllocationFailed , InvalidMetadata ,   NonCanonicalMetadata , ProfileMismatch , AudioHashMismatch }
enum class	SampleHeritageAutoCycleStatus : std::uint8_t {   Ok , InvalidSource , InvalidRange , InsufficientSignal ,   NoReliableCycle }
enum class	SampleHeritageRuntimeRngStageType : std::uint8_t { Quantization , Noise , LiveCyclic }
enum class	SampleHeritageRuntimeStateStatus : std::uint8_t {   Ok , NotPrepared , UnsupportedSchemaVersion , ProfileMismatch ,   InvalidStageLayout , InvalidRandomState , InvalidSlotLayout , InvalidHostSampleRate }
enum class	SampleHeritageSeedPolicy : std::uint8_t { RestartFromProfileSeed , ContinueSerializedState }
enum class	SampleHeritageBlockDomain : std::uint8_t { Voice , Bus , RecordCommit }
enum class	SampleHeritagePitchFamily : std::uint8_t { VariableClock , DropRepeat , EarlyLinear }
enum class	SampleHeritageConverterFamily : std::uint8_t { LinearPcm , MuLaw , ALaw }
enum class	SampleHeritageHoldMode : std::uint8_t { ZeroOrder }
enum class	SampleHeritageCutoffLaw : std::uint8_t { FixedHz , MachineRateRatio }
enum class	SampleHeritageNoiseGate : std::uint8_t { AlwaysOn , VoiceActive }
enum class	SampleHeritageReconstructionFamily : std::uint8_t { OnePole , Butterworth , Chebyshev , Elliptic }
enum class	SampleHeritageRecordFilterFamily : std::uint8_t { OnePole , Butterworth , Chebyshev , Elliptic }
enum class	SampleHeritageAnalogFilterFamily : std::uint8_t { None , Ladder4Pole }
enum class	SampleHeritageLivePitchMode : std::uint8_t { Preserve , RateLinked }
enum class	SampleHeritageProfileStatus : std::uint8_t {   Ok , UnsupportedSchemaVersion , InvalidProfileId , InvalidHostSampleRate ,   TooManyStages , TooManyBlocks , WrongBlockDomain , MixedLegacyAndTypedBlocks ,   NonCanonicalProfileRepresentation , DuplicateStage , InvalidStageOrder , InvalidStageParameter ,   UnsupportedRateConversion , DigestUnavailable }
enum class	SampleHeritageSrcStatus : std::uint8_t {   Ok , NotPrepared , InvalidConfiguration , SizeOverflow ,   AllocationFailed , InvalidDimensions , InputFrameMismatch , HistoryUnavailable }
enum class	SampleInterpolationPolicy : std::uint8_t {   Hold = 0 , Nearest = 1 , Linear = 2 , CubicHermite = 3 ,   CubicLagrange = 4 , RatioTrackingSinc = 5 }
enum class	SampleMemoryCategory : std::uint8_t { Preload , Page }
enum class	SampleMemoryReserveStatus : std::uint8_t {   Acquired , NotPrepared , InvalidByteCount , InvalidCategory ,   BudgetExceeded }
enum class	SampleMipSidecarStatus : std::uint8_t { Absent , Valid , Invalid }
enum class	SamplePreloadContractStatus : std::uint8_t {   Ok , InvalidSourceSampleRate , InvalidHostSampleRate , InvalidPlaybackRatio ,   InvalidLatency , Overflow }
enum class	SampleResourceStatus : uint8_t { Empty , Loaded , Missing , Oversized }
enum class	SampleSlotState : std::uint8_t {   Free , Reserved , Writing , Completed ,   Published , Retired }
enum class	SampleStarvationMode : std::uint8_t { Ready , FadingOut , Silent , Recovering }
enum class	SampleStreamAsyncPrepareStatus : std::uint8_t {   Ok , InvalidConfiguration , CachePrepareFailed , DecodePrepareFailed ,   MetadataAllocationFailed }
enum class	SampleStreamAsyncDispatchStatus : std::uint8_t {   Queued , Idle , Deferred , PoolRejected ,   InvalidState }
enum class	SampleStreamAsyncPollStatus : std::uint8_t { None , Published , Discarded , CopyFailed }
enum class	SampleStreamConsumptionStatus : std::uint8_t { Allowed , LegacyRejected , HeritageRejected }
enum class	SampleStreamDecodeCompletionStatus : std::uint8_t {   Decoded , ShortRead , ReaderError , Canceled ,   Stopped }
enum class	SampleStreamDecodeCompletionMatch : std::uint8_t {   Accepted , StaleSource , StaleGeneration , StaleReservation ,   DecodeError , Canceled , Stopped }
enum class	SampleStreamDecodeSourceAddStatus : std::uint8_t {   Added , InvalidSource , DuplicateSource , SourceCapacityFull ,   Stopped }
enum class	SampleStreamDecodeSubmitStatus : std::uint8_t {   Queued , InvalidJob , StaleSource , StaleGeneration ,   StaleReservation , SourceInFlight , QueueFull , Stopped }
enum class	SampleStreamDecodeCancelStatus : std::uint8_t {   Canceled , AlreadyCanceled , StaleSource , StaleGeneration ,   Stopped }
enum class	SampleStreamDemandClass : std::uint8_t { Attack , Sustain , Release }
enum class	SampleStreamScheduleStatus : std::uint8_t { Inserted , Refreshed , Full , Invalid }
enum class	SampleStreamCommandType : std::uint8_t { DemandPage , CancelRequester , CancelPendingSourceDemands }
enum class	SampleStreamCommandPushStatus : std::uint8_t { Enqueued , Full }
enum class	SampleStreamSourceAddStatus : std::uint8_t {   Added , InvalidConfig , DuplicateSource , StaleGeneration ,   SourceIdentityCapacityExceeded , BudgetExceeded , AllocationFailed }
enum class	SampleStreamSourceRetireStatus : std::uint8_t { Scheduled , InvalidGeneration , StaleSource , AlreadyScheduled }
enum class	SampleStreamServiceStatus : std::uint8_t {   Idle , Published , AlreadyReady , PageRetired ,   WaitingForAudioGeneration , StaleSource , NoPageAvailable , ReadFailed ,   PublishFailed }
enum class	SampleStreamAsyncReserveStatus : std::uint8_t {   Reserved , Idle , AlreadyReady , PageRetired ,   WaitingForAudioGeneration , StaleSource , SourceInFlight , NoPageAvailable ,   SerialExhausted }
enum class	SampleStreamAsyncCompletionStatus : std::uint8_t {   Published , Canceled , StaleSource , StaleRegistration ,   StaleReservation , CopyFailed , PublishFailed }
enum class	SampleStreamVoiceSupply : std::uint8_t {   Ready , Starved , EndOfSource , StaleGeneration ,   InvalidContract }
enum class	SampleStreamVoiceOutcomeClass : std::uint8_t {   None , ServiceStarvation , InvalidPreloadContract , StaleGeneration ,   NormalEndOfSource , InvalidRenderContract }
enum class	SampleStreamPageState : std::uint8_t {   Empty , Filling , Ready , Retiring ,   Retired }
enum class	SliceMarkerSource : std::uint8_t {   Onset , BeatGrid , Silence , Manual ,   Imported , LoopStart , LoopEnd }
enum class	SliceCandidateSelection : std::uint8_t { TimelineOrder , StrongestConfidence }
enum class	SliceSnapPolicy : std::uint8_t { NearZero , SignTransition }
enum class	FrameReaderStopMode : std::uint8_t { JoinOnly , Cooperative }
enum class	StreamingUnderrunPolicy : std::uint8_t { PreservePosition = 0 , AdvancePosition }
enum class	VoiceModulationTarget : std::uint8_t {   Gain , PitchCents , Pan , Pressure ,   Timbre , Aux0 , Aux1 , Aux2 ,   Aux3 , Aux4 , Aux5 , Aux6 ,   Aux7 }
enum class	VoiceModulationRate : std::uint8_t { Constant , AudioRate }
enum class	VoiceModulationStatus : std::uint8_t {   Ok , NotPrepared , InvalidFrameCount , InvalidTarget ,   NonFiniteValue , DuplicateTarget , LaneOverflow }
enum class	VoiceLfoPhasePolicy : std::uint8_t { FreeRunning , Retrigger }
	LFO phase policy on note-on. More...
enum class	VoiceNoteModulationStatus : std::uint8_t {   Ok , NotPrepared , InvalidFrameCount , InvalidNote ,   InvalidController , InvalidBendRange , InvalidRouting , InsufficientLanes ,   BufferRejected }
enum class	VoiceRuntimeFacadeStatus : std::uint8_t {   Ok , OwnerNotPrepared , InvalidModulationCapacity , InvalidTerminationCapacity ,   OwnerRejected }
enum class	WavetableCompileStatus : std::uint8_t {   Ok , InvalidSource , InvalidRecipe , InvalidExplicitCycle ,   InsufficientSignal , NoReliableCycle , SizeOverflow , AllocationFailed ,   FftUnavailable , NonFiniteResult }
enum class	WindowEnumerationStatus { ok , invalid_query , empty_audio , file_too_short }

Functions
const char *	analyzer_capability_name (AnalyzerCapability capability) noexcept
const char *	analyzer_backend_name (AnalyzerBackend backend) noexcept
const char *	analyzer_availability_name (AnalyzerAvailability availability) noexcept
const char *	analyzer_license_policy_name (AnalyzerLicensePolicy policy) noexcept
const char *	analyzer_execution_context_name (AnalyzerExecutionContext context) noexcept
const char *	analyzer_descriptor_status_name (AnalyzerDescriptorStatus status) noexcept
const char *	time_pitch_prepare_status_name (TimePitchPrepareStatus status) noexcept
const char *	time_pitch_process_status_name (TimePitchProcessStatus status) noexcept
bool	analyzer_descriptor_has_capability (const AnalyzerDescriptor &descriptor, AnalyzerCapability capability) noexcept
AnalyzerDescriptorStatus	validate_analyzer_descriptor (const AnalyzerDescriptor &descriptor) noexcept
bool	analyzer_descriptor_selectable (const AnalyzerDescriptor &descriptor, AnalyzerCapability capability, const AnalyzerSelectionPolicy &policy={}) noexcept
AnalyzerLicensePolicy	classify_analyzer_license_policy (std::string_view license_id) noexcept
AnalyzerAvailability	infer_package_analyzer_availability (bool installed, bool platform_supported, bool license_accepted) noexcept
AnalyzerDescriptor	make_package_analyzer_descriptor (const PackageAnalyzerDescriptorInput &input)
AnalyzerProvenance	analyzer_provenance_from_descriptor (const AnalyzerDescriptor &descriptor, std::string analysis_id={})
bool	validate_analyzer_marker_provenance (std::size_t marker_count, std::span< const AnalyzerMarkerProvenance > provenance) noexcept
const AnalyzerProvenance *	find_analyzer_marker_provenance (std::span< const AnalyzerMarkerProvenance > provenance, std::uint32_t marker_index) noexcept
std::vector< AnalyzerDescriptor >	built_in_analyzer_descriptors ()
BoundaryReport	build_boundary_report (const BoundaryReportInputs &inputs)
	Build the complaint-oriented boundary report from the given inputs.
std::optional< AudioFileInfo >	read_audio_file_info (const std::string &path)
std::optional< AudioFileData >	read_audio_file (const std::string &path)
std::optional< AudioFileData >	read_audio_file (const std::string &path, const std::function< bool(const AudioFileInfo &)> &admit)
bool	write_wav_file (const std::string &path, const AudioFileData &data)
bool	write_wav_file (const std::string &path, const AudioFileData &data, WavBitDepth bit_depth)
bool	write_wav_stream (std::ostream &output, const AudioFileData &data, WavBitDepth bit_depth)
void	int16_to_float (const int16_t *src, float *dst, size_t count)
void	int24_to_float (const uint8_t *src, float *dst, size_t count)
void	int32_to_float (const int32_t *src, float *dst, size_t count)
void	float_to_int16 (const float *src, int16_t *dst, size_t count)
void	float_to_int32 (const float *src, int32_t *dst, size_t count)
constexpr bool	is_supported_audio_sample_rate (double sample_rate_hz) noexcept
constexpr std::uint64_t	saturating_frame_add (std::uint64_t lhs, std::uint64_t rhs) noexcept
constexpr std::optional< std::uint64_t >	next_calibration_generation (std::uint64_t generation) noexcept
constexpr std::optional< LatencySnapshot >	make_latency_snapshot (const AudioIoTiming &timing, std::uint64_t graph_latency_frames, double graph_sample_rate_hz) noexcept
	Compose I/O timing with a graph total obtained from the graph's public latency accessor.
std::string_view	audio_probe_stage_name (AudioProbeStage stage)
	Stable string name for a probe stage, used as the JSON stage field.
std::string	audio_probe_snapshot_to_json (const AudioProbeSnapshot &snapshot, const AudioStats &stats, bool pretty=true)
	Serialize a probe snapshot (and the release-safe counter subset) to a flat JSON object string.
AudioScopeAcquisition	acquire_audio_scope_window (BufferView< const float > source, const AudioScopeAcquisitionConfig &config, const AudioProbeSnapshot *snapshot_metadata=nullptr)
AudioScopeMeasurements	measure_audio_scope_window (const AudioScopeAcquisition &acquisition)
std::string_view	audio_scope_trigger_mode_name (AudioScopeTriggerMode mode)
bool	parse_audio_scope_trigger_mode (std::string_view text, AudioScopeTriggerMode &out)
std::string	audio_scope_result_to_json (const AudioScopeResult &result, bool pretty=true)
	Serialize a scope result to the stable v1 JSON shape.
std::string	speaker_name (Speaker speaker)
	Get the speaker name as a string (e.g., "Front Left", "LFE").
std::optional< AudioIoTiming >	query_audio_io_timing (const AudioDevice &device) noexcept
	Current route timing, or no value when the concrete backend has not implemented timing publication.
std::unique_ptr< AudioSystem >	create_audio_system ()
void	zero_fill_short_read (float *buf, int frames_read, int total_frames, int channels) noexcept
	Zero-fill the trailing samples of an interleaved input buffer after a short read.
std::optional< std::vector< float > >	read_impulse_response_pcm (const float *samples, std::size_t frames, std::uint32_t channels, double src_rate, double target_sample_rate, const ImpulseResponseLoadOptions &opts={})
	Read already-decoded PCM → mono → resampled to target_sample_rate → (optionally) unit-energy normalized.
std::optional< std::vector< float > >	read_impulse_response (const std::string &path, double target_sample_rate, const ImpulseResponseLoadOptions &opts={})
	Read an IR file → mono → resampled to target_sample_rate → (optionally) unit-energy normalized.
const char *	to_string (LiveDspNodeKind kind) noexcept
std::string	live_dsp_telemetry_snapshot_to_json (const LiveDspTelemetrySnapshot &snapshot, bool pretty=true)
	Serialize a live-DSP telemetry snapshot to a flat JSON object string.
const char *	to_string (AudioRuntimeOverloadSeverity severity) noexcept
AudioRuntimeOverloadReport	evaluate_audio_runtime_overload (const AudioProcessLoadSnapshot &load, std::uint64_t xrun_count, const AudioRuntimeOverloadPolicy &policy={}) noexcept
LoopValidationResult	validate_loop_region (const LoopRegion &region, std::uint64_t source_frames, std::uint64_t min_loop_frames=1) noexcept
std::optional< AudioFileData >	offline_render (const AudioFileData &input, OfflineRenderCallback render_fn, const OfflineRenderOptions &options={})
	Render an entire in-memory audio file with deterministic block metadata.
std::optional< OfflineRenderStemResult >	offline_render_stems (const AudioFileData &input, OfflineRenderCallback render_fn, const OfflineRenderOptions &options, const std::vector< OfflineRenderStem > &stems)
	Render an in-memory file and extract named channel-range stems from the mix.
std::optional< OfflineRenderComparison >	compare_offline_render_audio (const AudioFileData &actual, const AudioFileData &expected)
	Compare two rendered artifacts for golden/null tests.
std::optional< std::string >	offline_render_audio_sha256 (const AudioFileData &audio)
	Compute a canonical SHA-256 digest for rendered floating-point audio.
std::optional< OfflineRenderArtifactManifest >	create_offline_render_manifest (const AudioFileData &rendered_audio, const OfflineRenderOptions &options={})
	Build a deterministic manifest for a rendered offline audio artifact.
OfflineRenderComputeDecision	evaluate_offline_render_compute_policy (const OfflineRenderComputePolicy &policy)
	Decide whether a GPU-assisted offline analysis request is allowed.
std::optional< AudioFileData >	offline_process (const AudioFileData &input, OfflineProcessCallback process_fn, int block_size=512)
	Process an entire audio file through a callback function.
bool	offline_process_file (const std::string &input_path, const std::string &output_path, OfflineProcessCallback process_fn, int block_size=512)
	Process a file on disk, writing the result to another file.
AudioFileData	apply_gain (const AudioFileData &input, float gain_linear)
	Simple gain processing for testing.
const std::array< unsigned, 13 > &	standard_sample_rates ()
	Rates worth offering when a driver reports a continuous range.
std::vector< double >	sample_rates_from (const PcmCapabilities &caps)
	Sample rates the device supports, ascending.
std::vector< int >	buffer_sizes_from (const PcmCapabilities &caps, unsigned periods_per_buffer=2)
	Callback buffer sizes (frames), ascending: the powers of two inside the driver's period range such that periods_per_buffer periods still fit in the largest buffer.
PcmDeviceSummary	summarize_pcm_capabilities (const std::optional< PcmCapabilities > &playback, const std::optional< PcmCapabilities > &capture)
	Summarise the probed directions.
RealtimeTimeStretchPrepareStatus	checked_realtime_time_stretch_prepared_geometry (const RealtimeTimeStretchConfig &config, std::uint64_t requested_max_bytes, RealtimeTimeStretchPreparedGeometry &prepared)
std::optional< std::filesystem::path >	confine_restored_path (const std::filesystem::path &path, const std::filesystem::path &root)
	Resolve a path restored from state against the directory the plugin is allowed to read from.
constexpr std::string_view	rt_safety_class_name (RtSafetyClass safety_class) noexcept
constexpr bool	rt_safety_class_may_be_called_from_realtime_thread (RtSafetyClass safety_class) noexcept
constexpr bool	rt_safety_class_is_audio_dsp_safe (RtSafetyClass safety_class) noexcept
constexpr std::span< const RtSafetyContract >	sampler_looper_rt_safety_contracts () noexcept
constexpr const RtSafetyContract *	find_sampler_looper_rt_safety_contract (std::string_view component, std::string_view operation) noexcept
constexpr std::span< const RtSafetyContract >	core_runtime_rt_safety_contracts () noexcept
constexpr const RtSafetyContract *	find_core_runtime_rt_safety_contract (std::string_view component, std::string_view operation) noexcept
const char *	sample_asset_status_name (SampleAssetStatus status) noexcept
std::string	sample_asset_normalize_extension (std::string_view extension)
SampleAssetKind	classify_sample_asset_extension (std::string_view extension)
std::uint64_t	sample_asset_decoded_bytes (std::uint32_t channels, std::uint64_t frames) noexcept
std::vector< SampleAssetDropItem >	classify_sample_asset_drop (const std::vector< std::string > &paths, const SampleAssetPolicy &policy={})
std::vector< SampleAssetDropItem >	probe_sample_asset_drop (const std::vector< std::string > &paths, const SampleAssetPolicy &policy={})
const char *	sample_bank_status_name (SampleBankStatus status) noexcept
SampleBankParseResult	parse_sample_bank_json (std::string_view json)
SampleBankStatus	validate_sample_bank_manifest (const SampleBankManifest &manifest, std::string &field_path)
SampleBankWriteResult	write_sample_bank_json (const SampleBankManifest &manifest)
SampleBankContentValidationResult	validate_sample_bank_content (const std::filesystem::path &content_root, std::span< const std::string > exported_bank_paths, std::uint64_t max_encoded_bytes_per_sample=1ull<< 30)
	Validate exported bank manifests and every referenced sample under one content root.
constexpr std::size_t	bytes_per_sample (SampleFormat format) noexcept
	Bytes per sample for format. Returns 0 for unknown values.
constexpr bool	is_float (SampleFormat format) noexcept
	True if format is a floating-point format.
SampleHeritageJsonParseResult	parse_sample_heritage_profile_json (std::string_view json)
	Parses the complete schema-v3 contract. This is an allocating, off-audio-thread API.
SampleHeritageJsonWriteResult	write_sample_heritage_profile_json (const SampleHeritageProfile &profile)
	Validates and writes one deterministic, whitespace-free schema-v3 representation.
SampleHeritageRuntimeStateJsonParseResult	parse_sample_heritage_runtime_state_json (std::string_view json)
	Strict canonical persistence for quiescent runtime continuation snapshots.
SampleHeritageRuntimeStateJsonWriteResult	write_sample_heritage_runtime_state_json (const SampleHeritageRuntimeState &state)
SampleHeritageTypedRuntimeStateJsonParseResult	parse_sample_heritage_typed_runtime_state_json (std::string_view json)
	Strict schema-v2 persistence for the fixed typed sampler engine bank.
SampleHeritageTypedRuntimeStateJsonWriteResult	write_sample_heritage_typed_runtime_state_json (const SampleHeritageTypedRuntimeState &state)
SampleHeritageAutoCycleResult	estimate_sample_heritage_auto_cycle (BufferView< const float > source, const SampleHeritageAutoCycleOptions &options={})
	Suggests a repeatable cycle length from periodic similarity in an audio region.
SampleHeritageRecordCommitResult	commit_sample_heritage_recording (const SampleHeritageProfile &profile, BufferView< const float > source, double source_sample_rate, const SampleHeritageRecordProvenance &provenance)
	Applies the profile's record_commit recipe and returns machine-rate PCM plus a canonical, content-addressed metadata envelope.
SampleHeritageRecordCommitResult	reload_sample_heritage_committed_asset (const SampleHeritageProfile &profile, BufferView< const float > committed_audio, double committed_sample_rate, std::string_view canonical_metadata_json)
	Verifies canonical metadata, profile identity, dimensions, and committed PCM hash before publishing an owned asset.
constexpr std::uint32_t	sample_heritage_adaptive_effective_search_radius (const SampleHeritageRecordCommitAdaptiveStretchBlock &block) noexcept
constexpr std::uint32_t	sample_heritage_adaptive_effective_crossfade_samples (const SampleHeritageRecordCommitAdaptiveStretchBlock &block) noexcept
std::array< std::uint8_t, 32 >	sample_heritage_profile_digest (const SampleHeritageProfile &profile)
	SHA-256 over a versioned, domain-separated, little-endian canonical byte encoding of the authoring profile.
SampleHeritageProfileValidation	validate_sample_heritage_profile (const SampleHeritageProfile &source) noexcept
constexpr const SampleInterpolationPolicyInfo *	sample_interpolation_policy_info (SampleInterpolationPolicy policy) noexcept
constexpr const SampleInterpolationPolicyInfo *	sample_interpolation_policy_info (std::string_view id) noexcept
constexpr std::string_view	sample_interpolation_policy_id (SampleInterpolationPolicy policy) noexcept
constexpr std::string_view	sample_interpolation_policy_name (SampleInterpolationPolicy policy) noexcept
constexpr bool	valid_sample_interpolation (SampleInterpolationPolicy policy) noexcept
constexpr SampleInterpolationFootprint	sample_interpolation_footprint (SampleInterpolationPolicy policy, float fraction, const SampleSincKernelSelection &sinc={}) noexcept
float	evaluate_sample_interpolation (SampleInterpolationPolicy policy, float fraction, std::span< const float > taps, const SampleSincKernelSelection &sinc={}) noexcept
bool	same_sample_interpolation (const PreparedSampleInterpolation &left, const PreparedSampleInterpolation &right) noexcept
ResolvedSampleInterpolationPosition	resolve_sample_interpolation_position (double normalized_position, const PreparedSampleInterpolation &interpolation) noexcept
constexpr bool	valid_loop_interpolation (LoopInterpolationMode mode) noexcept
constexpr SampleInterpolationPolicy	sample_interpolation_policy (LoopInterpolationMode mode) noexcept
std::optional< std::uint64_t >	checked_sample_storage_bytes (std::uint32_t channels, std::uint64_t frames_per_buffer, std::uint32_t buffer_count=1, std::uint32_t bytes_per_sample=sizeof(float)) noexcept
	Checked planar sample-storage formula shared by preload and page admission.
std::vector< double >	design_sample_mip_decimator ()
void	decimate_sample_mip_2x (const float *input, std::uint64_t input_frames, float *output, std::uint64_t output_frames, const std::vector< double > &coefficients) noexcept
bool	sample_mip_sidecar_exists (std::string_view source_path) noexcept
std::string	sample_mip_payload_path (std::string_view source_path, const std::array< std::uint8_t, 32 > &source_sha256, const std::array< std::uint8_t, 32 > &payload_sha256, std::uint32_t octave)
SampleMipSidecar	load_sample_mip_sidecar (std::string_view source_path, const FileFrameReader &source, const std::shared_ptr< MemoryMappedAudioReader > &retained_source)
SampleMipBuildResult	build_sample_mip_sidecar (std::string_view source_path, const SampleMipBuildOptions &options={})
SamplePreloadContractResult	evaluate_sample_preload_contract (const SamplePreloadContract &contract) noexcept
	Calculate the resident head required to cover a certified streaming service interval at the fastest supported source-consumption ratio.
bool	materialize_completed_recording_to_slot (RealtimeSampleRecorder &recorder, SampleSlotBank &bank, std::uint32_t slot_index, std::span< const float * > channel_scratch) noexcept
bool	publish_completed_recording_to_slot (RealtimeSampleRecorder &recorder, SampleSlotBank &bank, std::span< const float * > channel_scratch, std::uint64_t audio_safe_generation=0) noexcept
SampleStreamConsumptionEvaluation	evaluate_sample_stream_consumption (const SampleStreamConsumptionFactors &factors, double maximum_ratio) noexcept
SampleStreamDecodeCompletionMatch	match_sample_stream_decode_completion (const SampleStreamDecodeCompletion &completion, SampleStreamSourceToken expected_source, std::uint64_t expected_reservation_serial) noexcept
std::size_t	sample_slot_state_index (SampleSlotState state) noexcept
SamplerLooperMetricsSnapshot	collect_sampler_looper_metrics (const AudioStreamHandoff *handoff=nullptr, const RollingAudioCaptureBuffer *capture=nullptr, const RealtimeSampleRecorder *recorder=nullptr, const SampleSlotBank *slots=nullptr, const LoopRenderResult *loop=nullptr, const OnsetDetectionResult *onsets=nullptr, const SliceMap *slices=nullptr) noexcept
bool	validate_slice_map (const SliceMap &map) noexcept
FileFrameReader	make_retained_memory_mapped_frame_reader (std::shared_ptr< MemoryMappedAudioReader > mapped, bool require_ranged_read=false, bool compute_content_identity=false, std::uint64_t maximum_mapped_bytes=std::numeric_limits< std::uint64_t >::max())
	Bind an existing immutable mapped snapshot.
FileFrameReader	make_memory_mapped_frame_reader (std::string_view path, bool require_ranged_read=false, bool compute_content_identity=false, std::uint64_t maximum_mapped_bytes=std::numeric_limits< std::uint64_t >::max(), std::shared_ptr< MemoryMappedAudioReader > *retained_reader=nullptr)
	Open and retain a mapped reader for path.
std::optional< float >	get_system_volume ()
	Get the current system output volume (0.0 to 1.0).
bool	set_system_volume (float volume)
	Set the system output volume (0.0 to 1.0).
std::optional< bool >	is_system_muted ()
	Get the system mute state.
bool	set_system_muted (bool muted)
	Set the system mute state.
template<typename Owner>
	VoiceRuntimeFacade (Owner &) -> VoiceRuntimeFacade< Owner >
std::optional< AudioFileInfo >	inspect_wav (std::span< const std::uint8_t > bytes)
	Inspect a complete in-memory RIFF/WAVE file without decoding its samples.
std::optional< AudioFileData >	decode_wav (std::span< const std::uint8_t > bytes, WavDecodeLimits limits={})
	Decode a complete in-memory RIFF/WAVE file into deinterleaved float channels.
std::optional< WavMetadata >	read_wav_metadata (const std::string &path)
bool	write_wav_metadata (const std::string &path, const WavMetadata &metadata, uint32_t sample_rate=48000, uint16_t num_channels=1, uint16_t bits_per_sample=16)
bool	replace_metadata_in_file (const std::string &path, const WavMetadata &metadata)
std::vector< uint8_t >	encode_bext_chunk (const BwavMetadata &bwav)
std::vector< uint8_t >	encode_acid_chunk (const AcidMetadata &acid)
std::optional< BwavMetadata >	decode_bext_chunk (const uint8_t *data, size_t size)
std::optional< AcidMetadata >	decode_acid_chunk (const uint8_t *data, size_t size)
std::vector< uint8_t >	serialize_overview (const WaveformOverview &t)
std::optional< WaveformOverview >	deserialize_overview (const uint8_t *data, std::size_t size)
WavetableCompileResult	compile_wavetable (BufferView< const float > source, double source_sample_rate, const WavetableAuthoringRecipe &recipe={}, const WavetableAuthoringProvenance &provenance={})
	Compile one mono source buffer into an owned band stack for WavetableT.
WindowEnumerationResult	enumerate_excerpt_windows (const std::string &source_path, const AudioFileData &audio, const ExcerptQuery &query)
std::size_t	select_layers (const SampleZoneMap &map, const ZoneSelectionRequest &request, ZoneSelection *out, std::size_t max_out) noexcept
	Resolve a trigger to every zone that should sound.

Variables
constexpr double	kAudioScopeFrequencyPeriodTolerance = 0.08
	Zero-crossing frequency estimation is intentionally conservative.
constexpr const char *	kAudioScopeJsonSchema = "pulp.audio.scope.v1"
constexpr int	kAudioScopeJsonVersion = 1
constexpr double	kMinIrSampleRate = 4000.0
constexpr double	kMaxIrSampleRate = 400000.0
constexpr std::uint32_t	kDefaultVoiceTerminationFadeFrames = 64
constexpr int	kRealtimeTimeStretchMaximumChannels = 64
constexpr std::array	kSamplerLooperRtSafetyContracts
constexpr std::array	kCoreRuntimeRtSafetyContracts
constexpr std::string_view	kSampleBankSchema = "pulp.sample-bank.v1"
constexpr std::size_t	kSampleBankMaxJsonBytes = 16u << 20
constexpr std::uint32_t	kSampleBankMaxSamples = 4096
constexpr std::uint32_t	kSampleBankMaxZones = 65536
constexpr double	kSampleHeritageCyclicStretchMinimumFactor = 0.25
constexpr double	kSampleHeritageCyclicStretchMaximumFactor = 20.0
constexpr std::uint32_t	kSampleHeritageCommittedAssetSchemaVersion = 1
constexpr std::uint32_t	kSampleHeritageRuntimeStateSchemaVersion = 1
constexpr std::uint32_t	kSampleHeritageTypedRuntimeStateSchemaVersion = 2
constexpr std::size_t	kSampleHeritageRuntimeVoiceSlots = 8
constexpr std::uint32_t	kSampleHeritageProfileSchemaVersion = 3
constexpr std::uint32_t	kSampleHeritageProfileDigestVersion = 5
constexpr std::uint32_t	kSampleHeritageSpectralTiltLawVersion = 1
constexpr double	kSampleHeritageMaximumLadderCutoffRatio = 0.49
constexpr float	kSampleHeritageMaximumLadderResonance = 0.3f
constexpr std::size_t	kSampleHeritageMaximumStages = 7
constexpr std::size_t	kSampleHeritageMaximumVoiceBlocks = 8
constexpr std::size_t	kSampleHeritageMaximumBusBlocks = 2
constexpr std::size_t	kSampleHeritageMaximumRecordCommitBlocks = 4
constexpr std::size_t	kSampleHeritageMaximumChannels = 8
constexpr std::size_t	kSampleHeritageMaximumProfileIdBytes = 63
constexpr std::uint32_t	kInvalidSampleId
constexpr std::uint32_t	kMaximumSampleInterpolationTaps = 128
constexpr std::array< SampleInterpolationPolicyInfo, 6 >	kSampleInterpolationPolicies
constexpr std::uint32_t	kInvalidSamplePoolId
constexpr std::uint64_t	kConverterAllocationOverhead = 4u * sizeof(void*)
constexpr std::uint64_t	kConverterSharedOwnershipBytes = 8u * sizeof(void*)
constexpr std::size_t	kMaximumSampleSincCutoffTables = 32
constexpr std::size_t	kMaximumSampleSincOctaveTables = 8
constexpr double	kMaximumDenseSampleSincConsumption = 128.0
constexpr std::uint32_t	kDefaultSampleSincHalfWidth = 16
constexpr std::uint32_t	kHighQualitySampleSincHalfWidth = 24
constexpr SampleStarvationEnvelopeConfig	kDefaultSampleStarvationEnvelopeConfig
constexpr std::size_t	kSampleStreamLoopMaxPageDemands = 16
constexpr std::size_t	kSampleStreamVoiceMaxPageDemands = 16
constexpr std::uint32_t	kNoSampleSliceIndex
constexpr std::uint32_t	kUnmappedTransientCandidateMarkerIndex
constexpr std::uint32_t	kWavetableAuthoringRecipeSchemaVersion = 1
constexpr std::uint64_t	kWavetableAuthoringMaximumSourceFrames = 1u << 20
constexpr std::uint64_t	kWavetableAuthoringMaximumAnalysisFrames = 1u << 16
constexpr std::uint64_t	kWavetableAuthoringMaximumCycleSearchWork = 1u << 25

Typedef Documentation

AudioCallback

using pulp::audio::AudioCallback

Initial value:

 std::function<void(
    const BufferView<const float>& input,
    BufferView<float>& output,
    const CallbackContext& context
)>

FiniteTimeStretchRatioAtInputFrame

using pulp::audio::FiniteTimeStretchRatioAtInputFrame

Initial value:

 float (*)(void* context, std::uint64_t input_frame,
                                                     std::uint64_t input_frame_count) noexcept

FrameReader

using pulp::audio::FrameReader

Initial value:

 
    std::function<std::uint64_t(std::uint64_t start_frame,
                                BufferView<float> dest,
                                std::uint64_t frames)>

Caller-supplied random-access frame reader.

Fills dest with up to frames frames of planar float audio starting at source frame start_frame and returns the number of frames actually produced (a short return signals end-of-source or a read error). Runs ONLY on the background reader thread (or the pump_background() caller) — never on the audio thread — so it may allocate, lock, seek, and decode freely.

Decoupling the source behind a callback keeps this primitive independent of any particular file/decoder: a WAV memory-map, a chunked decoder, a procedurally generated stream, or a pre-rendered (e.g. tempo-stretched) buffer all satisfy the same contract.

OfflineProcessCallback

using pulp::audio::OfflineProcessCallback

Initial value:

 std::function<void(
    const float* input, float* output,
    int channels, int block_size, double sample_rate
)>

Callback for processing a block of audio.

Receives interleaved input, writes interleaved output. Both buffers have channels * block_size elements.

OfflineRenderCallback

using pulp::audio::OfflineRenderCallback

Initial value:

 std::function<void(
    const float* input, float* output,
    int channels, const OfflineRenderBlockContext& context
)>

Callback for deterministic offline render blocks.

OnsetDetectionMethod

using pulp::audio::OnsetDetectionMethod = signal::OnsetDetectionMethod

SampleHeritageBusBlockParameters

using pulp::audio::SampleHeritageBusBlockParameters

Initial value:

 
    std::variant<SampleHeritageBusNoiseIdleBlock,
    SampleHeritageBusOutputDriveBlock>

SampleHeritageRecordCommitBlockParameters

using pulp::audio::SampleHeritageRecordCommitBlockParameters

Initial value:

 
    std::variant<SampleHeritageRecordInputDriveClipBlock,
    SampleHeritageRecordRateBlock,
    SampleHeritageRecordConverterBlock, SampleHeritageRecordCommitCyclicStretchBlock,
                 SampleHeritageRecordCommitAdaptiveStretchBlock>

SampleHeritageStageParameters

using pulp::audio::SampleHeritageStageParameters

Initial value:

 
    std::variant<SampleHeritageMachineDomainStage,
    SampleHeritageQuantizationStage,
    SampleHeritageClockPitchStage,
    SampleHeritageDacHoldStage,
    SampleHeritageReconstructionFilterStage,
    SampleHeritageNoiseStage,
    SampleHeritageOutputStage>

SampleHeritageVoiceBlockParameters

using pulp::audio::SampleHeritageVoiceBlockParameters

Initial value:

 
    std::variant<SampleHeritageVoiceMachineDomainBlock,
    SampleHeritageVoiceClockBlock,
    SampleHeritageVoicePitchBlock,
    SampleHeritageVoiceConverterBlock,
    SampleHeritageVoiceLiveCyclicStretchBlock,
    SampleHeritageVoiceHoldDroopBlock,
    SampleHeritageVoiceReconstructionBlock,
    SampleHeritageVoiceAnalogColorBlock>

SampleResourceDecodeFunction

using pulp::audio::SampleResourceDecodeFunction

Initial value:

 std::function<std::optional<AudioFileData>(
    const std::string& path,
    runtime::BackgroundJobContext& context)>

StoppableFrameReader

using pulp::audio::StoppableFrameReader

Initial value:

 
    std::function<std::uint64_t(std::uint64_t start_frame,
                                BufferView<float> dest,
                                std::uint64_t frames,
                                FrameReaderStopToken stop_token)>

Enumeration Type Documentation

AnalyzerAvailability

enum class pulp::audio::AnalyzerAvailability : std::uint8_t

strong

Enumerator
Available
MissingPackage
LicenseNotAccepted
UnsupportedPlatform
Disabled
Unavailable

AnalyzerBackend

enum class pulp::audio::AnalyzerBackend : std::uint8_t

strong

Enumerator
BuiltIn
Package
ExternalProcess
ImportedMetadata

AnalyzerCapability

enum class pulp::audio::AnalyzerCapability : std::uint8_t

strong

Enumerator
OnsetDetection
BeatDetection
SliceAnalysis
LoopPointAnalysis
KeyDetection
TempoDetection
TransientClassification
TimeStretch
PitchShift
PitchDetection

AnalyzerDescriptorStatus

enum class pulp::audio::AnalyzerDescriptorStatus : std::uint8_t

strong

Enumerator
ok
empty_id
empty_display_name
missing_capability
package_id_required
duplicate_id

AnalyzerExecutionContext

enum class pulp::audio::AnalyzerExecutionContext : std::uint8_t

strong

Enumerator
OfflineOnly
BackgroundThread
RealtimeSafe

AnalyzerLicensePolicy

enum class pulp::audio::AnalyzerLicensePolicy : std::uint8_t

strong

Enumerator
Permissive
NoticeRequired
Copyleft
Commercial
Unknown

AsyncBlockMode

enum class pulp::audio::AsyncBlockMode : std::uint8_t

strong

How a process() call may treat a worker that has not finished the audio the callback is about to play.

Enumerator
Realtime	Live callback: never wait. Unfinished audio plays as silence and is counted as a miss; the reported latency never moves.
Offline	Declared offline render: wait for the worker (bounded by the configured deadline), so the bounce holds the worker's real output.
Auto	Realtime, except while a PullRateDetector sees the host pulling faster than real time without declaring it; then wait as for Offline.

AudioFocusState

enum class pulp::audio::AudioFocusState : std::uint8_t

strong

Audio-focus state reported to listeners.

gained is the default / idle state on platforms without an OS focus model. duck is a non-fatal attenuation request (reduce output ~6 dB) that persists until the next gained. lost is a full output stop; listeners should stop pushing non-silence until the next gained. lost_transient is a short-lived loss (e.g. an incoming call) — listeners may pause-and-resume rather than drop state.

Enumerator
gained
duck
lost
lost_transient

AudioProbeStage

enum class pulp::audio::AudioProbeStage : std::uint32_t

strong

Identifies which audio boundary a snapshot was produced at.

The first wired stage is kStandaloneOutputBoundary (the post-process() output tap in the standalone host). Other stages follow in later slices.

Enumerator
kUnknown
kProcessorOutput
kStandaloneOutputBoundary
kMeterBridge
kDeviceCallback
kGraphNode

AudioRuntimeOverloadSeverity

enum class pulp::audio::AudioRuntimeOverloadSeverity : uint8_t

strong

Enumerator
Nominal
Watch
Overloaded
Critical

AudioScopeTriggerMode

enum class pulp::audio::AudioScopeTriggerMode : std::uint8_t

strong

Enumerator
kNone
kRisingZero

AudioTimestampDomain

enum class pulp::audio::AudioTimestampDomain : std::uint8_t

strong

Clock domain used by the backend's audio timestamps.

Enumerator
unspecified
device_sample_frames
monotonic_host_time

AudioTimingConfidence

enum class pulp::audio::AudioTimingConfidence : std::uint8_t

strong

How strongly callers may rely on the reported values.

Enumerator
unavailable
estimated
reported
calibrated

AudioTimingSource

enum class pulp::audio::AudioTimingSource : std::uint8_t

strong

Authority behind the reported I/O timing.

Enumerator
unspecified
device_clock
os_estimate
user_calibration

BoundaryDiagnosis

enum class pulp::audio::BoundaryDiagnosis

strong

Coarse classification of where audio was lost (or that it was fine).

Enumerator
kNoProbeData	No usable probe snapshot was provided.
kSignalPresent	Audio is flowing at the observed boundary.
kProcessorSilent	Processor-output stage was silent.
kStandaloneBoundarySilent	Processor had signal but the boundary was silent.
kDeviceProblem	Signal present but device shows xruns/not running.

Endianness

enum class pulp::audio::Endianness : uint8_t

strong

Byte order.

Native resolves to the host endianness at the converter's construction time, so changes to the host byte order (e.g. cross-compilation) do not silently break.

Enumerator
Little
Big
Native

EnvelopeStage

enum class pulp::audio::EnvelopeStage : std::uint8_t

strong

Enumerator
Idle
Attack
Hold
Decay
Sustain
Release

FiniteTimeStretchFailure

enum class pulp::audio::FiniteTimeStretchFailure : std::uint8_t

strong

Enumerator
None
AllocationFailed
InvalidRatio
OutputTooShort
OutputTooLong
ProcessorProtocolError

FiniteTimeStretchPrepareStatus

enum class pulp::audio::FiniteTimeStretchPrepareStatus : std::uint8_t

strong

Enumerator
Prepared
InvalidSource
InvalidSlice
InvalidSampleRate
InvalidBlockSize
InvalidTarget
InvalidRatio
CapacityExceeded
SampleRateConverterPrepareFailed
ProcessorPrepareFailed

FiniteTimeStretchStage

enum class pulp::audio::FiniteTimeStretchStage : std::uint8_t

strong

Enumerator
PrepareSampleRateConverter
MaterializeTimelineInput
PrepareStretch
Stretch
ConvertOutput
Complete
Failed

FiniteTimeStretchStepStatus

enum class pulp::audio::FiniteTimeStretchStepStatus : std::uint8_t

strong

Enumerator
Progress
Complete
Failed

FrameReaderStopMode

enum class pulp::audio::FrameReaderStopMode : std::uint8_t

strong

Enumerator
JoinOnly
Cooperative

Layout

enum class pulp::audio::Layout : uint8_t

strong

Memory layout of the byte stream relative to channels.

Enumerator
Interleaved	[ch0_s0, ch1_s0, ch0_s1, ch1_s1, ...]
Planar	[ch0_s0, ch0_s1, ..., ch1_s0, ch1_s1, ...]

LiveDspNodeKind

enum class pulp::audio::LiveDspNodeKind : std::uint8_t

strong

Coarse node classification, interned at prepare() time (never on the RT thread).

Enumerator
Unknown
AudioInput
AudioOutput
Plugin
Gain
MidiInput
MidiOutput
Custom
Utility

LoopCrossfadeCurve

enum class pulp::audio::LoopCrossfadeCurve : std::uint8_t

strong

Enumerator
Linear
EqualPower

LoopEndpointRole

enum class pulp::audio::LoopEndpointRole : std::uint8_t

strong

Enumerator
StartFrame
ExclusiveEndFrame

LoopInterpolationMode

enum class pulp::audio::LoopInterpolationMode : std::uint8_t

strong

Enumerator
None
Linear
Cubic

LoopPlaybackMode

enum class pulp::audio::LoopPlaybackMode : std::uint8_t

strong

Enumerator
OneShot
Forward
Reverse
PingPong
ReverseOnce

LoopSnapPolicy

enum class pulp::audio::LoopSnapPolicy : std::uint8_t

strong

Enumerator
None
NearestZeroCrossing
SlopeMatchedZeroCrossing
ValueDirection

LoopValidationStatus

enum class pulp::audio::LoopValidationStatus : std::uint8_t

strong

Enumerator
Ok
EmptySource
InvalidRange
TooShort
CrossfadeTooLong
InvalidSampleRate

MusicalKeyMode

enum class pulp::audio::MusicalKeyMode : std::uint8_t

strong

Enumerator
Unknown
Major
Minor

OfflineRenderComputeBackend

enum class pulp::audio::OfflineRenderComputeBackend : uint8_t

strong

Enumerator
Cpu
Gpu

OfflineRenderExecutionScope

enum class pulp::audio::OfflineRenderExecutionScope : uint8_t

strong

Enumerator
RealtimeAudioThread
OfflineAnalysis
BackgroundAnalysis

OfflineRenderTailPolicy

enum class pulp::audio::OfflineRenderTailPolicy : uint8_t

strong

Enumerator
Truncate
RenderTail

RealtimeSampleRecorderCommandType

enum class pulp::audio::RealtimeSampleRecorderCommandType : std::uint8_t

strong

Enumerator
Arm
Start
Stop
Cancel
Reset

RealtimeSampleRecorderEventType

enum class pulp::audio::RealtimeSampleRecorderEventType : std::uint8_t

strong

Enumerator
CommandAccepted
CommandRejected
Started
Completed
Cancelled
Failed

RealtimeSampleRecorderState

enum class pulp::audio::RealtimeSampleRecorderState : std::uint8_t

strong

Enumerator
Idle
Armed
Recording
Completing
Completed
Cancelled
Failed

RealtimeSampleRecorderTimingType

enum class pulp::audio::RealtimeSampleRecorderTimingType : std::uint8_t

strong

Enumerator
Immediate
BlockOffset

RealtimeTimeStretchPrepareStatus

enum class pulp::audio::RealtimeTimeStretchPrepareStatus : std::uint8_t

strong

Enumerator
prepared
invalid_sample_rate
invalid_channel_count
invalid_max_block
invalid_max_time_ratio
invalid_spectral_geometry
unrepresentable_capacity

RealtimeTimeStretchQuality

enum class pulp::audio::RealtimeTimeStretchQuality : std::uint8_t

strong

Enumerator
quality
low_latency

RealtimeTimeStretchStreamFeedStatus

enum class pulp::audio::RealtimeTimeStretchStreamFeedStatus : std::uint8_t

strong

Enumerator
accepted
backpressure
input_closed
invalid_request

RealtimeTimeStretchStreamFinalizePlanStatus

enum class pulp::audio::RealtimeTimeStretchStreamFinalizePlanStatus : std::uint8_t

strong

Enumerator
ready
needs_drain
complete
invalid_request

RealtimeTimeStretchStreamFinalizeStatus

enum class pulp::audio::RealtimeTimeStretchStreamFinalizeStatus : std::uint8_t

strong

Enumerator
draining
backpressure
complete
invalid_request

RollingAudioCaptureMaterializeStatus

enum class pulp::audio::RollingAudioCaptureMaterializeStatus : std::uint8_t

strong

Enumerator
Ok
InvalidSnapshot
Overwritten
DestinationTooSmall

RtSafetyClass

enum class pulp::audio::RtSafetyClass : std::uint8_t

strong

Enumerator
AudioCallbackSafe
AudioCallbackSafeAfterPrepare
AudioCallbackSafeWithImmutableInputs
RealtimeTelemetryOnly
ControlThreadOnly
BackgroundThreadOnly
OfflineOnly

SampleAssetKind

enum class pulp::audio::SampleAssetKind : std::uint8_t

strong

Enumerator
unknown
audio
midi

SampleAssetStatus

enum class pulp::audio::SampleAssetStatus : std::uint8_t

strong

Enumerator
ok
empty_path
unsupported_extension
unsupported_asset_kind
metadata_read_failed
read_failed
write_failed
invalid_audio
channel_budget_exceeded
frame_budget_exceeded
byte_budget_exceeded
sample_rate_not_allowed

SampleBankStatus

enum class pulp::audio::SampleBankStatus : std::uint8_t

strong

Enumerator
ok
invalid_json
root_not_object
unknown_field
duplicate_field
missing_field
wrong_type
unsupported_schema
invalid_identifier
invalid_sample_id
invalid_path
invalid_hash
duplicate_sample_id
duplicate_sample_path
invalid_zone
missing_sample_reference
filesystem_error
path_escape
hash_mismatch
import_failed
preparation_failed
resource_limit_exceeded
unsupported_materialization_policy

SampleEditOperationKind

enum class pulp::audio::SampleEditOperationKind : std::uint8_t

strong

Enumerator
none
set_trim
set_fades
set_loop
clear_loop
set_reverse
set_normalize_gain

SampleFormat

enum class pulp::audio::SampleFormat : uint8_t

strong

Packed-PCM sample format the bytes are encoded in.

Enumerator
Int8	8-bit signed (-128..127)
Int16	16-bit signed
Int24	24-bit signed packed (3 bytes)
Int32	32-bit signed
Float32	IEEE-754 single.
Float64	IEEE-754 double.

SampleHeritageAnalogFilterFamily

enum class pulp::audio::SampleHeritageAnalogFilterFamily : std::uint8_t

strong

Enumerator
None
Ladder4Pole

SampleHeritageAutoCycleStatus

enum class pulp::audio::SampleHeritageAutoCycleStatus : std::uint8_t

strong

Enumerator
Ok
InvalidSource
InvalidRange
InsufficientSignal
NoReliableCycle

SampleHeritageBlockDomain

enum class pulp::audio::SampleHeritageBlockDomain : std::uint8_t

strong

Enumerator
Voice
Bus
RecordCommit

SampleHeritageBusDspStatus

enum class pulp::audio::SampleHeritageBusDspStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidProfile
InvalidDimensions

SampleHeritageConverterFamily

enum class pulp::audio::SampleHeritageConverterFamily : std::uint8_t

strong

Enumerator
LinearPcm
MuLaw
ALaw

SampleHeritageCutoffLaw

enum class pulp::audio::SampleHeritageCutoffLaw : std::uint8_t

strong

Enumerator
FixedHz
MachineRateRatio

SampleHeritageHoldMode

enum class pulp::audio::SampleHeritageHoldMode : std::uint8_t

strong

Enumerator
ZeroOrder

SampleHeritageJsonStatus

enum class pulp::audio::SampleHeritageJsonStatus : std::uint8_t

strong

Strict errors for the versioned sample-heritage JSON boundary.

Enumerator
Ok
InvalidJson
RootNotObject
UnknownField
DuplicateField
MissingField
WrongType
InvalidEnum
NumberOutOfRange
ProfileValidationFailed

SampleHeritageLiveCyclicShuffle

enum class pulp::audio::SampleHeritageLiveCyclicShuffle : std::uint8_t

strong

Enumerator
Identity
FisherYates

SampleHeritageLiveCyclicStatus

enum class pulp::audio::SampleHeritageLiveCyclicStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidConfiguration
SizeOverflow
AllocationFailed
InvalidDimensions
InputFrameMismatch
SourceUnavailable

SampleHeritageLivePitchMode

enum class pulp::audio::SampleHeritageLivePitchMode : std::uint8_t

strong

Enumerator
Preserve
RateLinked

SampleHeritageNoiseGate

enum class pulp::audio::SampleHeritageNoiseGate : std::uint8_t

strong

Enumerator
AlwaysOn
VoiceActive

SampleHeritagePitchFamily

enum class pulp::audio::SampleHeritagePitchFamily : std::uint8_t

strong

Enumerator
VariableClock
DropRepeat
EarlyLinear

SampleHeritagePitchStatus

enum class pulp::audio::SampleHeritagePitchStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidConfiguration
SizeOverflow
AllocationFailed
InvalidDimensions
InputFrameMismatch
HistoryUnavailable

SampleHeritagePlanStatus

enum class pulp::audio::SampleHeritagePlanStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
OutputTooLarge
SizeOverflow

SampleHeritagePrepareStatus

enum class pulp::audio::SampleHeritagePrepareStatus : std::uint8_t

strong

Enumerator
Ok
InvalidProfile
InvalidDimensions
UnsupportedRateConversion
SizeOverflow
AllocationFailed
KernelBuildFailed

SampleHeritageProcessStatus

enum class pulp::audio::SampleHeritageProcessStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidPlan
InvalidDimensions
InputFrameMismatch
TailInputNotSilent
InternalContractFailure

SampleHeritageProfileStatus

enum class pulp::audio::SampleHeritageProfileStatus : std::uint8_t

strong

Enumerator
Ok
UnsupportedSchemaVersion
InvalidProfileId
InvalidHostSampleRate
TooManyStages
TooManyBlocks
WrongBlockDomain
MixedLegacyAndTypedBlocks
NonCanonicalProfileRepresentation
DuplicateStage
InvalidStageOrder
InvalidStageParameter
UnsupportedRateConversion
DigestUnavailable

SampleHeritageReconstructionFamily

enum class pulp::audio::SampleHeritageReconstructionFamily : std::uint8_t

strong

Enumerator
OnePole
Butterworth
Chebyshev
Elliptic

SampleHeritageRecordCommitStatus

enum class pulp::audio::SampleHeritageRecordCommitStatus : std::uint8_t

strong

Enumerator
Ok
InvalidProfile
InvalidSource
InvalidProvenance
InvalidRecordChain
SizeOverflow
AllocationFailed
InvalidMetadata
NonCanonicalMetadata
ProfileMismatch
AudioHashMismatch

SampleHeritageRecordFilterFamily

enum class pulp::audio::SampleHeritageRecordFilterFamily : std::uint8_t

strong

Enumerator
OnePole
Butterworth
Chebyshev
Elliptic

SampleHeritageRuntimeRngStageType

enum class pulp::audio::SampleHeritageRuntimeRngStageType : std::uint8_t

strong

Enumerator
Quantization
Noise
LiveCyclic

SampleHeritageRuntimeStateStatus

enum class pulp::audio::SampleHeritageRuntimeStateStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
UnsupportedSchemaVersion
ProfileMismatch
InvalidStageLayout
InvalidRandomState
InvalidSlotLayout
InvalidHostSampleRate

SampleHeritageSeedPolicy

enum class pulp::audio::SampleHeritageSeedPolicy : std::uint8_t

strong

Enumerator
RestartFromProfileSeed
ContinueSerializedState

SampleHeritageSrcStatus

enum class pulp::audio::SampleHeritageSrcStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidConfiguration
SizeOverflow
AllocationFailed
InvalidDimensions
InputFrameMismatch
HistoryUnavailable

SampleInterpolationPolicy

enum class pulp::audio::SampleInterpolationPolicy : std::uint8_t

strong

Enumerator
Hold
Nearest
Linear
CubicHermite
CubicLagrange
RatioTrackingSinc

SampleMemoryCategory

enum class pulp::audio::SampleMemoryCategory : std::uint8_t

strong

Enumerator
Preload
Page

SampleMemoryReserveStatus

enum class pulp::audio::SampleMemoryReserveStatus : std::uint8_t

strong

Enumerator
Acquired
NotPrepared
InvalidByteCount
InvalidCategory
BudgetExceeded

SampleMipSidecarStatus

enum class pulp::audio::SampleMipSidecarStatus : std::uint8_t

strong

Enumerator
Absent
Valid
Invalid

SamplePreloadContractStatus

enum class pulp::audio::SamplePreloadContractStatus : std::uint8_t

strong

Enumerator
Ok
InvalidSourceSampleRate
InvalidHostSampleRate
InvalidPlaybackRatio
InvalidLatency
Overflow

SampleResourceStatus

enum class pulp::audio::SampleResourceStatus : uint8_t

strong

Enumerator
Empty
Loaded
Missing
Oversized

SampleSlotState

enum class pulp::audio::SampleSlotState : std::uint8_t

strong

Enumerator
Free
Reserved
Writing
Completed
Published
Retired

SampleStarvationMode

enum class pulp::audio::SampleStarvationMode : std::uint8_t

strong

Enumerator
Ready
FadingOut
Silent
Recovering

SampleStreamAsyncCompletionStatus

enum class pulp::audio::SampleStreamAsyncCompletionStatus : std::uint8_t

strong

Enumerator
Published
Canceled
StaleSource
StaleRegistration
StaleReservation
CopyFailed
PublishFailed

SampleStreamAsyncDispatchStatus

enum class pulp::audio::SampleStreamAsyncDispatchStatus : std::uint8_t

strong

Enumerator
Queued
Idle
Deferred
PoolRejected
InvalidState

SampleStreamAsyncPollStatus

enum class pulp::audio::SampleStreamAsyncPollStatus : std::uint8_t

strong

Enumerator
None
Published
Discarded
CopyFailed

SampleStreamAsyncPrepareStatus

enum class pulp::audio::SampleStreamAsyncPrepareStatus : std::uint8_t

strong

Enumerator
Ok
InvalidConfiguration
CachePrepareFailed
DecodePrepareFailed
MetadataAllocationFailed

SampleStreamAsyncReserveStatus

enum class pulp::audio::SampleStreamAsyncReserveStatus : std::uint8_t

strong

Enumerator
Reserved
Idle
AlreadyReady
PageRetired
WaitingForAudioGeneration
StaleSource
SourceInFlight
NoPageAvailable
SerialExhausted

SampleStreamCommandPushStatus

enum class pulp::audio::SampleStreamCommandPushStatus : std::uint8_t

strong

Enumerator
Enqueued
Full

SampleStreamCommandType

enum class pulp::audio::SampleStreamCommandType : std::uint8_t

strong

Enumerator
DemandPage
CancelRequester
CancelPendingSourceDemands

SampleStreamConsumptionStatus

enum class pulp::audio::SampleStreamConsumptionStatus : std::uint8_t

strong

Enumerator
Allowed
LegacyRejected
HeritageRejected

SampleStreamDecodeCancelStatus

enum class pulp::audio::SampleStreamDecodeCancelStatus : std::uint8_t

strong

Enumerator
Canceled
AlreadyCanceled
StaleSource
StaleGeneration
Stopped

SampleStreamDecodeCompletionMatch

enum class pulp::audio::SampleStreamDecodeCompletionMatch : std::uint8_t

strong

Enumerator
Accepted
StaleSource
StaleGeneration
StaleReservation
DecodeError
Canceled
Stopped

SampleStreamDecodeCompletionStatus

enum class pulp::audio::SampleStreamDecodeCompletionStatus : std::uint8_t

strong

Enumerator
Decoded
ShortRead
ReaderError
Canceled
Stopped

SampleStreamDecodeSourceAddStatus

enum class pulp::audio::SampleStreamDecodeSourceAddStatus : std::uint8_t

strong

Enumerator
Added
InvalidSource
DuplicateSource
SourceCapacityFull
Stopped

SampleStreamDecodeSubmitStatus

enum class pulp::audio::SampleStreamDecodeSubmitStatus : std::uint8_t

strong

Enumerator
Queued
InvalidJob
StaleSource
StaleGeneration
StaleReservation
SourceInFlight
QueueFull
Stopped

SampleStreamDemandClass

enum class pulp::audio::SampleStreamDemandClass : std::uint8_t

strong

Enumerator
Attack
Sustain
Release

SampleStreamPageState

enum class pulp::audio::SampleStreamPageState : std::uint8_t

strong

Enumerator
Empty
Filling
Ready
Retiring
Retired

SampleStreamScheduleStatus

enum class pulp::audio::SampleStreamScheduleStatus : std::uint8_t

strong

Enumerator
Inserted
Refreshed
Full
Invalid

SampleStreamServiceStatus

enum class pulp::audio::SampleStreamServiceStatus : std::uint8_t

strong

Enumerator
Idle
Published
AlreadyReady
PageRetired
WaitingForAudioGeneration
StaleSource
NoPageAvailable
ReadFailed
PublishFailed

SampleStreamSourceAddStatus

enum class pulp::audio::SampleStreamSourceAddStatus : std::uint8_t

strong

Enumerator
Added
InvalidConfig
DuplicateSource
StaleGeneration
SourceIdentityCapacityExceeded
BudgetExceeded
AllocationFailed

SampleStreamSourceRetireStatus

enum class pulp::audio::SampleStreamSourceRetireStatus : std::uint8_t

strong

Enumerator
Scheduled
InvalidGeneration
StaleSource
AlreadyScheduled

SampleStreamVoiceOutcomeClass

enum class pulp::audio::SampleStreamVoiceOutcomeClass : std::uint8_t

strong

Enumerator
None
ServiceStarvation
InvalidPreloadContract
StaleGeneration
NormalEndOfSource
InvalidRenderContract

SampleStreamVoiceSupply

enum class pulp::audio::SampleStreamVoiceSupply : std::uint8_t

strong

Enumerator
Ready
Starved
EndOfSource
StaleGeneration
InvalidContract

ShareMode

enum class pulp::audio::ShareMode

strong

Enumerator
shared
exclusive

SliceCandidateSelection

enum class pulp::audio::SliceCandidateSelection : std::uint8_t

strong

Enumerator
TimelineOrder
StrongestConfidence

SliceMarkerSource

enum class pulp::audio::SliceMarkerSource : std::uint8_t

strong

Enumerator
Onset
BeatGrid
Silence
Manual
Imported
LoopStart
LoopEnd

SliceSnapPolicy

enum class pulp::audio::SliceSnapPolicy : std::uint8_t

strong

Enumerator
NearZero
SignTransition

Speaker

enum class pulp::audio::Speaker : uint8_t

strong

Speaker position identifiers.

Enumerator
FrontLeft
FrontRight
FrontCenter
LFE
BackLeft
BackRight
SideLeft
SideRight
TopFrontLeft
TopFrontRight
TopBackLeft
TopBackRight
TopCenter
Discrete

StreamingUnderrunPolicy

enum class pulp::audio::StreamingUnderrunPolicy : std::uint8_t

strong

Enumerator
PreservePosition
AdvancePosition

TimePitchPrepareStatus

enum class pulp::audio::TimePitchPrepareStatus : std::uint8_t

strong

Enumerator
ok
unavailable
invalid_config
allocation_failed
setup_failed

TimePitchProcessStatus

enum class pulp::audio::TimePitchProcessStatus : std::uint8_t

strong

Enumerator
ok
unavailable
invalid_config
not_prepared
channel_mismatch
frame_budget_exceeded
processing_failed

TransientClass

enum class pulp::audio::TransientClass : std::uint8_t

strong

Enumerator
Unknown
Kick
Snare
Clap
Hat
Cymbal
Tom
Bass
Vocal
Percussion
Tonal
Noise

VoiceLfoPhasePolicy

enum class pulp::audio::VoiceLfoPhasePolicy : std::uint8_t

strong

LFO phase policy on note-on.

Enumerator
FreeRunning	The LFO runs from reset() and ignores note-on. This is the shipped pulp::signal::Lfo free-running contract.
Retrigger	Note-on restarts phase and the lifecycle for that voice. Random streams are not reseeded, so distinct notes stay distinct.

VoiceModulationRate

enum class pulp::audio::VoiceModulationRate : std::uint8_t

strong

Enumerator
Constant
AudioRate

VoiceModulationStatus

enum class pulp::audio::VoiceModulationStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidFrameCount
InvalidTarget
NonFiniteValue
DuplicateTarget
LaneOverflow

VoiceModulationTarget

enum class pulp::audio::VoiceModulationTarget : std::uint8_t

strong

Enumerator
Gain
PitchCents
Pan
Pressure
Timbre
Aux0
Aux1
Aux2
Aux3
Aux4
Aux5
Aux6
Aux7

VoiceNoteModulationStatus

enum class pulp::audio::VoiceNoteModulationStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidFrameCount
InvalidNote
InvalidController
InvalidBendRange
InvalidRouting
InsufficientLanes
BufferRejected

VoiceRuntimeFacadeStatus

enum class pulp::audio::VoiceRuntimeFacadeStatus : std::uint8_t

strong

Enumerator
Ok
OwnerNotPrepared
InvalidModulationCapacity
InvalidTerminationCapacity
OwnerRejected

VoiceState

enum class pulp::audio::VoiceState : std::uint8_t

strong

Enumerator
Free
Active
Released

VoiceStealPolicy

enum class pulp::audio::VoiceStealPolicy : std::uint8_t

strong

Enumerator
Oldest
PreferSameVoiceGroupOldest

VoiceTerminationReason

enum class pulp::audio::VoiceTerminationReason : std::uint8_t

strong

Enumerator
Choked
Stolen

WavBitDepth

enum class pulp::audio::WavBitDepth

strong

Enumerator
Int16
Int24
Float32

WavetableCompileStatus

enum class pulp::audio::WavetableCompileStatus : std::uint8_t

strong

Enumerator
Ok
InvalidSource
InvalidRecipe
InvalidExplicitCycle
InsufficientSignal
NoReliableCycle
SizeOverflow
AllocationFailed
FftUnavailable
NonFiniteResult

WindowEnumerationStatus

enum class pulp::audio::WindowEnumerationStatus

strong

Enumerator
ok
invalid_query
empty_audio
file_too_short

Function Documentation

acquire_audio_scope_window()

AudioScopeAcquisition pulp::audio::acquire_audio_scope_window	(	BufferView< const float >	source,
		const AudioScopeAcquisitionConfig &	config,
		const AudioProbeSnapshot *	snapshot_metadata = nullptr )

analyzer_availability_name()

const char * pulp::audio::analyzer_availability_name ( AnalyzerAvailability availability )

nodiscardnoexcept

analyzer_backend_name()

const char * pulp::audio::analyzer_backend_name ( AnalyzerBackend backend )

nodiscardnoexcept

analyzer_capability_name()

const char * pulp::audio::analyzer_capability_name ( AnalyzerCapability capability )

nodiscardnoexcept

analyzer_descriptor_has_capability()

bool pulp::audio::analyzer_descriptor_has_capability ( const AnalyzerDescriptor & descriptor, AnalyzerCapability capability )

nodiscardnoexcept

analyzer_descriptor_selectable()

bool pulp::audio::analyzer_descriptor_selectable ( const AnalyzerDescriptor & descriptor, AnalyzerCapability capability, const AnalyzerSelectionPolicy & policy = {} )

nodiscardnoexcept

analyzer_descriptor_status_name()

const char * pulp::audio::analyzer_descriptor_status_name ( AnalyzerDescriptorStatus status )

nodiscardnoexcept

analyzer_execution_context_name()

const char * pulp::audio::analyzer_execution_context_name ( AnalyzerExecutionContext context )

nodiscardnoexcept

analyzer_license_policy_name()

const char * pulp::audio::analyzer_license_policy_name ( AnalyzerLicensePolicy policy )

nodiscardnoexcept

analyzer_provenance_from_descriptor()

AnalyzerProvenance pulp::audio::analyzer_provenance_from_descriptor ( const AnalyzerDescriptor & descriptor, std::string analysis_id = {} )

nodiscard

apply_gain()

AudioFileData pulp::audio::apply_gain	(	const AudioFileData &	input,
		float	gain_linear )

Simple gain processing for testing.

audio_probe_snapshot_to_json()

std::string pulp::audio::audio_probe_snapshot_to_json	(	const AudioProbeSnapshot &	snapshot,
		const AudioStats &	stats,
		bool	pretty = true )

Serialize a probe snapshot (and the release-safe counter subset) to a flat JSON object string.

pretty controls indentation (default on, matching the offline Audio Doctor artifacts). The object always carries: stage, sample_rate, block_size, channel_count, sequence_number, peak_max, rms_max, peak_dbfs, rms_dbfs, clip_count, nan_inf_count, clipped_blocks, nan_blocks, silence_run_blocks, callbacks, underruns, device_xruns, cpu_overloads. peak_dbfs / rms_dbfs are null when the corresponding linear value is 0.

audio_probe_stage_name()

std::string_view pulp::audio::audio_probe_stage_name

(

AudioProbeStage

stage

)

Stable string name for a probe stage, used as the JSON stage field.

audio_scope_result_to_json()

std::string pulp::audio::audio_scope_result_to_json	(	const AudioScopeResult &	result,
		bool	pretty = true )

Serialize a scope result to the stable v1 JSON shape.

Unavailable measurements are serialized as explicit JSON null values.

audio_scope_trigger_mode_name()

std::string_view pulp::audio::audio_scope_trigger_mode_name

(

AudioScopeTriggerMode

mode

)

buffer_sizes_from()

std::vector< int > pulp::audio::buffer_sizes_from ( const PcmCapabilities & caps, unsigned periods_per_buffer = 2 )

inline

Callback buffer sizes (frames), ascending: the powers of two inside the driver's period range such that periods_per_buffer periods still fit in the largest buffer.

A driver with one fixed period reports that period.

build_boundary_report()

BoundaryReport pulp::audio::build_boundary_report

(

const BoundaryReportInputs &

inputs

)

Build the complaint-oriented boundary report from the given inputs.

build_sample_mip_sidecar()

SampleMipBuildResult pulp::audio::build_sample_mip_sidecar	(	std::string_view	source_path,
		const SampleMipBuildOptions &	options = {} )

built_in_analyzer_descriptors()

std::vector< AnalyzerDescriptor > pulp::audio::built_in_analyzer_descriptors ( )

nodiscard

bytes_per_sample()

std::size_t pulp::audio::bytes_per_sample ( SampleFormat format )

constexprnoexcept

Bytes per sample for format. Returns 0 for unknown values.

checked_realtime_time_stretch_prepared_geometry()

RealtimeTimeStretchPrepareStatus pulp::audio::checked_realtime_time_stretch_prepared_geometry ( const RealtimeTimeStretchConfig & config, std::uint64_t requested_max_bytes, RealtimeTimeStretchPreparedGeometry & prepared )

noexcept

checked_sample_storage_bytes()

std::optional< std::uint64_t > pulp::audio::checked_sample_storage_bytes ( std::uint32_t channels, std::uint64_t frames_per_buffer, std::uint32_t buffer_count = 1, std::uint32_t bytes_per_sample = sizeof(float) )

inlinenoexcept

Checked planar sample-storage formula shared by preload and page admission.

Returns nullopt for zero dimensions or when the product cannot fit uint64_t.

classify_analyzer_license_policy()

AnalyzerLicensePolicy pulp::audio::classify_analyzer_license_policy ( std::string_view license_id )

nodiscardnoexcept

classify_sample_asset_drop()

std::vector< SampleAssetDropItem > pulp::audio::classify_sample_asset_drop ( const std::vector< std::string > & paths, const SampleAssetPolicy & policy = {} )

nodiscard

classify_sample_asset_extension()

SampleAssetKind pulp::audio::classify_sample_asset_extension ( std::string_view extension )

nodiscard

collect_sampler_looper_metrics()

SamplerLooperMetricsSnapshot pulp::audio::collect_sampler_looper_metrics ( const AudioStreamHandoff * handoff = nullptr, const RollingAudioCaptureBuffer * capture = nullptr, const RealtimeSampleRecorder * recorder = nullptr, const SampleSlotBank * slots = nullptr, const LoopRenderResult * loop = nullptr, const OnsetDetectionResult * onsets = nullptr, const SliceMap * slices = nullptr )

noexcept

commit_sample_heritage_recording()

SampleHeritageRecordCommitResult pulp::audio::commit_sample_heritage_recording	(	const SampleHeritageProfile &	profile,
		BufferView< const float >	source,
		double	source_sample_rate,
		const SampleHeritageRecordProvenance &	provenance )

Applies the profile's record_commit recipe and returns machine-rate PCM plus a canonical, content-addressed metadata envelope.

Allocates throughout and must never run on the audio thread. This self-contained transaction accepts RestartFromProfileSeed converters; ContinueSerializedState requires prior converter state and is rejected by this API.

compare_offline_render_audio()

std::optional< OfflineRenderComparison > pulp::audio::compare_offline_render_audio	(	const AudioFileData &	actual,
		const AudioFileData &	expected )

Compare two rendered artifacts for golden/null tests.

compile_wavetable()

WavetableCompileResult pulp::audio::compile_wavetable	(	BufferView< const float >	source,
		double	source_sample_rate,
		const WavetableAuthoringRecipe &	recipe = {},
		const WavetableAuthoringProvenance &	provenance = {} )

Compile one mono source buffer into an owned band stack for WavetableT.

Computed hashes always replace, rather than trust, caller bookkeeping.

confine_restored_path()

std::optional< std::filesystem::path > pulp::audio::confine_restored_path ( const std::filesystem::path & path, const std::filesystem::path & root )

inline

Resolve a path restored from state against the directory the plugin is allowed to read from.

Symlinks along the existing prefix are followed, so a link that points out of root is refused like any other escape. A relative path is taken relative to root; an absolute one must already lie inside it. Returns the canonical path to read, or nullopt when it would leave root, when either argument is empty, or when root cannot be resolved.

core_runtime_rt_safety_contracts()

std::span< const RtSafetyContract > pulp::audio::core_runtime_rt_safety_contracts ( )

nodiscardconstexprnoexcept

create_audio_system()

std::unique_ptr< AudioSystem > pulp::audio::create_audio_system

(

)

create_offline_render_manifest()

std::optional< OfflineRenderArtifactManifest > pulp::audio::create_offline_render_manifest	(	const AudioFileData &	rendered_audio,
		const OfflineRenderOptions &	options = {} )

Build a deterministic manifest for a rendered offline audio artifact.

decimate_sample_mip_2x()

void pulp::audio::decimate_sample_mip_2x ( const float * input, std::uint64_t input_frames, float * output, std::uint64_t output_frames, const std::vector< double > & coefficients )

inlinenoexcept

decode_acid_chunk()

std::optional< AcidMetadata > pulp::audio::decode_acid_chunk	(	const uint8_t *	data,
		size_t	size )

decode_bext_chunk()

std::optional< BwavMetadata > pulp::audio::decode_bext_chunk	(	const uint8_t *	data,
		size_t	size )

decode_wav()

std::optional< AudioFileData > pulp::audio::decode_wav ( std::span< const std::uint8_t > bytes, WavDecodeLimits limits = {} )

nodiscard

Decode a complete in-memory RIFF/WAVE file into deinterleaved float channels.

This surface performs no file I/O and compiles with exceptions disabled. It rejects truncated streams and checks frame, channel, and decoded-byte ceilings before allocating output storage.

deserialize_overview()

std::optional< WaveformOverview > pulp::audio::deserialize_overview	(	const uint8_t *	data,
		std::size_t	size )

design_sample_mip_decimator()

std::vector< double > pulp::audio::design_sample_mip_decimator ( )

inline

encode_acid_chunk()

std::vector< uint8_t > pulp::audio::encode_acid_chunk

(

const AcidMetadata &

acid

)

encode_bext_chunk()

std::vector< uint8_t > pulp::audio::encode_bext_chunk

(

const BwavMetadata &

bwav

)

enumerate_excerpt_windows()

WindowEnumerationResult pulp::audio::enumerate_excerpt_windows	(	const std::string &	source_path,
		const AudioFileData &	audio,
		const ExcerptQuery &	query )

estimate_sample_heritage_auto_cycle()

SampleHeritageAutoCycleResult pulp::audio::estimate_sample_heritage_auto_cycle	(	BufferView< const float >	source,
		const SampleHeritageAutoCycleOptions &	options = {} )

Suggests a repeatable cycle length from periodic similarity in an audio region.

The returned cycle is an explicit neutral estimate, not a model of any hardware auto-cycle control. This offline helper is not suitable for the audio thread.

evaluate_audio_runtime_overload()

AudioRuntimeOverloadReport pulp::audio::evaluate_audio_runtime_overload ( const AudioProcessLoadSnapshot & load, std::uint64_t xrun_count, const AudioRuntimeOverloadPolicy & policy = {} )

inlinenoexcept

evaluate_offline_render_compute_policy()

OfflineRenderComputeDecision pulp::audio::evaluate_offline_render_compute_policy

(

const OfflineRenderComputePolicy &

policy

)

Decide whether a GPU-assisted offline analysis request is allowed.

evaluate_sample_interpolation()

float pulp::audio::evaluate_sample_interpolation ( SampleInterpolationPolicy policy, float fraction, std::span< const float > taps, const SampleSincKernelSelection & sinc = {} )

inlinenoexcept

evaluate_sample_preload_contract()

SamplePreloadContractResult pulp::audio::evaluate_sample_preload_contract ( const SamplePreloadContract & contract )

inlinenoexcept

Calculate the resident head required to cover a certified streaming service interval at the fastest supported source-consumption ratio.

The result also reserves one maximum host block plus interpolation and loop-prefetch guards. This is a control/import-thread calculation; it does not measure storage.

evaluate_sample_stream_consumption()

SampleStreamConsumptionEvaluation pulp::audio::evaluate_sample_stream_consumption ( const SampleStreamConsumptionFactors & factors, double maximum_ratio )

inlinenoexcept

find_analyzer_marker_provenance()

const AnalyzerProvenance * pulp::audio::find_analyzer_marker_provenance ( std::span< const AnalyzerMarkerProvenance > provenance, std::uint32_t marker_index )

nodiscardnoexcept

find_core_runtime_rt_safety_contract()

const RtSafetyContract * pulp::audio::find_core_runtime_rt_safety_contract ( std::string_view component, std::string_view operation )

nodiscardconstexprnoexcept

find_sampler_looper_rt_safety_contract()

const RtSafetyContract * pulp::audio::find_sampler_looper_rt_safety_contract ( std::string_view component, std::string_view operation )

nodiscardconstexprnoexcept

float_to_int16()

void pulp::audio::float_to_int16	(	const float *	src,
		int16_t *	dst,
		size_t	count )

float_to_int32()

void pulp::audio::float_to_int32	(	const float *	src,
		int32_t *	dst,
		size_t	count )

get_system_volume()

std::optional< float > pulp::audio::get_system_volume

(

)

Get the current system output volume (0.0 to 1.0).

Returns nullopt if the platform doesn't support it.

infer_package_analyzer_availability()

AnalyzerAvailability pulp::audio::infer_package_analyzer_availability ( bool installed, bool platform_supported, bool license_accepted )

nodiscardnoexcept

inspect_wav()

std::optional< AudioFileInfo > pulp::audio::inspect_wav ( std::span< const std::uint8_t > bytes )

nodiscard

Inspect a complete in-memory RIFF/WAVE file without decoding its samples.

int16_to_float()

void pulp::audio::int16_to_float	(	const int16_t *	src,
		float *	dst,
		size_t	count )

int24_to_float()

void pulp::audio::int24_to_float	(	const uint8_t *	src,
		float *	dst,
		size_t	count )

int32_to_float()

void pulp::audio::int32_to_float	(	const int32_t *	src,
		float *	dst,
		size_t	count )

is_float()

bool pulp::audio::is_float ( SampleFormat format )

constexprnoexcept

True if format is a floating-point format.

is_supported_audio_sample_rate()

bool pulp::audio::is_supported_audio_sample_rate ( double sample_rate_hz )

constexprnoexcept

is_system_muted()

std::optional< bool > pulp::audio::is_system_muted

(

)

Get the system mute state.

live_dsp_telemetry_snapshot_to_json()

std::string pulp::audio::live_dsp_telemetry_snapshot_to_json	(	const LiveDspTelemetrySnapshot &	snapshot,
		bool	pretty = true )

Serialize a live-DSP telemetry snapshot to a flat JSON object string.

pretty controls indentation (default on, matching the offline Audio Doctor and audio-probe artifacts). The object always carries the graph-level fields: available, enabled, sequence_number, node_count, blocks_written, blocks_drained, blocks_dropped, graph_over_budget_blocks, sample_rate, last_frame_count, last_available_ns, last_graph_elapsed_ns, last_graph_load, plus a nodes array. Each node object carries: node_id, kind, name, sample_count, last_elapsed_ns, min_elapsed_ns, max_elapsed_ns, mean_elapsed_ns, p50_elapsed_ns, p95_elapsed_ns, p99_elapsed_ns, jitter_ns, last_budget_fraction, over_budget_attributions. kind is the stable to_string(LiveDspNodeKind) name.

load_sample_mip_sidecar()

SampleMipSidecar pulp::audio::load_sample_mip_sidecar	(	std::string_view	source_path,
		const FileFrameReader &	source,
		const std::shared_ptr< MemoryMappedAudioReader > &	retained_source )

make_latency_snapshot()

std::optional< LatencySnapshot > pulp::audio::make_latency_snapshot ( const AudioIoTiming & timing, std::uint64_t graph_latency_frames, double graph_sample_rate_hz )

constexprnoexcept

Compose I/O timing with a graph total obtained from the graph's public latency accessor.

The three offsets intentionally expose distinct jobs: recorded-input placement, live monitoring, and scheduling output early. Unspecified timestamp authority or unavailable confidence fails closed.

make_memory_mapped_frame_reader()

FileFrameReader pulp::audio::make_memory_mapped_frame_reader ( std::string_view path, bool require_ranged_read = false, bool compute_content_identity = false, std::uint64_t maximum_mapped_bytes = std::numeric_limits<std::uint64_t>::max(), std::shared_ptr< MemoryMappedAudioReader > * retained_reader = nullptr )

inline

Open and retain a mapped reader for path.

With require_ranged_read, unsupported formats are rejected and a later ranged decode failure is reported rather than falling back to a whole-file decode. On failure returns a FileFrameReader with valid == false. Control thread only.

make_package_analyzer_descriptor()

AnalyzerDescriptor pulp::audio::make_package_analyzer_descriptor ( const PackageAnalyzerDescriptorInput & input )

nodiscard

make_retained_memory_mapped_frame_reader()

FileFrameReader pulp::audio::make_retained_memory_mapped_frame_reader ( std::shared_ptr< MemoryMappedAudioReader > mapped, bool require_ranged_read = false, bool compute_content_identity = false, std::uint64_t maximum_mapped_bytes = std::numeric_limits<std::uint64_t>::max() )

inline

Bind an existing immutable mapped snapshot.

This can tighten a capability probe to ranged-only reads without copying the source file a second time.

match_sample_stream_decode_completion()

SampleStreamDecodeCompletionMatch pulp::audio::match_sample_stream_decode_completion ( const SampleStreamDecodeCompletion & completion, SampleStreamSourceToken expected_source, std::uint64_t expected_reservation_serial )

inlinenoexcept

materialize_completed_recording_to_slot()

bool pulp::audio::materialize_completed_recording_to_slot ( RealtimeSampleRecorder & recorder, SampleSlotBank & bank, std::uint32_t slot_index, std::span< const float * > channel_scratch )

noexcept

measure_audio_scope_window()

AudioScopeMeasurements pulp::audio::measure_audio_scope_window

(

const AudioScopeAcquisition &

acquisition

)

next_calibration_generation()

std::optional< std::uint64_t > pulp::audio::next_calibration_generation ( std::uint64_t generation )

constexprnoexcept

offline_process()

std::optional< AudioFileData > pulp::audio::offline_process	(	const AudioFileData &	input,
		OfflineProcessCallback	process_fn,
		int	block_size = 512 )

Process an entire audio file through a callback function.

Returns the processed audio, or nullopt on failure.

offline_process_file()

bool pulp::audio::offline_process_file	(	const std::string &	input_path,
		const std::string &	output_path,
		OfflineProcessCallback	process_fn,
		int	block_size = 512 )

Process a file on disk, writing the result to another file.

Format is determined by the output file extension.

offline_render()

std::optional< AudioFileData > pulp::audio::offline_render	(	const AudioFileData &	input,
		OfflineRenderCallback	render_fn,
		const OfflineRenderOptions &	options = {} )

Render an entire in-memory audio file with deterministic block metadata.

offline_render_audio_sha256()

std::optional< std::string > pulp::audio::offline_render_audio_sha256

(

const AudioFileData &

audio

)

Compute a canonical SHA-256 digest for rendered floating-point audio.

offline_render_stems()

std::optional< OfflineRenderStemResult > pulp::audio::offline_render_stems	(	const AudioFileData &	input,
		OfflineRenderCallback	render_fn,
		const OfflineRenderOptions &	options,
		const std::vector< OfflineRenderStem > &	stems )

Render an in-memory file and extract named channel-range stems from the mix.

parse_audio_scope_trigger_mode()

bool pulp::audio::parse_audio_scope_trigger_mode	(	std::string_view	text,
		AudioScopeTriggerMode &	out )

parse_sample_bank_json()

SampleBankParseResult pulp::audio::parse_sample_bank_json

(

std::string_view

json

)

parse_sample_heritage_profile_json()

SampleHeritageJsonParseResult pulp::audio::parse_sample_heritage_profile_json

(

std::string_view

json

)

Parses the complete schema-v3 contract. This is an allocating, off-audio-thread API.

parse_sample_heritage_runtime_state_json()

SampleHeritageRuntimeStateJsonParseResult pulp::audio::parse_sample_heritage_runtime_state_json

(

std::string_view

json

)

Strict canonical persistence for quiescent runtime continuation snapshots.

parse_sample_heritage_typed_runtime_state_json()

SampleHeritageTypedRuntimeStateJsonParseResult pulp::audio::parse_sample_heritage_typed_runtime_state_json

(

std::string_view

json

)

Strict schema-v2 persistence for the fixed typed sampler engine bank.

Schema dispatch is the migration boundary; unknown newer versions fail closed.

probe_sample_asset_drop()

std::vector< SampleAssetDropItem > pulp::audio::probe_sample_asset_drop ( const std::vector< std::string > & paths, const SampleAssetPolicy & policy = {} )

nodiscard

publish_completed_recording_to_slot()

bool pulp::audio::publish_completed_recording_to_slot ( RealtimeSampleRecorder & recorder, SampleSlotBank & bank, std::span< const float * > channel_scratch, std::uint64_t audio_safe_generation = 0 )

noexcept

query_audio_io_timing()

std::optional< AudioIoTiming > pulp::audio::query_audio_io_timing ( const AudioDevice & device )

noexcept

Current route timing, or no value when the concrete backend has not implemented timing publication.

This is deliberately a non-virtual free function so adding the optional capability does not change AudioDevice's installed C++ vtable. Query only from a control thread, never the real-time callback.

read_audio_file() [1/2]

std::optional< AudioFileData > pulp::audio::read_audio_file

(

const std::string &

path

)

read_audio_file() [2/2]

std::optional< AudioFileData > pulp::audio::read_audio_file	(	const std::string &	path,
		const std::function< bool(const AudioFileInfo &)> &	admit )

read_audio_file_info()

std::optional< AudioFileInfo > pulp::audio::read_audio_file_info

(

const std::string &

path

)

read_impulse_response()

std::optional< std::vector< float > > pulp::audio::read_impulse_response ( const std::string & path, double target_sample_rate, const ImpulseResponseLoadOptions & opts = {} )

inline

Read an IR file → mono → resampled to target_sample_rate → (optionally) unit-energy normalized.

Returns nullopt on any failure (missing/empty file, silent or non-finite content, absurd length). Off-audio-thread only.

read_impulse_response_pcm()

std::optional< std::vector< float > > pulp::audio::read_impulse_response_pcm ( const float * samples, std::size_t frames, std::uint32_t channels, double src_rate, double target_sample_rate, const ImpulseResponseLoadOptions & opts = {} )

inline

Read already-decoded PCM → mono → resampled to target_sample_rate → (optionally) unit-energy normalized.

Same pipeline as read_impulse_response() with the decode step supplied by the caller, so a host without a codec (a wasm build, where the browser decodes with AudioContext.decodeAudioData) reaches the identical IR.

samples is PLANAR: channels consecutive planes of frames samples each (plane c starts at samples + c * frames) — the layout an AudioBuffer's per-channel Float32Arrays concatenate into, and the layout AudioFileData uses. Returns nullopt on any failure (empty buffer, implausible rate, silent or non-finite content, absurd length). Off-audio-thread only.

read_wav_metadata()

std::optional< WavMetadata > pulp::audio::read_wav_metadata

(

const std::string &

path

)

reload_sample_heritage_committed_asset()

SampleHeritageRecordCommitResult pulp::audio::reload_sample_heritage_committed_asset	(	const SampleHeritageProfile &	profile,
		BufferView< const float >	committed_audio,
		double	committed_sample_rate,
		std::string_view	canonical_metadata_json )

Verifies canonical metadata, profile identity, dimensions, and committed PCM hash before publishing an owned asset.

Allocates and is off-thread only.

replace_metadata_in_file()

bool pulp::audio::replace_metadata_in_file	(	const std::string &	path,
		const WavMetadata &	metadata )

resolve_sample_interpolation_position()

ResolvedSampleInterpolationPosition pulp::audio::resolve_sample_interpolation_position ( double normalized_position, const PreparedSampleInterpolation & interpolation )

inlinenoexcept

rt_safety_class_is_audio_dsp_safe()

bool pulp::audio::rt_safety_class_is_audio_dsp_safe ( RtSafetyClass safety_class )

nodiscardconstexprnoexcept

rt_safety_class_may_be_called_from_realtime_thread()

bool pulp::audio::rt_safety_class_may_be_called_from_realtime_thread ( RtSafetyClass safety_class )

nodiscardconstexprnoexcept

rt_safety_class_name()

std::string_view pulp::audio::rt_safety_class_name ( RtSafetyClass safety_class )

nodiscardconstexprnoexcept

same_sample_interpolation()

bool pulp::audio::same_sample_interpolation ( const PreparedSampleInterpolation & left, const PreparedSampleInterpolation & right )

inlinenoexcept

sample_asset_decoded_bytes()

std::uint64_t pulp::audio::sample_asset_decoded_bytes ( std::uint32_t channels, std::uint64_t frames )

nodiscardnoexcept

sample_asset_normalize_extension()

std::string pulp::audio::sample_asset_normalize_extension ( std::string_view extension )

nodiscard

sample_asset_status_name()

const char * pulp::audio::sample_asset_status_name ( SampleAssetStatus status )

nodiscardnoexcept

sample_bank_status_name()

const char * pulp::audio::sample_bank_status_name ( SampleBankStatus status )

noexcept

sample_heritage_adaptive_effective_crossfade_samples()

std::uint32_t pulp::audio::sample_heritage_adaptive_effective_crossfade_samples ( const SampleHeritageRecordCommitAdaptiveStretchBlock & block )

inlineconstexprnoexcept

sample_heritage_adaptive_effective_search_radius()

std::uint32_t pulp::audio::sample_heritage_adaptive_effective_search_radius ( const SampleHeritageRecordCommitAdaptiveStretchBlock & block )

inlineconstexprnoexcept

sample_heritage_profile_digest()

std::array< std::uint8_t, 32 > pulp::audio::sample_heritage_profile_digest

(

const SampleHeritageProfile &

profile

)

SHA-256 over a versioned, domain-separated, little-endian canonical byte encoding of the authoring profile.

This allocates and is strictly an off-audio-thread API.

sample_interpolation_footprint()

SampleInterpolationFootprint pulp::audio::sample_interpolation_footprint ( SampleInterpolationPolicy policy, float fraction, const SampleSincKernelSelection & sinc = {} )

constexprnoexcept

sample_interpolation_policy()

SampleInterpolationPolicy pulp::audio::sample_interpolation_policy ( LoopInterpolationMode mode )

constexprnoexcept

sample_interpolation_policy_id()

std::string_view pulp::audio::sample_interpolation_policy_id ( SampleInterpolationPolicy policy )

constexprnoexcept

sample_interpolation_policy_info() [1/2]

const SampleInterpolationPolicyInfo * pulp::audio::sample_interpolation_policy_info ( SampleInterpolationPolicy policy )

constexprnoexcept

sample_interpolation_policy_info() [2/2]

const SampleInterpolationPolicyInfo * pulp::audio::sample_interpolation_policy_info ( std::string_view id )

constexprnoexcept

sample_interpolation_policy_name()

std::string_view pulp::audio::sample_interpolation_policy_name ( SampleInterpolationPolicy policy )

constexprnoexcept

sample_mip_payload_path()

std::string pulp::audio::sample_mip_payload_path	(	std::string_view	source_path,
		const std::array< std::uint8_t, 32 > &	source_sha256,
		const std::array< std::uint8_t, 32 > &	payload_sha256,
		std::uint32_t	octave )

sample_mip_sidecar_exists()

bool pulp::audio::sample_mip_sidecar_exists ( std::string_view source_path )

noexcept

sample_rates_from()

std::vector< double > pulp::audio::sample_rates_from ( const PcmCapabilities & caps )

inline

Sample rates the device supports, ascending.

Rates the driver confirmed are used as they are; without confirmation the standard rates inside the reported range stand in. A device that supports exactly one rate reports it even when it is not a standard one.

sample_slot_state_index()

std::size_t pulp::audio::sample_slot_state_index ( SampleSlotState state )

noexcept

sampler_looper_rt_safety_contracts()

std::span< const RtSafetyContract > pulp::audio::sampler_looper_rt_safety_contracts ( )

nodiscardconstexprnoexcept

saturating_frame_add()

std::uint64_t pulp::audio::saturating_frame_add ( std::uint64_t lhs, std::uint64_t rhs )

constexprnoexcept

select_layers()

std::size_t pulp::audio::select_layers ( const SampleZoneMap & map, const ZoneSelectionRequest & request, ZoneSelection * out, std::size_t max_out )

noexcept

Resolve a trigger to every zone that should sound.

Writes up to max_out ZoneSelection entries (each with resolved pitch / playback rate) into out and returns the count written. Extra matches beyond max_out are dropped.

serialize_overview()

std::vector< uint8_t > pulp::audio::serialize_overview

(

const WaveformOverview &

t

)

set_system_muted()

bool pulp::audio::set_system_muted

(

bool

muted

)

Set the system mute state.

set_system_volume()

bool pulp::audio::set_system_volume

(

float

volume

)

Set the system output volume (0.0 to 1.0).

Returns true on success.

speaker_name()

std::string pulp::audio::speaker_name

(

Speaker

speaker

)

Get the speaker name as a string (e.g., "Front Left", "LFE").

standard_sample_rates()

const std::array< unsigned, 13 > & pulp::audio::standard_sample_rates ( )

inline

Rates worth offering when a driver reports a continuous range.

summarize_pcm_capabilities()

PcmDeviceSummary pulp::audio::summarize_pcm_capabilities ( const std::optional< PcmCapabilities > & playback, const std::optional< PcmCapabilities > & capture )

inline

Summarise the probed directions.

A device opened for both directions must run one rate and one buffer size on both, so the lists are the intersection of the directions that probed. Channel counts are per direction. When neither direction could be probed (device busy, or no audio hardware) a conservative default list is reported so callers never see an empty one.

time_pitch_prepare_status_name()

const char * pulp::audio::time_pitch_prepare_status_name ( TimePitchPrepareStatus status )

nodiscardnoexcept

time_pitch_process_status_name()

const char * pulp::audio::time_pitch_process_status_name ( TimePitchProcessStatus status )

nodiscardnoexcept

to_string() [1/2]

const char * pulp::audio::to_string ( AudioRuntimeOverloadSeverity severity )

inlinenoexcept

to_string() [2/2]

const char * pulp::audio::to_string ( LiveDspNodeKind kind )

noexcept

valid_loop_interpolation()

bool pulp::audio::valid_loop_interpolation ( LoopInterpolationMode mode )

constexprnoexcept

valid_sample_interpolation()

bool pulp::audio::valid_sample_interpolation ( SampleInterpolationPolicy policy )

constexprnoexcept

validate_analyzer_descriptor()

AnalyzerDescriptorStatus pulp::audio::validate_analyzer_descriptor ( const AnalyzerDescriptor & descriptor )

nodiscardnoexcept

validate_analyzer_marker_provenance()

bool pulp::audio::validate_analyzer_marker_provenance ( std::size_t marker_count, std::span< const AnalyzerMarkerProvenance > provenance )

nodiscardnoexcept

validate_loop_region()

LoopValidationResult pulp::audio::validate_loop_region ( const LoopRegion & region, std::uint64_t source_frames, std::uint64_t min_loop_frames = 1 )

noexcept

validate_sample_bank_content()

SampleBankContentValidationResult pulp::audio::validate_sample_bank_content	(	const std::filesystem::path &	content_root,
		std::span< const std::string >	exported_bank_paths,
		std::uint64_t	max_encoded_bytes_per_sample = 1ull<< 30 )

Validate exported bank manifests and every referenced sample under one content root.

Paths are confined, symlinks are rejected, manifests and sample reads are bounded, and hashes are verified. Control/background thread only.

validate_sample_bank_manifest()

SampleBankStatus pulp::audio::validate_sample_bank_manifest	(	const SampleBankManifest &	manifest,
		std::string &	field_path )

validate_sample_heritage_profile()

SampleHeritageProfileValidation pulp::audio::validate_sample_heritage_profile ( const SampleHeritageProfile & source )

inlinenoexcept

validate_slice_map()

bool pulp::audio::validate_slice_map ( const SliceMap & map )

noexcept

VoiceRuntimeFacade()

template<typename Owner>

pulp::audio::VoiceRuntimeFacade

(

Owner &

)

->VoiceRuntimeFacade< Owner >

write_sample_bank_json()

SampleBankWriteResult pulp::audio::write_sample_bank_json

(

const SampleBankManifest &

manifest

)

write_sample_heritage_profile_json()

SampleHeritageJsonWriteResult pulp::audio::write_sample_heritage_profile_json

(

const SampleHeritageProfile &

profile

)

Validates and writes one deterministic, whitespace-free schema-v3 representation.

This is an allocating, off-audio-thread API.

write_sample_heritage_runtime_state_json()

SampleHeritageRuntimeStateJsonWriteResult pulp::audio::write_sample_heritage_runtime_state_json

(

const SampleHeritageRuntimeState &

state

)

write_sample_heritage_typed_runtime_state_json()

SampleHeritageTypedRuntimeStateJsonWriteResult pulp::audio::write_sample_heritage_typed_runtime_state_json

(

const SampleHeritageTypedRuntimeState &

state

)

write_wav_file() [1/2]

bool pulp::audio::write_wav_file	(	const std::string &	path,
		const AudioFileData &	data )

write_wav_file() [2/2]

bool pulp::audio::write_wav_file	(	const std::string &	path,
		const AudioFileData &	data,
		WavBitDepth	bit_depth )

write_wav_metadata()

bool pulp::audio::write_wav_metadata	(	const std::string &	path,
		const WavMetadata &	metadata,
		uint32_t	sample_rate = 48000,
		uint16_t	num_channels = 1,
		uint16_t	bits_per_sample = 16 )

write_wav_stream()

bool pulp::audio::write_wav_stream	(	std::ostream &	output,
		const AudioFileData &	data,
		WavBitDepth	bit_depth )

zero_fill_short_read()

void pulp::audio::zero_fill_short_read ( float * buf, int frames_read, int total_frames, int channels )

inlinenoexcept

Zero-fill the trailing samples of an interleaved input buffer after a short read.

The caller has populated [0, frames_read) from the input stream; this routine zeros the range [frames_read, total_frames) so the downstream processor sees a deterministic, full-size buffer.

buf: interleaved float frames (total_frames × channels samples). frames_read: number of frames actually populated (>= 0, <= total_frames). total_frames: number of frames requested for the callback. channels: interleaving factor (1 = mono, 2 = stereo, ...).

Safe to call with frames_read == total_frames (no-op) and with frames_read == 0 (zeroes the whole buffer). Does nothing if any argument is non-positive or buf is null.

Variable Documentation

kAudioScopeFrequencyPeriodTolerance

double pulp::audio::kAudioScopeFrequencyPeriodTolerance = 0.08

inlineconstexpr

Zero-crossing frequency estimation is intentionally conservative.

At least two rising-zero intervals must agree within this fractional tolerance before a frequency is reported.

kAudioScopeJsonSchema

const char* pulp::audio::kAudioScopeJsonSchema = "pulp.audio.scope.v1"

inlineconstexpr

kAudioScopeJsonVersion

int pulp::audio::kAudioScopeJsonVersion = 1

inlineconstexpr

kConverterAllocationOverhead

std::uint64_t pulp::audio::kConverterAllocationOverhead = 4u * sizeof(void*)

inlineconstexpr

kConverterSharedOwnershipBytes

std::uint64_t pulp::audio::kConverterSharedOwnershipBytes = 8u * sizeof(void*)

inlineconstexpr

kCoreRuntimeRtSafetyContracts

std::array pulp::audio::kCoreRuntimeRtSafetyContracts

inlineconstexpr

kDefaultSampleSincHalfWidth

std::uint32_t pulp::audio::kDefaultSampleSincHalfWidth = 16

inlineconstexpr

kDefaultSampleStarvationEnvelopeConfig

SampleStarvationEnvelopeConfig pulp::audio::kDefaultSampleStarvationEnvelopeConfig

inlineconstexpr

Initial value:

{
    .fade_out_frames = 64,
    .recovery_frames = 64,
}

kDefaultVoiceTerminationFadeFrames

std::uint32_t pulp::audio::kDefaultVoiceTerminationFadeFrames = 64

inlineconstexpr

kHighQualitySampleSincHalfWidth

std::uint32_t pulp::audio::kHighQualitySampleSincHalfWidth = 24

inlineconstexpr

kInvalidSampleId

std::uint32_t pulp::audio::kInvalidSampleId

inlineconstexpr

Initial value:

=
    std::numeric_limits<std::uint32_t>::max()

kInvalidSamplePoolId

std::uint32_t pulp::audio::kInvalidSamplePoolId

inlineconstexpr

Initial value:

=
    kInvalidSampleId

kMaximumDenseSampleSincConsumption

double pulp::audio::kMaximumDenseSampleSincConsumption = 128.0

inlineconstexpr

kMaximumSampleInterpolationTaps

std::uint32_t pulp::audio::kMaximumSampleInterpolationTaps = 128

inlineconstexpr

kMaximumSampleSincCutoffTables

std::size_t pulp::audio::kMaximumSampleSincCutoffTables = 32

inlineconstexpr

kMaximumSampleSincOctaveTables

std::size_t pulp::audio::kMaximumSampleSincOctaveTables = 8

inlineconstexpr

kMaxIrSampleRate

double pulp::audio::kMaxIrSampleRate = 400000.0

inlineconstexpr

kMinIrSampleRate

double pulp::audio::kMinIrSampleRate = 4000.0

inlineconstexpr

kNoSampleSliceIndex

std::uint32_t pulp::audio::kNoSampleSliceIndex

inlineconstexpr

Initial value:

=
    static_cast<std::uint32_t>(-1)

kRealtimeTimeStretchMaximumChannels

int pulp::audio::kRealtimeTimeStretchMaximumChannels = 64

inlineconstexpr

kSampleBankMaxJsonBytes

std::size_t pulp::audio::kSampleBankMaxJsonBytes = 16u << 20

inlineconstexpr

kSampleBankMaxSamples

std::uint32_t pulp::audio::kSampleBankMaxSamples = 4096

inlineconstexpr

kSampleBankMaxZones

std::uint32_t pulp::audio::kSampleBankMaxZones = 65536

inlineconstexpr

kSampleBankSchema

std::string_view pulp::audio::kSampleBankSchema = "pulp.sample-bank.v1"

inlineconstexpr

kSampleHeritageCommittedAssetSchemaVersion

std::uint32_t pulp::audio::kSampleHeritageCommittedAssetSchemaVersion = 1

inlineconstexpr

kSampleHeritageCyclicStretchMaximumFactor

double pulp::audio::kSampleHeritageCyclicStretchMaximumFactor = 20.0

inlineconstexpr

kSampleHeritageCyclicStretchMinimumFactor

double pulp::audio::kSampleHeritageCyclicStretchMinimumFactor = 0.25

inlineconstexpr

kSampleHeritageMaximumBusBlocks

std::size_t pulp::audio::kSampleHeritageMaximumBusBlocks = 2

inlineconstexpr

kSampleHeritageMaximumChannels

std::size_t pulp::audio::kSampleHeritageMaximumChannels = 8

inlineconstexpr

kSampleHeritageMaximumLadderCutoffRatio

double pulp::audio::kSampleHeritageMaximumLadderCutoffRatio = 0.49

inlineconstexpr

kSampleHeritageMaximumLadderResonance

float pulp::audio::kSampleHeritageMaximumLadderResonance = 0.3f

inlineconstexpr

kSampleHeritageMaximumProfileIdBytes

std::size_t pulp::audio::kSampleHeritageMaximumProfileIdBytes = 63

inlineconstexpr

kSampleHeritageMaximumRecordCommitBlocks

std::size_t pulp::audio::kSampleHeritageMaximumRecordCommitBlocks = 4

inlineconstexpr

kSampleHeritageMaximumStages

std::size_t pulp::audio::kSampleHeritageMaximumStages = 7

inlineconstexpr

kSampleHeritageMaximumVoiceBlocks

std::size_t pulp::audio::kSampleHeritageMaximumVoiceBlocks = 8

inlineconstexpr

kSampleHeritageProfileDigestVersion

std::uint32_t pulp::audio::kSampleHeritageProfileDigestVersion = 5

inlineconstexpr

kSampleHeritageProfileSchemaVersion

std::uint32_t pulp::audio::kSampleHeritageProfileSchemaVersion = 3

inlineconstexpr

kSampleHeritageRuntimeStateSchemaVersion

std::uint32_t pulp::audio::kSampleHeritageRuntimeStateSchemaVersion = 1

inlineconstexpr

kSampleHeritageRuntimeVoiceSlots

std::size_t pulp::audio::kSampleHeritageRuntimeVoiceSlots = 8

inlineconstexpr

kSampleHeritageSpectralTiltLawVersion

std::uint32_t pulp::audio::kSampleHeritageSpectralTiltLawVersion = 1

inlineconstexpr

kSampleHeritageTypedRuntimeStateSchemaVersion

std::uint32_t pulp::audio::kSampleHeritageTypedRuntimeStateSchemaVersion = 2

inlineconstexpr

kSampleInterpolationPolicies

std::array<SampleInterpolationPolicyInfo, 6> pulp::audio::kSampleInterpolationPolicies

inlineconstexpr

Initial value:

{{
        {SampleInterpolationPolicy::Hold, "hold", "Hold"},
        {SampleInterpolationPolicy::Nearest, "nearest", "Nearest"},
        {SampleInterpolationPolicy::Linear, "linear", "Linear"},
        {SampleInterpolationPolicy::CubicHermite,
         "cubic-hermite", "Cubic Hermite"},
        {SampleInterpolationPolicy::CubicLagrange,
         "cubic-lagrange", "Cubic Lagrange"},
        {SampleInterpolationPolicy::RatioTrackingSinc,
         "ratio-tracking-sinc", "Ratio-tracking sinc"},
    }}

kSamplerLooperRtSafetyContracts

std::array pulp::audio::kSamplerLooperRtSafetyContracts

inlineconstexpr

kSampleStreamLoopMaxPageDemands

std::size_t pulp::audio::kSampleStreamLoopMaxPageDemands = 16

inlineconstexpr

kSampleStreamVoiceMaxPageDemands

std::size_t pulp::audio::kSampleStreamVoiceMaxPageDemands = 16

inlineconstexpr

kUnmappedTransientCandidateMarkerIndex

std::uint32_t pulp::audio::kUnmappedTransientCandidateMarkerIndex

inlineconstexpr

Initial value:

=
    std::numeric_limits<std::uint32_t>::max()

kWavetableAuthoringMaximumAnalysisFrames

std::uint64_t pulp::audio::kWavetableAuthoringMaximumAnalysisFrames = 1u << 16

inlineconstexpr

kWavetableAuthoringMaximumCycleSearchWork

std::uint64_t pulp::audio::kWavetableAuthoringMaximumCycleSearchWork = 1u << 25

inlineconstexpr

kWavetableAuthoringMaximumSourceFrames

std::uint64_t pulp::audio::kWavetableAuthoringMaximumSourceFrames = 1u << 20

inlineconstexpr

kWavetableAuthoringRecipeSchemaVersion

std::uint32_t pulp::audio::kWavetableAuthoringRecipeSchemaVersion = 1

inlineconstexpr