SoundWaveProxyReader.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "DSP/BufferVectorOperations.h"
#include "AudioDecompress.h"
#include "HAL/Platform.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
 
// Forward declare
class FSoundWaveProxy;
 
class FSoundWaveProxyReader
{
 
public:
    using FSoundWaveProxyRef = TSharedRef<FSoundWaveProxy, ESPMode::ThreadSafe>;
 
    static constexpr uint32 DefaultMinDecodeSizeInFrames = 128;
 
    static constexpr uint32 DecodeSizeQuantizationInFrames = 128;
 
    static uint32 ConformDecodeSize(uint32 InMaxDesiredDecodeSizeInFrames);
 
    static constexpr float MinLoopDurationInSeconds = 0.05f;
 
    static constexpr float MaxLoopDurationInSeconds = 60.f * 60.f * 365.f * 10.f;
 
    struct FSettings
    {
        uint32 MaxDecodeSizeInFrames = 1024;
        float StartTimeInSeconds = 0.f;
        bool bIsLooping = false;
        float LoopStartTimeInSeconds = 0.f;
        float LoopDurationInSeconds = 0.f;
        bool bMaintainAudioSync = false;
    };
 
private:
    FSoundWaveProxyReader(FSoundWaveProxyRef InWaveProxy, const FSettings& InSettings);
 
public:
    static ENGINE_API TUniquePtr<FSoundWaveProxyReader> Create(FSoundWaveProxyRef InWaveProxy, const FSettings& InSettings);
 
    ENGINE_API void SetIsLooping(bool bInIsLooping);
 
    inline bool IsLooping() const
    {
        return Settings.bIsLooping;
    }
 
    ENGINE_API void SetLoopStartTime(float InLoopStartTimeInSeconds);
 
    ENGINE_API void SetLoopDuration(float InLoopDurationInSeconds);
 
    inline float GetSampleRate() const
    {
        return SampleRate;
    }
 
    inline int32 GetNumChannels() const
    {
        return NumChannels;
    }
 
    inline int32 GetFrameIndex() const
    {
        return CurrentFrameIndex;
    }
 
    inline int32 GetNumFramesInWave() const
    {
        return NumFramesInWave;
    }
 
    inline int32 GetNumFramesInLoop() const
    {
        return LoopEndFrameIndex - LoopStartFrameIndex;
    }
 
    inline int32 GetLoopStartFrameIndex() const
    {
        return LoopStartFrameIndex;
    }
 
    inline int32 GetLoopEndFrameIndex() const
    {
        return LoopEndFrameIndex;
    }
 
    ENGINE_API bool SeekToTime(float InSeconds);
 
    ENGINE_API bool SeekToFrame(uint32 InFrameNum);
 
 
    ENGINE_API int32 PopAudio(Audio::FAlignedFloatBuffer& OutBuffer);
 
    ENGINE_API bool CanProduceMoreAudio() const;
 
    bool HasFailed() const
    { 
        return DecodeResult == EDecodeResult::Fail; 
    }
 
private:
 
    enum class EDecodeResult
    {
        Fail,                   // Decoder failed somehow.
        MoreDataRemaining,      // Data has produced and there's more remaining
        Finished                // The decoder has reached the end of the wave data
    };
 
    EDecodeResult Decode();
 
    int32 PopAudioFromDecoderOutput(TArrayView<float> OutBufferView);
    bool InitializeDecoder(float InStartTimeInSeconds);
    int32 DiscardSamples(int32 InNumSamplesToDiscard);
    float ClampLoopStartTime(float InStartTimeInSeconds);
    float ClampLoopDuration(float InDurationInSeconds);
    void UpdateLoopBoundaries();
 
    FSoundWaveProxyRef WaveProxy;
 
    FSettings Settings;
 
    float SampleRate = 0.f;
    int32 NumChannels = 0;
    EDecodeResult DecodeResult = EDecodeResult::MoreDataRemaining;
    int32 NumFramesInWave = 0;
    int32 NumDecodeSamplesToDiscard = 0;
    int32 CurrentFrameIndex = 0;
    int32 LoopStartFrameIndex = 0;
    int32 LoopEndFrameIndex = -1;
    float DurationInSeconds = 0.f;
    float MaxLoopStartTimeInSeconds = 0.f;
 
    bool bIsDecoderValid = false;
    bool bFallbackSeekMethodWarningLogged = false;
 
private:
    mutable TUniquePtr<class ICompressedAudioInfo> CompressedAudioInfo;
    Audio::TCircularAudioBuffer<float> DecoderOutput;
 
    TArray<int16> ResidualBuffer;
    Audio::FAlignedFloatBuffer SampleConversionBuffer;
 
    static constexpr uint32 MinNumFramesPerDecode = 1;
 
    bool bIsFirstDecode = true;
    bool bPreviousIsStreaming = true;
    uint32 NumFramesPerDecode = MinNumFramesPerDecode;
};