AudioMixerBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "AudioMixer.h"
#include "Audio.h"
 
namespace Audio
{
    namespace EBufferType
    {
        enum Type
        {
            PCM,
            PCMPreview,
            PCMRealTime,
            Streaming,
            Invalid,
        };
    }
 
    class FMixerDevice;
    class FMixerBuffer;
    class IAudioTask;
 
    class FMixerBuffer : public FSoundBuffer
    {
    public:
        FMixerBuffer(FAudioDevice* InAudioDevice, USoundWave* InWave, EBufferType::Type InBufferType);
        ~FMixerBuffer();
 
        //~ Begin FSoundBuffer Interface
        int32 GetSize() override;
        int32 GetCurrentChunkIndex() const override;
        int32 GetCurrentChunkOffset() const override;
        bool IsRealTimeSourceReady() override;
        bool ReadCompressedInfo(USoundWave* SoundWave) override;
        void Seek(const float SeekTime) override;
        //~ End FSoundBuffer Interface
 
        static FMixerBuffer* Init(FAudioDevice* AudioDevice, USoundWave* InWave, bool bForceRealtime);
        static FMixerBuffer* CreatePreviewBuffer(FAudioDevice* AudioDevice, USoundWave* InWave);
        static FMixerBuffer* CreateProceduralBuffer(FAudioDevice* AudioDevice, USoundWave* InWave);
        static FMixerBuffer* CreateNativeBuffer(FAudioDevice* AudioDevice, USoundWave* InWave);
        static FMixerBuffer* CreateStreamingBuffer(FAudioDevice* AudioDevice, USoundWave* InWave);
        static FMixerBuffer* CreateRealTimeBuffer(FAudioDevice* AudioDevice, USoundWave* InWave);
 
        EBufferType::Type GetType() const;
        bool IsRealTimeBuffer() const;
 
        ICompressedAudioInfo* GetDecompressionState(bool bTakesOwnership = false);
 
        void GetPCMData(uint8** OutData, uint32* OutDataSize);
 
        void EnsureHeaderParseTaskFinished();
 
        float GetSampleRate() const { return SampleRate; }
        int32 GetNumChannels() const { return NumChannels; }
        uint32 GetNumFrames() const { return NumFrames; }
        void InitSampleRate(const float InSampleRate) { SampleRate = InSampleRate; }
        void InitNumFrames(const uint32 InNumFrames) { NumFrames = InNumFrames; }
 
    private:
 
        IAudioTask* RealtimeAsyncHeaderParseTask;
 
        ICompressedAudioInfo* DecompressionState;
 
        EBufferType::Type BufferType;
 
        int32 SampleRate;
 
        uint32 NumFrames;
 
        int16 BitsPerSample;
 
        uint8* Data;
 
        uint32 DataSize;
 
        FThreadSafeBool bIsRealTimeSourceReady;
 
        bool bIsDynamicResource;
    };
}
 
inline const TCHAR* LexToString(const Audio::EBufferType::Type In)
{
#define CASE_TO_STRING(X) case X: return TEXT(#X);
    using namespace Audio::EBufferType;
    switch(In)
    {
        CASE_TO_STRING(Invalid);
        CASE_TO_STRING(PCMPreview)
        CASE_TO_STRING(PCMRealTime)
        CASE_TO_STRING(Streaming)
        default: return TEXT("Unknown");
    }
#undef CASE_TO_STRING
}