423 lines
11 KiB
C++
423 lines
11 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "AudioMixerPlatformSDL.h"
|
|
#include "Modules/ModuleManager.h"
|
|
#include "AudioMixer.h"
|
|
#include "AudioMixerDevice.h"
|
|
#include "CoreGlobals.h"
|
|
#include "Misc/ConfigCacheIni.h"
|
|
#include "AudioDevice.h"
|
|
|
|
#if WITH_ENGINE
|
|
#include "AudioPluginUtilities.h"
|
|
#endif // WITH_ENGINE
|
|
|
|
DECLARE_LOG_CATEGORY_EXTERN(LogAudioMixerSDL, Log, All);
|
|
DEFINE_LOG_CATEGORY(LogAudioMixerSDL);
|
|
|
|
namespace Audio
|
|
{
|
|
// Static callback function used in SDL
|
|
|
|
static void SDLCALL OnBufferEndWrapper(void* UserData, SDL_AudioStream* Stream, int AdditionalAmount, int TotalAmount)
|
|
{
|
|
if (AdditionalAmount > 0)
|
|
{
|
|
FMixerPlatformSDL* MixerPlatform = (FMixerPlatformSDL*)UserData;
|
|
int OutputBufferByteLength = MixerPlatform->GetOutputBufferByteLength();
|
|
|
|
Uint8* Data = SDL_stack_alloc(Uint8, OutputBufferByteLength);
|
|
if (Data)
|
|
{
|
|
MixerPlatform->HandleOnBufferEnd(Data, OutputBufferByteLength);
|
|
SDL_PutAudioStreamData(Stream, Data, OutputBufferByteLength);
|
|
SDL_stack_free(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
FMixerPlatformSDL::FMixerPlatformSDL()
|
|
: AudioDeviceID(INDEX_NONE)
|
|
, AudioStream(nullptr)
|
|
, OutputBuffer(nullptr)
|
|
, OutputBufferByteLength(0)
|
|
, bSuspended(false)
|
|
, bInitialized(false)
|
|
{
|
|
}
|
|
|
|
FMixerPlatformSDL::~FMixerPlatformSDL()
|
|
{
|
|
if (bInitialized)
|
|
{
|
|
TeardownHardware();
|
|
}
|
|
}
|
|
|
|
bool FMixerPlatformSDL::InitializeHardware()
|
|
{
|
|
if (bInitialized)
|
|
{
|
|
UE_LOG(LogAudioMixerSDL, Error, TEXT("SDL Audio already initialized."));
|
|
return false;
|
|
}
|
|
|
|
int32 Result = SDL_InitSubSystem(SDL_INIT_AUDIO);
|
|
if (Result < 0)
|
|
{
|
|
UE_LOG(LogAudioMixerSDL, Error, TEXT("SDL_InitSubSystem create failed: %d"), Result);
|
|
return false;
|
|
}
|
|
|
|
const char* DriverName = SDL_GetCurrentAudioDriver();
|
|
UE_LOG(LogAudioMixerSDL, Display, TEXT("Initialized SDL using %s platform API backend."), ANSI_TO_TCHAR(DriverName));
|
|
|
|
if (IAudioMixer::ShouldRecycleThreads())
|
|
{
|
|
// Pre-create the null render device thread so we can simple wake it up when we need it.
|
|
// Give it nothing to do, with a slow tick as the default, but ask it to wait for a signal to wake up.
|
|
CreateNullDeviceThread([] {}, 1.0f, true);
|
|
}
|
|
|
|
bInitialized = true;
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::TeardownHardware()
|
|
{
|
|
if(!bInitialized)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
StopAudioStream();
|
|
CloseAudioStream();
|
|
|
|
// this is refcounted
|
|
SDL_QuitSubSystem(SDL_INIT_AUDIO);
|
|
bInitialized = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::IsInitialized() const
|
|
{
|
|
return bInitialized;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::GetNumOutputDevices(uint32& OutNumOutputDevices)
|
|
{
|
|
if (!bInitialized)
|
|
{
|
|
UE_LOG(LogAudioMixerSDL, Error, TEXT("SDL3 Audio is not initialized."));
|
|
return false;
|
|
}
|
|
|
|
int NumDevices = 0;
|
|
SDL_AudioDeviceID* Devices = SDL_GetAudioPlaybackDevices(&NumDevices);
|
|
OutNumOutputDevices = NumDevices;
|
|
SDL_free(Devices);
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::GetOutputDeviceInfo(const uint32 InDeviceID, FAudioPlatformDeviceInfo& OutInfo)
|
|
{
|
|
FAudioPlatformSettings PlatformSettings = GetPlatformSettings();
|
|
AudioSpec = { GetPlatformAudioFormat(), GetPlatformChannels(), PlatformSettings.SampleRate };
|
|
|
|
FString DeviceName;
|
|
int NumDevices = 0;
|
|
SDL_AudioDeviceID* Devices = SDL_GetAudioPlaybackDevices(&NumDevices);
|
|
|
|
if (NumDevices)
|
|
{
|
|
SDL_AudioDeviceID DevId;
|
|
|
|
if (InDeviceID != AUDIO_MIXER_DEFAULT_DEVICE_INDEX)
|
|
{
|
|
DevId = Devices[InDeviceID];
|
|
}
|
|
else
|
|
{
|
|
DevId = SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK;
|
|
}
|
|
|
|
const char* AudioDeviceName = nullptr;
|
|
|
|
AudioDeviceName = SDL_GetAudioDeviceName(DevId);
|
|
DeviceName = ANSI_TO_TCHAR(AudioDeviceName);
|
|
|
|
SDL_free(Devices);
|
|
Devices = nullptr;
|
|
}
|
|
|
|
|
|
// opening a physical device no longer changes the spec we pass in, so there's no reason to bother with any of the previous code.
|
|
// Just take the device instance we have and return exactly what we asked for. The backend automatically takes care of making sure
|
|
// the physical device is actually set to a capable sample rate, etc to accommodate our requested format
|
|
OutInfo.DeviceId = DeviceName;
|
|
OutInfo.Name = DeviceName;
|
|
OutInfo.SampleRate = PlatformSettings.SampleRate; // sample rate conversion now happens in the SDL audio code, so our code can send whatever we like
|
|
OutInfo.Format = GetAudioStreamFormat();
|
|
OutInfo.NumChannels = FMath::Min<int32>(static_cast<int32>(GetPlatformChannels()), AUDIO_MIXER_MAX_OUTPUT_CHANNELS);
|
|
|
|
// Assume default channel map order, SDL doesn't support us querying it directly
|
|
OutInfo.OutputChannelArray.Reset();
|
|
for (int32 i = 0; i < OutInfo.NumChannels; ++i)
|
|
{
|
|
OutInfo.OutputChannelArray.Add(EAudioMixerChannel::Type(i));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::GetDefaultOutputDeviceIndex(uint32& OutDefaultDeviceIndex) const
|
|
{
|
|
// It's not possible to know what index the default audio device is.
|
|
OutDefaultDeviceIndex = AUDIO_MIXER_DEFAULT_DEVICE_INDEX;
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::OpenAudioStream(const FAudioMixerOpenStreamParams& Params)
|
|
{
|
|
if (!bInitialized || AudioStreamInfo.StreamState != EAudioOutputStreamState::Closed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int NumOutputDevices = 0;
|
|
SDL_AudioDeviceID* Devices = SDL_GetAudioPlaybackDevices(&NumOutputDevices);
|
|
if (!Devices || NumOutputDevices == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
OpenStreamParams = Params;
|
|
|
|
if (OpenStreamParams.OutputDeviceIndex!= AUDIO_MIXER_DEFAULT_DEVICE_INDEX)
|
|
{
|
|
AudioDeviceID = Devices[OpenStreamParams.OutputDeviceIndex];
|
|
}
|
|
else
|
|
{
|
|
AudioDeviceID = SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK;
|
|
}
|
|
SDL_free(Devices);
|
|
Devices = nullptr;
|
|
|
|
AudioStreamInfo.Reset();
|
|
AudioStreamInfo.AudioMixer = OpenStreamParams.AudioMixer;
|
|
AudioStreamInfo.NumOutputFrames = OpenStreamParams.NumFrames;
|
|
AudioStreamInfo.NumBuffers = OpenStreamParams.NumBuffers;
|
|
AudioStreamInfo.DeviceInfo.SampleRate = OpenStreamParams.SampleRate;
|
|
|
|
// If there's an available device, open it.
|
|
if (NumOutputDevices > 0)
|
|
{
|
|
if (!GetOutputDeviceInfo(AudioStreamInfo.OutputDeviceIndex, AudioStreamInfo.DeviceInfo))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
AudioStreamInfo.OutputDeviceIndex = OpenStreamParams.OutputDeviceIndex;
|
|
|
|
AudioSpec.format = GetPlatformAudioFormat();
|
|
AudioSpec.freq = Params.SampleRate;
|
|
AudioSpec.channels = AudioStreamInfo.DeviceInfo.NumChannels;
|
|
|
|
const char* DeviceName = nullptr;
|
|
DeviceName = SDL_GetAudioDeviceName(AudioDeviceID);
|
|
|
|
// only the default device can be overriden
|
|
FString CurrentDeviceNameString = GetCurrentDeviceName();
|
|
if (OpenStreamParams.OutputDeviceIndex != AUDIO_MIXER_DEFAULT_DEVICE_INDEX || CurrentDeviceNameString.Len() <= 0)
|
|
{
|
|
UE_LOG(LogAudioMixerSDL, Log, TEXT("Opening %s audio device (device index %d)"), DeviceName ? ANSI_TO_TCHAR(DeviceName) : TEXT("default"), OpenStreamParams.OutputDeviceIndex);
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogAudioMixerSDL, Log, TEXT("Opening overridden '%s' audio device (device index %d)"), *CurrentDeviceNameString, OpenStreamParams.OutputDeviceIndex);
|
|
}
|
|
|
|
AudioStream = SDL_OpenAudioDeviceStream(AudioDeviceID, &AudioSpec, OnBufferEndWrapper, (void*)this);
|
|
|
|
if (!AudioStream)
|
|
{
|
|
const char* ErrorText = SDL_GetError();
|
|
UE_LOG(LogAudioMixerSDL, Error, TEXT("%s"), ANSI_TO_TCHAR(ErrorText));
|
|
return false;
|
|
}
|
|
|
|
// Compute the expected output byte length
|
|
OutputBufferByteLength = OpenStreamParams.NumFrames * AudioStreamInfo.DeviceInfo.NumChannels * GetAudioStreamChannelSize();
|
|
}
|
|
else
|
|
{
|
|
// No devices available, Switch to NULL (Silent) Output.
|
|
AudioStreamInfo.DeviceInfo.OutputChannelArray = { EAudioMixerChannel::FrontLeft, EAudioMixerChannel::FrontRight };
|
|
AudioStreamInfo.DeviceInfo.NumChannels = 2;
|
|
AudioStreamInfo.DeviceInfo.Format = EAudioMixerStreamDataFormat::Float;
|
|
}
|
|
|
|
bInitialized = true;
|
|
AudioStreamInfo.StreamState = EAudioOutputStreamState::Open;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::CloseAudioStream()
|
|
{
|
|
if (AudioStreamInfo.StreamState == EAudioOutputStreamState::Closed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!StopAudioStream())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (AudioStream != nullptr)
|
|
{
|
|
FScopeLock ScopedLock(&OutputBufferMutex);
|
|
|
|
SDL_DestroyAudioStream(AudioStream);
|
|
AudioStream = nullptr;
|
|
OutputBuffer = nullptr;
|
|
OutputBufferByteLength = 0;
|
|
}
|
|
|
|
AudioStreamInfo.StreamState = EAudioOutputStreamState::Closed;
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::StartAudioStream()
|
|
{
|
|
if (!bInitialized || (AudioStreamInfo.StreamState != EAudioOutputStreamState::Open && AudioStreamInfo.StreamState != EAudioOutputStreamState::Stopped))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Start generating audio
|
|
BeginGeneratingAudio();
|
|
|
|
if (AudioStream != nullptr)
|
|
{
|
|
// Unpause audio device to start it rendering audio
|
|
SDL_ResumeAudioStreamDevice(AudioStream);
|
|
}
|
|
else
|
|
{
|
|
check(!bIsUsingNullDevice);
|
|
StartRunningNullDevice();
|
|
}
|
|
|
|
AudioStreamInfo.StreamState = EAudioOutputStreamState::Running;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FMixerPlatformSDL::StopAudioStream()
|
|
{
|
|
if (!bInitialized)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (AudioStreamInfo.StreamState != EAudioOutputStreamState::Stopped && AudioStreamInfo.StreamState != EAudioOutputStreamState::Closed)
|
|
{
|
|
if (AudioStream != nullptr)
|
|
{
|
|
// Pause the audio device
|
|
SDL_PauseAudioStreamDevice(AudioStream);
|
|
}
|
|
else
|
|
{
|
|
check(bIsUsingNullDevice);
|
|
StopRunningNullDevice();
|
|
}
|
|
|
|
if (AudioStreamInfo.StreamState == EAudioOutputStreamState::Running)
|
|
{
|
|
StopGeneratingAudio();
|
|
}
|
|
|
|
check(AudioStreamInfo.StreamState == EAudioOutputStreamState::Stopped);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
FAudioPlatformDeviceInfo FMixerPlatformSDL::GetPlatformDeviceInfo() const
|
|
{
|
|
return AudioStreamInfo.DeviceInfo;
|
|
}
|
|
|
|
void FMixerPlatformSDL::SubmitBuffer(const uint8* Buffer)
|
|
{
|
|
// Need to prevent the case in which we close down the audio stream leaving this point to potentially corrupt the free'ed pointer
|
|
FScopeLock ScopedLock(&OutputBufferMutex);
|
|
|
|
if (OutputBuffer)
|
|
{
|
|
FMemory::Memcpy(OutputBuffer, Buffer, OutputBufferByteLength);
|
|
}
|
|
}
|
|
|
|
void FMixerPlatformSDL::HandleOnBufferEnd(uint8* InOutputBuffer, int32 InOutputBufferByteLength)
|
|
{
|
|
if (!bIsDeviceInitialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
OutputBuffer = InOutputBuffer;
|
|
check(InOutputBufferByteLength == OutputBufferByteLength);
|
|
|
|
ReadNextBuffer();
|
|
}
|
|
|
|
FString FMixerPlatformSDL::GetDefaultDeviceName()
|
|
{
|
|
static FString DefaultName(TEXT("Default SDL Audio Device."));
|
|
return DefaultName;
|
|
}
|
|
|
|
void FMixerPlatformSDL::ResumeContext()
|
|
{
|
|
if (bSuspended)
|
|
{
|
|
if (AudioStream != nullptr)
|
|
{
|
|
SDL_ResumeAudioStreamDevice(AudioStream);
|
|
UE_LOG(LogAudioMixerSDL, Display, TEXT("Resuming Audio"));
|
|
bSuspended = false;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void FMixerPlatformSDL::SuspendContext()
|
|
{
|
|
if (!bSuspended)
|
|
{
|
|
if (AudioStream != nullptr)
|
|
{
|
|
SDL_PauseAudioStreamDevice(AudioStream);
|
|
UE_LOG(LogAudioMixerSDL, Display, TEXT("Suspending Audio"));
|
|
bSuspended = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
FAudioPlatformSettings FMixerPlatformSDL::GetPlatformSettings() const
|
|
{
|
|
#if PLATFORM_UNIX
|
|
return FAudioPlatformSettings::GetPlatformSettings(FPlatformProperties::GetRuntimeSettingsClassName());
|
|
#else
|
|
// On Windows, use default parameters.
|
|
return FAudioPlatformSettings();
|
|
#endif
|
|
}
|
|
}
|