SoundWave.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/IndirectArray.h"
#include "Sound/AudioSettings.h"
#include "Sound/SoundModulationDestination.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "Async/AsyncWork.h"
#include "Async/Mutex.h"
#include "Async/UniqueLock.h"
#include "Sound/SoundBase.h"
#include "Sound/SoundWaveTimecodeInfo.h"
#include "Interfaces/Interface_AsyncCompilation.h"
#include "Serialization/BulkData.h"
#include "Serialization/BulkDataBuffer.h"
#include "Serialization/EditorBulkData.h"
#include "Sound/SoundGroups.h"
#include "Sound/SoundWaveLoadingBehavior.h"
#include "UObject/ObjectKey.h"
#include "AudioMixerTypes.h"
#include "AudioCompressionSettings.h"
#include "UObject/PerPlatformProperties.h"
#include "ContentStreaming.h"
#include "IAudioProxyInitializer.h"
#include "IWaveformTransformation.h"
#include "ISoundWaveCloudStreaming.h"
#include "Templates/DontCopy.h"
#include "SoundWave.generated.h"
 
class FSoundWaveData;
class ITargetPlatform;
enum EAudioSpeakers : int;
struct FActiveSound;
struct FSoundParseParameters;
struct FPlatformAudioCookOverrides;
 
UENUM()
enum EDecompressionType : int
{
    DTYPE_Setup,
    DTYPE_Invalid,
    DTYPE_RealTime,
    DTYPE_Procedural,
    DTYPE_Xenon,
    DTYPE_Streaming,
    DTYPE_MAX,
};
 
inline const TCHAR* LexToString(const EDecompressionType InType)
{
#define CASE_TO_STRING(X) case X: return TEXT(#X);
    switch(InType)
    {
        FOREACH_ENUM_EDECOMPRESSIONTYPE(CASE_TO_STRING);
        default: break;
    }
    return TEXT("Unknown");
#undef CASE_TO_STRING
}
 
UENUM()
enum class ESoundWaveCuePointOrigin : uint8
{
    WaveFile = 0,
    MarkerTransformation,
};
 
enum class ESoundWavePrecacheState
{
    NotStarted,
    InProgress,
    Done
};
 
inline constexpr uint64 InvalidAudioStreamCacheLookupID = TNumericLimits<uint64>::Max();
 
struct FStreamedAudioChunk
{
    void Serialize(FArchive& Ar, UObject* Owner, int32 ChunkIndex);
 
    bool GetCopy(void** OutChunkData);
 
    /* Moves the memory out of the byte bulk-data. (Does copy with Discard original) */
    FBulkDataBuffer<uint8> MoveOutAsBuffer();
 
    int32 DataSize = 0;
 
    int32 AudioDataSize = 0;
 
    uint32 SeekOffsetInAudioFrames = uint32(INDEX_NONE);
 
    FByteBulkData BulkData;
 
private:
    uint8* CachedDataPtr{ nullptr };
 
public:
 
#if WITH_EDITORONLY_DATA
    FString DerivedDataKey;
 
    bool bLoadedFromCookedPackage = false;
 
    bool bInlineChunk = false;
 
    uint32 StoreInDerivedDataCache(const FString& InDerivedDataKey, const FStringView& SoundWaveName);
#endif // #if WITH_EDITORONLY_DATA
};
 
USTRUCT()
struct FStreamedAudioPlatformData
{
    GENERATED_USTRUCT_BODY()
 
    
    FName AudioFormat;
    TIndirectArray<struct FStreamedAudioChunk> Chunks;
 
#if WITH_EDITORONLY_DATA
    FString DerivedDataKey;
    mutable TDontCopy<FRWLock> AsyncTaskLock;
    struct FStreamedAudioAsyncCacheDerivedDataTask* AsyncTask;
#endif // #if WITH_EDITORONLY_DATA
 
    ENGINE_API FStreamedAudioPlatformData();
 
    ENGINE_API ~FStreamedAudioPlatformData();
 
    ENGINE_API int32 GetChunkFromDDC(int32 ChunkIndex, uint8** OutChunkData, bool bMakeSureChunkIsLoaded = false);
 
    ENGINE_API TIndirectArray<struct FStreamedAudioChunk>& GetChunks() const;
 
    ENGINE_API int32 GetNumChunks() const;
 
    ENGINE_API FName GetAudioFormat() const;
 
    ENGINE_API void Serialize(FArchive& Ar, class USoundWave* Owner);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void Cache(class USoundWave& InSoundWave, const FPlatformAudioCookOverrides* CompressionOverrides, FName AudioFormatName, uint32 InFlags, const ITargetPlatform* InTargetPlatform=nullptr);
    ENGINE_API void FinishCache();
    ENGINE_API bool IsFinishedCache() const;
    ENGINE_API bool IsAsyncWorkComplete() const;
    ENGINE_API bool IsCompiling() const;
    ENGINE_API bool TryInlineChunkData();
 
    UE_DEPRECATED(5.0, "Use AreDerivedChunksAvailable with the context instead.")
    ENGINE_API bool AreDerivedChunksAvailable() const;
    
    ENGINE_API bool AreDerivedChunksAvailable(FStringView Context) const;
#endif // WITH_EDITORONLY_DATA
 
private:
#if WITH_EDITORONLY_DATA
    friend class USoundWave;
    ENGINE_API bool RescheduleAsyncTask(FQueuedThreadPool* InThreadPool, EQueuedWorkPriority InPriority);
    ENGINE_API bool WaitAsyncTaskWithTimeout(float InTimeoutInSeconds);
#endif
 
    ENGINE_API int32 DeserializeChunkFromDDC(TArray<uint8> SerializedData, FStreamedAudioChunk &ChunkToDeserializeInto, int32 ChunkIndex, uint8** &OutChunkData);
};
 
USTRUCT(BlueprintType)
struct FSoundWaveSpectralData
{
    GENERATED_USTRUCT_BODY()
 
    // The frequency (in Hz) of the spectrum value
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpectralData")
    float FrequencyHz = 0.0f;
 
    // The magnitude of the spectrum at this frequency
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpectralData")
    float Magnitude = 0.0f;
 
    // The normalized magnitude of the spectrum at this frequency
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpectralData")
    float NormalizedMagnitude = 0.0f;
};
 
USTRUCT(BlueprintType)
struct FSoundWaveSpectralDataPerSound
{
    GENERATED_USTRUCT_BODY()
 
    // The array of current spectral data for this sound wave
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpectralData")
    TArray<FSoundWaveSpectralData> SpectralData;
 
    // The current playback time of this sound wave
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpectralData")
    float PlaybackTime = 0.0f;
 
    // The sound wave this spectral data is associated with
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "SpectralData")
    TObjectPtr<USoundWave> SoundWave = nullptr;
};
 
USTRUCT(BlueprintType)
struct FSoundWaveEnvelopeDataPerSound
{
    GENERATED_USTRUCT_BODY()
 
    // The current envelope of the playing sound
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "EnvelopeData")
    float Envelope = 0.0f;
 
    // The current playback time of this sound wave
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "EnvelopeData")
    float PlaybackTime = 0.0f;
 
    // The sound wave this envelope data is associated with
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "EnvelopeData")
    TObjectPtr<USoundWave> SoundWave = nullptr;
};
 
// Sort predicate for sorting spectral data by frequency (lowest first)
struct FCompareSpectralDataByFrequencyHz
{
    inline bool operator()(const FSoundWaveSpectralData& A, const FSoundWaveSpectralData& B) const
    {
        return A.FrequencyHz < B.FrequencyHz;
    }
};
 
 
// Struct used to store spectral data with time-stamps
USTRUCT()
struct FSoundWaveSpectralDataEntry
{
    GENERATED_USTRUCT_BODY()
 
    // The magnitude of the spectrum at this frequency
    UPROPERTY()
    float Magnitude = 0.0f;
 
    // The normalized magnitude of the spectrum at this frequency
    UPROPERTY()
    float NormalizedMagnitude = 0.0f;
};
 
 
// Struct used to store spectral data with time-stamps
USTRUCT()
struct FSoundWaveSpectralTimeData
{
    GENERATED_USTRUCT_BODY()
 
    // The spectral data at the given time. The array indices correspond to the frequencies set to analyze.
    UPROPERTY()
    TArray<FSoundWaveSpectralDataEntry> Data;
 
    // The timestamp associated with this spectral data
    UPROPERTY()
    float TimeSec = 0.0f;
};
 
// Struct used to store time-stamped envelope data
USTRUCT()
struct FSoundWaveEnvelopeTimeData
{
    GENERATED_USTRUCT_BODY()
 
    // The normalized linear amplitude of the audio
    UPROPERTY()
    float Amplitude = 0.0f;
 
    // The timestamp of the audio
    UPROPERTY()
    float TimeSec = 0.0f;
};
 
// The FFT size (in audio frames) to use for baked FFT analysis
UENUM(BlueprintType)
enum class ESoundWaveFFTSize : uint8
{
    VerySmall_64,
    Small_256,
    Medium_512,
    Large_1024,
    VeryLarge_2048,
};
 
// Sound Asset Compression Type
UENUM(BlueprintType)
enum class ESoundAssetCompressionType : uint8
{
    // Perceptual-based codec which supports all features across all platforms.
    BinkAudio,
 
    // Will encode the asset using ADPCM, a time-domain codec that has fixed-sized quality and about ~4x compression ratio, but is relatively cheap to decode.
    ADPCM,
 
    // Uncompressed audio. Large memory usage (streamed chunks contain less audio per chunk) but extremely cheap to decode and supports all features. 
    PCM,
 
    // Opus is a highly versatile audio codec. It is primarily designed for interactive speech and music transmission over the Internet, but is also applicable to storage and streaming applications.
    Opus,
 
    // Encodes the asset to a platform specific format and will be different depending on the platform. It does not currently support seeking.
    PlatformSpecific,
 
    // The project defines the codec used for this asset.
    ProjectDefined,
 
    // As BinkAudio, except better quality. Comparable CPU usage. Only valid sample rates are: 48000, 44100, 32000, and 24000.
    RADAudio UMETA(DisplayName = "RAD Audio"),
};
 
 
namespace Audio
{
    inline FName ToName(ESoundAssetCompressionType InDecoderType)
    {
        switch (InDecoderType)
        {
        case ESoundAssetCompressionType::RADAudio:              return NAME_RADA;
        case ESoundAssetCompressionType::BinkAudio:             return NAME_BINKA;
        case ESoundAssetCompressionType::ADPCM:                 return NAME_ADPCM;
        case ESoundAssetCompressionType::PCM:                   return NAME_PCM;
        case ESoundAssetCompressionType::Opus:                  return NAME_OPUS;
        case ESoundAssetCompressionType::PlatformSpecific:      return NAME_PLATFORM_SPECIFIC;
        case ESoundAssetCompressionType::ProjectDefined:        return NAME_PROJECT_DEFINED;
        default:
            ensure(false);
            return TEXT("UNKNOWN");
        }
    }
 
    inline ESoundAssetCompressionType ToSoundAssetCompressionType(EDefaultAudioCompressionType InDefaultCompressionType)
    {
        switch (InDefaultCompressionType)
        {
            case EDefaultAudioCompressionType::RADAudio:            return ESoundAssetCompressionType::RADAudio;
            case EDefaultAudioCompressionType::BinkAudio:           return ESoundAssetCompressionType::BinkAudio;
            case EDefaultAudioCompressionType::ADPCM:               return ESoundAssetCompressionType::ADPCM;
            case EDefaultAudioCompressionType::PCM:                 return ESoundAssetCompressionType::PCM;
            case EDefaultAudioCompressionType::Opus:                return ESoundAssetCompressionType::Opus;
            case EDefaultAudioCompressionType::PlatformSpecific:    return ESoundAssetCompressionType::PlatformSpecific;
            default:
                ensure(false);
                return ESoundAssetCompressionType::PlatformSpecific;
        }
    }
}
 
struct ISoundWaveClient
{
    ISoundWaveClient() {}
    virtual ~ISoundWaveClient() {}
    
    // OnBeginDestroy() returns true to unsubscribe as an ISoundWaveClient
    virtual bool OnBeginDestroy(class USoundWave* Wave) = 0;
    virtual bool OnIsReadyForFinishDestroy(class USoundWave* Wave) const = 0;
    virtual void OnFinishDestroy(class USoundWave* Wave) = 0;
};
UCLASS(hidecategories=Object, editinlinenew, BlueprintType, meta= (LoadBehavior = "LazyOnDemand"), MinimalAPI)
class USoundWave : public USoundBase, public IAudioProxyDataFactory, public IInterface_AsyncCompilation
{
    GENERATED_UCLASS_BODY()
 
private:
 
    UPROPERTY(Config, EditAnywhere, Category = "Format|Quality", meta = (DisplayName = "Compression", ClampMin = "1", ClampMax = "100", EditCondition = "SoundAssetCompressionType != ESoundAssetCompressionType::PCM && SoundAssetCompressionType != ESoundAssetCompressionType::ADPCM"), AssetRegistrySearchable)
    int32 CompressionQuality;
 
public:
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "5.0 - Property is deprecated. Streaming priority has no effect with stream caching enabled."))
    int32 StreamingPriority;
 
    UPROPERTY(EditAnywhere, Category = "Format|Quality")
    ESoundwaveSampleRateSettings SampleRateQuality;
 
    TEnumAsByte<EDecompressionType> DecompressionType;
 
    UPROPERTY(EditAnywhere, Category = Sound, meta = (DisplayName = "Group"))
    TEnumAsByte<ESoundGroup> SoundGroup;
 
    UPROPERTY(EditAnywhere, Category = Sound, AssetRegistrySearchable)
    uint8 bLooping : 1;
 
    UPROPERTY()
    uint8 bStreaming : 1;
 
private:
 
    // Deprecated compression type properties
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "5.0 - Property is deprecated. bSeekableStreaming now means ADPCM codec in SoundAssetCompressionType."))
    uint8 bSeekableStreaming : 1;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "5.0 - Property is deprecated. bUseBinkAudio now means Bink codec in SoundAssetCompressionType."))
    uint8 bUseBinkAudio : 1;
 
    UPROPERTY(Config, EditAnywhere, Category = "Format", AssetRegistrySearchable)
    ESoundAssetCompressionType SoundAssetCompressionType = ESoundAssetCompressionType::PlatformSpecific;
 
public:
    void AddPlayingSource()
    {
        NumSourcesPlaying.Increment();
    }
 
    void RemovePlayingSource()
    {
        check(NumSourcesPlaying.GetValue() > 0);
        NumSourcesPlaying.Decrement();
    }
 
    UFUNCTION(BlueprintPure, Category = "Audio")
    ENGINE_API ESoundAssetCompressionType GetSoundAssetCompressionType() const;
 
    ENGINE_API ESoundAssetCompressionType GetSoundAssetCompressionTypeEnum() const;
 
    UFUNCTION(BlueprintCallable, Category = "Audio")
    ENGINE_API void SetSoundAssetCompressionType(ESoundAssetCompressionType InSoundAssetCompressionType, bool bMarkDirty = true);
 
    UFUNCTION(BlueprintCallable, Category = "Audio")
    ENGINE_API TArray<FSoundWaveCuePoint> GetCuePoints() const;
    ENGINE_API void SetAllCuePoints(TArray<FSoundWaveCuePoint> InCuePoints) const;
 
#if WITH_EDITOR
    ENGINE_API TArray<FSoundWaveCuePoint> GetSoundWaveCuePoints() const;
    ENGINE_API void SetSoundWaveCuePoints(const TArray<FSoundWaveCuePoint>& InCuePoints);
 
    ENGINE_API const ESoundWaveCuePointOrigin GetCuePointOrigin() const;
    ENGINE_API void SetCuePointOrigin(const ESoundWaveCuePointOrigin InCuePointOrigin);
 
    ENGINE_API void SetLoudnessValues(const float InLUFS, const float InSamplePeakDB);
#endif //WITH_EDITOR
 
    UFUNCTION(BlueprintCallable, Category = "Audio")
    ENGINE_API TArray<FSoundWaveCuePoint> GetLoopRegions() const;
 
    ENGINE_API FName GetRuntimeFormat() const;
 
    ENGINE_API void ResetInvalidTemplateArguments();
 
private:
    // cached proxy
    FSoundWaveProxyPtr Proxy{ nullptr };
 
public:
 
    using FSoundWaveClientPtr = ISoundWaveClient*;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = "Analysis")
    TObjectPtr<USoundWave> OverrideSoundToUseForAnalysis;
 
    UPROPERTY(EditAnywhere, Category = "Analysis")
    uint8 TreatFileAsLoopingForAnalysis : 1;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|FFT")
    uint8 bEnableBakedFFTAnalysis : 1;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|Envelope")
    uint8 bEnableAmplitudeEnvelopeAnalysis : 1;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|FFT", meta = (EditCondition = "bEnableBakedFFTAnalysis"))
    ESoundWaveFFTSize FFTSize;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|FFT", meta = (EditCondition = "bEnableBakedFFTAnalysis", ClampMin = "512", UIMin = "512"))
    int32 FFTAnalysisFrameSize;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|FFT", meta = (EditCondition = "bEnableBakedFFTAnalysis", ClampMin = "0", UIMin = "0"))
    int32 FFTAnalysisAttackTime;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|FFT", meta = (EditCondition = "bEnableBakedFFTAnalysis", ClampMin = "0", UIMin = "0"))
    int32 FFTAnalysisReleaseTime;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|Envelope", meta = (EditCondition = "bEnableAmplitudeEnvelopeAnalysis", ClampMin = "512", UIMin = "512"))
    int32 EnvelopeFollowerFrameSize;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|Envelope", meta = (EditCondition = "bEnableAmplitudeEnvelopeAnalysis", ClampMin = "0", UIMin = "0"))
    int32 EnvelopeFollowerAttackTime;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|Envelope", meta = (EditCondition = "bEnableAmplitudeEnvelopeAnalysis", ClampMin = "0", UIMin = "0"))
    int32 EnvelopeFollowerReleaseTime;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Modulation")
    FSoundModulationDefaultRoutingSettings ModulationSettings;
 
    UPROPERTY(EditAnywhere, Category = "Analysis|FFT", meta = (EditCondition = "bEnableBakedFFTAnalysis"))
    TArray<float> FrequenciesToAnalyze;
 
    UPROPERTY()
    TArray<FSoundWaveSpectralTimeData> CookedSpectralTimeData;
 
    UPROPERTY()
    TArray<FSoundWaveEnvelopeTimeData> CookedEnvelopeTimeData;
 
    ENGINE_API bool GetInterpolatedCookedFFTDataForTime(float InTime, uint32& InOutLastIndex, TArray<FSoundWaveSpectralData>& OutData, bool bLoop);
    ENGINE_API bool GetInterpolatedCookedEnvelopeDataForTime(float InTime, uint32& InOutLastIndex, float& OutAmplitude, bool bLoop);
 
    ENGINE_API void GetHandleForChunkOfAudio(TFunction<void(FAudioChunkHandle&&)> OnLoadCompleted, bool bForceSync = false, int32 ChunkIndex = 1, ENamedThreads::Type CallbackThread = ENamedThreads::GameThread);
 
    ENGINE_API void RetainCompressedAudio(bool bForceSync = false);
 
    ENGINE_API void ReleaseCompressedAudio();
 
    ENGINE_API bool IsRetainingAudio();
    ENGINE_API void OverrideLoadingBehavior(ESoundWaveLoadingBehavior InLoadingBehavior);
 
    ENGINE_API ESoundWaveLoadingBehavior GetLoadingBehavior(bool bCheckSoundClasses = true) const;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(AdvancedDisplay, meta = (DeprecatedProperty))
    int32 InitialChunkSize_DEPRECATED;
#endif
 
#if WITH_EDITOR
    ENGINE_API const FWaveTransformUObjectConfiguration& GetTransformationChainConfig() const;
    ENGINE_API const FWaveTransformUObjectConfiguration& UpdateTransformations();
    // Pass in a Transformations array to overwrite this soundwave with another soundwaves transformation data
    ENGINE_API void OverwriteSoundWaveDataWithTransformationData(const TArrayView<TObjectPtr<UWaveformTransformationBase>> InTransformations = {});
    ENGINE_API FWaveformTransformationInfo GetWaveformTransformationInfo() const;
 
#endif
 
private:
 
    ENGINE_API uint32 GetInterpolatedCookedFFTDataForTimeInternal(float InTime, uint32 StartingIndex, TArray<FSoundWaveSpectralData>& OutData, bool bLoop);
    ENGINE_API uint32 GetInterpolatedCookedEnvelopeDataForTimeInternal(float InTime, uint32 StartingIndex, float& OutAmplitude, bool bLoop);
 
    FThreadSafeCounter PrecacheState;
 
public:
    FThreadSafeCounter NumSourcesPlaying;
 
private:
 
    TArray<FSoundWaveClientPtr> SourcesPlaying;
 
    // This is the sample rate retrieved from platform settings.
    mutable float CachedSampleRateOverride;
 
    // We cache a soundwave's loading behavior on the first call to USoundWave::GetLoadingBehaviorForWave(true);
    // Caches resolved loading behavior from the SoundClass graph. Must be called on the game thread.
    ENGINE_API void CacheInheritedLoadingBehavior() const;
 
    // Called when we change any properties about the underlying audio asset
#if WITH_EDITOR
    ENGINE_API void UpdateAsset(bool bMarkDirty = true);
#endif
 
public:
 
    uint8 bProcedural : 1;
 
    uint8 bRequiresStopFade:1;
 
    uint8 bIsSourceBus : 1;
 
    uint8 bCanProcessAsync : 1;
 
    uint8 bDynamicResource : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Subtitles, AssetRegistrySearchable)
    uint8 bMature : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Subtitles)
    uint8 bManualWordWrap : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Subtitles)
    uint8 bSingleLine : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bVirtualizeWhenSilent_DEPRECATED : 1;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category = Format)
    uint8 bIsAmbisonics : 1;
 
    uint8 bDecompressedFromOgg : 1;
 
#if WITH_EDITOR
    std::atomic<int32> CurrentChunkRevision = 0;
#endif
 
private:
 
    // This is set to false on initialization, then set to true on non-editor platforms when we cache appropriate sample rate.
    mutable uint8 bCachedSampleRateFromPlatformSettings : 1;
 
    // This is set when SetSampleRate is called to invalidate our cached sample rate while not re-parsing project settings.
    uint8 bSampleRateManuallyReset : 1;
 
#if WITH_EDITOR
    // Whether or not the thumbnail supports generation
    uint8 bNeedsThumbnailGeneration : 1;
 
    // Whether this asset is loaded from cooked data.
    uint8 bLoadedFromCookedData : 1;
#endif // !WITH_EDITOR
 
    enum class ESoundWaveResourceState : uint8
    {
        NeedsFree,
        Freeing,
        Freed
    };
 
    ESoundWaveResourceState ResourceState : 2;
 
public:
    // Loading behavior members are lazily initialized in const getters
    UPROPERTY(EditAnywhere, Category = "Loading", meta = (DisplayName = "Loading Behavior Override"))
    mutable ESoundWaveLoadingBehavior LoadingBehavior;
    
private:
    mutable UE::FMutex SourcesPlayingCs;
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = Loading, meta = (UIMin = 0, UIMax = 10, EditCondition = "LoadingBehavior == ESoundWaveLoadingBehavior::RetainOnLoad || LoadingBehavior == ESoundWaveLoadingBehavior::PrimeOnLoad"), DisplayName="Size of First Audio Chunk (seconds)")
    FPerPlatformFloat SizeOfFirstAudioChunkInSeconds = 0.0f;
#endif //WITH_EDITOR_ONLY_DATA
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Subtitles instead."))
    FString SpokenText_DEPRECATED;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Subtitles)
    float SubtitlePriority;
 
    UPROPERTY(Category = Sound, meta = (ClampMin = "0.0"), EditAnywhere)
    float Volume;
 
    UPROPERTY(Category = Sound, meta = (ClampMin = "0.125", ClampMax = "4.0"), EditAnywhere)
    float Pitch;
 
    UPROPERTY(Category = Info, AssetRegistrySearchable, VisibleAnywhere)
    int32 NumChannels;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<int32> ChannelOffsets;
 
    UPROPERTY()
    TArray<int32> ChannelSizes;
 
    UPROPERTY(Category = Info, AssetRegistrySearchable, VisibleAnywhere)
    float LUFS;
 
    UPROPERTY(Category = Info, AssetRegistrySearchable, VisibleAnywhere)
    float SamplePeakDB;
 
#endif // WITH_EDITORONLY_DATA
 
protected:
 
    UPROPERTY(Category = Info, AssetRegistrySearchable, VisibleAnywhere)
    int32 SampleRate;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Category = Info, AssetRegistrySearchable, VisibleAnywhere)
    int32 ImportedSampleRate;
 
    UPROPERTY(Category = Info, VisibleAnywhere, BlueprintGetter = GetCuePoints)
    TArray<FSoundWaveCuePoint> CuePoints;
 
    UPROPERTY(Category = Info, EditAnywhere)
    ESoundWaveCuePointOrigin CuePointOrigin;
#endif
 
    ENGINE_API virtual void SerializeCuePoints(FArchive& Ar, const bool bIsLoadingFromCookedArchive);
 
public:
 
    // Returns the compression quality of the sound asset.
    ENGINE_API int32 GetCompressionQuality() const;
 
    int32 ResourceID;
 
    ENGINE_API int32 GetResourceSize() const;
 
    int32 TrackedMemoryUsage;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Subtitles)
    TArray<struct FSubtitleCue> Subtitles;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = Subtitles)
    FString Comment;
 
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITORONLY_DATA
    
    UPROPERTY(VisibleAnywhere, Category = Info)
    FSoundWaveTimecodeInfo TimecodeInfo;
 
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FString SourceFilePath_DEPRECATED;
    
    UPROPERTY()
    FString SourceFileTimestamp_DEPRECATED;
 
    UPROPERTY(VisibleAnywhere, Instanced, Category = ImportSettings)
    TObjectPtr<class UAssetImportData> AssetImportData;
 
#endif // WITH_EDITORONLY_DATA
 
protected:
 
    UPROPERTY(EditAnywhere, Category = SoundWave, AdvancedDisplay)
    TObjectPtr<class UCurveTable> Curves;
 
    UPROPERTY()
    TObjectPtr<class UCurveTable> InternalCurves;
 
#if WITH_EDITORONLY_DATA
protected:
    UPROPERTY(EditAnywhere, Category = "Format", Meta=(DisplayName="Enable cloud streaming", DisplayAfter="SoundAssetCompressionType", EditCondition = "LoadingBehavior != ESoundWaveLoadingBehavior::ForceInline"), AssetRegistrySearchable)
    uint8 bEnableCloudStreaming : 1;
    UPROPERTY(EditAnywhere, config, Category="Platform specific", Meta=(DisplayName="Platform specific settings", ToolTip="Optionally disables cloud streaming per platform"))
    TMap<FGuid, FSoundWaveCloudStreamingPlatformSettings> PlatformSettings;
public:
    static FName GetCloudStreamingEnabledPropertyName() { return GET_MEMBER_NAME_CHECKED(USoundWave, bEnableCloudStreaming); }
    ENGINE_API void SetCloudStreamingEnabled(bool bEnabled);
    ENGINE_API bool IsCloudStreamingEnabled() const;
    ENGINE_API void TriggerRecookForCloudStreaming();
    static FName GetCloudStreamingPlatformSettingsPropertyName() { return GET_MEMBER_NAME_CHECKED(USoundWave, PlatformSettings); }
    TMap<FGuid, FSoundWaveCloudStreamingPlatformSettings>& GetCloudStreamingPlatformSettings() { return PlatformSettings; }
    const TMap<FGuid, FSoundWaveCloudStreamingPlatformSettings>& GetCloudStreamingPlatformSettings() const { return PlatformSettings; }
#endif // WITH_EDITORONLY_DATA
 
public:
    static ENGINE_API ITargetPlatform* GetRunningPlatform();
 
    static ENGINE_API const TCHAR* GetDefaultLoadingBehaviorCVarName();
 
    static ENGINE_API ESoundWaveLoadingBehavior GetDefaultLoadingBehavior();
 
    typedef FAsyncTask< class FAsyncAudioDecompressWorker > FAsyncAudioDecompress;  // Forward declare typedef
    FAsyncAudioDecompress* AudioDecompressor;
 
    uint8* CachedRealtimeFirstBuffer;
 
    int32 NumPrecacheFrames;
 
    int32 RawPCMDataSize;
 
    uint8* RawPCMData;
 
public:
    ENGINE_API const uint8* GetResourceData() const;
 
#if WITH_EDITORONLY_DATA
    struct FEditorAudioBulkData
    {
        UE::Serialization::FEditorBulkData RawData;
 
        // The container soundwave for this raw data. This must be non-null for any non-metadata instances.
        // We need this in order to parse the multichannel layout of the raw data - and we also use this 
        // in place of the BulkData Owner parameter in many places because many call sites pass null incorrectly,
        // resulting in the bulk data not being correlated with our asset.
        USoundWave* SoundWave;
 
        enum class EPayloadFlags : uint8
        {
            None,
            ReturnCopyWithTransformationData = 0x01
        };
 
        FEditorAudioBulkData()
            : RawData()
            , SoundWave()
        {
        }
            
        FEditorAudioBulkData(USoundWave* Owner)
        {
            SoundWave = Owner;
        }
 
        ENGINE_API void CreateFromBulkData(FBulkData& InBulkData, const FGuid& InGuid, UObject* Owner);
        ENGINE_API void Serialize(FArchive& Ar, UObject* Owner, bool bAllowRegister=true);
        ENGINE_API TFuture<FSharedBuffer> GetPayload(const EPayloadFlags Flags = EPayloadFlags::None) const;
        ENGINE_API bool HasPayloadData() const;
        ENGINE_API void UpdatePayload(FSharedBuffer InPayload, UObject* Owner = nullptr);
 
        //
        // Deprecated unused API forwarding for potential backwards compatability issues.
        // As the raw data needs to be converted before use or storage, always access it via the above functions.
        //
#pragma region Deprecated Pass Thru
        UE_DEPRECATED(5.4, "CreateLegacyUniqueIdentifier is provided just for API backwards compatibility.")
        void CreateLegacyUniqueIdentifier(UObject* Owner)
        {
            RawData.CreateLegacyUniqueIdentifier(Owner);
        }
        UE_DEPRECATED(5.4, "Reset is provided just for API backwards compatibility.")
        void Reset() 
        { 
            RawData.Reset(); 
        }
        UE_DEPRECATED(5.4, "UnloadData is provided just for API backwards compatibility.")
        void UnloadData()
        {
            RawData.UnloadData();
        }
        UE_DEPRECATED(5.4, "DetachFromDisk is provided just for API backwards compatibility.")
        void DetachFromDisk(FArchive* Ar, bool bEnsurePayloadIsLoaded)
        {
            RawData.DetachFromDisk(Ar, bEnsurePayloadIsLoaded);
        }
        UE_DEPRECATED(5.4, "GetIdentifier is provided just for API backwards compatibility.")
        FGuid GetIdentifier() const
        {
            return RawData.GetIdentifier();
        }
        UE_DEPRECATED(5.4, "GetPayloadId is provided just for API backwards compatibility.")
        const FIoHash& GetPayloadId() const
        {
            return RawData.GetPayloadId();
        }
        int64 GetPayloadSize() const
        {
            return RawData.GetPayloadSize();
        }
        UE_DEPRECATED(5.4, "DoesPayloadNeedLoading is provided just for API backwards compatibility.")
        bool DoesPayloadNeedLoading() const
        {
            return RawData.DoesPayloadNeedLoading();
        }
        UE_DEPRECATED(5.4, "GetCompressedPayload is provided just for API backwards compatibility.")
        TFuture<FCompressedBuffer> GetCompressedPayload() const
        {
            return RawData.GetCompressedPayload();
        }
        UE_DEPRECATED(5.4, "UpdatePayload is provided just for API backwards compatibility.")
        void UpdatePayload(FCompressedBuffer InPayload, UObject* Owner = nullptr)
        {
            RawData.UpdatePayload(InPayload, Owner);
        }
        UE_DEPRECATED(5.4, "UpdatePayload is provided just for API backwards compatibility.")
        void UpdatePayload(UE::Serialization::FEditorBulkData::FSharedBufferWithID InPayload, UObject* Owner = nullptr)
        {
            RawData.UpdatePayload(MoveTemp(InPayload), Owner);
        }
        UE_DEPRECATED(5.4, "SetCompressionOptions is provided just for API backwards compatibility.")
        void SetCompressionOptions(UE::Serialization::ECompressionOptions Option)
        {
            RawData.SetCompressionOptions(Option);
        }
        UE_DEPRECATED(5.4, "SetCompressionOptions is provided just for API backwards compatibility.")
        void SetCompressionOptions(ECompressedBufferCompressor Compressor, ECompressedBufferCompressionLevel CompressionLevel)
        {
            RawData.SetCompressionOptions(Compressor, CompressionLevel);
        }
        UE_DEPRECATED(5.4, "GetBulkDataVersions is provided just for API backwards compatibility.")
        void GetBulkDataVersions(FArchive& InlineArchive, FPackageFileVersion& OutUEVersion, int32& OutLicenseeUEVersion, FCustomVersionContainer& OutCustomVersions) const
        {
            RawData.GetBulkDataVersions(InlineArchive, OutUEVersion, OutLicenseeUEVersion, OutCustomVersions);
        }
        UE_DEPRECATED(5.4, "TearOff is provided just for API backwards compatibility.")
        void TearOff()
        {
            RawData.TearOff();
        }
        UE_DEPRECATED(5.4, "CopyTornOff is provided just for API backwards compatibility.")
        UE::Serialization::FEditorBulkData CopyTornOff() const
        {
            return RawData.CopyTornOff();
        }
        UE_DEPRECATED(5.4, "SerializeForRegistry is provided just for API backwards compatibility.")
        void SerializeForRegistry(FArchive& Ar)
        {
            RawData.SerializeForRegistry(Ar);
        }
        UE_DEPRECATED(5.4, "CanSaveForRegistry is provided just for API backwards compatibility.")
        bool CanSaveForRegistry() const
        {
            return RawData.CanSaveForRegistry();
        }
        UE_DEPRECATED(5.4, "HasPlaceholderPayloadId is provided just for API backwards compatibility.")
        bool HasPlaceholderPayloadId() const
        {
            return RawData.HasPlaceholderPayloadId();
        }
        UE_DEPRECATED(5.4, "IsMemoryOnlyPayload is provided just for API backwards compatibility.")
        bool IsMemoryOnlyPayload() const
        {
            return RawData.IsMemoryOnlyPayload();
        }
        UE_DEPRECATED(5.4, "UpdatePayloadId is provided just for API backwards compatibility.")
        void UpdatePayloadId()
        {
            return RawData.UpdatePayloadId();
        }
        UE_DEPRECATED(5.4, "LocationMatches is provided just for API backwards compatibility.")
        bool LocationMatches(const UE::Serialization::FEditorBulkData& Other) const
        {
            return RawData.LocationMatches(Other);
        }
        UE_DEPRECATED(5.4, "UpdateRegistrationOwner is provided just for API backwards compatibility.")
        void UpdateRegistrationOwner(UObject* Owner)
        {
            RawData.UpdateRegistrationOwner(Owner);
        }
#pragma endregion
    } RawData;
 
    UPROPERTY(EditAnywhere, Instanced, Category = "Waveform Processing")
    TArray<TObjectPtr<class UWaveformTransformationBase>> Transformations;
#endif
 
    FGuid CompressedDataGuid;
 
#if WITH_EDITORONLY_DATA
    TMap<FName, uint32> AsyncLoadingDataFormats;
 
    mutable FCriticalSection RawDataCriticalSection;
 
#endif // WITH_EDITORONLY_DATA
    TSortedMap<FString, FStreamedAudioPlatformData*> CookedPlatformData;
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual void PostLoad() override;
 
    // Returns true if the zeroth chunk is loaded, or attempts to load it if not already loaded,
    // returning true if the load was successful. Can return false if either an error was encountered
    // in attempting to load the chunk or if stream caching is not enabled for the given sound.
    ENGINE_API bool LoadZerothChunk();
 
    // Returns the amount of chunks this soundwave contains if it's streaming,
    // or zero if it is not a streaming source.
    ENGINE_API uint32 GetNumChunks() const;
 
    ENGINE_API uint32 GetSizeOfChunk(uint32 ChunkIndex) const;
 
    // Calculates audio streaming cache usage for this sound wave. 
    // @param OutTotalBytesOfAudioData - The accumulated number of bytes of all audio data of all chunks for this sound wave.
    // @param OutMaxChunkBytesOfAudioData - The maximum number of bytes of audio data for all audio chunks for this sound wave. 
    ENGINE_API void GetChunkSizeStats(uint32& OutTotalBytesOfAudioData, uint32& OutMaxChunkBytesOfAudioData) const;
 
    ENGINE_API virtual void BeginDestroy() override;
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
 
    ENGINE_API virtual bool IsCompiling() const override;
    ENGINE_API bool IsAsyncWorkComplete() const;
 
    ENGINE_API void PostImport();
    
    ENGINE_API virtual void PreSave(FObjectPreSaveContext SaveContext) override;
    ENGINE_API virtual void OnCookEvent(UE::Cook::ECookEvent CookEvent, UE::Cook::FCookEventContext& CookContext) override;
 
private:
    friend class FSoundWaveCompilingManager;
    ENGINE_API bool RescheduleAsyncTask(FQueuedThreadPool* InThreadPool, EQueuedWorkPriority InPriority);
    ENGINE_API bool WaitAsyncTaskWithTimeout(float InTimeoutInSeconds);
 
    void CreateNewSoundWaveData();
 
public:
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    ENGINE_API TArray<Audio::FTransformationPtr> CreateTransformations() const;
#endif // WITH_EDITORONLY_DATA
    
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    ENGINE_API virtual FName GetExporterName() override;
    ENGINE_API virtual FString GetDesc() override;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    //~ End UObject Interface.
 
    //~ Begin USoundBase Interface.
    ENGINE_API virtual bool IsPlayable() const override;
    ENGINE_API virtual void Parse(class FAudioDevice* AudioDevice, const UPTRINT NodeWaveInstanceHash, FActiveSound& ActiveSound, const FSoundParseParameters& ParseParams, TArray<FWaveInstance*>& WaveInstances) override;
    ENGINE_API virtual float GetDuration() const override;
    ENGINE_API virtual float GetSubtitlePriority() const override;
    ENGINE_API virtual bool SupportsSubtitles() const override;
    ENGINE_API virtual bool GetSoundWavesWithCookedAnalysisData(TArray<USoundWave*>& OutSoundWaves) override;
    ENGINE_API virtual bool HasCookedFFTData() const override;
    ENGINE_API virtual bool HasCookedAmplitudeEnvelopeData() const override;
    virtual bool IsProcedurallyGenerated() const override { return bProcedural; }
    //~ End USoundBase Interface.
 
    ENGINE_API FSoundWaveProxyPtr CreateSoundWaveProxy();
 
    //~Begin IAudioProxyDataFactory Interface.
    ENGINE_API virtual TSharedPtr<Audio::IProxyData> CreateProxyData(const Audio::FProxyDataInitParams& InitParams) override;
    //~ End IAudioProxyDataFactory Interface.
 
    // Called  when the procedural sound wave begins on the render thread. Only used in the audio mixer and when bProcedural is true.
    virtual void OnBeginGenerate() {}
 
    // Called when the procedural sound wave is done generating on the render thread. Only used in the audio mixer and when bProcedural is true..
    virtual void OnEndGenerate() {};
    virtual void OnEndGenerate(ISoundGeneratorPtr Generator) {};
 
    ENGINE_API void AddPlayingSource(const FSoundWaveClientPtr& Source);
    ENGINE_API void RemovePlayingSource(const FSoundWaveClientPtr& Source);
 
    bool IsGeneratingAudio() const
    {
        bool bIsGeneratingAudio = false;
        UE::TUniqueLock Lock(SourcesPlayingCs);
        bIsGeneratingAudio = SourcesPlaying.Num() > 0;
 
        return bIsGeneratingAudio;
    }
 
    void SetImportedSampleRate(uint32 InImportedSampleRate)
    {
#if WITH_EDITORONLY_DATA
        ImportedSampleRate = InImportedSampleRate;
#endif
    }
    
    uint32 GetImportedSampleRate() const
    {
#if WITH_EDITORONLY_DATA
        return ImportedSampleRate;
#else
        return 0;
#endif
    }
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void SetTimecodeInfo(const FSoundWaveTimecodeInfo& InTimecode);
    ENGINE_API TOptional<FSoundWaveTimecodeInfo> GetTimecodeInfo() const;
#endif //WITH_EDITORONLY_DATA   
 
    ENGINE_API void SetSampleRate(uint32 InSampleRate, const bool bFromDecoders=false);
 
    ENGINE_API void SetNumFrames(uint32 InNumFrames);
 
    ENGINE_API uint32 GetNumFrames() const;
 
    ENGINE_API virtual int32 GetResourceSizeForFormat(FName Format);
 
    ENGINE_API void FreeResources(bool bStopSoundsUsingThisResource = true);
 
    ENGINE_API bool CleanupDecompressor(bool bForceCleanup = false);
 
    ENGINE_API virtual void InitAudioResource(FByteBulkData& CompressedData);
 
    ENGINE_API virtual bool InitAudioResource(FName Format);
 
    ENGINE_API void RemoveAudioResource();
 
    ENGINE_API FWaveInstance& HandleStart(FActiveSound& ActiveSound, const UPTRINT WaveInstanceHash) const;
 
    virtual int32 GeneratePCMData(uint8* PCMData, const int32 SamplesNeeded) { ensure(false); return 0; }
 
    virtual Audio::EAudioMixerStreamDataFormat::Type GetGeneratedPCMDataFormat() const { return Audio::EAudioMixerStreamDataFormat::Int16; }
 
    SIZE_T GetCompressedDataSize(FName Format, const FPlatformAudioCookOverrides* CompressionOverrides = GetPlatformCompressionOverridesForCurrentPlatform())
    {
        FByteBulkData* Data = GetCompressedData(Format, CompressionOverrides);
        return Data ? Data->GetBulkDataSize() : 0;
    }
 
    ENGINE_API virtual bool HasCompressedData(FName Format, ITargetPlatform* TargetPlatform = GetRunningPlatform()) const;
 
#if WITH_EDITOR
    ENGINE_API bool GetImportedSoundWaveData(TArray<uint8>& OutRawPCMData, uint32& OutSampleRate, uint16& OutNumChannels) const;
 
    ENGINE_API bool GetImportedSoundWaveData(TArray<uint8>& OutRawPCMData, uint32& OutSampleRate, TArray<EAudioSpeakers>& OutChannelOrder) const;
 
    ENGINE_API void InvalidateSoundWaveIfNeccessary();
 
#endif //WITH_EDITOR
 
 
    static ENGINE_API FName GetPlatformSpecificFormat(FName Format, const FPlatformAudioCookOverrides* CompressionOverrides);
 
private:
#if WITH_EDITOR
    // Removes any in-progress async loading data formats. 
    ENGINE_API void FlushAsyncLoadingDataFormats();
 
    // Waits for audio rendering commands to execute
    ENGINE_API void FlushAudioRenderingCommands() const;
 
    ENGINE_API void BakeFFTAnalysis();
    ENGINE_API void BakeEnvelopeAnalysis();
 
    FWaveTransformUObjectConfiguration TransformationChainConfig;
#endif //WITH_EDITOR
 
public:
 
#if WITH_EDITOR
    ENGINE_API void LogBakedData();
 
    ENGINE_API bool IsCompressedDataReady(FName Format, const FPlatformAudioCookOverrides* CompressionOverrides) const;
 
    ENGINE_API bool IsLoadedFromCookedData() const;
#endif //WITH_EDITOR
 
    ENGINE_API virtual void BeginGetCompressedData(FName Format, const FPlatformAudioCookOverrides* CompressionOverrides, const ITargetPlatform* InTargetPlatform);
 
    ENGINE_API virtual FByteBulkData* GetCompressedData(FName Format, const FPlatformAudioCookOverrides* CompressionOverrides = GetPlatformCompressionOverridesForCurrentPlatform(),
        const ITargetPlatform* InTargetPlatform = GetRunningPlatform());
 
    ENGINE_API void InvalidateCompressedData(bool bFreeResources = false, bool bRebuildStreamingChunks = true);
 
    virtual class UCurveTable* GetCurveData() const override { return Curves; }
 
    // This function returns true if there are streamable chunks in this asset.
    ENGINE_API bool HasStreamingChunks();
 
#if WITH_EDITOR
    class UCurveTable* GetInternalCurveData() const { return InternalCurves; }
 
    bool HasInternalCurves() const { return InternalCurves != nullptr; }
 
    void SetCurveData(UCurveTable* InCurves) { Curves = InCurves; }
 
    void SetInternalCurveData(UCurveTable* InCurves) { InternalCurves = InCurves; }
 
    static FName GetCurvePropertyName() { return GET_MEMBER_NAME_CHECKED(USoundWave, Curves); }
#endif // WITH_EDITOR
 
public:
    ENGINE_API bool IsStreaming(const TCHAR* PlatformName = nullptr) const;
    ENGINE_API bool IsStreaming(const FPlatformAudioCookOverrides& Overrides) const;
 
    ENGINE_API virtual bool IsSeekable() const;
 
    ENGINE_API bool ShouldUseStreamCaching() const;
 
    ENGINE_API TArrayView<const uint8> GetZerothChunk(bool bForImmediatePlayback = false);
 
    ENGINE_API void UpdatePlatformData();
 
    ENGINE_API void CleanupCachedRunningPlatformData();
 
    ENGINE_API virtual void SerializeCookedPlatformData(class FArchive& Ar);
 
    /*
    * Returns a sample rate if there is a specific sample rate override for this platform, -1.0 otherwise.
    */
    ENGINE_API float GetSampleRateForCurrentPlatform() const;
 
    static ENGINE_API const FPlatformAudioCookOverrides* GetPlatformCompressionOverridesForCurrentPlatform();
 
    /*
    * Returns a sample rate if there is a specific sample rate override for this platform, -1.0 otherwise.
    */
    ENGINE_API float GetSampleRateForCompressionOverrides(const FPlatformAudioCookOverrides* CompressionOverrides) const;
 
    ENGINE_API void SetError(const TCHAR* InErrorMsg=nullptr);
    ENGINE_API void ResetError();
    ENGINE_API bool HasError() const;
 
#if WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    
    /*
    * Used to determine the loading behavior that's applied by the owner of this wave. Will determine
    * the most appropriate loading behavior if there are multiple owners. If there is no owner "Unintialized"
    * will be returned. The results are cached in TMap below.
    */
    ISoundWaveLoadingBehaviorUtil::FClassData GetOwnerLoadingBehavior(const ITargetPlatform* InTargetPlatform) const;
    
    mutable TMap<FName, ISoundWaveLoadingBehaviorUtil::FClassData> OwnerLoadingBehaviorCache;
    mutable FCriticalSection OwnerLoadingBehaviorCacheCS;
 
    /*
    * Returns this SoundWave's CuePoints array with the frame values scaled by
    * InSampleRate / ImportedSampleRate to account for resampling of the sound wave source data.
    * If no resampling is necessary, returns the CuePoints as-is.
    *
    * @param InSampleRate   The sample rate the SoundWave 
    * @return CuePoints array scaled if resampling occurred
    */
    ENGINE_API TArray<FSoundWaveCuePoint> GetCuePointsScaledForSampleRate(const float InSampleRate) const;
 
    /*
    * Modifies the InOutCuePoints array with the frame values scaled by
    * InSampleRate / ImportedSampleRate to account for resampling of the sound wave source data.
    * Does not modify InOutCuePoints if no resampling is necessary
    *
    * @param InSampleRate   The sample rate the SoundWave
    * @param InOutCuePoints The CuePoints array to re-scale
    */
    ENGINE_API void ScaleCuePointsForSampleRate(const float InSampleRate, TArray<FSoundWaveCuePoint>& InOutCuePoints) const;
 
    /*
    * Returns a sample rate if there is a specific sample rate override for this platform, -1.0 otherwise.
    */
    ENGINE_API float GetSampleRateForTargetPlatform(const ITargetPlatform* TargetPlatform);
    
    ENGINE_API float GetSizeOfFirstAudioChunkInSeconds(const ITargetPlatform* InTargetPlatform) const;
 
    ENGINE_API virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
 
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded(const ITargetPlatform* TargetPlatform) override;
 
    ENGINE_API virtual void ClearAllCachedCookedPlatformData() override;
 
    ENGINE_API virtual void ClearCachedCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
 
    ENGINE_API virtual void WillNeverCacheCookedPlatformDataAgain() override;
 
    ENGINE_API virtual bool GetRedrawThumbnail() const;
    ENGINE_API virtual void SetRedrawThumbnail(bool bInRedraw);
    ENGINE_API virtual bool CanVisualizeAsset() const;
 
#endif // WITH_EDITOR
 
    ENGINE_API virtual void CachePlatformData(bool bAsyncCache = false);
 
    ENGINE_API virtual void BeginCachePlatformData();
 
    ENGINE_API virtual void FinishCachePlatformData();
 
    ENGINE_API void ForceRebuildPlatformData();
#endif // WITH_EDITORONLY_DATA
 
    ENGINE_API bool GetChunkData(int32 ChunkIndex, uint8** OutChunkData, bool bMakeSureChunkIsLoaded = false);
 
    void SetPrecacheState(ESoundWavePrecacheState InState)
    {
        PrecacheState.Set((int32)InState);
    }
 
    ESoundWavePrecacheState GetPrecacheState() const
    {
        return (ESoundWavePrecacheState)PrecacheState.GetValue();
    }
 
 
private:
    TSharedPtr<FSoundWaveData, ESPMode::ThreadSafe> SoundWaveDataPtr{ MakeShared<FSoundWaveData>() };
 
    friend class FSoundWaveProxy;
    friend class USoundFactory;
};
 
 
class FSoundWaveData
{
public:
    UE_NONCOPYABLE(FSoundWaveData);
 
    FSoundWaveData()
        : bIsLooping(0)
        , bIsTemplate(0)
        , bIsStreaming(0)
        , bIsSeekable(0)
        , bShouldUseStreamCaching(0)
        , bLoadingBehaviorOverridden(0)
        , bHasError(0)
#if WITH_EDITOR
        , bLoadedFromCookedData(0)
#endif //WITH_EDITOR
    {
    }
 
    // dtor
    ENGINE_API ~FSoundWaveData();
 
    // non-const arg for internal call to FAudioDevice::GetRuntimeFormat
    ENGINE_API void InitializeDataFromSoundWave(USoundWave& InWave);
 
    ENGINE_API void OverrideRuntimeFormat(const FName& InRuntimeFormat);
 
    const FGuid& GetGUID() const { return WaveGuid; }
    const FName& GetFName() const { return NameCached; }
    const FName& GetPackageName() const { return PackageNameCached; }
    const FName& GetRuntimeFormat() const { return RuntimeFormat; }
    const FObjectKey& GetFObjectKey() const { return SoundWaveKeyCached; };
 
    float GetSampleRate() const { return SampleRate; }
    uint32 GetNumChannels() const { return NumChannels; }
    const TArray<FSoundWaveCuePoint>& GetCuePoints() const { return CuePoints; }
    const TArray<FSoundWaveCuePoint>& GetLoopRegions() const { return LoopRegions; }
    void SetAllCuePoints(const TArray<FSoundWaveCuePoint>& InCuePoints);
 
    ENGINE_API uint32 GetNumChunks() const;
    ENGINE_API uint32 GetSizeOfChunk(uint32 ChunkIndex) const;
    int32 GetNumFrames() const { return NumFrames; }
    float GetDuration() const { return Duration; }
 
    ENGINE_API void ReleaseCompressedAudio();
 
    ENGINE_API void SetError(const TCHAR* InErrorMsg=nullptr);  
    ENGINE_API bool HasError() const;
    ENGINE_API bool ResetError();
 
    bool IsStreaming() const { return bIsStreaming; }
    ESoundAssetCompressionType GetSoundCompressionType() const { return SoundAssetCompressionType; }
    bool IsLooping() const { return bIsLooping; }
    bool ShouldUseStreamCaching() const { return bShouldUseStreamCaching; }
    bool IsSeekable() const {  return bIsSeekable; }
    bool IsRetainingAudio() const {  return FirstChunk.IsValid(); }
    bool WasLoadingBehaviorOverridden() const { return bLoadingBehaviorOverridden; }
    ESoundWaveLoadingBehavior GetLoadingBehavior() const { return LoadingBehavior; }
 
    bool IsTemplate() const { return bIsTemplate; }
 
    ENGINE_API bool HasCompressedData(FName Format, ITargetPlatform* TargetPlatform = USoundWave::GetRunningPlatform()) const;
    ENGINE_API FByteBulkData* GetCompressedData(FName Format, const FPlatformAudioCookOverrides* CompressionOverrides = USoundWave::GetPlatformCompressionOverridesForCurrentPlatform());
 
    ENGINE_API bool GetChunkData(int32 ChunkIndex, uint8** OutChunkData, bool bMakeSureChunkIsLoaded = false);
 
    ENGINE_API bool IsZerothChunkDataLoaded() const;
    ENGINE_API const TArrayView<uint8> GetZerothChunkDataView() const;
 
    ENGINE_API bool HasChunkSeekTable(int32 InChunkIndex) const;
    ENGINE_API int32 FindChunkIndexForSeeking(uint32 InTimeInAudioFrames) const;
 
    // Returns true if the zeroth chunk is loaded, or attempts to load it if not already loaded,
    // returning true if the load was successful. Can return false if either an error was encountered
    // in attempting to load the chunk or if stream caching is not enabled for the given sound.
    ENGINE_API bool LoadZerothChunk();
 
 #if WITH_EDITOR
    ENGINE_API int32 GetCurrentChunkRevision() const;
 #endif // #if WITH_EDITOR
 
    ENGINE_API FStreamedAudioChunk& GetChunk(uint32 ChunkIndex);
    ENGINE_API int32 GetChunkFromDDC(int32 ChunkIndex, uint8** OutChunkData, bool bMakeSureChunkIsLoaded);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API FString GetDerivedDataKey() const;
    FPerPlatformFloat GetSizeOfFirstAudioChunkInSeconds() const { return SizeOfFirstAudioChunkInSeconds; }
#endif // #if WITH_EDITORONLY_DATA
 
    int32 GetResourceSize() { return ResourceSize; }
    const uint8* GetResourceData() const { return ResourceData.GetView().GetData(); }
    uint32 GetNumChannels() { return NumChannels; }
 
    void SetSampleRate(const int32 InSampleRate) { SampleRate = static_cast<float>(InSampleRate); }
    void SetNumFrames(const int32 InNumFrames) { NumFrames = InNumFrames; }
 
private:
    ENGINE_API void DiscardZerothChunkData();
 
    ENGINE_API FName FindRuntimeFormat(const USoundWave&) const;
 
    ENGINE_API void CacheRuntimeFormatDependentState(const FName InFormatName);
 
    FBulkDataBuffer<uint8> ZerothChunkData;
#if WITH_EDITOR
    mutable FCriticalSection LoadZerothChunkDataCriticalSection;
#endif
 
    /* Accessor to get the zeroth chunk which might perform additional work in editor to handle async tasks. */
    ENGINE_API FBulkDataBuffer<uint8>& GetZerothChunkData() const;
 
    FStreamedAudioPlatformData RunningPlatformData;
 
    FAudioChunkHandle FirstChunk;
 
    FFormatContainer CompressedFormatData;
 
    int32 ResourceSize = 0;
 
    FBulkDataBuffer<uint8> ResourceData;
 
    ESoundWaveLoadingBehavior LoadingBehavior = ESoundWaveLoadingBehavior::Uninitialized;
 
#if WITH_EDITORONLY_DATA
    // Set by CacheInheritedLoadingBehavior after traversing the Soundclass heirarchy 
    FPerPlatformFloat SizeOfFirstAudioChunkInSeconds = 0.f;
#endif //WITH_EDITORONLY_DATA
    
#if WITH_EDITOR
    int32 CurrentChunkRevision = 0;
#endif // #if WITH_EDITOR
 
    FName NameCached;
    FName PackageNameCached;
    FName RuntimeFormat{ "FSoundWaveProxy_InvalidFormat" };
    FObjectKey SoundWaveKeyCached;
    TArray<FSoundWaveCuePoint> CuePoints;
    TArray<FSoundWaveCuePoint> LoopRegions;
    ESoundAssetCompressionType SoundAssetCompressionType = ESoundAssetCompressionType::BinkAudio;
    FGuid WaveGuid;
    
    float SampleRate = 0;
    float Duration = 0;
 
    uint32 NumChannels = 0;
    int32 NumFrames = 0;
 
    // shared flags
    uint8 bIsLooping : 1;
    uint8 bIsTemplate : 1;
    uint8 bIsStreaming : 1;
    uint8 bIsSeekable : 1;
    uint8 bShouldUseStreamCaching : 1;
    uint8 bLoadingBehaviorOverridden : 1;
    uint8 bHasError : 1;
 
#if WITH_EDITOR
    uint8 bLoadedFromCookedData : 1;
#endif //WITH_EDITOR
 
    friend class USoundWave;
}; // class FSoundWaveData
 
using FSoundWaveProxyPtr = TSharedPtr<FSoundWaveProxy, ESPMode::ThreadSafe>;
class FSoundWaveProxy : public Audio::TProxyData<FSoundWaveProxy>
{
public:
    IMPL_AUDIOPROXY_CLASS(FSoundWaveProxy);
 
    ENGINE_API explicit FSoundWaveProxy(USoundWave* InWave);
 
    ENGINE_API FSoundWaveProxy(const FSoundWaveProxy& Other);
 
    ENGINE_API ~FSoundWaveProxy();
 
    // USoundWave Interface
    ENGINE_API void ReleaseCompressedAudio();
 
    // Returns true if the zeroth chunk is loaded, or attempts to load it if not already loaded,
    // returning true if the load was successful. Can return false if either an error was encountered
    // in attempting to load the chunk or if stream caching is not enabled for the given sound.
    ENGINE_API bool LoadZerothChunk();
    ENGINE_API bool GetChunkData(int32 ChunkIndex, uint8** OutChunkData, bool bMakeSureChunkIsLoaded = false);
 
    // Getters
    ENGINE_API const FName& GetFName() const;
    ENGINE_API const FName& GetPackageName() const;
    ENGINE_API const FName& GetRuntimeFormat() const;
    ENGINE_API const FObjectKey& GetFObjectKey() const;
 
    ENGINE_API float GetDuration() const;
    ENGINE_API float GetSampleRate() const;
 
    ENGINE_API int32 GetNumFrames() const;
    ENGINE_API uint32 GetNumChunks() const;
    ENGINE_API uint32 GetNumChannels() const;
    ENGINE_API uint32 GetSizeOfChunk(uint32 ChunkIndex) const;
    ENGINE_API const TArray<FSoundWaveCuePoint>& GetCuePoints() const;
    ENGINE_API const TArray<FSoundWaveCuePoint>& GetLoopRegions() const;
    ENGINE_API const TArray<FSoundWaveCuePoint> GetCuePointsAndLoopRegions() const;
 
    ENGINE_API bool IsLooping() const;
    ENGINE_API bool IsTemplate() const;
    ENGINE_API bool IsStreaming() const;
    ENGINE_API bool IsRetainingAudio() const;
    ENGINE_API bool ShouldUseStreamCaching() const;
    ENGINE_API bool IsSeekable() const;
    ENGINE_API bool IsZerothChunkDataLoaded() const;
    ENGINE_API bool WasLoadingBehaviorOverridden() const;
    ENGINE_API bool HasCompressedData(FName Format, ITargetPlatform* TargetPlatform = USoundWave::GetRunningPlatform()) const;
 
    ENGINE_API ESoundWaveLoadingBehavior GetLoadingBehavior() const;
 
    ENGINE_API const TArrayView<uint8> GetZerothChunkDataView() const;
 
    ENGINE_API FByteBulkData* GetCompressedData(FName Format, const FPlatformAudioCookOverrides* CompressionOverrides = USoundWave::GetPlatformCompressionOverridesForCurrentPlatform());
 
    static ENGINE_API TArrayView<const uint8> GetZerothChunk(const FSoundWaveProxyPtr& SoundWaveProxy, bool bForImmediatePlayback = false);
 
 
#if WITH_EDITOR
    ENGINE_API int32 GetCurrentChunkRevision() const;
#endif // #if WITH_EDITOR
 
    ENGINE_API FStreamedAudioChunk& GetChunk(uint32 ChunkIndex);
    ENGINE_API int32 GetChunkFromDDC(int32 ChunkIndex, uint8** OutChunkData, bool bMakeSureChunkIsLoaded);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API FString GetDerivedDataKey() const;
#endif // #if WITH_EDITORONLY_DATA
 
    ENGINE_API int32 GetResourceSize() const;
    ENGINE_API const uint8* GetResourceData() const;
 
    ENGINE_API const FSoundWavePtr GetSoundWaveData();
    
    friend inline uint32 GetTypeHash(const FSoundWaveProxy& InProxy)
    {
        return InProxy.TypeHash;
    }
    
private:
    TSharedPtr<FSoundWaveData, ESPMode::ThreadSafe> SoundWaveDataPtr;
    uint32 TypeHash = uint32(INDEX_NONE);
};