Audio.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    Audio.h: Unreal base audio.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "AudioDefines.h"
#include "Stats/Stats.h"
#include "HAL/ThreadSafeBool.h"
#include "Sound/AudioOutputTarget.h"
#include "Sound/QuartzQuantizationUtilities.h"
#include "Sound/SoundAttenuation.h"
#include "Sound/SoundEffectSource.h"
#include "Sound/SoundModulationDestination.h"
#include "Sound/SoundSubmixSend.h"
#include "Sound/SoundSourceBusSend.h"
#include "IAudioExtensionPlugin.h"
#include "IAudioModulation.h"
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogAudio, Display, All);
 
// Special log category used for temporary programmer debugging code of audio
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogAudioDebug, Display, All);
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Active Sounds"), STAT_ActiveSounds, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Audio Evaluate Concurrency"), STAT_AudioEvaluateConcurrency, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Audio Sources"), STAT_AudioSources, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Wave Instances"), STAT_WaveInstances, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Wave Instances Dropped"), STAT_WavesDroppedDueToPriority, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Virtualized Loops"), STAT_AudioVirtualLoops, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Audible Wave Instances Dropped"), STAT_AudibleWavesDroppedDueToPriority, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Max Channels"), STAT_AudioMaxChannels, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Max Stopping Sources"), STAT_AudioMaxStoppingSources, STATGROUP_Audio, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Finished delegates called"), STAT_AudioFinishedDelegatesCalled, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Finished delegates time"), STAT_AudioFinishedDelegates, STATGROUP_Audio, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("Audio Memory Used"), STAT_AudioMemorySize, STATGROUP_Audio, );
DECLARE_FLOAT_ACCUMULATOR_STAT_EXTERN(TEXT("Audio Buffer Time"), STAT_AudioBufferTime, STATGROUP_Audio, );
DECLARE_FLOAT_ACCUMULATOR_STAT_EXTERN(TEXT("Audio Buffer Time (w/ Channels)"), STAT_AudioBufferTimeChannels, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Gathering WaveInstances"), STAT_AudioGatherWaveInstances, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Processing Sources"), STAT_AudioStartSources, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Updating Sources"), STAT_AudioUpdateSources, STATGROUP_Audio, ENGINE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Updating Effects"), STAT_AudioUpdateEffects, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Source Init"), STAT_AudioSourceInitTime, STATGROUP_Audio, ENGINE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Source Create"), STAT_AudioSourceCreateTime, STATGROUP_Audio, ENGINE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Submit Buffers"), STAT_AudioSubmitBuffersTime, STATGROUP_Audio, ENGINE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Decompress Audio"), STAT_AudioDecompressTime, STATGROUP_Audio, ENGINE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Prepare Audio Decompression"), STAT_AudioPrepareDecompressionTime, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Finding Nearest Location"), STAT_AudioFindNearestLocation, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Decompress Streamed"), STAT_AudioStreamedDecompressTime, STATGROUP_Audio, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Buffer Creation"), STAT_AudioResourceCreationTime, STATGROUP_Audio, );
 
 
class FAudioDevice;
class USoundNode;
class USoundWave;
class USoundClass;
class USoundSubmix;
class USoundSourceBus;
class UAudioLinkSettingsAbstract;
struct FActiveSound;
struct FWaveInstance;
struct FSoundSourceBusSendInfo;
 
enum EAudioSpeakers : int
{                           //  4.0 5.1 6.1 7.1
    SPEAKER_FrontLeft,      //  *   *   *   *
    SPEAKER_FrontRight,     //  *   *   *   *
    SPEAKER_FrontCenter,    //      *   *   *
    SPEAKER_LowFrequency,   //      *   *   *
    SPEAKER_LeftSurround,   //  *   *   *   *
    SPEAKER_RightSurround,  //  *   *   *   *
    SPEAKER_LeftBack,       //          *   *       If there is no BackRight channel, this is the BackCenter channel
    SPEAKER_RightBack,      //              *
    SPEAKER_Count
};
 
// Forward declarations.
class UAudioComponent;
class USoundNode;
struct FWaveInstance;
struct FReverbSettings;
struct FSampleLoop;
struct FSoundWaveTimecodeInfo;
enum ELoopingMode
{
    LOOP_Never,
    LOOP_WithNotification,
    LOOP_Forever
};
 
struct FNotifyBufferFinishedHooks
{
    ENGINE_API void AddNotify(USoundNode* NotifyNode, UPTRINT WaveInstanceHash);
    ENGINE_API UPTRINT GetHashForNode(USoundNode* NotifyNode) const;
    ENGINE_API void AddReferencedObjects( FReferenceCollector& Collector );
    ENGINE_API void DispatchNotifies(FWaveInstance* WaveInstance, const bool bStopped);
 
    friend FArchive& operator<<( FArchive& Ar, FNotifyBufferFinishedHooks& WaveInstance );
 
private:
 
    struct FNotifyBufferDetails
    {
        TObjectPtr<USoundNode> NotifyNode;
        UPTRINT NotifyNodeWaveInstanceHash;
 
        FNotifyBufferDetails()
            : NotifyNode(nullptr)
            , NotifyNodeWaveInstanceHash(0)
        {
        }
 
        FNotifyBufferDetails(USoundNode* InNotifyNode, UPTRINT InHash)
            : NotifyNode(InNotifyNode)
            , NotifyNodeWaveInstanceHash(InHash)
        {
        }
    };
 
 
    TArray<FNotifyBufferDetails> Notifies;
};
 
ENGINE_API bool IsAudioPluginEnabled(EAudioPlugin PluginType);
ENGINE_API UClass* GetAudioPluginCustomSettingsClass(EAudioPlugin PluginType);
 
ENGINE_API bool IsSpatializationCVarEnabled();
 
class ISourceBufferListener
{
public:
    virtual ~ISourceBufferListener() = default;
 
    struct FOnNewBufferParams
    {
        const float* AudioData = nullptr;
        int32 SourceId = INDEX_NONE;
        int32 NumSamples = 0;
        int32 NumChannels = 0;
        int32 SampleRate = 0;
    };
    virtual void OnNewBuffer(const FOnNewBufferParams&) = 0;
    virtual void OnSourceReleased(const int32 InSourceId) = 0;
};
using FSharedISourceBufferListenerPtr = TSharedPtr<ISourceBufferListener, ESPMode::ThreadSafe>;
 
enum class EBusSendType : uint8
{
    PreEffect,
    PostEffect,
    Count
};
 
struct FWaveInstance
{
private:
    static ENGINE_API uint32 PlayOrderCounter;
 
public:
    TObjectPtr<USoundWave> WaveData;
 
    TObjectPtr<USoundClass> SoundClass;
 
    USoundSubmixBase* SoundSubmix;
 
    TArray<FSoundSubmixSendInfo> SoundSubmixSends;
 
    TArray<FSoundSourceBusSendInfo> BusSends[(int32)EBusSendType::Count];
 
    USoundEffectSourcePresetChain* SourceEffectChain;
 
    FNotifyBufferFinishedHooks NotifyBufferFinishedHooks;
 
    FActiveSound* ActiveSound;
 
    TUniquePtr<Audio::FQuartzQuantizedRequestData> QuantizedRequestData;
 
    FSharedISourceBufferListenerPtr SourceBufferListener;
    bool bShouldSourceBufferListenerZeroBuffer = false;
 
    bool bShouldUseAudioLink = true;
    UAudioLinkSettingsAbstract* AudioLinkSettingsOverride = nullptr;
 
private:
 
    float Volume;
 
    float DistanceAttenuation;
 
    float OcclusionAttenuation;
 
    float VolumeMultiplier;
 
    float EnvelopValue;
 
    float RelativeRenderCost;
 
public:
    int32 EnvelopeFollowerAttackTime;
 
    int32 EnvelopeFollowerReleaseTime;
 
    float Priority;
 
    float VoiceCenterChannelVolume;
 
    float RadioFilterVolume;
 
    float RadioFilterVolumeThreshold;
 
    float LFEBleed;
 
    ELoopingMode LoopingMode;
 
    float StartTime;
 
    uint32 bEnableBusSends : 1;
 
    uint32 bEnableBaseSubmix : 1;
 
    uint32 bEnableSubmixSends : 1;
 
    uint32 bEnableSourceDataOverride : 1;
 
    uint32 bApplyRadioFilter:1;
 
    uint32 bIsStarted:1;
 
    uint32 bIsFinished:1;
 
    uint32 bAlreadyNotifiedHook:1;
 
    uint32 bSpatializationIsExternalSend : 1;
 
private:
    uint32 bUseSpatialization:1;
 
public:
    uint32 bEnableLowPassFilter:1;
    
    uint32 bEnableHighPassFilter:1;
 
    uint32 bIsOccluded:1;
 
    uint32 bIsUISound:1;
 
    uint32 bIsMusic:1;
 
    uint32 bReverb:1;
 
    uint32 bCenterChannelOnly:1;
 
    uint32 bIsPaused:1;
 
    uint32 bReportedSpatializationWarning:1;
 
    uint32 bIsAmbisonics:1;
 
    uint32 bIsStopping:1;
 
    uint32 bIsDynamic:1;
 
    ESoundSpatializationAlgorithm SpatializationMethod;
 
    USpatializationPluginSourceSettingsBase* SpatializationPluginSettings;
 
    UOcclusionPluginSourceSettingsBase* OcclusionPluginSettings;
 
    UReverbPluginSourceSettingsBase* ReverbPluginSettings;
 
    USourceDataOverridePluginSourceSettingsBase* SourceDataOverridePluginSettings;
 
    EAudioOutputTarget::Type OutputTarget;
 
    float LowPassFilterFrequency;
    
    float HighPassFilterFrequency;
 
    float SoundClassFilterFrequency;
 
    float OcclusionFilterFrequency;
 
    float AmbientZoneFilterFrequency;
 
    float AttenuationLowpassFilterFrequency;
 
    float AttenuationHighpassFilterFrequency;
 
    float Pitch;
 
    FVector Location;
 
    float NonSpatializedRadiusStart;
 
    float NonSpatializedRadiusEnd;
 
    ENonSpatializedRadiusSpeakerMapMode NonSpatializedRadiusMode;
 
    float StereoSpread;
 
    float AttenuationDistance;
 
    float ListenerToSoundDistance;
 
    float ListenerToSoundDistanceForPanning;
 
    float AbsoluteAzimuth; 
 
    float PlaybackTime;
 
    float PlaybackPercent;
    
    float ReverbSendLevel;
 
    float ManualReverbSendLevel;
    
    TArray<FAttenuationSubmixSendSettings> AttenuationSubmixSends;
 
private:
    uint32 PlayOrder;
 
public:
    UPTRINT WaveInstanceHash;
 
    uint8 UserIndex;
 
    ENGINE_API FWaveInstance(const UPTRINT InWaveInstanceHash, FActiveSound& ActiveSound);
 
    ENGINE_API FWaveInstance(FWaveInstance&&);
    ENGINE_API FWaveInstance& operator=(FWaveInstance&&);
 
    ENGINE_API void StopWithoutNotification();
 
    ENGINE_API void NotifyFinished(const bool bStopped = false);
 
    friend FArchive& operator<<(FArchive& Ar, FWaveInstance* WaveInstance);
 
    ENGINE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
    ENGINE_API bool ShouldStopDueToMaxConcurrency() const;
 
    void SetVolume(const float InVolume) { Volume = InVolume; }
    void SetDistanceAttenuation(const float InDistanceAttenuation) { DistanceAttenuation = InDistanceAttenuation; }
    void SetOcclusionAttenuation(const float InOcclusionAttenuation) { OcclusionAttenuation = InOcclusionAttenuation; }
    void SetPitch(const float InPitch) { Pitch = InPitch; }
    void SetVolumeMultiplier(const float InVolumeMultiplier) { VolumeMultiplier = InVolumeMultiplier; }
 
    void SetStopping(const bool bInIsStopping) { bIsStopping = bInIsStopping; }
    bool IsStopping() const { return bIsStopping; }
 
    ENGINE_API bool IsPlaying() const;
 
    float GetVolumeMultiplier() const { return VolumeMultiplier; }
 
    ENGINE_API float GetActualVolume() const;
 
    ENGINE_API float GetVolumeWithDistanceAndOcclusionAttenuation() const;
 
    ENGINE_API float GetDistanceAndOcclusionAttenuation() const;
 
    ENGINE_API float GetDistanceAttenuation() const;
 
    ENGINE_API float GetOcclusionAttenuation() const;
 
    ENGINE_API float GetDynamicVolume() const;
 
    ENGINE_API float GetPitch() const;
 
    ENGINE_API float GetVolume() const;
 
    ENGINE_API float GetVolumeWeightedPriority() const;
 
    ENGINE_API bool IsSeekable() const;
 
    ENGINE_API bool IsStreaming() const;
 
    ENGINE_API FString GetName() const;
 
    void SetEnvelopeValue(const float InEnvelopeValue) { EnvelopValue = InEnvelopeValue; }
 
    float GetEnvelopeValue() const { return EnvelopValue; }
 
    void SetUseSpatialization(const bool InUseSpatialization) { bUseSpatialization = InUseSpatialization; }
 
    ENGINE_API bool GetUseSpatialization() const;
 
    void SetSpatializationIsExternalSend(const bool InSpatializationIsExternalSend) { bSpatializationIsExternalSend = InSpatializationIsExternalSend; }
 
    bool GetSpatializationIsExternalSend() const {  return bSpatializationIsExternalSend;}
 
    uint32 GetPlayOrder() const { return PlayOrder; }
 
    friend inline uint32 GetTypeHash(FWaveInstance* A) { return A->PlayOrder; }
 
    void SetRelativeRenderCost(float InRelativeRenderCost) { RelativeRenderCost = InRelativeRenderCost; }
 
    float GetRelativeRenderCost() const { return RelativeRenderCost; }
 
    ENGINE_API float GetEffectiveModulationValue(const EModulationDestination InDestination) const;
 
    ENGINE_API FSoundModulationDestinationSettings GetEffectiveModulationSettings(const EModulationDestination InDestination) const;
 
private:
    static Audio::FModulationParameter GetParameterBasedOnDestination(const EModulationDestination InDestination);
 
    void CalculateInheritedModulationSettingsAndValue(const EModulationDestination InDestination, FSoundModulationDestinationSettings& InOutSettings, float& OutValue) const;
};
 
/*-----------------------------------------------------------------------------
    FSoundBuffer.
-----------------------------------------------------------------------------*/
 
class FSoundBuffer
{
public:
    FSoundBuffer(class FAudioDevice * InAudioDevice)
        : ResourceID(0)
        , NumChannels(0)
        , bAllocationInPermanentPool(false)
        , AudioDevice(InAudioDevice)
    {
 
    }
 
    ENGINE_API virtual ~FSoundBuffer();
 
    virtual int32 GetSize() PURE_VIRTUAL(FSoundBuffer::GetSize,return 0;);
 
    ENGINE_API virtual FString Describe(bool bUseLongName);
 
    FName GetSoundClassName();
 
    FString GetChannelsDesc();
 
    virtual bool ReadCompressedInfo(USoundWave* SoundWave) { return true; }
 
    virtual bool ReadCompressedData(uint8* Destination, int32 NumFramesToDecode, bool bLooping) { return true; }
    
    virtual void Seek(const float SeekTime) {}
 
    virtual int32 GetCurrentChunkIndex() const {return -1;}
 
    virtual int32 GetCurrentChunkOffset() const {return -1;}
 
    virtual bool IsRealTimeSourceReady() { return true; }
 
    virtual void EnsureRealtimeTaskCompletion() { }
 
    int32   ResourceID;
    int32   NumChannels;
    FString ResourceName;
    bool    bAllocationInPermanentPool;
    class FAudioDevice * AudioDevice;
};
 
/*-----------------------------------------------------------------------------
FSoundSource.
-----------------------------------------------------------------------------*/
 
class FSoundSource
{
public:
    FSoundSource(FAudioDevice* InAudioDevice)
        : AudioDevice(InAudioDevice)
        , WaveInstance(nullptr)
        , LFEBleed(0.5f)
        , LPFFrequency(MAX_FILTER_FREQUENCY)
        , HPFFrequency(MIN_FILTER_FREQUENCY)
        , PlaybackTime(0.0f)
        , Pitch(1.0f)
        , LastUpdate(0)
        , LastHeardUpdate(0)
        , TickCount(0)
        , LeftChannelSourceLocation(0)
        , RightChannelSourceLocation(0)
        , NumFramesPlayed(0)
        , NumTotalFrames(1)
        , StartFrame(0)
        , VoiceId(-1)
        , Playing(false)
        , bReverbApplied(false)
        , bIsPausedByGame(false)
        , bIsManuallyPaused(false)
        , Paused(false)
        , bInitialized(true) // Note: this is defaulted to true since not all platforms need to deal with async initialization.
        , bIsPreviewSound(false)
        , bIsVirtual(false)
    {
    }
 
    ENGINE_API virtual ~FSoundSource();
 
    /* Prepares the source voice for initialization. This may parse a compressed asset header on some platforms */
    virtual bool PrepareForInitialization(FWaveInstance* InWaveInstance) { return true; }
 
    virtual bool IsPreparedToInit() { return true; }
 
    virtual bool Init(FWaveInstance* InWaveInstance) = 0;
 
    virtual bool IsInitialized() const { return bInitialized; };
 
    virtual void Update() = 0;
 
    virtual void Play() = 0;
 
    ENGINE_API virtual void Stop();
 
    virtual void StopNow() { Stop(); };
 
    virtual bool IsStopping() { return false; }
 
    virtual bool IsFinished() = 0;
    
    void SetPauseByGame(bool bInIsPauseByGame);
 
    void SetPauseManually(bool bInIsPauseManually);
 
    ENGINE_API virtual FString Describe(bool bUseLongName);
 
    bool IsGameOnly() const;
 
    const FWaveInstance* GetWaveInstance() const { return WaveInstance; }
 
    bool IsPlaying() const { return Playing; }
 
    bool IsPaused() const { return Paused; }
    
    bool IsPausedByGame() const { return bIsPausedByGame; }
 
    bool IsPausedManually() const { return bIsManuallyPaused; }
 
    bool IsReverbApplied() const { return bReverbApplied; }
 
    ENGINE_API bool SetReverbApplied(bool bHardwareAvailable);
 
    ENGINE_API float SetLFEBleed();
 
    ENGINE_API void SetFilterFrequency();
 
    ENGINE_API void UpdateStereoEmitterPositions();
 
    ENGINE_API FSpatializationParams GetSpatializationParams();
 
    UE_DEPRECATED(5.5, "The Buffer member no longer exists.  Use GetNumChannels() to qeury channel count.")
    virtual const FSoundBuffer* GetBuffer() const { return nullptr; }
 
    int32 GetNumChannels() const { return NumChannels; }
 
    virtual void InitializeSourceEffects(uint32 InEffectVoiceId)
    {
    }
 
    void SetVirtual()
    {
        bIsVirtual = true;
    }
 
    ENGINE_API virtual float GetPlaybackPercent() const;
 
    ENGINE_API virtual float GetSourceSampleRate() const;
 
    ENGINE_API virtual int64 GetNumFramesPlayed() const;
 
    ENGINE_API virtual int32 GetNumTotalFrames() const;
 
    ENGINE_API virtual int32 GetStartFrame() const;
 
    virtual float GetEnvelopeValue() const { return 0.0f; };
 
    virtual float GetRelativeRenderCost() const { return 1.0f; }
 
    ENGINE_API void GetChannelLocations(FVector& Left, FVector&Right) const;
 
    void NotifyPlaybackData();
 
protected:
 
    ENGINE_API void InitCommon();
 
    ENGINE_API void UpdateCommon();
 
    virtual void Pause() = 0;
 
    void UpdatePause();
 
    ENGINE_API float GetDebugVolume(const float InVolume);
 
    FAudioDevice* AudioDevice;
 
    FWaveInstance* WaveInstance;
 
    UE_DEPRECATED(5.5, "This is no longer used and should not be accessed directly.")
    FSoundBuffer* Buffer;
 
    float LFEBleed;
 
    float LPFFrequency;
 
    float HPFFrequency;
 
    UE_DEPRECATED(5.6, "This Variable duplicates cache behavior used at source voice level")
    float LastLPFFrequency=MAX_FILTER_FREQUENCY;
 
    UE_DEPRECATED(5.6, "This Variable duplicates cache behavior used at source voice level")
    float LastHPFFrequency=MIN_FILTER_FREQUENCY;
 
    float PlaybackTime;
 
    float Pitch;
 
    int32 LastUpdate;
 
    int32 LastHeardUpdate;
 
    int32 TickCount;
 
    FVector LeftChannelSourceLocation;
 
    FVector RightChannelSourceLocation;
 
    int32 NumFramesPlayed;
 
    int32 NumTotalFrames;
 
    int32 StartFrame;
 
    int32 NumChannels = 0;
 
    uint32 VoiceId;
 
    FThreadSafeBool Playing;
 
    uint8 bReverbApplied : 1;
 
    uint8 bIsPausedByGame : 1;
 
    uint8 bIsManuallyPaused : 1;
 
    uint8 Paused : 1;
 
    uint8 bInitialized : 1;
 
    uint8 bIsPreviewSound : 1;
 
    uint32 bIsVirtual : 1;
 
    friend class FAudioDevice;
    friend struct FActiveSound;
 
#if ENABLE_AUDIO_DEBUG
public:
 
    struct FDebugInfo
    {
        bool bIsSoloed = false;
 
        bool bIsMuted = false;
 
        FString MuteSoloReason;
 
        double CPUCoreUtilization = 0;
 
        float RelativeRenderCost = 1.f;
 
        FCriticalSection CS;
    };
    
    TSharedPtr<FDebugInfo, ESPMode::ThreadSafe> DebugInfo;
    friend struct FDebugInfo;
#endif //ENABLE_AUDIO_DEBUG
};
 
// Data representing a cue in a wave file
struct FWaveCue
{
    // Unique identifying gvalue for the cue
    uint32 CuePointID = 0;
    // Sample offset associated with the cue point
    uint32 Position = 0;
    // Cue label
    FString Label;
    // If this is a region, it will have a duration (sample length)
    uint32 SampleLength = 0;
};
 
// data representing a sample loop in a wave file
struct FWaveSampleLoop
{
    uint32 LoopID = 0;
    uint32 StartFrame = 0;
    uint32 EndFrame = 0;
};
 
//
// Structure for in-memory interpretation and modification of WAVE sound structures.
//
class FWaveModInfo
{
public:
 
    // Format specifiers
    static constexpr uint16 WAVE_INFO_FORMAT_PCM = 0x0001;
    static constexpr uint16 WAVE_INFO_FORMAT_ADPCM = 0x0002;
    static constexpr uint16 WAVE_INFO_FORMAT_IEEE_FLOAT = 0x0003;
    static constexpr uint16 WAVE_INFO_FORMAT_DVI_ADPCM = 0x0011;
    static constexpr uint16 WAVE_INFO_FORMAT_OODLE_WAVE = 0xFFFF;
 
    // Pointers to variables in the in-memory WAVE file.
    const uint32* pSamplesPerSec;
    const uint32* pAvgBytesPerSec;
    const uint16* pBlockAlign;
    const uint16* pBitsPerSample;
    const uint16* pChannels;
    uint16* pFormatTag;
 
    const uint32* pWaveDataSize;
    const uint32* pMasterSize;
    const uint8*  SampleDataStart;
    const uint8*  SampleDataEnd;
    uint32  SampleDataSize;
    const uint8*  WaveDataEnd;
 
    uint32  NewDataSize;
 
    // List of cues parsed from the wave file
    TArray<FWaveCue> WaveCues;
 
    // List of sample loops parsed from the wave file
    TArray<FWaveSampleLoop> WaveSampleLoops;
 
    // Timecode data if it was found on import.
    TPimplPtr<FSoundWaveTimecodeInfo, EPimplPtrMode::DeepCopy> TimecodeInfo;
 
    // Constructor.
    FWaveModInfo()
    {
    }
    
    // 16-bit padding.
    static uint32 Pad16Bit( uint32 InDW )
    {
        return ((InDW + 1)& ~1);
    }
 
    ENGINE_API static const TArray<uint32>& GetRequiredWaveChunkIds();
    ENGINE_API static const TArray<uint32>& GetOptionalWaveChunkIds();
    ENGINE_API static const uint32 GetChunkId(const char ChunkID[4]);
 
    // Read headers and load all info pointers in WaveModInfo. 
    // Returns 0 if invalid data encountered.
    ENGINE_API bool ReadWaveInfo(const uint8* WaveData, int32 WaveDataSize, FString* ErrorMessage = NULL, bool InHeaderDataOnly = false, void** OutFormatHeader = NULL );
    
    ENGINE_API bool ReadWaveHeader(const uint8* RawWaveData, int32 Size, int32 Offset );
 
    ENGINE_API void ReportImportFailure() const;
 
    ENGINE_API uint32 GetNumSamples() const;
 
    ENGINE_API bool IsFormatSupported() const;
    ENGINE_API bool IsFormatUncompressed() const;
 
};
 
ENGINE_API void SerializeWaveFile(TArray<uint8>& OutWaveFileData, const uint8* InPCMData, const int32 NumBytes, const int32 NumChannels, const int32 SampleRate);
 
ENGINE_API void SetCompressedAudioFormatsToBuild(const TCHAR* Platform = NULL);
 
ENGINE_API const TArray<FName>& GetCompressedAudioFormatsToBuild();