AudioMixer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/Future.h"
#include "AudioMixerLog.h"
#include "AudioMixerNullDevice.h"
#include "AudioMixerTypes.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "DSP/BufferVectorOperations.h"
#include "DSP/Dsp.h"
#include "DSP/ParamInterpolator.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformMath.h"
#include "HAL/Runnable.h"
#include "HAL/ThreadSafeBool.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Logging/LogVerbosity.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Optional.h"
#include "Misc/ScopeLock.h"
#include "Misc/SingleThreadRunnable.h"
#include "Modules/ModuleInterface.h"
#include "Stats/Stats.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
#include "Trace/Detail/Channel.h"
#include "UObject/NameTypes.h"
 
#define UE_API AUDIOMIXERCORE_API
 
class FEvent;
class FRunnableThread;
class FThreadSafeCounter;
namespace Audio { class FMixerNullCallback; }
 
// defines used for AudioMixer.h
#define AUDIO_PLATFORM_LOG_ONCE(INFO, VERBOSITY)    (AudioMixerPlatformLogOnce(INFO, FString(__FILE__), __LINE__, ELogVerbosity::VERBOSITY))
#define AUDIO_PLATFORM_ERROR(INFO)                  (AudioMixerPlatformLogOnce(INFO, FString(__FILE__), __LINE__, ELogVerbosity::Error))
 
#ifndef AUDIO_MIXER_ENABLE_DEBUG_MODE
// This define enables a bunch of more expensive debug checks and logging capabilities that are intended to be off most of the time even in debug builds of game/editor.
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
#define AUDIO_MIXER_ENABLE_DEBUG_MODE 0
#else
#define AUDIO_MIXER_ENABLE_DEBUG_MODE 1
#endif
#endif
 
 
// Enable debug checking for audio mixer
 
#if AUDIO_MIXER_ENABLE_DEBUG_MODE
#define AUDIO_MIXER_CHECK(expr) ensure(expr)
#define AUDIO_MIXER_CHECK_GAME_THREAD(_MixerDevice)         (_MixerDevice->CheckAudioThread())
#define AUDIO_MIXER_CHECK_AUDIO_PLAT_THREAD(_MixerDevice)   (_MixerDevice->CheckAudioRenderingThread())
#else
#define AUDIO_MIXER_CHECK(expr)
#define AUDIO_MIXER_CHECK_GAME_THREAD(_MixerDevice)
#define AUDIO_MIXER_CHECK_AUDIO_PLAT_THREAD(_MixerDevice)
#endif
 
#define AUDIO_MIXER_MAX_OUTPUT_CHANNELS             8           // Max number of speakers/channels supported (7.1)
 
#define AUDIO_MIXER_DEFAULT_DEVICE_INDEX            INDEX_NONE
 
// Cycle stats for audio mixer
DECLARE_STATS_GROUP(TEXT("AudioMixer"), STATGROUP_AudioMixer, STATCAT_Advanced);
 
// Tracks the time for the full render block 
DECLARE_CYCLE_STAT_EXTERN(TEXT("Render Audio"), STAT_AudioMixerRenderAudio, STATGROUP_AudioMixer, AUDIOMIXERCORE_API);
 
namespace EAudioMixerChannel
{
    enum Type
    {
        FrontLeft,
        FrontRight,
        FrontCenter,
        LowFrequency,
        BackLeft,
        BackRight,
        FrontLeftOfCenter,
        FrontRightOfCenter,
        BackCenter,
        SideLeft,
        SideRight,
        TopCenter,
        TopFrontLeft,
        TopFrontCenter,
        TopFrontRight,
        TopBackLeft,
        TopBackCenter,
        TopBackRight,
        Unknown,
        ChannelTypeCount,
        DefaultChannel = FrontLeft
    };
 
    inline constexpr int32 MaxSupportedChannel = EAudioMixerChannel::TopCenter;
 
    inline const TCHAR* ToString(EAudioMixerChannel::Type InType)
    {
        switch (InType)
        {
        case FrontLeft:             return TEXT("FrontLeft");
        case FrontRight:            return TEXT("FrontRight");
        case FrontCenter:           return TEXT("FrontCenter");
        case LowFrequency:          return TEXT("LowFrequency");
        case BackLeft:              return TEXT("BackLeft");
        case BackRight:             return TEXT("BackRight");
        case FrontLeftOfCenter:     return TEXT("FrontLeftOfCenter");
        case FrontRightOfCenter:    return TEXT("FrontRightOfCenter");
        case BackCenter:            return TEXT("BackCenter");
        case SideLeft:              return TEXT("SideLeft");
        case SideRight:             return TEXT("SideRight");
        case TopCenter:             return TEXT("TopCenter");
        case TopFrontLeft:          return TEXT("TopFrontLeft");
        case TopFrontCenter:        return TEXT("TopFrontCenter");
        case TopFrontRight:         return TEXT("TopFrontRight");
        case TopBackLeft:           return TEXT("TopBackLeft");
        case TopBackCenter:         return TEXT("TopBackCenter");
        case TopBackRight:          return TEXT("TopBackRight");
        case Unknown:               return TEXT("Unknown");
 
        default:
            return TEXT("UNSUPPORTED");
        }
    }
}
 
class FSoundWaveData;
class FSoundWaveProxy;
class ICompressedAudioInfo;
class USoundWave;
 
using FSoundWaveProxyPtr = TSharedPtr<FSoundWaveProxy, ESPMode::ThreadSafe>;
using FSoundWavePtr = TSharedPtr<FSoundWaveData, ESPMode::ThreadSafe>;
 
 
namespace Audio
{
    struct FAudioPlatformDeviceInfo
    {
        FString Name;
 
        FString DeviceId;
 
        int32 NumChannels;
 
        int32 NumDirectOutChannels;
 
        int32 SampleRate;
 
        EAudioMixerStreamDataFormat::Type Format;
 
        TArray<EAudioMixerChannel::Type> OutputChannelArray;
 
        uint8 bIsSystemDefault : 1;
 
        FAudioPlatformDeviceInfo()
        {
            Reset();
        }
 
        void Reset()
        {
            Name = TEXT("Unknown");
            DeviceId = TEXT("Unknown");
            NumChannels = 0;
            NumDirectOutChannels = 0;
            SampleRate = 0;
            Format = EAudioMixerStreamDataFormat::Unknown;
            OutputChannelArray.Reset();
            bIsSystemDefault = false;
        }
 
    };
 
    class IAudioMixer
    {
    public:
        virtual bool OnProcessAudioStream(FAlignedFloatBuffer& OutputBuffer) = 0;
 
        virtual void OnAudioStreamShutdown() = 0;
 
        bool IsMainAudioMixer() const { return bIsMainAudioMixer; }
 
        AUDIOMIXERCORE_API static bool ShouldUseThreadedDeviceSwap();
 
        AUDIOMIXERCORE_API static bool ShouldRecycleThreads();
 
        UE_DEPRECATED(5.6, "ShouldUseDeviceInfoCache functionality moved to IAudioMixerPlatformInterface.")
        AUDIOMIXERCORE_API static bool ShouldUseDeviceInfoCache();
 
 
    protected:
 
        IAudioMixer() 
        : bIsMainAudioMixer(false) 
        {}
 
        bool bIsMainAudioMixer;
    };
 
    enum class EDeviceEndpointType { Unknown, Render, Capture };
 
    // Interface for Caching Device Info.
    class IAudioPlatformDeviceInfoCache
    {
    public:
        // Pure Interface. 
        virtual ~IAudioPlatformDeviceInfoCache() = default;
            
        virtual TOptional<FAudioPlatformDeviceInfo> FindActiveOutputDevice(FName InDeviceID) const = 0;
        virtual TArray<FAudioPlatformDeviceInfo> GetAllActiveOutputDevices() const = 0;
        virtual TOptional<FAudioPlatformDeviceInfo> FindDefaultOutputDevice() const = 0;
 
        virtual bool IsAggregateHardwareDeviceId(const FName InDeviceId) const = 0;
 
        virtual TArray<FAudioPlatformDeviceInfo> GetLogicalAggregateDevices(const FName InHardwareId, const EDeviceEndpointType InEndpointType) const = 0;
    };
 
    struct FAudioMixerOpenStreamParams
    {
        uint32 OutputDeviceIndex;
 
        uint32 NumFrames;
        
        int32 NumBuffers;
 
        IAudioMixer* AudioMixer;
        
        uint32 SampleRate;
 
        /* The maximum number of sources we will try to decode or playback at once. */
        int32 MaxSources;
 
        bool bRestoreIfRemoved;
 
        bool bUseSystemAudioDevice;
 
        FString AudioDeviceId;
 
        FAudioMixerOpenStreamParams()
            : OutputDeviceIndex(INDEX_NONE)
            , NumFrames(1024)
            , NumBuffers(1)
            , AudioMixer(nullptr)
            , SampleRate(44100)
            , MaxSources(0)
            , bRestoreIfRemoved(false)
            , bUseSystemAudioDevice(true)
        {}
    };
 
    struct FAudioOutputStreamInfo
    {
        uint32 OutputDeviceIndex;
 
        FAudioPlatformDeviceInfo DeviceInfo;
 
        std::atomic<EAudioOutputStreamState::Type> StreamState;
 
        IAudioMixer* AudioMixer;
 
        uint32 NumBuffers;
 
        int32 NumOutputFrames;
 
        FAudioOutputStreamInfo()
        {
            Reset();
        }
 
        ~FAudioOutputStreamInfo()
        {
 
        }
 
        void Reset()
        {
            OutputDeviceIndex = 0;
            DeviceInfo.Reset();
            StreamState = EAudioOutputStreamState::Closed;
            AudioMixer = nullptr;
            NumBuffers = 2;
            NumOutputFrames = 0;
        }
    };
 
    enum class EAudioDeviceRole
    {
        Console,
        Multimedia,
        Communications,
 
        COUNT,
    };
 
    enum class EAudioDeviceState
    {
        Active,
        Disabled,
        NotPresent,
        Unplugged,
 
        COUNT,
    };
 
    struct FAudioRenderTimeAnalysis
    {
        double AvgRenderTime;
        double MaxRenderTime;
        double TotalRenderTime;
        double RenderTimeSinceLastLog;
        uint32 StartTime;
        double MaxSinceTick;
        uint64 RenderTimeCount;
        int32 RenderInstanceId;
 
        AUDIOMIXERCORE_API FAudioRenderTimeAnalysis();
        AUDIOMIXERCORE_API void Start();
        AUDIOMIXERCORE_API void End();
    };
 
    class FOutputBuffer
    {
    public:
        FOutputBuffer()
            : AudioMixer(nullptr)
            , DataFormat(EAudioMixerStreamDataFormat::Unknown)
        {}
 
        ~FOutputBuffer() = default;
 
        AUDIOMIXERCORE_API void Init(IAudioMixer* InAudioMixer, const int32 InNumSamples, const int32 InNumBuffers, const EAudioMixerStreamDataFormat::Type InDataFormat);
 
        AUDIOMIXERCORE_API bool MixNextBuffer();
 
        AUDIOMIXERCORE_API TArrayView<const uint8> PopBufferData(int32& OutBytesPopped) const;
 
        AUDIOMIXERCORE_API int32 GetNumSamples() const;
 
        EAudioMixerStreamDataFormat::Type GetFormat() const { return DataFormat; }
 
 
    private:
        IAudioMixer* AudioMixer;
 
        // Circular buffer used to buffer audio between the audio render thread and the platform interface thread.
        mutable Audio::TCircularAudioBuffer<uint8> CircularBuffer;
        
        // Buffer that we render audio to from the IAudioMixer instance associated with this output buffer.
        Audio::FAlignedFloatBuffer RenderBuffer;
 
        // Buffer read by the platform interface thread.
        mutable Audio::FAlignedByteBuffer PopBuffer;
 
        // For non-float situations, this buffer is used to convert RenderBuffer before pushing it to CircularBuffer.
        FAlignedByteBuffer FormattedBuffer;
        EAudioMixerStreamDataFormat::Type DataFormat;
 
        static AUDIOMIXERCORE_API size_t GetSizeForDataFormat(EAudioMixerStreamDataFormat::Type InDataFormat);
        int32 CallCounterMixNextBuffer{ 0 };
    };
 
    class IAudioMixerDeviceChangedListener
    {
    public:
        virtual ~IAudioMixerDeviceChangedListener() = default;
 
        struct FFormatChangedData
        {
            int32 NumChannels = 0;
            int32 SampleRate = 0;
            uint32 ChannelBitmask = 0;
        };
 
        enum class EDisconnectReason
        {
            DeviceRemoval,
            ServerShutdown,
            FormatChanged,
            SessionLogoff,
            SessionDisconnected,
            ExclusiveModeOverride
        };
 
        virtual void RegisterDeviceChangedListener() {}
        virtual void UnregisterDeviceChangedListener() {}
        virtual void OnDefaultCaptureDeviceChanged(const EAudioDeviceRole InAudioDeviceRole, const FString& DeviceId) {}
        virtual void OnDefaultRenderDeviceChanged(const EAudioDeviceRole InAudioDeviceRole, const FString& DeviceId) {}
        virtual void OnDeviceAdded(const FString& DeviceId, bool bIsRenderDevice) {}
        virtual void OnDeviceRemoved(const FString& DeviceId, bool bIsRenderDevice) {}
        virtual void OnDeviceStateChanged(const FString& DeviceId, const EAudioDeviceState InState, bool bIsRenderDevice) {}
        virtual void OnFormatChanged(const FString& InDeviceId, const FFormatChangedData& InFormat) {}
        virtual void OnSessionDisconnect(EDisconnectReason InReason) {}
        
        virtual FString GetDeviceId() const { return FString(); }
    };
 
    
    struct FDeviceSwapContext
    {
        FDeviceSwapContext() = delete;
        FDeviceSwapContext(const FString& InRequestedDeviceID, const FString& InReason) :
            RequestedDeviceId(InRequestedDeviceID),
            DeviceSwapReason(InReason)
        {}
        virtual ~FDeviceSwapContext() = default;
        
        FString RequestedDeviceId;
        FString DeviceSwapReason;
        TOptional<FAudioPlatformDeviceInfo> NewDevice;
    };
 
    struct FDeviceSwapResult
    {
        virtual ~FDeviceSwapResult() = default;
        
        virtual bool IsNewDeviceReady() const { return false; }
 
        FAudioPlatformDeviceInfo DeviceInfo;
        FString SwapReason;
        double SuccessfulDurationMs = 0.0;
    };
 
    class IAudioMixerPlatformInterface : public FRunnable,
                                                        public FSingleThreadRunnable,
                                                        public IAudioMixerDeviceChangedListener
    {
 
    public: // Virtual functions
        
        AUDIOMIXERCORE_API virtual ~IAudioMixerPlatformInterface();
 
        virtual FString GetPlatformApi() const = 0;
 
        virtual bool InitializeHardware() = 0;
 
        virtual bool CheckAudioDeviceChange() { return false; };
 
        virtual void ResumePlaybackOnNewDevice() {}
 
        virtual bool TeardownHardware() = 0;
        
        virtual bool IsInitialized() const = 0;
 
        virtual bool GetNumOutputDevices(uint32& OutNumOutputDevices) { OutNumOutputDevices = 1; return true; }
 
        virtual bool GetOutputDeviceInfo(const uint32 InDeviceIndex, FAudioPlatformDeviceInfo& OutInfo) = 0;
 
        virtual FString GetCurrentDeviceName() const { return CurrentDeviceName; }
 
        AUDIOMIXERCORE_API virtual int32 GetIndexForDevice(const FString& InDeviceName);
 
        virtual FAudioPlatformSettings GetPlatformSettings() const = 0;
 
        virtual bool GetDefaultOutputDeviceIndex(uint32& OutDefaultDeviceIndex) const { OutDefaultDeviceIndex = 0; return true; }
 
        virtual bool OpenAudioStream(const FAudioMixerOpenStreamParams& Params) = 0;
 
        virtual bool CloseAudioStream() = 0;
 
        virtual bool StartAudioStream() = 0;
 
        virtual bool StopAudioStream() = 0;
 
        UE_DEPRECATED(5.6, "Please use new version MoveAudioStreamToNewAudioDevice which takes no parameters.")
        virtual bool MoveAudioStreamToNewAudioDevice(const FString& InNewDeviceId) { return MoveAudioStreamToNewAudioDevice();  }
        virtual bool MoveAudioStreamToNewAudioDevice() { return true;  }
 
        virtual bool RequestDeviceSwap(const FString& DeviceID, bool bInForce, const TCHAR* InReason = nullptr) { return false; }
 
        virtual FAudioPlatformDeviceInfo GetPlatformDeviceInfo() const = 0;
 
        virtual void SubmitBuffer(const uint8* Buffer) {};
 
        virtual void SubmitDirectOutBuffer(const int32 InDirectOutIndex, const Audio::FAlignedFloatBuffer& InBuffer) {};
 
        virtual int32 GetNumFrames(const int32 InNumReqestedFrames) { return InNumReqestedFrames; }
 
        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 SupportsHardwareDecompression() const { return false; }
 
        virtual bool IsNonRealtime() const { return false; }
 
        virtual FString GetDefaultDeviceName() = 0;
 
        // Helper function to gets the channel map type at the given index.
        AUDIOMIXERCORE_API static bool GetChannelTypeAtIndex(const int32 Index, EAudioMixerChannel::Type& OutType);
 
        // Function to stop all audio from rendering. Used on mobile platforms which can suspend the application.
        virtual void SuspendContext() {}
        
        // Function to resume audio rendering. Used on mobile platforms which can suspend the application.
        virtual void ResumeContext() {}
        
        // Function called at the beginning of every call of UpdateHardware on the audio thread.
        virtual void OnHardwareUpdate() {}
 
        // Get the DeviceInfo Cache if one exists.
        virtual IAudioPlatformDeviceInfoCache* GetDeviceInfoCache() const { return nullptr;  }
 
        // Determine if the given device info struct is valid for use with this platform
        virtual bool IsDeviceInfoValid(const FAudioPlatformDeviceInfo& InDeviceInfo) const { return false; }
 
        // Subclasses can override to determine if it should use Cache for DeviceInfo Enumeration
        virtual bool ShouldUseDeviceInfoCache() const { return false; }
    
    public: // Public Functions
        //~ Begin FRunnable
        AUDIOMIXERCORE_API uint32 Run() override;
        //~ End FRunnable
 
        virtual class FSingleThreadRunnable* GetSingleThreadInterface() override { return this; }
 
        //~ Begin FSingleThreadRunnable Interface
        AUDIOMIXERCORE_API virtual void Tick() override;
        //~ End FSingleThreadRunnable Interface
 
        AUDIOMIXERCORE_API IAudioMixerPlatformInterface();
 
        AUDIOMIXERCORE_API void ReadNextBuffer();
 
        AUDIOMIXERCORE_API virtual void FadeIn();
 
        AUDIOMIXERCORE_API virtual void FadeOut();
 
        FString GetLastError() const { return LastError; }
 
        AUDIOMIXERCORE_API void PostInitializeHardware();
 
        bool GetIsListeningForDeviceEvents() const { return bIsListeningForDeviceEvents; }
        void SetIsListeningForDeviceEvents(bool bInListeningForDeviceEvents) { bIsListeningForDeviceEvents = bInListeningForDeviceEvents; }
 
    protected:
        
        // Run the "main" audio device
        AUDIOMIXERCORE_API uint32 MainAudioDeviceRun();
        
        // Wrapper around the thread Run. This is virtualized so a platform can fundamentally override the render function.
        AUDIOMIXERCORE_API virtual uint32 RunInternal();
 
        inline void AudioMixerPlatformLogOnce(const FString& LogDetails, const FString& FileName, int32 LineNumber, ELogVerbosity::Type InVerbosity = ELogVerbosity::Error)
        {
#if !NO_LOGGING
            // Log once to avoid Spam.
            static FCriticalSection Cs;
            static TSet<uint32> LogHistory;
 
            FScopeLock Lock(&Cs);
            FString Message = FString::Printf(TEXT("Audio Platform Device: %s (File %s, Line %d)"), *LogDetails, *FileName, LineNumber);
 
            if ((ELogVerbosity::Error == InVerbosity) || (ELogVerbosity::Fatal == InVerbosity))
            {
                // Save last error if it was at the error level.
                LastError = Message;
            }
 
            uint32 Hash = GetTypeHash(Message);
            if (!LogHistory.Contains(Hash))
            {
                switch (InVerbosity)
                {
                    case ELogVerbosity::Fatal:
                        UE_LOG(LogAudioMixer, Fatal, TEXT("%s"), *Message);
                        break;
 
                    case ELogVerbosity::Error:
                        UE_LOG(LogAudioMixer, Error, TEXT("%s"), *Message);
                        break;
 
                    case ELogVerbosity::Warning:
                        UE_LOG(LogAudioMixer, Warning, TEXT("%s"), *Message);
                        break;
 
                    case ELogVerbosity::Display:
                        UE_LOG(LogAudioMixer, Display, TEXT("%s"), *Message);
                        break;
 
                    case ELogVerbosity::Log:
                        UE_LOG(LogAudioMixer, Log, TEXT("%s"), *Message);
                        break;
 
                    case ELogVerbosity::Verbose:
                        UE_LOG(LogAudioMixer, Verbose, TEXT("%s"), *Message);
                        break;
 
                    case ELogVerbosity::VeryVerbose:
                        UE_LOG(LogAudioMixer, VeryVerbose, TEXT("%s"), *Message);
                        break;
 
                    default:
                        UE_LOG(LogAudioMixer, Error, TEXT("%s"), *Message);
                        {
                            static_assert(static_cast<uint8>(ELogVerbosity::NumVerbosity) == 8, "Missing ELogVerbosity case coverage");
                        }
                        break;
                }
                
                LogHistory.Add(Hash);
            }
#endif
        }
 
 
 
        AUDIOMIXERCORE_API void BeginGeneratingAudio();
 
        AUDIOMIXERCORE_API void StopGeneratingAudio();
 
        // Deprecated - use ApplyPrimaryAttenuation
        UE_DEPRECATED(5.1, "ApplyMasterAttenuation is deprecated, please use ApplyPrimaryAttenuation instead.")
        AUDIOMIXERCORE_API void ApplyMasterAttenuation(TArrayView<const uint8>& InOutPoppedAudio);
 
        AUDIOMIXERCORE_API void ApplyPrimaryAttenuation(TArrayView<const uint8>& InOutPoppedAudio);
 
        template<typename BufferType>
        void ApplyAttenuationInternal(TArrayView<BufferType>& InOutBuffer);
 
        AUDIOMIXERCORE_API void StartRunningNullDevice();
 
        AUDIOMIXERCORE_API void StopRunningNullDevice();
        
        AUDIOMIXERCORE_API void CreateNullDeviceThread(const TFunction<void()> InCallback, float InBufferDuration, bool bShouldPauseOnStart);
 
    protected:
 
        FAudioOutputStreamInfo AudioStreamInfo;
        FAudioMixerOpenStreamParams OpenStreamParams;
 
        Audio::FOutputBuffer OutputBuffer;
 
        bool bWarnedBufferUnderrun;
 
        //FRunnableThread* AudioRenderThread;
        TUniquePtr<FRunnableThread> AudioRenderThread;
 
        FEvent* AudioRenderEvent;
 
        FCriticalSection DeviceSwapCriticalSection;
 
        UE_DEPRECATED(5.6, "bIsInDeviceSwap has been deprecated. AudioStreamInfo.StreamState can provide similar functionality.")
        FThreadSafeBool bIsInDeviceSwap;
 
        FEvent* AudioFadeEvent;
 
        int32 NumOutputBuffers;
 
        float FadeVolume;
 
        FParam FadeParam;
 
        FString CurrentDeviceName;
 
        FString LastError;
 
        int32 CallCounterApplyAttenuationInternal{ 0 };
        int32 CallCounterReadNextBuffer{ 0 };
 
        FThreadSafeBool bPerformingFade;
        FThreadSafeBool bFadedOut;
        FThreadSafeBool bIsDeviceInitialized;
 
        UE_DEPRECATED(5.6, "bMoveAudioStreamToNewAudioDevice has been deprecated. AudioStreamInfo.StreamState can provide similar functionality.")
        FThreadSafeBool bMoveAudioStreamToNewAudioDevice;
 
        FThreadSafeBool bIsUsingNullDevice;
        FThreadSafeBool bIsGeneratingAudio;
 
        AUDIOMIXERCORE_API static FThreadSafeCounter NextInstanceID;
 
        const int32 InstanceID{ -1 };
 
    private:
        TUniquePtr<FMixerNullCallback> NullDeviceCallback;
        
        bool bIsListeningForDeviceEvents = true;
 
    };
 
    class FAudioMixerPlatformSwappable : public IAudioMixerPlatformInterface
    {
    public:
        UE_API FAudioMixerPlatformSwappable();
        virtual ~FAudioMixerPlatformSwappable() override = default;
 
        //~ Begin IAudioMixerPlatformInterface
        UE_API virtual bool RequestDeviceSwap(const FString& DeviceID, const bool bInForce, const TCHAR* InReason) override;
        UE_API virtual bool CheckAudioDeviceChange() override;
        UE_API virtual bool MoveAudioStreamToNewAudioDevice() override;
        UE_API virtual void ResumePlaybackOnNewDevice() override;
        //~ End IAudioMixerPlatformInterface
 
        UE_API virtual bool AllowDeviceSwap(const bool bInForceSwap);
 
        virtual bool InitializeDeviceSwapContext(const FString& InRequestedDeviceID, const TCHAR* InReason) = 0;
 
        UE_API virtual bool CheckThreadedDeviceSwap();
 
        virtual bool PreDeviceSwap() { return true; }
 
        virtual void EnqueueAsyncDeviceSwap() = 0;
 
        virtual void SynchronousDeviceSwap() = 0;
 
        virtual bool PostDeviceSwap() { return true; }
 
    protected:
        FString GetOriginalAudioDeviceId() const { return OriginalAudioDeviceId; }
        void SetOriginalAudioDeviceId(const FString& InAudioDeviceId) { OriginalAudioDeviceId = InAudioDeviceId; }
        
        void SetActiveDeviceSwapFuture(TFuture<TUniquePtr<FDeviceSwapResult>>&& InFuture) { ActiveDeviceSwap = MoveTemp(InFuture); } 
        void ResetActiveDeviceSwapFuture() { ActiveDeviceSwap.Reset(); }
 
        const FDeviceSwapResult* GetDeviceSwapResult() const { return ActiveDeviceSwap.IsValid() ? ActiveDeviceSwap.Get().Get() : nullptr; }
        FDeviceSwapResult* GetDeviceSwapResult() { return ActiveDeviceSwap.IsValid() ? ActiveDeviceSwap.Get().Get() : nullptr; }
 
    private:
        FString OriginalAudioDeviceId;
 
        TFuture<TUniquePtr<FDeviceSwapResult>> ActiveDeviceSwap;
        
        double LastDeviceSwapTime = 0.0;
    };
 
}
 
class FAudioDevice;
 
class IAudioDeviceModule : public IModuleInterface
{
public:
 
    virtual bool IsAudioMixerModule() const { return false; }
    virtual bool IsAudioDeviceClassMulticlient() const { return true; }
    virtual FAudioDevice* CreateAudioDevice() { return nullptr; }
    virtual Audio::IAudioMixerPlatformInterface* CreateAudioMixerPlatformInterface() { return nullptr; }
};
 
#undef UE_API