ISoundfieldEndpoint.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 "CoreMinimal.h"
#include "CoreTypes.h"
#include "DSP/MultithreadedPatching.h"
#include "Features/IModularFeatures.h"
#include "HAL/CriticalSection.h"
#include "HAL/ThreadSafeCounter.h"
#include "ISoundfieldFormat.h"
#include "Misc/AssertionMacros.h"
#include "Templates/SubclassOf.h"
#include "Templates/UniquePtr.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
 
#include "ISoundfieldEndpoint.generated.h"
 
class UClass;
struct FAudioPluginInitializationParams;
template <typename FuncType> class TFunctionRef;
 
 
class ISoundfieldEndpointSettingsProxy
{
public:
    virtual ~ISoundfieldEndpointSettingsProxy() {};
};
 
UCLASS(config = Engine, abstract, editinlinenew, BlueprintType, MinimalAPI)
class USoundfieldEndpointSettingsBase : public UObject
{
    GENERATED_BODY()
 
public:
    virtual TUniquePtr<ISoundfieldEndpointSettingsProxy> GetProxy() const PURE_VIRTUAL(USoundfieldEndpointSettingsBase::GetProxy, return nullptr;);
};
 
class ISoundfieldEndpoint
{
public:
    AUDIOEXTENSIONS_API ISoundfieldEndpoint(int32 NumRenderCallbacksToBuffer);
 
    virtual ~ISoundfieldEndpoint() {};
 
    AUDIOEXTENSIONS_API bool PushAudio(TUniquePtr<ISoundfieldAudioPacket>&& InPacket);
 
    AUDIOEXTENSIONS_API void SetNewSettings(TUniquePtr<ISoundfieldEndpointSettingsProxy>&& InNewSettings);
 
    // Returns the amount of ISoundfieldAudioPackets currently buffered for this endpoint.
    AUDIOEXTENSIONS_API int32 GetNumPacketsBuffer();
 
    // Returns the amount of ISoundfieldAudioPackets that can be buffered for this endpoint before reaching capacity.
    AUDIOEXTENSIONS_API int32 GetRemainderInPacketBuffer();
 
    AUDIOEXTENSIONS_API void ProcessAudioIfNecessary();
 
protected:
 
    virtual bool EndpointRequiresCallback() const { return false; }
 
    virtual float GetDesiredCallbackPeriodicity() const { return 0; }
 
    virtual void OnAudioCallback(TUniquePtr<ISoundfieldAudioPacket>&& InPacket, const ISoundfieldEndpointSettingsProxy* InSettings) { return; };
 
    AUDIOEXTENSIONS_API TUniquePtr<ISoundfieldAudioPacket> PopAudio();
 
    AUDIOEXTENSIONS_API void PollSettings(TFunctionRef<void(const ISoundfieldEndpointSettingsProxy*)> SettingsCallback);
 
    AUDIOEXTENSIONS_API void StartRunningCallback();
    AUDIOEXTENSIONS_API void StopRunningCallback();
 
    AUDIOEXTENSIONS_API void RunCallbackSynchronously();
 
private:
    // Owns a scoped thread and runs OnAudioCallback when StartRunningCallback() is called.
    TUniquePtr<Audio::FMixerNullCallback> RenderCallback;
    
    // This array is used as a non-copying circular buffer for ISoundfieldAudioPackets.
    TArray<TUniquePtr<ISoundfieldAudioPacket>> AudioPacketBuffer;
    FThreadSafeCounter ReadCounter;
    FThreadSafeCounter WriteCounter;
 
    // Owns the current settings for this endpoint.
    TUniquePtr<ISoundfieldEndpointSettingsProxy> CurrentSettings;
    FCriticalSection CurrentSettingsCriticalSection;
};
 
class ISoundfieldEndpointFactory : public ISoundfieldFactory
{
public:
    virtual ~ISoundfieldEndpointFactory()
    {
    }
 
    virtual FName GetEndpointTypeName() = 0;
 
    static FName GetModularFeatureName()
    {
        static FName SoundfieldEndpointName = FName(TEXT("Soundfield Endpoint"));
        return SoundfieldEndpointName;
    }
 
    static void RegisterEndpointType(ISoundfieldEndpointFactory* InFactory)
    {
        IModularFeatures::Get().RegisterModularFeature(GetModularFeatureName(), InFactory);
    }
 
    static void UnregisterEndpointType(ISoundfieldEndpointFactory* InFactory)
    {
        IModularFeatures::Get().UnregisterModularFeature(GetModularFeatureName(), InFactory);
    }
 
    static AUDIOEXTENSIONS_API ISoundfieldEndpointFactory* Get(const FName& InName);
 
    static AUDIOEXTENSIONS_API TArray<FName> GetAllSoundfieldEndpointTypes();
 
    static AUDIOEXTENSIONS_API FName DefaultSoundfieldEndpointName();
 
    AUDIOEXTENSIONS_API TUniquePtr<ISoundfieldDecoderStream> CreateDecoderStream(const FAudioPluginInitializationParams& InitInfo, const ISoundfieldEncodingSettingsProxy& InitialSettings) override;
 
    virtual TUniquePtr<ISoundfieldEndpoint> CreateNewEndpointInstance(const FAudioPluginInitializationParams& InitInfo, const ISoundfieldEndpointSettingsProxy& InitialSettings) = 0;
 
 
    virtual UClass* GetCustomEndpointSettingsClass() const
    {
        return nullptr;
    }
 
    virtual USoundfieldEndpointSettingsBase* GetDefaultEndpointSettings() = 0;
 
    bool IsEndpointFormat() override { return true; }
 
    AUDIOEXTENSIONS_API virtual FName GetSoundfieldFormatName() override;
    AUDIOEXTENSIONS_API virtual bool CanTranscodeToSoundfieldFormat(FName DestinationFormat, const ISoundfieldEncodingSettingsProxy& DestinationEncodingSettings) override;
};