IOSAudioDevice.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    IOSAudioDevice.h: Unreal IOSAudio audio interface object.
 =============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "AudioEffect.h"
#include "AudioDevice.h"
#include "Sound/SoundWave.h"
#include "DSP/ParamInterpolator.h"
#include "DSP/OnePole.h"
 
/*------------------------------------------------------------------------------------
    Audio Framework system headers
 ------------------------------------------------------------------------------------*/
#include <AudioToolbox/AudioToolbox.h>
#include <AudioUnit/AudioUnit.h>
#include <AVFoundation/AVAudioSession.h>
 
#define AudioSampleType SInt16
 
DECLARE_LOG_CATEGORY_EXTERN(LogIOSAudio, Log, All);
 
/*------------------------------------------------------------------------------------
    Dependencies, helpers & forward declarations.
------------------------------------------------------------------------------------*/
 
#define CHANNELS_PER_BUS 2
#define AudioCallbackFrameSize  (8 * 1024)  // This needs to be known ahead of time to allocate appropriate buffers
 
struct FWaveInstance;
class FIOSAudioDevice;
class FIOSAudioEffectsManager;
class ICompressedAudioInfo;
 
enum ESoundFormat
{
    SoundFormat_Invalid,
    SoundFormat_LPCM,
    SoundFormat_ADPCM
};
 
class FIOSAudioSoundBuffer : public FSoundBuffer
{
public:
    FIOSAudioSoundBuffer(FIOSAudioDevice* InAudioDevice, USoundWave* InWave, bool InStreaming, bool InProcedural);
    virtual ~FIOSAudioSoundBuffer(void);
 
    static FIOSAudioSoundBuffer* Init(FIOSAudioDevice* IOSAudioDevice, USoundWave* InWave);
    
    virtual int32 GetSize(void) override;
    
    // These are used by the streaming engine to manage loading/unloading of chunks
    virtual int32 GetCurrentChunkIndex() const override;
    virtual int32 GetCurrentChunkOffset() const override;
 
    virtual bool ReadCompressedInfo(USoundWave* SoundWave) override;
 
    virtual bool ReadCompressedData( uint8* Destination, int32 NumFramesToDecode, bool bLooping ) override;
    
    bool ReleaseCurrentChunk();
    
    int32  RenderCallbackBufferSize;
    int32  SampleRate;
    int32  SoundFormat;
    int16* SampleData;
    uint32 BufferSize;
    
    ICompressedAudioInfo*       DecompressionState;
    bool    bStreaming;
    bool    bIsProcedural;
};
 
class FIOSAudioSoundSource : public FSoundSource
{
public:
    FIOSAudioSoundSource(FIOSAudioDevice* InAudioDevice, uint32 InBusNumber);
    
    ~FIOSAudioSoundSource(void);
    
    virtual bool Init(FWaveInstance* WaveInstance) override;
    
    virtual void Update(void) override;
    
    virtual void Play(void) override;
    
    virtual void Stop(void) override;
    
    virtual void Pause(void) override;
    
    virtual bool IsFinished(void) override;
 
    AudioUnitElement GetAudioUnitElement(int32 Channel);
 
    TArray<Audio::FOnePoleLPF> LowpassFilterBank;
    TArray<Audio::FParam> LPFParamBank;
    
    int32 SampleRate;
    
    // Cached version of Source->LPFFrequency.
    float SourceLPFFrequency;
    
protected:
    bool AttachToAUGraph();
    bool DetachFromAUGraph();
 
    FIOSAudioDevice*      IOSAudioDevice;
    
    FIOSAudioSoundBuffer* IOSBuffer;
    uint32                BusNumber;
    
    int32   CallbackLock;
    
    bool    bChannel0Finished;
    bool    bAllChannelsFinished;
 
private:
    
    static OSStatus IOSAudioRenderCallback(void *InRefCon, AudioUnitRenderActionFlags *IOActionFlags,
                                           const AudioTimeStamp *InTimeStamp, UInt32 InBusNumber,
                                           UInt32 InNumberFrames, AudioBufferList *IOData);
 
    void CleanupAudioBuffer();
 
    friend class FIOSAudioDevice;
};
 
class FIOSAudioDevice : public FAudioDevice
{
public:
    FIOSAudioDevice();
    virtual ~FIOSAudioDevice() { }      
 
    AUGraph GetAudioUnitGraph() const { return AudioUnitGraph; }
    AUNode GetMixerNode() const { return MixerNode; }
    AudioUnit GetMixerUnit() const { return MixerUnit; }
    AudioUnit GetOutputUnit() const { return OutputUnit; }
 
    virtual void ResumeContext();
    virtual void SuspendContext();
    
    virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar = *GLog ) override;
 
    virtual void UpdateDeviceDeltaTime() override;
    
    static void IncrementSuspendCounter();
    static void DecrementSuspendCounter();
 
protected:
    virtual bool InitializeHardware() override;
 
    virtual void TeardownHardware() override;
 
    virtual void UpdateHardware() override;
 
    virtual FAudioEffectsManager* CreateEffectsManager() override;
 
    virtual FSoundSource* CreateSoundSource() override;
 
    void GetHardwareSampleRate(double& OutSampleRate);
    bool SetHardwareSampleRate(const double& InSampleRate);
    bool SetAudioSessionActive(bool bActive);
 
    virtual bool IsExernalBackgroundSoundActive() override;
 
    virtual FAudioPlatformSettings GetPlatformSettings() const override;
 
private:
 
    // Used to support adpcm streaming
    virtual bool HasCompressedAudioInfoClass(USoundWave* SoundWave) override { return true; }   
 
    void HandleError(const TCHAR* InLogOutput, bool bTeardown = false);
 
    AudioStreamBasicDescription MixerFormat;
    AUGraph                     AudioUnitGraph;
    AUNode                      OutputNode;
    AudioUnit                   OutputUnit;
    AUNode                      MixerNode;
    AudioUnit                   MixerUnit;
    FVector                     PlayerLocation;
    FVector                     PlayerFacing;
    FVector                     PlayerUp;
    FVector                     PlayerRight;
    int32                       NextBusNumber;
 
    friend class FIOSAudioSoundBuffer;
    friend class FIOSAudioSoundSource;
};