NO_LOGGING. More...

Namespaces
namespace	Analytics

namespace	AttenuationInterface

namespace	ChannelMapPrivate

namespace	ConvertDeinterleavePrivate

namespace	DirectedGraphAlgoPrivate

namespace	EarlyReflectionsPrivate

namespace	EAudioMixerStreamDataFormat

namespace	EAudioOutputStreamState

namespace	EBiquadFilter

namespace	EBufferType

namespace	EChorusDelays

namespace	EDynamicsProcessingMode

namespace	EFilter

namespace	ELFO

namespace	ELFOMode

namespace	EMasterSubmixType

namespace	EMusicalScale

namespace	EnvelopeFollowerPrivate

namespace	EOsc

namespace	EPeakMode

namespace	ESeekType

namespace	ESoundFileChannelMap

namespace	ESoundFileError

namespace	ESoundFileFormat

namespace	ESoundFileOpenMode

namespace	ESoundFileSeekMode

namespace	ESoundFileState

namespace	EStereoDelayMode

namespace	EWaveTable

namespace	FFTIntrinsics

namespace	FMixerSubmixPrivate

namespace	Grain

namespace	GrainDelay

namespace	ListenerOrientationInterface

namespace	MathIntrinsics

namespace	MixerSourcePrivate

namespace	MixerSubmixIntrinsics

namespace	ModulationInterfacePrivate

namespace	ModulationPrivate

namespace	ModulationUtils

namespace	MultichannelBufferPrivate

namespace	Note

namespace	ParameterInterfaceRegistryPrivate

namespace	ParameterPrivate

namespace	PitchShiftUtils

namespace	PseudoConstantQIntrinsics

namespace	Quartz

namespace	SoundFileUtils

namespace	SourceOrientationInterface

namespace	SpatializationInterface

namespace	SpectrumAnalyzerIntrinsics

namespace	SphericalHarmonicsPrivate

namespace	Trace

namespace	VectorOps

Classes
struct	DisjointedArrayView

class	FADEnvelope

class	FAlignedBlockBuffer

class	FAllPassFractionalDelay

class	FAmp

class	FAnalyzerFacade

class	FAnalyzerNRTFacade

struct	FAnalyzerNRTParameters

struct	FAnalyzerParameters

class	FAsyncDecodeWorker

class	FAsyncSoundWavePCMWriteWorker

class	FAsyncSpectrumAnalyzer

class	FAsyncSpectrumAnalyzerScopeLock

class	FAttackRelease

class	FAttackReleaseSmoother

struct	FAudioBufferDistanceAttenuationSettings

struct	FAudioBusKey

struct	FAudioBusSend

class	FAudioCapture

class	FAudioCaptureAndroidFactory

class	FAudioCaptureAndroidModule

class	FAudioCaptureAndroidStream

class	FAudioCaptureAudioUnitFactory

class	FAudioCaptureAudioUnitModule

class	FAudioCaptureAudioUnitStream

struct	FAudioCaptureDeviceParams

class	FAudioCaptureRtAudioFactory

class	FAudioCaptureRtAudioModule

class	FAudioCaptureRtAudioStream

class	FAudioCaptureSynth

class	FAudioCaptureWasapiFactory

class	FAudioCaptureWasapiModule

class	FAudioCaptureWasapiStream

struct	FAudioClockTimingData

class	FAudioFileWriter

class	FAudioFormatSettings

class	FAudioMixerEffectsManager

struct	FAudioMixerOpenStreamParams

class	FAudioMixerPlatformAudioLink

class	FAudioMixerPlatformSwappable

class	FAudioMixerWasapi

class	FAudioMixerWasapiDeviceThread

class	FAudioMixerWasapiRenderStream

class	FAudioMixerWasapiRunnable

struct	FAudioOutputStreamInfo

struct	FAudioPlatformDeviceInfo

struct	FAudioRecordingData

class	FAudioRenderScheduler

class	FAudioRenderStepId

struct	FAudioRenderTimeAnalysis

struct	FAudioThreadTimingData

class	FBaseChannelFormatConverter

class	FBiquadFilter

class	FBitCrusher

class	FBlockCorrelator

struct	FBlockCorrelatorSettings

class	FBufferLinearEase

class	FBufferOnePoleLPF

struct	FCaptureDeviceInfo

struct	FChannelMapParams

struct	FChannelPositionInfo

class	FCheckedAudioBuffer

struct	FCheckedBufferState

struct	FChildSubmixInfo

class	FChorus

class	FContiguousSparse2DKernelTransform

struct	FConvertDeinterleaveParams

class	FConvolutionFactory

struct	FConvolutionSettings

struct	FDecodeAudioTaskData

struct	FDecodeAudioTaskResults

class	FDecodeHandle

class	FDecodeHandleBase

class	FDecodingSoundSource

struct	FDecodingSoundSourceHandle

class	FDelay

class	FDelayAPF

class	FDelayStereo

struct	FDeviceSwapContext

struct	FDeviceSwapResult

struct	FDirectedGraphAlgo

class	FDynamicDelayAPF

class	FDynamicsProcessor

class	FDynamicStateVariableFilter

class	FEarlyReflections

class	FEarlyReflectionsFast

struct	FEarlyReflectionsFastSettings

struct	FEarlyReflectionsSettings

class	FEnvelope

class	FEnvelopeFollower

struct	FEnvelopeFollowerInitParams

class	FEqualizer

struct	FEventQuantizationSettings

class	FEventQuantizer

class	FExponentialEase

struct	FFDNCoefficients

struct	FFDNDelaySettings

class	FFeedbackDelayNetwork

class	FFFTFactory

struct	FFFTSettings

class	FFlanger

class	FFoldbackDistortion

class	FGrain

struct	FGrainData

class	FGrainEnvelope

class	FGranularSynth

class	FHeaderDecodeHandle

struct	FHeaderParseAudioTaskData

struct	FInitAudioBusSend

class	FInlineEnvelopeFollower

struct	FInlineEnvelopeFollowerInitParams

class	FIntegerDelay

class	FInterpolatedHPF

class	FInterpolatedLPF

class	FInterpolatedMultiTapDelay

class	FLadderFilter

class	FLateReflectionsFast

struct	FLateReflectionsFastSettings

class	FLateReflectionsPlate

struct	FLateReflectionsPlateDelays

struct	FLateReflectionsPlateOutputs

class	FLFO

class	FLinearCurve

class	FLinearEase

class	FLinearInterpFractionalDelay

class	FLinearPitchShifter

struct	FLinkwitzRileyBandFilter

class	FLinkwitzRileyBandSplitter

class	FLongDelayAPF

class	FMeanSquaredFIR

class	FMeanSquaredIIR

struct	FMelSpectrumKernelSettings

class	FMidiNoteQuantizer

class	FMixerAudioBus

class	FMixerBuffer

class	FMixerDevice

class	FMixerNullCallback

class	FMixerPlatformAndroid

class	FMixerPlatformAudioUnit

class	FMixerPlatformCoreAudio

class	FMixerPlatformNonRealtime

class	FMixerPlatformSDL

class	FMixerPlatformXAudio2

class	FMixerSource

class	FMixerSourceBuffer

struct	FMixerSourceBufferInitArgs

class	FMixerSourceManager

class	FMixerSourceSubmixOutputBuffer

struct	FMixerSourceSubmixOutputBufferSettings

struct	FMixerSourceSubmixSend

class	FMixerSourceVoice

struct	FMixerSourceVoiceInitParams

class	FMixerSubmix

struct	FModulationDestination

class	FModulationMatrix

struct	FModulationParameter

struct	FModulatorHandle

class	FMovingAverager

class	FMovingVectorAverager

struct	FMultibandBuffer

class	FMultichannelLinearResampler

class	FNullAudioCaptureDevice

class	FOnePoleFilter

class	FOnePoleLPF

class	FOnePoleLPFBank

class	FOsc

struct	FOscFrequencyMod

class	FOutputBuffer

class	FParam

struct	FParameterInterface

struct	FParameterPath

class	FParameterTransmitterBase

struct	FParameterTransmitterInitParams

struct	FPassiveFilterParams

struct	FPatch

struct	FPatchDestination

class	FPatchInput

class	FPatchMixer

class	FPatchMixerSplitter

struct	FPatchOutput

struct	FPatchSource

class	FPatchSplitter

struct	FPersistentQuartzSubsystemData

class	FPhaser

class	FPinkNoise

class	FPlateReverb

class	FPlateReverbFast

struct	FPlateReverbFastSettings

struct	FPlateReverbSettings

struct	FProceduralAudioTaskData

struct	FProceduralAudioTaskResults

class	FProceduralDecodeHandle

struct	FProxyDataInitParams

struct	FPseudoConstantQ

struct	FPseudoConstantQBandSettings

struct	FPseudoConstantQKernelSettings

class	FQuantizedNotify

class	FQuantizedOtherClockStart

class	FQuantizedPlayCommand

class	FQuantizedQueueCommand

class	FQuantizedTickRateChange

class	FQuantizedTransportReset

class	FQuartzClock

class	FQuartzClockManager

class	FQuartzClockProxy

class	FQuartzMetronome

struct	FQuartzMetronomeDelegateData

struct	FQuartzQuantizedCommandDelegateData

struct	FQuartzQuantizedCommandHandle

struct	FQuartzQuantizedCommandInitInfo

struct	FQuartzQuantizedRequestData

struct	FQuartzQueueCommandData

struct	FRawPCMDataBuffer

class	FResampler

class	FResamplerImpl

struct	FResamplerResults

struct	FResamplingParameters

struct	FReverbSettingsInternal

struct	FRiffCueChunk

struct	FRiffCuePointChunk

struct	FRiffLabelChunk

struct	FRiffListChunk

struct	FRiffSampleChunk

struct	FRiffSampleLoopChunk

class	FRingModulation

class	FRuntimeResampler

class	FSampleBufferReader

class	FSampleRateConverter

struct	FScopeComString

class	FScopedCoInitialize

class	FSignalProcessingModule

class	FSilenceDetection

class	FSimpleWaveReader

class	FSimpleWaveWriter

class	FSineOsc

class	FSineWaveTableOsc

class	FSinOsc2DRotation

class	FSlowAdaptiveGainControl

class	FSoundDataReader

struct	FSoundFileChunkInfo

class	FSoundFileChunkInfoWrapper

struct	FSoundFileConvertFormat

struct	FSoundFileCuePoint

struct	FSoundFileCues

struct	FSoundFileDescription

class	FSoundFileIOManager

class	FSoundFileIOManagerImpl

class	FSoundFileReader

class	FSoundFileWriter

class	FSoundSourceDecoder

class	FSoundWavePCMLoader

class	FSoundWavePCMWriter

class	FSoundWaveScrubber

class	FSoundWaveScrubberGenerator

struct	FSourceDecodeInit

struct	FSourceManagerInitParams

class	FSpectrumAnalysisAsyncWorker

class	FSpectrumAnalyzer

class	FSpectrumAnalyzerBuffer

class	FSpectrumAnalyzerScopeLock

struct	FSpectrumAnalyzerSettings

class	FSpectrumBandExtractor

struct	FSpectrumBandExtractorSettings

struct	FSpectrumBandExtractorSpectrumSettings

class	FStateVariableFilter

struct	FSubmixMap

struct	FSubmixVoiceData

class	FSynchronizedProceduralDecodeHandle

class	FTabularRenderHelper

class	FTapDelayPitchShifter

class	FUniformPartitionConvolution

class	FUniformPartitionConvolutionFactory

struct	FUniformPartitionConvolutionSettings

class	FVariablePoleFilter

class	FVectorComplexFFT

class	FVectorFFTFactory

struct	FVectorLinearResampler

class	FVectorRealToComplexFFT

struct	FVirtualSoundFileCallbackInfo

struct	FViterbi

class	FVolumeFader

class	FWasapiAggregateDeviceMgr

class	FWasapiAggregateRenderStream

class	FWasapiAudioFormat

class	FWasapiAudioUtils

class	FWasapiCaptureRunnable

class	FWasapiCaptureThread

class	FWasapiDefaultDeviceMgr

class	FWasapiDefaultRenderStream

class	FWasapiDeviceEnumeration

struct	FWasapiDeviceSwapContext

struct	FWasapiDeviceSwapResult

class	FWasapiInputStream

struct	FWasapiRenderStreamParams

class	FWasapiStreamManager

struct	FWaveFormatEx

struct	FWaveformTransformationWaveInfo

class	FWaveShaper

class	FWaveTableOsc

struct	FWetDry

class	FWhiteNoise

class	FWindow

struct	FWindowsMMDeviceCache

class	FWindowsMMDeviceEnumerationModule

class	FWindowsMMNotificationClient

struct	FXAudio2DeviceSwapContext

struct	FXAudio2DeviceSwapResult

class	FXAudio2VoiceCallback

class	IAnalyzerControls

class	IAnalyzerFactory

class	IAnalyzerNRTFactory

class	IAnalyzerNRTResult

class	IAnalyzerNRTSettings

class	IAnalyzerNRTWorker

class	IAnalyzerResult

class	IAnalyzerSettings

class	IAnalyzerWorker

class	IAudioCaptureFactory

class	IAudioCaptureStream

class	IAudioEncoder

class	IAudioMixer

class	IAudioMixerDeviceChangedListener

class	IAudioMixerPlatformInterface

struct	IAudioMixerRenderStep

class	IAudioMixerWasapiDeviceManager

class	IAudioParameterInterfaceRegistry

class	IAudioPlatformDeviceInfoCache

class	IAudioTask

class	IChannelFormatConverter

struct	IConvertDeinterleave

class	IConvolutionAlgorithm

class	IConvolutionAlgorithmFactory

class	IDeviceRenderCallback

class	IFFTAlgorithm

class	IFFTAlgorithmFactory

class	IFilter

class	ILegacyParameterTransmitter

class	IModulatorSettings

class	IOscBase

class	IParameterTransmitter

class	IProxyData

class	IQuantizedEventListener

class	IQuartzQuantizedCommand

class	ISampleRateConverter

class	ISoundFile

class	ISoundFileParser

class	ISoundFileReader

class	ISoundFileWriter

class	ISoundWaveCloudStreamingFeature

class	ISourceListener

class	ISpectrumBandExtractor

class	IViterbiInitialProbability

class	IViterbiObservations

class	IViterbiTransitionProbability

class	IWaveTransformation

struct	ScaleDegreeSet

class	TAutoDeinterleaveView

class	TAutoSlidingWindow

class	TCircularAudioBuffer

class	TDeinterleaveView

struct	TGetPower

struct	TGetPower< Base, 0 >

class	TParams

class	TProxyData

class	TSample

class	TSampleBuffer

class	TSampleRef

class	TScopedSlidingWindow

class	TSlidingBuffer

class	TSlidingWindow

class	WindowsMMCvarUtils

Typedefs
typedef TFunction< void(const float *InAudio, int32 NumFrames, int32 NumChannels, int32 SampleRate, double StreamTime, bool bOverFlow)>	FOnCaptureFunction

typedef TFunction< void(const void *InAudio, int32 NumFrames, int32 NumChannels, int32 SampleRate, double StreamTime, bool bOverFlow)>	FOnAudioCaptureFunction

using	FDeviceInfo = FWasapiDeviceEnumeration::FDeviceInfo

typedef TFunction< void(void *InBuffer, uint32 InNumFrames, double InStreamPosition, bool bInDiscontinuityError)>	FWasapiOnAudioCaptureFunction

using	FModulatorId = uint32

using	FModulatorTypeId = uint32

using	FModulatorHandleId = uint32

using	FModulationUnitConversionFunction = TFunction< void(float &)>

using	FModulationNormalizedConversionFunction = TFunction< void(float &)>

using	FModulationMixFunction = TFunction< void(float &, float)>

using	FParameterInterfacePtr = TSharedPtr< FParameterInterface, ESPMode::ThreadSafe >

using	DeviceID = uint32

using	FTransformationPtr = TUniquePtr< Audio::IWaveTransformation >

using	FMixerSourceBufferPtr = TSharedPtr< class FMixerSourceBuffer, ESPMode::ThreadSafe >

using	SoundFileCount = int64

typedef TArray< FSoundFileChunkInfoWrapper >	FSoundFileChunkArray

typedef struct SoundFileHandleOpaque	LibSoundFileHandle

typedef struct SoundFileChunkIteratorOpaque	LibSoundFileChunkIterator

typedef SoundFileCount(*	VirtualSoundFileGetLengthFuncPtr) (void *UserData)

typedef SoundFileCount(*	VirtualSoundFileSeekFuncPtr) (SoundFileCount Offset, int32 Mode, void *UserData)

typedef SoundFileCount(*	VirtualSoundFileReadFuncPtr) (void DataPtr, SoundFileCount ByteCount, void UserData)

typedef SoundFileCount(*	VirtualSoundFileWriteFuncPtr) (const void DataPtr, SoundFileCount ByteCount, void UserData)

typedef SoundFileCount(*	VirtualSoundFileTellFuncPtr) (void *UserData)

typedef LibSoundFileHandle (	SoundFileOpenFuncPtr) (const char Path, int32 Mode, FSoundFileDescription Description)

typedef LibSoundFileHandle (	SoundFileOpenVirtualFuncPtr) (FVirtualSoundFileCallbackInfo VirtualFileDescription, int32 Mode, FSoundFileDescription Description, void *UserData)

typedef int32(*	SoundFileCloseFuncPtr) (LibSoundFileHandle *FileHandle)

typedef int32(*	SoundFileErrorFuncPtr) (LibSoundFileHandle *FileHandle)

typedef const char (	SoundFileStrErrorFuncPtr) (LibSoundFileHandle *FileHandle)

typedef const char (	SoundFileErrorNumberFuncPtr) (int32 ErrorNumber)

typedef int32(*	SoundFileCommandFuncPtr) (LibSoundFileHandle FileHandle, int32 Command, void Data, int32 DataSize)

typedef int32(*	SoundFileFormatCheckFuncPtr) (const FSoundFileDescription *Description)

typedef SoundFileCount(*	SoundFileSeekFuncPtr) (LibSoundFileHandle *FileHandle, SoundFileCount NumFrames, int32 SeekMode)

typedef const char (	SoundFileGetVersionFuncPtr) (void)

typedef SoundFileCount(*	SoundFileReadFramesFloatFuncPtr) (LibSoundFileHandle FileHandle, float Buffer, SoundFileCount NumFrames)

typedef SoundFileCount(*	SoundFileReadFramesDoubleFuncPtr) (LibSoundFileHandle FileHandle, double Buffer, SoundFileCount NumFrames)

typedef SoundFileCount(*	SoundFileWriteFramesFloatFuncPtr) (LibSoundFileHandle FileHandle, const float Buffer, SoundFileCount NumFrames)

typedef SoundFileCount(*	SoundFileWriteFramesDoubleFuncPtr) (LibSoundFileHandle FileHandle, const double Buffer, SoundFileCount NumFrames)

typedef SoundFileCount(*	SoundFileReadSamplesFloatFuncPtr) (LibSoundFileHandle FileHandle, float Buffer, SoundFileCount NumSamples)

typedef SoundFileCount(*	SoundFileReadSamplesDoubleFuncPtr) (LibSoundFileHandle FileHandle, double Buffer, SoundFileCount NumSamples)

typedef SoundFileCount(*	SoundFileWriteSamplesFloatFuncPtr) (LibSoundFileHandle FileHandle, const float Buffer, SoundFileCount NumSamples)

typedef SoundFileCount(*	SoundFileWriteSamplesDoubleFuncPtr) (LibSoundFileHandle FileHandle, const double Buffer, SoundFileCount NumSamples)

typedef int32(*	SoundFileGetChunkSizeFuncPtr) (const LibSoundFileChunkIterator ChunkIterator, FSoundFileChunkInfo ChunkInfo)

typedef int32(*	SoundFileGetChunkDataFuncPtr) (const LibSoundFileChunkIterator ChunkIterator, FSoundFileChunkInfo ChunkInfo)

typedef LibSoundFileChunkIterator (	SoundFileGetChunkIteratorFuncPtr) (LibSoundFileHandle FileHandle, const FSoundFileChunkInfo ChunkInfo)

typedef LibSoundFileChunkIterator (	SoundFileNextChunkIteratorFuncPtr) (LibSoundFileChunkIterator *ChunkIterator)

typedef int32(*	SoundFileSetChunkFuncPtr) (LibSoundFileHandle FileHandle, const FSoundFileChunkInfo ChunkInfo)

typedef TSharedPtr< FMixerSubmix, ESPMode::ThreadSafe >	FMixerSubmixPtr

typedef TWeakPtr< FMixerSubmix, ESPMode::ThreadSafe >	FMixerSubmixWeakPtr

using	FQuartzClockCommandQueueType = Audio::Quartz::PrivateDefs::TQuartzCommandQueue< IQuartzClock >

using	FQuartzClockCommandQueuePtr = TSharedPtr< FQuartzClockCommandQueueType, ESPMode::ThreadSafe >

using	FQuartzClockCommandQueueWeakPtr = TWeakPtr< FQuartzClockCommandQueueType, ESPMode::ThreadSafe >

using	MetronomeCommandQueuePtr = Quartz::FQuartzGameThreadCommandQueuePtr

typedef TSharedPtr< FDecodingSoundSource >	FDecodingSoundSourcePtr

using	FDeviceId = uint32

typedef FAsyncTask< FAsyncSoundWavePCMWriteWorker >	FAsyncSoundWavePCMWriterTask

using	AudioTaskQueueId = uint32

using	FSoundHandleID = uint32

typedef TSharedPtr< FPatchOutput, ESPMode::ThreadSafe >	FPatchOutputStrongPtr

using	FAudioMixerPlatformSDL = FMixerPlatformSDL

using	FAudioBufferAlignedAllocator = TAlignedHeapAllocator< AUDIO_BUFFER_ALIGNMENT >

using	FAlignedByteBuffer = TArray< uint8, FAudioBufferAlignedAllocator >

using	FAlignedFloatBuffer = TArray< float, FAudioBufferAlignedAllocator >

using	FAlignedInt32Buffer = TArray< int32, FAudioBufferAlignedAllocator >

typedef TArray< uint8, FAudioBufferAlignedAllocator >	AlignedByteBuffer

typedef TArray< float, FAudioBufferAlignedAllocator >	AlignedFloatBuffer

typedef TArray< int32, FAudioBufferAlignedAllocator >	AlignedInt32Buffer

typedef TTuple< int32, int32 >	FDirectedEdge

typedef UE::MathCore::Graph::FDirectedTreeElement	FDirectedTreeElement

using	FMultichannelBuffer = TArray< Audio::FAlignedFloatBuffer >

using	FMultichannelBufferView = TArray< TArrayView< float > >

using	FMultichannelCircularBuffer = TArray< Audio::TCircularAudioBuffer< float > >

template<typename T >
using	TStackArrayOfPointers = TArray< T *, TInlineAllocator< MaxStackMultiMonoChannels > >

typedef TWeakPtr< FPatchOutput, ESPMode::ThreadSafe >	FPatchOutputWeakPtr

typedef FAsyncTask< FSpectrumAnalysisAsyncWorker >	FSpectrumAnalyzerTask

typedef int16	DefaultUSoundWaveSampleType

typedef TSampleBuffer	FSampleBuffer

Enumerations
enum class	EHardwareInputFeature : uint8 { EchoCancellation , NoiseSuppression , AutomaticGainControl }

enum class	EPCMAudioEncoding : uint8 { UNKNOWN , PCM_8 , PCM_16 , PCM_24 , PCM_24_IN_32 , PCM_32 , FLOATING_POINT_32 , FLOATING_POINT_64 }

enum class	ETransformationPriority : uint8 { None = 0 , Low , High }

enum class	EMixerSourceInitializationState : uint8 { NotInitialized , Initializing , Initialized }

enum class	EBufferReadMode : uint8 { Asynchronous , AsynchronousSkipFirstFrame }

enum class	EAudioTaskType { Procedural , Header , Decode , Invalid }

enum	EMixerSourceSubmixSendStage { PostDistanceAttenuation , PreDistanceAttenuation }

enum class	EDeviceEndpointType { Unknown , Render , Capture }

enum class	EAudioDeviceRole { Console , Multimedia , Communications , COUNT }

enum class	EAudioDeviceState { Active , Disabled , NotPresent , Unplugged , COUNT }

enum class	EResamplingMethod : uint8 { BestSinc = 0 , ModerateSinc = 1 , FastSinc = 2 , ZeroOrderHold = 3 , Linear = 4 }

enum class	EWasapiAudioEncoding : uint8 { UNKNOWN , PCM_8 , PCM_16 , PCM_24 , PCM_24_IN_32 , PCM_32 , FLOATING_POINT_32 , FLOATING_POINT_64 }

enum	EFormatType { IEEE_FLOAT = 0x3 }

enum class	ESoundWavePCMWriterState : uint8 { Idle , Generating , WritingToDisk , Suceeded , Failed , Cancelled }

enum class	ESoundWavePCMWriteTaskType : uint8 { GenerateSoundWave , GenerateAndWriteSoundWave , WriteSoundWave , WriteWavFile }

enum class	EResult : uint8 { Success = 0 , Failure = 1 , NotImplemented = 2 }

enum class	ESpectrumType : uint8 { MagnitudeSpectrum , PowerSpectrum }

enum class	EWindowType : uint8 { None , Hamming , Hann , Blackman }

enum class	ECheckBufferFlags : uint32 { None = 0 , Infinity = 1 << 1 , Nan = 1 << 2 , Denormalized = 1 << 3 , All = Infinity \| Nan \| Denormalized }

enum class	EBufferCheckBehavior : uint8 { Nothing , Ensure , Log , Break }

enum class	EChannelMapOrder : uint8 { OutputMajorOrder , InputMajorOrder }

enum class	EChannelMapMonoUpmixMethod : uint8 { Linear , EqualPower , FullVolume }

enum class	EPseudoConstantQNormalization : uint8 { EqualAmplitude , EqualEuclideanNorm , EqualEnergy }

enum class	EDynamicsProcessorChannelLinkMode : uint8 { Disabled , Average , Peak , Count }

enum	EDynamicFilterType { Bell , LowShelf , HighShelf }

enum class	EEventQuantization : uint8 { None , Bars8 , Bars4 , Bars2 , Bar , HalfNote , HalfNoteTriplet , QuarterNote , QuarterNoteTriplet , EighthNote , EighthNoteTriplet , SixteenthNote , SixteenthNoteTriplet , ThirtySecondNote , Count }

enum class	EFFTScaling : uint8 { None , MultipliedByFFTSize , MultipliedBySqrtFFTSize , DividedByFFTSize , DividedBySqrtFFTSize }

enum class	EGranularSynthMode : uint8 { Synthesis , Granulation , Count }

enum class	EGrainEnvelopeType { Rectangular , Triangle , DownwardTriangle , UpwardTriangle , ExponentialDecay , ExponentialIncrease , Gaussian , Hanning , Lanczos , Cosine , CosineSquared , Welch , Blackman , BlackmanHarris , Count }

enum class	EMelNormalization : uint8 { EqualAmplitude , EqualEuclideanNorm , EqualEnergy }

enum class	EFilterOrder : uint32 { TwoPole = 1 , FourPole , SixPole , EightPole }

enum class	EFaderCurve : uint8 { Linear , Logarithmic , SCurve , Sin , Count }

enum class	EWaveShaperType : int32 { Sin , ATan , Tanh , Cubic , HardClip }

Functions
void AUDIOMIXERAUDIOUNIT_API	IncrementIOSAudioMixerPlatformSuspendCounter ()

void AUDIOMIXERAUDIOUNIT_API	DecrementIOSAudioMixerPlatformSuspendCounter ()

IAnalyzerFactory *	GetAnalyzerFactory (FName InFactoryName)

IAnalyzerNRTFactory *	GetAnalyzerNRTFactory (FName InFactoryName)

class AUDIOCAPTURERTAUDIO_API	UE_DEPRECATED (5.3, "FRtAudioInputWrapper is deprecated, please use FAudioCapture instead.") FRtAudioInputWrapper

const TCHAR *	ToString (AudioSessionDisconnectReason InDisconnectReason)

const TCHAR *	ToString (ERole InRole)

const TCHAR *	ToString (EDataFlow InFlow)

FString	ToFString (const PROPERTYKEY InKey)

const TCHAR *	ToString (EAudioDeviceRole InRole)

const TCHAR *	ToString (EAudioDeviceState InState)

FString	ToFString (const TArray< EAudioMixerChannel::Type > &InChannels)

FString	AudioClientErrorToFString (HRESULT InResult)

FModulatorHandleId	CreateModulatorHandleId ()

void	RegisterModulationParameter (FName InName, FModulationParameter &&InParameter)

bool	UnregisterModulationParameter (FName InName)

void	UnregisterAllModulationParameters ()

bool	IsModulationParameterRegistered (FName InName)

const FModulationParameter *	GetModulationParameterPtr (FName InName)

const FModulationParameter &	GetDefaultModulationParameter ()

const FModulationParameter &	GetModulationParameter (FName InName)

template<typename UClassToUse >
IAudioProxyDataFactory *	CastToProxyDataFactory (UObject *InObject)

IAudioTask *	CreateAudioTask (Audio::FDeviceId InDeviceId, const FProceduralAudioTaskData &InJobData)

IAudioTask *	CreateAudioTask (Audio::FDeviceId InDeviceId, const FHeaderParseAudioTaskData &InJobData)

IAudioTask *	CreateAudioTask (Audio::FDeviceId InDeviceId, const FDecodeAudioTaskData &InJobData)

void	CreateSynchronizedAudioTaskQueue (AudioTaskQueueId QueueId)

void	DestroySynchronizedAudioTaskQueue (AudioTaskQueueId QueueId, bool RunCurrentQueue)

int	KickQueuedTasks (AudioTaskQueueId QueueId)

int32	GetCommandBufferInitialCapacity ()

bool	IsAudioBufferSilent (const float *AudioBuffer, const int32 NumSamples)

bool	SoundFileIOManagerInit ()

bool	SoundFileIOManagerShutdown ()

FName	NAME_PLATFORM_SPECIFIC (TEXT("PLATFORM_SPECIFIC"))

FName	NAME_PROJECT_DEFINED (TEXT("PROJECT_DEFINED"))

FName	NAME_BINKA (TEXT("BINKA"))

FName	NAME_ADPCM (TEXT("ADPCM"))

FName	NAME_PCM (TEXT("PCM"))

FName	NAME_OPUS (TEXT("OPUS"))

FName	NAME_RADA (TEXT("RADA"))

FName	NAME_OGG (TEXT("OGG"))

bool	CheckBufferValidity (const FResamplingParameters &InParameters, FResamplerResults &OutData)

int32	GetOutputBufferSize (const FResamplingParameters &InParameters)

bool	Resample (const FResamplingParameters &InParameters, FResamplerResults &OutData)

template<class ListenerType >
class	UE_DEPRECATED (5.5, "Message") TQuartzShareableCommandQueue

FName	ToName (ESoundAssetCompressionType InDecoderType)

ESoundAssetCompressionType	ToSoundAssetCompressionType (EDefaultAudioCompressionType InDefaultCompressionType)

ICompressedAudioInfo *	CreateSoundAssetDecoder (const FName &InRuntimeFormat)

uint64	GetTransmitterID (uint64 ComponentID, UPTRINT WaveInstanceHash, uint32 PlayOrder)

FName	GetCloudStreamingFormatOverride (const FName &InCurrentFormat, const USoundWave *InWave)

const TCHAR *	ShortEnumString (const TCHAR *InString)

ENGINE_API bool	MatchesLogFilter (const TCHAR *InName)

bool	MatchesLogFilter (const FName &InName)

void	EncodeMonoAmbisonicMixIn (TArrayView< const float > Src, TArrayView< float * > Dst, TArrayView< const float > AmbisonicGains)

void	DecodeMonoAmbisonicMixIn (TArrayView< const float * > Src, TArrayView< float > Dst, TArrayView< const float > AmbisonicGains)

void	DistanceAttenuationProcessAudio (TArrayView< int16 > &InOutBuffer, uint32 InNumChannels, float InDistance, const FAudioBufferDistanceAttenuationSettings &InSettings, float &InOutAttenuation)

void	DistanceAttenuationProcessAudio (TArrayView< float > &InOutBuffer, uint32 InNumChannels, float InDistance, const FAudioBufferDistanceAttenuationSettings &InSettings, float &InOutAttenuation)

void	GenerateRectangularWindow (float *WindowBuffer, int32 NumFrames, int32 NumChannels)

void	GenerateHammingWindow (float *WindowBuffer, int32 NumFrames, int32 NumChannels, bool bIsPeriodic)

void	GenerateHannWindow (float *WindowBuffer, int32 NumFrames, int32 NumChannels, bool bIsPeriodic)

void	GenerateBlackmanWindow (float *WindowBuffer, int32 NumFrames, int32 NumChannels, bool bIsPeriodic)

void	GenerateWindow (float *InOutWindowBuffer, EWindowType InType, int32 InNumFrames, int32 InNumChannels, bool bIsPeriodic)

uint32	GetCOLAHopSizeForWindow (EWindowType InType, uint32 WindowLength)

int32	CeilLog2 (int32 InNum)

float	GetPowerSpectrumScaling (int32 FFTSize, EFFTScaling InCurrentScaling, EFFTScaling InTargetScaling)

void	ScalePowerSpectrumInPlace (int32 FFTSize, EFFTScaling InCurrentScaling, EFFTScaling InTargetScaling, TArrayView< float > InPowerSpectrum)

int32	FindDenormalized (TArrayView< const float > InBuffer)

bool	ContainsDenormalized (TArrayView< const float > InBuffer)

int32	FindInfinity (TArrayView< const float > InBuffer)

bool	ContainsInfinity (TArrayView< const float > InBuffer)

int32	FindNan (TArrayView< const float > InBuffer)

bool	ContainsNan (TArrayView< const float > InBuffer)

bool	CheckBuffer (TArrayView< const float > InBuffer, const ECheckBufferFlags InFlags, ECheckBufferFlags &OutFailedFlags)

FString	ToDelimitedString (const ECheckBufferFlags InEnum)

void	Apply2ChannelGain (FAlignedFloatBuffer &StereoBuffer, const float *RESTRICT Gains)

void	Apply2ChannelGain (float RESTRICT StereoBuffer, int32 NumSamples, const float RESTRICT Gains)

void	Apply2ChannelGain (FAlignedFloatBuffer &StereoBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Apply2ChannelGain (float RESTRICT StereoBuffer, int32 NumSamples, const float RESTRICT StartGains, const float *RESTRICT EndGains)

void	MixMonoTo2ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	MixMonoTo2ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	MixMonoTo2ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	MixMonoTo2ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	MixMonoTo2ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer)

void	MixMonoTo2ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 InNumFrames)

void	Mix2ChannelsTo2ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	Mix2ChannelsTo2ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	Mix2ChannelsTo2ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Mix2ChannelsTo2ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Apply4ChannelGain (FAlignedFloatBuffer &InterleavedBuffer, const float *RESTRICT Gains)

void	Apply4ChannelGain (float RESTRICT InterleavedBuffer, int32 NumSamples, const float RESTRICT Gains)

void	Apply4ChannelGain (FAlignedFloatBuffer &InterleavedBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Apply4ChannelGain (float RESTRICT InterleavedBuffer, int32 NumSamples, const float RESTRICT StartGains, const float *RESTRICT EndGains)

void	MixMonoTo4ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	MixMonoTo4ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	MixMonoTo4ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	MixMonoTo4ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Mix2ChannelsTo4ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	Mix2ChannelsTo4ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	Mix2ChannelsTo4ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Mix2ChannelsTo4ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Apply6ChannelGain (FAlignedFloatBuffer &InterleavedBuffer, const float *RESTRICT Gains)

void	Apply6ChannelGain (float RESTRICT InterleavedBuffer, int32 NumSamples, const float RESTRICT Gains)

void	Apply6ChannelGain (FAlignedFloatBuffer &InterleavedBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Apply6ChannelGain (float RESTRICT InterleavedBuffer, int32 NumSamples, const float RESTRICT StartGains, const float *RESTRICT EndGains)

void	MixMonoTo6ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	MixMonoTo6ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	MixMonoTo6ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	MixMonoTo6ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Mix2ChannelsTo6ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	Mix2ChannelsTo6ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	Mix2ChannelsTo6ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Mix2ChannelsTo6ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Apply8ChannelGain (FAlignedFloatBuffer &InterleavedBuffer, const float *RESTRICT Gains)

void	Apply8ChannelGain (float RESTRICT InterleavedBuffer, int32 NumSamples, const float RESTRICT Gains)

void	Apply8ChannelGain (FAlignedFloatBuffer &InterleavedBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Apply8ChannelGain (float RESTRICT InterleavedBuffer, int32 NumSamples, const float RESTRICT StartGains, const float *RESTRICT EndGains)

void	MixMonoTo8ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	MixMonoTo8ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	MixMonoTo8ChannelsFast (const FAlignedFloatBuffer &MonoBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	MixMonoTo8ChannelsFast (const float RESTRICT MonoBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Mix2ChannelsTo8ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	Mix2ChannelsTo8ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	Mix2ChannelsTo8ChannelsFast (const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	Mix2ChannelsTo8ChannelsFast (const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float RESTRICT StartGains, const float RESTRICT EndGains)

void	DownmixBuffer (int32 NumSourceChannels, int32 NumDestinationChannels, const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, const float *RESTRICT Gains)

void	DownmixBuffer (int32 NumSourceChannels, int32 NumDestinationChannels, const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, const float *RESTRICT Gains)

void	DownmixBuffer (int32 NumSourceChannels, int32 NumDestinationChannels, const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &DestinationBuffer, float RESTRICT StartGains, const float RESTRICT EndGains)

void	DownmixBuffer (int32 NumSourceChannels, int32 NumDestinationChannels, const float RESTRICT SourceBuffer, float RESTRICT DestinationBuffer, int32 NumFrames, float RESTRICT StartGains, const float RESTRICT EndGains)

void	DownmixAndSumIntoBuffer (int32 NumSourceChannels, int32 NumDestinationChannels, const FAlignedFloatBuffer &SourceBuffer, FAlignedFloatBuffer &BufferToSumTo, const float *RESTRICT Gains)

void	DownmixAndSumIntoBuffer (int32 NumSourceChannels, int32 NumDestinationChannels, const float RESTRICT SourceBuffer, float RESTRICT BufferToSumTo, int32 NumFrames, const float *RESTRICT Gains)

void	BufferInterleave2ChannelFast (const FAlignedFloatBuffer &InBuffer1, const FAlignedFloatBuffer &InBuffer2, FAlignedFloatBuffer &OutBuffer)

void	BufferInterleave2ChannelFast (const float RESTRICT InBuffer1, const float RESTRICT InBuffer2, float *RESTRICT OutBuffer, const int32 InNum)

void	BufferDeinterleave2ChannelFast (const FAlignedFloatBuffer &InBuffer, FAlignedFloatBuffer &OutBuffer1, FAlignedFloatBuffer &OutBuffer2)

void	BufferDeinterleave2ChannelFast (const float RESTRICT InBuffer, float RESTRICT OutBuffer1, float *RESTRICT OutBuffer2, const int32 InNumFrames)

void	BufferSum2ChannelToMonoFast (const FAlignedFloatBuffer &InSamples, FAlignedFloatBuffer &OutSamples)

void	BufferSum2ChannelToMonoFast (const float RESTRICT InSamples, float RESTRICT OutSamples, const int32 InNumFrames)

bool	Create2DChannelMap (const FChannelMapParams &InParams, TArray< float > &OutChannelMap)

bool	CreateVorbis2DChannelMap (int32 InNumOutputChannels, EChannelMapOrder InOrder, TArray< float > &OutVorbisChannelMap)

TUniquePtr< FContiguousSparse2DKernelTransform >	NewPseudoConstantQKernelTransform (const FPseudoConstantQKernelSettings &InSettings, const int32 InFFTSize, const float InSampleRate)

void	EncodeMidSide (const FAlignedFloatBuffer &InLeftChannel, const FAlignedFloatBuffer &InRightChannel, FAlignedFloatBuffer &OutMidChannel, FAlignedFloatBuffer &OutSideChannel)

void	DecodeMidSide (const FAlignedFloatBuffer &InMidChannel, const FAlignedFloatBuffer &InSideChannel, FAlignedFloatBuffer &OutLeftChannel, FAlignedFloatBuffer &OutRightChannel)

void	ArraySum (TArrayView< const float > InValues, float &OutSum)

void	ArraySum (TArrayView< const float > InFloatBuffer1, TArrayView< const float > InFloatBuffer2, TArrayView< float > OutputBuffer)

void	ArrayCumulativeSum (TArrayView< const float > InView, TArray< float > &OutData)

void	ArrayMean (TArrayView< const float > InView, float &OutMean)

void	ArrayMeanSquared (TArrayView< const float > InView, float &OutMean)

float	ArrayGetMagnitude (TArrayView< const float > Buffer)

float	ArrayGetAverageValue (TArrayView< const float > Buffer)

float	ArrayGetAverageAbsValue (TArrayView< const float > Buffer)

void	ArrayMeanFilter (TArrayView< const float > InView, int32 WindowSize, int32 WindowOrigin, TArray< float > &OutData)

void	ArrayMaxFilter (TArrayView< const float > InView, int32 WindowSize, int32 WindowOrigin, TArray< float > &OutData)

void	ArrayGetEuclideanNorm (TArrayView< const float > InView, float &OutEuclideanNorm)

void	ArrayAbs (TArrayView< const float > InBuffer, TArrayView< float > OutBuffer)

void	ArrayAbsInPlace (TArrayView< float > InView)

void	ArrayClampMinInPlace (TArrayView< float > InView, float InMin)

void	ArrayClampMaxInPlace (TArrayView< float > InView, float InMax)

void	ArrayClampInPlace (TArrayView< float > InView, float InMin, float InMax)

void	ArrayMinMaxNormalize (TArrayView< const float > InView, TArray< float > &OutArray)

void	ArrayMax (const TArrayView< const float > &InView1, const TArrayView< const float > &InView2, const TArrayView< float > &OutView)

float	ArrayMaxAbsValue (const TArrayView< const float > InView)

void	ArrayMultiply (TArrayView< const float > InFloatBufferA, TArrayView< const float > InFloatBufferB, TArrayView< float > OutBuffer)

void	ArrayMultiplyInPlace (TArrayView< const float > InFloatBuffer, TArrayView< float > BufferToMultiply)

void	ArrayComplexMultiplyInPlace (TArrayView< const float > InValues1, TArrayView< float > InValues2)

void	ArrayComplexMultiplyAdd (TArrayView< const float > InValues1, TArrayView< const float > InValues2, TArrayView< float > OutArray)

void	ArrayMultiplyByConstant (TArrayView< const float > InFloatBuffer, float InValue, TArrayView< float > OutFloatBuffer)

void	ArrayMultiplyByConstantInPlace (TArrayView< float > InOutBuffer, float InGain)

void	ArrayAddInPlace (TArrayView< const float > InValues, TArrayView< float > InAccumulateValues)

void	ArrayAddConstantInplace (TArrayView< float > InOutBuffer, float InConstant)

void	ArrayMultiplyAddInPlace (TArrayView< const float > InValues, float InMultiplier, TArrayView< float > InAccumulateValues)

void	ArrayLerpAddInPlace (TArrayView< const float > InValues, float InStartMultiplier, float InEndMultiplier, TArrayView< float > InAccumulateValues)

void	ArraySubtract (TArrayView< const float > InMinuend, TArrayView< const float > InSubtrahend, TArrayView< float > OutBuffer)

void	ArraySubtractInPlace1 (TArrayView< const float > InMinuend, TArrayView< float > InOutSubtrahend)

void	ArraySubtractInPlace2 (TArrayView< float > InOutMinuend, TArrayView< const float > InSubtrahend)

void	ArraySubtractByConstantInPlace (TArrayView< float > InValues, float InSubtrahend)

void	ArraySquare (TArrayView< const float > InValues, TArrayView< float > OutValues)

void	ArraySquareInPlace (TArrayView< float > InValues)

void	ArraySqrtInPlace (TArrayView< float > InValues)

void	ArrayComplexConjugate (TArrayView< const float > InValues, TArrayView< float > OutValues)

void	ArrayComplexConjugateInPlace (TArrayView< float > InValues)

void	ArrayMagnitudeToDecibelInPlace (TArrayView< float > InValues, float InMinimumDb)

void	ArrayPowerToDecibelInPlace (TArrayView< float > InValues, float InMinimumDb)

void	ArrayComplexToPower (TArrayView< const float > InComplexValues, TArrayView< float > OutPowerValues)

void	ArrayComplexToPower (TArrayView< const float > InRealSamples, TArrayView< const float > InImaginarySamples, TArrayView< float > OutPowerSamples)

void	ArrayUnderflowClamp (TArrayView< float > InOutValues)

void	ArrayRangeClamp (TArrayView< float > InOutBuffer, float InMinValue, float InMaxValue)

void	ArraySetToConstantInplace (TArrayView< float > InOutBuffer, float InConstant)

void	ArrayWeightedSum (TArrayView< const float > InBuffer1, float InGain1, TArrayView< const float > InBuffer2, float InGain2, TArrayView< float > OutBuffer)

void	ArrayWeightedSum (TArrayView< const float > InBuffer1, float InGain1, TArrayView< const float > InBuffer2, TArrayView< float > OutBuffer)

void	ArrayFade (TArrayView< float > InOutBuffer, const float StartValue, const float EndValue)

void	ArrayFade (TArrayView< const float > InBuffer, const float InStartValue, const float InEndValue, TArrayView< float > OutBuffer)

void	ArrayMixIn (TArrayView< const float > InFloatBuffer, TArrayView< float > BufferToSumTo, const float Gain)

void	ArrayMixIn (TArrayView< const float > InFloatBuffer, TArrayView< float > BufferToSumTo)

void	ArrayMixIn (TArrayView< const float > InFloatBuffer, TArrayView< float > BufferToSumTo, const float StartGain, const float EndGain)

void	ArrayMixIn (TArrayView< const int16 > InPcm16Buffer, TArrayView< float > BufferToSumTo, const float Gain)

void	ArrayFloatToPcm16 (TArrayView< const float > InView, TArrayView< int16 > OutView)

void	ArrayPcm16ToFloat (TArrayView< const int16 > InView, TArrayView< float > OutView)

constexpr int	CreateByteMask (uint32 A, uint32 B, uint32 C, uint32 D)

void	ArrayFloatToPcm24 (TArrayView< const float > InView, TArrayView< int8 > OutView)

void	ArrayFloatToPcm32 (TArrayView< const float > InView, TArrayView< int32 > OutView)

void	ArrayFloatToPcmDouble (TArrayView< const float > InView, TArrayView< double > OutView)

void	ArrayInterleave (const TArray< FAlignedFloatBuffer > &InBuffers, FAlignedFloatBuffer &OutBuffer)

void	ArrayInterleave (const float const RESTRICT InBuffers, float *RESTRICT OutBuffer, const int32 InFrames, const int32 InChannels)

void	ArrayDeinterleave (const FAlignedFloatBuffer &InBuffer, TArray< FAlignedFloatBuffer > &OutBuffers, const int32 InChannels)

void	ArrayDeinterleave (const TArrayView< const float > InView, TArray< FAlignedFloatBuffer > &OutBuffers, const int32 InChannels)

void	ArrayDeinterleave (const float RESTRICT InBuffer, float const *RESTRICT OutBuffers, const int32 InFrames, const int32 InChannels)

void	ArrayInterpolate (const float InBuffer, float OutBuffer, const int32 NumInSamples, const int32 NumOutSamples)

void	ArrayInt16SwapBytes (TArrayView< int16 > InView)

void	ArrayInt24SwapBytes (TArrayView< int8 > InView)

void	ArrayInt32SwapBytes (TArrayView< int32 > InView)

void	ArrayFloatSwapBytes (TArrayView< float > InView)

void	ArrayDoubleSwapBytes (TArrayView< double > InView)

void	ArrayAPFLongDelayProcess (const float InSamples, const float InDelaySamples, const int32 InNum, float OutSamples, float OutDelaySamples, const float Gain)

void	ArrayLerpFractionalDelay (const float InSamples, const float InDelays, const float DelayData, const int IntegerDelays, int UpperDelayPos, int LowerDelayPos, const int32 InNum, float *OutSamples, const float MaxDelay)

void	ArrayScaledComplexConjugate (const float RESTRICT InValues, const int32 Num, float RESTRICT OutValues, const float Scale)

float	MelToHz (float InMel)

float	HzToMel (float InHz)

TUniquePtr< FContiguousSparse2DKernelTransform >	NewMelSpectrumKernelTransform (const FMelSpectrumKernelSettings &InSettings, const int32 InFFTSize, const float InSampleRate)

void	SetMultichannelBufferSize (int32 InNumChannels, int32 InNumFrames, FMultichannelBuffer &OutBuffer)

void	SetMultichannelCircularBufferCapacity (int32 InNumChannels, int32 InNumFrames, FMultichannelCircularBuffer &OutBuffer)

int32	GetMultichannelBufferNumFrames (const FMultichannelBuffer &InBuffer)

int32	GetMultichannelBufferNumFrames (const FMultichannelCircularBuffer &InBuffer)

int32	GetMultichannelBufferNumFrames (const FMultichannelBufferView &InBuffer)

FMultichannelBufferView	MakeMultichannelBufferView (FMultichannelBuffer &InBuffer)

FMultichannelBufferView	MakeMultichannelBufferView (FMultichannelBuffer &InBuffer, int32 InStartFrameIndex, int32 InNumFrames)

FMultichannelBufferView	SliceMultichannelBufferView (const FMultichannelBufferView &View, int32 InStartFrameIndex, int32 InNumFrames)

void	ShiftMultichannelBufferView (int32 InNumFrames, FMultichannelBufferView &View)

void	MultiMonoMixUpOrDown (TArrayView< const float > InSrc, const TArrayView< float > InDst, const int32 NumFrames, TArrayView< const float > MixGains, const int32 NumSrcChannels, const int32 NumDstChannels)

void	MultiMonoMixUpOrDown (TArrayView< const float * > InSrc, TArrayView< float * > InDst, const int32 NumFrames, TArrayView< const float > MixGains)

float	PerlinValueNoise1D (const float InX, const int32 InNumOctaves)

void	PerlinValueNoise1DBuffer (TArrayView< const float > InXBuffer, const float InOffset, const int32 InNumOctaves, TArrayView< float > OutNoiseBuffer)

class	UE_DEPRECATED (5.5, "Audio::FBiquad is deprecated in favor of Audio::FBiquadFilter due to performance issues") FBiquad

ECheckBufferFlags	operator\| (const ECheckBufferFlags A, const ECheckBufferFlags B)

ECheckBufferFlags &	operator\|= (ECheckBufferFlags &Out, const ECheckBufferFlags Other)

ECheckBufferFlags	operator& (const ECheckBufferFlags A, const ECheckBufferFlags B)

struct	UE_DEPRECATED (5.5, "This has moved to the UE::MathCore::Graph namespace") FStronglyConnectedComponent

void	CheckSample (float InSample, float Threshold=0.001f)

float	UnderflowClamp (const float InValue)

float	ConvertToDecibels (const float InLinear, const float InFloor=UE_SMALL_NUMBER)

float	ConvertToLinear (const float InDecibels)

float	GetGainFromVelocity (const float InVelocity)

float	FastSin (const float X)

float	FastSin2 (const float X)

float	FastSin3 (const float X)

float	FastTanh (float X)

float	FastTan (float X)

float	GetBipolar (const float X)

float	GetUnipolar (const float X)

void	ConvertBipolarBufferToUnipolar (float *InAlignedBuffer, int32 NumSamples)

float	GetFrequencyFromMidi (const float InMidiNote)

float	GetLogFrequencyClamped (const float InValue, const FVector2D &Domain, const FVector2D &Range)

float	GetLinearFrequencyClamped (const float InFrequencyValue, const FVector2D &Domain, const FVector2D &Range)

float	GetMidiFromFrequency (const float InFrequency)

float	GetPitchScaleFromMIDINote (int32 BaseMidiNote, int32 TargetMidiNote)

float	GetFrequencyMultiplier (const float InPitchSemitones)

float	GetSemitones (const float InMultiplier)

void	GetStereoPan (const float InLinearPan, float &OutLeft, float &OutRight)

void	EncodeMidSide (float &LeftChannel, float &RightChannel)

void	DecodeMidSide (float &MidChannel, float &SideChannel)

float	GetBandwidthFromQ (const float InQ)

float	GetQFromBandwidth (const float InBandwidth)

bool	QuadraticPeakInterpolation (const float InValues[3], float &OutPeakLoc, float &OutPeakValue)

float	LagrangianInterpolation (const TArray< FVector2D > Points, const float Alpha)

SIGNALPROCESSING_API void	AssignPcm24Value (int8 *OutPtr, const int32 InValue, const bool bIsOutputLittleEndian)

SIGNALPROCESSING_API void	ArrayInterpolate (const float RESTRICT InBuffer, float RESTRICT OutBuffer, const int32 NumInSamples, const int32 NumOutSamples)

SIGNALPROCESSING_API constexpr bool	IsHostLittleEndian ()

SIGNALPROCESSING_API void	SetMultichannelBufferSize (int32 InNumFrames, FMultichannelBuffer &OutBuffer)

template<typename T >
TStackArrayOfPointers< T >	MakeMultiMonoPointersFromView (TArrayView< T > InMultiMono, const int32 InNumFrames, const int32 InNumChannels)

FString	ToErrorFString (HRESULT InResult)

Variables
PRAGMA_DISABLE_DEPRECATION_WARNINGS typedef TMap< int32, FDirectedTreeElement >	FDirectedTree

constexpr int32	DefaultDeviceIndex = INDEX_NONE

constexpr int32	InvalidDeviceSampleRate = -1

constexpr int32	InvalidDeviceChannelCount = -1

constexpr EPCMAudioEncoding	DefaultDeviceEncoding = EPCMAudioEncoding::FLOATING_POINT_32

int32	DirectProceduralRenderingCVar = 1

FAutoConsoleVariableRef	CVarDirectProceduralRendering (TEXT("au.DirectProceduralRendering"), DirectProceduralRenderingCVar, TEXT("0: Disabled, 1: Enabled"), ECVF_Default)

SoundFileOpenFuncPtr	SoundFileOpen = nullptr

SoundFileOpenVirtualFuncPtr	SoundFileOpenVirtual = nullptr

SoundFileCloseFuncPtr	SoundFileClose = nullptr

SoundFileErrorFuncPtr	SoundFileError = nullptr

SoundFileStrErrorFuncPtr	SoundFileStrError = nullptr

SoundFileErrorNumberFuncPtr	SoundFileErrorNumber = nullptr

SoundFileCommandFuncPtr	SoundFileCommand = nullptr

SoundFileFormatCheckFuncPtr	SoundFileFormatCheck = nullptr

SoundFileSeekFuncPtr	SoundFileSeek = nullptr

SoundFileGetVersionFuncPtr	SoundFileGetVersion = nullptr

SoundFileReadFramesFloatFuncPtr	SoundFileReadFramesFloat = nullptr

SoundFileReadFramesDoubleFuncPtr	SoundFileReadFramesDouble = nullptr

SoundFileWriteFramesFloatFuncPtr	SoundFileWriteFramesFloat = nullptr

SoundFileWriteFramesDoubleFuncPtr	SoundFileWriteFramesDouble = nullptr

SoundFileReadSamplesFloatFuncPtr	SoundFileReadSamplesFloat = nullptr

SoundFileReadSamplesDoubleFuncPtr	SoundFileReadSamplesDouble = nullptr

SoundFileWriteSamplesFloatFuncPtr	SoundFileWriteSamplesFloat = nullptr

SoundFileWriteSamplesDoubleFuncPtr	SoundFileWriteSamplesDouble = nullptr

SoundFileGetChunkSizeFuncPtr	SoundFileGetChunkSize = nullptr

SoundFileGetChunkDataFuncPtr	SoundFileGetChunkData = nullptr

SoundFileGetChunkIteratorFuncPtr	SoundFileGetChunkIterator = nullptr

SoundFileNextChunkIteratorFuncPtr	SoundFileNextChunkIterator = nullptr

SoundFileSetChunkFuncPtr	SoundFileSetChunk = nullptr

void *	SoundFileDllHandle

int32	sRenderInstanceIds = 0

FThreadSafeCounter	AudioMixerTaskCounter

constexpr float	MonoUpmixFullVolume = 1.0f

constexpr float	MonoUpmixEqualPower = 0.707f

constexpr float	MonoUpmixLinear = 0.5f

constexpr int32	SmallBlockSizeBitCheck = (1 << 6) - 1

constexpr int32	SmallBlockSize = 64

constexpr int32	MaxStackMultiMonoChannels = 128

TSharedPtr< FWindowsMMNotificationClient >	WasapiWinNotificationClient

Detailed Description

NO_LOGGING.

Plugin interface for Non Real-Time (NRT) Audio Analyzers.

Interfaces for Soundfield Encoding and Decoding

This set of interfaces can be implemented to add support for encoding to and decoding from a soundfield format. There are four classes that are required to implement a soundfield format:

ISoundfieldPacket: Container for a single audio callback's resulting data for the soundfield format. For example, for first order ambisonics, this would contain an interleaved buffer of floats. For a proprietary spatial audio format, this would contain a bitstream.

USoundfieldEncodingSettingsBase: These are game thread-local, inspectable settings to define how a soundfield is getting encoded. For example, this may contain the order of an ambisonics sound field.

ISoundfieldEncodingSettingsProxy: This should contain all data from USoundfieldEncodingSettingsBase that needs to be read by an encoder or transcoder stream to apply the settings from an implementation of USoundfieldEncodingSettingsBase.

ISoundfieldEncoderStream: Class that encodes interleaved audio from a set of arbitrary locations to an ISoundfieldPacket. ISoundfieldDecoderStream: Class that decodes audio from an ISoundfieldPacket to interleaved audio at a set of arbitrary locations. ISoundfieldTranscodeStream: Class that translates a soundfield stream from one type to another. ISoundfieldMixerStream: Class that sums together multiple incoming ISoundfieldPackets into one ISoundfieldPacket.

ISoundfieldFactory: Factory class that declares the name of your format and creates new encoder, decoders, transcoders and mixers as requested.

Common Audio namespace Type Definitions/Identifiers

Sliding Window implementation which enables ranged for loop iteration over sequential input buffers of varying length.

Concrete implementation of FAudioDevice for XAudio2

See https://msdn.microsoft.com/en-us/library/windows/desktop/hh405049%28v=vs.85%29.aspx

Typedef Documentation

◆ AlignedByteBuffer

typedef TArray<uint8, FAudioBufferAlignedAllocator> Audio::AlignedByteBuffer

◆ AlignedFloatBuffer

typedef TArray<float, FAudioBufferAlignedAllocator> Audio::AlignedFloatBuffer

◆ AlignedInt32Buffer

typedef TArray<int32, FAudioBufferAlignedAllocator> Audio::AlignedInt32Buffer

◆ AudioTaskQueueId

using Audio::AudioTaskQueueId = typedef uint32

◆ DefaultUSoundWaveSampleType

typedef int16 Audio::DefaultUSoundWaveSampleType

◆ DeviceID

using Audio::DeviceID = typedef uint32

◆ FAlignedByteBuffer

using Audio::FAlignedByteBuffer = typedef TArray<uint8, FAudioBufferAlignedAllocator>

◆ FAlignedFloatBuffer

using Audio::FAlignedFloatBuffer = typedef TArray<float, FAudioBufferAlignedAllocator>

◆ FAlignedInt32Buffer

using Audio::FAlignedInt32Buffer = typedef TArray<int32, FAudioBufferAlignedAllocator>

◆ FAsyncSoundWavePCMWriterTask

typedef FAsyncTask<FAsyncSoundWavePCMWriteWorker> Audio::FAsyncSoundWavePCMWriterTask

◆ FAudioBufferAlignedAllocator

using Audio::FAudioBufferAlignedAllocator = typedef TAlignedHeapAllocator<AUDIO_BUFFER_ALIGNMENT>

Aligned allocator used for fast operations.

◆ FAudioMixerPlatformSDL

using Audio::FAudioMixerPlatformSDL = typedef FMixerPlatformSDL

◆ FDecodingSoundSourcePtr

typedef TSharedPtr<FDecodingSoundSource> Audio::FDecodingSoundSourcePtr

◆ FDeviceId

typedef uint32 Audio::FDeviceId

Typed identifier for Audio Device Id

◆ FDeviceInfo

using Audio::FDeviceInfo = typedef FWasapiDeviceEnumeration::FDeviceInfo

◆ FDirectedEdge

typedef TTuple<int32, int32> Audio::FDirectedEdge

A pair of int32s represent a directed edge. The first value represents the source vertex, and the second value represents the destination vertex.

◆ FDirectedTreeElement

typedef UE::MathCore::Graph::FDirectedTreeElement Audio::FDirectedTreeElement

An element in a directed tree with references to children of a vertex.

◆ FMixerSourceBufferPtr

using Audio::FMixerSourceBufferPtr = typedef TSharedPtr<class FMixerSourceBuffer, ESPMode::ThreadSafe>

◆ FMixerSubmixPtr

typedef TSharedPtr<FMixerSubmix, ESPMode::ThreadSafe> Audio::FMixerSubmixPtr

◆ FMixerSubmixWeakPtr

typedef TWeakPtr<FMixerSubmix, ESPMode::ThreadSafe> Audio::FMixerSubmixWeakPtr

◆ FModulationMixFunction

using Audio::FModulationMixFunction = typedef TFunction<void(float& , float )>

◆ FModulationNormalizedConversionFunction

using Audio::FModulationNormalizedConversionFunction = typedef TFunction<void(float& )>

◆ FModulationUnitConversionFunction

using Audio::FModulationUnitConversionFunction = typedef TFunction<void(float& )>

◆ FModulatorHandleId

using Audio::FModulatorHandleId = typedef uint32

◆ FModulatorId

using Audio::FModulatorId = typedef uint32

◆ FModulatorTypeId

using Audio::FModulatorTypeId = typedef uint32

◆ FMultichannelBuffer

using Audio::FMultichannelBuffer = typedef TArray<Audio::FAlignedFloatBuffer>

A deinterleaved multichannel buffer

◆ FMultichannelBufferView

using Audio::FMultichannelBufferView = typedef TArray<TArrayView<float> >

A deinterleaved multichannel buffer view. The semantics are similar to TArray<> and TArrayView<>. FMultichannelBufferView allows sample values to be read and written, but it cannot be resized.

◆ FMultichannelCircularBuffer

using Audio::FMultichannelCircularBuffer = typedef TArray<Audio::TCircularAudioBuffer<float> >

A deinterleaved multichannel circular buffer

◆ FOnAudioCaptureFunction

typedef TFunction<void(const void* InAudio, int32 NumFrames, int32 NumChannels, int32 SampleRate, double StreamTime, bool bOverFlow)> Audio::FOnAudioCaptureFunction

◆ FOnCaptureFunction

typedef TFunction<void(const float* InAudio, int32 NumFrames, int32 NumChannels, int32 SampleRate, double StreamTime, bool bOverFlow)> Audio::FOnCaptureFunction

◆ FParameterInterfacePtr

typedef TSharedPtr< FParameterInterface, ESPMode::ThreadSafe > Audio::FParameterInterfacePtr

◆ FPatchOutputStrongPtr

typedef TSharedPtr< FPatchOutput, ESPMode::ThreadSafe > Audio::FPatchOutputStrongPtr

Patch outputs are owned by the FPatchMixer, and are pinned by the FPatchInput.

◆ FPatchOutputWeakPtr

typedef TWeakPtr<FPatchOutput, ESPMode::ThreadSafe> Audio::FPatchOutputWeakPtr

◆ FQuartzClockCommandQueuePtr

using Audio::FQuartzClockCommandQueuePtr = typedef TSharedPtr<FQuartzClockCommandQueueType, ESPMode::ThreadSafe>

◆ FQuartzClockCommandQueueType

using Audio::FQuartzClockCommandQueueType = typedef Audio::Quartz::PrivateDefs::TQuartzCommandQueue<IQuartzClock>

◆ FQuartzClockCommandQueueWeakPtr

using Audio::FQuartzClockCommandQueueWeakPtr = typedef TWeakPtr<FQuartzClockCommandQueueType, ESPMode::ThreadSafe>

◆ FSampleBuffer

typedef TSampleBuffer Audio::FSampleBuffer

◆ FSoundFileChunkArray

typedef TArray<FSoundFileChunkInfoWrapper> Audio::FSoundFileChunkArray

◆ FSoundHandleID

using Audio::FSoundHandleID = typedef uint32

◆ FSpectrumAnalyzerTask

typedef FAsyncTask<FSpectrumAnalysisAsyncWorker> Audio::FSpectrumAnalyzerTask

◆ FTransformationPtr

using Audio::FTransformationPtr = typedef TUniquePtr<Audio::IWaveTransformation>

◆ FWasapiOnAudioCaptureFunction

typedef TFunction<void(void* InBuffer, uint32 InNumFrames, double InStreamPosition, bool bInDiscontinuityError)> Audio::FWasapiOnAudioCaptureFunction

FWasapiOnAudioCaptureFunction - Callback function type for receiving audio from a capture device.

◆ LibSoundFileChunkIterator

typedef struct SoundFileChunkIteratorOpaque Audio::LibSoundFileChunkIterator

◆ LibSoundFileHandle

typedef struct SoundFileHandleOpaque Audio::LibSoundFileHandle

◆ MetronomeCommandQueuePtr

using Audio::MetronomeCommandQueuePtr = typedef Quartz::FQuartzGameThreadCommandQueuePtr

◆ SoundFileCloseFuncPtr

typedef int32(* Audio::SoundFileCloseFuncPtr) (LibSoundFileHandle *FileHandle)

◆ SoundFileCommandFuncPtr

typedef int32(* Audio::SoundFileCommandFuncPtr) (LibSoundFileHandle *FileHandle, int32 Command, void *Data, int32 DataSize)

◆ SoundFileCount

using Audio::SoundFileCount = typedef int64

◆ SoundFileErrorFuncPtr

typedef int32(* Audio::SoundFileErrorFuncPtr) (LibSoundFileHandle *FileHandle)

◆ SoundFileErrorNumberFuncPtr

typedef const char *(* Audio::SoundFileErrorNumberFuncPtr) (int32 ErrorNumber)

◆ SoundFileFormatCheckFuncPtr

typedef int32(* Audio::SoundFileFormatCheckFuncPtr) (const FSoundFileDescription *Description)

◆ SoundFileGetChunkDataFuncPtr

typedef int32(* Audio::SoundFileGetChunkDataFuncPtr) (const LibSoundFileChunkIterator *ChunkIterator, FSoundFileChunkInfo *ChunkInfo)

◆ SoundFileGetChunkIteratorFuncPtr

typedef LibSoundFileChunkIterator *(* Audio::SoundFileGetChunkIteratorFuncPtr) (LibSoundFileHandle *FileHandle, const FSoundFileChunkInfo *ChunkInfo)

◆ SoundFileGetChunkSizeFuncPtr

typedef int32(* Audio::SoundFileGetChunkSizeFuncPtr) (const LibSoundFileChunkIterator *ChunkIterator, FSoundFileChunkInfo *ChunkInfo)

◆ SoundFileGetVersionFuncPtr

typedef const char *(* Audio::SoundFileGetVersionFuncPtr) (void)

◆ SoundFileNextChunkIteratorFuncPtr

typedef LibSoundFileChunkIterator *(* Audio::SoundFileNextChunkIteratorFuncPtr) (LibSoundFileChunkIterator *ChunkIterator)

◆ SoundFileOpenFuncPtr

typedef LibSoundFileHandle *(* Audio::SoundFileOpenFuncPtr) (const char *Path, int32 Mode, FSoundFileDescription *Description)

◆ SoundFileOpenVirtualFuncPtr

typedef LibSoundFileHandle *(* Audio::SoundFileOpenVirtualFuncPtr) (FVirtualSoundFileCallbackInfo *VirtualFileDescription, int32 Mode, FSoundFileDescription *Description, void *UserData)

◆ SoundFileReadFramesDoubleFuncPtr

typedef SoundFileCount(* Audio::SoundFileReadFramesDoubleFuncPtr) (LibSoundFileHandle *FileHandle, double *Buffer, SoundFileCount NumFrames)

◆ SoundFileReadFramesFloatFuncPtr

typedef SoundFileCount(* Audio::SoundFileReadFramesFloatFuncPtr) (LibSoundFileHandle *FileHandle, float *Buffer, SoundFileCount NumFrames)

◆ SoundFileReadSamplesDoubleFuncPtr

typedef SoundFileCount(* Audio::SoundFileReadSamplesDoubleFuncPtr) (LibSoundFileHandle *FileHandle, double *Buffer, SoundFileCount NumSamples)

◆ SoundFileReadSamplesFloatFuncPtr

typedef SoundFileCount(* Audio::SoundFileReadSamplesFloatFuncPtr) (LibSoundFileHandle *FileHandle, float *Buffer, SoundFileCount NumSamples)

◆ SoundFileSeekFuncPtr

typedef SoundFileCount(* Audio::SoundFileSeekFuncPtr) (LibSoundFileHandle *FileHandle, SoundFileCount NumFrames, int32 SeekMode)

◆ SoundFileSetChunkFuncPtr

typedef int32(* Audio::SoundFileSetChunkFuncPtr) (LibSoundFileHandle *FileHandle, const FSoundFileChunkInfo *ChunkInfo)

◆ SoundFileStrErrorFuncPtr

typedef const char *(* Audio::SoundFileStrErrorFuncPtr) (LibSoundFileHandle *FileHandle)

◆ SoundFileWriteFramesDoubleFuncPtr

typedef SoundFileCount(* Audio::SoundFileWriteFramesDoubleFuncPtr) (LibSoundFileHandle *FileHandle, const double *Buffer, SoundFileCount NumFrames)

◆ SoundFileWriteFramesFloatFuncPtr

typedef SoundFileCount(* Audio::SoundFileWriteFramesFloatFuncPtr) (LibSoundFileHandle *FileHandle, const float *Buffer, SoundFileCount NumFrames)

◆ SoundFileWriteSamplesDoubleFuncPtr

typedef SoundFileCount(* Audio::SoundFileWriteSamplesDoubleFuncPtr) (LibSoundFileHandle *FileHandle, const double *Buffer, SoundFileCount NumSamples)

◆ SoundFileWriteSamplesFloatFuncPtr

typedef SoundFileCount(* Audio::SoundFileWriteSamplesFloatFuncPtr) (LibSoundFileHandle *FileHandle, const float *Buffer, SoundFileCount NumSamples)

◆ TStackArrayOfPointers

template<typename T >

using Audio::TStackArrayOfPointers = typedef TArray<T*,TInlineAllocator<MaxStackMultiMonoChannels> >

◆ VirtualSoundFileGetLengthFuncPtr

typedef SoundFileCount(* Audio::VirtualSoundFileGetLengthFuncPtr) (void *UserData)

◆ VirtualSoundFileReadFuncPtr

typedef SoundFileCount(* Audio::VirtualSoundFileReadFuncPtr) (void *DataPtr, SoundFileCount ByteCount, void *UserData)

◆ VirtualSoundFileSeekFuncPtr

typedef SoundFileCount(* Audio::VirtualSoundFileSeekFuncPtr) (SoundFileCount Offset, int32 Mode, void *UserData)

◆ VirtualSoundFileTellFuncPtr

typedef SoundFileCount(* Audio::VirtualSoundFileTellFuncPtr) (void *UserData)

◆ VirtualSoundFileWriteFuncPtr

typedef SoundFileCount(* Audio::VirtualSoundFileWriteFuncPtr) (const void *DataPtr, SoundFileCount ByteCount, void *UserData)

Enumeration Type Documentation

◆ EAudioDeviceRole

enum class Audio::EAudioDeviceRole

strong

Enumerator
Console
Multimedia
Communications
COUNT

◆ EAudioDeviceState

enum class Audio::EAudioDeviceState

strong

Enumerator
Active
Disabled
NotPresent
Unplugged
COUNT

◆ EAudioTaskType

enum class Audio::EAudioTaskType

strong

Enumerator
Procedural
Header
Decode
Invalid

◆ EBufferCheckBehavior

enum class Audio::EBufferCheckBehavior : uint8

strong

Enumerator
Nothing
Ensure
Log
Break

◆ EBufferReadMode

enum class Audio::EBufferReadMode : uint8

strong

Enum describing the data-read mode of an audio buffer.

Enumerator
Asynchronous	Read the next buffer asynchronously.
AsynchronousSkipFirstFrame	Read the next buffer asynchronously but skip the first chunk of audio.

◆ EChannelMapMonoUpmixMethod

enum class Audio::EChannelMapMonoUpmixMethod : uint8

strong

Denotes the upmix method for mixing a mono input into the front left and front right speakers.

Enumerator
Linear
EqualPower
FullVolume

◆ EChannelMapOrder

enum class Audio::EChannelMapOrder : uint8

strong

Denotes the order of gain coefficients for a channel map.

Enumerator
OutputMajorOrder
InputMajorOrder

◆ ECheckBufferFlags

enum class Audio::ECheckBufferFlags : uint32

strong

Enumerator
None
Infinity
Nan
Denormalized
All

◆ EDeviceEndpointType

enum class Audio::EDeviceEndpointType

strong

Enumerator
Unknown
Render
Capture

◆ EDynamicFilterType

enum Audio::EDynamicFilterType

Enumerator
Bell
LowShelf
HighShelf

◆ EDynamicsProcessorChannelLinkMode

enum class Audio::EDynamicsProcessorChannelLinkMode : uint8

strong

Enumerator
Disabled
Average
Peak
Count

◆ EEventQuantization

enum class Audio::EEventQuantization : uint8

strong

Enumerator
None
Bars8
Bars4
Bars2
Bar
HalfNote
HalfNoteTriplet
QuarterNote
QuarterNoteTriplet
EighthNote
EighthNoteTriplet
SixteenthNote
SixteenthNoteTriplet
ThirtySecondNote
Count

◆ EFaderCurve

enum class Audio::EFaderCurve : uint8

strong

Type of fade to use when adjusting a fader's volume over time.

Enumerator
Linear
Logarithmic
SCurve
Sin
Count

◆ EFFTScaling

enum class Audio::EFFTScaling : uint8

strong

EFFTScaling

EFFTScaling describes how transformed data is scaled. IFFTAlgorithm implementations must return this value to describe how to achieve equal energy between input data and transformed data. It is assumed that applying the logical inverse of the scaling will produce equal energy.

Enumerator
None	No scaling needed to maintain equal energy.
MultipliedByFFTSize	Output is effectively multiplied by FFTSize. To maintain equal energy, output must be divided by the FFTSize.
MultipliedBySqrtFFTSize	Output is effectively multiplied by the square root of the FFTSize. To maintain equal energy, output must be divided by the square root of the FFTSize.
DividedByFFTSize	Output is effectively divided by the square root of the FFTSize. To maintain equal energy, output must be multiplied by the square root of the FFTSize.
DividedBySqrtFFTSize	Output is effectively divided by the square root of the FFTSize. To maintain equal energy, output must be multiplied by the square root of the FFTSize.

◆ EFilterOrder

enum class Audio::EFilterOrder : uint32

strong

Enumerator
TwoPole
FourPole
SixPole
EightPole

◆ EFormatType

enum Audio::EFormatType

Enumerator
IEEE_FLOAT

◆ EGrainEnvelopeType

enum class Audio::EGrainEnvelopeType

strong

Enumerator
Rectangular
Triangle
DownwardTriangle
UpwardTriangle
ExponentialDecay
ExponentialIncrease
Gaussian
Hanning
Lanczos
Cosine
CosineSquared
Welch
Blackman
BlackmanHarris
Count

◆ EGranularSynthMode

enum class Audio::EGranularSynthMode : uint8

strong

Enumerator
Synthesis
Granulation
Count

◆ EHardwareInputFeature

enum class Audio::EHardwareInputFeature : uint8

strong

Enumerator
EchoCancellation
NoiseSuppression
AutomaticGainControl

◆ EMelNormalization

enum class Audio::EMelNormalization : uint8

strong

Normalization methods for a mel transform.

Enumerator
EqualAmplitude
EqualEuclideanNorm
EqualEnergy

◆ EMixerSourceInitializationState

enum class Audio::EMixerSourceInitializationState : uint8

strong

State to track initialization stages.

Enumerator
NotInitialized
Initializing
Initialized

◆ EMixerSourceSubmixSendStage

enum Audio::EMixerSourceSubmixSendStage

Enumerator
PostDistanceAttenuation
PreDistanceAttenuation

◆ EPCMAudioEncoding

enum class Audio::EPCMAudioEncoding : uint8

strong

PCM audio format (bits per sample) supported by device layers (WASAPI, CoreAudio, etc.)

Enumerator
UNKNOWN
PCM_8
PCM_16
PCM_24
PCM_24_IN_32
PCM_32
FLOATING_POINT_32
FLOATING_POINT_64

◆ EPseudoConstantQNormalization

enum class Audio::EPseudoConstantQNormalization : uint8

strong

Band normalization schemes

Enumerator
EqualAmplitude
EqualEuclideanNorm
EqualEnergy

◆ EResamplingMethod

enum class Audio::EResamplingMethod : uint8

strong

Enumerator
BestSinc
ModerateSinc
FastSinc
ZeroOrderHold
Linear

◆ EResult

enum class Audio::EResult : uint8

strong

Enumerator
Success
Failure
NotImplemented

◆ ESoundWavePCMWriterState

enum class Audio::ESoundWavePCMWriterState : uint8

strong

Enumerator
Idle
Generating
WritingToDisk
Suceeded
Failed
Cancelled

◆ ESoundWavePCMWriteTaskType

enum class Audio::ESoundWavePCMWriteTaskType : uint8

strong

Enumerator
GenerateSoundWave
GenerateAndWriteSoundWave
WriteSoundWave
WriteWavFile

◆ ESpectrumType

enum class Audio::ESpectrumType : uint8

strong

Enumerator
MagnitudeSpectrum
PowerSpectrum

◆ ETransformationPriority

enum class Audio::ETransformationPriority : uint8

strong

Enumerator
None
Low
High

◆ EWasapiAudioEncoding

enum class Audio::EWasapiAudioEncoding : uint8

strong

EWasapiAudioEncoding - Audio bit depths supported by WASAPI implementation

Enumerator
UNKNOWN
PCM_8
PCM_16
PCM_24
PCM_24_IN_32
PCM_32
FLOATING_POINT_32
FLOATING_POINT_64

◆ EWaveShaperType

enum class Audio::EWaveShaperType : int32

strong

Enumerator
Sin
ATan
Tanh
Cubic
HardClip

◆ EWindowType

enum class Audio::EWindowType : uint8

strong

Enumerator
None
Hamming
Hann
Blackman

Function Documentation

◆ Apply2ChannelGain() [1/4]

SIGNALPROCESSING_API void Audio::Apply2ChannelGain	(	FAlignedFloatBuffer &	StereoBuffer,
		const float *RESTRICT	Gains
	)

CHANNEL MIXING OPERATIONS: To understand these functions, it's best that you have prior experience reading SIMD code. These functions are all variations on component-wise matrix multiplies. There are two types of functions below:

Apply[N]ChannelGain: These are all in-place multiplies of an N-length gain vector and an N-length frame. There are two flavors of every variant of this function: The non-interpolating form (which takes a single gain matrix) And the interpolating form (which takes a start gain matrix and interpolates to the end gain matrix over the given number of frames). All non-interpolating forms of these functions use the following steps:

Create a const GainVector, or series of GainVectors, that maps to the multiplies required for each iteration.
In a loop: i. load a frame or number of frames into a vector register or series of vector registers (these are named Result). ii. perform a vector multiply on result with the corresponding gain vector. iii. store the result vector in the same position in the buffer we loaded from.

The interpolating forms of these functions use the following steps:

Initialize a non-const GainVector, or series of GainVectors, from StartGains, that maps to the multiplies required for each iteration.
Compute the amount we add to GainVector for each iteration to reach Destination Gains and store it in the const GainDeltasVector.
In a loop: i. load a frame or number of frames into a vector register or series of vector registers (these are named Result). ii. perform a vector multiply on result with the corresponding gain vector. iii. store the result vector in the same position in the buffer we loaded from. iv. increment each GainVector by it's corresponding GainDeltasVector.

MixMonoTo[N]ChannelsFast and Mix2ChannelsTo[N]ChannelsFast: These, like Apply[N]ChannelGain, all have non-interpolating and interpolating forms. All non-interpolating forms of these functions use the following steps:

Create a const GainVector, or series of GainVectors, that maps to the multiplies required for each input channel for each iteration.
In a loop: i. load a frame or number of frames into a const vector register or series of const vector registers (these are named Input). ii. perform a vector multiply on input with the corresponding gain vector and store the result in a new vector or series of vectors named Result. iii. if there is a second input channel, store the results of the following MultiplyAdd operation to Results: (Gain Vectors for second channel) * (Input vectors for second channel) + (Result vectors from step ii).

Interpolating forms of these functions use the following steps:

Initialize a non-const GainVector, or series of GainVectors, from StartGains, that maps to the multiplies required for each input channel for each iteration.
Compute the amount we add to each GainVector for each iteration to reach the vector's corresponding DestinationGains and store it in a corresponding GainDeltaVector.
In a loop: i. load a frame or number of frames into a const vector register or series of const vector registers (these are named Input). ii. perform a vector multiply on input with the corresponding gain vector and store the result in a new vector or series of vectors named Result. iii. if there is a second input channel, store the results of the following MultiplyAdd operation to Results: (Gain Vectors for second channel) * (Input vectors for second channel) + (Result vectors from step ii). iv. increment each GainVector by it's corresponding GainDeltasVector.

DETERMINING THE VECTOR LAYOUT FOR EACH FUNCTION: For every variant of Mix[N]ChannelsTo[N]ChannelsFast, we use the least common multiple of the number of output channels and the SIMD vector length (4) to calulate the length of our matrix. For example, MixMonoTo4ChannelsFast can use a single VectorRegister4Float for each variable. GainVector's values are [g0, g1, g2, g3], input channels are mapped to [i0, i0, i0, i0], and output channels are mapped to [o0, o1, o2, o3]. MixMonoTo8ChannelsFast has an LCM of 8, so we use two VectorRegister4Float for each variable. This results in the following layout: GainVector1: [g0, g1, g2, g3] GainVector2: [g4, g5, g6, g7] InputVector1: [i0, i0, i0, i0] InputVector2: [i0, i0, i0, i0] ResultVector1: [o0, o1, o2, o3] ResultVector2: [o4, o5, o6, o7]

The general naming convention for vector variables is [Name]Vector[VectorIndex] for MixMonoTo[N]ChannelsFast functions. For Mix2ChannelsTo[N]ChannelsFast functions, the naming convention for vector variables is [Name]Vector[VectorIndex][InputChannelIndex].

For clarity, the layout of vectors for each function variant is given in a block comment above that function.

CHANNEL-SPECIFIC OPERATIONS Takes a 2 channel interleaved buffer and applies Gains to it. Gains is expected to point to a 2 float long buffer. StereoBuffer must have an even number of frames. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ Apply2ChannelGain() [2/4]

SIGNALPROCESSING_API void Audio::Apply2ChannelGain	(	FAlignedFloatBuffer &	StereoBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Apply2ChannelGain() [3/4]

SIGNALPROCESSING_API void Audio::Apply2ChannelGain	(	float *RESTRICT	StereoBuffer,
		int32	NumSamples,
		const float *RESTRICT	Gains
	)

◆ Apply2ChannelGain() [4/4]

SIGNALPROCESSING_API void Audio::Apply2ChannelGain	(	float *RESTRICT	StereoBuffer,
		int32	NumSamples,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Apply4ChannelGain() [1/4]

SIGNALPROCESSING_API void Audio::Apply4ChannelGain	(	FAlignedFloatBuffer &	InterleavedBuffer,
		const float *RESTRICT	Gains
	)

Takes a 4 channel interleaved buffer and applies Gains to it. Gains is expected to point to a 2 float long buffer. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ Apply4ChannelGain() [2/4]

SIGNALPROCESSING_API void Audio::Apply4ChannelGain	(	FAlignedFloatBuffer &	InterleavedBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Apply4ChannelGain() [3/4]

SIGNALPROCESSING_API void Audio::Apply4ChannelGain	(	float *RESTRICT	InterleavedBuffer,
		int32	NumSamples,
		const float *RESTRICT	Gains
	)

◆ Apply4ChannelGain() [4/4]

SIGNALPROCESSING_API void Audio::Apply4ChannelGain	(	float *RESTRICT	InterleavedBuffer,
		int32	NumSamples,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Apply6ChannelGain() [1/4]

SIGNALPROCESSING_API void Audio::Apply6ChannelGain	(	FAlignedFloatBuffer &	InterleavedBuffer,
		const float *RESTRICT	Gains
	)

Takes a 6 channel interleaved buffer and applies Gains to it. Gains is expected to point to a 2 float long buffer. InterleavedBuffer must have an even number of frames.

◆ Apply6ChannelGain() [2/4]

SIGNALPROCESSING_API void Audio::Apply6ChannelGain	(	FAlignedFloatBuffer &	InterleavedBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Apply6ChannelGain() [3/4]

SIGNALPROCESSING_API void Audio::Apply6ChannelGain	(	float *RESTRICT	InterleavedBuffer,
		int32	NumSamples,
		const float *RESTRICT	Gains
	)

◆ Apply6ChannelGain() [4/4]

SIGNALPROCESSING_API void Audio::Apply6ChannelGain	(	float *RESTRICT	InterleavedBuffer,
		int32	NumSamples,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Apply8ChannelGain() [1/4]

SIGNALPROCESSING_API void Audio::Apply8ChannelGain	(	FAlignedFloatBuffer &	InterleavedBuffer,
		const float *RESTRICT	Gains
	)

Takes an 8 channel interleaved buffer and applies Gains to it. Gains is expected to point to an 8 float long buffer.

◆ Apply8ChannelGain() [2/4]

SIGNALPROCESSING_API void Audio::Apply8ChannelGain	(	FAlignedFloatBuffer &	InterleavedBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Apply8ChannelGain() [3/4]

SIGNALPROCESSING_API void Audio::Apply8ChannelGain	(	float *RESTRICT	InterleavedBuffer,
		int32	NumSamples,
		const float *RESTRICT	Gains
	)

◆ Apply8ChannelGain() [4/4]

SIGNALPROCESSING_API void Audio::Apply8ChannelGain	(	float *RESTRICT	InterleavedBuffer,
		int32	NumSamples,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ ArrayAbs()

SIGNALPROCESSING_API void Audio::ArrayAbs	(	TArrayView< const float >	InBuffer,
		TArrayView< float >	OutBuffer
	)

Absolute value of array elements

◆ ArrayAbsInPlace()

SIGNALPROCESSING_API void Audio::ArrayAbsInPlace ( TArrayView< float > InBuffer )

Absolute value of array elements in place.

InBuffer contains the data to be manipulated.

◆ ArrayAddConstantInplace()

SIGNALPROCESSING_API void Audio::ArrayAddConstantInplace	(	TArrayView< float >	InOutBuffer,
		float	InConstant
	)

Adds a constant to a buffer (useful for DC offset removal)

◆ ArrayAddInPlace()

SIGNALPROCESSING_API void Audio::ArrayAddInPlace	(	TArrayView< const float >	InValues,
		TArrayView< float >	InAccumulateValues
	)

Add arrays element-wise in place. InAccumulateValues[i] += InValues[i]

InValues is the array to add. InAccumulateValues is the array which holds the sum.

◆ ArrayAPFLongDelayProcess()

SIGNALPROCESSING_API void Audio::ArrayAPFLongDelayProcess	(	const float *	InSamples,
		const float *	InDelaySamples,
		const int32	InNum,
		float *	OutSamples,
		float *	OutDelaySamples,
		const float	Gain
	)

All Pass Filter with a long delay.

◆ ArrayClampInPlace()

SIGNALPROCESSING_API void Audio::ArrayClampInPlace	(	TArrayView< float >	InView,
		float	InMin,
		float	InMax
	)

Clamp values in an array.

InView is a view of a float array to be clamped. InMin is the minimum value allowable in the array. InMax is the maximum value allowable in the array.

◆ ArrayClampMaxInPlace()

SIGNALPROCESSING_API void Audio::ArrayClampMaxInPlace	(	TArrayView< float >	InView,
		float	InMax
	)

Clamp maximum value of array in place.

InView contains data to be clamped. InMax contains the maximum value allowable in InView.

◆ ArrayClampMinInPlace()

SIGNALPROCESSING_API void Audio::ArrayClampMinInPlace	(	TArrayView< float >	InView,
		float	InMin
	)

Clamp minimum value of array in place.

InView contains data to be clamped. InMin contains the minimum value allowable in InView.

◆ ArrayComplexConjugate()

SIGNALPROCESSING_API void Audio::ArrayComplexConjugate	(	TArrayView< const float >	InValues,
		TArrayView< float >	OutValues
	)

Perform complex conjugate of array. Assumes complex numbers are interlaves [real_0, imag_0, real_1, image_1, ..., real_N, imag_N].

◆ ArrayComplexConjugateInPlace()

SIGNALPROCESSING_API void Audio::ArrayComplexConjugateInPlace ( TArrayView< float > InValues )

◆ ArrayComplexMultiplyAdd()

SIGNALPROCESSING_API void Audio::ArrayComplexMultiplyAdd	(	TArrayView< const float >	InValues1,
		TArrayView< const float >	InValues2,
		TArrayView< float >	OutArray
	)

Multiplies two complex valued arrays element-wise. This assumes elements are in interleaved format [real_0, imag_0, ..., real_N, imag_N] Adds result to OutArray

◆ ArrayComplexMultiplyInPlace()

SIGNALPROCESSING_API void Audio::ArrayComplexMultiplyInPlace	(	TArrayView< const float >	InValues1,
		TArrayView< float >	InValues2
	)

Multiplies two complex valued arrays element-wise. This assumes elements are in interleaved format [real_0, imag_0, ..., real_N, imag_N] Stores result in InValues2

◆ ArrayComplexToPower() [1/2]

SIGNALPROCESSING_API void Audio::ArrayComplexToPower	(	TArrayView< const float >	InComplexSamples,
		TArrayView< float >	OutPowerSamples
	)

Compute power of complex data. Out[i] = Complex[2 * i] * Complex[2 * i] + Complex[2 * i + 1] * Complex[2 * i + 1]

◆ ArrayComplexToPower() [2/2]

SIGNALPROCESSING_API void Audio::ArrayComplexToPower	(	TArrayView< const float >	InRealSamples,
		TArrayView< const float >	InImaginarySamples,
		TArrayView< float >	OutPowerSamples
	)

Compute power of complex data. Out[i] = Real[i] * Real[i] + Imaginary[i] * Imaginary[i]

◆ ArrayCumulativeSum()

SIGNALPROCESSING_API void Audio::ArrayCumulativeSum	(	TArrayView< const float >	InView,
		TArray< float > &	OutData
	)

Cumulative sum of array.

InView contains data to be cumulatively summed. OutData contains sum and is same size as InView.

◆ ArrayDeinterleave() [1/3]

SIGNALPROCESSING_API void Audio::ArrayDeinterleave	(	const FAlignedFloatBuffer &	InBuffer,
		TArray< FAlignedFloatBuffer > &	OutBuffers,
		const int32	InChannels
	)

Interleaves samples from an array of input buffers

◆ ArrayDeinterleave() [2/3]

SIGNALPROCESSING_API void Audio::ArrayDeinterleave	(	const float *RESTRICT	InBuffer,
		float const RESTRICT	OutBuffers,
		const int32	InFrames,
		const int32	InChannels
	)

Interleaves samples from an array of input buffers

◆ ArrayDeinterleave() [3/3]

SIGNALPROCESSING_API void Audio::ArrayDeinterleave	(	const TArrayView< const float >	InView,
		TArray< FAlignedFloatBuffer > &	OutBuffers,
		const int32	InChannels
	)

Interleaves samples from an array of input buffers

◆ ArrayDoubleSwapBytes()

SIGNALPROCESSING_API void Audio::ArrayDoubleSwapBytes ( TArrayView< double > InView )

Vectorized 64-bit float byte swapping.

◆ ArrayFade() [1/2]

SIGNALPROCESSING_API void Audio::ArrayFade	(	TArrayView< const float >	InBuffer,
		const float	InStartValue,
		const float	InEndValue,
		TArrayView< float >	OutBuffer
	)

◆ ArrayFade() [2/2]

SIGNALPROCESSING_API void Audio::ArrayFade	(	TArrayView< float >	InOutBuffer,
		const float	StartValue,
		const float	EndValue
	)

◆ ArrayFloatSwapBytes()

SIGNALPROCESSING_API void Audio::ArrayFloatSwapBytes ( TArrayView< float > InView )

Vectorized 32-bit float byte swapping.

◆ ArrayFloatToPcm16()

SIGNALPROCESSING_API void Audio::ArrayFloatToPcm16	(	TArrayView< const float >	InView,
		TArrayView< int16 >	OutView
	)

◆ ArrayFloatToPcm24()

SIGNALPROCESSING_API void Audio::ArrayFloatToPcm24	(	TArrayView< const float >	InView,
		TArrayView< int8 >	OutView
	)

Converts float PCM data to 24 bit integer PCM data

◆ ArrayFloatToPcm32()

SIGNALPROCESSING_API void Audio::ArrayFloatToPcm32	(	TArrayView< const float >	InView,
		TArrayView< int32 >	OutView
	)

Converts float PCM data to 32 bit integer PCM data

◆ ArrayFloatToPcmDouble()

SIGNALPROCESSING_API void Audio::ArrayFloatToPcmDouble	(	TArrayView< const float >	InView,
		TArrayView< double >	OutView
	)

Converts float PCM data to double PCM data

◆ ArrayGetAverageAbsValue()

SIGNALPROCESSING_API float Audio::ArrayGetAverageAbsValue ( TArrayView< const float > Buffer )

Takes an audio buffer and gets the average absolute amplitude across that buffer.

◆ ArrayGetAverageValue()

SIGNALPROCESSING_API float Audio::ArrayGetAverageValue ( TArrayView< const float > Buffer )

Takes an audio buffer and gets the average amplitude across that buffer.

◆ ArrayGetEuclideanNorm()

SIGNALPROCESSING_API void Audio::ArrayGetEuclideanNorm	(	TArrayView< const float >	InView,
		float &	OutEuclideanNorm
	)

Computes the EuclideanNorm of the InView. Same as calculating the energy in window.

◆ ArrayGetMagnitude()

SIGNALPROCESSING_API float Audio::ArrayGetMagnitude ( TArrayView< const float > Buffer )

Takes an audio buffer and returns the magnitude across that buffer.

◆ ArrayInt16SwapBytes()

SIGNALPROCESSING_API void Audio::ArrayInt16SwapBytes ( TArrayView< int16 > InView )

Vectorized 16-bit integer byte swapping.

◆ ArrayInt24SwapBytes()

SIGNALPROCESSING_API void Audio::ArrayInt24SwapBytes ( TArrayView< int8 > InView )

Vectorized 24-bit integer byte swapping.

◆ ArrayInt32SwapBytes()

SIGNALPROCESSING_API void Audio::ArrayInt32SwapBytes ( TArrayView< int32 > InView )

Vectorized 32-bit integer byte swapping.

◆ ArrayInterleave() [1/2]

SIGNALPROCESSING_API void Audio::ArrayInterleave	(	const float const RESTRICT	InBuffers,
		float *RESTRICT	OutBuffer,
		const int32	InFrames,
		const int32	InChannels
	)

Interleaves samples from an array of input buffers

◆ ArrayInterleave() [2/2]

SIGNALPROCESSING_API void Audio::ArrayInterleave	(	const TArray< FAlignedFloatBuffer > &	InBuffers,
		FAlignedFloatBuffer &	OutBuffer
	)

Interleaves samples from an array of input buffers

◆ ArrayInterpolate() [1/2]

void Audio::ArrayInterpolate	(	const float *	InBuffer,
		float *	OutBuffer,
		const int32	NumInSamples,
		const int32	NumOutSamples
	)

◆ ArrayInterpolate() [2/2]

SIGNALPROCESSING_API void Audio::ArrayInterpolate	(	const float *RESTRICT	InBuffer,
		float *RESTRICT	OutBuffer,
		const int32	NumInSamples,
		const int32	NumOutSamples
	)

Interpolates a Mono audio buffer.

◆ ArrayLerpAddInPlace()

SIGNALPROCESSING_API void Audio::ArrayLerpAddInPlace	(	TArrayView< const float >	InValues,
		float	InStartMultiplier,
		float	InEndMultiplier,
		TArrayView< float >	InAccumulateValues
	)

Linearly Interpolate Add arrays element-wise in place. InAccumulateValues[i] += ((1 - alpha) * InStartMultiplier + alpha * InEndMultipler) * InValues[i] Interpolation is performed over the length of the array.

Parameters

InValues	- The array to add.
InStartMultiplier	- The beginning value to multiply against InValues
InEndMultiplier	- The ending value to multiply against InValues
InAccumulateValues	- The array which holds the sum.

◆ ArrayLerpFractionalDelay()

SIGNALPROCESSING_API void Audio::ArrayLerpFractionalDelay	(	const float *	InSamples,
		const float *	InDelays,
		const float *	DelayData,
		const int *	IntegerDelays,
		int *	UpperDelayPos,
		int *	LowerDelayPos,
		const int32	InNum,
		float *	OutSamples,
		const float	MaxDelay
	)

Fractional delay using linear interpolation.

◆ ArrayMagnitudeToDecibelInPlace()

SIGNALPROCESSING_API void Audio::ArrayMagnitudeToDecibelInPlace	(	TArrayView< float >	InValues,
		float	InMinimumDb
	)

Convert magnitude values to decibel values in place. db = 20 * log10(val)

◆ ArrayMax()

SIGNALPROCESSING_API void Audio::ArrayMax	(	const TArrayView< const float > &	InView1,
		const TArrayView< const float > &	InView2,
		const TArrayView< float > &	OutView
	)

Element-wise Max

◆ ArrayMaxAbsValue()

SIGNALPROCESSING_API float Audio::ArrayMaxAbsValue ( const TArrayView< const float > InView )

Returns the largest value of an array irrespective of sign (ex. {-3, 2, 1} would return 3). InView is a view of a float array to get the largest absolute value from.

◆ ArrayMaxFilter()

SIGNALPROCESSING_API void Audio::ArrayMaxFilter	(	TArrayView< const float >	InView,
		int32	WindowSize,
		int32	WindowOrigin,
		TArray< float > &	OutData
	)

Max filter of array.

Note: At array boundaries, this algorithm truncates windows where no valid array data exists.

InView contains data to be filtered. WindowSize determines the number of samples from InView analyzed to produce a value in OutData. WindowOrigin describes the offset from the windows first sample to the index of OutData. For example, if WindowOrigin = WindowSize/4, then OutData[i] = Max(InView[i - Window/4 : i + 3 * Window / 4]). OutData contains the produceds data.

◆ ArrayMean()

SIGNALPROCESSING_API void Audio::ArrayMean	(	TArrayView< const float >	InView,
		float &	OutMean
	)

Mean of array. Equivalent to Sum(InView) / InView.Num()

InView contains data to be analyzed. OutMean contains the result.

◆ ArrayMeanFilter()

SIGNALPROCESSING_API void Audio::ArrayMeanFilter	(	TArrayView< const float >	InView,
		int32	WindowSize,
		int32	WindowOrigin,
		TArray< float > &	OutData
	)

Mean filter of array.

Note: Uses standard biased mean estimator of Sum(x) / Count(x). Note: At array boundaries, this algorithm truncates windows where no valid array data exists. Values calculated with truncated windows have corresponding increased variances.

InView contains data to be filtered. WindowSize determines the number of samples from InView analyzed to produce a value in OutData. WindowOrigin describes the offset from the windows first sample to the index of OutData. For example, if WindowOrigin = WindowSize/4, then OutData[i] = Mean(InView[i - Window/4 : i + 3 * Window / 4]). OutData contains the produceds data.

◆ ArrayMeanSquared()

SIGNALPROCESSING_API void Audio::ArrayMeanSquared	(	TArrayView< const float >	InView,
		float &	OutMean
	)

Mean Squared of array. Equivalent to Sum(InView * InView) / InView.Num()

InArray contains data to be analyzed. OutMean contains the result.

◆ ArrayMinMaxNormalize()

SIGNALPROCESSING_API void Audio::ArrayMinMaxNormalize	(	TArrayView< const float >	InView,
		TArray< float > &	OutArray
	)

Scale an array so the minimum is 0 and the maximum is 1

InView is the view of a float array with the input data. OutArray is an array which will hold the normalized data.

◆ ArrayMixIn() [1/4]

SIGNALPROCESSING_API void Audio::ArrayMixIn	(	TArrayView< const float >	InFloatBuffer,
		TArrayView< float >	BufferToSumTo
	)

◆ ArrayMixIn() [2/4]

SIGNALPROCESSING_API void Audio::ArrayMixIn	(	TArrayView< const float >	InFloatBuffer,
		TArrayView< float >	BufferToSumTo,
		const float	Gain
	)

Takes buffer InFloatBuffer, optionally multiplies it by Gain, and adds it to BufferToSumTo.

◆ ArrayMixIn() [3/4]

SIGNALPROCESSING_API void Audio::ArrayMixIn	(	TArrayView< const float >	InFloatBuffer,
		TArrayView< float >	BufferToSumTo,
		const float	StartGain,
		const float	EndGain
	)

This version of ArrayMixIn will fade from StartGain to EndGain.

◆ ArrayMixIn() [4/4]

SIGNALPROCESSING_API void Audio::ArrayMixIn	(	TArrayView< const int16 >	InPcm16Buffer,
		TArrayView< float >	BufferToSumTo,
		const float	Gain = `1.0f`
	)

Takes buffer InPcm16Buffer, converts it to float and optionally multiplies it by Gain, and adds it to BufferToSumTo.

◆ ArrayMultiply()

SIGNALPROCESSING_API void Audio::ArrayMultiply	(	TArrayView< const float >	InFloatBufferA,
		TArrayView< const float >	InFloatBufferB,
		TArrayView< float >	OutBuffer
	)

Multiply the second buffer by the first buffer.

◆ ArrayMultiplyAddInPlace()

SIGNALPROCESSING_API void Audio::ArrayMultiplyAddInPlace	(	TArrayView< const float >	InValues,
		float	InMultiplier,
		TArrayView< float >	InAccumulateValues
	)

Multiply Add arrays element-wise in place. InAccumulateValues[i] += InMultiplier * InValues[i]

Parameters

InValues	- The array to add.
InMultiplier	- The value to multiply against InValues
InAccumulateValues	- The array which holds the sum.

◆ ArrayMultiplyByConstant()

SIGNALPROCESSING_API void Audio::ArrayMultiplyByConstant	(	TArrayView< const float >	InFloatBuffer,
		float	InValue,
		TArrayView< float >	OutFloatBuffer
	)

Multiplies the input float buffer with the given value.

◆ ArrayMultiplyByConstantInPlace()

SIGNALPROCESSING_API void Audio::ArrayMultiplyByConstantInPlace	(	TArrayView< float >	InOutBuffer,
		float	InGain
	)

Similar to ArrayMultiplyByConstant, but performs the multiply in place.

◆ ArrayMultiplyInPlace()

SIGNALPROCESSING_API void Audio::ArrayMultiplyInPlace	(	TArrayView< const float >	InFloatBuffer,
		TArrayView< float >	BufferToMultiply
	)

Multiply the second buffer in place by the first buffer.

◆ ArrayPcm16ToFloat()

SIGNALPROCESSING_API void Audio::ArrayPcm16ToFloat	(	TArrayView< const int16 >	InView,
		TArrayView< float >	OutView
	)

◆ ArrayPowerToDecibelInPlace()

SIGNALPROCESSING_API void Audio::ArrayPowerToDecibelInPlace	(	TArrayView< float >	InValues,
		float	InMinimumDb
	)

Convert power values to decibel values in place. db = 10 * log10(val)

◆ ArrayRangeClamp()

SIGNALPROCESSING_API void Audio::ArrayRangeClamp	(	TArrayView< float >	InOutBuffer,
		float	InMinValue,
		float	InMaxValue
	)

◆ ArrayScaledComplexConjugate()

SIGNALPROCESSING_API void Audio::ArrayScaledComplexConjugate	(	const float *RESTRICT	InValues,
		const int32	Num,
		float *RESTRICT	OutValues,
		const float	Scale
	)

Perform complex conjugate as well as scale.

◆ ArraySetToConstantInplace()

SIGNALPROCESSING_API void Audio::ArraySetToConstantInplace	(	TArrayView< float >	InOutBuffer,
		float	InConstant
	)

Sets a constant to a buffer (useful for DC offset application)

◆ ArraySqrtInPlace()

SIGNALPROCESSING_API void Audio::ArraySqrtInPlace ( TArrayView< float > InValues )

Take Square Root of values in place.

◆ ArraySquare()

SIGNALPROCESSING_API void Audio::ArraySquare	(	TArrayView< const float >	InValues,
		TArrayView< float >	OutValues
	)

◆ ArraySquareInPlace()

SIGNALPROCESSING_API void Audio::ArraySquareInPlace ( TArrayView< float > InValues )

Square values in place.

◆ ArraySubtract()

SIGNALPROCESSING_API void Audio::ArraySubtract	(	TArrayView< const float >	InMinuend,
		TArrayView< const float >	InSubtrahend,
		TArrayView< float >	OutBuffer
	)

Subract arrays element-wise. OutArray = InMinuend - InSubtrahend

InMinuend is the array of data to be subtracted from. InSubtrahend is the array of data to subtract. OutBuffer is the array which holds the result.

◆ ArraySubtractByConstantInPlace()

SIGNALPROCESSING_API void Audio::ArraySubtractByConstantInPlace	(	TArrayView< float >	InValues,
		float	InSubtrahend
	)

Subtract value from each element in InValues

◆ ArraySubtractInPlace1()

SIGNALPROCESSING_API void Audio::ArraySubtractInPlace1	(	TArrayView< const float >	InMinuend,
		TArrayView< float >	InOutSubtrahend
	)

◆ ArraySubtractInPlace2()

SIGNALPROCESSING_API void Audio::ArraySubtractInPlace2	(	TArrayView< float >	InOutMinuend,
		TArrayView< const float >	InSubtrahend
	)

◆ ArraySum() [1/2]

SIGNALPROCESSING_API void Audio::ArraySum	(	TArrayView< const float >	InFloatBuffer1,
		TArrayView< const float >	InFloatBuffer2,
		TArrayView< float >	OutputBuffer
	)

Sums two buffers together and places the result in the resulting buffer.

◆ ArraySum() [2/2]

SIGNALPROCESSING_API void Audio::ArraySum	(	TArrayView< const float >	InValues,
		float &	OutSum
	)

Sum all values in an array.

◆ ArrayUnderflowClamp()

SIGNALPROCESSING_API void Audio::ArrayUnderflowClamp ( TArrayView< float > InOutValues )

◆ ArrayWeightedSum() [1/2]

SIGNALPROCESSING_API void Audio::ArrayWeightedSum	(	TArrayView< const float >	InBuffer1,
		float	InGain1,
		TArrayView< const float >	InBuffer2,
		float	InGain2,
		TArrayView< float >	OutBuffer
	)

◆ ArrayWeightedSum() [2/2]

SIGNALPROCESSING_API void Audio::ArrayWeightedSum	(	TArrayView< const float >	InBuffer1,
		float	InGain1,
		TArrayView< const float >	InBuffer2,
		TArrayView< float >	OutBuffer
	)

◆ AssignPcm24Value()

SIGNALPROCESSING_API void Audio::AssignPcm24Value	(	int8 *	OutPtr,
		const int32	InValue,
		const bool	bIsOutputLittleEndian
	)

Copies 24 bits of a 32 bit integer (assumes data has been clamped to 24-bits)

◆ AudioClientErrorToFString()

WINDOWSMMDEVICEENUMERATION_API FString Audio::AudioClientErrorToFString ( HRESULT InResult )

◆ BufferDeinterleave2ChannelFast() [1/2]

SIGNALPROCESSING_API void Audio::BufferDeinterleave2ChannelFast	(	const FAlignedFloatBuffer &	InBuffer,
		FAlignedFloatBuffer &	OutBuffer1,
		FAlignedFloatBuffer &	OutBuffer2
	)

Deinterleaves samples from a 2 channel input buffer

◆ BufferDeinterleave2ChannelFast() [2/2]

SIGNALPROCESSING_API void Audio::BufferDeinterleave2ChannelFast	(	const float *RESTRICT	InBuffer,
		float *RESTRICT	OutBuffer1,
		float *RESTRICT	OutBuffer2,
		const int32	InNumFrames
	)

Deinterleaves samples from a 2 channel input buffer

◆ BufferInterleave2ChannelFast() [1/2]

SIGNALPROCESSING_API void Audio::BufferInterleave2ChannelFast	(	const FAlignedFloatBuffer &	InBuffer1,
		const FAlignedFloatBuffer &	InBuffer2,
		FAlignedFloatBuffer &	OutBuffer
	)

Interleaves samples from two input buffers

◆ BufferInterleave2ChannelFast() [2/2]

SIGNALPROCESSING_API void Audio::BufferInterleave2ChannelFast	(	const float *RESTRICT	InBuffer1,
		const float *RESTRICT	InBuffer2,
		float *RESTRICT	OutBuffer,
		const int32	InNum
	)

Interleaves samples from two input buffers

◆ BufferSum2ChannelToMonoFast() [1/2]

SIGNALPROCESSING_API void Audio::BufferSum2ChannelToMonoFast	(	const FAlignedFloatBuffer &	InSamples,
		FAlignedFloatBuffer &	OutSamples
	)

Sums 2 channel interleaved input samples. OutSamples[n] = InSamples[2n] + InSamples[2n + 1]

◆ BufferSum2ChannelToMonoFast() [2/2]

SIGNALPROCESSING_API void Audio::BufferSum2ChannelToMonoFast	(	const float *RESTRICT	InSamples,
		float *RESTRICT	OutSamples,
		const int32	InNumFrames
	)

Sums 2 channel interleaved input samples. OutSamples[n] = InSamples[2n] + InSamples[2n + 1]

◆ CastToProxyDataFactory()

template<typename UClassToUse >

IAudioProxyDataFactory * Audio::CastToProxyDataFactory ( UObject * InObject )

◆ CeilLog2()

SIGNALPROCESSING_API int32 Audio::CeilLog2 ( int32 InNum )

◆ CheckBuffer()

SIGNALPROCESSING_API bool Audio::CheckBuffer	(	TArrayView< const float >	InBuffer,
		const ECheckBufferFlags	InFlags,
		ECheckBufferFlags &	OutFailedFlags
	)

Performs various tests on a audio buffer.

Parameters

InBuffer Buffer to examine @parm InFlags Bitfield of checks to perform

Returns: true if check passes, false otherwise

◆ CheckBufferValidity()

bool Audio::CheckBufferValidity	(	const FResamplingParameters &	InParameters,
		FResamplerResults &	OutData
	)

◆ CheckSample()

void Audio::CheckSample	(	float	InSample,
		float	Threshold = `0.001f`
	)

inline

◆ ContainsDenormalized()

SIGNALPROCESSING_API bool Audio::ContainsDenormalized ( TArrayView< const float > InBuffer )

◆ ContainsInfinity()

SIGNALPROCESSING_API bool Audio::ContainsInfinity ( TArrayView< const float > InBuffer )

◆ ContainsNan()

SIGNALPROCESSING_API bool Audio::ContainsNan ( TArrayView< const float > InBuffer )

◆ ConvertBipolarBufferToUnipolar()

void Audio::ConvertBipolarBufferToUnipolar	(	float *	InAlignedBuffer,
		int32	NumSamples
	)

inline

◆ ConvertToDecibels()

float Audio::ConvertToDecibels	(	const float	InLinear,
		const float	InFloor = `UE_SMALL_NUMBER`
	)

inline

◆ ConvertToLinear()

float Audio::ConvertToLinear ( const float InDecibels )

inline

◆ Create2DChannelMap()

SIGNALPROCESSING_API bool Audio::Create2DChannelMap	(	const FChannelMapParams &	InParams,
		TArray< float > &	OutChannelMap
	)

Create a 2D channel map.

Parameters

InParams	- Configuration of channel map.
OutChannelMap	- Array to append with channel map.

Returns: true on success, false on failure.

◆ CreateAudioTask() [1/3]

IAudioTask * Audio::CreateAudioTask	(	Audio::FDeviceId	InDeviceId,
		const FDecodeAudioTaskData &	InJobData
	)

◆ CreateAudioTask() [2/3]

IAudioTask * Audio::CreateAudioTask	(	Audio::FDeviceId	InDeviceId,
		const FHeaderParseAudioTaskData &	InJobData
	)

◆ CreateAudioTask() [3/3]

IAudioTask * Audio::CreateAudioTask	(	Audio::FDeviceId	InDeviceId,
		const FProceduralAudioTaskData &	InJobData
	)

◆ CreateByteMask()

constexpr int Audio::CreateByteMask	(	uint32	A,
		uint32	B,
		uint32	C,
		uint32	D
	)

constexpr

◆ CreateModulatorHandleId()

FModulatorHandleId Audio::CreateModulatorHandleId ( )

◆ CreateSoundAssetDecoder()

ENGINE_API ICompressedAudioInfo * Audio::CreateSoundAssetDecoder ( const FName & InRuntimeFormat )

Returns a decoder for the sound assets's given compression type. Will return nullptr if the compression type is platform-dependent.

◆ CreateSynchronizedAudioTaskQueue()

void Audio::CreateSynchronizedAudioTaskQueue ( AudioTaskQueueId QueueId )

◆ CreateVorbis2DChannelMap()

SIGNALPROCESSING_API bool Audio::CreateVorbis2DChannelMap	(	int32	InNumOutputChannels,
		EChannelMapOrder	InOrder,
		TArray< float > &	OutVorbisChannelMap
	)

Create a 2D channel map for 5.1 vorbis input audio.

Parameters

InNumOutputChannels	- Number of channels in the output audio.
InOrder	- Order of gian coefficients in the output channel map.
OutChannelMap	- Array to append with channel map.

Returns: true on success, false on failure.

◆ DecodeMidSide() [1/2]

SIGNALPROCESSING_API void Audio::DecodeMidSide	(	const FAlignedFloatBuffer &	InMidChannel,
		const FAlignedFloatBuffer &	InSideChannel,
		FAlignedFloatBuffer &	OutLeftChannel,
		FAlignedFloatBuffer &	OutRightChannel
	)

◆ DecodeMidSide() [2/2]

void Audio::DecodeMidSide	(	float &	MidChannel,
		float &	SideChannel
	)

inline

◆ DecodeMonoAmbisonicMixIn()

SIGNALPROCESSING_API void Audio::DecodeMonoAmbisonicMixIn	(	TArrayView< const float * >	Src,
		TArrayView< float >	Dst,
		TArrayView< const float >	AmbisonicGains
	)

◆ DecrementIOSAudioMixerPlatformSuspendCounter()

void AUDIOMIXERAUDIOUNIT_API Audio::DecrementIOSAudioMixerPlatformSuspendCounter ( )

◆ DestroySynchronizedAudioTaskQueue()

void Audio::DestroySynchronizedAudioTaskQueue	(	AudioTaskQueueId	QueueId,
		bool	RunCurrentQueue
	)

◆ DistanceAttenuationProcessAudio() [1/2]

SIGNALPROCESSING_API void Audio::DistanceAttenuationProcessAudio	(	TArrayView< float > &	InOutBuffer,
		uint32	InNumChannels,
		float	InDistance,
		const FAudioBufferDistanceAttenuationSettings &	InSettings,
		float &	InOutAttenuation
	)

◆ DistanceAttenuationProcessAudio() [2/2]

SIGNALPROCESSING_API void Audio::DistanceAttenuationProcessAudio	(	TArrayView< int16 > &	InOutBuffer,
		uint32	InNumChannels,
		float	InDistance,
		const FAudioBufferDistanceAttenuationSettings &	InSettings,
		float &	InOutAttenuation
	)

◆ DownmixAndSumIntoBuffer() [1/2]

SIGNALPROCESSING_API void Audio::DownmixAndSumIntoBuffer	(	int32	NumSourceChannels,
		int32	NumDestinationChannels,
		const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	BufferToSumTo,
		const float *RESTRICT	Gains
	)

This is similar to DownmixBuffer, except that it sums into DestinationBuffer rather than overwriting it.

◆ DownmixAndSumIntoBuffer() [2/2]

SIGNALPROCESSING_API void Audio::DownmixAndSumIntoBuffer	(	int32	NumSourceChannels,
		int32	NumDestinationChannels,
		const float *RESTRICT	SourceBuffer,
		float *RESTRICT	BufferToSumTo,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

◆ DownmixBuffer() [1/4]

SIGNALPROCESSING_API void Audio::DownmixBuffer	(	int32	NumSourceChannels,
		int32	NumDestinationChannels,
		const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

These functions are non-vectorized versions of the Mix[N]ChannelsTo[N]Channels functions above:

This is a generalized operation that uses the channel gain matrix provided in Gains to mix an interleaved source buffer to the interleaved downmix buffer. This operation is not explicitly vectorized and will almost always be slower than using one of the functions above.

◆ DownmixBuffer() [2/4]

SIGNALPROCESSING_API void Audio::DownmixBuffer	(	int32	NumSourceChannels,
		int32	NumDestinationChannels,
		const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ DownmixBuffer() [3/4]

SIGNALPROCESSING_API void Audio::DownmixBuffer	(	int32	NumSourceChannels,
		int32	NumDestinationChannels,
		const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

◆ DownmixBuffer() [4/4]

SIGNALPROCESSING_API void Audio::DownmixBuffer	(	int32	NumSourceChannels,
		int32	NumDestinationChannels,
		const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ EncodeMidSide() [1/2]

SIGNALPROCESSING_API void Audio::EncodeMidSide	(	const FAlignedFloatBuffer &	InLeftChannel,
		const FAlignedFloatBuffer &	InRightChannel,
		FAlignedFloatBuffer &	OutMidChannel,
		FAlignedFloatBuffer &	OutSideChannel
	)

◆ EncodeMidSide() [2/2]

void Audio::EncodeMidSide	(	float &	LeftChannel,
		float &	RightChannel
	)

inline

◆ EncodeMonoAmbisonicMixIn()

SIGNALPROCESSING_API void Audio::EncodeMonoAmbisonicMixIn	(	TArrayView< const float >	Src,
		TArrayView< float * >	Dst,
		TArrayView< const float >	AmbisonicGains
	)

◆ FastSin()

float Audio::FastSin ( const float X )

inline

◆ FastSin2()

float Audio::FastSin2 ( const float X )

inline

◆ FastSin3()

float Audio::FastSin3 ( const float X )

inline

◆ FastTan()

float Audio::FastTan ( float X )

inline

◆ FastTanh()

float Audio::FastTanh ( float X )

inline

◆ FindDenormalized()

SIGNALPROCESSING_API int32 Audio::FindDenormalized ( TArrayView< const float > InBuffer )

◆ FindInfinity()

SIGNALPROCESSING_API int32 Audio::FindInfinity ( TArrayView< const float > InBuffer )

◆ FindNan()

SIGNALPROCESSING_API int32 Audio::FindNan ( TArrayView< const float > InBuffer )

◆ GenerateBlackmanWindow()

SIGNALPROCESSING_API void Audio::GenerateBlackmanWindow	(	float *	WindowBuffer,
		int32	NumFrames,
		int32	NumChannels,
		bool	bIsPeriodic
	)

◆ GenerateHammingWindow()

SIGNALPROCESSING_API void Audio::GenerateHammingWindow	(	float *	WindowBuffer,
		int32	NumFrames,
		int32	NumChannels,
		bool	bIsPeriodic
	)

◆ GenerateHannWindow()

SIGNALPROCESSING_API void Audio::GenerateHannWindow	(	float *	WindowBuffer,
		int32	NumFrames,
		int32	NumChannels,
		bool	bIsPeriodic
	)

◆ GenerateRectangularWindow()

SIGNALPROCESSING_API void Audio::GenerateRectangularWindow	(	float *	WindowBuffer,
		int32	NumFrames,
		int32	NumChannels
	)

◆ GenerateWindow()

SIGNALPROCESSING_API void Audio::GenerateWindow	(	float *	InOutWindowBuffer,
		EWindowType	InType,
		int32	InNumFrames,
		int32	InNumChannels,
		bool	bIsPeriodic
	)

◆ GetAnalyzerFactory()

IAnalyzerFactory * Audio::GetAnalyzerFactory ( FName InFactoryName )

◆ GetAnalyzerNRTFactory()

IAnalyzerNRTFactory * Audio::GetAnalyzerNRTFactory ( FName InFactoryName )

◆ GetBandwidthFromQ()

float Audio::GetBandwidthFromQ ( const float InQ )

inline

◆ GetBipolar()

float Audio::GetBipolar ( const float X )

inline

◆ GetCloudStreamingFormatOverride()

FName Audio::GetCloudStreamingFormatOverride	(	const FName &	InCurrentFormat,
		const USoundWave *	InWave
	)

◆ GetCOLAHopSizeForWindow()

SIGNALPROCESSING_API uint32 Audio::GetCOLAHopSizeForWindow	(	EWindowType	InType,
		uint32	WindowLength
	)

◆ GetCommandBufferInitialCapacity()

int32 Audio::GetCommandBufferInitialCapacity ( )

◆ GetDefaultModulationParameter()

AUDIOEXTENSIONS_API const FModulationParameter & Audio::GetDefaultModulationParameter ( )

◆ GetFrequencyFromMidi()

float Audio::GetFrequencyFromMidi ( const float InMidiNote )

inline

◆ GetFrequencyMultiplier()

float Audio::GetFrequencyMultiplier ( const float InPitchSemitones )

inline

◆ GetGainFromVelocity()

float Audio::GetGainFromVelocity ( const float InVelocity )

inline

◆ GetLinearFrequencyClamped()

float Audio::GetLinearFrequencyClamped	(	const float	InFrequencyValue,
		const FVector2D &	Domain,
		const FVector2D &	Range
	)

inline

◆ GetLogFrequencyClamped()

float Audio::GetLogFrequencyClamped	(	const float	InValue,
		const FVector2D &	Domain,
		const FVector2D &	Range
	)

inline

◆ GetMidiFromFrequency()

float Audio::GetMidiFromFrequency ( const float InFrequency )

inline

◆ GetModulationParameter()

AUDIOEXTENSIONS_API const FModulationParameter & Audio::GetModulationParameter ( FName InName )

◆ GetModulationParameterPtr()

AUDIOEXTENSIONS_API const FModulationParameter * Audio::GetModulationParameterPtr ( FName InName )

◆ GetMultichannelBufferNumFrames() [1/3]

SIGNALPROCESSING_API int32 Audio::GetMultichannelBufferNumFrames ( const FMultichannelBuffer & InBuffer )

Return the number of frames in the buffer. It is expected that each channel contains the same number of frames.

◆ GetMultichannelBufferNumFrames() [2/3]

SIGNALPROCESSING_API int32 Audio::GetMultichannelBufferNumFrames ( const FMultichannelBufferView & InBuffer )

Return the number of frames in the buffer. It is expected that each channel contains the same number of frames.

◆ GetMultichannelBufferNumFrames() [3/3]

SIGNALPROCESSING_API int32 Audio::GetMultichannelBufferNumFrames ( const FMultichannelCircularBuffer & InBuffer )

Return the number of frames in the buffer. It is expected that each channel contains the same number of frames.

◆ GetOutputBufferSize()

AUDIOPLATFORMCONFIGURATION_API int32 Audio::GetOutputBufferSize ( const FResamplingParameters & InParameters )

◆ GetPitchScaleFromMIDINote()

float Audio::GetPitchScaleFromMIDINote	(	int32	BaseMidiNote,
		int32	TargetMidiNote
	)

inline

◆ GetPowerSpectrumScaling()

SIGNALPROCESSING_API float Audio::GetPowerSpectrumScaling	(	int32	FFTSize,
		EFFTScaling	InCurrentScaling,
		EFFTScaling	InTargetScaling
	)

◆ GetQFromBandwidth()

float Audio::GetQFromBandwidth ( const float InBandwidth )

inline

◆ GetSemitones()

float Audio::GetSemitones ( const float InMultiplier )

inline

◆ GetStereoPan()

void Audio::GetStereoPan	(	const float	InLinearPan,
		float &	OutLeft,
		float &	OutRight
	)

inline

◆ GetTransmitterID()

ENGINE_API uint64 Audio::GetTransmitterID	(	uint64	ComponentID,
		UPTRINT	WaveInstanceHash,
		uint32	PlayOrder
	)

Creates an ID for use by Parameter Transmitters that can differentiate between multiple voices playing on the same Audio Component.

◆ GetUnipolar()

float Audio::GetUnipolar ( const float X )

inline

◆ HzToMel()

SIGNALPROCESSING_API float Audio::HzToMel ( float InHz )

Convert a frequency in hz to a mel frequency.

◆ IncrementIOSAudioMixerPlatformSuspendCounter()

void AUDIOMIXERAUDIOUNIT_API Audio::IncrementIOSAudioMixerPlatformSuspendCounter ( )

◆ IsAudioBufferSilent()

bool Audio::IsAudioBufferSilent	(	const float *	AudioBuffer,
		const int32	NumSamples
	)

◆ IsHostLittleEndian()

SIGNALPROCESSING_API constexpr bool Audio::IsHostLittleEndian ( )

constexpr

Returns true if host has little endian byte ordering

◆ IsModulationParameterRegistered()

AUDIOEXTENSIONS_API bool Audio::IsModulationParameterRegistered ( FName InName )

◆ KickQueuedTasks()

int Audio::KickQueuedTasks ( AudioTaskQueueId QueueId )

◆ LagrangianInterpolation()

float Audio::LagrangianInterpolation	(	const TArray< FVector2D >	Points,
		const float	Alpha
	)

inline

◆ MakeMultichannelBufferView() [1/2]

SIGNALPROCESSING_API FMultichannelBufferView Audio::MakeMultichannelBufferView ( FMultichannelBuffer & InBuffer )

Creates a FMultichannelBufferView from a FMultichannelBuffer.

◆ MakeMultichannelBufferView() [2/2]

SIGNALPROCESSING_API FMultichannelBufferView Audio::MakeMultichannelBufferView	(	FMultichannelBuffer &	InBuffer,
		int32	InStartFrameIndex,
		int32	InNumFrames
	)

Creates a FMultichannelBufferView from a FMultichannelBuffer.

◆ MakeMultiMonoPointersFromView()

template<typename T >

TStackArrayOfPointers< T > Audio::MakeMultiMonoPointersFromView	(	TArrayView< T >	InMultiMono,
		const int32	InNumFrames,
		const int32	InNumChannels
	)

◆ MatchesLogFilter() [1/2]

bool Audio::MatchesLogFilter ( const FName & InName )

inline

◆ MatchesLogFilter() [2/2]

ENGINE_API bool Audio::MatchesLogFilter ( const TCHAR * InName )

◆ MelToHz()

SIGNALPROCESSING_API float Audio::MelToHz ( float InMel )

Convert a mel frequency to a frequency in hz.

◆ Mix2ChannelsTo2ChannelsFast() [1/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo2ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 2 channel buffer and mixes it to an 2 channel interleaved buffer using Gains. Gains is expected to point to a 16 float long buffer. Output gains for the left input channel should be the first 8 values in Gains, and Output gains for the right input channel should be rest. NumFrames must be a multiple of 4. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ Mix2ChannelsTo2ChannelsFast() [2/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo2ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Mix2ChannelsTo2ChannelsFast() [3/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo2ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain1 | g0 | g1 | g0 | g1 | | | * | * | * | * | | Input1 | i0 | i0 | i2 | i2 | | | + | + | + | + | | Gain2 | g2 | g3 | g2 | g3 | | | * | * | * | * | | Input2 | i1 | i1 | i3 | i3 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ Mix2ChannelsTo2ChannelsFast() [4/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo2ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain1 | g0 | g1 | g0 | g1 | | | * | * | * | * | | Input1 | i0 | i0 | i2 | i2 | | | + | + | + | + | | Gain2 | g2 | g3 | g2 | g3 | | | * | * | * | * | | Input2 | i1 | i1 | i3 | i3 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ Mix2ChannelsTo4ChannelsFast() [1/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo4ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 2 channel buffer and mixes it to an 8 channel interleaved buffer using Gains. Gains is expected to point to a 16 float long buffer. Output gains for the left input channel should be the first 8 values in Gains, and Output gains for the right input channel should be rest. NumFrames must be a multiple of 4. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ Mix2ChannelsTo4ChannelsFast() [2/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo4ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Mix2ChannelsTo4ChannelsFast() [3/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo4ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frame per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain1 | g0 | g1 | g2 | g3 | | | * | * | * | * | | Input1 | i0 | i0 | i0 | i0 | | | + | + | + | + | | Gain2 | g4 | g5 | g6 | g7 | | | * | * | * | * | | Input2 | i1 | i1 | i1 | i1 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ Mix2ChannelsTo4ChannelsFast() [4/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo4ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frame per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain1 | g0 | g1 | g2 | g3 | | | * | * | * | * | | Input1 | i0 | i0 | i0 | i0 | | | + | + | + | + | | Gain2 | g4 | g5 | g6 | g7 | | | * | * | * | * | | Input2 | i1 | i1 | i1 | i1 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ Mix2ChannelsTo6ChannelsFast() [1/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo6ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 2 channel buffer and mixes it to an 8 channel interleaved buffer using Gains. Gains is expected to point to a 16 float long buffer. Output gains for the left input channel should be the first 8 values in Gains, and Output gains for the right input channel should be rest. NumFrames must be a multiple of 4. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ Mix2ChannelsTo6ChannelsFast() [2/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo6ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Mix2ChannelsTo6ChannelsFast() [3/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo6ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 | | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 | | | * | * | * | * | * | * | * | * | * | * | * | * | | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i2 | i2 | i2 | i2 | i2 | i2 | | | + | + | + | + | + | + | + | + | + | + | + | + | | Gain2 | g6 | g7 | g8 | g9 | g10 | g11 | g6 | g7 | g8 | g9 | g10 | g11 | | | * | * | * | * | * | * | * | * | * | * | * | * | | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | i3 | i3 | i3 | i3 | i3 | | | = | = | = | = | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+

◆ Mix2ChannelsTo6ChannelsFast() [4/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo6ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 | | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 | | | * | * | * | * | * | * | * | * | * | * | * | * | | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i2 | i2 | i2 | i2 | i2 | i2 | | | + | + | + | + | + | + | + | + | + | + | + | + | | Gain2 | g6 | g7 | g8 | g9 | g10 | g11 | g6 | g7 | g8 | g9 | g10 | g11 | | | * | * | * | * | * | * | * | * | * | * | * | * | | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i3 | i3 | i3 | i3 | i3 | i3 | | | = | = | = | = | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+

◆ Mix2ChannelsTo8ChannelsFast() [1/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo8ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 2 channel buffer and mixes it to an 8 channel interleaved buffer using Gains. Gains is expected to point to a 16 float long buffer. Output gains for the left input channel should be the first 8 values in Gains, and Output gains for the right input channel should be rest. these buffers must have an even number of frames. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ Mix2ChannelsTo8ChannelsFast() [2/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo8ChannelsFast	(	const FAlignedFloatBuffer &	SourceBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ Mix2ChannelsTo8ChannelsFast() [3/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo8ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frames per iteration: +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+ | | Vector 1 | | | | Vector 2 | | | | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+ | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 | | | * | * | * | * | * | * | * | * | | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | | | + | + | + | + | + | + | + | + | | Gain2 | g8 | g9 | g10 | g11 | g12 | g13 | g14 | g5 | | | * | * | * | * | * | * | * | * | | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | | | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+

◆ Mix2ChannelsTo8ChannelsFast() [4/4]

SIGNALPROCESSING_API void Audio::Mix2ChannelsTo8ChannelsFast	(	const float *RESTRICT	SourceBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frames per iteration: +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+ | | Vector 1 | | | | Vector 2 | | | | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+ | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 | | | * | * | * | * | * | * | * | * | | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | | | + | + | + | + | + | + | + | + | | Gain2 | g8 | g9 | g10 | g11 | g12 | g13 | g14 | g15 | | | * | * | * | * | * | * | * | * | | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | | | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | +-----—+-------—+------—+------—+------—+-------—+------—+------—+------—+

◆ MixMonoTo2ChannelsFast() [1/6]

SIGNALPROCESSING_API void Audio::MixMonoTo2ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer
	)

◆ MixMonoTo2ChannelsFast() [2/6]

SIGNALPROCESSING_API void Audio::MixMonoTo2ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 1 channel buffer and mixes it to a stereo buffer using Gains. Gains is expected to point to a 2 float long buffer. these buffers must have an even number of frames. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ MixMonoTo2ChannelsFast() [3/6]

SIGNALPROCESSING_API void Audio::MixMonoTo2ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ MixMonoTo2ChannelsFast() [4/6]

SIGNALPROCESSING_API void Audio::MixMonoTo2ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	InNumFrames
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Input | i0 | i0 | i1 | i1 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ MixMonoTo2ChannelsFast() [5/6]

SIGNALPROCESSING_API void Audio::MixMonoTo2ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain | g0 | g1 | g0 | g1 | | | * | * | * | * | | Input | i0 | i0 | i0 | i0 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ MixMonoTo2ChannelsFast() [6/6]

SIGNALPROCESSING_API void Audio::MixMonoTo2ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain | g0 | g1 | g0 | g1 | | | * | * | * | * | | Input | i0 | i0 | i1 | i1 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ MixMonoTo4ChannelsFast() [1/4]

SIGNALPROCESSING_API void Audio::MixMonoTo4ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 1 channel buffer and mixes it to an 8 channel interleaved buffer using Gains. Gains is expected to point to a 8 float long buffer. these buffers must have an even number of frames. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ MixMonoTo4ChannelsFast() [2/4]

SIGNALPROCESSING_API void Audio::MixMonoTo4ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ MixMonoTo4ChannelsFast() [3/4]

SIGNALPROCESSING_API void Audio::MixMonoTo4ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frame per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain | g0 | g1 | g2 | g3 | | | * | * | * | * | | Input | i0 | i0 | i0 | i0 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ MixMonoTo4ChannelsFast() [4/4]

SIGNALPROCESSING_API void Audio::MixMonoTo4ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frame per iteration: +---------—+------—+------—+------—+------—+ | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | +---------—+------—+------—+------—+------—+ | Gain | g0 | g1 | g2 | g3 | | | * | * | * | * | | Input | i0 | i0 | i0 | i0 | | | = | = | = | = | | Output | o0 | o1 | o2 | o3 | +---------—+------—+------—+------—+------—+

◆ MixMonoTo6ChannelsFast() [1/4]

SIGNALPROCESSING_API void Audio::MixMonoTo6ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 1 channel buffer and mixes it to an 8 channel interleaved buffer using Gains. Gains is expected to point to a 8 float long buffer. these buffers must have an even number of frames. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ MixMonoTo6ChannelsFast() [2/4]

SIGNALPROCESSING_API void Audio::MixMonoTo6ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ MixMonoTo6ChannelsFast() [3/4]

SIGNALPROCESSING_API void Audio::MixMonoTo6ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | | +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 | | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 | | | * | * | * | * | * | * | * | * | * | * | * | * | | Input | i0 | i0 | i0 | i0 | i0 | i0 | i1 | i1 | i1 | i1 | i1 | i1 | | | = | = | = | = | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 | +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+

◆ MixMonoTo6ChannelsFast() [4/4]

SIGNALPROCESSING_API void Audio::MixMonoTo6ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 2 frames per iteration: +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | | +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+ | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 | | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 | | | * | * | * | * | * | * | * | * | * | * | * | * | | Input | i0 | i0 | i0 | i0 | i0 | i0 | i1 | i1 | i1 | i1 | i1 | i1 | | | = | = | = | = | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 | +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+-------—+------—+-------—+-------—+

◆ MixMonoTo8ChannelsFast() [1/4]

SIGNALPROCESSING_API void Audio::MixMonoTo8ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	Gains
	)

Takes a 1 channel buffer and mixes it to an 8 channel interleaved buffer using Gains. Gains is expected to point to a 8 float long buffer. these buffers must have an even number of frames. If StartGains and EndGains are provided, this function will interpolate between the two across the buffer.

◆ MixMonoTo8ChannelsFast() [2/4]

SIGNALPROCESSING_API void Audio::MixMonoTo8ChannelsFast	(	const FAlignedFloatBuffer &	MonoBuffer,
		FAlignedFloatBuffer &	DestinationBuffer,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

◆ MixMonoTo8ChannelsFast() [3/4]

SIGNALPROCESSING_API void Audio::MixMonoTo8ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	Gains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frames per iteration: +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+ | | Vector 1 | | | | Vector 2 | | | | | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 | | | * | * | * | * | * | * | * | * | | Input | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | | | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+

◆ MixMonoTo8ChannelsFast() [4/4]

SIGNALPROCESSING_API void Audio::MixMonoTo8ChannelsFast	(	const float *RESTRICT	MonoBuffer,
		float *RESTRICT	DestinationBuffer,
		int32	NumFrames,
		const float *RESTRICT	StartGains,
		const float *RESTRICT	EndGains
	)

See CHANNEL MIXING OPERATIONS above for more info. 1 frames per iteration: +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+ | | Vector 1 | | | | Vector 2 | | | | | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 | | | * | * | * | * | * | * | * | * | | Input | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | | | = | = | = | = | = | = | = | = | | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | +---------—+-------—+------—+------—+------—+-------—+------—+------—+------—+

◆ MultiMonoMixUpOrDown() [1/2]

SIGNALPROCESSING_API void Audio::MultiMonoMixUpOrDown	(	TArrayView< const float * >	InSrc,
		TArrayView< float * >	InDst,
		const int32	NumFrames,
		TArrayView< const float >	MixGains
	)

◆ MultiMonoMixUpOrDown() [2/2]

SIGNALPROCESSING_API void Audio::MultiMonoMixUpOrDown	(	TArrayView< const float >	InSrc,
		const TArrayView< float >	InDst,
		const int32	NumFrames,
		TArrayView< const float >	MixGains,
		const int32	NumSrcChannels,
		const int32	NumDstChannels
	)

Given a Matrix of Gains (produced by calling ChannelMap.cpp (Audio::Create2DChannelMap), Mix Up/Down Source into Destination.

Parameters

InSrc	ArrayView to Source (Multi-mono)
InDst	ArrayView to Destination (Mult-mono).
NumFrames	Number of Frames in Each Channel.
MixGains	Matrix of Gains (in Row Major Format, see Create2DChannelMap). [NumDstChannels*NumSrcChannels]
NumDstChannels	Num Of Destination Channels.
NumSrcChannels	Num Of Source Channels.

◆ NAME_ADPCM()

FName Audio::NAME_ADPCM ( TEXT("ADPCM") )

inline

◆ NAME_BINKA()

FName Audio::NAME_BINKA ( TEXT("BINKA") )

inline

◆ NAME_OGG()

FName Audio::NAME_OGG ( TEXT("OGG") )

inline

◆ NAME_OPUS()

FName Audio::NAME_OPUS ( TEXT("OPUS") )

inline

◆ NAME_PCM()

FName Audio::NAME_PCM ( TEXT("PCM") )

inline

◆ NAME_PLATFORM_SPECIFIC()

FName Audio::NAME_PLATFORM_SPECIFIC ( TEXT("PLATFORM_SPECIFIC") )

inline

◆ NAME_PROJECT_DEFINED()

FName Audio::NAME_PROJECT_DEFINED ( TEXT("PROJECT_DEFINED") )

inline

◆ NAME_RADA()

FName Audio::NAME_RADA ( TEXT("RADA") )

inline

◆ NewMelSpectrumKernelTransform()

SIGNALPROCESSING_API TUniquePtr< FContiguousSparse2DKernelTransform > Audio::NewMelSpectrumKernelTransform	(	const FMelSpectrumKernelSettings &	InSettings,
		const int32	InFFTSize,
		const float	InSampleRate
	)

◆ NewPseudoConstantQKernelTransform()

SIGNALPROCESSING_API TUniquePtr< FContiguousSparse2DKernelTransform > Audio::NewPseudoConstantQKernelTransform	(	const FPseudoConstantQKernelSettings &	InSettings,
		const int32	InFFTSize,
		const float	InSampleRate
	)

NewPseudoConstantQKernelTransform

This creates a new Pseudo Constant Q Kernel Transform. Pseudo Constant Q differs from standard Constant Q in that it applies a window to an existing DFT output as opposed to using a bank of filters. The use of an FFT speeds up the calculation but introduces some limitations in bandwidth due to the granularity of the DFT.

The resulting kernel will transform an array with (InFFTSize / 2 + 1) elements into an array with InSettings.NumBands elements.

InSettings controls the number of bands and band properties. InFFTSize controls the expected input size to the kernel. InSampleRate describes the sampling rate of the analyzed audio.

Returns a TUniquePtr to a FContiguousSparse2DKernelTransform.

◆ operator&()

ECheckBufferFlags Audio::operator&	(	const ECheckBufferFlags	A,
		const ECheckBufferFlags	B
	)

inline

◆ operator|()

ECheckBufferFlags Audio::operator\|	(	const ECheckBufferFlags	A,
		const ECheckBufferFlags	B
	)

inline

◆ operator|=()

ECheckBufferFlags & Audio::operator\|=	(	ECheckBufferFlags &	Out,
		const ECheckBufferFlags	Other
	)

inline

◆ PerlinValueNoise1D()

SIGNALPROCESSING_API float Audio::PerlinValueNoise1D	(	const float	InX,
		const int32	InNumOctaves
	)

PerlinValueNoise1D. Computes 1 sample of "value" noise using the Perlin 1D function with N octaves. Each "Octave" is a new layer and comes from the doubling of frequencies (through the noise), hence octave. The higher frequencies have less amplitude, creating higher "detail".

Parameters

InX	The input "X" Value to hash into Perlin noise space. Time or an "X" coordinate (in the case of 1d) is often used.
InNumOctaves	The number of octaves (layers) to compute. Each octave has higher frequency and less amplitude. Value needs to be > 0.

◆ PerlinValueNoise1DBuffer()

SIGNALPROCESSING_API void Audio::PerlinValueNoise1DBuffer	(	TArrayView< const float >	InXBuffer,
		const float	InOffset,
		const int32	InNumOctaves,
		TArrayView< float >	OutNoiseBuffer
	)

PerlinValueNoise1DBuffer. Whole buffer version of Value noise.

Parameters

InXBuffer	Buffer to compute value noise on.
InOffset	Offset each value is offset by. This is normally used to give different results when using multiple calls with the same input.
InNumOctaves	The number of octaves (layers) to compute. Each octave has higher frequency and less amplitude.
OutNoiseBuffer	Buffer to write the noise too. Should be as big as the input buffer.

◆ QuadraticPeakInterpolation()

bool Audio::QuadraticPeakInterpolation	(	const float	InValues[3],
		float &	OutPeakLoc,
		float &	OutPeakValue
	)

inline

◆ RegisterModulationParameter()

AUDIOEXTENSIONS_API void Audio::RegisterModulationParameter	(	FName	InName,
		FModulationParameter &&	InParameter
	)

◆ Resample()

AUDIOPLATFORMCONFIGURATION_API bool Audio::Resample	(	const FResamplingParameters &	InParameters,
		FResamplerResults &	OutData
	)

◆ ScalePowerSpectrumInPlace()

SIGNALPROCESSING_API void Audio::ScalePowerSpectrumInPlace	(	int32	FFTSize,
		EFFTScaling	InCurrentScaling,
		EFFTScaling	InTargetScaling,
		TArrayView< float >	InPowerSpectrum
	)

◆ SetMultichannelBufferSize() [1/2]

SIGNALPROCESSING_API void Audio::SetMultichannelBufferSize	(	int32	InNumChannels,
		int32	InNumFrames,
		FMultichannelBuffer &	OutBuffer
	)

Set the number of channels and frames for a multichannel buffer.

Parameters

InNumChannels	- Number of channels to hold in the buffer.
InNumFrames	- Number of frames to hold in the buffer.
OutBuffer	- Buffer to resize.

◆ SetMultichannelBufferSize() [2/2]

SIGNALPROCESSING_API void Audio::SetMultichannelBufferSize	(	int32	InNumFrames,
		FMultichannelBuffer &	OutBuffer
	)

Set the number of frames for a multichannel buffer.

Parameters

InNumFrames	- Number of frames to hold in the buffer.
OutBuffer	- Buffer to resize.

◆ SetMultichannelCircularBufferCapacity()

SIGNALPROCESSING_API void Audio::SetMultichannelCircularBufferCapacity	(	int32	InNumChannels,
		int32	InNumFrames,
		FMultichannelCircularBuffer &	OutBuffer
	)

Set the number of channels and capacity for a multichannel circular buffer.

Parameters

InNumChannels	- Number of channels to hold in the buffer.
InNumFrames	- Maximum number of frames the buffer can hold.
OutBuffer	- Buffer to resize.

◆ ShiftMultichannelBufferView()

SIGNALPROCESSING_API void Audio::ShiftMultichannelBufferView	(	int32	InNumFrames,
		FMultichannelBufferView &	View
	)

Shift the start frame of a multichannel buffer view to a given number of frames.

◆ ShortEnumString()

const TCHAR * Audio::ShortEnumString ( const TCHAR * InString )

inline

◆ SliceMultichannelBufferView()

SIGNALPROCESSING_API FMultichannelBufferView Audio::SliceMultichannelBufferView	(	const FMultichannelBufferView &	View,
		int32	InStartFrameIndex,
		int32	InNumFrames
	)

Slice a multichannel buffer view to a given frame range.

◆ SoundFileIOManagerInit()

bool Audio::SoundFileIOManagerInit ( )

◆ SoundFileIOManagerShutdown()

bool Audio::SoundFileIOManagerShutdown ( )

◆ ToDelimitedString()

FString Audio::ToDelimitedString ( const ECheckBufferFlags InEnum )

◆ ToErrorFString()

FString Audio::ToErrorFString ( HRESULT InResult )

◆ ToFString() [1/2]

WINDOWSMMDEVICEENUMERATION_API FString Audio::ToFString ( const PROPERTYKEY InKey )

◆ ToFString() [2/2]

WINDOWSMMDEVICEENUMERATION_API FString Audio::ToFString ( const TArray< EAudioMixerChannel::Type > & InChannels )

◆ ToName()

FName Audio::ToName ( ESoundAssetCompressionType InDecoderType )

inline

◆ ToSoundAssetCompressionType()

ESoundAssetCompressionType Audio::ToSoundAssetCompressionType ( EDefaultAudioCompressionType InDefaultCompressionType )

inline

◆ ToString() [1/5]

WINDOWSMMDEVICEENUMERATION_API const TCHAR * Audio::ToString ( AudioSessionDisconnectReason InDisconnectReason )

NO_LOGGING

◆ ToString() [2/5]

WINDOWSMMDEVICEENUMERATION_API const TCHAR * Audio::ToString ( EAudioDeviceRole InRole )

◆ ToString() [3/5]

WINDOWSMMDEVICEENUMERATION_API const TCHAR * Audio::ToString ( EAudioDeviceState InState )

◆ ToString() [4/5]

WINDOWSMMDEVICEENUMERATION_API const TCHAR * Audio::ToString ( EDataFlow InFlow )

NO_LOGGING

◆ ToString() [5/5]

WINDOWSMMDEVICEENUMERATION_API const TCHAR * Audio::ToString ( ERole InRole )

NO_LOGGING

◆ UE_DEPRECATED() [1/4]

class AUDIOCAPTURERTAUDIO_API Audio::UE_DEPRECATED	(	5.	3,
		"FRtAudioInputWrapper is	deprecated,
		please use FAudioCapture instead."
	)

◆ UE_DEPRECATED() [2/4]

class Audio::UE_DEPRECATED	(	5.	5,
		"Audio::FBiquad is deprecated in favor of Audio::FBiquadFilter due to performance issues"
	)

◆ UE_DEPRECATED() [3/4]

template<class ListenerType >

class Audio::UE_DEPRECATED	(	5.	5,
		"Message"
	)

◆ UE_DEPRECATED() [4/4]

struct Audio::UE_DEPRECATED	(	5.	5,
		"This has moved to the UE::MathCore::Graph namespace"
	)

A strongly connected component contains a subgraph of strongly connected vertices and their corresponding edges.

Vertices in the strongly connected component.

Edges in the strongly connected component.

◆ UnderflowClamp()

float Audio::UnderflowClamp ( const float InValue )

inline

◆ UnregisterAllModulationParameters()

AUDIOEXTENSIONS_API void Audio::UnregisterAllModulationParameters ( )

◆ UnregisterModulationParameter()

AUDIOEXTENSIONS_API bool Audio::UnregisterModulationParameter ( FName InName )

Variable Documentation

◆ AudioMixerTaskCounter

FThreadSafeCounter Audio::AudioMixerTaskCounter

◆ CVarDirectProceduralRendering

FAutoConsoleVariableRef Audio::CVarDirectProceduralRendering(TEXT("au.DirectProceduralRendering"), DirectProceduralRenderingCVar, TEXT("0: Disabled, 1: Enabled"), ECVF_Default)	(	TEXT("au.DirectProceduralRendering")	,
		DirectProceduralRenderingCVar	,
		TEXT("0: Disabled, 1: Enabled")	,
		ECVF_Default
	)

◆ DefaultDeviceEncoding

constexpr EPCMAudioEncoding Audio::DefaultDeviceEncoding = EPCMAudioEncoding::FLOATING_POINT_32

constexpr

◆ DefaultDeviceIndex

constexpr int32 Audio::DefaultDeviceIndex = INDEX_NONE

constexpr

◆ DirectProceduralRenderingCVar

int32 Audio::DirectProceduralRenderingCVar = 1

◆ FDirectedTree

PRAGMA_DISABLE_DEPRECATION_WARNINGS typedef TMap<int32, FDirectedTreeElement> Audio::FDirectedTree

A directed tree graph represenation.

◆ InvalidDeviceChannelCount

constexpr int32 Audio::InvalidDeviceChannelCount = -1

constexpr

◆ InvalidDeviceSampleRate

constexpr int32 Audio::InvalidDeviceSampleRate = -1

constexpr

◆ MaxStackMultiMonoChannels

constexpr int32 Audio::MaxStackMultiMonoChannels = 128

constexpr

◆ MonoUpmixEqualPower

constexpr float Audio::MonoUpmixEqualPower = 0.707f

inlineconstexpr

◆ MonoUpmixFullVolume

constexpr float Audio::MonoUpmixFullVolume = 1.0f

inlineconstexpr

◆ MonoUpmixLinear

constexpr float Audio::MonoUpmixLinear = 0.5f

inlineconstexpr

◆ SmallBlockSize

constexpr int32 Audio::SmallBlockSize = 64

constexpr

◆ SmallBlockSizeBitCheck

constexpr int32 Audio::SmallBlockSizeBitCheck = (1 << 6) - 1

constexpr

◆ SoundFileClose

SoundFileCloseFuncPtr Audio::SoundFileClose = nullptr

◆ SoundFileCommand

SoundFileCommandFuncPtr Audio::SoundFileCommand = nullptr

◆ SoundFileDllHandle

void* Audio::SoundFileDllHandle

◆ SoundFileError

SoundFileErrorFuncPtr Audio::SoundFileError = nullptr

◆ SoundFileErrorNumber

SoundFileErrorNumberFuncPtr Audio::SoundFileErrorNumber = nullptr

◆ SoundFileFormatCheck

SoundFileFormatCheckFuncPtr Audio::SoundFileFormatCheck = nullptr

◆ SoundFileGetChunkData

SoundFileGetChunkDataFuncPtr Audio::SoundFileGetChunkData = nullptr

◆ SoundFileGetChunkIterator

SoundFileGetChunkIteratorFuncPtr Audio::SoundFileGetChunkIterator = nullptr

◆ SoundFileGetChunkSize

SoundFileGetChunkSizeFuncPtr Audio::SoundFileGetChunkSize = nullptr

◆ SoundFileGetVersion

SoundFileGetVersionFuncPtr Audio::SoundFileGetVersion = nullptr

◆ SoundFileNextChunkIterator

SoundFileNextChunkIteratorFuncPtr Audio::SoundFileNextChunkIterator = nullptr

◆ SoundFileOpen

SoundFileOpenFuncPtr Audio::SoundFileOpen = nullptr

◆ SoundFileOpenVirtual

SoundFileOpenVirtualFuncPtr Audio::SoundFileOpenVirtual = nullptr

◆ SoundFileReadFramesDouble

SoundFileReadFramesDoubleFuncPtr Audio::SoundFileReadFramesDouble = nullptr

◆ SoundFileReadFramesFloat

SoundFileReadFramesFloatFuncPtr Audio::SoundFileReadFramesFloat = nullptr

◆ SoundFileReadSamplesDouble

SoundFileReadSamplesDoubleFuncPtr Audio::SoundFileReadSamplesDouble = nullptr

◆ SoundFileReadSamplesFloat

SoundFileReadSamplesFloatFuncPtr Audio::SoundFileReadSamplesFloat = nullptr

◆ SoundFileSeek

SoundFileSeekFuncPtr Audio::SoundFileSeek = nullptr

◆ SoundFileSetChunk

SoundFileSetChunkFuncPtr Audio::SoundFileSetChunk = nullptr

◆ SoundFileStrError

SoundFileStrErrorFuncPtr Audio::SoundFileStrError = nullptr

◆ SoundFileWriteFramesDouble

SoundFileWriteFramesDoubleFuncPtr Audio::SoundFileWriteFramesDouble = nullptr

◆ SoundFileWriteFramesFloat

SoundFileWriteFramesFloatFuncPtr Audio::SoundFileWriteFramesFloat = nullptr

◆ SoundFileWriteSamplesDouble

SoundFileWriteSamplesDoubleFuncPtr Audio::SoundFileWriteSamplesDouble = nullptr

◆ SoundFileWriteSamplesFloat

SoundFileWriteSamplesFloatFuncPtr Audio::SoundFileWriteSamplesFloat = nullptr

◆ sRenderInstanceIds

int32 Audio::sRenderInstanceIds = 0

◆ WasapiWinNotificationClient

TSharedPtr<FWindowsMMNotificationClient> Audio::WasapiWinNotificationClient

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AlignedByteBuffer

◆ AlignedFloatBuffer

◆ AlignedInt32Buffer

◆ AudioTaskQueueId

◆ DefaultUSoundWaveSampleType

◆ DeviceID

◆ FAlignedByteBuffer

◆ FAlignedFloatBuffer

◆ FAlignedInt32Buffer

◆ FAsyncSoundWavePCMWriterTask

◆ FAudioBufferAlignedAllocator

◆ FAudioMixerPlatformSDL

◆ FDecodingSoundSourcePtr

◆ FDeviceId

◆ FDeviceInfo

◆ FDirectedEdge

◆ FDirectedTreeElement

◆ FMixerSourceBufferPtr

◆ FMixerSubmixPtr

◆ FMixerSubmixWeakPtr

◆ FModulationMixFunction

◆ FModulationNormalizedConversionFunction

◆ FModulationUnitConversionFunction

◆ FModulatorHandleId

◆ FModulatorId

◆ FModulatorTypeId

◆ FMultichannelBuffer

◆ FMultichannelBufferView

◆ FMultichannelCircularBuffer

◆ FOnAudioCaptureFunction

◆ FOnCaptureFunction

◆ FParameterInterfacePtr

◆ FPatchOutputStrongPtr

◆ FPatchOutputWeakPtr

◆ FQuartzClockCommandQueuePtr

◆ FQuartzClockCommandQueueType

◆ FQuartzClockCommandQueueWeakPtr

◆ FSampleBuffer

◆ FSoundFileChunkArray

◆ FSoundHandleID

◆ FSpectrumAnalyzerTask

◆ FTransformationPtr

◆ FWasapiOnAudioCaptureFunction

◆ LibSoundFileChunkIterator

◆ LibSoundFileHandle

◆ MetronomeCommandQueuePtr

◆ SoundFileCloseFuncPtr

◆ SoundFileCommandFuncPtr

◆ SoundFileCount

◆ SoundFileErrorFuncPtr

◆ SoundFileErrorNumberFuncPtr

◆ SoundFileFormatCheckFuncPtr

◆ SoundFileGetChunkDataFuncPtr

◆ SoundFileGetChunkIteratorFuncPtr

◆ SoundFileGetChunkSizeFuncPtr

◆ SoundFileGetVersionFuncPtr

◆ SoundFileNextChunkIteratorFuncPtr

◆ SoundFileOpenFuncPtr

◆ SoundFileOpenVirtualFuncPtr

◆ SoundFileReadFramesDoubleFuncPtr

◆ SoundFileReadFramesFloatFuncPtr

◆ SoundFileReadSamplesDoubleFuncPtr

◆ SoundFileReadSamplesFloatFuncPtr

◆ SoundFileSeekFuncPtr

◆ SoundFileSetChunkFuncPtr

◆ SoundFileStrErrorFuncPtr

◆ SoundFileWriteFramesDoubleFuncPtr

◆ SoundFileWriteFramesFloatFuncPtr

◆ SoundFileWriteSamplesDoubleFuncPtr

◆ SoundFileWriteSamplesFloatFuncPtr

◆ TStackArrayOfPointers

◆ VirtualSoundFileGetLengthFuncPtr