IAudioEndpoint.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AudioMixerNullDevice.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "DSP/MultithreadedPatching.h"
#include "Features/IModularFeature.h"
#include "Features/IModularFeatures.h"
#include "HAL/CriticalSection.h"
#include "ISoundfieldFormat.h"
#include "Logging/LogMacros.h"
#include "Misc/AssertionMacros.h"
#include "Templates/UniquePtr.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
 
#include "IAudioEndpoint.generated.h"
 
class UClass;
struct FAudioPluginInitializationParams;
template <typename FuncType> class TFunctionRef;
 
DECLARE_LOG_CATEGORY_EXTERN(LogAudioEndpoints, Display, All);
 
class IAudioEndpointSettingsProxy
{
public:
    virtual ~IAudioEndpointSettingsProxy() {}
};
 
UCLASS(config = Engine, abstract, editinlinenew, BlueprintType, MinimalAPI)
class UAudioEndpointSettingsBase : public UObject
{
    GENERATED_BODY()
 
public:
    virtual TUniquePtr<IAudioEndpointSettingsProxy> GetProxy() const PURE_VIRTUAL(UAudioEndpointSettingsBase::GetProxy, return nullptr;);
};
 
//A blank class for when unimplemented endpoint types are returned
class FDummyEndpointSettingsProxy : public IAudioEndpointSettingsProxy
{
};
 
UCLASS()
class UDummyEndpointSettings : public UAudioEndpointSettingsBase
{
    GENERATED_BODY()
 
    public:
        virtual TUniquePtr<IAudioEndpointSettingsProxy> GetProxy() const override;
};
 
class IAudioEndpoint
{
public:
    virtual ~IAudioEndpoint() {};
 
    AUDIOEXTENSIONS_API Audio::FPatchInput PatchNewInput(float ExpectedDurationPerRender, float& OutSampleRate, int32& OutNumChannels);
 
    AUDIOEXTENSIONS_API void SetNewSettings(TUniquePtr<IAudioEndpointSettingsProxy>&& InNewSettings);
 
    AUDIOEXTENSIONS_API void ProcessAudioIfNeccessary();
 
    AUDIOEXTENSIONS_API virtual bool IsImplemented();
 
protected:
 
    AUDIOEXTENSIONS_API virtual float GetSampleRate() const;
 
    AUDIOEXTENSIONS_API virtual int32 GetNumChannels() const;
 
    virtual bool EndpointRequiresCallback() const { return false; }
    virtual int32 GetDesiredNumFrames() const { return 0; }
 
    virtual bool OnAudioCallback(const TArrayView<const float>& InAudio, const int32& NumChannels, const IAudioEndpointSettingsProxy* InSettings) { return false; };
 
    AUDIOEXTENSIONS_API int32 PopAudio(float* OutAudio, int32 NumSamples);
 
    AUDIOEXTENSIONS_API void PollSettings(TFunctionRef<void(const IAudioEndpointSettingsProxy*)> NewSettingsRetrieved);
 
    AUDIOEXTENSIONS_API void DisconnectAllInputs();
 
    AUDIOEXTENSIONS_API void StartRunningAsyncCallback();
    AUDIOEXTENSIONS_API void StopRunningAsyncCallback();
 
    AUDIOEXTENSIONS_API void RunCallbackSynchronously();
 
 
private:
    // Owns a scoped thread and runs OnAudioCallback when StartRunningCallback() is called.
    TUniquePtr<Audio::FMixerNullCallback> RenderCallback;
    
    // If we have a render callback, we pop audio from the PatchMixer to this buffer before calling OnAudioCallback.
    Audio::FAlignedFloatBuffer BufferForRenderCallback;
 
    // Owns the current settings for this endpoint.
    TUniquePtr<IAudioEndpointSettingsProxy> CurrentSettings;
    FCriticalSection CurrentSettingsCriticalSection;
 
    // Object used to mix all inputs together. Polled when OnAudioCallback is executed or when PollAudio is called.
    Audio::FPatchMixer PatchMixer;
};
 
 
class IAudioEndpointFactory : public IModularFeature
{
public:
    virtual ~IAudioEndpointFactory()
    {
    }
 
    AUDIOEXTENSIONS_API virtual FName GetEndpointTypeName();
 
    static AUDIOEXTENSIONS_API FName GetTypeNameForDefaultEndpoint();
 
    static AUDIOEXTENSIONS_API FName GetModularFeatureName();
 
    static AUDIOEXTENSIONS_API void RegisterEndpointType(IAudioEndpointFactory* InFactory);
 
    static AUDIOEXTENSIONS_API void UnregisterEndpointType(IAudioEndpointFactory* InFactory);
 
    static AUDIOEXTENSIONS_API IAudioEndpointFactory* Get(const FName& InName);
 
    static AUDIOEXTENSIONS_API TArray<FName> GetAvailableEndpointTypes();
 
    AUDIOEXTENSIONS_API virtual TUniquePtr<IAudioEndpoint> CreateNewEndpointInstance(const FAudioPluginInitializationParams& InitInfo, const IAudioEndpointSettingsProxy& InitialSettings);
 
    AUDIOEXTENSIONS_API virtual UClass* GetCustomSettingsClass() const;
 
    AUDIOEXTENSIONS_API virtual const UAudioEndpointSettingsBase* GetDefaultSettings() const;
 
    bool bIsImplemented = false;
 
    static AUDIOEXTENSIONS_API IAudioEndpointFactory* GetDummyFactory();
};