pulp::signal Namespace Reference

Namespaces
namespace	detail
	Round-2 effect-wave vocabulary.
namespace	chardelay
namespace	classic_reverb
namespace	drum
namespace	dynamics
namespace	fdn
namespace	fir_design_detail
namespace	junction
namespace	round2
	Migration namespace for the unshipped Round-2 spelling whose template arity conflicts with the established slot matrix.
namespace	nonlin_ambience
	The calibration register: every number this module ships that is not cited to the literature lives here with a default and a range, so a reviewer finds them in one place rather than spread through the code.
namespace	osc
namespace	rt
namespace	special
namespace	spectral_codec_detail
namespace	tape
	Published tables and closed forms, free of any instance so a test can assert the SHIPPED constant rather than a copy of it.
namespace	units

Classes
struct	VoicePartial
	Which abscissa a SpectralEnvelope's break-points are measured along. More...
struct	VoiceTable
	A partial set. Fixed capacity; copying one is a memcpy, never an allocation. More...
class	AdditiveBankT
	A sinusoidal-bank additive synthesizer. More...
class	SpectralEnvelope
	A break-point spectral envelope: gain in dB as a function of frequency, interpolated linearly in the (log2 abscissa, dB) domain — the perceptually correct axes on both sides. More...
class	AdsrT
class	AnalogVcfT
	Measured panel voicings backed by a four-pole nonlinear OTA cascade. More...
struct	StreamingAnalysisConfig
struct	ChromaFrameT
	One complete chroma analysis window. More...
class	ChromaFrontEndT
	Fixed-capacity chroma analysis over caller-owned planar input. More...
struct	OnsetNoveltyFrameT
	One complete novelty window. More...
class	OnsetNoveltyFrontEndT
	Fixed-capacity streaming novelty analysis. More...
class	AudioMatrixMixerT
	Fixed-capacity signed audio routing matrix with sample-continuous gain ramps. More...
class	AutoDuckedSendT
	Stereo send-gain processor for keeping an effect return out of the way of a source or sidechain signal. More...
class	BallisticsFilterT
	Envelope follower with configurable attack and release times. More...
struct	BeatRepeatCapturePlan
struct	BeatRepeatPlanResult
class	BeatRepeatKernelT
class	BiasT
struct	BiquadCoefficientsT
class	BiquadT
class	BlitOscillatorT
	Band-limited impulse train evaluated by discrete summation. More...
struct	BreakpointEnvelopePointT
class	BreakpointEnvelopeT
struct	BridgedTComponents
	Component values of the TR-808 bass drum's bridged-T network, in SI units (ohms, farads). More...
struct	Q43Leakage
	Softplus fit of Q43's collector current against Vcomm (DAFx-14 Eq. More...
class	BridgedTResonator
	The TR-808 bass drum's bridged-T network: one second-order system with three inputs (pulse shaper, feedback buffer, retrigger pulse) and two outputs (Vbt, the sound; Vcomm, the node that drives Q43's leakage). More...
class	CartesianWalkT
	The 2-D (Cartesian) sequencer. More...
class	LogisticMapT
	Logistic map: x <- r * x * (1 - x) (May, "Simple mathematical models with very complicated dynamics", Nature 261, 1976). More...
class	CharacterDelayT
class	CheckedRetainedByteCharge
class	ChorusT
class	ChorusEnsembleT
	One chorus engine, four voicings. Stereo in place. More...
class	ClassicReverbT
struct	CombFilterConfig
struct	CombFilterSampleResult
struct	CombFilterBlockResult
class	CombFilterT
	A fixed-capacity, integer-delay comb-filter family. More...
class	CommutedStringExcitationCursorT
	Per-voice traversal state for an immutable prepared excitation profile. More...
class	CommutedStringExcitationProfileT
	A fixed-capacity body-shaped excitation shared by plucked-string voices. More...
class	CompressorT
class	LimiterT
class	PartitionedConvolverT
	Uniform partitioned convolution engine. More...
class	ConvolverSpectrumArenaT
	A fixed number of equal-length spectra in one contiguous, 64-byte-aligned block, each starting on a 64-byte boundary. More...
struct	ConvolverInputHistoryT
	The convolver's input-side overlap-save history. More...
struct	ConvolverIrStateT
	Pre-computed, audio-thread-ready state for a single impulse response. More...
class	ConvolverIrSwapperT
	Lock-free background-IR shuttle for PartitionedConvolver. More...
class	NonUniformPartitionedConvolverT
	Two-stage non-uniform partitioned convolver. More...
class	CrossFeedbackMultitapDelayT
	A wet-only stereo multitap delay with normalized tap feedback. More...
struct	CyclicStretchRegime
	One of the two documented sonic regimes. More...
class	CyclicStretchT
	The fixed-cycle splice stretcher. More...
class	DcBlocker
	One-pole DC blocker (first-order high-pass). More...
class	DeEsserT
	A bounded mono de-esser primitive. More...
class	DecayEnvelopeT
	A one-shot percussion envelope: linear attack ramp, optional hold, then exponential decay. More...
class	DelayLineT
struct	SnapChunk
	One chunk of a block: samples [begin, end). More...
class	SnapChunks
	The chunks of [0, num_samples), consecutive and at most kSnapChunkSamples long, as a range. More...
class	DiffusionNetworkT
	A bounded cascade of stereo Schroeder allpasses with energy-preserving inter-channel coupling. More...
class	DiodeBridgeGainT
	The diode bridge as a gain element: an exact 1/(1 + x) divider plus the audio-path curvature that divider's diodes actually impose. More...
class	TransformerBracketT
	One input or output transformer: band-limit, mild saturation, DC-blocked. More...
class	DiodeBridgeCompressorT
	Two transformer brackets around one diode bridge, with a feedback sidechain. More...
struct	ClipperSolverConfig
class	DiodeClipperT
	The diode-to-ground clipper: series resistor, shunt diode network, optional shunt capacitor. More...
class	FeedbackClipperT
	The op-amp gain stage with the diode network either at its output or across its feedback resistor. More...
class	ToneStackT
	Pre/post tone shaping around the clipper: a two-pole tilt pair. More...
struct	NoiseShaperStateT
struct	DitheredQuantizationResultT
	Public intermediate returned by the pure quantizer transition. More...
class	DitherQuantizerT
	Stateful deterministic wrapper for per-sample and block processing. More...
class	DryWetMixerT
class	DustT
	Deterministic discrete-time Poisson impulse source. More...
class	DynamicEqBandT
	One internally keyed dynamic-EQ band. More...
class	GainReduction
	Canonical gain-reduction meter value. More...
class	EnvelopeFollowerT
	Discoverable name for Pulp's established peak/RMS envelope follower. More...
class	StereoEnvelopeFollowerT
	Two-channel envelope follower with a detector-domain stereo link. More...
class	EarlyReflectionsT
	A wet-only early-reflection renderer with a caller-authored tap pattern. More...
class	ArT
	Attack-Release, gate-driven. More...
class	AdT
	Attack-Decay one-shot, trigger-driven. More...
class	AhdT
	Attack-Hold-Decay one-shot, trigger-driven. More...
class	DahdsrT
	Delay-Attack-Hold-Decay-Sustain-Release with per-stage curves and velocity. More...
class	ModEnvT
	Delay-Attack-Hold-Decay modulation envelope with a signed depth. More...
class	TransientDetectorT
	Level-independent transient detector: the normalized excess of a fast envelope follower over a slow one. More...
class	ExpanderT
	Stereo upward/downward expander with a continuous bounded gain law. More...
class	ExplicitQResonatorBankT
struct	FastMath
	Math helpers optimized for audio DSP. More...
class	FdnReverbT
class	FeedforwardCompressorT
	Log-domain feedforward compressor with a soft-knee gain computer. More...
class	FetCompressorT
	Feedback-topology FET compressor. More...
class	FftT
class	MultiBackendFft
	Multi-backend FFT. More...
struct	FilterDesign
	Filter coefficient generation utilities. More...
class	FilterMorphT
struct	FiniteStretchConfigT
class	FiniteStretchBuilderT
struct	FirDesignPoint
struct	FirLeastSquaresOptions
struct	FirLeastSquaresResult
struct	FirEquirippleBand
	One contiguous approximation band for an equiripple design. More...
struct	FirEquirippleOptions
struct	FirEquirippleResult
struct	MinimumPhaseFirOptions
struct	MinimumPhaseFirResult
class	FirFilterT
	FIR filter with arbitrary coefficients. More...
class	FixedIrConvolverT
	Zero-latency convolution with one impulse response for the lifetime of a preparation, running whichever engine is cheaper for that IR length and block size. More...
class	FlangerT
	The flanger. More...
class	FmOperatorRoutingT
	Fixed-capacity routing for an operator network. More...
class	FmOperatorEngineT
	Bounded melodic FM/PM operator engine. More...
class	FormantFilterBankT
	A parallel bank of resonant band-pass sections for fixed source-filter colour. More...
struct	Thiran1Coefficients
struct	FractionalDelaySampleResult
class	FractionalDelayHistoryT
	Prepared history shared by any number of stateless Lagrange read heads. More...
struct	FractionalDelayBlockResult
class	FractionalDelayLineT
	A prepared mono fractional-delay line. More...
struct	FreezeHoldSnapshotT
	Value image of a FreezeHold's held state: everything needed to reproduce the held output bit-for-bit on a hold prepared with the same geometry. More...
struct	FreezeHoldReferenceTiming
	Time-based FreezeHold timing that reproduces the frame-count defaults (8 capture frames, 6 crossfade frames, 0.015 rad/frame walk) at the reference geometry they were tuned for: a 512-sample analysis hop at 48 kHz (RealtimePitchTimeProcessor's quality mode, 4096/512). More...
class	FreezeHoldT
class	FreezeLoopSamplerT
class	FrequencyShifterT
	Shifts every frequency in a signal by the same number of Hz. More...
class	HilbertQuadratureNetworkT
	A pair of allpass cascades whose outputs stand a quarter cycle apart across nearly the whole band — the analytic-signal splitter an SSB shifter needs. More...
class	SsbFrequencyShifterT
	The single-sideband frequency shifter. More...
class	FuzzPairT
	The two-transistor direct-coupled feedback pair. More...
class	GainT
class	SimpleMixerT
class	GateLogicT
	Combinational logic on gate signals. More...
struct	GrainView
	A read-only view of one grain, for metering and grain-cloud displays. More...
class	GranularEngineT
struct	GraphicEqBandT
class	GraphicEqT
	A bounded cascade of configurable peaking bands for one audio channel. More...
class	HalfBandAllpassSectionT
	One single-coefficient allpass section run at the sub-rate. More...
struct	HalfBandIirDesign
	Coefficients of one elliptic polyphase half-band filter, ascending. More...
class	HalfBandIirStageT
	Fixed-storage polyphase half-band stage that filters whole blocks: the engine behind HalfBandUpsampler2xT, HalfBandDownsampler2xT, and the oversampler's polyphase lane. More...
class	HalfBandUpsampler2xT
	2x half-band upsampler. More...
class	HalfBandDownsampler2xT
	2x half-band downsampler. More...
struct	DiatonicMapping
	The result of one key+scale interval mapping. More...
class	DiatonicMapT
	Key + scale interval mapper. More...
class	HarmonyEngineT
	The diatonic harmonizer: YinTrackerT + DiatonicMapT + one PitchShifterT per voice. More...
class	HeadphoneCrossfeedT
	Mixes a delayed, low-pass-filtered copy of each channel into the opposite ear. More...
struct	IirDesign
	Chebyshev / Elliptic IIR design utilities. More...
class	MapClipT
	Map a finite control interval to another interval and clip outside it. More...
class	IndexedControlT
	Read an externally indexed control waveform. More...
struct	Interpolator
	Collection of interpolation algorithms for reading between samples. More...
class	KarplusStrongT
	A plucked string: a delay line fed back through a loss filter. More...
class	LadderBankT
	Voices independent LadderFilterT voices advanced together. More...
class	LadderFilterT
class	LatencyAwareControlSmoother
class	LeslieRotaryT
	A rotary speaker cabinet: two rotors, a crossover, a stereo mic pair and a reflective box. More...
class	LfoT
class	EffectLfoT
struct	LfoShapeParams
	The shape parameters the deterministic waves take. More...
class	LfsrT
	Configurable Fibonacci linear-feedback shift register with a weighted register-to-output projection. More...
class	LinkwitzRileyT
class	LinkwitzRileyCrossoverT
	Fixed-capacity Linkwitz-Riley crossover for two or more ordered bands. More...
class	SampleRateReducerT
	Sample-and-hold rate reducer with clock jitter and a reconstruction filter. More...
class	LofiChainT
	The three lo-fi stages in the order the hardware they model applies them: quantise the word, hold it at a lower clock, then push it through an output stage that cannot represent the smallest codes. More...
class	LogRampedValueT
	Exponentially-smoothed value for parameters where linear ramping sounds wrong (pitch, frequency, gain in dB). More...
class	LookupTableT
	Pre-computed function lookup table with linear interpolation. More...
struct	LoudnessCompensationConfig
	Every tunable of the stateful stages. More...
struct	MakeupLimits
struct	LegSpectra
	The long-term spectra of the two legs on one bin grid, K-weighted, on a common scale. More...
struct	BandPowerGain
	One band of a band-wise response: its frequency span and power gain. More...
class	SpectrumCdf
	The normalised cumulative of a power spectrum on a uniform bin grid. More...
class	MinimumPhaseResponse
	The minimum-phase response with a given magnitude on an FFT grid, by the folded real cepstrum: ln|H| -> cepstrum -> fold onto positive quefrency -> exp(FFT). More...
struct	SpectrumBands
	A band-compressed, rate-independent copy of a LongTermSpectrum's estimate, for saving with a session and restoring warm. More...
class	MaterialChangeDetector
	Detects a genuine change of material from the gap between the make-up the fast and the slow estimates give the current shape. More...
class	LongTermSpectrum
class	MakeupTarget
	What the make-up gain is heading for. More...
class	LowpassGateT
	A lowpass gate: an amplitude gate and a lowpass filter driven by one control signal with deliberately asymmetric dynamics. More...
class	LpgT
	Vactrol-modelled low-pass gate. More...
struct	Matrix
	NxN matrix stored in row-major order. More...
struct	Vec3
	Transform a 3D vector by a 4x4 matrix (assumes w=1). More...
class	MirroredHistoryBuffer
	A single-thread circular history whose complete oldest-to-newest window is always physically contiguous. More...
struct	ModMatrixT
class	DenseModMatrixT
	Dense Round-2 matrix facade. More...
class	SlewLimiterT
class	ConstantTimeSlewLimiterT
	Distance-independent portamento used by the Round-2 effect and sequencing lane. More...
class	SampleHoldT
	Latch a value on a clock's rising edge, with optional glide to the new value instead of a step. More...
class	AttenuverterT
	y = x * gain + offset, with gain allowed to go negative. More...
class	RectifierT
	Full- or half-wave rectification. More...
class	ComparatorT
	Threshold comparator with hysteresis — the bridge from the signal domain to the event domain. More...
class	SignalComparatorT
	Signal-valued comparator from the Round-2 patching lane. More...
class	QuantizerT
	Snap a control value to N equally spaced levels across a range. More...
class	CurveT
	Response shaper for a unit control: the stage-curve law, or smoothstep. More...
struct	ModalMode
	One resonant mode of a vibrating object: frequency, decay time, and impulse-response amplitude. More...
struct	ModalShape
	The spatial eigenfunction of one mode along a body's normalized length coordinate x in [0, 1]: phi(x) = sin(pi * half_waves * x + end_phase). More...
class	ModalBankT
	Bank of two-pole modal resonators, stored structure-of-arrays in lane groups so the per-sample state update auto-vectorizes across modes. More...
struct	ModalSpecExcitation
	How the resonator is struck. More...
struct	ModalShapeMap
	A mode shape sampled on a uniform grid across the object's normalized extent [0, 1], mode-major. More...
struct	ModalSpecTolerances
	The PASS criteria a render of this spec must meet. More...
struct	ModalSpec
	A modal instrument, complete. More...
struct	ModalSpecDiagnostics
	What a parse found beyond the spec itself. Always populated; read it. More...
struct	ModulationCurve
	Curve strength is dimensionless and legal in [0, 1]. More...
struct	LoudnessBiquadCoefficients
struct	KWeightingCoefficients
struct	ChannelLevels
	Per-channel level measurements computed on the audio thread. More...
struct	MultiChannelMeterData
	Complete metering snapshot for all channels, published lock-free. More...
struct	MultiChannelBallistics
	Configurable ballistics for multi-channel meter display (UI thread). More...
class	MultiChannelMeterT
	Audio-thread metering processor. More...
class	MultichannelPhaseCoordinatorT
	RT contract: prepare() allocates internal phase/magnitude storage and must run off the audio thread. More...
class	NlmsAdaptiveFilterT
class	NoiseGateT
class	NoiseMorpherT
	RT contract: prepare() and prepare_masked_scratch() allocate storage and must run off the audio thread. More...
class	NoiseSourceT
	A deterministic, colourable noise generator. More...
class	NoiseTiltT
	Continuous spectral-tilt noise source built from NoiseSourceT's canonical seeded white stream and a fixed cascade of canonical BiquadT shelves. More...
class	NonlinAmbienceT
	The nonlin / gated ambience engine. Stereo, processed in place. More...
class	MultistageWavefolderT
	A sequential wavefolder whose stage drive increases through the chain. More...
class	ChebyshevHarmonicShaperT
	A fixed-storage Chebyshev-series transfer function. More...
class	NonlinearRingModulatorT
	An internally carried ring modulator with ideal and diode-ring models. More...
struct	OfflineStretchOptions
	Whole-input render options. More...
class	OfflineStretchT
	Offline stretcher. More...
class	OscillatorT
class	OtaCascadeFilterT
	Voicing-neutral four-pole nonlinear cascade with fixed-storage oversampling. More...
class	ConvolverT
class	OversamplerT
class	PannerT
struct	ParallelDynamicsConfigT
struct	PreparedParallelDynamicsConfigT
class	ParallelDynamicsMixerT
	Blend true-stereo dry input with an already-processed true-stereo wet path. More...
struct	ParametricEqBandT
class	ParametricEqT
	A bounded series cascade of arbitrary parametric bands. More...
class	ParticleCollisionExciterT
	Bounded stochastic collision model for shaken particle instruments. More...
class	ParticlePercussionVoiceT
	Single particle-percussion voice composed from the shared collision model and Pulp's existing resonators. More...
class	PathLatencyAlignerT
	Aligns N already-processed paths to the largest declared intrinsic latency. More...
class	ClickFreePathSwitcherT
	Fixed-capacity, click-free path selector. More...
class	PhaseDistortionOscT
	Phase distortion: a cosine read at a warped phase. More...
struct	PhaseVocoderConfig
class	PhaseVocoderT
class	PhaserT
class	PhaserStagesT
	A cascaded first-order-allpass phaser. More...
class	PitchShifterT
	Time-domain ratio pitch shifter: dual-tap crossfaded modulated delay. More...
class	FeedbackLoopProcessorT
	Interface for a processor placed inside the feedback loop. More...
class	PitchedFeedbackDelayT
struct	Polynomial
	Polynomial evaluation and manipulation utilities. More...
struct	Mat2T
	Simple 2x2 matrix for biquad coefficient manipulation. More...
struct	Mat3T
	Simple 3x3 matrix for state-space filter representations. More...
class	ProbGateT
	Passes each incoming trigger with a stated probability, deterministically. More...
struct	ProcessingSwitchPlan
	How long each phase of a switch lasts, in samples. More...
class	ProcessingSwitchCrossfadeT
	The audio-thread state of one switch. More...
class	ProcessorChainT
	Chain multiple DSP processors in series. More...
class	ProcessorDuplicatorT
	Duplicates a mono processor across N channels. More...
struct	PitchTimeStreamFinalizePlan
struct	RealtimePitchTimeConfig
struct	RealtimePitchTimePreparedGeometry
class	RealtimePitchTimeProcessorT
class	ReedWaveguideLoopT
	Owns and oversamples one complete reed -> bore -> bell feedback loop. More...
struct	ResamplerQuality
	Quality knobs for the Kaiser-window prototype. More...
struct	ResamplerProcessResult
class	ResamplerT
class	ReverbT
class	ReverseBufferT
	A mono streaming reverse-window processor. More...
class	RiseFallGeneratorT
class	Xorshift32
	Xorshift32 (Marsaglia, "Xorshift RNGs", J. More...
class	OuWalkT
	Ornstein-Uhlenbeck walk (Uhlenbeck & Ornstein, Phys. More...
class	DriftT
	Two decorrelated OU walks presented as the two things drift is actually wired to: a pitch ratio and a unit fraction. More...
class	RunglerT
	The Hordijk shift-register / DAC chaos sequencer. More...
class	SaturatorAdaa2
	Second-order antiderivative antialiasing over one shape, in the curve's own argument domain (Bilbao, Esqueda, Parker & Välimäki, IEEE SPL 24(7), 2017). More...
class	SaturatorT
	The memoryless saturation stage. More...
class	QuantizeScaleT
	CV-to-scale quantizer on the 1 V/octave standard. More...
class	ScannerVibratoT
	The motor-scanned tapped delay line. More...
struct	ScopeCaptureConfig
struct	ScopeCaptureFrameT
class	ScopeCaptureT
class	ScopedFlushDenormals
class	AlignedBufferT
	RAII aligned buffer with SIMD-friendly access. More...
class	SincResamplerT
class	SixBandEqT
	A low shelf, four peaking sections, and a high shelf in series. More...
class	SmoothedValue
	Linear smoothing for control-rate parameters. More...
class	SoftBypassT
class	SosCascadeT
	Executes a bounded cascade of normalized second-order sections (SOS). More...
struct	CepstralEnvelopeConfigT
struct	CepstralEnvelopeResultT
class	CepstralEnvelopeAnalyzerT
	Log-magnitude spectrum to liftered log-envelope. More...
struct	AutocorrelationResultT
struct	LevinsonDurbinResultT
struct	LpcAnalysisResultT
class	LpcAnalyzerT
struct	SpeakerDriverArchetype
	One driver's published-form Thiele-Small set plus the two geometry figures the cabinet and breakup stages need. More...
class	SpeakerModelT
	Physics-based speaker + cabinet + microphone emulator. More...
struct	SpectralBandT
struct	SpectralBandLayoutT
struct	SpectralBandResolutionT
	Control-side report of how discrete FFT bin centers represent an authored viewport. More...
struct	SpectralMaskTableT
struct	SpectralCrossSynthesisPrepareConfigT
struct	SpectralCrossSynthesisConfigT
class	SpectralCrossSynthesisT
struct	SpectralDelayBreakpoint
struct	SpectralDelayMatrixRecipe
struct	SpectralDelayMatrixTable
struct	SpectralDelayMatrixConfig
struct	SpectralDelayMatrixGeometry
class	SpectralDelayMatrixT
struct	SpectralEnvelopeShifterConfig
class	SpectralEnvelopeShifterT
struct	SpectralFeatureFrameT
	One complete control-rate spectral-feature window. More...
class	SpectralFeatureFrontEndT
	Fixed-capacity streaming centroid, flatness, rolloff, and flux analysis. More...
struct	SpectralStreamGeometry
	Offline profile 1: symmetric float Hann, unscaled forward FFT, 1/N inverse, local-origin phase, indexed channels, full-overlap startup and squared-window OLA normalization (threshold 1e-9f). More...
struct	SpectralFrameStamp
struct	OwnedSpectralStream
	Arrays have exact element counts, with no hidden vector capacity. More...
struct	EncodedSpectralStream
struct	SpectralCodecMemory
struct	SpectralCodecResult
struct	SpectralFrameEngineConfig
	Configuration for a SpectralFrameEngine. More...
struct	SpectralFrameEngineGeometry
class	SpectralFrameEngineT
	Streaming multichannel STFT/WOLA engine. More...
class	SpectralGateT
class	SpectralFrameBlurT
struct	SpectralMaskProcessorConfigT
class	SpectralPreMaskStageT
	A frame-domain stage that SpectralMaskProcessorT::process() runs on each analysis frame group before the mask. More...
class	SpectralWetSourceStageT
	A time-domain stage that SpectralMaskProcessorT::process() runs on each block before the wet path's analysis. More...
class	SpectralMaskProcessorT
class	SpectralMorphT
struct	SpectrogramColor
	RGBA color for spectrogram pixels. More...
class	ColorMapper
	Maps a normalized value [0,1] to a color using a predefined ramp. More...
class	FrequencyAxis
	Utilities for mapping FFT bins to display coordinates. More...
class	SpectrogramBuffer
	Scrolling spectrogram buffer that accumulates STFT frames as rows. More...
struct	SpectrumTraceConfig
struct	SpectrumTraceFrameT
class	SpectrumTraceT
class	SquareOscBankT
	A bank of band-limited square-wave oscillators at fixed frequencies, summed into one output. More...
class	StageSeqT
	The pulse-count stage sequencer. More...
class	StagedTransition
struct	StftConfig
	Configuration for an STFT processor. More...
struct	StftFrameT
	A single completed STFT frame: magnitude (linear or dB) and phase. More...
class	StftT
	Allocation-stable STFT processor with single-thread ownership. More...
struct	StnConfig
struct	StnMasksT
	Per-frame soft masks. Each spans num_bins and sums to ~1 per bin. More...
class	StnDecomposerT
struct	StretchPreset
	The tunable subset of OfflineStretchOptions that defines a "character preset". More...
class	SubOscillatorT
	A one- or two-octave divider derived from an explicit parent phase. More...
struct	StereoSampleT
class	SupersawT
class	SvfT
class	SvfBankT
	Voices independent SvfT voices advanced together. More...
class	TapeMachineT
	The tape machine insert. More...
class	TapeEqSection
	One first-order EQ section — a (curve, speed) record network, or its exact inverse. More...
class	TapeCompanderT
	The 2:1 / 1:2 linear-dB compander pair. More...
struct	TempoDelayResult
class	TempoDelayTime
	Fixed-state controller for deterministic delay read-time modulation. More...
struct	TempoDelayWrapperProcessResult
class	TempoDelayWrapper
	A wet-only, stereo delay that owns its histories and feedback routes. More...
class	TiltEqT
	A reusable spectral slope built from a fixed cascade of high shelves. More...
class	TptFilterT
	First-order TPT (trapezoidal integration) filter. More...
struct	TransferCurvePointT
struct	PreparedTransferCurveT
class	TransferCurveT
	Audio-thread processor for a fixed-capacity arbitrary transfer curve. More...
class	TransientDesignerT
	Separates attack and sustain by comparing exact-timing peak envelopes. More...
class	TransientPhasePolicyT
class	TransitionMixerT
class	TransportEdgeT
	Converts a run level and a reset level into the (run_high, reset_edge) pair the sequencers consume, and optionally detects the clock edge alongside them. More...
class	HystereticTriggerDetectT
	Hysteretic continuous-CV edge detector. More...
class	TriggerDetectT
	Rising-edge detector with a refractory period. More...
class	GateGenT
	Trigger in, fixed-length gate out. More...
class	ClockDividerT
	Pass every Nth trigger. More...
class	ClockMultT
	Emit N evenly spaced event triggers per measured input period. More...
class	SignalClockMultT
	Continuous-signal clock multiplier. More...
class	BurstGenT
	One trigger in, a burst of N triggers out, with a spacing curve and a level ramp. More...
class	TrigDelayT
	Delay a trigger by a fixed time, through a small fixed-capacity queue. More...
class	TruePeakLimiterT
class	TwoPoleResonatorT
	A single decaying resonance: one complex pole pair, excited by whatever the caller feeds it. More...
struct	UnisonSpec
	Control-side configuration for a fixed unison layout. More...
struct	UnisonVoiceParameters
class	UnisonLayout
class	UnitDelayT
	One sample of explicit signal memory. More...
class	VactrolConditionerT
	The asymmetric one-pole that lags a control signal the way a photoresistor lags its LED. More...
class	VcaT
	Voltage-controlled amplifier. More...
class	VcaCompressorT
	True-RMS, log-domain, single-time-constant feedforward compressor. More...
struct	VelvetNoiseDrawT
class	VelvetNoiseGridT
	Sequential convenience wrapper over the coordinate-keyed pure draw. More...
class	DelayVibratoT
	True pitch vibrato: a fractional delay whose tap position is modulated by a sine, which scales the frequency of everything passing through it equally. More...
class	PhaseVibratoT
	Magnatone-style phase vibrato: N cascaded first-order allpass stages whose corner is driven straight from the LFO, summed back against the direct path. More...
class	UniVibeT
	Univibe-style phase vibrato: four allpass stages at deliberately unequal corners, all swept together by one lamp-and-photocell control chain. More...
class	VocoderT
	A classic channel vocoder: analysis bank → envelopes → matched synthesis bank. More...
class	WaveguideJunctionT
	A bounded N-port pressure-wave scattering junction. More...
class	WaveguideLineT
	A passive bidirectional waveguide segment. More...
class	ReedExciterT
	A normalized pressure-controlled reed valve. More...
class	WaveguideReflectionFilterT
	A passive boundary filter with H(z) = g (1 - a) / (1 - a z^-1). More...
class	WavesetTransformerT
	A bounded, allocation-free-at-runtime waveset transformation engine. More...
class	WaveShaperT
struct	WavetableEntryT
	One single-cycle wavetable plus the maximum playback frequency it remains bandlimited at. More...
class	WavetableT
	Wavetable oscillator with band-switching. More...
class	WavetableBankT
	Linear-interpolated morph across N Wavetables. More...
class	WindowFunction
class	YinTrackerT
	Monophonic fundamental-frequency estimator, after de Cheveigné & Kawahara 2002 [1], steps 1–5. More...
class	ZeroLatencyConvolverT
	See the file doc block for the schedule and its lineage. More...
struct	ZeroLatencyConvolverDesign
	Zero-latency non-uniform partitioned convolution engine. More...

Typedefs
using	AdditiveBank = AdditiveBankT<float>
using	AdditiveBank64 = AdditiveBankT<double>
using	Adsr = AdsrT<float>
using	Adsr64 = AdsrT<double>
using	AnalogVcf = AnalogVcfT<float>
	Single-precision measured analog VCF.
using	AnalogVcf64 = AnalogVcfT<double>
	Double-precision measured analog VCF.
using	ChromaFrontEnd = ChromaFrontEndT<float>
using	ChromaFrontEnd64 = ChromaFrontEndT<double>
using	OnsetNoveltyFrontEnd = OnsetNoveltyFrontEndT<float>
using	OnsetNoveltyFrontEnd64 = OnsetNoveltyFrontEndT<double>
using	AudioMatrixMixer = AudioMatrixMixerT<float>
using	AudioMatrixMixer64 = AudioMatrixMixerT<double>
using	AutoDuckedSend = AutoDuckedSendT<float>
using	AutoDuckedSend64 = AutoDuckedSendT<double>
using	BallisticsFilter = BallisticsFilterT<float>
using	BallisticsFilter64 = BallisticsFilterT<double>
using	BeatRepeatKernel = BeatRepeatKernelT<float>
using	BeatRepeatKernel64 = BeatRepeatKernelT<double>
using	Bias = BiasT<float>
using	Bias64 = BiasT<double>
using	BiquadCoefficients = BiquadCoefficientsT<float>
using	Biquad = BiquadT<float>
using	Biquad64 = BiquadT<double>
using	BlitOscillator = BlitOscillatorT<float>
using	BlitOscillator64 = BlitOscillatorT<double>
using	BreakpointEnvelopePoint = BreakpointEnvelopePointT<float>
using	BreakpointEnvelopePoint64 = BreakpointEnvelopePointT<double>
using	BreakpointEnvelope = BreakpointEnvelopeT<float>
using	BreakpointEnvelope64 = BreakpointEnvelopeT<double>
using	CartesianWalk = CartesianWalkT<float>
using	CartesianWalk64 = CartesianWalkT<double>
using	LogisticMap = LogisticMapT<float>
using	LogisticMap64 = LogisticMapT<double>
using	CharacterDelay = CharacterDelayT<float>
using	Chorus = ChorusT<float>
using	Chorus64 = ChorusT<double>
using	ChorusEnsemble = ChorusEnsembleT<float>
using	ChorusEnsemble64 = ChorusEnsembleT<double>
using	ClassicReverb = ClassicReverbT<float>
using	CombFilter = CombFilterT<float>
using	CombFilter64 = CombFilterT<double>
using	CommutedStringExcitationCursor = CommutedStringExcitationCursorT<float>
using	CommutedStringExcitationCursor64 = CommutedStringExcitationCursorT<double>
using	CommutedStringExcitationProfile = CommutedStringExcitationProfileT<float>
using	CommutedStringExcitationProfile64 = CommutedStringExcitationProfileT<double>
using	Compressor = CompressorT<float>
using	Compressor64 = CompressorT<double>
using	Limiter = LimiterT<float>
using	Limiter64 = LimiterT<double>
using	PartitionedConvolver = PartitionedConvolverT<float>
using	PartitionedConvolver64 = PartitionedConvolverT<double>
using	ConvolverInputHistory = ConvolverInputHistoryT<float>
using	ConvolverInputHistory64 = ConvolverInputHistoryT<double>
using	ConvolverIrState = ConvolverIrStateT<float>
using	ConvolverIrState64 = ConvolverIrStateT<double>
using	ConvolverIrSwapper = ConvolverIrSwapperT<float>
using	ConvolverIrSwapper64 = ConvolverIrSwapperT<double>
using	NonUniformPartitionedConvolver = NonUniformPartitionedConvolverT<float>
using	NonUniformPartitionedConvolver64 = NonUniformPartitionedConvolverT<double>
using	CrossFeedbackMultitapDelay = CrossFeedbackMultitapDelayT<float>
using	CrossFeedbackMultitapDelay64 = CrossFeedbackMultitapDelayT<double>
using	CyclicStretch = CyclicStretchT<float>
using	CyclicStretch64 = CyclicStretchT<double>
using	DeEsser = DeEsserT<float>
using	DeEsser64 = DeEsserT<double>
using	DecayEnvelope = DecayEnvelopeT<float>
using	DecayEnvelope64 = DecayEnvelopeT<double>
using	DelayLine = DelayLineT<float>
using	DelayLine64 = DelayLineT<double>
using	DiffusionNetwork = DiffusionNetworkT<float>
using	DiffusionNetwork64 = DiffusionNetworkT<double>
using	DiodeBridgeGain = DiodeBridgeGainT<float>
using	DiodeBridgeGain64 = DiodeBridgeGainT<double>
using	TransformerBracket = TransformerBracketT<float>
using	TransformerBracket64 = TransformerBracketT<double>
using	DiodeBridgeCompressor = DiodeBridgeCompressorT<float>
using	DiodeBridgeCompressor64 = DiodeBridgeCompressorT<double>
using	DiodeClipper = DiodeClipperT<float>
using	DiodeClipper64 = DiodeClipperT<double>
using	FeedbackClipper = FeedbackClipperT<float>
using	FeedbackClipper64 = FeedbackClipperT<double>
using	ToneStack = ToneStackT<float>
using	ToneStack64 = ToneStackT<double>
using	DitherQuantizer = DitherQuantizerT<float>
using	DitherQuantizer64 = DitherQuantizerT<double>
using	DryWetMixer = DryWetMixerT<float>
using	DryWetMixer64 = DryWetMixerT<double>
using	Dust = DustT<float>
using	Dust64 = DustT<double>
using	DynamicEqBand = DynamicEqBandT<float>
using	DynamicEqBand64 = DynamicEqBandT<double>
using	EnvelopeFollower = EnvelopeFollowerT<float>
using	EnvelopeFollower64 = EnvelopeFollowerT<double>
using	StereoEnvelopeFollower = StereoEnvelopeFollowerT<float>
using	StereoEnvelopeFollower64 = StereoEnvelopeFollowerT<double>
using	EarlyReflections = EarlyReflectionsT<float>
using	EarlyReflections64 = EarlyReflectionsT<double>
using	Ar = ArT<float>
using	Ar64 = ArT<double>
using	Ad = AdT<float>
using	Ad64 = AdT<double>
using	Ahd = AhdT<float>
using	Ahd64 = AhdT<double>
using	Dahdsr = DahdsrT<float>
using	Dahdsr64 = DahdsrT<double>
using	ModEnv = ModEnvT<float>
using	ModEnv64 = ModEnvT<double>
using	TransientDetector = TransientDetectorT<float>
using	TransientDetector64 = TransientDetectorT<double>
using	Expander = ExpanderT<float>
using	Expander64 = ExpanderT<double>
using	ExplicitQResonatorBank = ExplicitQResonatorBankT<float>
using	ExplicitQResonatorBank64 = ExplicitQResonatorBankT<double>
using	FdnReverb = FdnReverbT<float>
using	FeedforwardCompressor = FeedforwardCompressorT<float>
using	FeedforwardCompressor64 = FeedforwardCompressorT<double>
using	FetCompressor = FetCompressorT<float>
using	FetCompressor64 = FetCompressorT<double>
using	Fft = FftT<float>
using	Fft64 = FftT<double>
using	FilterMorph = FilterMorphT<float>
using	FilterMorph64 = FilterMorphT<double>
using	FiniteStretchRatioAtInputFrame
	Called for the analysis frame ending at input_frame.
using	FiniteStretchConfig = FiniteStretchConfigT<float>
using	FiniteStretchConfig64 = FiniteStretchConfigT<double>
using	FiniteStretchBuilder = FiniteStretchBuilderT<float>
using	FiniteStretchBuilder64 = FiniteStretchBuilderT<double>
using	FirFilter = FirFilterT<float>
using	FirFilter64 = FirFilterT<double>
using	FixedIrConvolver = FixedIrConvolverT<float>
using	FixedIrConvolver64 = FixedIrConvolverT<double>
using	Flanger = FlangerT<float>
using	Flanger64 = FlangerT<double>
using	FmOperatorRouting = FmOperatorRoutingT<float>
using	FmOperatorRouting64 = FmOperatorRoutingT<double>
using	FmOperatorEngine = FmOperatorEngineT<float>
using	FmOperatorEngine64 = FmOperatorEngineT<double>
using	FormantFilterBank = FormantFilterBankT<float>
using	FormantFilterBank64 = FormantFilterBankT<double>
using	FractionalDelayLine = FractionalDelayLineT<float>
using	FractionalDelayLine64 = FractionalDelayLineT<double>
using	FractionalDelayHistory = FractionalDelayHistoryT<float>
using	FractionalDelayHistory64 = FractionalDelayHistoryT<double>
using	FreezeHoldSnapshot = FreezeHoldSnapshotT<float>
using	FreezeHoldSnapshot64 = FreezeHoldSnapshotT<double>
using	FreezeHold = FreezeHoldT<float>
using	FreezeHold64 = FreezeHoldT<double>
using	FreezeLoopSampler = FreezeLoopSamplerT<float>
using	FreezeLoopSampler64 = FreezeLoopSamplerT<double>
template<typename SampleType = double>
using	HilbertPairT = HilbertQuadratureNetworkT<SampleType>
	A pair of allpass chains whose outputs stand a quarter cycle apart across the audio band — the analytic-signal splitter, spelled the way this header has always spelled it.
using	HilbertPair = HilbertPairT<double>
using	FrequencyShifter = FrequencyShifterT<float>
using	FrequencyShifter64 = FrequencyShifterT<double>
using	HilbertQuadratureNetwork = HilbertQuadratureNetworkT<double>
using	SsbFrequencyShifter = SsbFrequencyShifterT<float>
using	SsbFrequencyShifter64 = SsbFrequencyShifterT<double>
using	FuzzPair = FuzzPairT<float>
using	FuzzPair64 = FuzzPairT<double>
using	Gain = GainT<float>
using	Gain64 = GainT<double>
using	SimpleMixer = SimpleMixerT<float>
using	SimpleMixer64 = SimpleMixerT<double>
using	GateLogic = GateLogicT<float>
using	GateLogic64 = GateLogicT<double>
using	GranularEngine = GranularEngineT<float>
using	GranularEngine64 = GranularEngineT<double>
using	GraphicEqBand = GraphicEqBandT<float>
using	GraphicEq = GraphicEqT<float>
using	GraphicEq64 = GraphicEqT<double>
using	HalfBandAllpassSection = HalfBandAllpassSectionT<float>
using	HalfBandAllpassSection64 = HalfBandAllpassSectionT<double>
using	HalfBandIirStage = HalfBandIirStageT<float>
using	HalfBandIirStage64 = HalfBandIirStageT<double>
using	HalfBandUpsampler2x = HalfBandUpsampler2xT<float>
using	HalfBandUpsampler2x64 = HalfBandUpsampler2xT<double>
using	HalfBandDownsampler2x = HalfBandDownsampler2xT<float>
using	HalfBandDownsampler2x64 = HalfBandDownsampler2xT<double>
using	DiatonicMap = DiatonicMapT<float>
using	DiatonicMap64 = DiatonicMapT<double>
using	HarmonyEngine = HarmonyEngineT<float>
using	HarmonyEngine64 = HarmonyEngineT<double>
using	HeadphoneCrossfeed = HeadphoneCrossfeedT<float>
using	HeadphoneCrossfeed64 = HeadphoneCrossfeedT<double>
using	MapClip = MapClipT<float>
using	MapClip64 = MapClipT<double>
using	IndexedControl = IndexedControlT<float>
using	IndexedControl64 = IndexedControlT<double>
using	KarplusStrong = KarplusStrongT<float>
using	KarplusStrong64 = KarplusStrongT<double>
template<std::size_t Voices = 16>
using	LadderBank = LadderBankT<float, Voices>
using	LadderFilter = LadderFilterT<float>
using	LadderFilter64 = LadderFilterT<double>
using	LeslieRotary = LeslieRotaryT<float>
using	LeslieRotary64 = LeslieRotaryT<double>
using	Lfo = LfoT<float>
using	Lfo64 = LfoT<double>
using	EffectLfo = EffectLfoT<float>
using	EffectLfo64 = EffectLfoT<double>
using	Lfsr = LfsrT<float>
using	Lfsr64 = LfsrT<double>
using	LinkwitzRiley = LinkwitzRileyT<float>
using	LinkwitzRiley64 = LinkwitzRileyT<double>
using	LinkwitzRileyCrossover = LinkwitzRileyCrossoverT<float>
using	LinkwitzRileyCrossover64 = LinkwitzRileyCrossoverT<double>
using	SampleRateReducer = SampleRateReducerT<float>
using	SampleRateReducer64 = SampleRateReducerT<double>
using	LofiChain = LofiChainT<float>
using	LofiChain64 = LofiChainT<double>
using	LogRampedValue = LogRampedValueT<float>
using	LogRampedValue64 = LogRampedValueT<double>
using	LookupTable = LookupTableT<float>
using	LookupTable64 = LookupTableT<double>
using	LowpassGate = LowpassGateT<float>
using	LowpassGate64 = LowpassGateT<double>
using	Lpg = LpgT<float>
using	Lpg64 = LpgT<double>
using	Matrix2 = Matrix<2>
using	Matrix3 = Matrix<3>
using	Matrix4 = Matrix<4>
using	Matrix2d = Matrix<2, double>
using	Matrix3d = Matrix<3, double>
using	Matrix4d = Matrix<4, double>
using	ModMatrix = ModMatrixT<32, float>
using	ModMatrix64 = ModMatrixT<32, double>
using	SlewLimiter = SlewLimiterT<float>
using	SlewLimiter64 = SlewLimiterT<double>
using	ConstantTimeSlewLimiter = ConstantTimeSlewLimiterT<float>
using	ConstantTimeSlewLimiter64 = ConstantTimeSlewLimiterT<double>
using	SampleHold = SampleHoldT<float>
using	SampleHold64 = SampleHoldT<double>
using	Attenuverter = AttenuverterT<float>
using	Attenuverter64 = AttenuverterT<double>
using	Rectifier = RectifierT<float>
using	Rectifier64 = RectifierT<double>
using	Comparator = ComparatorT<float>
using	Comparator64 = ComparatorT<double>
using	SignalComparator = SignalComparatorT<float>
using	SignalComparator64 = SignalComparatorT<double>
using	Quantizer = QuantizerT<float>
using	Quantizer64 = QuantizerT<double>
using	Curve = CurveT<float>
using	Curve64 = CurveT<double>
using	ModalBank = ModalBankT<float>
using	ModalBank64 = ModalBankT<double>
using	MultiChannelMeter = MultiChannelMeterT<float>
using	MultiChannelMeter64 = MultiChannelMeterT<double>
using	MultichannelPhaseCoordinator = MultichannelPhaseCoordinatorT<float>
using	MultichannelPhaseCoordinator64 = MultichannelPhaseCoordinatorT<double>
using	NlmsAdaptiveFilter = NlmsAdaptiveFilterT<float>
using	NlmsAdaptiveFilter64 = NlmsAdaptiveFilterT<double>
using	NoiseGate = NoiseGateT<float>
using	NoiseGate64 = NoiseGateT<double>
using	NoiseMorpher = NoiseMorpherT<float>
using	NoiseMorpher64 = NoiseMorpherT<double>
using	NoiseSource = NoiseSourceT<float>
using	NoiseSource64 = NoiseSourceT<double>
using	NoiseTilt = NoiseTiltT<float>
using	NoiseTilt64 = NoiseTiltT<double>
using	NonlinAmbience = NonlinAmbienceT<float>
using	NonlinAmbience64 = NonlinAmbienceT<double>
using	MultistageWavefolder = MultistageWavefolderT<float>
using	MultistageWavefolder64 = MultistageWavefolderT<double>
using	ChebyshevHarmonicShaper = ChebyshevHarmonicShaperT<float>
using	ChebyshevHarmonicShaper64 = ChebyshevHarmonicShaperT<double>
using	NonlinearRingModulator = NonlinearRingModulatorT<float>
using	NonlinearRingModulator64 = NonlinearRingModulatorT<double>
using	OfflineStretch = OfflineStretchT<float>
using	OfflineStretch64 = OfflineStretchT<double>
using	Oscillator = OscillatorT<float>
using	Oscillator64 = OscillatorT<double>
using	OtaCascadeFilter = OtaCascadeFilterT<float>
	Single-precision sample interface for OtaCascadeFilterT<float>.
using	OtaCascadeFilter64 = OtaCascadeFilterT<double>
	Double-precision sample interface for OtaCascadeFilterT<double>.
using	Convolver = ConvolverT<float>
using	Convolver64 = ConvolverT<double>
using	Oversampler = OversamplerT<float>
using	Oversampler64 = OversamplerT<double>
using	Panner = PannerT<float>
using	Panner64 = PannerT<double>
using	ParallelDynamicsConfig = ParallelDynamicsConfigT<float>
using	ParallelDynamicsConfig64 = ParallelDynamicsConfigT<double>
using	PreparedParallelDynamicsConfig = PreparedParallelDynamicsConfigT<float>
using	PreparedParallelDynamicsConfig64 = PreparedParallelDynamicsConfigT<double>
using	ParallelDynamicsMixer = ParallelDynamicsMixerT<float>
using	ParallelDynamicsMixer64 = ParallelDynamicsMixerT<double>
using	ParametricEqBand = ParametricEqBandT<float>
using	ParametricEq = ParametricEqT<float>
using	ParametricEq64 = ParametricEqT<double>
using	ParticleCollisionExciter = ParticleCollisionExciterT<float>
using	ParticleCollisionExciter64 = ParticleCollisionExciterT<double>
using	ParticlePercussionVoice = ParticlePercussionVoiceT<float>
using	ParticlePercussionVoice64 = ParticlePercussionVoiceT<double>
using	PathLatencyAligner = PathLatencyAlignerT<float>
using	PathLatencyAligner64 = PathLatencyAlignerT<double>
using	ClickFreePathSwitcher = ClickFreePathSwitcherT<float>
using	ClickFreePathSwitcher64 = ClickFreePathSwitcherT<double>
using	PhaseDistortionOsc = PhaseDistortionOscT<float>
using	PhaseDistortionOsc64 = PhaseDistortionOscT<double>
using	PhaseVocoder = PhaseVocoderT<float>
using	PhaseVocoder64 = PhaseVocoderT<double>
using	Phaser = PhaserT<float>
using	Phaser64 = PhaserT<double>
using	PhaserStages = PhaserStagesT<float>
using	PhaserStages64 = PhaserStagesT<double>
using	PitchShifter = PitchShifterT<float>
using	PitchShifter64 = PitchShifterT<double>
using	FeedbackLoopProcessor = FeedbackLoopProcessorT<float>
using	FeedbackLoopProcessor64 = FeedbackLoopProcessorT<double>
using	PitchedFeedbackDelay = PitchedFeedbackDelayT<float>
using	PitchedFeedbackDelay64 = PitchedFeedbackDelayT<double>
using	Mat2 = Mat2T<float>
using	Mat2d = Mat2T<double>
using	Mat3 = Mat3T<float>
using	Mat3d = Mat3T<double>
using	ProbGate = ProbGateT<float>
using	ProbGate64 = ProbGateT<double>
using	ProcessingSwitchCrossfade = ProcessingSwitchCrossfadeT<float>
using	ProcessingSwitchCrossfade64 = ProcessingSwitchCrossfadeT<double>
template<typename... Processors>
using	ProcessorChain = ProcessorChainT<float, Processors...>
template<typename... Processors>
using	ProcessorChain64 = ProcessorChainT<double, Processors...>
template<typename P>
using	ProcessorDuplicator = ProcessorDuplicatorT<P, float>
template<typename P>
using	ProcessorDuplicator64 = ProcessorDuplicatorT<P, double>
using	RealtimePitchTimeProcessor = RealtimePitchTimeProcessorT<float>
using	RealtimePitchTimeProcessor64 = RealtimePitchTimeProcessorT<double>
using	ReedWaveguideLoop = ReedWaveguideLoopT<float>
using	ReedWaveguideLoop64 = ReedWaveguideLoopT<double>
using	Resampler = ResamplerT<float>
using	Resampler64 = ResamplerT<double>
using	Reverb = ReverbT<float>
using	Reverb64 = ReverbT<double>
using	ReverseBuffer = ReverseBufferT<float>
using	ReverseBuffer64 = ReverseBufferT<double>
using	RiseFallGenerator = RiseFallGeneratorT<float>
using	RiseFallGenerator64 = RiseFallGeneratorT<double>
using	OuWalk = OuWalkT<float>
using	OuWalk64 = OuWalkT<double>
using	Drift = DriftT<float>
using	Drift64 = DriftT<double>
using	Rungler = RunglerT<float>
using	Rungler64 = RunglerT<double>
using	Saturator = SaturatorT<float>
using	Saturator64 = SaturatorT<double>
using	QuantizeScale = QuantizeScaleT<float>
using	QuantizeScale64 = QuantizeScaleT<double>
using	ScannerVibrato = ScannerVibratoT<float>
using	ScannerVibrato64 = ScannerVibratoT<double>
using	ScopeCapture = ScopeCaptureT<float>
using	ScopeCapture64 = ScopeCaptureT<double>
using	AlignedBuffer = AlignedBufferT<float>
using	AlignedBuffer64 = AlignedBufferT<double>
using	SincResampler = SincResamplerT<float>
using	SincResampler64 = SincResamplerT<double>
using	SixBandEq = SixBandEqT<float>
using	SixBandEq64 = SixBandEqT<double>
using	SmoothedValue64 = SmoothedValue<double>
template<typename Processor>
using	SoftBypass = SoftBypassT<Processor, float>
template<typename Processor>
using	SoftBypass64 = SoftBypassT<Processor, double>
using	SosCascade = SosCascadeT<float>
using	SosCascade64 = SosCascadeT<double>
using	CepstralEnvelopeConfig = CepstralEnvelopeConfigT<float>
using	CepstralEnvelopeConfig64 = CepstralEnvelopeConfigT<double>
using	CepstralEnvelopeAnalyzer = CepstralEnvelopeAnalyzerT<float>
using	CepstralEnvelopeAnalyzer64 = CepstralEnvelopeAnalyzerT<double>
using	LpcAnalyzer = LpcAnalyzerT<float>
using	LpcAnalyzer64 = LpcAnalyzerT<double>
using	SpeakerModel = SpeakerModelT<float>
using	SpeakerModel64 = SpeakerModelT<double>
using	SpectralBand = SpectralBandT<float>
using	SpectralBand64 = SpectralBandT<double>
using	SpectralBandLayout = SpectralBandLayoutT<float>
using	SpectralBandLayout64 = SpectralBandLayoutT<double>
using	SpectralBandResolution = SpectralBandResolutionT<float>
using	SpectralBandResolution64 = SpectralBandResolutionT<double>
using	SpectralMaskTable = SpectralMaskTableT<float>
using	SpectralMaskTable64 = SpectralMaskTableT<double>
using	SpectralCrossSynthesisPrepareConfig = SpectralCrossSynthesisPrepareConfigT<float>
using	SpectralCrossSynthesisPrepareConfig64 = SpectralCrossSynthesisPrepareConfigT<double>
using	SpectralCrossSynthesisConfig = SpectralCrossSynthesisConfigT<float>
using	SpectralCrossSynthesisConfig64 = SpectralCrossSynthesisConfigT<double>
using	SpectralCrossSynthesis = SpectralCrossSynthesisT<float>
using	SpectralCrossSynthesis64 = SpectralCrossSynthesisT<double>
using	SpectralDelayMatrix = SpectralDelayMatrixT<float>
using	SpectralDelayMatrix64 = SpectralDelayMatrixT<double>
using	SpectralEnvelopeShifter = SpectralEnvelopeShifterT<float>
using	SpectralEnvelopeShifter64 = SpectralEnvelopeShifterT<double>
using	SpectralFeatureFrontEnd = SpectralFeatureFrontEndT<float>
using	SpectralFeatureFrontEnd64 = SpectralFeatureFrontEndT<double>
using	SpectralFrameEngine = SpectralFrameEngineT<float>
using	SpectralFrameEngine64 = SpectralFrameEngineT<double>
using	SpectralGate = SpectralGateT<float>
using	SpectralGate64 = SpectralGateT<double>
using	SpectralFrameBlur = SpectralFrameBlurT<float>
using	SpectralFrameBlur64 = SpectralFrameBlurT<double>
using	SpectralMaskProcessorConfig = SpectralMaskProcessorConfigT<float>
using	SpectralMaskProcessorConfig64 = SpectralMaskProcessorConfigT<double>
using	SpectralMaskProcessor = SpectralMaskProcessorT<float>
using	SpectralMaskProcessor64 = SpectralMaskProcessorT<double>
using	SpectralPreMaskStage = SpectralPreMaskStageT<float>
using	SpectralPreMaskStage64 = SpectralPreMaskStageT<double>
using	SpectralWetSourceStage = SpectralWetSourceStageT<float>
using	SpectralWetSourceStage64 = SpectralWetSourceStageT<double>
using	SpectralMorph = SpectralMorphT<float>
using	SpectralMorph64 = SpectralMorphT<double>
using	SpectrumTrace = SpectrumTraceT<float>
using	SpectrumTrace64 = SpectrumTraceT<double>
using	SquareOscBank = SquareOscBankT<float>
using	SquareOscBank64 = SquareOscBankT<double>
using	StageSeq = StageSeqT<float>
using	StageSeq64 = StageSeqT<double>
using	StftFrame = StftFrameT<float>
using	StftFrame64 = StftFrameT<double>
using	Stft = StftT<float>
using	Stft64 = StftT<double>
using	StnMasks = StnMasksT<float>
using	StnMasks64 = StnMasksT<double>
using	StnDecomposer = StnDecomposerT<float>
using	StnDecomposer64 = StnDecomposerT<double>
using	SubOscillator = SubOscillatorT<float>
using	SubOscillator64 = SubOscillatorT<double>
using	Supersaw = SupersawT<float>
using	Supersaw64 = SupersawT<double>
using	Svf = SvfT<float>
using	Svf64 = SvfT<double>
template<std::size_t Voices = 16>
using	SvfBank = SvfBankT<float, Voices>
using	TapeMachine = TapeMachineT<float>
using	TapeMachine64 = TapeMachineT<double>
using	TapeCompander = TapeCompanderT<float>
using	TiltEq = TiltEqT<float>
using	TiltEq64 = TiltEqT<double>
using	TptFilter = TptFilterT<float>
using	TptFilter64 = TptFilterT<double>
using	TransferCurvePoint = TransferCurvePointT<float>
using	TransferCurvePoint64 = TransferCurvePointT<double>
using	PreparedTransferCurve = PreparedTransferCurveT<float, 32>
using	PreparedTransferCurve64 = PreparedTransferCurveT<double, 32>
using	TransferCurve = TransferCurveT<float, 32>
using	TransferCurve64 = TransferCurveT<double, 32>
using	TransientDesigner = TransientDesignerT<float>
using	TransientDesigner64 = TransientDesignerT<double>
using	TransientPhasePolicy = TransientPhasePolicyT<float>
using	TransientPhasePolicy64 = TransientPhasePolicyT<double>
using	TransitionMixer = TransitionMixerT<float>
using	TransitionMixer64 = TransitionMixerT<double>
using	TransportEdge = TransportEdgeT<float>
using	TransportEdge64 = TransportEdgeT<double>
using	HystereticTriggerDetect = HystereticTriggerDetectT<float>
using	HystereticTriggerDetect64 = HystereticTriggerDetectT<double>
using	TriggerDetect = TriggerDetectT<float>
using	TriggerDetect64 = TriggerDetectT<double>
using	GateGen = GateGenT<float>
using	GateGen64 = GateGenT<double>
using	ClockDivider = ClockDividerT<float>
using	ClockDivider64 = ClockDividerT<double>
using	ClockMult = ClockMultT
	Backward-compatible name for the already-decoded event adapter.
using	ClockMult64 = ClockMultT
using	EventClockMult = ClockMultT
using	EventClockMult64 = ClockMultT
using	SignalClockMult = SignalClockMultT<float>
using	SignalClockMult64 = SignalClockMultT<double>
using	BurstGen = BurstGenT<float>
using	BurstGen64 = BurstGenT<double>
using	TrigDelay = TrigDelayT<float>
using	TrigDelay64 = TrigDelayT<double>
using	TruePeakLimiter = TruePeakLimiterT<float>
using	TruePeakLimiter64 = TruePeakLimiterT<double>
using	TwoPoleResonator = TwoPoleResonatorT<float>
using	TwoPoleResonator64 = TwoPoleResonatorT<double>
using	UnitDelay = UnitDelayT<float>
using	UnitDelay64 = UnitDelayT<double>
using	VactrolConditioner = VactrolConditionerT<float>
using	VactrolConditioner64 = VactrolConditionerT<double>
using	Vca = VcaT<float>
using	Vca64 = VcaT<double>
using	VcaCompressor = VcaCompressorT<float>
using	VcaCompressor64 = VcaCompressorT<double>
using	VelvetNoiseGrid = VelvetNoiseGridT<float>
using	VelvetNoiseGrid64 = VelvetNoiseGridT<double>
using	DelayVibrato = DelayVibratoT<float>
using	DelayVibrato64 = DelayVibratoT<double>
using	PhaseVibrato = PhaseVibratoT<float>
using	PhaseVibrato64 = PhaseVibratoT<double>
using	UniVibe = UniVibeT<float>
using	UniVibe64 = UniVibeT<double>
using	Vocoder = VocoderT<float>
using	Vocoder64 = VocoderT<double>
using	WaveguideJunction = WaveguideJunctionT<float>
using	WaveguideJunction64 = WaveguideJunctionT<double>
using	WaveguideLine = WaveguideLineT<float>
using	WaveguideLine64 = WaveguideLineT<double>
using	ReedExciter = ReedExciterT<float>
using	ReedExciter64 = ReedExciterT<double>
using	WaveguideReflectionFilter = WaveguideReflectionFilterT<float>
using	WaveguideReflectionFilter64 = WaveguideReflectionFilterT<double>
using	WavesetTransformer = WavesetTransformerT<float>
using	WavesetTransformer64 = WavesetTransformerT<double>
using	WaveShaper = WaveShaperT<float>
using	WaveShaper64 = WaveShaperT<double>
using	WavetableEntry = WavetableEntryT<float>
using	WavetableEntry64 = WavetableEntryT<double>
using	Wavetable = WavetableT<float>
using	Wavetable64 = WavetableT<double>
using	WavetableBank = WavetableBankT<float>
using	WavetableBank64 = WavetableBankT<double>
using	YinTracker = YinTrackerT<float>
using	YinTracker64 = YinTrackerT<double>
using	ZeroLatencyConvolver = ZeroLatencyConvolverT<float>
using	ZeroLatencyConvolver64 = ZeroLatencyConvolverT<double>

Enumerations
enum class	SpectralDomain : std::uint8_t { absolute_hz , relative_to_f0 }
	This enum exists because "sampling a spectral envelope makes timbre pitch-independent" is only true under a condition, and the two readings of that sentence are genuinely different sounds: More...
enum class	OnsetDetectionMethod : std::uint8_t { EnergyFlux , SpectralFlux , HighFrequencyContent }
enum class	MatrixHeadroomPolicy { Raw , NormalizePeak }
	Raw applies the signed matrix exactly. More...
enum class	AutoDuckedSendStatus { ready , invalid_sample_rate , invalid_config }
enum class	BeatRepeatPlanError {   None , InvalidDivision , TickRangeExceeded , SampleRangeExceeded ,   CaptureRangeExceeded , HistoryCapacityExceeded , Unprepared , SampleRateMismatch ,   ReleaseInProgress , StaleRequest }
enum class	BreakpointEnvelopeStatus : std::uint8_t {   ok , too_few_points , too_many_points , invalid_time ,   times_not_ordered , invalid_value , invalid_sample_rate , invalid_loop }
enum class	CartesianAccess { row_major , independent }
	How a CartesianWalkT's two axes relate. More...
enum class	CombFilterMode { feedforward , feedback , allpass }
enum class	CombFilterStatus {   ok , not_prepared , not_configured , invalid_argument ,   non_finite_input , output_out_of_range }
enum class	CommutedStringExcitationPrepareStatus {   ok , empty_base_excitation , empty_body_impulse_response , retained_sample_limit_exceeded ,   non_finite_input , non_finite_output , input_aliases_profile }
enum class	CompressorBallistics : std::uint8_t { branching , decoupled }
	How CompressorT smooths the gain reduction its static curve asks for, in the log (dB) domain after the gain computer (the two detector forms of Giannoulis, Massberg and Reiss, "Digital Dynamic Range Compressor Design", JAES 2012). More...
enum class	CrossfadeGainLaw { EqualGain , EqualPower }
	The old→new gain split applied to a shaped progress u ∈ [0,1]. More...
enum class	DiodeModel : std::uint8_t { silicon , germanium , led }
	Diode device families. The members differ only in (Is, n). More...
enum class	ClipperTopology : std::uint8_t { to_ground , in_loop }
	Where the diode pair sits relative to the gain stage. More...
enum class	DitherMode : std::uint8_t { none = 0 , tpdf = 1 }
enum class	NoiseShapingOrder : std::uint8_t { none = 0 , first = 1 , second = 2 }
enum class	MixCurve {   Linear , EqualPower , Balanced , Sin3dB ,   Sin4_5dB , Sin6dB , Sqrt3dB , Sqrt4_5dB }
	Crossfade curve between dry (mix=0) and wet (mix=1). More...
enum class	DustAmplitudeDistribution : std::uint8_t { constant , uniform_unipolar , uniform_bipolar }
	Amplitude law applied when a DustT event occurs. More...
enum class	DynamicsStereoLink { independent , peak_linked }
	Shared policy for dynamics processors with two detector channels. More...
enum class	EnvelopeStage : std::uint8_t {   idle , delay , attack , hold ,   decay , sustain , release }
	Stage of any envelope in this header. More...
enum class	ExpansionMode { downward , upward }
enum class	ExpanderStatus { ready , invalid_sample_rate , invalid_config }
enum class	FastTrigProfile : std::uint8_t { reference , realtime_efficient , realtime_precise }
	Semantic accuracy choices for bounded-cycle real-time trigonometry. More...
enum class	LadderSaturation { exact , accurate , realtime_efficient }
	Saturator choices for the Moog ladder's per-stage non-linearity. More...
enum class	CompressorDetector : std::uint8_t { peak , rms }
	What the sidechain measures. More...
enum class	FetRatio : std::uint8_t {   r4_1 , r8_1 , r12_1 , r20_1 ,   all_buttons_in }
	The ratio buttons. More...
enum class	FftBackend {   auto_ , vdsp , kissfft , fftw3 ,   mkl }
enum class	MorphFilterType { lowpass , bandpass , highpass , notch }
enum class	FiniteStretchPrepareStatus {   prepared , invalid_mode , invalid_input , invalid_output ,   invalid_output_layout , invalid_target , invalid_ratio , unrepresentable_capacity ,   processor_prepare_failed }
enum class	FiniteStretchStepStatus { progress , complete , failed }
enum class	FiniteStretchFailure {   none , invalid_ratio , output_too_short , output_too_long ,   processor_protocol_error }
enum class	FiniteStretchWorkUnit { none , feed , drain , finalize }
enum class	FiniteStretchWorkOutcome { none , advanced , backpressure }
enum class	FiniteStretchCounterGeometryStatus { representable , input_counter_overflow , output_counter_overflow }
enum class	FirDesignStatus {   success , invalid_argument , unsupported_size , workspace_limit_exceeded ,   allocation_failure , rank_deficient , ill_conditioned , numerical_failure ,   not_converged }
enum class	LinearPhaseFirType { type_i_symmetric_odd , type_ii_symmetric_even , type_iii_antisymmetric_odd , type_iv_antisymmetric_even }
enum class	ConvolutionBackend : std::uint8_t { none , direct_fir , partitioned_fft }
	The engine a FixedIrConvolverT runs. More...
enum class	FlangerMode : std::uint8_t { classic , through_zero , barberpole }
	Which of the three sweep topologies the engine runs. More...
enum class	FlangerPolarity : std::uint8_t { positive , negative }
	The sign of the wet contribution, in the mix and in the feedback tap alike. More...
enum class	FlangerDelayEngine : std::uint8_t { clean , bbd }
	Which delay engine fills the modulated slot. More...
enum class	FmOperatorFrequencyMode : std::uint8_t { ratio , fixed_hz }
	How an operator derives its unmodulated frequency. More...
enum class	FmOperatorAliasPolicy : std::uint8_t { bounded , bright_band_safe }
	Alias behavior for the modulation network. More...
enum class	FormantVowel {   a , e , i , o ,   u }
enum class	FormantConfigureStatus {   configured , not_prepared , invalid_count , non_finite ,   out_of_range , unordered , unstable }
enum class	FractionalDelayMethod { thiran1 , lagrange3 , lagrange5 }
enum class	FractionalDelayStatus {   ok , not_prepared , invalid_argument , non_finite_input ,   invalid_delay , output_out_of_range }
enum class	FreezeHoldSynthesis : std::uint8_t { polar , rotor }
	How held frames are synthesised (see the class notes on per-callback cost). More...
enum class	FreezeHoldFrequency : std::uint8_t { newest , energy_weighted }
	Where a held bin's instantaneous frequency comes from. More...
enum class	FreezeHoldAverage : std::uint8_t { at_latch , running }
	When the capture window is averaged. More...
enum class	FreezeHoldPhaseLock : std::uint8_t { none , peak_lobe }
	Phase structure of a hold as it starts (see the class notes on stationarity). More...
enum class	FreezeRestoreEngage : std::uint8_t { crossfade , immediate , as_captured }
	How a restored hold enters the output. More...
enum class	FrequencyShiftMode : std::uint8_t { up , down , dual_mono , stereo_split }
	Which sideband a SsbFrequencyShifterT keeps, and how it spreads it. More...
enum class	FuzzDevice : std::uint8_t { germanium , silicon }
	The two device families. They differ only in (n, Is). More...
enum class	GateOp {   logic_and , logic_or , logic_xor , logic_nand ,   logic_nor , logic_xnor }
	Boolean operation performed by a GateLogicT. More...
enum class	GrainSource : std::uint8_t { buffer , live_ring }
	Where grains read from. More...
enum class	Coherence : std::uint8_t { incoherent , coherent }
	Which normalization law applies — a statement about whether grains are correlated with each other, not a tone control. More...
enum class	StealPolicy : std::uint8_t { oldest , quietest , drop_new }
	What happens when a grain is due and the pool is full. More...
enum class	GrainInterp : std::uint8_t { linear , cubic_hermite }
	Fractional-read quality inside a grain. More...
enum class	GraphicEqPrepareStatus { prepared , invalid_sample_rate , invalid_capacity }
enum class	GraphicEqConfigureStatus {   configured , not_prepared , over_capacity , invalid_transition ,   non_finite , frequency_out_of_range , frequencies_not_strictly_increasing , gain_out_of_range ,   q_out_of_range , unstable , transition_in_progress }
enum class	ScaleType : std::uint8_t {   major = 0 , natural_minor = 1 , dorian = 2 , phrygian = 3 ,   lydian = 4 , mixolydian = 5 , harmonic_minor = 6 , melodic_minor = 7 ,   major_pentatonic = 8 , minor_pentatonic = 9 }
	The shipped scale collection, order-locked. More...
enum class	OffScalePolicy : std::uint8_t { nearest_lower , nearest , mute_wet }
	How a pitch class that is not in the active scale is resolved. More...
enum class	LeslieSpeed : std::uint8_t { stop , chorale , tremolo }
	The three positions of the cabinet's speed switch. More...
enum class	LfoWave : std::uint8_t {   sine , triangle , saw_up , saw_down ,   square , sample_hold , smooth_random }
	The effect-wave vocabulary, shared by these functions and by EffectLfoT (lfo.hpp), whose set_wave(LfoWave) overload selects the effect convention. More...
enum class	FloorCurve { linear , smoothstep }
	The curve applied above a floor threshold by floor_shape. More...
enum class	SlewMode : std::uint8_t { linear , exponential }
	Rate limiter with independent rise and fall speeds. More...
enum class	ModulationCurveShape : std::uint8_t {   linear , exponential , logarithmic , smoothstep ,   hold }
enum class	MeterFeatures : std::uint8_t { levels = 0 , correlation = 1u << 0 , loudness = 1u << 1 , all = correlation | loudness }
	What a MultiChannelMeter computes. More...
enum class	LoudnessChannelRole : std::uint8_t {   left , right , center , lfe ,   left_surround , right_surround , left_rear_surround , right_rear_surround ,   unknown }
	Speaker roles used by the BS.1770 channel summation. More...
enum class	NoiseColor {   white , pink , brown , blue ,   violet }
	Spectral tilt of a NoiseSourceT, named by the usual colour convention. More...
enum class	NonlinProgram { ambience = 0 , gated = 1 , reverse = 2 , nonlin2 = 3 }
	The four programs. More...
enum class	NonlinearAliasPolicy : std::uint8_t { oversample_4x , oversample_2x , off }
	Antialiasing choices shared by the nonlinear-shaping processors. More...
enum class	RingModulationModel : std::uint8_t { ideal_multiplier , diode_ring }
enum class	RingCarrierWaveform : std::uint8_t { sine , triangle , square }
enum class	RingCarrierMode : std::uint8_t { bipolar , unipolar }
enum class	RingOutputPolarity : std::uint8_t { normal , inverted }
enum class	OfflineFormantMode { follow_pitch , preserve_original , shift_independently }
	Formant behavior for the spectral modes. More...
enum class	StretchTransientMode { phase_reset , verbatim_relocate }
	Transient strategy. More...
enum class	StretchCharacter { clean , varispeed , phase_vocoder , granular }
	Character mode — the musically-distinct "engine per job" selector. More...
enum class	PanLaw {   Linear , Balanced , Sin3dB , EqualPower = Sin3dB ,   Sin4_5dB , Sin6dB , Sqrt3dB , Sqrt4_5dB }
	Stereo pan law selector. More...
enum class	ParametricEqBandType : std::uint8_t { low_shelf , peaking , high_shelf }
enum class	ParametricEqPrepareStatus { prepared , invalid_sample_rate , invalid_capacity }
enum class	ParametricEqConfigureStatus {   configured , not_prepared , over_capacity , invalid_transition ,   non_finite , frequency_out_of_range , frequencies_not_strictly_increasing , gain_out_of_range ,   q_out_of_range , invalid_solo , unstable , transition_in_progress }
enum class	PhaseDistortionShape {   saw , pulse , resonant_saw , resonant_triangle ,   resonant_trapezoid }
	Which phase warp a PhaseDistortionOscT applies. More...
enum class	PedalMode : std::uint8_t { whammy , harmony , detune , dive }
	How the expression pedal maps to a shift target. More...
enum class	PitchInterp : std::uint8_t { linear , cubic }
	Fractional-delay read quality for the two taps. More...
enum class	ShiftSource : std::uint8_t { pedal , direct }
	Which control feeds the shift target. More...
enum class	PitchTimeQuality { quality , low_latency }
enum class	PitchTimeMode { realtime_pitch , time_stretch }
enum class	FormantMode { follow , preserve }
enum class	PitchTimeStreamFeedStatus { accepted , backpressure , input_closed , invalid_request }
enum class	PitchTimeStreamFinalizeStatus {   draining , backpressure , complete , invalid_mode ,   invalid_request }
enum class	PitchTimeStreamFinalizePlanStatus {   ready , needs_drain , complete , invalid_mode ,   invalid_request }
enum class	PitchTimePrepareStatus {   prepared , invalid_sample_rate , invalid_channel_count , invalid_max_block ,   invalid_max_time_ratio , invalid_max_pitch_semitones , invalid_spectral_geometry , unrepresentable_capacity }
enum class	ReverseBufferState { unprepared , bypassed , priming , running }
enum class	RiseFallStage : std::uint8_t { idle , rising , falling }
enum class	SaturatorShape : std::uint8_t { tanh_soft , atan_soft , cubic_soft , sinh_arc }
	Which member of the waveshaper family a SaturatorT evaluates. More...
enum class	SaturatorAliasPolicy : std::uint8_t { adaa , oversample_2x , off , adaa2 }
	How a SaturatorT keeps the harmonics it generates from folding back. More...
enum class	QuantizeMode { edo , scale_mask }
	How a QuantizeScaleT divides the octave. More...
enum class	ScannerMode : std::uint8_t {   off , v1 , v2 , v3 ,   c1 , c2 , c3 }
	The console's six-position vibrato/chorus switch, plus off. More...
enum class	ScopeTriggerMode : std::uint8_t { immediate , rising_edge , falling_edge , either_edge }
enum class	SosCascadeInstallStatus {   installed , not_prepared , over_capacity , non_finite ,   unstable }
enum class	SosCascadeTransition { reset_state , preserve_state }
	Coefficient changes take effect immediately. More...
enum class	SourceFilterAnalysisStatus : std::uint8_t {   Ok , NotPrepared , InvalidFftSize , InvalidOrder ,   InvalidIterationCount , InvalidTolerance , InvalidInputSize , InvalidOutputSize ,   InvalidWorkspaceSize , AllocationFailure , NonFiniteInput , NumericalOverflow ,   DegenerateInput , RankDeficient , UnstableModel , PredictionErrorOverflow ,   InvalidSampleRate , InvalidGain , ResponseSingularity }
enum class	SpeakerBoxType { sealed , open_back }
	Cabinet topology. More...
enum class	SpectralBandSpacing : std::uint8_t { linear , logarithmic }
enum class	SpectralBandEdgePolicy : std::uint8_t { mute_outside , extend_edge_band }
enum class	SpectralMaskBoundaryKernel : std::uint8_t { hard , raised_cosine }
enum class	SpectralCrossSynthesisNormalization { none , match_carrier_rms }
enum class	SpectralCodecError {   None , UnsupportedFormat , InvalidGeometry , ResourceLimit ,   InvalidLength , InvalidChronology , InvalidComponent , NoncanonicalZero ,   AllocationFailure }
enum class	SpectralSplitResult : std::uint8_t {   Ok , NotPrepared , InvalidBlock , InvalidFrame ,   ChronologyExhausted , CapacityExceeded , NonfiniteSynthesis , OutputUnderrun ,   StreamStopped }
enum class	SpectralMagnitudeInterpolation { linear , equal_power }
enum class	SpectralPhaseInterpolation { shortest_arc , normalized_vector }
enum class	ColorRamp { inferno , viridis , grayscale , heat }
	Predefined color ramp types for spectrogram rendering. More...
enum class	FrequencyScale { linear , logarithmic , mel }
	Frequency axis scaling modes. More...
enum class	SpectrumBandScale : std::uint8_t { linear , logarithmic }
enum class	SpectrumBandAggregation : std::uint8_t { mean_power , maximum }
enum class	SpectrumFrequencyWeighting : std::uint8_t { none , a , c }
enum class	SeqDirection { forward , reverse , pingpong , random }
	How a StageSeqT walks from one stage to the next. More...
enum class	StageGateMode { hold , repeat , single , rest }
	What the gate does across the clock pulses a stage occupies. More...
enum class	SubOscillatorWaveform { square , sine }
	Output shape for a parent-phase-locked sub-oscillator. More...
enum class	TapeCurve : std::uint8_t { nab , iec_ccir , cassette_type1 , cassette_type2 }
	Which recording standard's record/playback network pair is in force. More...
enum class	TapeArchetype : std::uint8_t { ampex_350_440 , studer_a800 , cassette_deck }
	Which machine's full preset a fresh instance starts from. More...
enum class	TempoDelayError : std::uint8_t {   none , not_prepared , invalid_division , invalid_tempo ,   invalid_sample_rate , invalid_delay , out_of_range }
enum class	TempoDelayWrapperInterpolation : std::uint8_t { lagrange3 , lagrange5 , thiran1 }
enum class	TempoDelayWrapperError : std::uint8_t {   none , not_prepared , invalid_sample_rate , invalid_capacity ,   unsupported_interpolation , invalid_delay , invalid_tempo , invalid_division ,   out_of_range , invalid_feedback , invalid_crossfeed , non_finite_input }
enum class	TransitionCurve { Smoothstep , EqualPower }
enum class	UnisonGainLaw : std::uint8_t { PeakSafe , EqualPower }
enum class	VcaResponse : std::uint8_t { linear , exponential }
enum class	VocoderCarrier : std::uint8_t { external , internal }
	Where the thing that speaks comes from. More...
enum class	VocoderWave : std::uint8_t { saw , pulse }
	The internal carrier's shape. Both are polyBLEP-corrected. More...
enum class	IrNormalizeMode { none , peak , energy }
	IR amplitude policy applied at load, after resampling and tail trim. More...

Functions
VoiceTable	make_organ_voice (int count=64)
	The drawbar organ voice (§10a): nine tonewheel footages over a −12 dB/oct harmonic tail.
VoiceTable	make_bell_voice (int count=64)
	The bell voice (§10b): a modal body whose partials each decay at their own rate.
double	onset_energy_flux (double previous, double current) noexcept
	Pure novelty transitions shared by fixed-capacity streaming analysis and background/offline adapters.
double	onset_spectral_bin_flux (OnsetDetectionMethod method, double previous, double current, std::size_t bin) noexcept
BeatRepeatPlanResult	lower_beat_repeat_capture (const timebase::CompiledTempoMap &tempo, timebase::BeatDivision division, timebase::SamplePosition requested_sample) noexcept
	Lower the first grid edge strictly after requested_sample and the exact preceding grid interval into integer host samples.
template<typename SampleType>
bool	biquad_is_stable (const BiquadCoefficientsT< SampleType > &c) noexcept
	Return whether a normalized real biquad's poles are strictly inside the unit circle.
double	q43_collector_current (double vcomm, const Q43Leakage &leak) noexcept
	Q43's collector current for a given Vcomm (DAFx-14 Eq.
double	q43_branch_resistance (double vcomm, const BridgedTComponents &c, const Q43Leakage &leak, double guard_v=-0.01) noexcept
	Resistance of the Vcomm-to-ground branch through R166, Q43's collector and R165 (DAFx-14 Eq.
double	bridged_t_shunt_resistance (double r_e, const BridgedTComponents &c) noexcept
	Total Vcomm-to-ground resistance seen by the network: R161 || R_e || R170.
double	bridged_t_center_frequency (double r_eff, const BridgedTComponents &c) noexcept
	Centre frequency of the bridged-T for a given total shunt resistance.
BridgedTComponents	bridged_t_retuned_to (const BridgedTComponents &c, double target_hz) noexcept
	Quality factor of the bridged-T network alone, with its three inputs grounded.
double	bridged_t_q (double r_eff, const BridgedTComponents &c) noexcept
bool	checked_capacity_product (std::uint64_t lhs, std::uint64_t rhs, std::uint64_t maximum, std::uint64_t &product) noexcept
bool	checked_capacity_sum (std::uint64_t lhs, std::uint64_t rhs, std::uint64_t maximum, std::uint64_t &sum) noexcept
template<typename Element>
bool	checked_allocation_bytes (std::uint64_t elements, std::uint64_t target_max_bytes, std::uint64_t *bytes=nullptr) noexcept
template<typename Element>
bool	checked_repeated_allocation_bytes (std::uint64_t elements_per_allocation, std::uint64_t repetitions, std::uint64_t target_max_bytes, std::uint64_t &aggregate_bytes) noexcept
	Validate one allocation against its address ceiling, then compute the aggregate retained charge for repetitions distinct allocations.
constexpr bool	is_valid_comb_filter_mode (CombFilterMode mode) noexcept
std::complex< double >	comb_filter_response (CombFilterMode mode, std::size_t delay_samples, double gain, double omega) noexcept
	Returns H(e^jw) for the documented mode equations.
template<typename T>
constexpr T	crossfade_smoothstep (T t) noexcept
	Smoothstep progress shaping: cubic 3u²−2u³ with zero slope at both ends, clamped to [0,1].
template<typename T>
void	crossfade_gains (T u, CrossfadeGainLaw law, T &old_gain, T &new_gain) noexcept
	Old/new blend gains for an ALREADY-SHAPED progress u (the caller applies any smoothstep/clamp first).
long long	round_half_even (double x) noexcept
	Round half to even, in integer logic.
double	exp_decay_coefficient (double ms, double sample_rate)
	Per-sample multiplier for an exponential decay with time constant ms.
double	t60_decay_coefficient (double ms, double sample_rate)
	Per-sample multiplier for a decay that reaches -60 dB after ms.
template<typename T>
constexpr T	snap_threshold ()
	Threshold in absolute value below which a sample is treated as zero.
template<typename T>
T	snap_to_zero (T x)
	Returns 0 if |x| < snap_threshold, else x.
template<typename T>
T	snap_recursion_state (T x)
	Snap a per-sample recursion's state: snap_to_zero() where subnormals are slow, the identity where kSubnormalsAreFree.
template<typename T>
void	snap_to_zero (T *samples, int n)
	Snap an entire buffer in place.
constexpr SnapChunks	snap_chunks (std::size_t num_samples) noexcept
template<typename T>
bool	is_denormal (T x)
	Return true if x is a denormal (subnormal) float.
template<typename SampleType>
constexpr SampleType	tpdf_difference (SampleType first, SampleType second) noexcept
	Converts two independent uniform draws in [0, 1) to unit-peak TPDF noise.
template<typename SampleType>
constexpr SampleType	tpdf_centered_sum (SampleType first, SampleType second) noexcept
template<typename SampleType>
SampleType	quantization_step (SampleType bits) noexcept
	Mid-tread quantization step for a continuous bit-depth control.
template<typename SampleType>
DitheredQuantizationResultT< SampleType >	quantize_with_error_feedback (SampleType input, SampleType step, DitherMode dither_mode, NoiseShapingOrder shaping, NoiseShaperStateT< SampleType > &state, SampleType first_uniform=SampleType{}, SampleType second_uniform=SampleType{}) noexcept
	One allocation-free error-feedback transition.
template<auto Saturation> requires std::is_same_v<decltype(Saturation), LadderSaturation>
float	ladder_tanh_profiled (float x)
	The ladder's float saturator for an explicit choice.
template<auto RealtimeEfficient> requires std::is_same_v<decltype(RealtimeEfficient), bool>
float	ladder_tanh_profiled (float x)
	The previous boolean form: true is the Padé saturator, false is exact std::tanh, as before LadderSaturation existed.
float	ladder_tanh (float x)
	The ladder's default float saturator.
double	lipschitz_tanh (double v) noexcept
	A [3/2] Padé tanh that is 1-LIPSCHITZ and bounded — the saturator to reach for inside a feedback loop.
template<typename SampleType>
bool	checked_fft_platform_setup_bytes (std::uint64_t fft_size, std::uint64_t target_max_bytes, std::uint64_t &bytes) noexcept
template<typename SampleType>
bool	checked_fft_retained_bytes (std::uint64_t fft_size, std::uint64_t target_max_bytes, std::uint64_t &bytes) noexcept
	Complete retained-storage contract for one prepared FftT.
const char *	fft_backend_name (FftBackend b) noexcept
	Stringify a backend tag for diagnostics / env-var parsing.
FftBackend	parse_fft_backend (const char *s) noexcept
	Parse a backend tag from a string. Unknown / empty → auto_.
bool	fft_backend_available (FftBackend b) noexcept
	True iff the backend can be instantiated on this machine right now.
FftBackend	resolve_fft_backend (FftBackend hint=FftBackend::auto_) noexcept
	Resolve auto_ → best available backend on this machine, honoring the PULP_FFT_BACKEND env var if set to a concrete backend that is available.
FiniteStretchCounterGeometryStatus	checked_finite_stretch_counter_geometry (const RealtimePitchTimeConfig &config, std::uint64_t input_frames) noexcept
std::complex< double >	fir_response (std::span< const double > coefficients, double omega) noexcept
double	linear_phase_fir_amplitude (std::span< const double > coefficients, LinearPhaseFirType type, double omega) noexcept
	Signed amplitude after removing the exact linear delay of a Type I-IV FIR.
FirLeastSquaresResult	design_fir_least_squares (std::span< const FirDesignPoint > points, const FirLeastSquaresOptions &options)
	Weighted least-squares design of a real Type I, II, III, or IV linear-phase FIR.
FirEquirippleResult	design_fir_equiripple (std::span< const FirEquirippleBand > bands, const FirEquirippleOptions &options)
	Equiripple (weighted minimax) design of a real Type I-IV linear-phase FIR by the Remez exchange, the Parks and McClellan method.
MinimumPhaseFirResult	reconstruct_minimum_phase_fir (std::span< const double > one_sided_magnitudes, const MinimumPhaseFirOptions &options={})
	Reconstruct a causal minimum-phase FIR from N/2+1 nonnegative magnitude bins.
constexpr bool	is_valid_fractional_delay_method (FractionalDelayMethod method) noexcept
Thiran1Coefficients	design_thiran1 (double delay_samples) noexcept
	Designs H(z) = (a + z^-1) / (1 + a z^-1), where a = (1 - D) / (1 + D).
double	thiran1_magnitude (const Thiran1Coefficients &design, double omega) noexcept
double	thiran1_group_delay_samples (const Thiran1Coefficients &design, double omega) noexcept
	Exact group delay of the first-order allpass at angular frequency omega.
std::array< double, 6 >	lagrange5_weights (double fraction) noexcept
template<typename SampleType>
SampleType	lagrange5 (double fraction, SampleType ym2, SampleType ym1, SampleType y0, SampleType y1, SampleType y2, SampleType y3) noexcept
float	magnitude_to_db (double magnitude)
	Convert a linear magnitude to dB, floored at min_response_db.
template<typename SampleType>
double	section_magnitude (const BiquadCoefficientsT< SampleType > &c, double omega)
	Linear magnitude |H(e^jω)| of one section at normalized angular frequency ω = 2π·f/fs (radians/sample, meaningful over [0, π]).
double	section_magnitude (const BiquadCoefficients &c, double omega)
template<typename SampleType>
double	section_group_delay (const BiquadCoefficientsT< SampleType > &c, double omega)
	Group delay of one biquad section at omega (radians per sample), in samples: -d(arg H)/d(omega) for H = B/A, evaluated in closed form as tau(B) - tau(A) with tau(P) = Re(sum k p_k z^-k / sum p_k z^-k), so no numeric differentiation is involved.
template<typename SampleType, std::size_t Extent>
double	cascade_magnitude (std::span< const BiquadCoefficientsT< SampleType >, Extent > sos, double omega)
	Linear magnitude |H| of a cascade at angular frequency ω.
double	cascade_magnitude (std::span< const BiquadCoefficients > sos, double omega)
double	angular_frequency (double freq_hz, double sample_rate)
	Angular frequency (radians/sample) of freq_hz at sample_rate, clamped to [0, π].
template<typename SampleType>
float	section_magnitude_db (const BiquadCoefficientsT< SampleType > &c, double freq_hz, double sample_rate)
	Magnitude of one section at a frequency in Hz, in dB.
float	section_magnitude_db (const BiquadCoefficients &c, double freq_hz, double sample_rate)
template<typename SampleType, std::size_t Extent>
float	cascade_magnitude_db (std::span< const BiquadCoefficientsT< SampleType >, Extent > sos, double freq_hz, double sample_rate)
	Magnitude of a cascade at a frequency in Hz, in dB.
float	cascade_magnitude_db (std::span< const BiquadCoefficients > sos, double freq_hz, double sample_rate)
template<typename SampleType>
float	magnitude_db (const BiquadT< SampleType > &filter, double freq_hz, double sample_rate)
	Ask a live filter what it looks like: the magnitude, in dB, that this BiquadT is applying at freq_hz with its coefficients as they stand.
double	fft_bin_frequency (std::size_t index, std::size_t bin_count, double sample_rate)
	Center frequency of bin index in a real-FFT magnitude array.
double	log_frequency_at (std::size_t index, std::size_t count, double min_hz, double max_hz)
	Frequency of sample index of count, log-spaced across [min_hz, max_hz].
template<typename SampleType, std::size_t Extent>
void	response_curve_db (std::span< const BiquadCoefficientsT< SampleType >, Extent > sos, double min_hz, double max_hz, double sample_rate, std::span< float > out)
	Sample a cascade's magnitude response into out, at out.size() log-spaced frequencies spanning [min_hz, max_hz], in dB.
void	response_curve_db (std::span< const BiquadCoefficients > sos, double min_hz, double max_hz, double sample_rate, std::span< float > out)
HalfBandIirDesign	design_halfband_iir (std::size_t coefficient_count, double passband_edge) noexcept
	Closed-form elliptic half-band design (see the file comment).
template<typename Coefficient = double>
std::complex< double >	halfband_iir_response (const HalfBandIirDesign &design, double frequency) noexcept
	Complex response of design at frequency cycles per sample of the filter's own rate: 1/2 (A(z^2) + z^-1 B(z^2)).
template<typename Coefficient = double>
double	halfband_iir_magnitude_db (const HalfBandIirDesign &design, double frequency) noexcept
	Magnitude of design in dB at frequency (cycles per sample of the filter's own rate).
template<typename Coefficient = double>
double	halfband_iir_group_delay (const HalfBandIirDesign &design, double frequency) noexcept
	Group delay of H(z) in samples of the filter's own rate.
template<typename Coefficient = double>
double	halfband_iir_stopband_db (const HalfBandIirDesign &design) noexcept
	Worst-case (largest) stopband magnitude in dB over [stopband_edge(), 0.5], sampled densely enough to land on every ripple peak of designs up to kHalfBandIirMaxCoefficients.
bool	cascade_is_stable (std::span< const FilterDesign::Coefficients > sos)
	Returns true if every biquad section's poles lie strictly inside the unit circle (i.e.
constexpr bool	lfo_wave_is_periodic (LfoWave wave) noexcept
	True for the waves that are periodic functions of phase (everything but the two random waves).
double	lfo_wave (LfoWave wave, double phase, const LfoShapeParams &params={}) noexcept
	The trivial value of wave at phase (any real number of cycles), in [-1, 1].
double	lfo_wave_integral (LfoWave wave, double phase, const LfoShapeParams &params={}) noexcept
	The cumulative integral of wave from phase 0 to phase, in value x cycles.
double	lfo_wave_mean (LfoWave wave, double from, double to, const LfoShapeParams &params={}) noexcept
	The exact mean of wave over the phase interval [from, to], in any units of whole cycles and of any length: the band-limited value for a consumer that takes one value per interval.
double	lfo_wave_bandlimited (LfoWave wave, double phase, double increment, const LfoShapeParams &params={}) noexcept
	The band-limited value of wave for a consumer that reads it EVERY sample, at phase with a per-sample phase step of increment (cycles).
double	quantize_bits (double x, double bits)
	Quantises to bits of resolution, mid-tread, symmetric about zero.
double	dead_zone_saturate (double x, double dead_zone)
	A dead-zone saturator: a hard gap around zero, then a soft-limited slope.
template<typename Sample = double>
Sample	floor_shape (Sample x, std::type_identity_t< Sample > threshold, FloorCurve curve)
	A noise-floor shaper: silence below threshold, rescaled above it.
double	k_weighting_power (double hz, const pulp::signal::KWeightingCoefficients &k, double sample_rate) noexcept
	|K(f)|^2 for BS.1770 K-weighting at sample_rate, through Pulp's own K-weighting design and biquad response evaluator.
float	clamp_makeup_db_ (double ratio, MakeupLimits limits) noexcept
float	blend_makeup_gain_db (std::span< const std::complex< double > > response, const LegSpectra &s, double mix, MakeupLimits limits) noexcept
	Make-up, dB, for the two-leg model in the file comment: response is the wet leg's complex response per bin, s the legs' spectra on the same grid, mix the wet share.
float	makeup_gain_db (std::span< const double > response_power, std::span< const double > spectrum_power, MakeupLimits limits) noexcept
	The single-leg, real-response form: per-bin power response |H|^2 against a per-bin power spectrum on the same grid.
template<typename WeightFn>
float	band_makeup_gain_db (std::span< const BandPowerGain > bands, WeightFn &&weight, MakeupLimits limits) noexcept
	The single-leg form over bands, each weighted by weight(lo_hz, hi_hz) – the material's energy between two frequencies (SpectrumCdf::weight, or any reference weighting).
template<typename SampleType>
SampleType	determinant (const Matrix< 2, SampleType > &m)
	Determinant of a 2x2 matrix.
template<typename SampleType>
SampleType	determinant (const Matrix< 3, SampleType > &m)
	Determinant of a 3x3 matrix.
Matrix4	translation_matrix (float x, float y, float z)
	4x4 translation matrix
Matrix4	scale_matrix (float sx, float sy, float sz)
	4x4 scale matrix
Matrix4	rotation_x (float radians)
	4x4 rotation around X axis
Matrix4	rotation_y (float radians)
	4x4 rotation around Y axis
Matrix4	rotation_z (float radians)
	4x4 rotation around Z axis
Vec3	transform (const Matrix4 &m, const Vec3 &v)
template<typename SampleType>
void	mid_side_encode (SampleType left, SampleType right, SampleType &mid, SampleType &side) noexcept
	Orthonormal stereo transform.
template<typename SampleType>
void	mid_side_decode (SampleType mid, SampleType side, SampleType &left, SampleType &right) noexcept
template<typename SampleType>
bool	mid_side_encode_block (const SampleType *left, const SampleType *right, SampleType *mid, SampleType *side, std::size_t frames) noexcept
template<typename SampleType>
bool	mid_side_decode_block (const SampleType *mid, const SampleType *side, SampleType *left, SampleType *right, std::size_t frames) noexcept
template<typename SampleType>
SampleType	stereo_width (SampleType left, SampleType right, SampleType width, SampleType &out_left, SampleType &out_right) noexcept
	Mono-safe width built on the orthonormal transform.
float	stage_curve (float p, float curve)
	The shared stage-shaping law:
float	curve_rise (float p, float curve)
	Shape a rising stage: 0 -> 1 over p, with curve in [-1, +1].
float	curve_fall (float p, float curve)
	Shape a falling stage: 1 -> 0 over p.
float	smoothstep (float p)
	Cubic smoothstep, 3t^2 - 2t^3.
float	bi_to_uni (float x)
	Bipolar [-1, 1] to unipolar [0, 1].
float	uni_to_bi (float x)
	Unipolar [0, 1] to bipolar [-1, 1].
template<typename SampleType = float>
void	fill_strike_pulse (std::span< SampleType > dst, SampleType velocity)
	Fill dst with a raised-cosine contact pulse, peak-normalized to velocity.
float	mode_shape_at (const ModalShape &shape, float position)
	Evaluate a mode's shape at a normalized position along the body.
void	fill_ideal_string_shapes (std::span< ModalShape > dst)
	Fill dst with the mode shapes of an ideal string fixed at both ends: dst[i] describes the (i+1)-th transverse mode, phi_m(x) = sin(m*pi*x), whose nodes are at x = k/m.
template<typename SampleType = float>
void	fill_mode_weights (std::span< SampleType > dst, std::span< const ModalShape > shapes, float position)
	Sample every shape in shapes at position, writing phi_m(position) to dst.
void	resolve_modes (const ModalSpec &spec, float strike_position, float pickup_position, std::vector< ModalMode > &out)
	Resolve the spec's modes at a strike/pickup position into out.
std::vector< ModalMode >	resolve_modes (const ModalSpec &spec, float strike_position=0.5f, float pickup_position=0.5f)
	Convenience overload; allocates.
template<typename SampleType>
void	load_modes (const ModalSpec &spec, ModalBankT< SampleType > &bank, std::vector< ModalMode > &scratch, float strike_position=0.5f, float pickup_position=0.5f)
	Resolve the spec at a strike/pickup position and load the result into an already-prepared bank.
template<typename SampleType>
void	prepare_and_load (const ModalSpec &spec, ModalBankT< SampleType > &bank, double sample_rate, float strike_position=0.5f, float pickup_position=0.5f)
	Prepare bank to hold this spec's modes at sample_rate and load them.
bool	validate_modal_spec (const ModalSpec &spec, std::string &error)
	Check a spec's internal consistency.
std::optional< ModalSpec >	parse_modal_spec (std::string_view json, ModalSpecDiagnostics *diagnostics=nullptr)
	Parse a ModalSpec from JSON.
std::string	to_json (const ModalSpec &spec, bool pretty=true)
	Serialize a spec to JSON.
bool	operator== (const ModalSpec &a, const ModalSpec &b)
	Exact equality over every known field.
bool	operator!= (const ModalSpec &a, const ModalSpec &b)
ModulationCurve	sanitize_modulation_curve (ModulationCurve curve) noexcept
template<typename SampleType>
SampleType	modulation_curve_progress (SampleType progress, ModulationCurve curve, bool rising) noexcept
template<typename SampleType, typename ProgressType>
SampleType	interpolate_modulation_curve (SampleType start, SampleType end, ProgressType progress, ModulationCurve curve={}) noexcept
constexpr MeterFeatures	operator| (MeterFeatures a, MeterFeatures b) noexcept
constexpr bool	has_feature (MeterFeatures set, MeterFeatures feature) noexcept
KWeightingCoefficients	k_weighting_coefficients (double sample_rate)
	Return the two-stage K-weighting design for a sample rate.
template<typename SampleType>
bool	nway_constant_power_gains (SampleType position, std::span< SampleType > gains) noexcept
	Compute adjacent-path constant-power weights for a position in [0, N-1].
long	offline_stretch_output_frames (long in_frames, double time_ratio) noexcept
	The exact, sample-accurate output length for an input of in_frames frames at the given time ratio: round(in_frames * time_ratio).
template<typename SampleType = float>
std::optional< PreparedParallelDynamicsConfigT< SampleType > >	prepare_parallel_dynamics_config (const ParallelDynamicsConfigT< SampleType > &config, std::size_t max_latency_samples) noexcept
	Validate a complete control snapshot and derive its audio-rate gains.
ProcessingSwitchPlan	plan_processing_switch (std::int64_t incoming_latency, std::int64_t incoming_history, double sample_rate, double fade_seconds) noexcept
	The plan for switching INTO a realisation with incoming_latency samples of delay that needs incoming_history samples of input before its output is steady (an FIR's length; zero for a realisation that primes its own stream start).
template<typename SampleType = float>
void	processing_switch_gains_at (const ProcessingSwitchPlan &plan, std::int64_t position, SampleType &outgoing, SampleType &incoming) noexcept
	Gains for the outgoing and incoming outputs at absolute position samples into a switch following plan.
template<typename SampleType>
PitchTimePrepareStatus	checked_realtime_pitch_time_prepared_geometry (const RealtimePitchTimeConfig &config, double max_pitch_ratio, std::uint64_t requested_max_bytes, RealtimePitchTimePreparedGeometry< SampleType > &prepared) noexcept
	Derive all processor geometry and compose the retained-storage contracts of its owned DSP primitives without changing processor state.
constexpr std::uint64_t	mix64 (std::uint64_t z)
	splitmix64 finalizer (Steele, Lea & Flood, OOPSLA 2014).
constexpr std::uint64_t	mix64 (std::uint64_t seed, std::uint64_t index, std::uint64_t field=0u)
	Purpose-keyed overload used when seed, index, and field are already separate values.
float	unit_from (std::uint64_t key)
	Stateless purpose-keyed draw in [0, 1).
template<typename T>
T	unit_from (std::uint64_t key)
template<typename T = float>
T	bipolar_from (std::uint64_t key)
constexpr std::uint64_t	rng_key (std::uint64_t purpose, std::uint64_t index)
	Combine a purpose tag and an index into a key for unit_from().
double	adaa_linear_magnitude (int order, double cycles_per_sample) noexcept
	The linear-path magnitude response of order-th-order antiderivative antialiasing (1 or 2) at cycles_per_sample (0 … 0.5).
bool	denormals_are_flushed () noexcept
bool	source_filter_fft_size_valid (int fft_size) noexcept
template<typename SampleType>
AutocorrelationResultT< SampleType >	scaled_autocorrelation (std::span< const SampleType > samples, int order, std::span< SampleType > autocorrelation) noexcept
	Biased autocorrelation of a safely normalized signal.
template<typename SampleType>
LevinsonDurbinResultT< SampleType >	levinson_durbin (std::span< const SampleType > autocorrelation, std::span< SampleType > coefficients, std::span< SampleType > reflection_coefficients, std::span< SampleType > workspace, SampleType rank_tolerance=std::numeric_limits< SampleType >::epsilon() *SampleType{64}) noexcept
	Solves A(z) = 1 + sum(a[k] z^-(k+1)).
template<typename SampleType>
SourceFilterAnalysisStatus	lpc_stability (std::span< const SampleType > coefficients, std::span< SampleType > workspace, SampleType stability_margin=std::numeric_limits< SampleType >::epsilon() *SampleType{64}) noexcept
	Explicit Schur step-down stability test for the A(z) coefficient convention used above.
template<typename SampleType>
SourceFilterAnalysisStatus	all_pole_magnitude_response (std::span< const SampleType > coefficients, SampleType gain, SampleType sample_rate, int fft_size, std::span< SampleType > magnitude, std::span< SampleType > stability_workspace, SampleType stability_margin=std::numeric_limits< SampleType >::epsilon() *SampleType{64}, SampleType denominator_floor=std::numeric_limits< SampleType >::epsilon() *SampleType{64}) noexcept
	Evaluates gain / |A(e^jw)| at fft_size / 2 + 1 bins from DC through Nyquist.
float	sinc (float x)
	Sinc function: sin(pi*x) / (pi*x), with sinc(0) = 1.
float	bessel_i0 (float x)
	Modified Bessel function of the first kind, order 0 Used in Kaiser window design.
float	gamma_fn (float x)
	Gamma function approximation (Stirling's for large x, series for small).
float	erf_fn (float x)
	Error function.
float	erfc_fn (float x)
	Complementary error function.
float	lanczos (float x, int a)
	Lanczos kernel (used in high-quality resampling).
float	db_to_linear (float db)
	dB to linear gain conversion
float	linear_to_db (float linear)
	Linear gain to dB conversion.
float	freq_to_midi (float freq)
	Frequency to MIDI note number (A4 = 69).
float	midi_to_freq (float note)
	MIDI note number to frequency.
template<typename SampleType>
bool	analyze_spectral_band_resolution (const SpectralBandLayoutT< SampleType > &layout, int fft_size, SampleType sample_rate, SpectralBandResolutionT< SampleType > &out_resolution) noexcept
	Report the number of discrete FFT bin centers directly owned by each band.
template<typename SampleType>
bool	build_spectral_mask (const SpectralBandLayoutT< SampleType > &layout, int fft_size, SampleType sample_rate, SpectralMaskTableT< SampleType > &out_table) noexcept
	Compile a complete positive-frequency gain table.
template<typename SampleType>
bool	apply_spectral_mask (std::complex< SampleType > *const *frames, int channels, int num_bins, const SpectralMaskTableT< SampleType > &table) noexcept
	Multiply one coherent positive-frequency frame group by a prepared mask.
template<typename SampleType>
std::optional< SpectralDelayMatrixGeometry< SampleType > >	checked_spectral_delay_matrix_geometry (const SpectralDelayMatrixConfig &config, std::uint64_t target_max_bytes=kTargetAddressMaximumBytes) noexcept
bool	compile_spectral_delay_matrix_table (const SpectralDelayMatrixRecipe &recipe, int num_bins, int analysis_hop, double sample_rate, int maximum_delay_frames, SpectralDelayMatrixTable &out_table)
SpectralCodecResult< OwnedSpectralStream >	make_spectral_stream (SpectralStreamGeometry g, std::uint64_t count, std::uint64_t budget=spectral_codec_memory_budget) noexcept
	Allocate an editable owned stream with canonical chronology and zero bins.
SpectralCodecResult< OwnedSpectralStream >	decode_spectral_stream (std::span< const std::uint8_t > bytes, std::uint64_t budget=spectral_codec_memory_budget) noexcept
	Validate the whole input before allocating; no partial stream is returned.
SpectralCodecResult< EncodedSpectralStream >	encode_spectral_stream (const OwnedSpectralStream &in, std::uint64_t budget=spectral_codec_memory_budget) noexcept
	Canonicalize signed bin zeros without mutating the caller. Offline only.
bool	is_valid_spectral_frame_geometry (int fft_size, int analysis_hop) noexcept
constexpr std::int64_t	spectral_frame_engine_first_frame_start (int fft_size, int analysis_hop, bool full_overlap_stream_start) noexcept
	Stream position of the first analysis frame after prepare()/reset().
template<typename SampleType>
double	spectral_ola_window_energy (const SampleType *window, int fft_size, int hop, std::int64_t first_frame_start, std::int64_t position) noexcept
	Accumulated squared synthesis window at stream position for equal-hop frames of length fft_size starting at first_frame_start + k * hop (k >= 0) — the per-sample divisor the WOLA path normalizes by.
template<typename SampleType>
std::optional< SpectralFrameEngineGeometry >	checked_spectral_frame_engine_geometry (const SpectralFrameEngineConfig &config, std::uint64_t target_max_bytes=kTargetAddressMaximumBytes) noexcept
	Derive every integer and typed backing-store capacity used by prepare().
const char *	to_string (StretchCharacter c)
bool	character_from_string (const std::string &s, StretchCharacter &out)
StretchPreset	capture_preset (const OfflineStretchOptions &o, const std::string &name="untitled")
	Capture the preset-relevant fields FROM a configured OfflineStretchOptions.
void	apply_preset (OfflineStretchOptions &o, const StretchPreset &p)
	Apply a preset to options (only the preset-managed fields; ratio/pitch are the caller's, not the preset's).
std::string	preset_to_text (const StretchPreset &p)
bool	preset_from_text (const std::string &text, StretchPreset &out, std::string *err=nullptr)
	Parse a preset.
TempoDelayResult	tempo_delay_samples (timebase::BeatDivision division, double beats_per_minute, double sample_rate) noexcept
	Convert an exact persisted musical division to a fractional delay length.
template<typename SampleType = float, std::size_t MaxPoints = 32>
std::optional< PreparedTransferCurveT< SampleType, MaxPoints > >	prepare_transfer_curve (std::span< const TransferCurvePointT< SampleType > > points, SampleType input_min, SampleType input_max, SampleType output_min, SampleType output_max) noexcept
	Validate and prepare a piecewise transfer curve.
template<typename SampleType, std::size_t MaxPoints>
SampleType	evaluate_transfer_curve (const PreparedTransferCurveT< SampleType, MaxPoints > &curve, SampleType input) noexcept
	Evaluate a prepared curve.
template<class Mixer, class OutView, class OldView>
bool	blend_fade_out (Mixer &mixer, OutView &out, const OldView &old_render) noexcept
	Blend an already-rendered fading-out buffer into the live output under a TransitionMixer's old->new gains, then advance the mixer by the block.
template<typename SampleType = double>
VelvetNoiseDrawT< SampleType >	velvet_noise_draw (std::uint64_t seed, std::uint64_t index) noexcept
	Pure draw for one velvet grid cell.
template<typename SampleType>
int	velvet_noise_offset (const VelvetNoiseDrawT< SampleType > &draw, SampleType grid_samples) noexcept
	Converts a grid draw to its zero-based sample offset.
double	bessel_i0 (double x)
double	kaiser_beta_for_stopband (double stopband_db)
std::size_t	kaiser_length_for_transition (double stopband_db, double normalized_width)
void	kaiser_window (std::vector< double > &output, double beta)
std::vector< double >	design_windowed_sinc (std::size_t taps, double cutoff, double beta)

Variables
constexpr std::uint64_t	kTargetAddressMaximumBytes
constexpr CyclicStretchRegime	kCyclicStretchShortFrame {200.0, 1, 45.0, 1.0}
	"Clean-ish short frame" — one cycle per grain, a generous equal-power splice, cycle_hz meant to be tuned to the material's fundamental.
constexpr CyclicStretchRegime	kCyclicStretchLongFrame {200.0, 8, 8.0, 0.0}
	"Glitchy long frame" — tens of milliseconds per grain, a short linear splice, cycle_hz left wherever it happens to be.
constexpr bool	kSubnormalsAreFree
	Whether subnormal arithmetic runs at full speed on this target.
constexpr std::size_t	kSnapChunkSamples = 64
	Samples a block path runs between denormal snaps of its recursive state.
constexpr LadderSaturation	kDefaultLadderSaturation = LadderSaturation::accurate
	Selecting the default ladder saturator at build time:
constexpr std::uint64_t	kVdspFftSetupChargeBytesPerPoint = 64
	Conservative policy charge for Accelerate's opaque float FFT setup.
constexpr std::uint64_t	kVdspSplitPaddingFloats = 84
	Floats a float FftT's vDSP split buffer holds beyond its two N-point halves: up to 15 to reach a 64-byte boundary, a 4-float (16-byte) step off it, and a 64-float (256-byte) gap between the halves, which is how their placement is pinned (see FftT).
constexpr std::uint64_t	kDefaultFirDesignWorkspaceBytes = 256u * 1024u * 1024u
constexpr std::size_t	kMaximumFirDesignTapCount = 1023u
constexpr std::size_t	kMaximumFirDesignPointCount = 65536u
constexpr std::size_t	kMaximumMinimumPhaseFirSize = 65536u
	Largest admitted radix-2 FFT size for minimum-phase reconstruction.
constexpr float	min_response_db = -200.0f
	Floor applied to dB conversions.
constexpr std::size_t	kHalfBandIirMaxCoefficients = 16
	Largest coefficient count a HalfBandIirDesign carries (eight sections per path).
constexpr double	kHalfBandIirMinPassbandEdge = 1e-4
	Smallest passband edge design_halfband_iir() accepts, in cycles per sample at the filter's own rate.
constexpr std::array< float, 3 >	kDefaultCoefficientsA
	Default half-band design: design_halfband_iir(6, 0.21), path A.
constexpr std::array< float, 3 >	kDefaultCoefficientsB
	Default half-band design, path B. See kDefaultCoefficientsA.
constexpr int	kScaleCount = 10
	Number of entries in the shipped scale table.
constexpr std::uint16_t	kScaleTable [kScaleCount]
	Pitch-class masks, bit k set ⇒ semitone k above the root is in the scale.
constexpr float	kCurveSpan = 8.0f
	Curve span for the shared stage-shaping law.
constexpr int	kModalSpecSchemaVersion = 1
	Schema version this build writes and is the highest it can read.
static constexpr int	kMaxMeterChannels = 16
	Maximum supported channel count for metering.
static constexpr double	kMaxMeterInputMagnitude = 1.0e6
	Finite samples outside this deliberately generous audio-domain ceiling are clipped before every peak, RMS, correlation, and loudness calculation.
constexpr std::size_t	kHouseHalfBandTaps = 65
	Pulp's low-latency linear-phase half-band design.
constexpr double	kHouseHalfBandStopbandDb = 81.3
constexpr double	kHouseHalfBandStageOnePassband = 0.45
constexpr double	kHouseHalfBandStageTwoPassband = 0.225
constexpr int	kRealtimePitchTimeMaximumChannels = 64
constexpr std::uint64_t	kGoldenGamma = 0x9E3779B97F4A7C15ull
	The 64-bit golden-ratio odd constant that splitmix64 steps its state by.
constexpr bool	kHardwareFlushSupported = false
	True when this build sets the hardware flush-to-zero mode.
static constexpr size_t	kSimdAlignment = 64
	Alignment in bytes for SIMD operations (covers AVX-512).
constexpr int	kSourceFilterMinimumFftSize = 256
constexpr int	kSourceFilterMaximumFftSize = 1 << 20
constexpr int	kSourceFilterMaximumLpcOrder = 256
constexpr int	kSourceFilterMaximumEnvelopeIterations = 1024
constexpr std::size_t	kSpectralBandMaskMaximumBands = 64
constexpr std::size_t	kSpectralBandMaskMaximumBins
constexpr std::uint32_t	kSpectralBandMaskMaximumTransitionFrames = 4096
constexpr std::size_t	kSpectralDelayMinimumRetainedBytes = std::size_t{1} << 20u
constexpr std::size_t	kSpectralDelayMaximumRetainedBytes = std::size_t{1} << 29u
constexpr std::uint64_t	spectral_codec_memory_budget = 128ULL * 1024 * 1024
constexpr int	kSpectralFrameEngineMinimumFftSize = 256
constexpr int	kSpectralFrameEngineMaximumFftSize = 16384
constexpr std::uint64_t	kSpectralFrameEngineMaximumRingSize
constexpr std::uint64_t	kSpectralMaskProcessorDefaultMaximumRetainedBytes
constexpr double	kMinimumTempoDelayBpm = timebase::kMinimumCompiledTempoBpm
	These bounds intentionally match TempoMap / CompiledTempoMap: a delay synchronized to a transport must accept exactly the tempo and sample-rate domain that the transport can compile.
constexpr double	kMaximumTempoDelayBpm = timebase::kMaximumCompiledTempoBpm
constexpr double	kMaximumTempoDelaySampleRate
constexpr double	kTriggerHighThreshold = 0.5
constexpr double	kTriggerLowThreshold = 0.25

Typedef Documentation

Ad

using pulp::signal::Ad = AdT<float>

Ad64

using pulp::signal::Ad64 = AdT<double>

AdditiveBank

using pulp::signal::AdditiveBank = AdditiveBankT<float>

AdditiveBank64

using pulp::signal::AdditiveBank64 = AdditiveBankT<double>

Adsr

using pulp::signal::Adsr = AdsrT<float>

Adsr64

using pulp::signal::Adsr64 = AdsrT<double>

Ahd

using pulp::signal::Ahd = AhdT<float>

Ahd64

using pulp::signal::Ahd64 = AhdT<double>

AlignedBuffer

using pulp::signal::AlignedBuffer = AlignedBufferT<float>

AlignedBuffer64

using pulp::signal::AlignedBuffer64 = AlignedBufferT<double>

AnalogVcf

using pulp::signal::AnalogVcf = AnalogVcfT<float>

Single-precision measured analog VCF.

AnalogVcf64

using pulp::signal::AnalogVcf64 = AnalogVcfT<double>

Double-precision measured analog VCF.

Ar

using pulp::signal::Ar = ArT<float>

Ar64

using pulp::signal::Ar64 = ArT<double>

Attenuverter

using pulp::signal::Attenuverter = AttenuverterT<float>

Attenuverter64

using pulp::signal::Attenuverter64 = AttenuverterT<double>

AudioMatrixMixer

using pulp::signal::AudioMatrixMixer = AudioMatrixMixerT<float>

AudioMatrixMixer64

using pulp::signal::AudioMatrixMixer64 = AudioMatrixMixerT<double>

AutoDuckedSend

using pulp::signal::AutoDuckedSend = AutoDuckedSendT<float>

AutoDuckedSend64

using pulp::signal::AutoDuckedSend64 = AutoDuckedSendT<double>

BallisticsFilter

using pulp::signal::BallisticsFilter = BallisticsFilterT<float>

BallisticsFilter64

using pulp::signal::BallisticsFilter64 = BallisticsFilterT<double>

BeatRepeatKernel

using pulp::signal::BeatRepeatKernel = BeatRepeatKernelT<float>

BeatRepeatKernel64

using pulp::signal::BeatRepeatKernel64 = BeatRepeatKernelT<double>

Bias

using pulp::signal::Bias = BiasT<float>

Bias64

using pulp::signal::Bias64 = BiasT<double>

Biquad

using pulp::signal::Biquad = BiquadT<float>

Biquad64

using pulp::signal::Biquad64 = BiquadT<double>

BiquadCoefficients

using pulp::signal::BiquadCoefficients = BiquadCoefficientsT<float>

BlitOscillator

using pulp::signal::BlitOscillator = BlitOscillatorT<float>

BlitOscillator64

using pulp::signal::BlitOscillator64 = BlitOscillatorT<double>

BreakpointEnvelope

using pulp::signal::BreakpointEnvelope = BreakpointEnvelopeT<float>

BreakpointEnvelope64

using pulp::signal::BreakpointEnvelope64 = BreakpointEnvelopeT<double>

BreakpointEnvelopePoint

using pulp::signal::BreakpointEnvelopePoint = BreakpointEnvelopePointT<float>

BreakpointEnvelopePoint64

using pulp::signal::BreakpointEnvelopePoint64 = BreakpointEnvelopePointT<double>

BurstGen

using pulp::signal::BurstGen = BurstGenT<float>

BurstGen64

using pulp::signal::BurstGen64 = BurstGenT<double>

CartesianWalk

using pulp::signal::CartesianWalk = CartesianWalkT<float>

CartesianWalk64

using pulp::signal::CartesianWalk64 = CartesianWalkT<double>

CepstralEnvelopeAnalyzer

using pulp::signal::CepstralEnvelopeAnalyzer = CepstralEnvelopeAnalyzerT<float>

CepstralEnvelopeAnalyzer64

using pulp::signal::CepstralEnvelopeAnalyzer64 = CepstralEnvelopeAnalyzerT<double>

CepstralEnvelopeConfig

using pulp::signal::CepstralEnvelopeConfig = CepstralEnvelopeConfigT<float>

CepstralEnvelopeConfig64

using pulp::signal::CepstralEnvelopeConfig64 = CepstralEnvelopeConfigT<double>

CharacterDelay

using pulp::signal::CharacterDelay = CharacterDelayT<float>

ChebyshevHarmonicShaper

using pulp::signal::ChebyshevHarmonicShaper = ChebyshevHarmonicShaperT<float>

ChebyshevHarmonicShaper64

using pulp::signal::ChebyshevHarmonicShaper64 = ChebyshevHarmonicShaperT<double>

Chorus

using pulp::signal::Chorus = ChorusT<float>

Chorus64

using pulp::signal::Chorus64 = ChorusT<double>

ChorusEnsemble

using pulp::signal::ChorusEnsemble = ChorusEnsembleT<float>

ChorusEnsemble64

using pulp::signal::ChorusEnsemble64 = ChorusEnsembleT<double>

ChromaFrontEnd

using pulp::signal::ChromaFrontEnd = ChromaFrontEndT<float>

ChromaFrontEnd64

using pulp::signal::ChromaFrontEnd64 = ChromaFrontEndT<double>

ClassicReverb

using pulp::signal::ClassicReverb = ClassicReverbT<float>

ClickFreePathSwitcher

using pulp::signal::ClickFreePathSwitcher = ClickFreePathSwitcherT<float>

ClickFreePathSwitcher64

using pulp::signal::ClickFreePathSwitcher64 = ClickFreePathSwitcherT<double>

ClockDivider

using pulp::signal::ClockDivider = ClockDividerT<float>

ClockDivider64

using pulp::signal::ClockDivider64 = ClockDividerT<double>

ClockMult

using pulp::signal::ClockMult = ClockMultT

Backward-compatible name for the already-decoded event adapter.

ClockMult64

using pulp::signal::ClockMult64 = ClockMultT

CombFilter

using pulp::signal::CombFilter = CombFilterT<float>

CombFilter64

using pulp::signal::CombFilter64 = CombFilterT<double>

CommutedStringExcitationCursor

using pulp::signal::CommutedStringExcitationCursor = CommutedStringExcitationCursorT<float>

CommutedStringExcitationCursor64

using pulp::signal::CommutedStringExcitationCursor64 = CommutedStringExcitationCursorT<double>

CommutedStringExcitationProfile

using pulp::signal::CommutedStringExcitationProfile = CommutedStringExcitationProfileT<float>

CommutedStringExcitationProfile64

using pulp::signal::CommutedStringExcitationProfile64 = CommutedStringExcitationProfileT<double>

Comparator

using pulp::signal::Comparator = ComparatorT<float>

Comparator64

using pulp::signal::Comparator64 = ComparatorT<double>

Compressor

using pulp::signal::Compressor = CompressorT<float>

Compressor64

using pulp::signal::Compressor64 = CompressorT<double>

ConstantTimeSlewLimiter

using pulp::signal::ConstantTimeSlewLimiter = ConstantTimeSlewLimiterT<float>

ConstantTimeSlewLimiter64

using pulp::signal::ConstantTimeSlewLimiter64 = ConstantTimeSlewLimiterT<double>

Convolver

using pulp::signal::Convolver = ConvolverT<float>

Convolver64

using pulp::signal::Convolver64 = ConvolverT<double>

ConvolverInputHistory

using pulp::signal::ConvolverInputHistory = ConvolverInputHistoryT<float>

ConvolverInputHistory64

using pulp::signal::ConvolverInputHistory64 = ConvolverInputHistoryT<double>

ConvolverIrState

using pulp::signal::ConvolverIrState = ConvolverIrStateT<float>

ConvolverIrState64

using pulp::signal::ConvolverIrState64 = ConvolverIrStateT<double>

ConvolverIrSwapper

using pulp::signal::ConvolverIrSwapper = ConvolverIrSwapperT<float>

ConvolverIrSwapper64

using pulp::signal::ConvolverIrSwapper64 = ConvolverIrSwapperT<double>

CrossFeedbackMultitapDelay

using pulp::signal::CrossFeedbackMultitapDelay = CrossFeedbackMultitapDelayT<float>

CrossFeedbackMultitapDelay64

using pulp::signal::CrossFeedbackMultitapDelay64 = CrossFeedbackMultitapDelayT<double>

Curve

using pulp::signal::Curve = CurveT<float>

Curve64

using pulp::signal::Curve64 = CurveT<double>

CyclicStretch

using pulp::signal::CyclicStretch = CyclicStretchT<float>

CyclicStretch64

using pulp::signal::CyclicStretch64 = CyclicStretchT<double>

Dahdsr

using pulp::signal::Dahdsr = DahdsrT<float>

Dahdsr64

using pulp::signal::Dahdsr64 = DahdsrT<double>

DecayEnvelope

using pulp::signal::DecayEnvelope = DecayEnvelopeT<float>

DecayEnvelope64

using pulp::signal::DecayEnvelope64 = DecayEnvelopeT<double>

DeEsser

using pulp::signal::DeEsser = DeEsserT<float>

DeEsser64

using pulp::signal::DeEsser64 = DeEsserT<double>

DelayLine

using pulp::signal::DelayLine = DelayLineT<float>

DelayLine64

using pulp::signal::DelayLine64 = DelayLineT<double>

DelayVibrato

using pulp::signal::DelayVibrato = DelayVibratoT<float>

DelayVibrato64

using pulp::signal::DelayVibrato64 = DelayVibratoT<double>

DiatonicMap

using pulp::signal::DiatonicMap = DiatonicMapT<float>

DiatonicMap64

using pulp::signal::DiatonicMap64 = DiatonicMapT<double>

DiffusionNetwork

using pulp::signal::DiffusionNetwork = DiffusionNetworkT<float>

DiffusionNetwork64

using pulp::signal::DiffusionNetwork64 = DiffusionNetworkT<double>

DiodeBridgeCompressor

using pulp::signal::DiodeBridgeCompressor = DiodeBridgeCompressorT<float>

DiodeBridgeCompressor64

using pulp::signal::DiodeBridgeCompressor64 = DiodeBridgeCompressorT<double>

DiodeBridgeGain

using pulp::signal::DiodeBridgeGain = DiodeBridgeGainT<float>

DiodeBridgeGain64

using pulp::signal::DiodeBridgeGain64 = DiodeBridgeGainT<double>

DiodeClipper

using pulp::signal::DiodeClipper = DiodeClipperT<float>

DiodeClipper64

using pulp::signal::DiodeClipper64 = DiodeClipperT<double>

DitherQuantizer

using pulp::signal::DitherQuantizer = DitherQuantizerT<float>

DitherQuantizer64

using pulp::signal::DitherQuantizer64 = DitherQuantizerT<double>

Drift

using pulp::signal::Drift = DriftT<float>

Drift64

using pulp::signal::Drift64 = DriftT<double>

DryWetMixer

using pulp::signal::DryWetMixer = DryWetMixerT<float>

DryWetMixer64

using pulp::signal::DryWetMixer64 = DryWetMixerT<double>

Dust

using pulp::signal::Dust = DustT<float>

Dust64

using pulp::signal::Dust64 = DustT<double>

DynamicEqBand

using pulp::signal::DynamicEqBand = DynamicEqBandT<float>

DynamicEqBand64

using pulp::signal::DynamicEqBand64 = DynamicEqBandT<double>

EarlyReflections

using pulp::signal::EarlyReflections = EarlyReflectionsT<float>

EarlyReflections64

using pulp::signal::EarlyReflections64 = EarlyReflectionsT<double>

EffectLfo

using pulp::signal::EffectLfo = EffectLfoT<float>

EffectLfo64

using pulp::signal::EffectLfo64 = EffectLfoT<double>

EnvelopeFollower

using pulp::signal::EnvelopeFollower = EnvelopeFollowerT<float>

EnvelopeFollower64

using pulp::signal::EnvelopeFollower64 = EnvelopeFollowerT<double>

EventClockMult

using pulp::signal::EventClockMult = ClockMultT

EventClockMult64

using pulp::signal::EventClockMult64 = ClockMultT

Expander

using pulp::signal::Expander = ExpanderT<float>

Expander64

using pulp::signal::Expander64 = ExpanderT<double>

ExplicitQResonatorBank

using pulp::signal::ExplicitQResonatorBank = ExplicitQResonatorBankT<float>

ExplicitQResonatorBank64

using pulp::signal::ExplicitQResonatorBank64 = ExplicitQResonatorBankT<double>

FdnReverb

using pulp::signal::FdnReverb = FdnReverbT<float>

FeedbackClipper

using pulp::signal::FeedbackClipper = FeedbackClipperT<float>

FeedbackClipper64

using pulp::signal::FeedbackClipper64 = FeedbackClipperT<double>

FeedbackLoopProcessor

using pulp::signal::FeedbackLoopProcessor = FeedbackLoopProcessorT<float>

FeedbackLoopProcessor64

using pulp::signal::FeedbackLoopProcessor64 = FeedbackLoopProcessorT<double>

FeedforwardCompressor

using pulp::signal::FeedforwardCompressor = FeedforwardCompressorT<float>

FeedforwardCompressor64

using pulp::signal::FeedforwardCompressor64 = FeedforwardCompressorT<double>

FetCompressor

using pulp::signal::FetCompressor = FetCompressorT<float>

FetCompressor64

using pulp::signal::FetCompressor64 = FetCompressorT<double>

Fft

using pulp::signal::Fft = FftT<float>

Fft64

using pulp::signal::Fft64 = FftT<double>

FilterMorph

using pulp::signal::FilterMorph = FilterMorphT<float>

FilterMorph64

using pulp::signal::FilterMorph64 = FilterMorphT<double>

FiniteStretchBuilder

using pulp::signal::FiniteStretchBuilder = FiniteStretchBuilderT<float>

FiniteStretchBuilder64

using pulp::signal::FiniteStretchBuilder64 = FiniteStretchBuilderT<double>

FiniteStretchConfig

using pulp::signal::FiniteStretchConfig = FiniteStretchConfigT<float>

FiniteStretchConfig64

using pulp::signal::FiniteStretchConfig64 = FiniteStretchConfigT<double>

FiniteStretchRatioAtInputFrame

using pulp::signal::FiniteStretchRatioAtInputFrame

Initial value:

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

Called for the analysis frame ending at input_frame.

Positions after EOF are clamped to the finite input length, so finalization holds the endpoint ratio. The callback must be allocation-free and noexcept.

FirFilter

using pulp::signal::FirFilter = FirFilterT<float>

FirFilter64

using pulp::signal::FirFilter64 = FirFilterT<double>

FixedIrConvolver

using pulp::signal::FixedIrConvolver = FixedIrConvolverT<float>

FixedIrConvolver64

using pulp::signal::FixedIrConvolver64 = FixedIrConvolverT<double>

Flanger

using pulp::signal::Flanger = FlangerT<float>

Flanger64

using pulp::signal::Flanger64 = FlangerT<double>

FmOperatorEngine

using pulp::signal::FmOperatorEngine = FmOperatorEngineT<float>

FmOperatorEngine64

using pulp::signal::FmOperatorEngine64 = FmOperatorEngineT<double>

FmOperatorRouting

using pulp::signal::FmOperatorRouting = FmOperatorRoutingT<float>

FmOperatorRouting64

using pulp::signal::FmOperatorRouting64 = FmOperatorRoutingT<double>

FormantFilterBank

using pulp::signal::FormantFilterBank = FormantFilterBankT<float>

FormantFilterBank64

using pulp::signal::FormantFilterBank64 = FormantFilterBankT<double>

FractionalDelayHistory

using pulp::signal::FractionalDelayHistory = FractionalDelayHistoryT<float>

FractionalDelayHistory64

using pulp::signal::FractionalDelayHistory64 = FractionalDelayHistoryT<double>

FractionalDelayLine

using pulp::signal::FractionalDelayLine = FractionalDelayLineT<float>

FractionalDelayLine64

using pulp::signal::FractionalDelayLine64 = FractionalDelayLineT<double>

FreezeHold

using pulp::signal::FreezeHold = FreezeHoldT<float>

FreezeHold64

using pulp::signal::FreezeHold64 = FreezeHoldT<double>

FreezeHoldSnapshot

using pulp::signal::FreezeHoldSnapshot = FreezeHoldSnapshotT<float>

FreezeHoldSnapshot64

using pulp::signal::FreezeHoldSnapshot64 = FreezeHoldSnapshotT<double>

FreezeLoopSampler

using pulp::signal::FreezeLoopSampler = FreezeLoopSamplerT<float>

FreezeLoopSampler64

using pulp::signal::FreezeLoopSampler64 = FreezeLoopSamplerT<double>

FrequencyShifter

using pulp::signal::FrequencyShifter = FrequencyShifterT<float>

FrequencyShifter64

using pulp::signal::FrequencyShifter64 = FrequencyShifterT<double>

FuzzPair

using pulp::signal::FuzzPair = FuzzPairT<float>

FuzzPair64

using pulp::signal::FuzzPair64 = FuzzPairT<double>

Gain

using pulp::signal::Gain = GainT<float>

Gain64

using pulp::signal::Gain64 = GainT<double>

GateGen

using pulp::signal::GateGen = GateGenT<float>

GateGen64

using pulp::signal::GateGen64 = GateGenT<double>

GateLogic

using pulp::signal::GateLogic = GateLogicT<float>

GateLogic64

using pulp::signal::GateLogic64 = GateLogicT<double>

GranularEngine

using pulp::signal::GranularEngine = GranularEngineT<float>

GranularEngine64

using pulp::signal::GranularEngine64 = GranularEngineT<double>

GraphicEq

using pulp::signal::GraphicEq = GraphicEqT<float>

GraphicEq64

using pulp::signal::GraphicEq64 = GraphicEqT<double>

GraphicEqBand

using pulp::signal::GraphicEqBand = GraphicEqBandT<float>

HalfBandAllpassSection

using pulp::signal::HalfBandAllpassSection = HalfBandAllpassSectionT<float>

HalfBandAllpassSection64

using pulp::signal::HalfBandAllpassSection64 = HalfBandAllpassSectionT<double>

HalfBandDownsampler2x

using pulp::signal::HalfBandDownsampler2x = HalfBandDownsampler2xT<float>

HalfBandDownsampler2x64

using pulp::signal::HalfBandDownsampler2x64 = HalfBandDownsampler2xT<double>

HalfBandIirStage

using pulp::signal::HalfBandIirStage = HalfBandIirStageT<float>

HalfBandIirStage64

using pulp::signal::HalfBandIirStage64 = HalfBandIirStageT<double>

HalfBandUpsampler2x

using pulp::signal::HalfBandUpsampler2x = HalfBandUpsampler2xT<float>

HalfBandUpsampler2x64

using pulp::signal::HalfBandUpsampler2x64 = HalfBandUpsampler2xT<double>

HarmonyEngine

using pulp::signal::HarmonyEngine = HarmonyEngineT<float>

HarmonyEngine64

using pulp::signal::HarmonyEngine64 = HarmonyEngineT<double>

HeadphoneCrossfeed

using pulp::signal::HeadphoneCrossfeed = HeadphoneCrossfeedT<float>

HeadphoneCrossfeed64

using pulp::signal::HeadphoneCrossfeed64 = HeadphoneCrossfeedT<double>

HilbertPair

using pulp::signal::HilbertPair = HilbertPairT<double>

HilbertPairT

template<typename SampleType = double>

using pulp::signal::HilbertPairT = HilbertQuadratureNetworkT<SampleType>

A pair of allpass chains whose outputs stand a quarter cycle apart across the audio band — the analytic-signal splitter, spelled the way this header has always spelled it.

See HilbertQuadratureNetworkT for the structure, the coefficient table, and why only one of the four I/Q assignments both holds phase across the band and leaves the in-phase branch undelayed.

HilbertQuadratureNetwork

using pulp::signal::HilbertQuadratureNetwork = HilbertQuadratureNetworkT<double>

HystereticTriggerDetect

using pulp::signal::HystereticTriggerDetect = HystereticTriggerDetectT<float>

HystereticTriggerDetect64

using pulp::signal::HystereticTriggerDetect64 = HystereticTriggerDetectT<double>

IndexedControl

using pulp::signal::IndexedControl = IndexedControlT<float>

IndexedControl64

using pulp::signal::IndexedControl64 = IndexedControlT<double>

KarplusStrong

using pulp::signal::KarplusStrong = KarplusStrongT<float>

KarplusStrong64

using pulp::signal::KarplusStrong64 = KarplusStrongT<double>

LadderBank

template<std::size_t Voices = 16>

using pulp::signal::LadderBank = LadderBankT<float, Voices>

LadderFilter

using pulp::signal::LadderFilter = LadderFilterT<float>

LadderFilter64

using pulp::signal::LadderFilter64 = LadderFilterT<double>

LeslieRotary

using pulp::signal::LeslieRotary = LeslieRotaryT<float>

LeslieRotary64

using pulp::signal::LeslieRotary64 = LeslieRotaryT<double>

Lfo

using pulp::signal::Lfo = LfoT<float>

Lfo64

using pulp::signal::Lfo64 = LfoT<double>

Lfsr

using pulp::signal::Lfsr = LfsrT<float>

Lfsr64

using pulp::signal::Lfsr64 = LfsrT<double>

Limiter

using pulp::signal::Limiter = LimiterT<float>

Limiter64

using pulp::signal::Limiter64 = LimiterT<double>

LinkwitzRiley

using pulp::signal::LinkwitzRiley = LinkwitzRileyT<float>

LinkwitzRiley64

using pulp::signal::LinkwitzRiley64 = LinkwitzRileyT<double>

LinkwitzRileyCrossover

using pulp::signal::LinkwitzRileyCrossover = LinkwitzRileyCrossoverT<float>

LinkwitzRileyCrossover64

using pulp::signal::LinkwitzRileyCrossover64 = LinkwitzRileyCrossoverT<double>

LofiChain

using pulp::signal::LofiChain = LofiChainT<float>

LofiChain64

using pulp::signal::LofiChain64 = LofiChainT<double>

LogisticMap

using pulp::signal::LogisticMap = LogisticMapT<float>

LogisticMap64

using pulp::signal::LogisticMap64 = LogisticMapT<double>

LogRampedValue

using pulp::signal::LogRampedValue = LogRampedValueT<float>

LogRampedValue64

using pulp::signal::LogRampedValue64 = LogRampedValueT<double>

LookupTable

using pulp::signal::LookupTable = LookupTableT<float>

LookupTable64

using pulp::signal::LookupTable64 = LookupTableT<double>

LowpassGate

using pulp::signal::LowpassGate = LowpassGateT<float>

LowpassGate64

using pulp::signal::LowpassGate64 = LowpassGateT<double>

LpcAnalyzer

using pulp::signal::LpcAnalyzer = LpcAnalyzerT<float>

LpcAnalyzer64

using pulp::signal::LpcAnalyzer64 = LpcAnalyzerT<double>

Lpg

using pulp::signal::Lpg = LpgT<float>

Lpg64

using pulp::signal::Lpg64 = LpgT<double>

MapClip

using pulp::signal::MapClip = MapClipT<float>

MapClip64

using pulp::signal::MapClip64 = MapClipT<double>

Mat2

using pulp::signal::Mat2 = Mat2T<float>

Mat2d

using pulp::signal::Mat2d = Mat2T<double>

Mat3

using pulp::signal::Mat3 = Mat3T<float>

Mat3d

using pulp::signal::Mat3d = Mat3T<double>

Matrix2

using pulp::signal::Matrix2 = Matrix<2>

Matrix2d

using pulp::signal::Matrix2d = Matrix<2, double>

Matrix3

using pulp::signal::Matrix3 = Matrix<3>

Matrix3d

using pulp::signal::Matrix3d = Matrix<3, double>

Matrix4

using pulp::signal::Matrix4 = Matrix<4>

Matrix4d

using pulp::signal::Matrix4d = Matrix<4, double>

ModalBank

using pulp::signal::ModalBank = ModalBankT<float>

ModalBank64

using pulp::signal::ModalBank64 = ModalBankT<double>

ModEnv

using pulp::signal::ModEnv = ModEnvT<float>

ModEnv64

using pulp::signal::ModEnv64 = ModEnvT<double>

ModMatrix

using pulp::signal::ModMatrix = ModMatrixT<32, float>

ModMatrix64

using pulp::signal::ModMatrix64 = ModMatrixT<32, double>

MultiChannelMeter

using pulp::signal::MultiChannelMeter = MultiChannelMeterT<float>

MultiChannelMeter64

using pulp::signal::MultiChannelMeter64 = MultiChannelMeterT<double>

MultichannelPhaseCoordinator

using pulp::signal::MultichannelPhaseCoordinator = MultichannelPhaseCoordinatorT<float>

MultichannelPhaseCoordinator64

using pulp::signal::MultichannelPhaseCoordinator64 = MultichannelPhaseCoordinatorT<double>

MultistageWavefolder

using pulp::signal::MultistageWavefolder = MultistageWavefolderT<float>

MultistageWavefolder64

using pulp::signal::MultistageWavefolder64 = MultistageWavefolderT<double>

NlmsAdaptiveFilter

using pulp::signal::NlmsAdaptiveFilter = NlmsAdaptiveFilterT<float>

NlmsAdaptiveFilter64

using pulp::signal::NlmsAdaptiveFilter64 = NlmsAdaptiveFilterT<double>

NoiseGate

using pulp::signal::NoiseGate = NoiseGateT<float>

NoiseGate64

using pulp::signal::NoiseGate64 = NoiseGateT<double>

NoiseMorpher

using pulp::signal::NoiseMorpher = NoiseMorpherT<float>

NoiseMorpher64

using pulp::signal::NoiseMorpher64 = NoiseMorpherT<double>

NoiseSource

using pulp::signal::NoiseSource = NoiseSourceT<float>

NoiseSource64

using pulp::signal::NoiseSource64 = NoiseSourceT<double>

NoiseTilt

using pulp::signal::NoiseTilt = NoiseTiltT<float>

NoiseTilt64

using pulp::signal::NoiseTilt64 = NoiseTiltT<double>

NonlinAmbience

using pulp::signal::NonlinAmbience = NonlinAmbienceT<float>

NonlinAmbience64

using pulp::signal::NonlinAmbience64 = NonlinAmbienceT<double>

NonlinearRingModulator

using pulp::signal::NonlinearRingModulator = NonlinearRingModulatorT<float>

NonlinearRingModulator64

using pulp::signal::NonlinearRingModulator64 = NonlinearRingModulatorT<double>

NonUniformPartitionedConvolver

using pulp::signal::NonUniformPartitionedConvolver = NonUniformPartitionedConvolverT<float>

NonUniformPartitionedConvolver64

using pulp::signal::NonUniformPartitionedConvolver64 = NonUniformPartitionedConvolverT<double>

OfflineStretch

using pulp::signal::OfflineStretch = OfflineStretchT<float>

OfflineStretch64

using pulp::signal::OfflineStretch64 = OfflineStretchT<double>

OnsetNoveltyFrontEnd

using pulp::signal::OnsetNoveltyFrontEnd = OnsetNoveltyFrontEndT<float>

OnsetNoveltyFrontEnd64

using pulp::signal::OnsetNoveltyFrontEnd64 = OnsetNoveltyFrontEndT<double>

Oscillator

using pulp::signal::Oscillator = OscillatorT<float>

Oscillator64

using pulp::signal::Oscillator64 = OscillatorT<double>

OtaCascadeFilter

using pulp::signal::OtaCascadeFilter = OtaCascadeFilterT<float>

Single-precision sample interface for OtaCascadeFilterT<float>.

OtaCascadeFilter64

using pulp::signal::OtaCascadeFilter64 = OtaCascadeFilterT<double>

Double-precision sample interface for OtaCascadeFilterT<double>.

OuWalk

using pulp::signal::OuWalk = OuWalkT<float>

OuWalk64

using pulp::signal::OuWalk64 = OuWalkT<double>

Oversampler

using pulp::signal::Oversampler = OversamplerT<float>

Oversampler64

using pulp::signal::Oversampler64 = OversamplerT<double>

Panner

using pulp::signal::Panner = PannerT<float>

Panner64

using pulp::signal::Panner64 = PannerT<double>

ParallelDynamicsConfig

using pulp::signal::ParallelDynamicsConfig = ParallelDynamicsConfigT<float>

ParallelDynamicsConfig64

using pulp::signal::ParallelDynamicsConfig64 = ParallelDynamicsConfigT<double>

ParallelDynamicsMixer

using pulp::signal::ParallelDynamicsMixer = ParallelDynamicsMixerT<float>

ParallelDynamicsMixer64

using pulp::signal::ParallelDynamicsMixer64 = ParallelDynamicsMixerT<double>

ParametricEq

using pulp::signal::ParametricEq = ParametricEqT<float>

ParametricEq64

using pulp::signal::ParametricEq64 = ParametricEqT<double>

ParametricEqBand

using pulp::signal::ParametricEqBand = ParametricEqBandT<float>

ParticleCollisionExciter

using pulp::signal::ParticleCollisionExciter = ParticleCollisionExciterT<float>

ParticleCollisionExciter64

using pulp::signal::ParticleCollisionExciter64 = ParticleCollisionExciterT<double>

ParticlePercussionVoice

using pulp::signal::ParticlePercussionVoice = ParticlePercussionVoiceT<float>

ParticlePercussionVoice64

using pulp::signal::ParticlePercussionVoice64 = ParticlePercussionVoiceT<double>

PartitionedConvolver

using pulp::signal::PartitionedConvolver = PartitionedConvolverT<float>

PartitionedConvolver64

using pulp::signal::PartitionedConvolver64 = PartitionedConvolverT<double>

PathLatencyAligner

using pulp::signal::PathLatencyAligner = PathLatencyAlignerT<float>

PathLatencyAligner64

using pulp::signal::PathLatencyAligner64 = PathLatencyAlignerT<double>

PhaseDistortionOsc

using pulp::signal::PhaseDistortionOsc = PhaseDistortionOscT<float>

PhaseDistortionOsc64

using pulp::signal::PhaseDistortionOsc64 = PhaseDistortionOscT<double>

Phaser

using pulp::signal::Phaser = PhaserT<float>

Phaser64

using pulp::signal::Phaser64 = PhaserT<double>

PhaserStages

using pulp::signal::PhaserStages = PhaserStagesT<float>

PhaserStages64

using pulp::signal::PhaserStages64 = PhaserStagesT<double>

PhaseVibrato

using pulp::signal::PhaseVibrato = PhaseVibratoT<float>

PhaseVibrato64

using pulp::signal::PhaseVibrato64 = PhaseVibratoT<double>

PhaseVocoder

using pulp::signal::PhaseVocoder = PhaseVocoderT<float>

PhaseVocoder64

using pulp::signal::PhaseVocoder64 = PhaseVocoderT<double>

PitchedFeedbackDelay

using pulp::signal::PitchedFeedbackDelay = PitchedFeedbackDelayT<float>

PitchedFeedbackDelay64

using pulp::signal::PitchedFeedbackDelay64 = PitchedFeedbackDelayT<double>

PitchShifter

using pulp::signal::PitchShifter = PitchShifterT<float>

PitchShifter64

using pulp::signal::PitchShifter64 = PitchShifterT<double>

PreparedParallelDynamicsConfig

using pulp::signal::PreparedParallelDynamicsConfig = PreparedParallelDynamicsConfigT<float>

PreparedParallelDynamicsConfig64

using pulp::signal::PreparedParallelDynamicsConfig64 = PreparedParallelDynamicsConfigT<double>

PreparedTransferCurve

using pulp::signal::PreparedTransferCurve = PreparedTransferCurveT<float, 32>

PreparedTransferCurve64

using pulp::signal::PreparedTransferCurve64 = PreparedTransferCurveT<double, 32>

ProbGate

using pulp::signal::ProbGate = ProbGateT<float>

ProbGate64

using pulp::signal::ProbGate64 = ProbGateT<double>

ProcessingSwitchCrossfade

using pulp::signal::ProcessingSwitchCrossfade = ProcessingSwitchCrossfadeT<float>

ProcessingSwitchCrossfade64

using pulp::signal::ProcessingSwitchCrossfade64 = ProcessingSwitchCrossfadeT<double>

ProcessorChain

template<typename... Processors>

using pulp::signal::ProcessorChain = ProcessorChainT<float, Processors...>

ProcessorChain64

template<typename... Processors>

using pulp::signal::ProcessorChain64 = ProcessorChainT<double, Processors...>

ProcessorDuplicator

template<typename P>

using pulp::signal::ProcessorDuplicator = ProcessorDuplicatorT<P, float>

ProcessorDuplicator64

template<typename P>

using pulp::signal::ProcessorDuplicator64 = ProcessorDuplicatorT<P, double>

Quantizer

using pulp::signal::Quantizer = QuantizerT<float>

Quantizer64

using pulp::signal::Quantizer64 = QuantizerT<double>

QuantizeScale

using pulp::signal::QuantizeScale = QuantizeScaleT<float>

QuantizeScale64

using pulp::signal::QuantizeScale64 = QuantizeScaleT<double>

RealtimePitchTimeProcessor

using pulp::signal::RealtimePitchTimeProcessor = RealtimePitchTimeProcessorT<float>

RealtimePitchTimeProcessor64

using pulp::signal::RealtimePitchTimeProcessor64 = RealtimePitchTimeProcessorT<double>

Rectifier

using pulp::signal::Rectifier = RectifierT<float>

Rectifier64

using pulp::signal::Rectifier64 = RectifierT<double>

ReedExciter

using pulp::signal::ReedExciter = ReedExciterT<float>

ReedExciter64

using pulp::signal::ReedExciter64 = ReedExciterT<double>

ReedWaveguideLoop

using pulp::signal::ReedWaveguideLoop = ReedWaveguideLoopT<float>

ReedWaveguideLoop64

using pulp::signal::ReedWaveguideLoop64 = ReedWaveguideLoopT<double>

Resampler

using pulp::signal::Resampler = ResamplerT<float>

Resampler64

using pulp::signal::Resampler64 = ResamplerT<double>

Reverb

using pulp::signal::Reverb = ReverbT<float>

Reverb64

using pulp::signal::Reverb64 = ReverbT<double>

ReverseBuffer

using pulp::signal::ReverseBuffer = ReverseBufferT<float>

ReverseBuffer64

using pulp::signal::ReverseBuffer64 = ReverseBufferT<double>

RiseFallGenerator

using pulp::signal::RiseFallGenerator = RiseFallGeneratorT<float>

RiseFallGenerator64

using pulp::signal::RiseFallGenerator64 = RiseFallGeneratorT<double>

Rungler

using pulp::signal::Rungler = RunglerT<float>

Rungler64

using pulp::signal::Rungler64 = RunglerT<double>

SampleHold

using pulp::signal::SampleHold = SampleHoldT<float>

SampleHold64

using pulp::signal::SampleHold64 = SampleHoldT<double>

SampleRateReducer

using pulp::signal::SampleRateReducer = SampleRateReducerT<float>

SampleRateReducer64

using pulp::signal::SampleRateReducer64 = SampleRateReducerT<double>

Saturator

using pulp::signal::Saturator = SaturatorT<float>

Saturator64

using pulp::signal::Saturator64 = SaturatorT<double>

ScannerVibrato

using pulp::signal::ScannerVibrato = ScannerVibratoT<float>

ScannerVibrato64

using pulp::signal::ScannerVibrato64 = ScannerVibratoT<double>

ScopeCapture

using pulp::signal::ScopeCapture = ScopeCaptureT<float>

ScopeCapture64

using pulp::signal::ScopeCapture64 = ScopeCaptureT<double>

SignalClockMult

using pulp::signal::SignalClockMult = SignalClockMultT<float>

SignalClockMult64

using pulp::signal::SignalClockMult64 = SignalClockMultT<double>

SignalComparator

using pulp::signal::SignalComparator = SignalComparatorT<float>

SignalComparator64

using pulp::signal::SignalComparator64 = SignalComparatorT<double>

SimpleMixer

using pulp::signal::SimpleMixer = SimpleMixerT<float>

SimpleMixer64

using pulp::signal::SimpleMixer64 = SimpleMixerT<double>

SincResampler

using pulp::signal::SincResampler = SincResamplerT<float>

SincResampler64

using pulp::signal::SincResampler64 = SincResamplerT<double>

SixBandEq

using pulp::signal::SixBandEq = SixBandEqT<float>

SixBandEq64

using pulp::signal::SixBandEq64 = SixBandEqT<double>

SlewLimiter

using pulp::signal::SlewLimiter = SlewLimiterT<float>

SlewLimiter64

using pulp::signal::SlewLimiter64 = SlewLimiterT<double>

SmoothedValue64

using pulp::signal::SmoothedValue64 = SmoothedValue<double>

SoftBypass

template<typename Processor>

using pulp::signal::SoftBypass = SoftBypassT<Processor, float>

SoftBypass64

template<typename Processor>

using pulp::signal::SoftBypass64 = SoftBypassT<Processor, double>

SosCascade

using pulp::signal::SosCascade = SosCascadeT<float>

SosCascade64

using pulp::signal::SosCascade64 = SosCascadeT<double>

SpeakerModel

using pulp::signal::SpeakerModel = SpeakerModelT<float>

SpeakerModel64

using pulp::signal::SpeakerModel64 = SpeakerModelT<double>

SpectralBand

using pulp::signal::SpectralBand = SpectralBandT<float>

SpectralBand64

using pulp::signal::SpectralBand64 = SpectralBandT<double>

SpectralBandLayout

using pulp::signal::SpectralBandLayout = SpectralBandLayoutT<float>

SpectralBandLayout64

using pulp::signal::SpectralBandLayout64 = SpectralBandLayoutT<double>

SpectralBandResolution

using pulp::signal::SpectralBandResolution = SpectralBandResolutionT<float>

SpectralBandResolution64

using pulp::signal::SpectralBandResolution64 = SpectralBandResolutionT<double>

SpectralCrossSynthesis

using pulp::signal::SpectralCrossSynthesis = SpectralCrossSynthesisT<float>

SpectralCrossSynthesis64

using pulp::signal::SpectralCrossSynthesis64 = SpectralCrossSynthesisT<double>

SpectralCrossSynthesisConfig

using pulp::signal::SpectralCrossSynthesisConfig = SpectralCrossSynthesisConfigT<float>

SpectralCrossSynthesisConfig64

using pulp::signal::SpectralCrossSynthesisConfig64 = SpectralCrossSynthesisConfigT<double>

SpectralCrossSynthesisPrepareConfig

using pulp::signal::SpectralCrossSynthesisPrepareConfig = SpectralCrossSynthesisPrepareConfigT<float>

SpectralCrossSynthesisPrepareConfig64

using pulp::signal::SpectralCrossSynthesisPrepareConfig64 = SpectralCrossSynthesisPrepareConfigT<double>

SpectralDelayMatrix

using pulp::signal::SpectralDelayMatrix = SpectralDelayMatrixT<float>

SpectralDelayMatrix64

using pulp::signal::SpectralDelayMatrix64 = SpectralDelayMatrixT<double>

SpectralEnvelopeShifter

using pulp::signal::SpectralEnvelopeShifter = SpectralEnvelopeShifterT<float>

SpectralEnvelopeShifter64

using pulp::signal::SpectralEnvelopeShifter64 = SpectralEnvelopeShifterT<double>

SpectralFeatureFrontEnd

using pulp::signal::SpectralFeatureFrontEnd = SpectralFeatureFrontEndT<float>

SpectralFeatureFrontEnd64

using pulp::signal::SpectralFeatureFrontEnd64 = SpectralFeatureFrontEndT<double>

SpectralFrameBlur

using pulp::signal::SpectralFrameBlur = SpectralFrameBlurT<float>

SpectralFrameBlur64

using pulp::signal::SpectralFrameBlur64 = SpectralFrameBlurT<double>

SpectralFrameEngine

using pulp::signal::SpectralFrameEngine = SpectralFrameEngineT<float>

SpectralFrameEngine64

using pulp::signal::SpectralFrameEngine64 = SpectralFrameEngineT<double>

SpectralGate

using pulp::signal::SpectralGate = SpectralGateT<float>

SpectralGate64

using pulp::signal::SpectralGate64 = SpectralGateT<double>

SpectralMaskProcessor

using pulp::signal::SpectralMaskProcessor = SpectralMaskProcessorT<float>

SpectralMaskProcessor64

using pulp::signal::SpectralMaskProcessor64 = SpectralMaskProcessorT<double>

SpectralMaskProcessorConfig

using pulp::signal::SpectralMaskProcessorConfig = SpectralMaskProcessorConfigT<float>

SpectralMaskProcessorConfig64

using pulp::signal::SpectralMaskProcessorConfig64 = SpectralMaskProcessorConfigT<double>

SpectralMaskTable

using pulp::signal::SpectralMaskTable = SpectralMaskTableT<float>

SpectralMaskTable64

using pulp::signal::SpectralMaskTable64 = SpectralMaskTableT<double>

SpectralMorph

using pulp::signal::SpectralMorph = SpectralMorphT<float>

SpectralMorph64

using pulp::signal::SpectralMorph64 = SpectralMorphT<double>

SpectralPreMaskStage

using pulp::signal::SpectralPreMaskStage = SpectralPreMaskStageT<float>

SpectralPreMaskStage64

using pulp::signal::SpectralPreMaskStage64 = SpectralPreMaskStageT<double>

SpectralWetSourceStage

using pulp::signal::SpectralWetSourceStage = SpectralWetSourceStageT<float>

SpectralWetSourceStage64

using pulp::signal::SpectralWetSourceStage64 = SpectralWetSourceStageT<double>

SpectrumTrace

using pulp::signal::SpectrumTrace = SpectrumTraceT<float>

SpectrumTrace64

using pulp::signal::SpectrumTrace64 = SpectrumTraceT<double>

SquareOscBank

using pulp::signal::SquareOscBank = SquareOscBankT<float>

SquareOscBank64

using pulp::signal::SquareOscBank64 = SquareOscBankT<double>

SsbFrequencyShifter

using pulp::signal::SsbFrequencyShifter = SsbFrequencyShifterT<float>

SsbFrequencyShifter64

using pulp::signal::SsbFrequencyShifter64 = SsbFrequencyShifterT<double>

StageSeq

using pulp::signal::StageSeq = StageSeqT<float>

StageSeq64

using pulp::signal::StageSeq64 = StageSeqT<double>

StereoEnvelopeFollower

using pulp::signal::StereoEnvelopeFollower = StereoEnvelopeFollowerT<float>

StereoEnvelopeFollower64

using pulp::signal::StereoEnvelopeFollower64 = StereoEnvelopeFollowerT<double>

Stft

using pulp::signal::Stft = StftT<float>

Stft64

using pulp::signal::Stft64 = StftT<double>

StftFrame

using pulp::signal::StftFrame = StftFrameT<float>

StftFrame64

using pulp::signal::StftFrame64 = StftFrameT<double>

StnDecomposer

using pulp::signal::StnDecomposer = StnDecomposerT<float>

StnDecomposer64

using pulp::signal::StnDecomposer64 = StnDecomposerT<double>

StnMasks

using pulp::signal::StnMasks = StnMasksT<float>

StnMasks64

using pulp::signal::StnMasks64 = StnMasksT<double>

SubOscillator

using pulp::signal::SubOscillator = SubOscillatorT<float>

SubOscillator64

using pulp::signal::SubOscillator64 = SubOscillatorT<double>

Supersaw

using pulp::signal::Supersaw = SupersawT<float>

Supersaw64

using pulp::signal::Supersaw64 = SupersawT<double>

Svf

using pulp::signal::Svf = SvfT<float>

Svf64

using pulp::signal::Svf64 = SvfT<double>

SvfBank

template<std::size_t Voices = 16>

using pulp::signal::SvfBank = SvfBankT<float, Voices>

TapeCompander

using pulp::signal::TapeCompander = TapeCompanderT<float>

TapeMachine

using pulp::signal::TapeMachine = TapeMachineT<float>

TapeMachine64

using pulp::signal::TapeMachine64 = TapeMachineT<double>

TiltEq

using pulp::signal::TiltEq = TiltEqT<float>

TiltEq64

using pulp::signal::TiltEq64 = TiltEqT<double>

ToneStack

using pulp::signal::ToneStack = ToneStackT<float>

ToneStack64

using pulp::signal::ToneStack64 = ToneStackT<double>

TptFilter

using pulp::signal::TptFilter = TptFilterT<float>

TptFilter64

using pulp::signal::TptFilter64 = TptFilterT<double>

TransferCurve

using pulp::signal::TransferCurve = TransferCurveT<float, 32>

TransferCurve64

using pulp::signal::TransferCurve64 = TransferCurveT<double, 32>

TransferCurvePoint

using pulp::signal::TransferCurvePoint = TransferCurvePointT<float>

TransferCurvePoint64

using pulp::signal::TransferCurvePoint64 = TransferCurvePointT<double>

TransformerBracket

using pulp::signal::TransformerBracket = TransformerBracketT<float>

TransformerBracket64

using pulp::signal::TransformerBracket64 = TransformerBracketT<double>

TransientDesigner

using pulp::signal::TransientDesigner = TransientDesignerT<float>

TransientDesigner64

using pulp::signal::TransientDesigner64 = TransientDesignerT<double>

TransientDetector

using pulp::signal::TransientDetector = TransientDetectorT<float>

TransientDetector64

using pulp::signal::TransientDetector64 = TransientDetectorT<double>

TransientPhasePolicy

using pulp::signal::TransientPhasePolicy = TransientPhasePolicyT<float>

TransientPhasePolicy64

using pulp::signal::TransientPhasePolicy64 = TransientPhasePolicyT<double>

TransitionMixer

using pulp::signal::TransitionMixer = TransitionMixerT<float>

TransitionMixer64

using pulp::signal::TransitionMixer64 = TransitionMixerT<double>

TransportEdge

using pulp::signal::TransportEdge = TransportEdgeT<float>

TransportEdge64

using pulp::signal::TransportEdge64 = TransportEdgeT<double>

TrigDelay

using pulp::signal::TrigDelay = TrigDelayT<float>

TrigDelay64

using pulp::signal::TrigDelay64 = TrigDelayT<double>

TriggerDetect

using pulp::signal::TriggerDetect = TriggerDetectT<float>

TriggerDetect64

using pulp::signal::TriggerDetect64 = TriggerDetectT<double>

TruePeakLimiter

using pulp::signal::TruePeakLimiter = TruePeakLimiterT<float>

TruePeakLimiter64

using pulp::signal::TruePeakLimiter64 = TruePeakLimiterT<double>

TwoPoleResonator

using pulp::signal::TwoPoleResonator = TwoPoleResonatorT<float>

TwoPoleResonator64

using pulp::signal::TwoPoleResonator64 = TwoPoleResonatorT<double>

UnitDelay

using pulp::signal::UnitDelay = UnitDelayT<float>

UnitDelay64

using pulp::signal::UnitDelay64 = UnitDelayT<double>

UniVibe

using pulp::signal::UniVibe = UniVibeT<float>

UniVibe64

using pulp::signal::UniVibe64 = UniVibeT<double>

VactrolConditioner

using pulp::signal::VactrolConditioner = VactrolConditionerT<float>

VactrolConditioner64

using pulp::signal::VactrolConditioner64 = VactrolConditionerT<double>

Vca

using pulp::signal::Vca = VcaT<float>

Vca64

using pulp::signal::Vca64 = VcaT<double>

VcaCompressor

using pulp::signal::VcaCompressor = VcaCompressorT<float>

VcaCompressor64

using pulp::signal::VcaCompressor64 = VcaCompressorT<double>

VelvetNoiseGrid

using pulp::signal::VelvetNoiseGrid = VelvetNoiseGridT<float>

VelvetNoiseGrid64

using pulp::signal::VelvetNoiseGrid64 = VelvetNoiseGridT<double>

Vocoder

using pulp::signal::Vocoder = VocoderT<float>

Vocoder64

using pulp::signal::Vocoder64 = VocoderT<double>

WaveguideJunction

using pulp::signal::WaveguideJunction = WaveguideJunctionT<float>

WaveguideJunction64

using pulp::signal::WaveguideJunction64 = WaveguideJunctionT<double>

WaveguideLine

using pulp::signal::WaveguideLine = WaveguideLineT<float>

WaveguideLine64

using pulp::signal::WaveguideLine64 = WaveguideLineT<double>

WaveguideReflectionFilter

using pulp::signal::WaveguideReflectionFilter = WaveguideReflectionFilterT<float>

WaveguideReflectionFilter64

using pulp::signal::WaveguideReflectionFilter64 = WaveguideReflectionFilterT<double>

WavesetTransformer

using pulp::signal::WavesetTransformer = WavesetTransformerT<float>

WavesetTransformer64

using pulp::signal::WavesetTransformer64 = WavesetTransformerT<double>

WaveShaper

using pulp::signal::WaveShaper = WaveShaperT<float>

WaveShaper64

using pulp::signal::WaveShaper64 = WaveShaperT<double>

Wavetable

using pulp::signal::Wavetable = WavetableT<float>

Wavetable64

using pulp::signal::Wavetable64 = WavetableT<double>

WavetableBank

using pulp::signal::WavetableBank = WavetableBankT<float>

WavetableBank64

using pulp::signal::WavetableBank64 = WavetableBankT<double>

WavetableEntry

using pulp::signal::WavetableEntry = WavetableEntryT<float>

WavetableEntry64

using pulp::signal::WavetableEntry64 = WavetableEntryT<double>

YinTracker

using pulp::signal::YinTracker = YinTrackerT<float>

YinTracker64

using pulp::signal::YinTracker64 = YinTrackerT<double>

ZeroLatencyConvolver

using pulp::signal::ZeroLatencyConvolver = ZeroLatencyConvolverT<float>

ZeroLatencyConvolver64

using pulp::signal::ZeroLatencyConvolver64 = ZeroLatencyConvolverT<double>

Enumeration Type Documentation

AutoDuckedSendStatus

enum class pulp::signal::AutoDuckedSendStatus

strong

Enumerator
ready
invalid_sample_rate
invalid_config

BeatRepeatPlanError

enum class pulp::signal::BeatRepeatPlanError

strong

Enumerator
None
InvalidDivision
TickRangeExceeded
SampleRangeExceeded
CaptureRangeExceeded
HistoryCapacityExceeded
Unprepared
SampleRateMismatch
ReleaseInProgress
StaleRequest

BreakpointEnvelopeStatus

enum class pulp::signal::BreakpointEnvelopeStatus : std::uint8_t

strong

Enumerator
ok
too_few_points
too_many_points
invalid_time
times_not_ordered
invalid_value
invalid_sample_rate
invalid_loop

CartesianAccess

enum class pulp::signal::CartesianAccess

strong

How a CartesianWalkT's two axes relate.

Enumerator
row_major	X advances on its clock; an X wrap carries into Y, like reading text. The Y clock input is ignored — carrying and clocking Y would make the row advance twice per wrap.
independent	X and Y advance only on their own clocks and never on each other's. The documented René behaviour and the default.

ClipperTopology

enum class pulp::signal::ClipperTopology : std::uint8_t

strong

Where the diode pair sits relative to the gain stage.

Enumerator
to_ground	Shunt across the stage output. Level-independent knee.
in_loop	Across the op-amp's feedback resistor. Knee tracks drive.

Coherence

enum class pulp::signal::Coherence : std::uint8_t

strong

Which normalization law applies — a statement about whether grains are correlated with each other, not a tone control.

Enumerator
incoherent	Scattered grains; powers add; 1/(w_rms·√N̄).
coherent	Grid-aligned grains; amplitudes add; 1/(w_mean·N̄).

ColorRamp

enum class pulp::signal::ColorRamp

strong

Predefined color ramp types for spectrogram rendering.

Enumerator
inferno
viridis
grayscale
heat

CombFilterMode

enum class pulp::signal::CombFilterMode

strong

Enumerator
feedforward
feedback
allpass

CombFilterStatus

enum class pulp::signal::CombFilterStatus

strong

Enumerator
ok
not_prepared
not_configured
invalid_argument
non_finite_input
output_out_of_range

CommutedStringExcitationPrepareStatus

enum class pulp::signal::CommutedStringExcitationPrepareStatus

strong

Enumerator
ok
empty_base_excitation
empty_body_impulse_response
retained_sample_limit_exceeded
non_finite_input
non_finite_output
input_aliases_profile

CompressorBallistics

enum class pulp::signal::CompressorBallistics : std::uint8_t

strong

How CompressorT smooths the gain reduction its static curve asks for, in the log (dB) domain after the gain computer (the two detector forms of Giannoulis, Massberg and Reiss, "Digital Dynamic Range Compressor Design", JAES 2012).

attack_ms and release_ms are one-pole time constants (tau).

• branching (the default): one one-pole that uses the attack coefficient while more reduction is asked for and the release coefficient otherwise. A steady-level step moves from 10% to 90% in ln(9) tau = 2.2 tau in either direction. On a tone the per-sample detector rides the waveform: only samples near each peak pull toward more reduction and release acts between them, so attack is slower than the knob (about 2x at 1 kHz with 5/100 ms), the reduction settles short of the static curve, and the gain ripples at twice the tone frequency. Measured at 5/100 ms with a -6 dBFS tone: THD+N -39.5 / -45.5 dB at 50 / 100 Hz.
• decoupled (opt in with set_ballistics()): a peak hold that decays with the release time, followed by an attack one-pole. The hold sits at each cycle's peak, so attack follows the knob on tones as on steps (2.2 tau), the reduction settles on the static curve, and the attack stage filters the release droop between peaks: THD+N -48.8 / -60.3 dB under the same conditions. Its release is the release hold and the attack one-pole in series, so a level step releases in about 2.2 x release only while attack is much shorter than release. Measured 10%-90% release (knob 2.2 tau in brackets): 5/100 ms 220 ms (220), 20/100 ms 227 ms (220), 30/60 ms 155 ms (132), 50/50 ms 168 ms (110), 100/100 ms 336 ms (220).

Enumerator
branching
decoupled

CompressorDetector

enum class pulp::signal::CompressorDetector : std::uint8_t

strong

What the sidechain measures.

Enumerator
peak	Sample peak. Literal, fastest-responding.
rms	Running mean-square. Reads program loudness.

ConvolutionBackend

enum class pulp::signal::ConvolutionBackend : std::uint8_t

strong

The engine a FixedIrConvolverT runs.

Enumerator
none	No IR loaded; process() passes audio through.
direct_fir	FirFilterT: a vectorized time-domain dot product.
partitioned_fft	PartitionedConvolverT: uniform overlap-save FFT.

CrossfadeGainLaw

enum class pulp::signal::CrossfadeGainLaw

strong

The old→new gain split applied to a shaped progress u ∈ [0,1].

Enumerator
EqualGain	(1−u, u) — amplitude sum == 1.
EqualPower	(cos(u·π/2), sin(u·π/2)) — power sum == 1.

DiodeModel

enum class pulp::signal::DiodeModel : std::uint8_t

strong

Diode device families. The members differ only in (Is, n).

Enumerator
silicon	Small-signal switching class. Clips ~0.6 V, hard.
germanium	Much larger Is: turns on earlier and softer.
led	Smallest Is, highest n: latest onset, steepest slope.

DitherMode

enum class pulp::signal::DitherMode : std::uint8_t

strong

Enumerator
none
tpdf

DustAmplitudeDistribution

enum class pulp::signal::DustAmplitudeDistribution : std::uint8_t

strong

Amplitude law applied when a DustT event occurs.

Enumerator
constant	Exactly level.
uniform_unipolar	Uniform on [0, level).
uniform_bipolar	Uniform on [-level, level).

DynamicsStereoLink

enum class pulp::signal::DynamicsStereoLink

strong

Shared policy for dynamics processors with two detector channels.

Enumerator
independent
peak_linked

EnvelopeStage

enum class pulp::signal::EnvelopeStage : std::uint8_t

strong

Stage of any envelope in this header.

Reported by every type's stage(); the shorter shapes simply never enter the stages they do not have.

Enumerator
idle
delay
attack
hold
decay
sustain
release

ExpanderStatus

enum class pulp::signal::ExpanderStatus

strong

Enumerator
ready
invalid_sample_rate
invalid_config

ExpansionMode

enum class pulp::signal::ExpansionMode

strong

Enumerator
downward
upward

FastTrigProfile

enum class pulp::signal::FastTrigProfile : std::uint8_t

strong

Semantic accuracy choices for bounded-cycle real-time trigonometry.

The names describe the contract a consumer requests. Polynomial degree and coefficient layout are implementation details and are not session state.

Enumerator
reference	Platform sine; the compatibility default.
realtime_efficient	Lower-cost float path with maximum absolute error at most 1.2e-4 over one bounded cycle. This profile can audibly change recursive FM.
realtime_precise	Float-precision path with maximum absolute error at most 2.5e-7 over one bounded cycle.

FetRatio

enum class pulp::signal::FetRatio : std::uint8_t

strong

The ratio buttons.

all_buttons_in is not a fifth ratio — it is the documented distinct circuit state produced by engaging all four buttons at once (Moore 2012), modelled here as four simultaneous deviations from the 20:1 baseline.

Enumerator
r4_1
r8_1
r12_1
r20_1
all_buttons_in

FftBackend

enum class pulp::signal::FftBackend

strong

Enumerator
auto_	Pick best available at runtime.
vdsp	Apple Accelerate vDSP (Apple only).
kissfft	Built-in radix-2 fallback (always available).
fftw3	FFTW3 single-precision (runtime-dlopen).
mkl	Intel MKL DFTI (runtime-dlopen).

FiniteStretchCounterGeometryStatus

enum class pulp::signal::FiniteStretchCounterGeometryStatus

strong

Enumerator
representable
input_counter_overflow
output_counter_overflow

FiniteStretchFailure

enum class pulp::signal::FiniteStretchFailure

strong

Enumerator
none
invalid_ratio
output_too_short
output_too_long
processor_protocol_error

FiniteStretchPrepareStatus

enum class pulp::signal::FiniteStretchPrepareStatus

strong

Enumerator
prepared
invalid_mode
invalid_input
invalid_output
invalid_output_layout
invalid_target
invalid_ratio
unrepresentable_capacity
processor_prepare_failed

FiniteStretchStepStatus

enum class pulp::signal::FiniteStretchStepStatus

strong

Enumerator
progress
complete
failed

FiniteStretchWorkOutcome

enum class pulp::signal::FiniteStretchWorkOutcome

strong

Enumerator
none
advanced
backpressure

FiniteStretchWorkUnit

enum class pulp::signal::FiniteStretchWorkUnit

strong

Enumerator
none
feed
drain
finalize

FirDesignStatus

enum class pulp::signal::FirDesignStatus

strong

Enumerator
success
invalid_argument
unsupported_size
workspace_limit_exceeded
allocation_failure
rank_deficient
ill_conditioned
numerical_failure
not_converged	The exchange hit its iteration cap without meeting the convergence tolerance, or the achieved minimax error exceeded a stated requirement.

FlangerDelayEngine

enum class pulp::signal::FlangerDelayEngine : std::uint8_t

strong

Which delay engine fills the modulated slot.

Enumerator
clean	Lagrange-interpolated line. Linear, transparent, the default.
bbd	The bucket-brigade character model: dark, companded, alive.

FlangerMode

enum class pulp::signal::FlangerMode : std::uint8_t

strong

Which of the three sweep topologies the engine runs.

Enumerator
classic	One modulated delay against an undelayed dry. Latency 0.
through_zero	Swept wet crossing a fixed-delay dry. Latency = offset.
barberpole	Fixed delay, frequency-shifted wet. Latency 0.

FlangerPolarity

enum class pulp::signal::FlangerPolarity : std::uint8_t

strong

The sign of the wet contribution, in the mix and in the feedback tap alike.

Enumerator
positive	y = dry + wet. Notches at (2k+1)/(2D).
negative	y = dry − wet. Notches at k/D, including one at DC.

FloorCurve

enum class pulp::signal::FloorCurve

strong

The curve applied above a floor threshold by floor_shape.

Enumerator
linear	A straight ramp from silence at the threshold to full scale.
smoothstep	Smoothstep, which leaves the threshold with zero slope so the onset of audibility is gradual rather than a corner.

FmOperatorAliasPolicy

enum class pulp::signal::FmOperatorAliasPolicy : std::uint8_t

strong

Alias behavior for the modulation network.

Sine operators have no unmodulated harmonics, but FM/PM sidebands are not band-limited. bounded preserves the requested modulation and clamps the instantaneous frequency to the representable band. bright_band_safe additionally fades routed modulation according to the destination's base frequency plus current absolute Hz deviation between 65% and 90% of Nyquist, where even the first upper sideband has little room. It is a conservative bright-note policy, not a claim that arbitrary deep PM at a low base frequency is alias-free.

Enumerator
bounded
bright_band_safe

FmOperatorFrequencyMode

enum class pulp::signal::FmOperatorFrequencyMode : std::uint8_t

strong

How an operator derives its unmodulated frequency.

Enumerator
ratio	base_frequency_hz * ratio.
fixed_hz	An absolute frequency in Hz, independent of the played key.

FormantConfigureStatus

enum class pulp::signal::FormantConfigureStatus

strong

Enumerator
configured
not_prepared
invalid_count
non_finite
out_of_range
unordered
unstable

FormantMode

enum class pulp::signal::FormantMode

strong

Enumerator
follow
preserve

FormantVowel

enum class pulp::signal::FormantVowel

strong

Enumerator
a
e
i
o
u

FractionalDelayMethod

enum class pulp::signal::FractionalDelayMethod

strong

Enumerator
thiran1
lagrange3
lagrange5

FractionalDelayStatus

enum class pulp::signal::FractionalDelayStatus

strong

Enumerator
ok
not_prepared
invalid_argument
non_finite_input
invalid_delay
output_out_of_range

FreezeHoldAverage

enum class pulp::signal::FreezeHoldAverage : std::uint8_t

strong

When the capture window is averaged.

Enumerator
at_latch	Sum the window inside the latching frame group (the original path).
running	Maintain running sums as frames arrive; the latch only divides.

FreezeHoldFrequency

enum class pulp::signal::FreezeHoldFrequency : std::uint8_t

strong

Where a held bin's instantaneous frequency comes from.

Enumerator
newest	The newest captured frame's phase increment (the original estimate).
energy_weighted	Energy-weighted circular mean of the increments over the window.

FreezeHoldPhaseLock

enum class pulp::signal::FreezeHoldPhaseLock : std::uint8_t

strong

Phase structure of a hold as it starts (see the class notes on stationarity).

Enumerator
none	Every bin starts at its latched phase and rotates at its own frequency (the original behaviour).
peak_lobe	Bins within lobe_half_width of a spectral peak rotate at the peak's frequency; every other bin starts at a random phase.

FreezeHoldSynthesis

enum class pulp::signal::FreezeHoldSynthesis : std::uint8_t

strong

How held frames are synthesised (see the class notes on per-callback cost).

Enumerator
polar	One std::polar per channel per bin per hop (the original path).
rotor	Unit phasor per bin advanced by a rotor and a jitter table.

FreezeRestoreEngage

enum class pulp::signal::FreezeRestoreEngage : std::uint8_t

strong

How a restored hold enters the output.

Enumerator
crossfade	Fade in over the configured crossfade, like a normal engage.
immediate	Replace the output with the hold from the adopting frame onward.
as_captured	Resume the recorded request and fade position (a hold captured mid-release keeps releasing).

FrequencyScale

enum class pulp::signal::FrequencyScale

strong

Frequency axis scaling modes.

Enumerator
linear
logarithmic
mel

FrequencyShiftMode

enum class pulp::signal::FrequencyShiftMode : std::uint8_t

strong

Which sideband a SsbFrequencyShifterT keeps, and how it spreads it.

Enumerator
up	Upper sideband on both channels: f → f + Δf.
down	Lower sideband on both channels: f → f − Δf.
dual_mono	Two independent identical mono shifters. See the note below.
stereo_split	Up on the left, down on the right, scaled by the spread.

FuzzDevice

enum class pulp::signal::FuzzDevice : std::uint8_t

strong

The two device families. They differ only in (n, Is).

Enumerator
germanium	Large Is: conducts from ~0.36 V, softer knee, drifts more.
silicon	Small Is: conducts from ~0.69 V, harder knee, stable.

GateOp

enum class pulp::signal::GateOp

strong

Boolean operation performed by a GateLogicT.

Ordered to match the catalog node's op parameter.

Enumerator
logic_and
logic_or
logic_xor
logic_nand
logic_nor
logic_xnor

GrainInterp

enum class pulp::signal::GrainInterp : std::uint8_t

strong

Fractional-read quality inside a grain.

Named GrainInterp rather than the bare Interp the spec suggests because pulp::signal is a shared namespace and an unqualified Interp would be the first thing to collide.

Enumerator
linear	2-point. Cheapest; audible imaging when pitching up.
cubic_hermite	4-point Catmull-Rom. The default and the anti-imaging measure for the whole ±24 st range.

GrainSource

enum class pulp::signal::GrainSource : std::uint8_t

strong

Where grains read from.

The grain core is identical either way; only source addressing differs.

Enumerator
buffer	A borrowed static buffer with a traversable playhead.
live_ring	A continuously captured ring of recent input.

GraphicEqConfigureStatus

enum class pulp::signal::GraphicEqConfigureStatus

strong

Enumerator
configured
not_prepared
over_capacity
invalid_transition
non_finite
frequency_out_of_range
frequencies_not_strictly_increasing
gain_out_of_range
q_out_of_range
unstable
transition_in_progress

GraphicEqPrepareStatus

enum class pulp::signal::GraphicEqPrepareStatus

strong

Enumerator
prepared
invalid_sample_rate
invalid_capacity

IrNormalizeMode

enum class pulp::signal::IrNormalizeMode

strong

IR amplitude policy applied at load, after resampling and tail trim.

The right choice is data-dependent — a reverb IR wants constant broadband send level, a cabinet IR wants a flat 0 dB peak — so this is a parameter, not a constant.

Enumerator
none	File passes through untouched (match / linear-phase EQ kernels).
peak	max|h| = 1 (cabinet / mic-response IRs).
energy	sum h^2 = 1 per output ear (default; convolution reverb).

LadderSaturation

enum class pulp::signal::LadderSaturation

strong

Saturator choices for the Moog ladder's per-stage non-linearity.

• exact: std::tanh. The reference the others are measured against.
• accurate: FastMath::tanh_accurate, within 3.0e-7 (3.6e-7 without fused multiply-add) of std::tanh over the inputs its tests scan. Against the exact-saturator ladder, over cutoffs of 300 Hz to 6 kHz, resonance 0 to 1 and sine input of 110 Hz to 7 kHz at 48 kHz, the pointwise output difference is at most -124 dBFS for input up to 0 dBFS, -107 dBFS at +10 dBFS drive and -102 dBFS at +20 dBFS, measured with Apple clang and with GCC and glibc, with or without fused multiply-add (the worst cases are high resonance, a low input and a high cutoff, where the recursion amplifies the saturator's error; the exact reference's own libm tanh differs by platform). Tested with about 2 dB of margin. Harmonic and alias levels match to 0.001 dB and resonant ringing frequency and decay are unchanged. About 2.4x the throughput of std::tanh. This is the default.
• realtime_efficient: FastMath::tanh_minimax_recursive (the tanh_minimax fit in Estrin form), within 3.8e-6 of std::tanh for every input and continuous in value and slope where it clamps at |x| = 7. Cheapest per evaluation at normal levels, including inside a polyphonic voice loop; under heavy drive accurate can be faster, because this form's division is on the recursion's critical path for every argument below 7. FastMath::tanh is not offered here: its 5.7e-5 worst error is 15x this one's, its slope at the origin is not 1, and a resonant loop amplifies saturator error.

Enumerator
exact
accurate
realtime_efficient

LeslieSpeed

enum class pulp::signal::LeslieSpeed : std::uint8_t

strong

The three positions of the cabinet's speed switch.

Enumerator
stop	Brake. Both rotors ramp to rest and the modulation freezes.
chorale	Slow. A wide, gentle chorus.
tremolo	Fast. The shimmering swirl.

LfoWave

enum class pulp::signal::LfoWave : std::uint8_t

strong

The effect-wave vocabulary, shared by these functions and by EffectLfoT (lfo.hpp), whose set_wave(LfoWave) overload selects the effect convention.

Distinct on purpose from the toolkit LfoT::Wave.

Enumerator
sine
triangle
saw_up
saw_down
square
sample_hold
smooth_random

LinearPhaseFirType

enum class pulp::signal::LinearPhaseFirType

strong

Enumerator
type_i_symmetric_odd
type_ii_symmetric_even
type_iii_antisymmetric_odd
type_iv_antisymmetric_even

LoudnessChannelRole

enum class pulp::signal::LoudnessChannelRole : std::uint8_t

strong

Speaker roles used by the BS.1770 channel summation.

LFE is excluded; lateral surrounds receive 1.41 while rear channels at +/-135 degrees use 1.0 as specified for advanced channel layouts.

Enumerator
left
right
center
lfe
left_surround
right_surround
left_rear_surround
right_rear_surround
unknown

MatrixHeadroomPolicy

enum class pulp::signal::MatrixHeadroomPolicy

strong

Raw applies the signed matrix exactly.

NormalizePeak scales each output row by max(1, sum(abs(gain))) so full-scale, arbitrarily correlated inputs cannot exceed full scale. Neither policy clips the output.

Enumerator
Raw
NormalizePeak

MeterFeatures

enum class pulp::signal::MeterFeatures : std::uint8_t

strong

What a MultiChannelMeter computes.

Sample peak, RMS, and clip detection are always on; stereo correlation and BS.1770 loudness (K-weighted momentary, integrated, short-term, and loudness range) can be left out when nothing reads them, which removes their per-sample cost. Combine with |.

Enumerator
levels
correlation
loudness
all

MixCurve

enum class pulp::signal::MixCurve

strong

Crossfade curve between dry (mix=0) and wet (mix=1).

Conventional crossfade taxonomy. Sin3dB is an alias of EqualPower kept for explicit naming. Each curve hits dry=1/wet=0 at mix=0 and dry=0/wet=1 at mix=1; they differ in the midpoint behavior:

• Linear: -6 dB notch at midpoint, constant amplitude sum.
• EqualPower: -3 dB notch, constant power sum (sin/cos).
• Balanced: dry stays at 1 until mix=0.5 then linearly drops to 0; wet inverse — useful for "include dry until midway" balance behavior.
• Sin3dB: alias of EqualPower.
• Sin4_5dB: sin/cos law shaped by exponent 1.5 → -4.5 dB notch.
• Sin6dB: sin/cos law squared → -6 dB notch.
• Sqrt3dB: sqrt law → -3 dB notch.
• Sqrt4_5dB: sqrt with offset → -4.5 dB notch.

Enumerator
Linear
EqualPower
Balanced
Sin3dB
Sin4_5dB
Sin6dB
Sqrt3dB
Sqrt4_5dB

ModulationCurveShape

enum class pulp::signal::ModulationCurveShape : std::uint8_t

strong

Enumerator
linear
exponential
logarithmic
smoothstep
hold

MorphFilterType

enum class pulp::signal::MorphFilterType

strong

Enumerator
lowpass
bandpass
highpass
notch

NoiseColor

enum class pulp::signal::NoiseColor

strong

Spectral tilt of a NoiseSourceT, named by the usual colour convention.

The number after each name is the power-spectral-density slope the colour is defined by; the implementation is validated against those slopes rather than against a particular filter topology.

Enumerator
white	0 dB/octave — the raw generator output.
pink	-3 dB/octave — equal power per octave.
brown	-6 dB/octave — integrated white ("red" noise).
blue	+3 dB/octave — the mirror of pink.
violet	+6 dB/octave — differentiated white ("purple" noise).

NoiseShapingOrder

enum class pulp::signal::NoiseShapingOrder : std::uint8_t

strong

Enumerator
none
first
second

NonlinearAliasPolicy

enum class pulp::signal::NonlinearAliasPolicy : std::uint8_t

strong

Antialiasing choices shared by the nonlinear-shaping processors.

Enumerator
oversample_4x
oversample_2x
off

NonlinProgram

enum class pulp::signal::NonlinProgram

strong

The four programs.

The names are documented RMX16 product history; the shapes below are this module's own designs derived from the cited lineages.

Enumerator
ambience	Short falling cloud — the "natural" one.
gated	Flat body, hard cut.
reverse	Rise to a peak, then cut.
nonlin2	Rippled body, shaped attack, hard gate.

OfflineFormantMode

enum class pulp::signal::OfflineFormantMode

strong

Formant behavior for the spectral modes.

signal::FormantMode on main is only {follow, preserve} and cannot express the three-way behavior we need, so this is an offline-specific enum. Each value maps to a concrete SpectralEnvelopeShifter warp at wiring time (the shifter exposes a single warp knob, not a mode enum): follow_pitch -> warp = 1 (formants ride the shift) preserve_original -> warp = pitch_ratio (formants held at source) shift_independently -> warp = pitch_ratio/formant_ratio (decoupled via formant_semitones)

Enumerator
follow_pitch
preserve_original
shift_independently

OffScalePolicy

enum class pulp::signal::OffScalePolicy : std::uint8_t

strong

How a pitch class that is not in the active scale is resolved.

Enumerator
nearest_lower	Snap DOWN to the nearest in-scale degree (ties → lower).
nearest	Snap to the nearest in-scale degree in either direction.
mute_wet	Report it and let the caller duck the wet voice.

OnsetDetectionMethod

enum class pulp::signal::OnsetDetectionMethod : std::uint8_t

strong

Enumerator
EnergyFlux
SpectralFlux
HighFrequencyContent

PanLaw

enum class pulp::signal::PanLaw

strong

Stereo pan law selector.

Sin3dB and EqualPower are aliases. Each law hits hard-left at pan=-1 and hard-right at pan=+1; they differ in the center behavior:

• Linear: additive law. Constant amplitude sum, -6 dB notch at center.
• Balanced: full level on the panned-toward side until center, then ramp. Useful as a stereo balance control.
• Sin3dB: sin/cos law. Constant power, -3 dB notch at center.
• Sin4_5dB: sin/cos law shaped by exponent 1.5 → -4.5 dB notch.
• Sin6dB: sin/cos law squared → -6 dB notch.
• Sqrt3dB: sqrt law → -3 dB notch.
• Sqrt4_5dB: sqrt law with offset → -4.5 dB notch.

Enumerator
Linear
Balanced
Sin3dB
EqualPower
Sin4_5dB
Sin6dB
Sqrt3dB
Sqrt4_5dB

ParametricEqBandType

enum class pulp::signal::ParametricEqBandType : std::uint8_t

strong

Enumerator
low_shelf
peaking
high_shelf

ParametricEqConfigureStatus

enum class pulp::signal::ParametricEqConfigureStatus

strong

Enumerator
configured
not_prepared
over_capacity
invalid_transition
non_finite
frequency_out_of_range
frequencies_not_strictly_increasing
gain_out_of_range
q_out_of_range
invalid_solo
unstable
transition_in_progress

ParametricEqPrepareStatus

enum class pulp::signal::ParametricEqPrepareStatus

strong

Enumerator
prepared
invalid_sample_rate
invalid_capacity

PedalMode

enum class pulp::signal::PedalMode : std::uint8_t

strong

How the expression pedal maps to a shift target.

The mode picks the LAW, not the mix: see default_mix_for.

Enumerator
whammy	Continuous heel→toe bend. Dry conventionally muted.
harmony	Morph between two fixed intervals. Dry conventionally on.
detune	Sub-semitone offset scaled by the pedal. Dry on.
dive	Dive-bomb toward a floor near (but never at) r = 0.

PhaseDistortionShape

enum class pulp::signal::PhaseDistortionShape

strong

Which phase warp a PhaseDistortionOscT applies.

Enumerator
saw	the bend point slides toward zero: sine becomes saw-like
pulse	a ramp then a hold: sine becomes pulse-like
resonant_saw	a swept carrier windowed by a falling ramp
resonant_triangle	the same carrier windowed by a triangle
resonant_trapezoid	the same carrier windowed by a clamped trapezoid

PitchInterp

enum class pulp::signal::PitchInterp : std::uint8_t

strong

Fractional-delay read quality for the two taps.

Named PitchInterp rather than the spec's bare Interp because pulp::signal already carries Interpolator, and an unqualified Interp in that namespace is a collision waiting to happen.

Enumerator
linear	2-point. Dattorro's recommendation for modulated delays.
cubic	4-point Lagrange. Brighter tap, ~4× the read cost.

PitchTimeMode

enum class pulp::signal::PitchTimeMode

strong

Enumerator
realtime_pitch
time_stretch

PitchTimePrepareStatus

enum class pulp::signal::PitchTimePrepareStatus

strong

Enumerator
prepared
invalid_sample_rate
invalid_channel_count
invalid_max_block
invalid_max_time_ratio
invalid_max_pitch_semitones
invalid_spectral_geometry
unrepresentable_capacity

PitchTimeQuality

enum class pulp::signal::PitchTimeQuality

strong

Enumerator
quality
low_latency

PitchTimeStreamFeedStatus

enum class pulp::signal::PitchTimeStreamFeedStatus

strong

Enumerator
accepted
backpressure
input_closed
invalid_request

PitchTimeStreamFinalizePlanStatus

enum class pulp::signal::PitchTimeStreamFinalizePlanStatus

strong

Enumerator
ready
needs_drain
complete
invalid_mode
invalid_request

PitchTimeStreamFinalizeStatus

enum class pulp::signal::PitchTimeStreamFinalizeStatus

strong

Enumerator
draining
backpressure
complete
invalid_mode
invalid_request

QuantizeMode

enum class pulp::signal::QuantizeMode

strong

How a QuantizeScaleT divides the octave.

Enumerator
edo	N equal steps per octave.
scale_mask	12-TET, then snapped to a 12-bit pitch-class mask.

ReverseBufferState

enum class pulp::signal::ReverseBufferState

strong

Enumerator
unprepared
bypassed
priming
running

RingCarrierMode

enum class pulp::signal::RingCarrierMode : std::uint8_t

strong

Enumerator
bipolar
unipolar

RingCarrierWaveform

enum class pulp::signal::RingCarrierWaveform : std::uint8_t

strong

Enumerator
sine
triangle
square

RingModulationModel

enum class pulp::signal::RingModulationModel : std::uint8_t

strong

Enumerator
ideal_multiplier
diode_ring

RingOutputPolarity

enum class pulp::signal::RingOutputPolarity : std::uint8_t

strong

Enumerator
normal
inverted

RiseFallStage

enum class pulp::signal::RiseFallStage : std::uint8_t

strong

Enumerator
idle
rising
falling

SaturatorAliasPolicy

enum class pulp::signal::SaturatorAliasPolicy : std::uint8_t

strong

How a SaturatorT keeps the harmonics it generates from folding back.

Enumerator
adaa	First-order antiderivative antialiasing. Half a sample of delay.
oversample_2x	House linear-phase half-band pair. Latency reported exactly.
off	Raw per-sample evaluation. Tests and the CPU floor only.
adaa2	Second-order antiderivative antialiasing. One sample of delay.

SaturatorShape

enum class pulp::signal::SaturatorShape : std::uint8_t

strong

Which member of the waveshaper family a SaturatorT evaluates.

Enumerator
tanh_soft	tanh(u). The canonical smooth saturator.
atan_soft	atan(u). Softer knee than tanh at the shoulder.
cubic_soft	u − u³/3, clipping at |u| ≥ 1. Hardest character.
sinh_arc	asinh(u). Unbounded and sub-linear; never hard-limits.

ScaleType

enum class pulp::signal::ScaleType : std::uint8_t

strong

The shipped scale collection, order-locked.

Index 0 is Major; a scale selector's domain is the closed index set {0..9} into this table. Masks are the standard diatonic/common-scale set so an audio-side "C Dorian" and a MIDI-side "C Dorian" agree. Public music theory, not a fitted table.

Enumerator
major	Ionian {0,2,4,5,7,9,11}.
natural_minor	Aeolian {0,2,3,5,7,8,10}.
dorian	{0,2,3,5,7,9,10}
phrygian	{0,1,3,5,7,8,10}
lydian	{0,2,4,6,7,9,11}
mixolydian	{0,2,4,5,7,9,10}
harmonic_minor	{0,2,3,5,7,8,11}
melodic_minor	ascending {0,2,3,5,7,9,11}
major_pentatonic	{0,2,4,7,9}
minor_pentatonic	{0,3,5,7,10}

ScannerMode

enum class pulp::signal::ScannerMode : std::uint8_t

strong

The console's six-position vibrato/chorus switch, plus off.

Enumerator
off	Bit-exact dry passthrough.
v1	Shallow vibrato — scanner output only.
v2	Medium vibrato.
v3	Full vibrato.
c1	Shallow chorus — scanner plus dry.
c2	Medium chorus.
c3	Full chorus. The lush one.

ScopeTriggerMode

enum class pulp::signal::ScopeTriggerMode : std::uint8_t

strong

Enumerator
immediate
rising_edge
falling_edge
either_edge

SeqDirection

enum class pulp::signal::SeqDirection

strong

How a StageSeqT walks from one stage to the next.

Enumerator
forward	(s + 1) mod N.
reverse	(s − 1 + N) mod N.
pingpong	Reflects at both ends without repeating them; period 2N − 2.
random	Seeded draw, rejection-sampled past skipped stages.

ShiftSource

enum class pulp::signal::ShiftSource : std::uint8_t

strong

Which control feeds the shift target.

The spec's API sketch carries both set_shift_semitones and set_pedal but no selector, while its parameter table describes shift_semitones as the "direct shift when not pedal-driven" — so the selector has to exist somewhere. Making it explicit beats a last-writer-wins rule that a host re-sending both automation lanes would flip back and forth every block.

Enumerator
pedal	set_pedal through the §5 law. The default.
direct	set_shift_semitones. Detents and the pedal law are bypassed.

SlewMode

enum class pulp::signal::SlewMode : std::uint8_t

strong

Rate limiter with independent rise and fall speeds.

Two modes, and they are not interchangeable:

• linear travels at a fixed slope. set_rise_ms(10) means a full 0 -> 1 step takes exactly 10 ms, no matter how far it actually has to go. This is the mode for portamento and for anything where the time is the musical quantity.
• exponential is a one-pole toward the target, so ms is a time constant (63.2% of the remaining distance) and the approach is asymptotic. This is the mode for de-clicking, where what matters is that the corner is gone, not how long it took.

RT contract: prepare() and setters recompute coefficients. process(), reset(), and accessors allocate nothing.

USE: portamento on a pitch control; gliding a stepped source so sample-and-hold burbles instead of clicking; motor-lag and tape-transport emulation, where the rise and fall genuinely differ; taming a square LFO into a trance gate whose edges are a knob rather than a hazard.

Enumerator
linear
exponential

SosCascadeInstallStatus

enum class pulp::signal::SosCascadeInstallStatus

strong

Enumerator
installed
not_prepared
over_capacity
non_finite
unstable

SosCascadeTransition

enum class pulp::signal::SosCascadeTransition

strong

Coefficient changes take effect immediately.

The policy says what happens to the recursive DF2T tail at that boundary; it does not crossfade designs.

Enumerator
reset_state
preserve_state

SourceFilterAnalysisStatus

enum class pulp::signal::SourceFilterAnalysisStatus : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidFftSize
InvalidOrder
InvalidIterationCount
InvalidTolerance
InvalidInputSize
InvalidOutputSize
InvalidWorkspaceSize
AllocationFailure
NonFiniteInput
NumericalOverflow
DegenerateInput
RankDeficient
UnstableModel
PredictionErrorOverflow
InvalidSampleRate
InvalidGain
ResponseSingularity

SpeakerBoxType

enum class pulp::signal::SpeakerBoxType

strong

Cabinet topology.

Sealed traps air behind the cone and stiffens it (the closed-box alpha of Small 1972); open-back lets the rear wave out, giving a near-free-air driver plus dipole cancellation.

Enumerator
sealed
open_back

SpectralBandEdgePolicy

enum class pulp::signal::SpectralBandEdgePolicy : std::uint8_t

strong

Enumerator
mute_outside
extend_edge_band

SpectralBandSpacing

enum class pulp::signal::SpectralBandSpacing : std::uint8_t

strong

Enumerator
linear
logarithmic

SpectralCodecError

enum class pulp::signal::SpectralCodecError

strong

Enumerator
None
UnsupportedFormat
InvalidGeometry
ResourceLimit
InvalidLength
InvalidChronology
InvalidComponent
NoncanonicalZero
AllocationFailure

SpectralCrossSynthesisNormalization

enum class pulp::signal::SpectralCrossSynthesisNormalization

strong

Enumerator
none
match_carrier_rms

SpectralDomain

enum class pulp::signal::SpectralDomain : std::uint8_t

strong

This enum exists because "sampling a spectral envelope makes timbre pitch-independent" is only true under a condition, and the two readings of that sentence are genuinely different sounds:

• absolute_hz (default) — break-points are frequencies in Hz, and a partial reads the envelope at its own absolute frequency. This is what Rodet & Depalle mean by a spectral envelope, and it is what a FORMANT is: a resonance of a fixed body, which does NOT move when the singer changes note. In this domain the relative spectrum legitimately changes with pitch — that is the vowel staying the same vowel.
• relative_to_f0 — break-points are multiples of the fundamental, and a partial reads the envelope at f_p / f0. The shape now slides with pitch, so the relative spectrum is identical at every fundamental. This is the fully scale-invariant reading: one morph knob producing the same timbral gesture at any pitch.

Neither is more correct; they answer different questions, and a spec that says both "the vowel tracks pitch" and "unlike a fixed filter" is asking for both at once. Note that the spectral_tilt_db_oct term is measured against log2(f_p/f0) and so is scale-invariant in BOTH domains — a pure tilt is the one envelope shape whose relative spectrum never depends on pitch, which is why the scale-invariance test can use tilt-like envelopes in either mode.

Enumerator
absolute_hz
relative_to_f0

SpectralMagnitudeInterpolation

enum class pulp::signal::SpectralMagnitudeInterpolation

strong

Enumerator
linear
equal_power

SpectralMaskBoundaryKernel

enum class pulp::signal::SpectralMaskBoundaryKernel : std::uint8_t

strong

Enumerator
hard
raised_cosine

SpectralPhaseInterpolation

enum class pulp::signal::SpectralPhaseInterpolation

strong

Enumerator
shortest_arc
normalized_vector

SpectralSplitResult

enum class pulp::signal::SpectralSplitResult : std::uint8_t

strong

Enumerator
Ok
NotPrepared
InvalidBlock
InvalidFrame
ChronologyExhausted
CapacityExceeded
NonfiniteSynthesis
OutputUnderrun
StreamStopped

SpectrumBandAggregation

enum class pulp::signal::SpectrumBandAggregation : std::uint8_t

strong

Enumerator
mean_power
maximum

SpectrumBandScale

enum class pulp::signal::SpectrumBandScale : std::uint8_t

strong

Enumerator
linear
logarithmic

SpectrumFrequencyWeighting

enum class pulp::signal::SpectrumFrequencyWeighting : std::uint8_t

strong

Enumerator
none
a
c

StageGateMode

enum class pulp::signal::StageGateMode

strong

What the gate does across the clock pulses a stage occupies.

Enumerator
hold	High for the whole stage.
repeat	A separate gate per pulse, at repeat_duty.
single	High on the first pulse only.
rest	Low for the whole stage — silence with duration.

StealPolicy

enum class pulp::signal::StealPolicy : std::uint8_t

strong

What happens when a grain is due and the pool is full.

Enumerator
oldest	Recycle the grain furthest through its window — the quietest one when durations match, so the edit is inaudible.
quietest	Recycle the smallest current w(phase)·g. For mixed lengths.
drop_new	Skip the incoming grain. Thins clouds rather than cutting.

StretchCharacter

enum class pulp::signal::StretchCharacter

strong

Character mode — the musically-distinct "engine per job" selector.

Each has a different artifact signature; pick by material/taste. clean — peak-lock phase vocoder + material-adaptive FFT (the default). Natural, time != pitch. Best for tonal/melodic/sustained. varispeed — pitch+time LINKED (pure resample) + speed-scaled tape head EQ. Tape character, NO stretch artifacts. Pitch follows tempo. phase_vocoder — reserved character mode; currently renders through the clean spectral path. Use relocate_transients for opt-in tempo-only transient grafting. granular — reserved for grain/stutter texture; currently renders as clean.

Enumerator
clean
varispeed
phase_vocoder
granular

StretchTransientMode

enum class pulp::signal::StretchTransientMode

strong

Transient strategy.

phase_reset uses the (causal) TransientPhasePolicy Röbel reset; verbatim_relocate (offline-only) grafts each ORIGINAL attack back onto the phase-vocoder output, peak-aligned, to restore the punch the PV smears. Active on the tempo-only spectral path; a no-op on tonal material (no onsets) and at ratio==1.

Enumerator
phase_reset
verbatim_relocate

SubOscillatorWaveform

enum class pulp::signal::SubOscillatorWaveform

strong

Output shape for a parent-phase-locked sub-oscillator.

Enumerator
square
sine

TapeArchetype

enum class pulp::signal::TapeArchetype : std::uint8_t

strong

Which machine's full preset a fresh instance starts from.

Enumerator
ampex_350_440	Documented NAB-native two-speed studio recorder lineage.
studer_a800	Documented NAB and CCIR-switchable multitrack.
cassette_deck	Fixed 1.875 ips, Type I / Type II EQ switch.

TapeCurve

enum class pulp::signal::TapeCurve : std::uint8_t

strong

Which recording standard's record/playback network pair is in force.

Enumerator
nab	NAB reel. Bass turnover AND treble turnover.
iec_ccir	IEC/CCIR reel. Treble turnover only — no bass shelf.
cassette_type1	Compact cassette, ferric ("Normal"). 3180 / 120 µs.
cassette_type2	Compact cassette, chrome. 3180 / 70 µs.

TempoDelayError

enum class pulp::signal::TempoDelayError : std::uint8_t

strong

Enumerator
none
not_prepared
invalid_division
invalid_tempo
invalid_sample_rate
invalid_delay
out_of_range

TempoDelayWrapperError

enum class pulp::signal::TempoDelayWrapperError : std::uint8_t

strong

Enumerator
none
not_prepared
invalid_sample_rate
invalid_capacity
unsupported_interpolation
invalid_delay
invalid_tempo
invalid_division
out_of_range
invalid_feedback
invalid_crossfeed
non_finite_input

TempoDelayWrapperInterpolation

enum class pulp::signal::TempoDelayWrapperInterpolation : std::uint8_t

strong

Enumerator
lagrange3
lagrange5
thiran1

TransitionCurve

enum class pulp::signal::TransitionCurve

strong

Enumerator
Smoothstep
EqualPower

UnisonGainLaw

enum class pulp::signal::UnisonGainLaw : std::uint8_t

strong

Enumerator
PeakSafe
EqualPower

VcaResponse

enum class pulp::signal::VcaResponse : std::uint8_t

strong

Enumerator
linear
exponential

VocoderCarrier

enum class pulp::signal::VocoderCarrier : std::uint8_t

strong

Where the thing that speaks comes from.

Enumerator
external	The caller's carrier_ext input: a pad, a guitar, anything rich.
internal	The module's own band-limited oscillator — the DVP-1 lesson.

VocoderWave

enum class pulp::signal::VocoderWave : std::uint8_t

strong

The internal carrier's shape. Both are polyBLEP-corrected.

Enumerator
saw
pulse

Function Documentation

adaa_linear_magnitude()

double pulp::signal::adaa_linear_magnitude ( int order, double cycles_per_sample )

inlinenoexcept

The linear-path magnitude response of order-th-order antiderivative antialiasing (1 or 2) at cycles_per_sample (0 … 0.5).

On a signal small enough to stay on the linear part of the curve, ADAA reduces to a short moving average of the input: (x[n] + x[n−1]) / 2 for first order and (x[n] + x[n−1] + x[n−2]) / 3 for second (the divided differences of u²/2 and u³/6). Their magnitudes are |cos(πf)| and |1 + 2cos(2πf)| / 3: −0.7 dB / −1.9 dB at 0.125, −3.0 dB / −9.5 dB at 0.25, and a null at Nyquist (first order) or at a third of the rate (second). That top-octave droop is part of what ADAA costs at the base rate and is reported, not hidden; running ADAA inside an oversampler is what moves it out of the audio band.

all_pole_magnitude_response()

template<typename SampleType>

SourceFilterAnalysisStatus pulp::signal::all_pole_magnitude_response ( std::span< const SampleType > coefficients, SampleType gain, SampleType sample_rate, int fft_size, std::span< SampleType > magnitude, std::span< SampleType > stability_workspace, SampleType stability_margin = std::numeric_limits<SampleType>::epsilon() * SampleType{64}, SampleType denominator_floor = std::numeric_limits<SampleType>::epsilon() * SampleType{64} )

nodiscardnoexcept

Evaluates gain / |A(e^jw)| at fft_size / 2 + 1 bins from DC through Nyquist.

The explicit Schur check runs before output mutation. This helper is analysis-only and does not construct a runtime filter.

analyze_spectral_band_resolution()

template<typename SampleType>

bool pulp::signal::analyze_spectral_band_resolution ( const SpectralBandLayoutT< SampleType > & layout, int fft_size, SampleType sample_rate, SpectralBandResolutionT< SampleType > & out_resolution )

noexcept

Report the number of discrete FFT bin centers directly owned by each band.

This is a failure-atomic control-thread operation with no dynamic allocation. It intentionally ignores boundary-kernel influence: the report answers whether every authored control has at least one distinct hard-boundary bin, not whether a smoothed transition can influence a neighboring bin.

angular_frequency()

double pulp::signal::angular_frequency ( double freq_hz, double sample_rate )

inline

Angular frequency (radians/sample) of freq_hz at sample_rate, clamped to [0, π].

Frequencies at or above Nyquist alias, so they saturate at π rather than wrapping around and reporting a bogus magnitude.

apply_preset()

void pulp::signal::apply_preset ( OfflineStretchOptions & o, const StretchPreset & p )

inline

Apply a preset to options (only the preset-managed fields; ratio/pitch are the caller's, not the preset's).

apply_spectral_mask()

template<typename SampleType>

bool pulp::signal::apply_spectral_mask ( std::complex< SampleType > *const * frames, int channels, int num_bins, const SpectralMaskTableT< SampleType > & table )

noexcept

Multiply one coherent positive-frequency frame group by a prepared mask.

Geometry and table values are validated before mutation, so failure is atomic. No allocation, locks, or I/O occur.

band_makeup_gain_db()

template<typename WeightFn>

float pulp::signal::band_makeup_gain_db ( std::span< const BandPowerGain > bands, WeightFn && weight, MakeupLimits limits )

inlinenodiscardnoexcept

The single-leg form over bands, each weighted by weight(lo_hz, hi_hz) – the material's energy between two frequencies (SpectrumCdf::weight, or any reference weighting).

bessel_i0() [1/2]

double pulp::signal::bessel_i0 ( double x )

inline

bessel_i0() [2/2]

float pulp::signal::bessel_i0 ( float x )

inline

Modified Bessel function of the first kind, order 0 Used in Kaiser window design.

bi_to_uni()

float pulp::signal::bi_to_uni ( float x )

inline

Bipolar [-1, 1] to unipolar [0, 1].

bipolar_from()

template<typename T = float>

T pulp::signal::bipolar_from ( std::uint64_t key )

inline

biquad_is_stable()

template<typename SampleType>

bool pulp::signal::biquad_is_stable ( const BiquadCoefficientsT< SampleType > & c )

inlinenoexcept

Return whether a normalized real biquad's poles are strictly inside the unit circle.

Non-finite coefficients fail the comparisons and are rejected.

blend_fade_out()

template<class Mixer, class OutView, class OldView>

bool pulp::signal::blend_fade_out ( Mixer & mixer, OutView & out, const OldView & old_render )

inlinenoexcept

Blend an already-rendered fading-out buffer into the live output under a TransitionMixer's old->new gains, then advance the mixer by the block.

Returns true when the fade has completed. Pure, RT-safe (no alloc/lock); the shared crossfade math for the reload hot-swap slot and the SignalGraph live plugin swap so both stay click-free by the same law. Templated on the mixer + buffer-view types to avoid a signal->audio header dependency; out holds the new render on entry and the blended result on return, old_render is the fading-out instance's render for this block. Channel/frame counts are the min of the two views. The mixer position is shared across channels (read before the loop, advanced once after).

blend_makeup_gain_db()

float pulp::signal::blend_makeup_gain_db ( std::span< const std::complex< double > > response, const LegSpectra & s, double mix, MakeupLimits limits )

inlinenodiscardnoexcept

Make-up, dB, for the two-leg model in the file comment: response is the wet leg's complex response per bin, s the legs' spectra on the same grid, mix the wet share.

0 dB when there is nothing to measure; the boost limit when the response removes everything.

bridged_t_center_frequency()

double pulp::signal::bridged_t_center_frequency ( double r_eff, const BridgedTComponents & c )

inlinenoexcept

Centre frequency of the bridged-T for a given total shunt resistance.

bridged_t_q()

double pulp::signal::bridged_t_q ( double r_eff, const BridgedTComponents & c )

inlinenoexcept

bridged_t_retuned_to()

BridgedTComponents pulp::signal::bridged_t_retuned_to ( const BridgedTComponents & c, double target_hz )

inlinenoexcept

Quality factor of the bridged-T network alone, with its three inputs grounded.

This is the bare network (~2.3 at nominal values), not the Q of the ring you hear: the feedback buffer wraps this network in a regenerative loop that raises the ringing Q by an order of magnitude, and the decay pot is what sets it.

With C41 == C42 this collapses to sqrt(R167 / R_eff) / 2 – independent of the capacitor values. Scaling both arms therefore retunes the drum while leaving Q exactly invariant, which is the signature a tune control has to reproduce. Scale both capacitive arms so the network's at-rest centre frequency lands on target_hz, returning the retuned components.

This is how the instrument is retuned on the bench: substituting a capacitor moves the pitch. With the two arms kept equal the centre frequency goes as 1/C while Q is independent of them, so scaling both by the ratio of current to target frequency moves the pitch and leaves the ring's character exactly where it was – which is what a tune control has to do, and why this is a retune rather than a pitch-shift bolted on top.

The at-rest branch resistance (r165 + r166, the state the network settles into between hits) is what the solve targets. During a hit the attack shunt and the leakage sigh move R_eff deliberately, and those are the drum's signature rather than error to be corrected.

Capacitance is clamped to the same physical range the components carry elsewhere, so an extreme request lands at the end of the range rather than silently reporting a pitch the network cannot reach.

bridged_t_shunt_resistance()

double pulp::signal::bridged_t_shunt_resistance ( double r_e, const BridgedTComponents & c )

inlinenoexcept

Total Vcomm-to-ground resistance seen by the network: R161 || R_e || R170.

This single quantity sets both the centre frequency and the Q, which is why it is the modulation target for the attack jump and the sigh alike.

build_spectral_mask()

template<typename SampleType>

bool pulp::signal::build_spectral_mask ( const SpectralBandLayoutT< SampleType > & layout, int fft_size, SampleType sample_rate, SpectralMaskTableT< SampleType > & out_table )

noexcept

Compile a complete positive-frequency gain table.

The operation is failure-atomic: out_table is unchanged if geometry or controls are bad. This is a control-thread operation; it performs no dynamic allocation.

capture_preset()

StretchPreset pulp::signal::capture_preset ( const OfflineStretchOptions & o, const std::string & name = "untitled" )

inline

Capture the preset-relevant fields FROM a configured OfflineStretchOptions.

cascade_is_stable()

bool pulp::signal::cascade_is_stable ( std::span< const FilterDesign::Coefficients > sos )

inline

Returns true if every biquad section's poles lie strictly inside the unit circle (i.e.

the filter is BIBO stable).

cascade_magnitude() [1/2]

double pulp::signal::cascade_magnitude ( std::span< const BiquadCoefficients > sos, double omega )

inline

cascade_magnitude() [2/2]

template<typename SampleType, std::size_t Extent>

double pulp::signal::cascade_magnitude ( std::span< const BiquadCoefficientsT< SampleType >, Extent > sos, double omega )

inline

Linear magnitude |H| of a cascade at angular frequency ω.

Sections are in series, so magnitudes multiply (equivalently, their dB values sum).

cascade_magnitude_db() [1/2]

float pulp::signal::cascade_magnitude_db ( std::span< const BiquadCoefficients > sos, double freq_hz, double sample_rate )

inline

cascade_magnitude_db() [2/2]

template<typename SampleType, std::size_t Extent>

float pulp::signal::cascade_magnitude_db ( std::span< const BiquadCoefficientsT< SampleType >, Extent > sos, double freq_hz, double sample_rate )

inline

Magnitude of a cascade at a frequency in Hz, in dB.

character_from_string()

bool pulp::signal::character_from_string ( const std::string & s, StretchCharacter & out )

inline

checked_allocation_bytes()

template<typename Element>

bool pulp::signal::checked_allocation_bytes ( std::uint64_t elements, std::uint64_t target_max_bytes, std::uint64_t * bytes = nullptr )

inlinenoexcept

checked_capacity_product()

bool pulp::signal::checked_capacity_product ( std::uint64_t lhs, std::uint64_t rhs, std::uint64_t maximum, std::uint64_t & product )

inlinenoexcept

checked_capacity_sum()

bool pulp::signal::checked_capacity_sum ( std::uint64_t lhs, std::uint64_t rhs, std::uint64_t maximum, std::uint64_t & sum )

inlinenoexcept

checked_fft_platform_setup_bytes()

template<typename SampleType>

bool pulp::signal::checked_fft_platform_setup_bytes ( std::uint64_t fft_size, std::uint64_t target_max_bytes, std::uint64_t & bytes )

inlinenoexcept

checked_fft_retained_bytes()

template<typename SampleType>

bool pulp::signal::checked_fft_retained_bytes ( std::uint64_t fft_size, std::uint64_t target_max_bytes, std::uint64_t & bytes )

inlinenoexcept

Complete retained-storage contract for one prepared FftT.

Keeping this beside FftT makes callers compose the transform's allocation policy instead of duplicating its platform-specific backing stores.

checked_finite_stretch_counter_geometry()

FiniteStretchCounterGeometryStatus pulp::signal::checked_finite_stretch_counter_geometry ( const RealtimePitchTimeConfig & config, std::uint64_t input_frames )

inlinenoexcept

checked_realtime_pitch_time_prepared_geometry()

template<typename SampleType>

PitchTimePrepareStatus pulp::signal::checked_realtime_pitch_time_prepared_geometry ( const RealtimePitchTimeConfig & config, double max_pitch_ratio, std::uint64_t requested_max_bytes, RealtimePitchTimePreparedGeometry< SampleType > & prepared )

noexcept

Derive all processor geometry and compose the retained-storage contracts of its owned DSP primitives without changing processor state.

checked_repeated_allocation_bytes()

template<typename Element>

bool pulp::signal::checked_repeated_allocation_bytes ( std::uint64_t elements_per_allocation, std::uint64_t repetitions, std::uint64_t target_max_bytes, std::uint64_t & aggregate_bytes )

inlinenoexcept

Validate one allocation against its address ceiling, then compute the aggregate retained charge for repetitions distinct allocations.

The aggregate is deliberately not compared with the per-allocation ceiling.

checked_spectral_delay_matrix_geometry()

template<typename SampleType>

std::optional< SpectralDelayMatrixGeometry< SampleType > > pulp::signal::checked_spectral_delay_matrix_geometry ( const SpectralDelayMatrixConfig & config, std::uint64_t target_max_bytes = kTargetAddressMaximumBytes )

inlinenoexcept

checked_spectral_frame_engine_geometry()

template<typename SampleType>

std::optional< SpectralFrameEngineGeometry > pulp::signal::checked_spectral_frame_engine_geometry ( const SpectralFrameEngineConfig & config, std::uint64_t target_max_bytes = kTargetAddressMaximumBytes )

inlinenoexcept

Derive every integer and typed backing-store capacity used by prepare().

target_max_bytes makes 32-bit target limits testable on a 64-bit host.

clamp_makeup_db_()

float pulp::signal::clamp_makeup_db_ ( double ratio, MakeupLimits limits )

inlinenodiscardnoexcept

comb_filter_response()

std::complex< double > pulp::signal::comb_filter_response ( CombFilterMode mode, std::size_t delay_samples, double gain, double omega )

inlinenoexcept

Returns H(e^jw) for the documented mode equations.

Invalid arguments return a complex NaN. omega is radians/sample.

compile_spectral_delay_matrix_table()

bool pulp::signal::compile_spectral_delay_matrix_table ( const SpectralDelayMatrixRecipe & recipe, int num_bins, int analysis_hop, double sample_rate, int maximum_delay_frames, SpectralDelayMatrixTable & out_table )

inline

crossfade_gains()

template<typename T>

void pulp::signal::crossfade_gains ( T u, CrossfadeGainLaw law, T & old_gain, T & new_gain )

inlinenoexcept

Old/new blend gains for an ALREADY-SHAPED progress u (the caller applies any smoothstep/clamp first).

Pure — no state, no allocation. Full-precision π/2 so the double instantiation is exact; at float precision the constant rounds to the same value the callers used before, so every float caller is unchanged.

crossfade_smoothstep()

template<typename T>

T pulp::signal::crossfade_smoothstep ( T t )

constexprnoexcept

Smoothstep progress shaping: cubic 3u²−2u³ with zero slope at both ends, clamped to [0,1].

constexpr/pure — the click-free ramp shared by the live-swap crossfades.

curve_fall()

float pulp::signal::curve_fall ( float p, float curve )

inline

Shape a falling stage: 1 -> 0 over p.

+1 is an exponential decay — fast initial drop into a long tail. -1 holds near the top and then falls off a cliff. See curve_rise() for why the signs differ.

curve_rise()

float pulp::signal::curve_rise ( float p, float curve )

inline

Shape a rising stage: 0 -> 1 over p, with curve in [-1, +1].

+1 is an exponential attack — slow to leave zero, then accelerating into the peak. -1 is a logarithmic attack: it jumps and then eases in.

The sign flip against stage_curve() is deliberate and is the whole reason these two helpers exist. The house convention labels +1 "exponential" and -1 "logarithmic", which is a decay-oriented convention (an exponential decay drops fast and then tails; an exponential attack starts slow and then rushes). One raw law cannot satisfy both readings with the same sign, so the law is applied to a rising stage with the sign inverted and to a falling stage directly. The result is that curve = +1 means "exponential" in the musical sense on every stage of every envelope in the library, which is the property a user setting one knob per stage actually needs.

db_to_linear()

float pulp::signal::db_to_linear ( float db )

inline

dB to linear gain conversion

dead_zone_saturate()

double pulp::signal::dead_zone_saturate ( double x, double dead_zone )

inline

A dead-zone saturator: a hard gap around zero, then a soft-limited slope.

The gap is what distinguishes this from an ordinary soft clipper. Digital audio chips of the 8- and 16-bit era produced no output at all for the smallest input codes, so a decaying tail does not fade smoothly — it thins out and then stops abruptly. That truncated tail is the characteristic sound; a tanh alone cannot produce it because tanh is smooth through zero.

dead_zone is the fraction of full scale that produces silence. The region above it is rescaled so the transfer curve stays continuous and still reaches full scale, then soft-limited so the rescaling cannot clip.

decode_spectral_stream()

SpectralCodecResult< OwnedSpectralStream > pulp::signal::decode_spectral_stream ( std::span< const std::uint8_t > bytes, std::uint64_t budget = spectral_codec_memory_budget )

inlinenoexcept

Validate the whole input before allocating; no partial stream is returned.

Bin checks operate on bits so subnormals survive host flush-to-zero modes.

denormals_are_flushed()

bool pulp::signal::denormals_are_flushed ( )

inlinenoexcept

Returns

true if the CPU is currently flushing denormals to zero. On the no-op fallback platform this is always false.

design_fir_equiripple()

FirEquirippleResult pulp::signal::design_fir_equiripple ( std::span< const FirEquirippleBand > bands, const FirEquirippleOptions & options )

inline

Equiripple (weighted minimax) design of a real Type I-IV linear-phase FIR by the Remez exchange, the Parks and McClellan method.

Where design_fir_least_squares minimizes weighted squared error and lets the worst-case error fall where it may, this equalizes the weighted error: the returned filter attains the same weighted ripple at every alternation point, which is the smallest achievable peak error for the tap count. That is what lets a caller state stopband depth and transition width as requirements instead of discovering them, which windowed-sinc design cannot express.

This function allocates and iterates. It is for design and control threads, never an audio callback. Work is O(iterations * r^3) in the number of independent coefficients r, plus O(iterations * grid * r) for the sweep, so large tap counts are deliberately an offline cost.

Determinism: the grid, the initial alternation set, the pivoting, and the extremum tie-breaking are all fixed, so a given input always yields the same output. Amplitudes are absolute signed zero-phase targets in the same convention as FirDesignPoint; there is no implicit normalization.

Fail-closed. The result carries empty coefficients unless status is success.

design_fir_least_squares()

FirLeastSquaresResult pulp::signal::design_fir_least_squares ( std::span< const FirDesignPoint > points, const FirLeastSquaresOptions & options )

inline

Weighted least-squares design of a real Type I, II, III, or IV linear-phase FIR.

This function allocates and performs O(grid*taps^2) work. It is for design and control threads, never an audio callback. Frequencies may be in any order. A deterministic column-pivoted Householder QR rejects rank loss and excessive R-diagonal spread instead of solving unstable normal equations. Targets are absolute signed zero-phase amplitudes: there is no implicit DC, peak, or energy normalization.

design_halfband_iir()

HalfBandIirDesign pulp::signal::design_halfband_iir ( std::size_t coefficient_count, double passband_edge )

inlinenoexcept

Closed-form elliptic half-band design (see the file comment).

coefficient_count is the number of allpass sections across both paths (filter order 2 * count + 1) and passband_edge the passband edge in cycles per sample at the filter's own rate, strictly inside (0, 0.25). Out-of-range arguments return an invalid (count == 0) design, including passband edges below kHalfBandIirMinPassbandEdge, where the selectivity underflows the theta series and every coefficient would come out zero. Near the other extreme (16 sections with an edge within ~1e-3 of 0.25) the transition is so narrow that the double-precision series loses accuracy and the stopband is no longer quite equiripple; halfband_iir_stopband_db() reports what the coefficients actually achieve. Not realtime: evaluates trigonometric series; call while configuring.

design_thiran1()

Thiran1Coefficients pulp::signal::design_thiran1 ( double delay_samples )

inlinenoexcept

Designs H(z) = (a + z^-1) / (1 + a z^-1), where a = (1 - D) / (1 + D).

D in [1, 2] keeps the pole radius at most 1/3.

design_windowed_sinc()

std::vector< double > pulp::signal::design_windowed_sinc ( std::size_t taps, double cutoff, double beta )

inline

determinant() [1/2]

template<typename SampleType>

SampleType pulp::signal::determinant ( const Matrix< 2, SampleType > & m )

inline

Determinant of a 2x2 matrix.

determinant() [2/2]

template<typename SampleType>

SampleType pulp::signal::determinant ( const Matrix< 3, SampleType > & m )

inline

Determinant of a 3x3 matrix.

encode_spectral_stream()

SpectralCodecResult< EncodedSpectralStream > pulp::signal::encode_spectral_stream ( const OwnedSpectralStream & in, std::uint64_t budget = spectral_codec_memory_budget )

inlinenoexcept

Canonicalize signed bin zeros without mutating the caller. Offline only.

erf_fn()

float pulp::signal::erf_fn ( float x )

inline

Error function.

erfc_fn()

float pulp::signal::erfc_fn ( float x )

inline

Complementary error function.

evaluate_transfer_curve()

template<typename SampleType, std::size_t MaxPoints>

SampleType pulp::signal::evaluate_transfer_curve ( const PreparedTransferCurveT< SampleType, MaxPoints > & curve, SampleType input )

noexcept

Evaluate a prepared curve.

Finite inputs are clamped to the explicit input domain; non-finite inputs recover to silence. Segment interpolation uses the shared modulation-curve vocabulary and cannot overshoot its endpoints.

exp_decay_coefficient()

double pulp::signal::exp_decay_coefficient ( double ms, double sample_rate )

inline

Per-sample multiplier for an exponential decay with time constant ms.

After ms milliseconds the envelope has fallen to 1/e (about -8.7 dB) of its starting value. This is the RC convention: it describes a capacitor discharging, which is what an analogue percussion envelope is.

fft_backend_available()

bool pulp::signal::fft_backend_available ( FftBackend b )

noexcept

True iff the backend can be instantiated on this machine right now.

vdsp is only available on Apple; fftw3/mkl require the shared lib to be loadable via dlopen at runtime.

fft_backend_name()

const char * pulp::signal::fft_backend_name ( FftBackend b )

noexcept

Stringify a backend tag for diagnostics / env-var parsing.

fft_bin_frequency()

double pulp::signal::fft_bin_frequency ( std::size_t index, std::size_t bin_count, double sample_rate )

inline

Center frequency of bin index in a real-FFT magnitude array.

A real FFT of n samples yields n/2 + 1 magnitude bins, linearly spaced from DC (bin 0) to Nyquist (the last bin) — NOT spanning some display range like 20 Hz–20 kHz. Plotting code that assumes otherwise misplaces every bin, so the mapping lives here next to the FFT's own contract rather than being re-guessed at each call site.

fill_ideal_string_shapes()

void pulp::signal::fill_ideal_string_shapes ( std::span< ModalShape > dst )

inline

Fill dst with the mode shapes of an ideal string fixed at both ends: dst[i] describes the (i+1)-th transverse mode, phi_m(x) = sin(m*pi*x), whose nodes are at x = k/m.

Pair with fill_mode_weights() to turn a strike or pickup position into per-mode weights.

fill_mode_weights()

template<typename SampleType = float>

void pulp::signal::fill_mode_weights ( std::span< SampleType > dst, std::span< const ModalShape > shapes, float position )

inline

Sample every shape in shapes at position, writing phi_m(position) to dst.

Multiply the result into ModalMode::gain for the strike side, or hand it to ModalBankT::set_pickup_gains() for the listening side; the two sides are independent, matching the modal expansion's separable phi_m(strike) * phi_m(pickup) coupling.

fill_strike_pulse()

template<typename SampleType = float>

void pulp::signal::fill_strike_pulse ( std::span< SampleType > dst, SampleType velocity )

inline

Fill dst with a raised-cosine contact pulse, peak-normalized to velocity.

The span length is the contact duration in samples: a short contact (hard mallet) has a flat excitation spectrum that reaches the high modes; a long contact (soft mallet) rolls the high modes off. Feed the pulse into ModalBankT::process_add as input to strike the object.

fir_response()

std::complex< double > pulp::signal::fir_response ( std::span< const double > coefficients, double omega )

inlinenoexcept

floor_shape()

template<typename Sample = double>

Sample pulp::signal::floor_shape ( Sample x, std::type_identity_t< Sample > threshold, FloorCurve curve )

inline

A noise-floor shaper: silence below threshold, rescaled above it.

This is the dead-zone geometry of dead_zone_saturate without the tanh. Where that function exists to truncate a decaying tail the way an early converter did, this one exists to lift a floor: everything under the threshold is discarded and the surviving region is stretched back to full scale. Only a full-scale input keeps its level; everything below it is pulled down, which is what makes a noise bed vanish rather than merely quieten.

The curve choice is audible at the threshold itself. linear arrives with a non-zero slope, which makes material hovering near the threshold chatter as it crosses; smoothstep leaves with zero slope and fades that crossing in.

Input beyond full scale saturates. That clamp is load-bearing rather than defensive: 3n^2 - 2n^3 is only a smoothstep on [0, 1]. Past it the curve turns over, reaches zero at n = 1.5, then goes negative — and copysign would hand that back as a large positive sample. A caller whose upstream gain can exceed unity, which is any caller with an EQ in front, would hear that as a burst rather than a floor.

Returns the shaped sample only. Deciding how much of it to use is the caller's: a dry/wet mix toward this value belongs at the call site, because the amount is usually a product-level control rather than a property of the transfer function.

freq_to_midi()

float pulp::signal::freq_to_midi ( float freq )

inline

Frequency to MIDI note number (A4 = 69).

gamma_fn()

float pulp::signal::gamma_fn ( float x )

inline

Gamma function approximation (Stirling's for large x, series for small).

halfband_iir_group_delay()

template<typename Coefficient = double>

double pulp::signal::halfband_iir_group_delay ( const HalfBandIirDesign & design, double frequency )

inlinenoexcept

Group delay of H(z) in samples of the filter's own rate.

Both paths are allpass, so dP/dw = -j tau_P P exactly and the half-band's delay is Re((tau_A A + (tau_B + 1) z^-1 B) / (A + z^-1 B)) with no numeric differentiation.

halfband_iir_magnitude_db()

template<typename Coefficient = double>

double pulp::signal::halfband_iir_magnitude_db ( const HalfBandIirDesign & design, double frequency )

inlinenoexcept

Magnitude of design in dB at frequency (cycles per sample of the filter's own rate).

halfband_iir_response()

template<typename Coefficient = double>

std::complex< double > pulp::signal::halfband_iir_response ( const HalfBandIirDesign & design, double frequency )

inlinenoexcept

Complex response of design at frequency cycles per sample of the filter's own rate: 1/2 (A(z^2) + z^-1 B(z^2)).

Coefficient selects the precision the coefficients are rounded to before evaluation, so a float filter's response includes its coefficient quantization.

halfband_iir_stopband_db()

template<typename Coefficient = double>

double pulp::signal::halfband_iir_stopband_db ( const HalfBandIirDesign & design )

inlinenoexcept

Worst-case (largest) stopband magnitude in dB over [stopband_edge(), 0.5], sampled densely enough to land on every ripple peak of designs up to kHalfBandIirMaxCoefficients.

has_feature()

bool pulp::signal::has_feature ( MeterFeatures set, MeterFeatures feature )

constexprnoexcept

interpolate_modulation_curve()

template<typename SampleType, typename ProgressType>

SampleType pulp::signal::interpolate_modulation_curve ( SampleType start, SampleType end, ProgressType progress, ModulationCurve curve = {} )

inlinenoexcept

is_denormal()

template<typename T>

bool pulp::signal::is_denormal ( T x )

inline

Return true if x is a denormal (subnormal) float.

Useful for diagnostics; not for hot paths.

is_valid_comb_filter_mode()

bool pulp::signal::is_valid_comb_filter_mode ( CombFilterMode mode )

inlineconstexprnoexcept

is_valid_fractional_delay_method()

bool pulp::signal::is_valid_fractional_delay_method ( FractionalDelayMethod method )

inlineconstexprnoexcept

is_valid_spectral_frame_geometry()

bool pulp::signal::is_valid_spectral_frame_geometry ( int fft_size, int analysis_hop )

inlinenoexcept

k_weighting_coefficients()

KWeightingCoefficients pulp::signal::k_weighting_coefficients ( double sample_rate )

inline

Return the two-stage K-weighting design for a sample rate.

The design is the bilinear-frequency-mapped form of the BS.1770-5 48 kHz reference filters; rates whose Nyquist frequency cannot represent the shelf return valid == false.

k_weighting_power()

double pulp::signal::k_weighting_power ( double hz, const pulp::signal::KWeightingCoefficients & k, double sample_rate )

inlinenodiscardnoexcept

|K(f)|^2 for BS.1770 K-weighting at sample_rate, through Pulp's own K-weighting design and biquad response evaluator.

1 where the rate cannot represent the design.

kaiser_beta_for_stopband()

double pulp::signal::kaiser_beta_for_stopband ( double stopband_db )

inline

kaiser_length_for_transition()

std::size_t pulp::signal::kaiser_length_for_transition ( double stopband_db, double normalized_width )

inline

kaiser_window()

void pulp::signal::kaiser_window ( std::vector< double > & output, double beta )

inline

ladder_tanh()

float pulp::signal::ladder_tanh ( float x )

inline

The ladder's default float saturator.

ladder_tanh_profiled() [1/2]

template<auto RealtimeEfficient>
requires std::is_same_v<decltype(RealtimeEfficient), bool>

float pulp::signal::ladder_tanh_profiled ( float x )

inline

The previous boolean form: true is the Padé saturator, false is exact std::tanh, as before LadderSaturation existed.

ladder_tanh_profiled() [2/2]

template<auto Saturation>
requires std::is_same_v<decltype(Saturation), LadderSaturation>

float pulp::signal::ladder_tanh_profiled ( float x )

inline

The ladder's float saturator for an explicit choice.

Both forms take an auto parameter constrained to its exact type. With a typed LadderSaturation parameter MSVC converts the argument true to the enumerator whose value is 1 (accurate) and reports the boolean call as ambiguous (C2668); Clang and GCC never consider that conversion.

lagrange5()

template<typename SampleType>

SampleType pulp::signal::lagrange5 ( double fraction, SampleType ym2, SampleType ym1, SampleType y0, SampleType y1, SampleType y2, SampleType y3 )

noexcept

lagrange5_weights()

std::array< double, 6 > pulp::signal::lagrange5_weights ( double fraction )

inlinenoexcept

lanczos()

float pulp::signal::lanczos ( float x, int a )

inline

Lanczos kernel (used in high-quality resampling).

levinson_durbin()

template<typename SampleType>

LevinsonDurbinResultT< SampleType > pulp::signal::levinson_durbin ( std::span< const SampleType > autocorrelation, std::span< SampleType > coefficients, std::span< SampleType > reflection_coefficients, std::span< SampleType > workspace, SampleType rank_tolerance = std::numeric_limits<SampleType>::epsilon() * SampleType{64} )

nodiscardnoexcept

Solves A(z) = 1 + sum(a[k] z^-(k+1)).

workspace must hold order elements. Rejection zeroes coefficients and reflections, so partial models are never published.

lfo_wave()

double pulp::signal::lfo_wave ( LfoWave wave, double phase, const LfoShapeParams & params = {} )

inlinenodiscardnoexcept

The trivial value of wave at phase (any real number of cycles), in [-1, 1].

What a display draws, and the value every other function here agrees with away from a corner and in the limit of a vanishing interval.

lfo_wave_bandlimited()

double pulp::signal::lfo_wave_bandlimited ( LfoWave wave, double phase, double increment, const LfoShapeParams & params = {} )

inlinenodiscardnoexcept

The band-limited value of wave for a consumer that reads it EVERY sample, at phase with a per-sample phase step of increment (cycles).

The trivial waveform plus the polyBLEP correction for each step in its value (the saw's wrap, the square's two edges) and the polyBLAMP correction for each break in its slope (the triangle's apex and trough). Each correction reaches the sample before a corner and the sample after it, which is why this is stateless: both taps are placed from the phase's distance to the corner. The kernels are osc::poly_blep / osc::poly_blamp, with their documented reach – tens of dB over the trivial waveform, not a tabulated kernel's hundred.

A non-positive or non-finite increment (a stopped LFO) reads as the trivial waveform: nothing is moving, so nothing is discontinuous.

lfo_wave_integral()

double pulp::signal::lfo_wave_integral ( LfoWave wave, double phase, const LfoShapeParams & params = {} )

inlinenodiscardnoexcept

The cumulative integral of wave from phase 0 to phase, in value x cycles.

Continuous in phase, defined for any real phase, so the mean of an interval is (integral(to) - integral(from)) / (to - from).

lfo_wave_is_periodic()

bool pulp::signal::lfo_wave_is_periodic ( LfoWave wave )

nodiscardconstexprnoexcept

True for the waves that are periodic functions of phase (everything but the two random waves).

lfo_wave_mean()

double pulp::signal::lfo_wave_mean ( LfoWave wave, double from, double to, const LfoShapeParams & params = {} )

inlinenodiscardnoexcept

The exact mean of wave over the phase interval [from, to], in any units of whole cycles and of any length: the band-limited value for a consumer that takes one value per interval.

A zero-length interval is the point value at from, so a consumer may shrink its interval to nothing and read the trivial waveform; to < from is treated as the interval the other way round.

linear_phase_fir_amplitude()

double pulp::signal::linear_phase_fir_amplitude ( std::span< const double > coefficients, LinearPhaseFirType type, double omega )

inlinenoexcept

Signed amplitude after removing the exact linear delay of a Type I-IV FIR.

Symmetric filters use the real component. Antisymmetric filters use the +j component, matching FirDesignPoint::amplitude.

linear_to_db()

float pulp::signal::linear_to_db ( float linear )

inline

Linear gain to dB conversion.

lipschitz_tanh()

double pulp::signal::lipschitz_tanh ( double v )

inlinenoexcept

A [3/2] Padé tanh that is 1-LIPSCHITZ and bounded — the saturator to reach for inside a feedback loop.

This is a different curve from FastMath::tanh, not a cheaper one, and the difference is the whole reason it exists. FastMath::tanh chases fidelity to std::tanh; this one is chosen for a property. Its derivative is (x^2-9)^2 / (9(3+x^2)^2), which is exactly 1 at the origin and strictly below 1 everywhere else, so it can never amplify — and the clamp at the point where the curve reaches unity (f(3) = 1 exactly) makes it bounded as well, without breaking that slope bound.

Inside a recursion those two properties are load-bearing. A saturator with small-signal gain above 1 (tanh(k*x) for k > 1 is the usual way to get one) silently raises the loop gain with it, which turns a decay-time control into a stability question; an unbounded one lets a self-oscillating loop settle only by growing more slowly than it decays. Two modules derived this same curve independently for those reasons — the character delay's dub feedback and the FDN reverb's in-loop drive — so it is defined once, here.

load_modes()

template<typename SampleType>

void pulp::signal::load_modes	(	const ModalSpec &	spec,
		ModalBankT< SampleType > &	bank,
		std::vector< ModalMode > &	scratch,
		float	strike_position = 0.5f,
		float	pickup_position = 0.5f )

Resolve the spec at a strike/pickup position and load the result into an already-prepared bank.

scratch holds the resolved modes; reuse the same vector across calls to keep a live position sweep allocation-free. The bank must have been prepared for at least spec.modes.size() modes — ModalBankT::set_modes silently ignores the excess otherwise.

log_frequency_at()

double pulp::signal::log_frequency_at ( std::size_t index, std::size_t count, double min_hz, double max_hz )

inline

Frequency of sample index of count, log-spaced across [min_hz, max_hz].

Index 0 lands exactly on min_hz and index count-1 exactly on max_hz — the spacing a frequency plot's x-axis uses, so a curve sampled with this maps one-to-one onto evenly spaced pixels of a log axis.

lower_beat_repeat_capture()

BeatRepeatPlanResult pulp::signal::lower_beat_repeat_capture ( const timebase::CompiledTempoMap & tempo, timebase::BeatDivision division, timebase::SamplePosition requested_sample )

inlinenoexcept

Lower the first grid edge strictly after requested_sample and the exact preceding grid interval into integer host samples.

Tempo ramps and segment anchors are resolved by CompiledTempoMap itself.

lpc_stability()

template<typename SampleType>

SourceFilterAnalysisStatus pulp::signal::lpc_stability ( std::span< const SampleType > coefficients, std::span< SampleType > workspace, SampleType stability_margin = std::numeric_limits<SampleType>::epsilon() * SampleType{64} )

nodiscardnoexcept

Explicit Schur step-down stability test for the A(z) coefficient convention used above.

workspace must contain exactly coefficients.size() elements. stability_margin rejects poles closer than that margin to the unit circle.

magnitude_db()

template<typename SampleType>

float pulp::signal::magnitude_db ( const BiquadT< SampleType > & filter, double freq_hz, double sample_rate )

inline

Ask a live filter what it looks like: the magnitude, in dB, that this BiquadT is applying at freq_hz with its coefficients as they stand.

magnitude_to_db()

float pulp::signal::magnitude_to_db ( double magnitude )

inline

Convert a linear magnitude to dB, floored at min_response_db.

make_bell_voice()

VoiceTable pulp::signal::make_bell_voice ( int count = 64 )

inline

The bell voice (§10b): a modal body whose partials each decay at their own rate.

The five named modes — hum 0.5, prime 1.0, tierce ≈1.2, quint 1.5, nominal 2.0 — are the documented tuned partials of the modern English church bell (Perrin, Charnley & de Pont 1983; Fletcher & Rossing). Ratios above the nominal are design parameters: the cited work establishes that higher modes exist, but the specific fill used here (2.50, 2.66, 3.00, 4.00, 5.00, then a geometric 5.0·1.14^(p−9) cluster) is not individually sourced from it. All amplitudes and decay times throughout are design parameters.

The decay SPREAD is the point of this voice and the reason per_partial_decay exists: the nominal rings for 2.5 s while the p=10 cluster mode dies in about 526 ms, a ~4.75:1 ratio, heard as the bell brightening downward into its hum.

Geometric spacing of the upper-mode cluster above the tenth partial. [design parameter] default 1.14, range 1.05 .. 1.30.

Upper-cluster amplitude and decay laws. [design parameter] default level 0.20 with exponent 1.5; decay scale 3000 ms divided by the ratio.

make_organ_voice()

VoiceTable pulp::signal::make_organ_voice ( int count = 64 )

inline

The drawbar organ voice (§10a): nine tonewheel footages over a −12 dB/oct harmonic tail.

The footage→harmonic mapping is documented behaviour (Hammond, US Patent 1,956,350): 16′→0.5, 5⅓′→1.5, 8′→1, 4′→2, 2⅔′→3, 2′→4, 1⅗′→5, 1⅓′→6, 1′→8. The drawbar LEVELS shipped here are a "full principal" registration and are design parameters — a registration is a performance choice, not a published constant. Partials past the ninth fill in as a −12 dB/oct tail so the voice has body instead of stopping at a synthetic cliff.

Every partial is sustained (decay_ms ≤ 0): a tonewheel does not decay, it is switched. All stored phases are 0 — documented tonewheel voices are phase-coherent.

Level of the harmonic tail at ratio 1, before its −12 dB/oct rolloff. [design parameter] default 0.30, range 0.0 .. 1.0.

make_spectral_stream()

SpectralCodecResult< OwnedSpectralStream > pulp::signal::make_spectral_stream ( SpectralStreamGeometry g, std::uint64_t count, std::uint64_t budget = spectral_codec_memory_budget )

inlinenoexcept

Allocate an editable owned stream with canonical chronology and zero bins.

Nonthrowing allocation failure leaves no partially published value.

makeup_gain_db()

float pulp::signal::makeup_gain_db ( std::span< const double > response_power, std::span< const double > spectrum_power, MakeupLimits limits )

inlinenodiscardnoexcept

The single-leg, real-response form: per-bin power response |H|^2 against a per-bin power spectrum on the same grid.

A flat response is 0 dB.

mid_side_decode()

template<typename SampleType>

void pulp::signal::mid_side_decode ( SampleType mid, SampleType side, SampleType & left, SampleType & right )

inlinenoexcept

mid_side_decode_block()

template<typename SampleType>

bool pulp::signal::mid_side_decode_block ( const SampleType * mid, const SampleType * side, SampleType * left, SampleType * right, std::size_t frames )

inlinenoexcept

mid_side_encode()

template<typename SampleType>

void pulp::signal::mid_side_encode ( SampleType left, SampleType right, SampleType & mid, SampleType & side )

inlinenoexcept

Orthonormal stereo transform.

The 1/sqrt(2) normalization makes the transform self-inverse and preserves L2 energy: L^2 + R^2 == M^2 + S^2. IEEE non-finite samples propagate. Output buffers must not overlap each other; either output may exactly alias either input.

mid_side_encode_block()

template<typename SampleType>

bool pulp::signal::mid_side_encode_block ( const SampleType * left, const SampleType * right, SampleType * mid, SampleType * side, std::size_t frames )

inlinenoexcept

midi_to_freq()

float pulp::signal::midi_to_freq ( float note )

inline

MIDI note number to frequency.

mix64() [1/2]

std::uint64_t pulp::signal::mix64 ( std::uint64_t seed, std::uint64_t index, std::uint64_t field = 0u )

constexpr

Purpose-keyed overload used when seed, index, and field are already separate values.

It remains a pure stateless draw.

mix64() [2/2]

std::uint64_t pulp::signal::mix64 ( std::uint64_t z )

constexpr

splitmix64 finalizer (Steele, Lea & Flood, OOPSLA 2014).

A bijective avalanche mix, not a generator: it has no state, so it turns any key into a well-distributed value.

mode_shape_at()

float pulp::signal::mode_shape_at ( const ModalShape & shape, float position )

inline

Evaluate a mode's shape at a normalized position along the body.

Evaluated in double: the argument grows with the mode index, so a float sin() leaves a high mode's nodes progressively less null (about 1e-4 of full scale by mode 1000). A node that is only approximately a node defeats the point of striking one, and this is control-rate arithmetic.

modulation_curve_progress()

template<typename SampleType>

SampleType pulp::signal::modulation_curve_progress ( SampleType progress, ModulationCurve curve, bool rising )

inlinenoexcept

nway_constant_power_gains()

template<typename SampleType>

bool pulp::signal::nway_constant_power_gains ( SampleType position, std::span< SampleType > gains )

inlinenoexcept

Compute adjacent-path constant-power weights for a position in [0, N-1].

All unselected weights are zero and sum(weight^2) is one. A non-finite position selects path zero. Empty output is rejected.

offline_stretch_output_frames()

long pulp::signal::offline_stretch_output_frames ( long in_frames, double time_ratio )

inlinenoexcept

The exact, sample-accurate output length for an input of in_frames frames at the given time ratio: round(in_frames * time_ratio).

The sampler relies on this being exact so stretched loops stay locked to the host bar grid. This is the single source of truth for the output length and MUST match the number of frames process() writes.

onset_energy_flux()

double pulp::signal::onset_energy_flux ( double previous, double current )

inlinenoexcept

Pure novelty transitions shared by fixed-capacity streaming analysis and background/offline adapters.

The first window is represented by callers as zero novelty because it has no predecessor.

onset_spectral_bin_flux()

double pulp::signal::onset_spectral_bin_flux ( OnsetDetectionMethod method, double previous, double current, std::size_t bin )

inlinenoexcept

operator!=()

bool pulp::signal::operator!= ( const ModalSpec & a, const ModalSpec & b )

inline

operator==()

bool pulp::signal::operator==	(	const ModalSpec &	a,
		const ModalSpec &	b )

Exact equality over every known field.

Float fields are compared bit-wise; this is a round-trip check, not a perceptual one.

operator|()

MeterFeatures pulp::signal::operator| ( MeterFeatures a, MeterFeatures b )

constexprnoexcept

parse_fft_backend()

FftBackend pulp::signal::parse_fft_backend ( const char * s )

noexcept

Parse a backend tag from a string. Unknown / empty → auto_.

parse_modal_spec()

std::optional< ModalSpec > pulp::signal::parse_modal_spec	(	std::string_view	json,
		ModalSpecDiagnostics *	diagnostics = nullptr )

Parse a ModalSpec from JSON.

Returns std::nullopt on any failure — malformed JSON, a missing or mistyped required field, a value that fails validation — with a message in diagnostics->error. It never returns a partially-populated spec and never silently substitutes a default for a field that was present but wrong: a typo'd t60 must fail loudly, because a spec whose numbers are not the numbers you wrote is worse than no spec.

── Version and unknown-field policy ──────────────────────────────────────

• schema_version is required. A version newer than kModalSpecSchemaVersion is rejected — a breaking change is the only reason the version moves, so this build provably cannot read it. Older versions are accepted (v1 is the only version so far).
• Unrecognized fields at any level are ignored and reported in diagnostics->unknown_fields. This is what lets an additive field ship without a version bump.
• Ignored fields are not preserved: to_json(parse(x)) drops them. Loading and re-saving a file written by a newer producer therefore loses that producer's additions. Tools that re-save should check unknown_fields and refuse, or warn, rather than quietly truncate.

plan_processing_switch()

ProcessingSwitchPlan pulp::signal::plan_processing_switch ( std::int64_t incoming_latency, std::int64_t incoming_history, double sample_rate, double fade_seconds )

inlinenodiscardnoexcept

The plan for switching INTO a realisation with incoming_latency samples of delay that needs incoming_history samples of input before its output is steady (an FIR's length; zero for a realisation that primes its own stream start).

The fade is fade_seconds at sample_rate. Pure.

prepare_and_load()

template<typename SampleType>

void pulp::signal::prepare_and_load	(	const ModalSpec &	spec,
		ModalBankT< SampleType > &	bank,
		double	sample_rate,
		float	strike_position = 0.5f,
		float	pickup_position = 0.5f )

Prepare bank to hold this spec's modes at sample_rate and load them.

Allocates (prepare()); loader thread only.

prepare_parallel_dynamics_config()

template<typename SampleType = float>

std::optional< PreparedParallelDynamicsConfigT< SampleType > > pulp::signal::prepare_parallel_dynamics_config ( const ParallelDynamicsConfigT< SampleType > & config, std::size_t max_latency_samples )

noexcept

Validate a complete control snapshot and derive its audio-rate gains.

Equal-gain is the linear law for correlated dry/processed signals. Equal- power is available for decorrelated or deliberately phase-altered wet paths. Both laws have exact dry-only and wet-only endpoints.

prepare_transfer_curve()

template<typename SampleType = float, std::size_t MaxPoints = 32>

std::optional< PreparedTransferCurveT< SampleType, MaxPoints > > pulp::signal::prepare_transfer_curve ( std::span< const TransferCurvePointT< SampleType > > points, SampleType input_min, SampleType input_max, SampleType output_min, SampleType output_max )

noexcept

Validate and prepare a piecewise transfer curve.

Points must be finite, strictly ordered by input, and lie inside the explicit input/output domains. The first and last point must coincide with the input-domain endpoints. Invalid input returns std::nullopt without a partial result. This bounded control-side operation allocates no memory.

preset_from_text()

bool pulp::signal::preset_from_text ( const std::string & text, StretchPreset & out, std::string * err = nullptr )

inline

Parse a preset.

Tolerant: blank lines and # comments skipped, unknown keys ignored, whitespace trimmed. Returns false (with *err set) only on a malformed value for a recognized key (e.g. a bad character name).

preset_to_text()

std::string pulp::signal::preset_to_text ( const StretchPreset & p )

inline

processing_switch_gains_at()

template<typename SampleType = float>

void pulp::signal::processing_switch_gains_at ( const ProcessingSwitchPlan & plan, std::int64_t position, SampleType & outgoing, SampleType & incoming )

inlinenoexcept

Gains for the outgoing and incoming outputs at absolute position samples into a switch following plan.

Pure: the whole schedule as a function.

q43_branch_resistance()

double pulp::signal::q43_branch_resistance ( double vcomm, const BridgedTComponents & c, const Q43Leakage & leak, double guard_v = -0.01 )

inlinenoexcept

Resistance of the Vcomm-to-ground branch through R166, Q43's collector and R165 (DAFx-14 Eq.

9, algebraically collapsed to one multiply-add and one divide). With iC == 0 this is exactly R165 + R166; as Q43 leaks it falls, which raises the bridged-T's centre frequency. That is the pitch sigh: it emerges from the ring amplitude, and there is no pitch envelope anywhere.

Eq. 9's denominator vanishes at Vcomm ~ +17uV, and Vcomm crosses zero twice per ring cycle, so samples land near that pole routinely rather than rarely. The pole is an artifact of the fit, not of the circuit: Eq. 8's softplus tail never quite reaches zero, so it reports ~0.36 nA of leakage at Vcomm = 0 where a real Q43 is simply off. Eq. 9 then divides by that fiction. Two defences, and both are needed:

• Above guard_v the branch is the series value outright. This is not an approximation of Eq. 9 so much as a repair of it – it discards a region the fit was never valid in (leakage is a below-the-knee phenomenon, and the knee is at -0.556 V). What it costs is the real correction near the threshold: 0.195% of R_e at -10 mV, worth about 0.04 Hz of centre frequency. What it buys is the removal of a pole that Eq. 9 approaches through +/-infinity.
• The clamp is the second line of defence, against a re-fit of Eq. 8's constants moving the pole. It cannot stand alone: raw values near the pole go negative, and a negative value clamps to R166 – which is the attack tuning, so a clamp-only implementation emits spurious blips an octave up rather than a glitch you would notice as a glitch.

q43_collector_current()

double pulp::signal::q43_collector_current ( double vcomm, const Q43Leakage & leak )

inlinenoexcept

Q43's collector current for a given Vcomm (DAFx-14 Eq.

8): a negated softplus, so iC is ~zero above the knee and turns linear below it. The current is negative by this fit's sign convention – it is drawn in.

Evaluated by the softplus's asymptotic branches rather than the literal log1p(exp(e)). A hard strike drives Vcomm several volts negative, which puts e well past the point where exp() overflows, and clamping e there would be worse than the overflow it prevents: it freezes the leakage at whatever current the clamp corresponds to, so R_e stops falling and turns back up again – the drum's pitch would bend the wrong way on its loudest hits. Both branches below are exact to double precision at their thresholds, so the function stays monotone over the whole rail-to-rail range.

quantization_step()

template<typename SampleType>

SampleType pulp::signal::quantization_step ( SampleType bits )

inlinenoexcept

Mid-tread quantization step for a continuous bit-depth control.

quantize_bits()

double pulp::signal::quantize_bits ( double x, double bits )

inline

Quantises to bits of resolution, mid-tread, symmetric about zero.

bits is a continuous control rather than an integer: sweeping it is musically useful and the rounding grid is well defined between whole bit depths. Values at or above 24 return the input unchanged, because at that point the quantisation step is below the noise floor of anything the caller will play it through and the rounding only costs cycles.

quantize_with_error_feedback()

template<typename SampleType>

DitheredQuantizationResultT< SampleType > pulp::signal::quantize_with_error_feedback ( SampleType input, SampleType step, DitherMode dither_mode, NoiseShapingOrder shaping, NoiseShaperStateT< SampleType > & state, SampleType first_uniform = SampleType{}, SampleType second_uniform = SampleType{} )

inlinenoexcept

One allocation-free error-feedback transition.

First order realizes the noise-transfer function 1 - z^-1; second order realizes (1 - z^-1)^2. Error memory is clamped to four quantization steps and snapped away from denormals. A non-finite input or arithmetic overflow emits zero and clears the memory, so one bad frame cannot poison the tail.

reconstruct_minimum_phase_fir()

MinimumPhaseFirResult pulp::signal::reconstruct_minimum_phase_fir ( std::span< const double > one_sided_magnitudes, const MinimumPhaseFirOptions & options = {} )

inline

Reconstruct a causal minimum-phase FIR from N/2+1 nonnegative magnitude bins.

Input bins cover DC through Nyquist for the implied even FFT size N=2*(bins-1). Exact zeros are floored before the logarithm. Retaining fewer than N coefficients truncates the circular impulse and therefore changes the requested magnitude; measured_magnitudes and errors always report that post-truncation result. This is allocation-allowed offline or control work, never an audio callback. The result is minimum phase within the finite, floored FFT geometry; it is not a linear-phase design.

resolve_fft_backend()

FftBackend pulp::signal::resolve_fft_backend ( FftBackend hint = FftBackend::auto_ )

noexcept

Resolve auto_ → best available backend on this machine, honoring the PULP_FFT_BACKEND env var if set to a concrete backend that is available.

Never returns FftBackend::auto_.

resolve_modes() [1/2]

void pulp::signal::resolve_modes ( const ModalSpec & spec, float strike_position, float pickup_position, std::vector< ModalMode > & out )

inline

Resolve the spec's modes at a strike/pickup position into out.

With no shape maps this copies modes verbatim, gains included — the property the whole verification story rests on. With maps, each gain is multiplied by its strike and pickup weights. out is resized rather than reallocated when it already has capacity, so a caller that pre-sizes it can sweep a strike position without allocating.

resolve_modes() [2/2]

std::vector< ModalMode > pulp::signal::resolve_modes ( const ModalSpec & spec, float strike_position = 0.5f, float pickup_position = 0.5f )

inline

Convenience overload; allocates.

response_curve_db() [1/2]

void pulp::signal::response_curve_db ( std::span< const BiquadCoefficients > sos, double min_hz, double max_hz, double sample_rate, std::span< float > out )

inline

response_curve_db() [2/2]

template<typename SampleType, std::size_t Extent>

void pulp::signal::response_curve_db ( std::span< const BiquadCoefficientsT< SampleType >, Extent > sos, double min_hz, double max_hz, double sample_rate, std::span< float > out )

inline

Sample a cascade's magnitude response into out, at out.size() log-spaced frequencies spanning [min_hz, max_hz], in dB.

This is the stage a curve widget wants: hand it one point per pixel column and the result is the polyline, already in the plot's own x-spacing. Allocation-free — out is caller-owned.

rng_key()

std::uint64_t pulp::signal::rng_key ( std::uint64_t purpose, std::uint64_t index )

constexpr

Combine a purpose tag and an index into a key for unit_from().

The golden constant is added, not just multiplied by: mix64 is a bijection and therefore maps 0 to 0, so without it the natural first key — purpose 0, index 0 — would land exactly on the finalizer's fixed point and draw 0.

rotation_x()

Matrix4 pulp::signal::rotation_x ( float radians )

inline

4x4 rotation around X axis

rotation_y()

Matrix4 pulp::signal::rotation_y ( float radians )

inline

4x4 rotation around Y axis

rotation_z()

Matrix4 pulp::signal::rotation_z ( float radians )

inline

4x4 rotation around Z axis

round_half_even()

long long pulp::signal::round_half_even ( double x )

inlinenoexcept

Round half to even, in integer logic.

Spelled out rather than delegated because the two obvious library calls disagree at exactly the values this schedule hits: std::llround rounds half AWAY from zero, and std::nearbyint only rounds half-to-even while the FP rounding mode is at its default — which a host, a plugin loaded alongside, or a -ffast-math translation unit may have changed. The snap has to be bit-reproducible across platforms, so it does not depend on either.

sanitize_modulation_curve()

ModulationCurve pulp::signal::sanitize_modulation_curve ( ModulationCurve curve )

inlinenoexcept

scale_matrix()

Matrix4 pulp::signal::scale_matrix ( float sx, float sy, float sz )

inline

4x4 scale matrix

scaled_autocorrelation()

template<typename SampleType>

AutocorrelationResultT< SampleType > pulp::signal::scaled_autocorrelation ( std::span< const SampleType > samples, int order, std::span< SampleType > autocorrelation )

nodiscardnoexcept

Biased autocorrelation of a safely normalized signal.

Every lag uses the same samples.size() divisor, preserving a positive-semidefinite Toeplitz sequence. The returned values describe samples / input_scale.

section_group_delay()

template<typename SampleType>

double pulp::signal::section_group_delay ( const BiquadCoefficientsT< SampleType > & c, double omega )

inline

Group delay of one biquad section at omega (radians per sample), in samples: -d(arg H)/d(omega) for H = B/A, evaluated in closed form as tau(B) - tau(A) with tau(P) = Re(sum k p_k z^-k / sum p_k z^-k), so no numeric differentiation is involved.

section_magnitude() [1/2]

double pulp::signal::section_magnitude ( const BiquadCoefficients & c, double omega )

inline

section_magnitude() [2/2]

template<typename SampleType>

double pulp::signal::section_magnitude ( const BiquadCoefficientsT< SampleType > & c, double omega )

inline

Linear magnitude |H(e^jω)| of one section at normalized angular frequency ω = 2π·f/fs (radians/sample, meaningful over [0, π]).

section_magnitude_db() [1/2]

float pulp::signal::section_magnitude_db ( const BiquadCoefficients & c, double freq_hz, double sample_rate )

inline

section_magnitude_db() [2/2]

template<typename SampleType>

float pulp::signal::section_magnitude_db ( const BiquadCoefficientsT< SampleType > & c, double freq_hz, double sample_rate )

inline

Magnitude of one section at a frequency in Hz, in dB.

sinc()

float pulp::signal::sinc ( float x )

inline

Sinc function: sin(pi*x) / (pi*x), with sinc(0) = 1.

smoothstep()

float pulp::signal::smoothstep ( float p )

inline

Cubic smoothstep, 3t^2 - 2t^3.

Zero slope at both ends, unlike the exponential law, which is the right shape for a crossfade or a knob feel that must not click at either extreme.

snap_chunks()

SnapChunks pulp::signal::snap_chunks ( std::size_t num_samples )

constexprnoexcept

snap_recursion_state()

template<typename T>

T pulp::signal::snap_recursion_state ( T x )

inline

Snap a per-sample recursion's state: snap_to_zero() where subnormals are slow, the identity where kSubnormalsAreFree.

Block paths keep snapping once per kSnapChunkSamples chunk with snap_to_zero().

snap_threshold()

template<typename T>

T pulp::signal::snap_threshold ( )

inlineconstexpr

Threshold in absolute value below which a sample is treated as zero.

1e-15f corresponds to about -300 dB FS for float — well below any audible level and well above the denormal range (~1.4e-45f).

snap_to_zero() [1/2]

template<typename T>

void pulp::signal::snap_to_zero ( T * samples, int n )

inline

Snap an entire buffer in place.

snap_to_zero() [2/2]

template<typename T>

T pulp::signal::snap_to_zero ( T x )

inline

Returns 0 if |x| < snap_threshold, else x.

Branchless on most compilers (compiles to a cmpltps + andps pair on x86-SSE).

RT contract: snap_threshold(), scalar/buffer snap_to_zero(), and is_denormal() are allocation-free. is_denormal() is intended for diagnostics, not audio hot paths.

source_filter_fft_size_valid()

bool pulp::signal::source_filter_fft_size_valid ( int fft_size )

inlinenoexcept

spectral_frame_engine_first_frame_start()

std::int64_t pulp::signal::spectral_frame_engine_first_frame_start ( int fft_size, int analysis_hop, bool full_overlap_stream_start )

inlineconstexprnoexcept

Stream position of the first analysis frame after prepare()/reset().

With full overlap this is the largest multiple of analysis_hop that lies above -fft_size, so every frame that overlaps input sample 0 exists.

spectral_ola_window_energy()

template<typename SampleType>

double pulp::signal::spectral_ola_window_energy ( const SampleType * window, int fft_size, int hop, std::int64_t first_frame_start, std::int64_t position )

inlinenoexcept

Accumulated squared synthesis window at stream position for equal-hop frames of length fft_size starting at first_frame_start + k * hop (k >= 0) — the per-sample divisor the WOLA path normalizes by.

Pure, so a test or tool can state the coverage at any sample without running audio.

stage_curve()

float pulp::signal::stage_curve ( float p, float curve )

inline

The shared stage-shaping law:

shaped(p) = (1 - e^(-k*p)) / (1 - e^(-k)),   k = kCurveSpan * curve

Maps p in [0, 1] onto [0, 1], monotonically, with shaped(0) = 0 and shaped(1) = 1 for every curve. curve = 0 is the linear limit (the formula is 0/0 there, so it is special-cased to the analytic limit p).

This is the raw law. Callers shaping an envelope stage should use curve_rise() / curve_fall() below rather than this directly — see the note there about what "+1 = exponential" means for a stage that falls.

stereo_width()

template<typename SampleType>

SampleType pulp::signal::stereo_width ( SampleType left, SampleType right, SampleType width, SampleType & out_left, SampleType & out_right )

inlinenoexcept

Mono-safe width built on the orthonormal transform.

Width is linear side gain in [0, 2]; non-finite values select unity so malformed automation does not collapse or explode the image. Returns the sanitized width.

t60_decay_coefficient()

double pulp::signal::t60_decay_coefficient ( double ms, double sample_rate )

inline

Per-sample multiplier for a decay that reaches -60 dB after ms.

This is the T60 convention used to describe how long a struck body rings. It is the natural unit for a resonator's decay time and for any control labelled "decay" in seconds, because it matches what a listener hears as the end of the sound; exp_decay_coefficient is the natural unit when modelling a specific RC network.

tempo_delay_samples()

TempoDelayResult pulp::signal::tempo_delay_samples ( timebase::BeatDivision division, double beats_per_minute, double sample_rate )

inlinenodiscardnoexcept

Convert an exact persisted musical division to a fractional delay length.

A beat is one quarter note regardless of meter. Straight, dotted, and triplet values come from timebase::beat_fraction() as reduced integer rationals. The returned fractional sample count is not rounded; the delay interpolation owner chooses its own sample-addressing policy.

thiran1_group_delay_samples()

double pulp::signal::thiran1_group_delay_samples ( const Thiran1Coefficients & design, double omega )

inlinenoexcept

Exact group delay of the first-order allpass at angular frequency omega.

thiran1_magnitude()

double pulp::signal::thiran1_magnitude ( const Thiran1Coefficients & design, double omega )

inlinenoexcept

to_json()

std::string pulp::signal::to_json	(	const ModalSpec &	spec,
		bool	pretty = true )

Serialize a spec to JSON.

Emits every known field, including defaulted ones, so the output is a complete self-describing document and a diff between two specs shows every difference rather than only the overridden ones. pretty emits line breaks — leave it on for files people read and version-control.

Round-trip contract: for any spec that parse_modal_spec accepted, parse_modal_spec(to_json(s)) yields a spec equal to s (modulo any unknown fields, which are already gone by then).

to_string()

const char * pulp::signal::to_string ( StretchCharacter c )

inline

tpdf_centered_sum()

template<typename SampleType>

SampleType pulp::signal::tpdf_centered_sum ( SampleType first, SampleType second )

constexprnoexcept

tpdf_difference()

template<typename SampleType>

SampleType pulp::signal::tpdf_difference ( SampleType first, SampleType second )

constexprnoexcept

Converts two independent uniform draws in [0, 1) to unit-peak TPDF noise.

The difference spelling preserves existing converter streams that already use u1 - u2; the centered-sum spelling preserves streams using u1 + u2 - 1. Both have zero mean and variance 1/6.

transform()

Vec3 pulp::signal::transform ( const Matrix4 & m, const Vec3 & v )

inline

translation_matrix()

Matrix4 pulp::signal::translation_matrix ( float x, float y, float z )

inline

4x4 translation matrix

uni_to_bi()

float pulp::signal::uni_to_bi ( float x )

inline

Unipolar [0, 1] to bipolar [-1, 1].

unit_from() [1/2]

template<typename T>

T pulp::signal::unit_from ( std::uint64_t key )

inline

unit_from() [2/2]

float pulp::signal::unit_from ( std::uint64_t key )

inline

Stateless purpose-keyed draw in [0, 1).

USE: per-voice / per-partial / per-tap detune and offsets. Deriving them from unit_from(rng_key(purpose, index)) instead of a shared stream makes each one independent of when it was requested, so adding a voice or reordering initialisation cannot shuffle every other value.

validate_modal_spec()

bool pulp::signal::validate_modal_spec	(	const ModalSpec &	spec,
		std::string &	error )

Check a spec's internal consistency.

Returns false and fills error with a message naming the offending field (and mode index, where there is one) on the first problem found. parse_modal_spec runs this, so a spec that parses is already valid; call it directly after building a spec in code.

velvet_noise_draw()

template<typename SampleType = double>

VelvetNoiseDrawT< SampleType > pulp::signal::velvet_noise_draw ( std::uint64_t seed, std::uint64_t index )

inlinenoexcept

Pure draw for one velvet grid cell.

Coordinates, rather than call order, select the draw, so a full build and an incremental build are identical.

velvet_noise_offset()

template<typename SampleType>

int pulp::signal::velvet_noise_offset ( const VelvetNoiseDrawT< SampleType > & draw, SampleType grid_samples )

inlinenoexcept

Converts a grid draw to its zero-based sample offset.

A cell of width one always lands at zero; wider cells use the same nearest-sample rule as Pulp's existing ambience tap builder.

Variable Documentation

kCurveSpan

float pulp::signal::kCurveSpan = 8.0f

inlineconstexpr

Curve span for the shared stage-shaping law.

8 puts the extremes at roughly a 20:1 slope ratio between the start and end of a stage — audibly a strong curve without becoming a step.

kCyclicStretchLongFrame

CyclicStretchRegime pulp::signal::kCyclicStretchLongFrame {200.0, 8, 8.0, 0.0}

inlineconstexpr

"Glitchy long frame" — tens of milliseconds per grain, a short linear splice, cycle_hz left wherever it happens to be.

At 48 kHz with the default cycle this resolves to N = 1920 (40 ms), X = 154, S = 1766, so the flutter sits at 27.2 Hz — an audible robotic buzz with obvious repetition granularity. The jungle / lo-fi vocal. [design parameters; see the node's parameter table for ranges]

kCyclicStretchShortFrame

CyclicStretchRegime pulp::signal::kCyclicStretchShortFrame {200.0, 1, 45.0, 1.0}

inlineconstexpr

"Clean-ish short frame" — one cycle per grain, a generous equal-power splice, cycle_hz meant to be tuned to the material's fundamental.

At 48 kHz this resolves to L = 240, N = 240, X = 108, S = 132, so the flutter sits at 363.6 Hz — high enough to read as a metallic sheen above the pitch rather than a discrete buzz. The "it almost sounds like a real stretch" setting. [design parameters; see the node's parameter table for ranges]

kDefaultCoefficientsA

std::array<float, 3> pulp::signal::kDefaultCoefficientsA

inlineconstexpr

Initial value:

= {
    0.04536216434896102f,
    0.3371496879790739f,
    0.7080641363635385f,
}

Default half-band design: design_halfband_iir(6, 0.21), path A.

Passband flat (droop < 1e-8 dB) to 0.21 of the 2x rate (0.42 of the input rate when upsampling), stopband at or below -94.8 dB from 0.29 of the 2x rate, DC group delay 3.16 samples at the 2x rate. A test pins these literals to the design function.

kDefaultCoefficientsB

std::array<float, 3> pulp::signal::kDefaultCoefficientsB

inlineconstexpr

Initial value:

= {
    0.16808748123450207f,
    0.5223778543083539f,
    0.8974455911727747f,
}

Default half-band design, path B. See kDefaultCoefficientsA.

kDefaultFirDesignWorkspaceBytes

std::uint64_t pulp::signal::kDefaultFirDesignWorkspaceBytes = 256u * 1024u * 1024u

inlineconstexpr

kDefaultLadderSaturation

LadderSaturation pulp::signal::kDefaultLadderSaturation = LadderSaturation::accurate

inlineconstexpr

Selecting the default ladder saturator at build time:

• PULP_SIGNAL_LADDER_SATURATION = 0 (exact), 1 (accurate) or 2 (realtime_efficient) selects it explicitly;
• otherwise PULP_SIGNAL_FAST_LADDER_TANH keeps its original meaning: defined to 1 selects realtime_efficient, defined to 0 selects exact std::tanh (the default before the accurate saturator existed);
• with neither defined the default is accurate.

This is the single source of truth for the saturator: LadderFilterT<float> (the interpreter) and the live-kernel f2_ladder_tanhf export (the F2 WASM emitter) both route through it, so the per-node bit-exact null test stays green under any setting.

kGoldenGamma

std::uint64_t pulp::signal::kGoldenGamma = 0x9E3779B97F4A7C15ull

inlineconstexpr

The 64-bit golden-ratio odd constant that splitmix64 steps its state by.

kHalfBandIirMaxCoefficients

std::size_t pulp::signal::kHalfBandIirMaxCoefficients = 16

inlineconstexpr

Largest coefficient count a HalfBandIirDesign carries (eight sections per path).

Order 33 already reaches the float noise floor at any useful transition width.

kHalfBandIirMinPassbandEdge

double pulp::signal::kHalfBandIirMinPassbandEdge = 1e-4

inlineconstexpr

Smallest passband edge design_halfband_iir() accepts, in cycles per sample at the filter's own rate.

kHardwareFlushSupported

bool pulp::signal::kHardwareFlushSupported = false

inlineconstexpr

True when this build sets the hardware flush-to-zero mode.

False on the no-op fallback (e.g. MSVC/ARM64), where DSP must rely on snap_to_zero.

kHouseHalfBandStageOnePassband

double pulp::signal::kHouseHalfBandStageOnePassband = 0.45

inlineconstexpr

kHouseHalfBandStageTwoPassband

double pulp::signal::kHouseHalfBandStageTwoPassband = 0.225

inlineconstexpr

kHouseHalfBandStopbandDb

double pulp::signal::kHouseHalfBandStopbandDb = 81.3

inlineconstexpr

kHouseHalfBandTaps

std::size_t pulp::signal::kHouseHalfBandTaps = 65

inlineconstexpr

Pulp's low-latency linear-phase half-band design.

Character-delay hysteresis and the drum output stage share these exact constants so the "house pair" cannot drift into two almost-identical filters.

kMaximumFirDesignPointCount

std::size_t pulp::signal::kMaximumFirDesignPointCount = 65536u

inlineconstexpr

kMaximumFirDesignTapCount

std::size_t pulp::signal::kMaximumFirDesignTapCount = 1023u

inlineconstexpr

kMaximumMinimumPhaseFirSize

std::size_t pulp::signal::kMaximumMinimumPhaseFirSize = 65536u

inlineconstexpr

Largest admitted radix-2 FFT size for minimum-phase reconstruction.

This mirrors the point-count bound: the one-sided input is a sampled grid too.

kMaximumTempoDelayBpm

double pulp::signal::kMaximumTempoDelayBpm = timebase::kMaximumCompiledTempoBpm

inlineconstexpr

kMaximumTempoDelaySampleRate

double pulp::signal::kMaximumTempoDelaySampleRate

inlineconstexpr

Initial value:

=
    static_cast<double>(timebase::kMaximumCompiledSampleRate)

kMaxMeterChannels

int pulp::signal::kMaxMeterChannels = 16

staticconstexpr

Maximum supported channel count for metering.

kMaxMeterInputMagnitude

double pulp::signal::kMaxMeterInputMagnitude = 1.0e6

staticconstexpr

Finite samples outside this deliberately generous audio-domain ceiling are clipped before every peak, RMS, correlation, and loudness calculation.

This keeps double-input arithmetic deterministic instead of allowing a finite but non-audio value to overflow a squared-energy accumulator.

kMinimumTempoDelayBpm

double pulp::signal::kMinimumTempoDelayBpm = timebase::kMinimumCompiledTempoBpm

inlineconstexpr

These bounds intentionally match TempoMap / CompiledTempoMap: a delay synchronized to a transport must accept exactly the tempo and sample-rate domain that the transport can compile.

kModalSpecSchemaVersion

int pulp::signal::kModalSpecSchemaVersion = 1

inlineconstexpr

Schema version this build writes and is the highest it can read.

Bumped only for a breaking change — a field whose meaning changed, or one whose absence can no longer be defaulted safely. Additive fields ship without a bump and are picked up by the unknown-field policy below, so an older build keeps loading a newer additive file instead of rejecting it.

kRealtimePitchTimeMaximumChannels

int pulp::signal::kRealtimePitchTimeMaximumChannels = 64

inlineconstexpr

kScaleCount

int pulp::signal::kScaleCount = 10

inlineconstexpr

Number of entries in the shipped scale table.

kScaleTable

std::uint16_t pulp::signal::kScaleTable[kScaleCount]

inlineconstexpr

Initial value:

= {
    music::scale_intervals(music::kPulpSignalScales[0].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[1].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[2].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[3].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[4].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[5].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[6].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[7].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[8].scale)->mask(),
    music::scale_intervals(music::kPulpSignalScales[9].scale)->mask(),
}

Pitch-class masks, bit k set ⇒ semitone k above the root is in the scale.

Order-locked: index 0 is Major, index 9 is Minor pentatonic.

kSimdAlignment

size_t pulp::signal::kSimdAlignment = 64

staticconstexpr

Alignment in bytes for SIMD operations (covers AVX-512).

kSnapChunkSamples

std::size_t pulp::signal::kSnapChunkSamples = 64

inlineconstexpr

Samples a block path runs between denormal snaps of its recursive state.

Snapping once per chunk instead of after every sample keeps the snap out of the per-sample recursion. It changes nothing above snap_threshold(): a state at or above it at the start of a chunk cannot decay into the float subnormal range within 64 samples unless its pole is inside |z| < 0.44 (1e-15 * 0.44^64 is still above FLT_MIN), and a faster-decaying state falls through that range within the chunk. Either way, subnormal residency is bounded by one chunk however long the buffer is. Block paths that also rescan their input for faults use the same chunk as their unit.

kSourceFilterMaximumEnvelopeIterations

int pulp::signal::kSourceFilterMaximumEnvelopeIterations = 1024

inlineconstexpr

kSourceFilterMaximumFftSize

int pulp::signal::kSourceFilterMaximumFftSize = 1 << 20

inlineconstexpr

kSourceFilterMaximumLpcOrder

int pulp::signal::kSourceFilterMaximumLpcOrder = 256

inlineconstexpr

kSourceFilterMinimumFftSize

int pulp::signal::kSourceFilterMinimumFftSize = 256

inlineconstexpr

kSpectralBandMaskMaximumBands

std::size_t pulp::signal::kSpectralBandMaskMaximumBands = 64

inlineconstexpr

kSpectralBandMaskMaximumBins

std::size_t pulp::signal::kSpectralBandMaskMaximumBins

inlineconstexpr

Initial value:

=
    static_cast<std::size_t>(kSpectralFrameEngineMaximumFftSize / 2 + 1)

kSpectralBandMaskMaximumTransitionFrames

std::uint32_t pulp::signal::kSpectralBandMaskMaximumTransitionFrames = 4096

inlineconstexpr

kSpectralDelayMaximumRetainedBytes

std::size_t pulp::signal::kSpectralDelayMaximumRetainedBytes = std::size_t{1} << 29u

inlineconstexpr

kSpectralDelayMinimumRetainedBytes

std::size_t pulp::signal::kSpectralDelayMinimumRetainedBytes = std::size_t{1} << 20u

inlineconstexpr

kSpectralFrameEngineMaximumFftSize

int pulp::signal::kSpectralFrameEngineMaximumFftSize = 16384

inlineconstexpr

kSpectralFrameEngineMaximumRingSize

std::uint64_t pulp::signal::kSpectralFrameEngineMaximumRingSize

inlineconstexpr

Initial value:

=
    std::uint64_t{1} << 30u

kSpectralFrameEngineMinimumFftSize

int pulp::signal::kSpectralFrameEngineMinimumFftSize = 256

inlineconstexpr

kSpectralMaskProcessorDefaultMaximumRetainedBytes

std::uint64_t pulp::signal::kSpectralMaskProcessorDefaultMaximumRetainedBytes

inlineconstexpr

Initial value:

=
    std::uint64_t{256} << 20u

kSubnormalsAreFree

bool pulp::signal::kSubnormalsAreFree

inlineconstexpr

Initial value:

=
 
 
 
    false

Whether subnormal arithmetic runs at full speed on this target.

64-bit ARM cores handle subnormal operands in hardware at no extra cost; x86 takes a slow assist per subnormal operation, which is what snapping recursive state exists to avoid. Where subnormals are free, a per-sample recursion does not snap its state (snap_recursion_state() is the identity): the snap's compare and select sat inside the recursion's dependency chain and made per-sample calls 2.3-2.7x slower on M5 Max. The output matches a snapping build bit for bit until a state value first falls below snap_threshold(), 1e-15 (about -300 dB). From then on the tail keeps decaying instead of stopping at zero, and the two differ only at the tail's own scale (below 1e-13, about -260 dB, for the filters measured).

Every Pulp plug-in and graph entry point already runs its audio under ScopedFlushDenormals. A per-sample caller outside such an entry that needs subnormal-free state on any target should hold a ScopedFlushDenormals across its loop.

kTargetAddressMaximumBytes

std::uint64_t pulp::signal::kTargetAddressMaximumBytes

inlineconstexpr

Initial value:

=
    static_cast<std::uint64_t>(std::numeric_limits<std::size_t>::max())

kTriggerHighThreshold

double pulp::signal::kTriggerHighThreshold = 0.5

inlineconstexpr

kTriggerLowThreshold

double pulp::signal::kTriggerLowThreshold = 0.25

inlineconstexpr

kVdspFftSetupChargeBytesPerPoint

std::uint64_t pulp::signal::kVdspFftSetupChargeBytesPerPoint = 64

inlineconstexpr

Conservative policy charge for Accelerate's opaque float FFT setup.

Apple does not expose its allocation size, so admission treats the setup as one allocation bounded at 64 bytes per transform point. muFFT-backed float transforms charge the shim's bound for their plans and staging buffers, several allocations whose largest must fit target_max_bytes; the built-in transform owns no platform setup and charges zero.

kVdspSplitPaddingFloats

std::uint64_t pulp::signal::kVdspSplitPaddingFloats = 84

inlineconstexpr

Floats a float FftT's vDSP split buffer holds beyond its two N-point halves: up to 15 to reach a 64-byte boundary, a 4-float (16-byte) step off it, and a 64-float (256-byte) gap between the halves, which is how their placement is pinned (see FftT).

min_response_db

float pulp::signal::min_response_db = -200.0f

inlineconstexpr

Floor applied to dB conversions.

A notch's null is a true zero, so its magnitude in dB is -inf; clamping keeps curve points finite and plottable.

spectral_codec_memory_budget

std::uint64_t pulp::signal::spectral_codec_memory_budget = 128ULL * 1024 * 1024

inlineconstexpr