AudioMixerPlatformXAudio2.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AudioMixer.h"
#include "Windows/AllowWindowsPlatformTypes.h"
 
// Notes on how the headers and libs are used in UE XAudio2 implementation:
//   Intel Windows:
//     Use the MS XAudio2.9 redist header/library/DLL to guarantee 2.9 on any Windows version
//   Arm64 Windows:
//     Must use the system XAudio2_9.dll. We could use the Win10 SDK's verison of xaudio2.h, however
//     UE includes a copy of the DirectX SDK headers, which will interfere with finding the SDK version.
//     The redist header is usable, however, even tho we are not using the redist libraries. We do not 
//     need to manually load the DLL because linking with the SDK arm64 .lib, without a DELAYLOAD, 
//     will make the OS automatically load the DLL correctly.
//   Consoles:
//     Similar to the Arm64 above, except the copy of DirectX SDK headers are not used, so consoles
//     can use the xaudio2.h from the SDK
#define USE_REDIST_HEADER PLATFORM_WINDOWS
#define USE_REDIST_LIB PLATFORM_WINDOWS && !PLATFORM_CPU_ARM_FAMILY
 
#if USE_REDIST_HEADER
#include <xaudio2redist.h>
#else
#include <xaudio2.h>
#endif
#include "Windows/HideWindowsPlatformTypes.h"
 
#include "Async/Future.h"
 
#ifndef XAUDIO_SUPPORTS_DEVICE_DETAILS
    #define XAUDIO_SUPPORTS_DEVICE_DETAILS      1
#endif  //XAUDIO_SUPPORTS_DEVICE_DETAILS
 
// Any platform defines
namespace Audio
{
    class FMixerPlatformXAudio2;
 
    class FXAudio2VoiceCallback final : public IXAudio2VoiceCallback
    {
    public:
        FXAudio2VoiceCallback() {}
        ~FXAudio2VoiceCallback() {}
 
    private:
        void STDCALL OnVoiceProcessingPassStart(UINT32 BytesRequired) {}
        void STDCALL OnVoiceProcessingPassEnd() {}
        void STDCALL OnStreamEnd() {}
        void STDCALL OnBufferStart(void* BufferContext) {}
        void STDCALL OnLoopEnd(void* BufferContext) {}
        void STDCALL OnVoiceError(void* BufferContext, HRESULT Error) {}
 
        void STDCALL OnBufferEnd(void* BufferContext);
 
    };
 
    struct FXAudio2DeviceSwapContext : public FDeviceSwapContext
    {
        FXAudio2DeviceSwapContext() = delete;
        FXAudio2DeviceSwapContext(const FString& InRequestedDeviceID, const FString& InReason) :
            FDeviceSwapContext(InRequestedDeviceID, InReason)
        {}
        
        bool bUseDefaultDevice = false;
        IXAudio2* PreviousSystem = nullptr;
        IXAudio2MasteringVoice* PreviousMasteringVoice = nullptr;
        IXAudio2SourceVoice* PreviousSourceVoice = nullptr;
        FXAudio2VoiceCallback* Callbacks = nullptr;
        uint32 RenderingSampleRate = 0;
    };
 
    struct FXAudio2DeviceSwapResult : public FDeviceSwapResult
    {
        virtual bool IsNewDeviceReady() const override
        {
            return NewSystem && NewMasteringVoice && NewSourceVoice;
        }
 
        IXAudio2* NewSystem = nullptr;
        IXAudio2MasteringVoice* NewMasteringVoice = nullptr;
        IXAudio2SourceVoice* NewSourceVoice = nullptr;
    };
 
    class FMixerPlatformXAudio2 : public FAudioMixerPlatformSwappable,
                                  public IXAudio2EngineCallback
    {
 
    public:
 
        FMixerPlatformXAudio2();
        virtual ~FMixerPlatformXAudio2() override;
 
        //~ Begin IAudioMixerPlatformInterface
        virtual FString GetPlatformApi() const override { return TEXT("XAudio2"); }
        virtual bool InitializeHardware() override;
        virtual bool CheckAudioDeviceChange() override;
        virtual bool TeardownHardware() override;
        virtual bool IsInitialized() const override;
        virtual bool GetNumOutputDevices(uint32& OutNumOutputDevices) override;
        virtual bool GetOutputDeviceInfo(const uint32 InDeviceIndex, FAudioPlatformDeviceInfo& OutInfo) override;
        virtual FString GetCurrentDeviceName() const override;
        virtual bool GetDefaultOutputDeviceIndex(uint32& OutDefaultDeviceIndex) const override;
        virtual bool OpenAudioStream(const FAudioMixerOpenStreamParams& Params) override;
        virtual bool CloseAudioStream() override;
        virtual bool StartAudioStream() override;
        virtual bool StopAudioStream() override;
        virtual bool MoveAudioStreamToNewAudioDevice() override;
        
        virtual FAudioPlatformDeviceInfo GetPlatformDeviceInfo() const override;
        virtual void SubmitBuffer(const uint8* Buffer) override;
        virtual FString GetDefaultDeviceName() override;
        virtual FAudioPlatformSettings GetPlatformSettings() const override;
        virtual void OnHardwareUpdate() override;
        virtual IAudioPlatformDeviceInfoCache* GetDeviceInfoCache() const override;
        virtual bool IsDeviceInfoValid(const FAudioPlatformDeviceInfo& InDeviceInfo) const override;
        virtual bool ShouldUseDeviceInfoCache() const override { return true; }
        //~ End IAudioMixerPlatformInterface
 
        //~ Begin IAudioMixerDeviceChangedListener
        virtual void RegisterDeviceChangedListener() override;
        virtual void UnregisterDeviceChangedListener() override;
        virtual void OnDefaultCaptureDeviceChanged(const EAudioDeviceRole InAudioDeviceRole, const FString& DeviceId) override;
        virtual void OnDefaultRenderDeviceChanged(const EAudioDeviceRole InAudioDeviceRole, const FString& DeviceId) override;
        virtual void OnDeviceAdded(const FString& DeviceId, bool bIsRenderDevice) override;
        virtual void OnDeviceRemoved(const FString& DeviceId, bool bIsRenderDevice) override;
        virtual void OnDeviceStateChanged(const FString& DeviceId, const EAudioDeviceState InState, bool bIsRenderDevice) override;
        virtual void OnSessionDisconnect(Audio::IAudioMixerDeviceChangedListener::EDisconnectReason InReason) override;
        virtual FString GetDeviceId() const override;       
        //~ End IAudioMixerDeviceChangedListener
 
        //~ Begin FAudioMixerPlatformSwappable
        virtual bool InitializeDeviceSwapContext(const FString& InRequestedDeviceID, const TCHAR* InReason) override;
        virtual bool CheckThreadedDeviceSwap() override;
        virtual bool PreDeviceSwap() override;
        virtual void EnqueueAsyncDeviceSwap() override;
        virtual void SynchronousDeviceSwap() override;
        virtual bool PostDeviceSwap() override;
        //~ End FAudioMixerPlatformSwappable
    
    protected:
        virtual uint32 GetCreateFlags() const { return 0; }
        virtual bool ShouldUseDefaultDevice() const { return false; }
 
        static IXAudio2MasteringVoice* CreateMasteringVoice(IXAudio2& InXAudio2System, const FAudioPlatformDeviceInfo& NewDevice, bool bUseDefaultDevice);
 
        //~ Begin IXAudio2EngineCallback
        virtual void OnCriticalError(HRESULT Error) override;
        virtual void OnProcessingPassStart() override;
        virtual void OnProcessingPassEnd() override;
        //~ End IXAudio2EngineCallback
        
        // Used to teardown and reinitialize XAudio2.
        // This must be done to repopulate the playback device list in XAudio 2.7.
        bool ResetXAudio2System();
 
        bool InitDeviceSwapContextInternal(const FString& InRequestedDeviceID, const TCHAR* InReason, const TOptional<FAudioPlatformDeviceInfo>& InDeviceInfo);
        
        // Handle to XAudio2DLL
        HMODULE XAudio2Dll;
        
        // Bool indicating that the default audio device changed
        // And that we need to restart the audio device.
        UE_DEPRECATED(5.6, "bDeviceChanged has been deprecated.")
        FThreadSafeBool bDeviceChanged;
 
        IXAudio2* XAudio2System;
        IXAudio2MasteringVoice* OutputAudioStreamMasteringVoice;
        IXAudio2SourceVoice* OutputAudioStreamSourceVoice;
        FXAudio2VoiceCallback OutputVoiceCallback;
        
        // When we are running the null device,
        // we check whether a new audio device was connected every second or so.
        float TimeSinceNullDeviceWasLastChecked;
 
        bool FirstBufferSubmitted{false};
 
        TUniquePtr<IAudioPlatformDeviceInfoCache> DeviceInfoCache;
 
        uint32 bIsInitialized : 1;
        uint32 bIsDeviceOpen : 1;
 
    private:
        TUniquePtr<FXAudio2DeviceSwapContext> DeviceSwapContext;
 
        static TUniquePtr<FDeviceSwapResult> PerformDeviceSwap(TUniquePtr<FXAudio2DeviceSwapContext>&& InDeviceContext);
    };
 
}