AudioDevice.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AudioDeviceHandle.h"
#include "AudioDynamicParameter.h"
#include "AudioMixerTrace.h"
#include "AudioVirtualLoop.h"
#include "Components/AudioComponent.h"
#include "HAL/LowLevelMemStats.h"
#include "Math/Transform.h"
#include "Math/Vector.h"
#include "ProfilingDebugging/TraceAuxiliary.h"
#include "Sound/AudioVolume.h"
#include "Sound/SoundClass.h"
#include "Sound/SoundMix.h"
#include "Subsystems/AudioEngineSubsystem.h"
#include "UObject/StrongObjectPtr.h"
 
 
class FArchive;
class FAudioDevice;
class FAudioEffectsManager;
class FCanvas;
class FOutputDevice;
class FReferenceCollector;
class FSoundBuffer;
class FViewport;
class FViewportClient;
class IAudioSpatialization;
class ICompressedAudioInfo;
class ISubmixBufferListener;
class UReverbEffect;
class USoundAttenuation;
class USoundBase;
class USoundClass;
class USoundConcurrency;
class USoundEffectSourcePreset;
class USoundEffectSubmixPreset;
class USoundMix;
class USoundModulatorBase;
class USoundSubmixBase;
class USoundSourceBus;
class USoundWave;
class UWorld;
 
struct FActiveSound;
struct FAttenuationFocusData;
struct FAudioComponentParam;
struct FAudioQualitySettings;
struct FAudioVirtualLoop;
struct FSourceEffectChainEntry;
struct FSoundClassDynamicProperties;
struct FSoundClassProperties;
struct FSoundGroup;
struct FSoundParseParameters;
struct FSoundSpectrumAnalyzerDelegateSettings;
struct FSoundSpectrumAnalyzerSettings;
struct FWaveInstance;
 
namespace Audio
{
    class FPatchInput;
    struct FPatchOutput;
    typedef TSharedPtr<FPatchOutput, ESPMode::ThreadSafe> FPatchOutputStrongPtr;
}
 
namespace Audio
{
    class FAudioDebugger;
 
    ENGINE_API ICompressedAudioInfo* CreateSoundAssetDecoder(const FName& InRuntimeFormat);
 
    ENGINE_API uint64 GetTransmitterID(uint64 ComponentID, UPTRINT WaveInstanceHash, uint32 PlayOrder);
}
 
enum EDebugState
{
    // No debug sounds
    DEBUGSTATE_None,
    // No reverb sounds
    DEBUGSTATE_IsolateDryAudio,
    // Only reverb sounds
    DEBUGSTATE_IsolateReverb,
    // Force LPF on all sources
    DEBUGSTATE_TestLPF,
    // Force LPF on all sources
    DEBUGSTATE_TestHPF,
    // Bleed all sounds to the LFE speaker
    DEBUGSTATE_TestLFEBleed,
    // Disable any LPF filter effects
    DEBUGSTATE_DisableLPF,
    // Disable any LPF filter effects
    DEBUGSTATE_DisableHPF,
    // Disable any radio filter effects
    DEBUGSTATE_DisableRadio,
    DEBUGSTATE_MAX,
};
 
namespace ESoundMixState
{
    enum Type
    {
        // Waiting to fade in
        Inactive,
        // Fading in
        FadingIn,
        // Fully active
        Active,
        // Fading out
        FadingOut,
        // Time elapsed, just about to be removed
        AwaitingRemoval,
    };
 
    static const TCHAR* GetString(ESoundMixState::Type InType)
    {
        switch (InType)
        {
            case ESoundMixState::Inactive: return TEXT("Inactive");
            case ESoundMixState::FadingIn: return TEXT("FadingIn");
            case ESoundMixState::Active: return TEXT("Active");
            case ESoundMixState::FadingOut: return TEXT("FadingOut");
            case ESoundMixState::AwaitingRemoval: return TEXT("AwaitingRemoval");
            default: return TEXT("unknown");
        }
    }
}
 
namespace ESortedActiveWaveGetType
{
    enum Type
    {
        FullUpdate,
        PausedUpdate,
        QueryOnly,
    };
}
 
struct FListener
{
    FTransform Transform;
    FVector Velocity;
 
    FVector AttenuationOverride;
 
    uint32 bUseAttenuationOverride:1;
 
    struct FInteriorSettings InteriorSettings;
 
    uint32 AudioVolumeID;
 
    uint32 WorldID;
 
    int32 ListenerIndex;
 
    double InteriorStartTime;
    double InteriorEndTime;
    double ExteriorEndTime;
    double InteriorLPFEndTime;
    double ExteriorLPFEndTime;
    float InteriorVolumeInterp;
    float InteriorLPFInterp;
    float ExteriorVolumeInterp;
    float ExteriorLPFInterp;
    FAudioDevice* AudioDevice;
 
    FVector GetUp() const       { return Transform.GetUnitAxis(EAxis::Z); }
    FVector GetFront() const    { return Transform.GetUnitAxis(EAxis::Y); }
    FVector GetRight() const    { return Transform.GetUnitAxis(EAxis::X); }
 
    FVector GetPosition(bool bAllowOverride) const;
 
    float Interpolate(const double EndTime);
 
    void UpdateCurrentInteriorSettings();
 
    void ApplyInteriorSettings(uint32 AudioVolumeID, const FInteriorSettings& Settings);
 
    FListener(FAudioDevice* InAudioDevice)
        : Transform(FTransform::Identity)
        , Velocity(ForceInit)
        , AttenuationOverride(ForceInit)
        , bUseAttenuationOverride(false)
        , AudioVolumeID(0)
        , ListenerIndex(0)
        , InteriorStartTime(0.0)
        , InteriorEndTime(0.0)
        , ExteriorEndTime(0.0)
        , InteriorLPFEndTime(0.0)
        , ExteriorLPFEndTime(0.0)
        , InteriorVolumeInterp(0.f)
        , InteriorLPFInterp(0.f)
        , ExteriorVolumeInterp(0.f)
        , ExteriorLPFInterp(0.f)
        , AudioDevice(InAudioDevice)
    {
    }
 
private:
    FListener();
};
 
struct FListenerProxy
{
    FTransform Transform;
 
    FVector AttenuationOverride;
 
    uint32 bUseAttenuationOverride :1;
 
    uint32 WorldID = INDEX_NONE;
 
    FVector GetPosition(bool bAllowOverride) const;
 
    FListenerProxy()
        : bUseAttenuationOverride(false)
    {
    }
 
    FListenerProxy(const FListener& Listener)
        : Transform(Listener.Transform)
        , AttenuationOverride(Listener.AttenuationOverride)
        , bUseAttenuationOverride(Listener.bUseAttenuationOverride)
        , WorldID(Listener.WorldID)
    {
    }
};
 
struct FAudioClassInfo
{
    int32 NumResident;
    int32 SizeResident;
    int32 NumRealTime;
    int32 SizeRealTime;
 
    FAudioClassInfo()
        : NumResident(0)
        , SizeResident(0)
        , NumRealTime(0)
        , SizeRealTime(0)
    {
    }
};
 
struct FSoundMixState
{
    bool IsBaseSoundMix;
    uint32 ActiveRefCount;
    uint32 PassiveRefCount;
    double StartTime;
    double FadeInStartTime;
    double FadeInEndTime;
    double FadeOutStartTime;
    double EndTime;
    float InterpValue;
    ESoundMixState::Type CurrentState;
};
 
struct FSoundMixClassOverride
{
    FSoundClassAdjuster SoundClassAdjustor;
    FDynamicParameter VolumeOverride;
    FDynamicParameter PitchOverride;
    float FadeInTime;
    uint8 bOverrideApplied : 1;
    uint8 bOverrideChanged : 1;
    uint8 bIsClearing : 1;
    uint8 bIsCleared : 1;
 
    FSoundMixClassOverride()
        : VolumeOverride(1.0f)
        , PitchOverride(1.0f)
        , FadeInTime(0.0f)
        , bOverrideApplied(false)
        , bOverrideChanged(false)
        , bIsClearing(false)
        , bIsCleared(false)
    {
    }
};
 
typedef TMap<USoundClass*, FSoundMixClassOverride> FSoundMixClassOverrideMap;
typedef TWeakObjectPtr<UAudioComponent> FAudioComponentPtr;
 
struct FActivatedReverb
{
    FReverbSettings ReverbSettings;
    float Priority;
 
    FActivatedReverb()
        : Priority(0.f)
    {
    }
};
 
struct FAttenuationListenerData
{
    FVector ListenerToSoundDir;
    FVector::FReal AttenuationDistance;
    FVector::FReal ListenerToSoundDistance;
 
    // (AudioMixer only)
    // Non-attenuation distance for calculating surround sound speaker maps for sources w/ spread
    FVector::FReal ListenerToSoundDistanceForPanning;
 
    FTransform ListenerTransform;
    const FTransform SoundTransform;
    const FSoundAttenuationSettings* AttenuationSettings;
 
    static FAttenuationListenerData Create(const FAudioDevice& AudioDevice, int32 ListenerIndex, const FTransform& InSoundTransform, const FSoundAttenuationSettings& InAttenuationSettings);
 
private:
    FAttenuationListenerData(const FTransform& InListenerTransform, const FTransform& InSoundTransform, const FSoundAttenuationSettings& InAttenuationSettings)
        : ListenerToSoundDir(FVector::ZeroVector)
        , AttenuationDistance(0.0f)
        , ListenerToSoundDistance(0.0f)
        , ListenerToSoundDistanceForPanning(0.0f)
        , ListenerTransform(InListenerTransform)
        , SoundTransform(InSoundTransform)
        , AttenuationSettings(&InAttenuationSettings)
    {
    }
};
 
/*
* Setting for global focus scaling
*/
struct FGlobalFocusSettings
{
    float FocusAzimuthScale;
    float NonFocusAzimuthScale;
    float FocusDistanceScale;
    float NonFocusDistanceScale;
    float FocusVolumeScale;
    float NonFocusVolumeScale;
    float FocusPriorityScale;
    float NonFocusPriorityScale;
 
    FGlobalFocusSettings()
        : FocusAzimuthScale(1.0f)
        , NonFocusAzimuthScale(1.0f)
        , FocusDistanceScale(1.0f)
        , NonFocusDistanceScale(1.0f)
        , FocusVolumeScale(1.0f)
        , NonFocusVolumeScale(1.0f)
        , FocusPriorityScale(1.0f)
        , NonFocusPriorityScale(1.0f)
    {
    }
};
 
class IDeviceChangedListener
{
public:
    virtual void OnDeviceRemoved(FString DeviceID) = 0;
    virtual void OnDefaultDeviceChanged() = 0;
};
 
struct FAudioDeviceRenderInfo
{
    int32 NumFrames = 0;
};
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnAudioDevicePreRender, const FAudioDeviceRenderInfo&);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnAudioDevicePostRender, const FAudioDeviceRenderInfo&);
 
class FAudioDevice : public FExec
{
public:
 
    //Begin FExec Interface
#if UE_ALLOW_EXEC_COMMANDS
    ENGINE_API virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar = *GLog) override;
#endif
    //End FExec Interface
 
#if !UE_BUILD_SHIPPING
    ENGINE_API UAudioComponent* GetTestComponent(UWorld* InWorld);
    ENGINE_API void StopTestComponent();
 
private:
    bool HandleDumpSoundInfoCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleListWavesCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleListSoundClassesCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleShowSoundClassHierarchyCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleListSoundClassVolumesCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleListAudioComponentsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleListSoundDurationsCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleSoundTemplateInfoCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleSetBaseSoundMixCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleIsolateDryAudioCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleIsolateReverbCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleTestLPFCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleTestHPFCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleTestLFEBleedCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleDisableLPFCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleDisableHPFCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleDisableRadioCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleEnableRadioCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleResetSoundStateCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleToggleSpatializationExtensionCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleEnableHRTFForAllCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleSoloCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleClearSoloCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandlePlayAllPIEAudioCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleAudio3dVisualizeCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleAudioMemoryInfo(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleAudioSoloSoundClass(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleAudioSoloSoundWave(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleAudioSoloSoundCue(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleAudioMixerDebugSound(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleSoundClassFixup(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleAudioDebugSound(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleResetAllDynamicSoundVolumesCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleResetDynamicSoundVolumeCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleGetDynamicSoundVolumeCommand(const TCHAR* Cmd, FOutputDevice& Ar);
    bool HandleSetDynamicSoundCommand(const TCHAR* Cmd, FOutputDevice& Ar);
 
    using FToggleSoloPtr = void (Audio::FAudioDebugger::*)(FName InName, bool bExclusive);
    void HandleAudioSoloCommon(const TCHAR* Cmd, FOutputDevice& Ar, FToggleSoloPtr Funct);
 
    void ShowSoundClassHierarchy(FOutputDevice& Ar, USoundClass* SoundClass = nullptr, int32 Indent = 0) const;
 
    void GetSoundClassInfo(TMap<FName, FAudioClassInfo>& AudioClassInfos);
#endif
 
#if UE_AUDIO_PROFILERTRACE_ENABLED
    void OnTraceStarted(FTraceAuxiliary::EConnectionType TraceType, const FString& TraceDestination);
#endif // UE_AUDIO_PROFILERTRACE_ENABLED
 
public:
 
    ENGINE_API FAudioDevice();
 
    ENGINE_API virtual ~FAudioDevice();
 
    virtual void GetAudioDeviceList(TArray<FString>& OutAudioDeviceNames) const
    {
    }
 
    ENGINE_API static const FAudioQualitySettings& GetQualityLevelSettings();
 
    ENGINE_API bool Init(Audio::FDeviceId InDeviceID, int32 InMaxSources, int32 BufferSizeOverride = INDEX_NONE, int32 NumBuffersOverride = INDEX_NONE);
 
    ENGINE_API void OnDeviceCreated(Audio::FDeviceId InDeviceID);
 
    ENGINE_API void OnDeviceDestroyed(Audio::FDeviceId InDeviceID);
 
    ENGINE_API void Teardown();
 
    ENGINE_API void Deinitialize();
 
    ENGINE_API void Update(bool bGameTicking);
 
    virtual void UpdateGameThread() {}
 
    ENGINE_API void Suspend(bool bGameTicking);
 
    ENGINE_API virtual void CountBytes(FArchive& Ar);
 
    ENGINE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
    ENGINE_API int32 GetSortedActiveWaveInstances(TArray<FWaveInstance*>& WaveInstances, const ESortedActiveWaveGetType::Type GetType);
 
    ENGINE_API void UpdateActiveSoundPlaybackTime(bool bIsTimeTicking);
 
    virtual void FadeOut() {}
    virtual void FadeIn() {}
 
    ENGINE_API void Flush(UWorld* WorldToFlush, bool bClearActivatedReverb = true);
 
    /*
    * Derived classes can override this method to do their own cleanup. Called at the end of FAudioDevice::Flush()
    */
    ENGINE_API virtual void FlushExtended(UWorld* WorldToFlush, bool bClearActivatedReverb);
 
    virtual void FlushAudioRenderingCommands(bool bPumpSynchronously = false) {}
 
    ENGINE_API void OnPreGarbageCollect();
 
    ENGINE_API void StopSoundsUsingResource(USoundWave* SoundWave, TArray<UAudioComponent*>* StoppedComponents = nullptr);
 
    ENGINE_API static bool LegacyReverbDisabled();
 
#if WITH_EDITOR
    ENGINE_API void OnBeginPIE(const bool bIsSimulating);
 
    ENGINE_API void OnEndPIE(const bool bIsSimulating);
#endif
 
    ENGINE_API virtual void Precache(USoundWave* SoundWave, bool bSynchronous = false, bool bTrackMemory = true, bool bForceFullDecompression = false);
 
    UE_DEPRECATED(5.7, "With PCM audio caching removed, this hueristic is no longer used.")
    ENGINE_API float GetCompressionDurationThreshold(const FSoundGroup &SoundGroup);
 
    UE_DEPRECATED(5.7, "Most of these arguments are no longer used, replace calls with the caller's value for bForceFullDecompression")
    ENGINE_API bool ShouldUseRealtimeDecompression(bool bForceFullDecompression, const FSoundGroup &SoundGroup, USoundWave* SoundWave, float CompressedDurationThreshold) const;
 
    ENGINE_API void PrecacheStartupSounds();
 
    ENGINE_API void SetMaxChannels(int32 InMaxChannels);
 
    ENGINE_API void SetMaxChannelsScaled(float InScaledChannelCount);
 
    ENGINE_API int32 GetMaxChannels() const;
 
    ENGINE_API int32 GetMaxSources() const;
 
    ENGINE_API TRange<float> GetGlobalPitchRange() const;
 
    UE_DEPRECATED(5.5, "No longer needed for resource managment, existing calls may be deleted")
    ENGINE_API void StopSourcesUsingBuffer(FSoundBuffer * SoundBuffer);
 
    ENGINE_API virtual void StopAllSounds(bool bShouldStopUISounds = false);
 
    ENGINE_API void SetListener(UWorld* World, int32 InListenerIndex, const FTransform& ListenerTransform, float InDeltaSeconds);
 
    ENGINE_API void SetListenerAttenuationOverride(int32 ListenerIndex, const FVector AttenuationPosition);
 
    ENGINE_API void ClearListenerAttenuationOverride(int32 ListenerIndex);
 
    const TArray<FListener>& GetListeners() const { check(IsInAudioThread()); return Listeners; }
 
    UReverbEffect* GetCurrentReverbEffect() const
    {
        check(IsInGameThread());
        return CurrentReverbEffect;
    }
 
    struct FCreateComponentParams
    {
        ENGINE_API FCreateComponentParams();
        ENGINE_API FCreateComponentParams(UWorld* World, AActor* Actor = nullptr);
        ENGINE_API FCreateComponentParams(AActor* Actor);
        ENGINE_API FCreateComponentParams(FAudioDevice* AudioDevice);
 
        USoundAttenuation* AttenuationSettings;
        TSubclassOf<UAudioComponent> AudioComponentClass = UAudioComponent::StaticClass();
        TSet<USoundConcurrency*> ConcurrencySet;
        bool bAutoDestroy;
        bool bPlay;
        bool bStopWhenOwnerDestroyed;
 
        ENGINE_API void SetLocation(FVector Location);
        ENGINE_API bool ShouldUseAttenuation() const;
 
    private:
        UWorld* World;
        AActor* Actor;
        FAudioDevice* AudioDevice;
 
        bool bLocationSet;
        FVector Location;
 
        ENGINE_API void CommonInit();
 
        friend FAudioDevice;
    };
 
    ENGINE_API static UAudioComponent* CreateComponent(USoundBase* Sound, const FCreateComponentParams& Params = FCreateComponentParams());
 
    ENGINE_API void PlaySoundAtLocation(USoundBase* Sound, UWorld* World, float VolumeMultiplier, float PitchMultiplier, float StartTime, const FVector& Location, const FRotator& Rotation, USoundAttenuation* AttenuationSettings = nullptr, USoundConcurrency* ConcurrencySettings = nullptr, const TArray<FAudioParameter>* Params = nullptr, const AActor* OwningActor = nullptr);
    ENGINE_API void PlaySoundAtLocation(USoundBase* Sound, UWorld* World, float VolumeMultiplier, float PitchMultiplier, float StartTime, const FVector& Location, const FRotator& Rotation, USoundAttenuation* AttenuationSettings, USoundConcurrency* Concurrency, TArray<FAudioParameter>&& Params, const AActor* OwningActor = nullptr);
 
 
    ENGINE_API void AddNewActiveSound(const FActiveSound& ActiveSound, const TArray<FAudioParameter>* InDefaultParams = nullptr, const FString* EventLogID = nullptr);
 
    ENGINE_API void AddNewActiveSound(TSharedRef<FActiveSound> ActiveSound, TArray<FAudioParameter>&& InDefaultParams, const FString* EventLogID = nullptr);
 
    UE_DEPRECATED(5.7, "Use AddNewActiveSound which accepts a TSharedRef<>")
    ENGINE_API void AddNewActiveSound(const FActiveSound& ActiveSound, TArray<FAudioParameter>&& InDefaultParams);
 
    ENGINE_API void RetriggerVirtualLoop(FAudioVirtualLoop& VirtualLoop);
 
    ENGINE_API void StopActiveSound(uint64 AudioComponentID, const FString* EventLogID = nullptr);
 
    ENGINE_API void StopActiveSound(FActiveSound* ActiveSound, const FString* EventLogID = nullptr);
 
    ENGINE_API void PauseActiveSound(uint64 AudioComponentID, const bool bInIsPaused);
 
    ENGINE_API void NotifyActiveSoundOcclusionTraceDone(FActiveSound* ActiveSound, bool bIsOccluded);
 
    UE_DEPRECATED(5.0, "This call cannot be called from the GameThread & AudioComponents can now execute multiple ActiveSound instances at once.  Use 'SendCommandToActiveSounds' instead.")
    ENGINE_API FActiveSound* FindActiveSound(uint64 AudioComponentID);
 
    ENGINE_API bool CanHaveMultipleActiveSounds(uint64 AudioComponentID) const;
 
    ENGINE_API void SetCanHaveMultipleActiveSounds(uint64 AudioComponentID, bool InCanHaveMultipleActiveSounds);
 
    ENGINE_API void RemoveActiveSound(FActiveSound* ActiveSound);
 
    ENGINE_API void AddAudioVolumeProxy(const FAudioVolumeProxy& Proxy);
    ENGINE_API void RemoveAudioVolumeProxy(uint32 AudioVolumeID);
    ENGINE_API void UpdateAudioVolumeProxy(const FAudioVolumeProxy& Proxy);
 
    struct FAudioVolumeSettings
    {
        uint32 AudioVolumeID = uint32(INDEX_NONE);
        float Priority = 0.0f;
        FReverbSettings ReverbSettings;
        FInteriorSettings InteriorSettings;
        TArray<FAudioVolumeSubmixSendSettings> SubmixSendSettings;
        TArray<FAudioVolumeSubmixOverrideSettings> SubmixOverrideSettings;
        bool bChanged = false;
    };
 
    ENGINE_API void GetAudioVolumeSettings(const uint32 WorldID, const FVector& Location, FAudioVolumeSettings& OutSettings) const;
    ENGINE_API void ResetAudioVolumeProxyChangedState();
 
    ENGINE_API void GatherInteriorData(FActiveSound& ActiveSound, FSoundParseParameters& ParseParams) const;
 
    ENGINE_API void ApplyInteriorSettings(FActiveSound& ActiveSound, FSoundParseParameters& ParseParams) const;
 
    UE_DEPRECATED(5.3, "NotifyPending is deprecated in public scope. Use IActiveSoundUpdateInterface::NotifyActiveSoundDeleting instead.")
    void NotifyPendingDelete(FActiveSound& ActiveSound) const {}
 
protected:
 
    ENGINE_API void NotifySubsystemsActiveSoundCreated(FActiveSound& ActiveSound) const;
 
    ENGINE_API void NotifySubsystemsActiveSoundDeleting(FActiveSound& ActiveSound) const;
 
    ENGINE_API void NotifySubsystemsVirtualizedSoundCreated(FActiveSound& ActiveSound) const;
 
    ENGINE_API void NotifySubsystemsVirtualizedSoundDeleting(FActiveSound& ActiveSound) const;
 
    UE_DEPRECATED(5.5, "NotifyAddActiveSound is deprecated. Use NotifySubsystemsActiveSoundCreated instead.")
    void NotifyAddActiveSound(FActiveSound& ActiveSound) const
    {
        NotifySubsystemsActiveSoundCreated(ActiveSound);
    }
 
    UE_DEPRECATED(5.5, "NotifyPendingDeleteInternal is deprecated. Use NotifySubsystemsActiveSoundDeleting and/or NotifySubsystemsVirtualizedSoundDeleting instead.")
    void NotifyPendingDeleteInternal(FActiveSound& ActiveSound) const
    {
        NotifySubsystemsActiveSoundDeleting(ActiveSound);
    }
 
    UE_DEPRECATED(5.7, "NotifySubsystemsSetOwner is deprecated. Use ActiveSound.GetOwnerKey instead.")
    ENGINE_API void NotifySubsystemsSetOwner(FActiveSound& ActiveSound, const UObject* Owner) const;
 
public:
 
    ENGINE_API bool GetDefaultAudioSettings(uint32 WorldID, FReverbSettings& OutReverbSettings, FInteriorSettings& OutInteriorSettings) const;
 
    ENGINE_API void SetDefaultAudioSettings(UWorld* World, const FReverbSettings& DefaultReverbSettings, const FInteriorSettings& DefaultInteriorSettings);
 
    EDebugState GetMixDebugState() const { return((EDebugState)DebugState); }
 
    ENGINE_API void SetMixDebugState(EDebugState DebugState);
 
    ENGINE_API void InitSoundClasses();
 
protected:
    ENGINE_API void InitSoundSources();
 
    ENGINE_API void InitializeSubsystemCollection();
 
    // Handle for our device created delegate
    FDelegateHandle DeviceCreatedHandle;
 
    // Handle for our device destroyed delegate
    FDelegateHandle DeviceDestroyedHandle;
 
    FCriticalSection RenderStateCallbackListCritSec;
 
    // Callback as audio device is about to render a buffer
    FOnAudioDevicePreRender OnAudioDevicePreRender;
 
    // Callback as audio device has just finished rendering a buffer
    FOnAudioDevicePostRender OnAudioDevicePostRender;
 
public:
    ENGINE_API void RegisterSoundClass(USoundClass* InSoundClass);
 
    ENGINE_API void UnregisterSoundClass(USoundClass* SoundClass);
 
    virtual void InitSoundSubmixes() {}
 
    virtual void RegisterSoundSubmix(USoundSubmixBase* SoundSubmix, bool bInit) {}
 
    virtual void UnregisterSoundSubmix(const USoundSubmixBase* SoundSubmix, const bool bReparentChildren) {}
 
    ENGINE_API virtual USoundSubmix& GetMainSubmixObject() const;
 
    UE_DEPRECATED(5.4, "Use RegisterSubmixBufferListener version that requires a shared reference to a listener and provide explicit reference to a submix: use GetMainSubmixObject to register with the Main Output Submix (rather than nullptr for safety), and instantiate buffer listener via the shared pointer API.")
    ENGINE_API virtual void RegisterSubmixBufferListener(ISubmixBufferListener* InSubmixBufferListener, USoundSubmix* SoundSubmix = nullptr);
 
    UE_DEPRECATED(5.4, "Use UnregisterSubmixBufferListener version that requires a shared reference to a listener and provide explicit reference to a submix: use GetMainSubmixObject to unregister from the Main Output Submix (rather than nullptr for safety), and instantiate buffer listener via the shared pointer API.")
    ENGINE_API virtual void UnregisterSubmixBufferListener(ISubmixBufferListener* InSubmixBufferListener, USoundSubmix* SoundSubmix = nullptr);
 
    ENGINE_API virtual void RegisterSubmixBufferListener(TSharedRef<ISubmixBufferListener, ESPMode::ThreadSafe> InSubmixBufferListener, USoundSubmix& SoundSubmix);
 
    ENGINE_API virtual void UnregisterSubmixBufferListener(TSharedRef<ISubmixBufferListener, ESPMode::ThreadSafe> InSubmixBufferListener, USoundSubmix& SoundSubmix);
 
 
    ENGINE_API virtual Audio::FPatchOutputStrongPtr AddPatchForSubmix(uint32 InObjectId, float InPatchGain);
 
    ENGINE_API virtual Audio::FPatchInput AddPatchInputForAudioBus(uint32 InAudioBusId, int32 InFrames, int32 InChannels, float InGain = 1.f);
 
    ENGINE_API virtual Audio::FPatchOutputStrongPtr AddPatchOutputForAudioBus(uint32 InAudioBusId, int32 InFrames, int32 InChannels, float InGain = 1.f);
 
    ENGINE_API FSoundClassProperties* GetSoundClassCurrentProperties(USoundClass* InSoundClass);
 
    ENGINE_API FSoundClassDynamicProperties* GetSoundClassDynamicProperties(USoundClass* InSoundClass);
 
    ENGINE_API bool LocationIsAudible(const FVector& Location, const float MaxDistance) const;
 
    ENGINE_API bool LocationIsAudible(const FVector& Location, int32 ListenerIndex, const float MaxDistance) const;
 
    ENGINE_API float GetDistanceToNearestListener(const FVector& Location) const;
 
    ENGINE_API bool GetDistanceSquaredToListener(const FVector& Location, int32 ListenerIndex, float& OutSqDistance) const;
 
    ENGINE_API bool GetDistanceSquaredToNearestListener(const FVector& Location, float& OutSqDistance) const;
        
    ENGINE_API static float GetMaxWorldDistance();
 
    ENGINE_API bool GetListenerPosition(int32 ListenerIndex, FVector& OutPosition, bool bAllowOverride) const;
 
    ENGINE_API bool GetListenerTransform(int32 ListenerIndex, FTransform& OutTransform) const;
 
    ENGINE_API bool GetListenerWorldID(int32 ListenerIndex, uint32& OutWorldID) const;
 
    ENGINE_API void SetDefaultBaseSoundMix(USoundMix* SoundMix);
 
    ENGINE_API void RemoveSoundMix(USoundMix* SoundMix);
 
    ENGINE_API void ResetInterpolation();
 
    ENGINE_API void EnableRadioEffect(bool bEnable = false);
 
    friend class FAudioEffectsManager;
    ENGINE_API void SetBaseSoundMix(USoundMix* SoundMix);
 
    ENGINE_API void PushSoundMixModifier(USoundMix* SoundMix, bool bIsPassive = false, bool bIsRetrigger = false);
 
    ENGINE_API void SetSoundMixClassOverride(USoundMix* InSoundMix, USoundClass* InSoundClass, float Volume, float Pitch, float FadeInTime, bool bApplyToChildren);
 
    ENGINE_API void ClearSoundMixClassOverride(USoundMix* InSoundMix, USoundClass* InSoundClass, float FadeOutTime);
 
    ENGINE_API void PopSoundMixModifier(USoundMix* SoundMix, bool bIsPassive = false);
 
    ENGINE_API void ClearSoundMixModifier(USoundMix* SoundMix);
 
    ENGINE_API void ClearSoundMixModifiers();
 
    ENGINE_API void ActivateReverbEffect(UReverbEffect* ReverbEffect, FName TagName, float Priority, float Volume, float FadeTime);
 
    ENGINE_API void DeactivateReverbEffect(FName TagName);
 
    virtual bool HasCompressedAudioInfoClass(USoundWave* SoundWave) { return false; }
 
    UE_DEPRECATED(5.7, "Realtime decpmpression is available on all platforms")
    virtual bool SupportsRealtimeDecompression() const
    {
        return true;
    }
 
    UE_DEPRECATED(5.7, "PCM Audio Caching is a leagacy feature that is now disabled for all platforms")
    virtual bool DisablePCMAudioCaching() const
    {
        return true;
    }
 
    virtual bool ValidateAPICall(const TCHAR* Function, uint32 ErrorCode)
    {
        return true;
    }
 
    const TArray<FActiveSound*>& GetActiveSounds() const
    {
        check(IsInAudioThread());
        return ActiveSounds;
    }
 
    ENGINE_API void InvalidateCachedInteriorVolumes() const;
 
    virtual void SuspendContext() {}
 
    virtual void ResumeContext() {}
 
    virtual bool IsExernalBackgroundSoundActive() { return false; }
 
    ENGINE_API bool IsHRTFEnabledForAll() const;
 
    void SetHRTFEnabledForAll(bool InbHRTFEnabledForAll)
    {
        const bool bNewHRTFEnabledForAll = InbHRTFEnabledForAll;
 
        bHRTFEnabledForAll_OnGameThread = bNewHRTFEnabledForAll;
 
        DECLARE_CYCLE_STAT(TEXT("FAudioThreadTask.SetHRTFEnabledForAll"), STAT_SetHRTFEnabledForAll, STATGROUP_AudioThreadCommands);
 
        FAudioDevice* AudioDevice = this;
        FAudioThread::RunCommandOnAudioThread([AudioDevice, bNewHRTFEnabledForAll]()
        {
            AudioDevice->bHRTFEnabledForAll = bNewHRTFEnabledForAll;
 
        }, GET_STATID(STAT_SetHRTFEnabledForAll));
    }
 
    ENGINE_API bool IsHRTFDisabled() const;
 
    void SetHRTFDisabled(bool InIsHRTFDisabled)
    {
        const bool bNewHRTFDisabled = InIsHRTFDisabled;
 
        bHRTFDisabled_OnGameThread = bNewHRTFDisabled;
 
        DECLARE_CYCLE_STAT(TEXT("FAudioThreadTask.SetHRTFDisabled"), STAT_SetHRTFDisabled, STATGROUP_AudioThreadCommands);
 
        FAudioDevice* AudioDevice = this;
        FAudioThread::RunCommandOnAudioThread([AudioDevice, bNewHRTFDisabled]()
        {
            AudioDevice->bHRTFDisabled = bNewHRTFDisabled;
 
        }, GET_STATID(STAT_SetHRTFDisabled));
    }
 
    void SetSpatializationInterfaceEnabled(bool InbSpatializationInterfaceEnabled)
    {
        FAudioThread::SuspendAudioThread();
 
        bSpatializationInterfaceEnabled = InbSpatializationInterfaceEnabled;
 
        FAudioThread::ResumeAudioThread();
    }
 
    ENGINE_API void RegisterPluginListener(const TAudioPluginListenerPtr PluginListener);
 
    ENGINE_API void UnregisterPluginListener(const TAudioPluginListenerPtr PluginListener);
 
    ENGINE_API bool IsAudioDeviceMuted() const;
 
    ENGINE_API void SetDeviceMuted(bool bMuted);
 
    ENGINE_API void GetAzimuth(const FAttenuationListenerData& OutListenerData, float& OutAzimuth, float& AbsoluteAzimuth) const;
 
    ENGINE_API float GetFocusFactor(const float Azimuth, const FSoundAttenuationSettings& AttenuationSettings) const;
 
    ENGINE_API void GetMaxDistanceAndFocusFactor(USoundBase* Sound, const UWorld* World, const FVector& Location, const FSoundAttenuationSettings* AttenuationSettingsToApply, float& OutMaxDistance, float& OutFocusFactor);
 
    ENGINE_API bool SoundIsAudible(USoundBase* Sound, const UWorld* World, const FVector& Location, const FSoundAttenuationSettings* AttenuationSettingsToApply, float MaxDistance, float FocusFactor) const;
 
    ENGINE_API static int32 FindClosestListenerIndex(const FTransform& SoundTransform, const TArray<FListener>& InListeners);
 
    ENGINE_API int32 FindClosestListenerIndex(const FTransform& SoundTransform) const;
    ENGINE_API int32 FindClosestListenerIndex(const FVector& Position, float& OutSqDistance, bool AllowAttenuationOverrides) const;
 
    ENGINE_API void UnlinkActiveSoundFromComponent(const FActiveSound& InActiveSound);
 
    virtual double GetAudioTime() const
    {
        return 0.0;
    }
 
    virtual void EnableDebugAudioOutput()
    {
    }
 
    ENGINE_API static FAudioDeviceHandle GetMainAudioDevice();
 
    ENGINE_API static FAudioDeviceManager* GetAudioDeviceManager();
 
    ENGINE_API float GetLowPassFilterResonance() const;
 
    virtual int32 GetNumActiveSources() const { return 0; }
 
    int32 GetNumFreeSources() const { return Sources.Num(); }
 
    float GetSampleRate() const { return (float)(SampleRate); }
 
    int32 GetBufferLength() const { return PlatformSettings.CallbackBufferFrameSize; }
 
    int32 GetNumBuffers() const { return PlatformSettings.NumBuffers; }
 
    bool IsSpatializationPluginEnabled() const
    {
        return bSpatializationInterfaceEnabled;
    }
 
    ENGINE_API bool SetCurrentSpatializationPlugin(FName PluginName);
 
    ENGINE_API TArray<FName> GetAvailableSpatializationPluginNames() const;
 
    TAudioSpatializationPtr GetSpatializationPluginInterface()
    {
        return GetCurrentSpatializationPluginInterfaceInfo().SpatializationPlugin;
    }
 
    struct FAudioSpatializationInterfaceInfo;
    ENGINE_API FAudioSpatializationInterfaceInfo GetCurrentSpatializationPluginInterfaceInfo();
 
    ENGINE_API bool SpatializationPluginInterfacesAvailable();
 
    bool IsModulationPluginEnabled() const
    {
        return bModulationInterfaceEnabled;
    }
 
    bool IsOcclusionPluginEnabled() const
    {
        return bOcclusionInterfaceEnabled;
    }
 
    ENGINE_API static bool IsOcclusionPluginLoaded();
 
    bool IsReverbPluginEnabled() const
    {
        return bReverbInterfaceEnabled;
    }
 
    ENGINE_API static bool IsReverbPluginLoaded();
 
    bool IsSourceDataOverridePluginEnabled() const
    {
        return bSourceDataOverrideInterfaceEnabled;
    }
 
    ENGINE_API static bool IsSourceDataOverridePluginLoaded();
 
    bool IsStoppingVoicesEnabled() const
    {
        return bIsStoppingVoicesEnabled;
    }
 
    bool IsBakedAnalaysisQueryingEnabled() const
    {
        return bIsBakedAnalysisEnabled;
    }
 
    ENGINE_API void SendCommandToActiveSounds(uint64 InAudioComponentID, TUniqueFunction<void(FActiveSound&)> InFunc, const TStatId InStatId = TStatId());
 
    virtual bool IsNonRealtime() const
    {
        return false;
    }
 
    virtual void UpdateSourceEffectChain(const uint32 SourceEffectChainId, const TArray<FSourceEffectChainEntry>& SourceEffectChain, const bool bPlayEffectChainTails) {}
 
    virtual bool GetCurrentSourceEffectChain(const uint32 SourceEffectChainId, TArray<FSourceEffectChainEntry>& OutCurrentSourceEffectChainEntries) { return false; }
 
    virtual void UpdateSubmixProperties(USoundSubmixBase* InSubmix)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void StartRecording(USoundSubmix* InSubmix, float ExpectedRecordingDuration)
    {
        UE_LOG(LogAudio, Error, TEXT("Submix recording only works with the audio mixer. Please run using -audiomixer to or set INI file use submix recording."));
    }
 
    virtual Audio::FAlignedFloatBuffer& StopRecording(USoundSubmix* InSubmix, float& OutNumChannels, float& OutSampleRate)
    {
        UE_LOG(LogAudio, Error, TEXT("Submix recording only works with the audio mixer. Please run using -audiomixer to or set INI file use submix recording."));
 
        static Audio::FAlignedFloatBuffer InvalidBuffer;
        return InvalidBuffer;
    }
 
    virtual void StartEnvelopeFollowing(USoundSubmix* InSubmix)
    {
        UE_LOG(LogAudio, Error, TEXT("Envelope following submixes only works with the audio mixer. Please run using -audiomixer or set INI file to use submix recording."));
    }
 
    virtual void StopEnvelopeFollowing(USoundSubmix* InSubmix)
    {
        UE_LOG(LogAudio, Error, TEXT("Envelope following submixes only works with the audio mixer. Please run using -audiomixer or set INI file to use submix recording."));
    }
 
    virtual void SetSubmixWetDryLevel(USoundSubmix* InSoundSubmix, float InOutputVolume, float InWetLevel, float InDryLevel)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void SetSubmixAutoDisable(USoundSubmix* InSoundSubmix, bool bInAutoDisable)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void SetSubmixAutoDisableTime(USoundSubmix* InSoundSubmix, float InDisableTime)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    UE_DEPRECATED(5.1, "UpdateSubmixModulationSettings taking single modulators is deprecated.  Use the overload that allows for modulator sets")
    virtual void UpdateSubmixModulationSettings(USoundSubmix* InSoundSubmix, USoundModulatorBase* InOutputModulation, USoundModulatorBase* InWetLevelModulation, USoundModulatorBase* InDryLevelModulation)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer & 'UpdateSubmixModulationSettings' function taking single modulators no longer supported."));
    }
 
    virtual void UpdateSubmixModulationSettings(USoundSubmix* InSoundSubmix, const TSet<TObjectPtr<USoundModulatorBase>>& InOutputModulation, const TSet<TObjectPtr<USoundModulatorBase>>& InWetLevelModulation, const TSet<TObjectPtr<USoundModulatorBase>>& InDryLevelModulation)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void SetSubmixModulationBaseLevels(USoundSubmix* InSoundSubmix, float InVolumeModBase, float InWetModBase, float InDryModBase)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void SetSubmixOutputVolume(USoundSubmix* InSoundSubmix, float InOutputVolume)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void SetSubmixWetLevel(USoundSubmix* InSoundSubmix, float InWetLevel)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void SetSubmixDryLevel(USoundSubmix* InSoundSubmix, float InDryLevel)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void SetSubmixEffectChainOverride(USoundSubmix* InSoundSubmix, const TArray<FSoundEffectSubmixPtr>& InSubmixEffectChain, float InCrossfadeTime)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    virtual void ClearSubmixEffectChainOverride(USoundSubmix* InSoundSubmix, float InCrossfadeTime)
    {
        UE_LOG(LogAudio, Error, TEXT("Submixes are only supported in audio mixer."));
    }
 
    ENGINE_API virtual void AddEnvelopeFollowerDelegate(USoundSubmix* InSubmix, const FOnSubmixEnvelopeBP& OnSubmixEnvelopeBP);
    ENGINE_API virtual void RemoveEnvelopeFollowerDelegate(USoundSubmix* InSubmix, const FOnSubmixEnvelopeBP& OnSubmixEnvelopeBP);
 
    ENGINE_API virtual void StartSpectrumAnalysis(USoundSubmix* InSubmix, const FSoundSpectrumAnalyzerSettings& InSettings);
    ENGINE_API virtual void StopSpectrumAnalysis(USoundSubmix* InSubmix);
    ENGINE_API virtual void GetMagnitudesForFrequencies(USoundSubmix* InSubmix, const TArray<float>& InFrequencies, TArray<float>& OutMagnitudes);
    ENGINE_API virtual void GetPhasesForFrequencies(USoundSubmix* InSubmix, const TArray<float>& InFrequencies, TArray<float>& OutPhases);
    ENGINE_API virtual void AddSpectralAnalysisDelegate(USoundSubmix* InSubmix, const FSoundSpectrumAnalyzerDelegateSettings& InDelegateSettings, const FOnSubmixSpectralAnalysisBP& OnSubmixSpectralAnalysisBP);
    ENGINE_API virtual void RemoveSpectralAnalysisDelegate(USoundSubmix* InSubmix, const FOnSubmixSpectralAnalysisBP& OnSubmixSpectralAnalysisBP);
 
 
protected:
    friend class FSoundSource;
 
    ENGINE_API void HandlePause(bool bGameTicking, bool bGlobalPause = false);
 
    ENGINE_API void StopSources(TArray<FWaveInstance*>& WaveInstances, int32 FirstActiveIndex);
 
    ENGINE_API void StartSources(TArray<FWaveInstance*>& WaveInstances, int32 FirstActiveIndex, bool bGameTicking);
 
    virtual void OnListenerUpdated(const TArray<FListener>& InListeners) {};
 
    ENGINE_API void NotifyAudioDevicePreRender(const FAudioDeviceRenderInfo& InInfo);
 
    ENGINE_API void NotifyAudioDevicePostRender(const FAudioDeviceRenderInfo& InInfo);
 
private:
 
    void AddNewActiveSoundInternal(TSharedRef<FActiveSound> InActiveSound, TArray<FAudioParameter>&& InDefaultParams, FAudioVirtualLoop* InVirtualLoopToRetrigger = nullptr);
 
 
    void AddNewActiveSoundInternal(const FActiveSound& InActiveSound, TArray<FAudioParameter>&& InDefaultParams, FAudioVirtualLoop* InVirtualLoopToRetrigger = nullptr);
 
    void InitSoundParams(FActiveSound& InOutActiveSound, TArray<FAudioParameter> InDefaultParams, bool bInIsVirtualLoopRealzing) const;
 
    void ReportSoundFailedToStart(const uint64 AudioComponentID, FAudioVirtualLoop* VirtualLoop);
 
    void InitializePluginListeners(UWorld* World);
 
    void NotifyPluginListenersWorldChanged(UWorld* World);
 
    void ParseSoundClasses(float InDeltaTime);
 
    void UpdateConcurrency(TArray<FWaveInstance*>& WaveInstances, TArray<FActiveSound*>& ActiveSoundsCopy);
 
    bool SoundIsAudible(const FActiveSound& NewActiveSound);
 
 
    bool ApplySoundMix(USoundMix* NewMix, FSoundMixState* SoundMixState);
 
    void UpdateSoundMix(USoundMix* SoundMix, FSoundMixState* SoundMixState);
 
    void UpdatePassiveSoundMixModifiers(TArray<FWaveInstance*>& WaveInstances, int32 FirstActiveIndex);
 
    bool TryClearingSoundMix(USoundMix* SoundMix, FSoundMixState* SoundMixState);
 
    bool TryClearingEQSoundMix(USoundMix* SoundMix);
 
    USoundMix* FindNextHighestEQPrioritySoundMix(USoundMix* IgnoredSoundMix);
 
    void ClearSoundMix(USoundMix* SoundMix);
 
    void ApplyClassAdjusters(USoundMix* SoundMix, float InterpValue, float DeltaTime);
 
    void UpdateSoundClassProperties(float DeltaTime);
 
    void VirtualizeInactiveLoops();
 
    void RecursiveApplyAdjuster(const FSoundClassAdjuster& InAdjuster, USoundClass* InSoundClass);
 
    float InterpolateAdjuster(const float Adjuster, const float InterpValue) const
    {
        return Adjuster * InterpValue + 1.0f - InterpValue;
    }
 
    float GetInterpolatedFrequency(const float InFrequency, const float InterpValue) const;
 
    virtual FAudioPlatformSettings GetPlatformSettings() const { return FAudioPlatformSettings(); }
 
    void UpdateAudioVolumeEffects();
 
    void UpdateAudioEngineSubsystems();
 
#if UE_AUDIO_PROFILERTRACE_ENABLED
    void SendSoundStartedTraceMessage(const FActiveSound& InActiveSound) const;
 
    void SendSoundIsAlivePingTraceMessage(const FActiveSound& InActiveSound) const;
#endif // UE_AUDIO_PROFILERTRACE_ENABLED
 
public:
 
    ENGINE_API void* InitEffect(FSoundSource* Source);
 
    ENGINE_API void* UpdateEffect(FSoundSource* Source);
 
    ENGINE_API void DestroyEffect(FSoundSource* Source);
 
    FAudioEffectsManager* GetEffects()
    {
        check(IsInAudioThread());
        return Effects;
    }
 
    const FAudioEffectsManager* GetEffects() const
    {
        check(IsInAudioThread());
        return Effects;
    }
 
    const TMap<USoundMix*, FSoundMixState>& GetSoundMixModifiers() const
    {
        return ObjectPtrDecay(SoundMixModifiers);
    }
 
    const TArray<USoundMix*>& GetPrevPassiveSoundMixModifiers() const
    {
        return ObjectPtrDecay(PrevPassiveSoundMixModifiers);
    }
 
    USoundMix* GetDefaultBaseSoundMixModifier()
    {
        return DefaultBaseSoundMix;
    }
 
    void SetSoundMixModifiers(const TMap<USoundMix*, FSoundMixState>& InSoundMixModifiers, const TArray<USoundMix*>& InPrevPassiveSoundMixModifiers, USoundMix* InDefaultBaseSoundMix)
    {
        SoundMixModifiers = ObjectPtrWrap(InSoundMixModifiers);
        PrevPassiveSoundMixModifiers = ObjectPtrWrap(InPrevPassiveSoundMixModifiers);
        DefaultBaseSoundMix = InDefaultBaseSoundMix;
    }
 
    ENGINE_API FDelegateHandle AddPreRenderDelegate(const FOnAudioDevicePreRender::FDelegate& InDelegate);
 
    ENGINE_API bool RemovePreRenderDelegate(const FDelegateHandle& InHandle);
 
    ENGINE_API FDelegateHandle AddPostRenderDelegate(const FOnAudioDevicePostRender::FDelegate& InDelegate);
 
    ENGINE_API bool RemovePostRenderDelegate(const FDelegateHandle& InHandle);
 
private:
    void RecurseIntoSoundClasses(USoundClass* CurrentClass, FSoundClassProperties& ParentProperties);
 
    void UpdateHighestPriorityReverb();
 
    void SendUpdateResultsToGameThread(int32 FirstActiveIndex);
 
public:
 
// If we make FAudioDevice not be subclassable, then all the functions following would move to IAudioDeviceModule
 
    virtual bool InitializeHardware()
    {
        return true;
    }
 
    virtual void TeardownHardware()
    {
    }
 
    virtual void UpdateHardwareTiming()
    {
    }
 
    virtual void UpdateHardware()
    {
    }
 
    ENGINE_API virtual FAudioEffectsManager* CreateEffectsManager();
 
    virtual FSoundSource* CreateSoundSource() = 0;
 
    ENGINE_API void AddSoundToStop(FActiveSound* SoundToStop);
 
    ENGINE_API bool IsPendingStop(FActiveSound* ActiveSound);
 
    ENGINE_API FVector GetListenerTransformedDirection(const FVector& Position, float* OutDistance);
 
    ENGINE_API float GetDeviceDeltaTime() const;
 
    ENGINE_API float GetGameDeltaTime() const;
 
    ENGINE_API bool IsUsingListenerAttenuationOverride(int32 ListenerIndex) const;
 
    ENGINE_API const FVector& GetListenerAttenuationOverride(int32 ListenerIndex) const;
 
    ENGINE_API void UpdateVirtualLoops(bool bForceUpdate);
 
    virtual void UpdateDeviceDeltaTime()
    {
        const double CurrTime = FPlatformTime::Seconds();
        DeviceDeltaTime = UE_REAL_TO_FLOAT(CurrTime - LastUpdateTime);
        LastUpdateTime = CurrTime;
    }
 
private:
    void ProcessingPendingActiveSoundStops(bool bForceDelete = false);
 
    void StopOldestStoppingSource();
 
    bool ShouldUseAttenuation(const UWorld* World) const;
 
    int32 GetNumPrecacheFrames() const;
 
    void UpdateUnpreparedSound(FWaveInstance* WaveInstance, bool bGameTicking) const;
 
    void UpdateSoundDuration(FWaveInstance* WaveInstance, bool bGameTicking) const;
 
    bool RemoveVirtualLoop(FActiveSound& ActiveSound);
public:
 
    ENGINE_API static bool CanUseVRAudioDevice();
 
    double GetAudioClock() const { return AudioClock; }
 
    virtual double GetInterpolatedAudioClock() const { return GetAudioClock(); }
 
    ENGINE_API void AddVirtualLoop(const FAudioVirtualLoop& InVirtualLoop);
 
    bool AreStartupSoundsPreCached() const { return bStartupSoundsPreCached; }
 
    UE_DEPRECATED(5.1, "GetTransientMasterVolume has been deprecated. Please use GetTransientPrimaryVolume instead.")
    float GetTransientMasterVolume() const { check(IsInAudioThread()); return TransientPrimaryVolume; }
 
    UE_DEPRECATED(5.1, "SetTransientMasterVolume has been deprecated. Please use SetTransientPrimaryVolume instead.")
    ENGINE_API void SetTransientMasterVolume(float TransientPrimaryVolume);
 
    UE_DEPRECATED(5.1, "GetMasterVolume has been deprecated. Please use GetPrimaryVolume instead.")
    float GetMasterVolume() const { return PrimaryVolume; }
 
    float GetTransientPrimaryVolume() const { check(IsInAudioThread()); return TransientPrimaryVolume; }
    ENGINE_API void SetTransientPrimaryVolume(float TransientPrimaryVolume);
 
    float GetPrimaryVolume() const { return PrimaryVolume; }
 
    ENGINE_API FSoundSource* GetSoundSource(FWaveInstance* WaveInstance) const;
 
    ENGINE_API const FGlobalFocusSettings& GetGlobalFocusSettings() const;
    ENGINE_API void SetGlobalFocusSettings(const FGlobalFocusSettings& NewFocusSettings);
 
    const FDynamicParameter& GetGlobalPitchScale() const { check(IsInAudioThread()); return GlobalPitchScale; }
    ENGINE_API void SetGlobalPitchModulation(float PitchScale, float TimeSec);
    ENGINE_API float ClampPitch(float InPitchScale) const;
 
    ENGINE_API void SetSoundClassDistanceScale(USoundClass* InSoundClass, float DistanceScale, float TimeSec);
 
    float GetPlatformAudioHeadroom() const { check(IsInAudioThread()); return PlatformAudioHeadroom; }
    ENGINE_API void SetPlatformAudioHeadroom(float PlatformHeadRoom);
 
    ENGINE_API const TMap<FName, FActivatedReverb>& GetActiveReverb() const;
 
    bool PlayWhenSilentEnabled() const { return bAllowPlayWhenSilent; }
 
    ENGINE_API bool IsMainAudioDevice() const;
 
    void SetUseAttenuationForNonGameWorlds(bool bInUseAttenuationForNonGameWorlds)
    {
        bUseAttenuationForNonGameWorlds = bInUseAttenuationForNonGameWorlds;
    }
 
    ENGINE_API const TArray<FWaveInstance*>& GetActiveWaveInstances() const;
 
    float GetDefaultReverbSendLevel() const { return DefaultReverbSendLevel; }
 
    ENGINE_API const TMap<FWaveInstance*, FSoundSource*>& GetWaveInstanceSourceMap() const;
 
    ENGINE_API FName GetAudioStateProperty(const FName& PropertyName) const;
    ENGINE_API void SetAudioStateProperty(const FName& PropertyName, const FName& PropertyValue);
 
    UAudioEngineSubsystem* GetSubsystemBase(TSubclassOf<UAudioEngineSubsystem> SubsystemClass) const
    {
        return SubsystemCollection.GetSubsystem<UAudioEngineSubsystem>(SubsystemClass);
    }
 
    template <typename TSubsystemClass>
    TSubsystemClass* GetSubsystem() const
    {
        return SubsystemCollection.GetSubsystem<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    static inline TSubsystemClass* GetSubsystem(const FAudioDeviceHandle& InHandle)
    {
        if (InHandle.IsValid())
        {
            return InHandle->GetSubsystem<TSubsystemClass>();
        }
        return nullptr;
    }
 
    template <typename TSubsystemClass>
    TArray<TSubsystemClass*> GetSubsystemArrayCopy() const
    {
        return SubsystemCollection.GetSubsystemArrayCopy<TSubsystemClass>(TSubsystemClass::StaticClass());
    }
 
    template <typename TSubsystemClass>
    void ForEachSubsystem(TFunctionRef<void(TSubsystemClass*)> Operation) const
    {
        ((FSubsystemCollection<UAudioEngineSubsystem>&)SubsystemCollection).ForEachSubsystem(
            [Operation=MoveTemp(Operation)](UAudioEngineSubsystem* Subsystem){
                Operation(CastChecked<TSubsystemClass>(Subsystem));
            }, TSubsystemClass::StaticClass());
    }
 
public:
 
    int32 NumStoppingSources;
 
    int32 SampleRate;
 
    FAudioPlatformSettings PlatformSettings;
 
    int32 NumPrecacheFrames;
 
    Audio::FDeviceId DeviceID;
 
    struct FAudioSpatializationInterfaceInfo
    {
        // ctors
        FAudioSpatializationInterfaceInfo() = default;
        ENGINE_API FAudioSpatializationInterfaceInfo(FName InPluginName, FAudioDevice* InAudioDevice, IAudioSpatializationFactory* InAudioSpatializationFactoryPtr);
 
        ENGINE_API bool IsValid() const;
 
        FName PluginName;
        TAudioSpatializationPtr SpatializationPlugin = nullptr;
        int32 MaxChannelsSupportedBySpatializationPlugin = 1;
        uint8 bSpatializationIsExternalSend:1;
        uint8 bIsInitialized:1;
        uint8 bReturnsToSubmixGraph:1;
    };
 
    UE_DEPRECATED(5.1, "Do not access this member directly, it is not used. Call GetSpatializationPluginInterface() instead.")
    TAudioSpatializationPtr SpatializationPluginInterface = nullptr;
 
protected:
    FName CurrentSpatializationPluginInterfaceName;
    TArray<FAudioSpatializationInterfaceInfo> SpatializationInterfaces;
    FAudioSpatializationInterfaceInfo* CurrentSpatializationInterfaceInfoPtr = nullptr;
 
    FAudioPluginInitializationParams PluginInitializationParams;
 
public:
    TAudioSourceDataOverridePtr SourceDataOverridePluginInterface;
 
    TAudioReverbPtr ReverbPluginInterface;
 
    TAudioOcclusionPtr OcclusionInterface;
 
    TAudioModulationPtr ModulationInterface;
 
    TArray<TAudioPluginListenerPtr> PluginListeners;
 
    // Game thread cache of listener transforms
    TArray<FListenerProxy> ListenerProxies;
 
private:
    int32 MaxSources;
 
    int32 MaxChannels;
    int32 MaxChannels_GameThread;
 
    float MaxChannelsScale;
    float MaxChannelsScale_GameThread;
 
    uint64 CurrentTick;
 
    TStrongObjectPtr<UAudioComponent> TestAudioComponent;
 
    TEnumAsByte<enum EDebugState> DebugState;
 
    float TransientPrimaryVolume;
 
    float PrimaryVolume;
 
    FDynamicParameter GlobalPitchScale;
 
    FGlobalFocusSettings GlobalFocusSettings;
    FGlobalFocusSettings GlobalFocusSettings_GameThread;
 
    double LastUpdateTime;
 
    int32 NextResourceID;
 
protected:
    // Audio thread representation of listeners
    TArray<FListener> Listeners;
 
    TArray<FSoundSource*> Sources;
    TArray<FSoundSource*> FreeSources;
 
private:
 
    TStrongObjectPtr<UAudioSubsystemCollectionRoot> SubsystemCollectionRoot;
 
    FAudioSubsystemCollection SubsystemCollection;
 
    TMap<FWaveInstance*, FSoundSource*> WaveInstanceSourceMap;
 
    TMap<USoundClass*, FSoundClassProperties> SoundClasses;
    TMap<USoundClass*, FSoundClassDynamicProperties> DynamicSoundClassProperties;
 
    USoundMix* BaseSoundMix;
 
    TObjectPtr<USoundMix> DefaultBaseSoundMix;
 
    TMap<TObjectPtr<USoundMix>, FSoundMixState> SoundMixModifiers;
 
    TMap<USoundMix*, FSoundMixClassOverrideMap> SoundMixClassEffectOverrides;
 
protected:
    FAudioEffectsManager* Effects;
 
private:
    UReverbEffect* CurrentReverbEffect;
 
    float PlatformAudioHeadroom;
 
    float DefaultReverbSendLevel;
 
    TMap<FName, FActivatedReverb> ActivatedReverbs;
 
    TSharedPtr<FActivatedReverb> PendingActivatedReverb;
 
    FActivatedReverb HighestPriorityActivatedReverb_AudioThread;
 
    FAudioVolumeSettings CurrentAudioVolumeSettings;
 
    bool bHRTFEnabledForAll_OnGameThread;
 
    bool bHRTFDisabled_OnGameThread;
 
    uint8 bGameWasTicking:1;
 
public:
    UE_DEPRECATED(5.7, "bDisableAudioCaching has no effect and will be removed in 5.8")
    uint8 bDisableAudioCaching:1 = false;
 
    uint8 bIsAudioDeviceHardwareInitialized : 1;
 
    uint8 bIsStoppingVoicesEnabled : 1;
 
    uint8 bIsBakedAnalysisEnabled : 1;
 
    uint8 bAudioMixerModuleLoaded : 1;
 
    uint8 bOcclusionIsExternalSend:1;
    uint8 bReverbIsExternalSend:1;
 
// deprecate these as they have been moved to the info struct.
 
    UE_DEPRECATED(5.1, "This member is no longer  in use. Use the return value of GetCurrentSpatializationPluginInterfaceInfo()")
    uint8 bSpatializationIsExternalSend:1;
 
    UE_DEPRECATED(5.1, "This member is no longer  in use. Use the return value of GetCurrentSpatializationPluginInterfaceInfo()")
    int32 MaxChannelsSupportedBySpatializationPlugin;
 
 
 
private:
    uint8 bStartupSoundsPreCached:1;
 
    uint8 bSpatializationInterfaceEnabled:1;
    uint8 bOcclusionInterfaceEnabled:1;
    uint8 bReverbInterfaceEnabled:1;
    uint8 bSourceDataOverrideInterfaceEnabled:1;
    uint8 bModulationInterfaceEnabled:1;
 
    uint8 bPluginListenersInitialized:1;
 
    uint8 bHRTFEnabledForAll:1;
 
    uint8 bHRTFDisabled:1;
 
    uint8 bIsDeviceMuted:1;
 
    uint8 bIsInitialized:1;
 
protected:
 
    double AudioClock;
 
    uint8 bAllowCenterChannel3DPanning : 1;
 
    float DeviceDeltaTime;
 
    inline bool IsInitialized() const { return bIsInitialized; }
 
private:
 
    uint8 bHasActivatedReverb:1;
 
    uint8 bAllowPlayWhenSilent:1;
 
    uint8 bUseAttenuationForNonGameWorlds:1;
 
    TArray<FActiveSound*> ActiveSounds;
    TArray<TObjectPtr<USoundWave>> ReferencedSoundWaves;
 
    void UpdateReferencedSoundWaves();
    TArray<USoundWave*> ReferencedSoundWaves_AudioThread;
    FCriticalSection AudioThreadReferenceCritSec;
 
    TArray<USoundWave*> PrecachingSoundWaves;
 
    TArray<FWaveInstance*> ActiveWaveInstances;
 
    TMap<FActiveSound*, FAudioVirtualLoop> VirtualLoops;
 
    TArray<FSoundClassAdjuster> SoundClassAdjustersCopy;
 
    TSet<FActiveSound*> PendingSoundsToStop;
 
    TQueue<FActiveSound*> PendingAddedActiveSounds;
 
    int32 MaxActiveSoundsAddedPerFrame;
 
    TArray<FActiveSound*> PendingSoundsToDelete;
 
    TMap<uint64, TArray<FActiveSound*>> AudioComponentIDToActiveSoundMap;
 
    TMap<uint64, bool> AudioComponentIDToCanHaveMultipleActiveSoundsMap;
 
    TMap<uint32, FAudioVolumeProxy> AudioVolumeProxies;
 
    TMap<uint32, TPair<FReverbSettings,FInteriorSettings>> WorldIDToDefaultAudioVolumeSettingsMap;
 
    TArray<TObjectPtr<USoundMix>> PrevPassiveSoundMixModifiers;
 
    TMap<FName, FName> AudioStateProperties;
 
    friend class FSoundConcurrencyManager;
    FSoundConcurrencyManager ConcurrencyManager;
 
    TArray<FMatrix> InverseListenerTransforms;
 
    uint32 OneShotCount;
 
    // Global min and max pitch scale, derived from audio settings
    float GlobalMinPitch;
    float GlobalMaxPitch;
};