Turánszki János
1338 lines
42 KiB
C++
1338 lines
42 KiB
C++
#include "wiAudio.h"
|
|
#include "wiBacklog.h"
|
|
#include "wiHelper.h"
|
|
#include "wiTimer.h"
|
|
#include "wiVector.h"
|
|
|
|
#define STB_VORBIS_HEADER_ONLY
|
|
#include "Utility/stb_vorbis.c"
|
|
|
|
#include <sstream>
|
|
|
|
template<typename T>
|
|
static constexpr T AlignTo(T value, T alignment)
|
|
{
|
|
return ((value + alignment - T(1)) / alignment) * alignment;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include <wrl/client.h> // ComPtr
|
|
#include <xaudio2.h>
|
|
#include <xaudio2fx.h>
|
|
#include <x3daudio.h>
|
|
#pragma comment(lib,"xaudio2.lib")
|
|
|
|
//Little-Endian things:
|
|
#define fourccRIFF 'FFIR'
|
|
#define fourccDATA 'atad'
|
|
#define fourccFMT ' tmf'
|
|
#define fourccWAVE 'EVAW'
|
|
#define fourccXWMA 'AMWX'
|
|
#define fourccDPDS 'sdpd'
|
|
|
|
#define xaudio_assert(cond, fname) { wilog_assert(cond, "XAudio2 error: %s failed with %s (%s:%d)", fname, wi::helper::GetPlatformErrorString(hr).c_str(), relative_path(__FILE__), __LINE__); }
|
|
#define xaudio_check(call) [&]() { HRESULT hr = call; xaudio_assert(SUCCEEDED(hr), extract_function_name(#call).c_str()); return hr; }()
|
|
|
|
namespace wi::audio
|
|
{
|
|
static const XAUDIO2FX_REVERB_I3DL2_PARAMETERS reverbPresets[] =
|
|
{
|
|
XAUDIO2FX_I3DL2_PRESET_DEFAULT,
|
|
XAUDIO2FX_I3DL2_PRESET_GENERIC,
|
|
XAUDIO2FX_I3DL2_PRESET_FOREST,
|
|
XAUDIO2FX_I3DL2_PRESET_PADDEDCELL,
|
|
XAUDIO2FX_I3DL2_PRESET_ROOM,
|
|
XAUDIO2FX_I3DL2_PRESET_BATHROOM,
|
|
XAUDIO2FX_I3DL2_PRESET_LIVINGROOM,
|
|
XAUDIO2FX_I3DL2_PRESET_STONEROOM,
|
|
XAUDIO2FX_I3DL2_PRESET_AUDITORIUM,
|
|
XAUDIO2FX_I3DL2_PRESET_CONCERTHALL,
|
|
XAUDIO2FX_I3DL2_PRESET_CAVE,
|
|
XAUDIO2FX_I3DL2_PRESET_ARENA,
|
|
XAUDIO2FX_I3DL2_PRESET_HANGAR,
|
|
XAUDIO2FX_I3DL2_PRESET_CARPETEDHALLWAY,
|
|
XAUDIO2FX_I3DL2_PRESET_HALLWAY,
|
|
XAUDIO2FX_I3DL2_PRESET_STONECORRIDOR,
|
|
XAUDIO2FX_I3DL2_PRESET_ALLEY,
|
|
XAUDIO2FX_I3DL2_PRESET_CITY,
|
|
XAUDIO2FX_I3DL2_PRESET_MOUNTAINS,
|
|
XAUDIO2FX_I3DL2_PRESET_QUARRY,
|
|
XAUDIO2FX_I3DL2_PRESET_PLAIN,
|
|
XAUDIO2FX_I3DL2_PRESET_PARKINGLOT,
|
|
XAUDIO2FX_I3DL2_PRESET_SEWERPIPE,
|
|
XAUDIO2FX_I3DL2_PRESET_UNDERWATER,
|
|
XAUDIO2FX_I3DL2_PRESET_SMALLROOM,
|
|
XAUDIO2FX_I3DL2_PRESET_MEDIUMROOM,
|
|
XAUDIO2FX_I3DL2_PRESET_LARGEROOM,
|
|
XAUDIO2FX_I3DL2_PRESET_MEDIUMHALL,
|
|
XAUDIO2FX_I3DL2_PRESET_LARGEHALL,
|
|
XAUDIO2FX_I3DL2_PRESET_PLATE,
|
|
};
|
|
|
|
struct AudioInternal
|
|
{
|
|
bool success = false;
|
|
Microsoft::WRL::ComPtr<IXAudio2> audioEngine;
|
|
IXAudio2MasteringVoice* masteringVoice = nullptr;
|
|
XAUDIO2_VOICE_DETAILS masteringVoiceDetails = {};
|
|
IXAudio2SubmixVoice* submixVoices[SUBMIX_TYPE_COUNT] = {};
|
|
X3DAUDIO_HANDLE audio3D = {};
|
|
Microsoft::WRL::ComPtr<IUnknown> reverbEffect;
|
|
IXAudio2SubmixVoice* reverbSubmix = nullptr;
|
|
uint32_t termination_data = 0;
|
|
XAUDIO2_BUFFER termination_mark = {};
|
|
|
|
AudioInternal()
|
|
{
|
|
wi::Timer timer;
|
|
|
|
HRESULT hr;
|
|
hr = xaudio_check(CoInitializeEx(NULL, COINIT_MULTITHREADED));
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
hr = xaudio_check(XAudio2Create(&audioEngine, 0, XAUDIO2_USE_DEFAULT_PROCESSOR));
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
XAUDIO2_DEBUG_CONFIGURATION debugConfig = {};
|
|
debugConfig.TraceMask = XAUDIO2_LOG_ERRORS | XAUDIO2_LOG_WARNINGS;
|
|
debugConfig.BreakMask = XAUDIO2_LOG_ERRORS | XAUDIO2_LOG_WARNINGS;
|
|
audioEngine->SetDebugConfiguration(&debugConfig);
|
|
#endif // _DEBUG
|
|
|
|
hr = xaudio_check(audioEngine->CreateMasteringVoice(&masteringVoice));
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
masteringVoice->GetVoiceDetails(&masteringVoiceDetails);
|
|
|
|
// Without clamping sample rate, it was crashing 32bit 192kHz audio devices
|
|
if (masteringVoiceDetails.InputSampleRate > 48000)
|
|
masteringVoiceDetails.InputSampleRate = 48000;
|
|
|
|
for (int i = 0; i < SUBMIX_TYPE_COUNT; ++i)
|
|
{
|
|
hr = xaudio_check(audioEngine->CreateSubmixVoice(
|
|
&submixVoices[i],
|
|
masteringVoiceDetails.InputChannels,
|
|
masteringVoiceDetails.InputSampleRate,
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
));
|
|
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
DWORD channelMask;
|
|
masteringVoice->GetChannelMask(&channelMask);
|
|
hr = xaudio_check(X3DAudioInitialize(channelMask, X3DAUDIO_SPEED_OF_SOUND, audio3D));
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Reverb setup:
|
|
{
|
|
hr = xaudio_check(XAudio2CreateReverb(&reverbEffect));
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
XAUDIO2_EFFECT_DESCRIPTOR effects[] = { { reverbEffect.Get(), TRUE, 1 } };
|
|
XAUDIO2_EFFECT_CHAIN effectChain = { arraysize(effects), effects };
|
|
hr = xaudio_check(audioEngine->CreateSubmixVoice(
|
|
&reverbSubmix,
|
|
1, // reverb is mono
|
|
masteringVoiceDetails.InputSampleRate,
|
|
0,
|
|
0,
|
|
nullptr,
|
|
&effectChain
|
|
));
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
XAUDIO2FX_REVERB_PARAMETERS native;
|
|
ReverbConvertI3DL2ToNative(&reverbPresets[REVERB_PRESET_DEFAULT], &native);
|
|
HRESULT hr = xaudio_check(reverbSubmix->SetEffectParameters(0, &native, sizeof(native)));
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
termination_mark.Flags = XAUDIO2_END_OF_STREAM;
|
|
termination_mark.pAudioData = (const BYTE*)&termination_data;
|
|
termination_mark.AudioBytes = sizeof(termination_data);
|
|
|
|
success = true;
|
|
wilog("wi::audio Initialized [XAudio2] (%d ms)", (int)std::round(timer.elapsed()));
|
|
}
|
|
~AudioInternal()
|
|
{
|
|
if (reverbSubmix != nullptr)
|
|
reverbSubmix->DestroyVoice();
|
|
|
|
for (int i = 0; i < SUBMIX_TYPE_COUNT; ++i)
|
|
{
|
|
if (submixVoices[i] != nullptr)
|
|
submixVoices[i]->DestroyVoice();
|
|
}
|
|
|
|
if (masteringVoice != nullptr)
|
|
masteringVoice->DestroyVoice();
|
|
|
|
audioEngine->StopEngine();
|
|
|
|
CoUninitialize();
|
|
}
|
|
|
|
constexpr bool IsValid() const { return success; }
|
|
};
|
|
static std::shared_ptr<AudioInternal> audio_internal;
|
|
|
|
void Initialize()
|
|
{
|
|
audio_internal = std::make_shared<AudioInternal>();
|
|
}
|
|
|
|
struct SoundInternal
|
|
{
|
|
std::shared_ptr<AudioInternal> audio;
|
|
WAVEFORMATEX wfx = {};
|
|
wi::vector<uint8_t> audioData;
|
|
};
|
|
struct SoundInstanceInternal : public IXAudio2VoiceCallback
|
|
{
|
|
std::shared_ptr<AudioInternal> audio;
|
|
std::shared_ptr<SoundInternal> soundinternal;
|
|
IXAudio2SourceVoice* sourceVoice = nullptr;
|
|
XAUDIO2_VOICE_DETAILS voiceDetails = {};
|
|
wi::vector<float> outputMatrix;
|
|
wi::vector<float> channelAzimuths;
|
|
XAUDIO2_BUFFER buffer = {};
|
|
bool ended = true;
|
|
|
|
~SoundInstanceInternal()
|
|
{
|
|
sourceVoice->Stop();
|
|
sourceVoice->DestroyVoice();
|
|
}
|
|
|
|
// Called just before this voice's processing pass begins.
|
|
STDMETHOD_(void, OnVoiceProcessingPassStart) (THIS_ UINT32 BytesRequired)
|
|
{
|
|
}
|
|
|
|
// Called just after this voice's processing pass ends.
|
|
STDMETHOD_(void, OnVoiceProcessingPassEnd) (THIS)
|
|
{
|
|
}
|
|
|
|
// Called when this voice has just finished playing a buffer stream
|
|
// (as marked with the XAUDIO2_END_OF_STREAM flag on the last buffer).
|
|
STDMETHOD_(void, OnStreamEnd) (THIS)
|
|
{
|
|
ended = true;
|
|
}
|
|
|
|
// Called when this voice is about to start processing a new buffer.
|
|
STDMETHOD_(void, OnBufferStart) (THIS_ void* pBufferContext)
|
|
{
|
|
ended = false;
|
|
}
|
|
|
|
// Called when this voice has just finished processing a buffer.
|
|
// The buffer can now be reused or destroyed.
|
|
STDMETHOD_(void, OnBufferEnd) (THIS_ void* pBufferContext)
|
|
{
|
|
}
|
|
|
|
// Called when this voice has just reached the end position of a loop.
|
|
STDMETHOD_(void, OnLoopEnd) (THIS_ void* pBufferContext)
|
|
{
|
|
}
|
|
|
|
// Called in the event of a critical error during voice processing,
|
|
// such as a failing xAPO or an error from the hardware XMA decoder.
|
|
// The voice may have to be destroyed and re-created to recover from
|
|
// the error. The callback arguments report which buffer was being
|
|
// processed when the error occurred, and its HRESULT code.
|
|
STDMETHOD_(void, OnVoiceError) (THIS_ void* pBufferContext, HRESULT Error)
|
|
{
|
|
}
|
|
};
|
|
SoundInternal* to_internal(const Sound* param)
|
|
{
|
|
return static_cast<SoundInternal*>(param->internal_state.get());
|
|
}
|
|
SoundInstanceInternal* to_internal(const SoundInstance* param)
|
|
{
|
|
return static_cast<SoundInstanceInternal*>(param->internal_state.get());
|
|
}
|
|
|
|
bool FindChunk(const uint8_t* data, DWORD fourcc, DWORD& dwChunkSize, DWORD& dwChunkDataPosition)
|
|
{
|
|
size_t pos = 0;
|
|
|
|
DWORD dwChunkType;
|
|
DWORD dwChunkDataSize;
|
|
DWORD dwRIFFDataSize = 0;
|
|
DWORD dwFileType;
|
|
DWORD bytesRead = 0;
|
|
DWORD dwOffset = 0;
|
|
|
|
while(true)
|
|
{
|
|
memcpy(&dwChunkType, data + pos, sizeof(DWORD));
|
|
pos += sizeof(DWORD);
|
|
memcpy(&dwChunkDataSize, data + pos, sizeof(DWORD));
|
|
pos += sizeof(DWORD);
|
|
|
|
switch (dwChunkType)
|
|
{
|
|
case fourccRIFF:
|
|
dwRIFFDataSize = dwChunkDataSize;
|
|
dwChunkDataSize = 4;
|
|
memcpy(&dwFileType, data + pos, sizeof(DWORD));
|
|
pos += sizeof(DWORD);
|
|
break;
|
|
|
|
default:
|
|
pos += dwChunkDataSize;
|
|
}
|
|
|
|
dwOffset += sizeof(DWORD) * 2;
|
|
|
|
if (dwChunkType == fourcc)
|
|
{
|
|
dwChunkSize = dwChunkDataSize;
|
|
dwChunkDataPosition = dwOffset;
|
|
return true;
|
|
}
|
|
|
|
dwOffset += dwChunkDataSize;
|
|
|
|
if (bytesRead >= dwRIFFDataSize) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool CreateSound(const std::string& filename, Sound* sound)
|
|
{
|
|
wi::vector<uint8_t> filedata;
|
|
bool success = wi::helper::FileRead(filename, filedata);
|
|
if (!success)
|
|
{
|
|
return false;
|
|
}
|
|
return CreateSound(filedata.data(), filedata.size(), sound);
|
|
}
|
|
bool CreateSound(const uint8_t* data, size_t size, Sound* sound)
|
|
{
|
|
if (audio_internal == nullptr || !audio_internal->IsValid())
|
|
return false;
|
|
std::shared_ptr<SoundInternal> soundinternal = std::make_shared<SoundInternal>();
|
|
soundinternal->audio = audio_internal;
|
|
sound->internal_state = soundinternal;
|
|
|
|
DWORD dwChunkSize;
|
|
DWORD dwChunkPosition;
|
|
|
|
bool success;
|
|
|
|
success = FindChunk(data, fourccRIFF, dwChunkSize, dwChunkPosition);
|
|
if (success)
|
|
{
|
|
// Wav decoder:
|
|
DWORD filetype;
|
|
memcpy(&filetype, data + dwChunkPosition, sizeof(DWORD));
|
|
if (filetype != fourccWAVE)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
success = FindChunk(data, fourccFMT, dwChunkSize, dwChunkPosition);
|
|
if (!success)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
memcpy(&soundinternal->wfx, data + dwChunkPosition, dwChunkSize);
|
|
soundinternal->wfx.wFormatTag = WAVE_FORMAT_PCM;
|
|
|
|
success = FindChunk(data, fourccDATA, dwChunkSize, dwChunkPosition);
|
|
if (!success)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
soundinternal->audioData.resize(dwChunkSize);
|
|
memcpy(soundinternal->audioData.data(), data + dwChunkPosition, dwChunkSize);
|
|
}
|
|
else
|
|
{
|
|
// Ogg decoder:
|
|
int channels = 0;
|
|
int sample_rate = 0;
|
|
short* output = nullptr;
|
|
int samples = stb_vorbis_decode_memory(data, (int)size, &channels, &sample_rate, &output);
|
|
if (samples < 0)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
// WAVEFORMATEX: https://docs.microsoft.com/en-us/previous-versions/dd757713(v=vs.85)?redirectedfrom=MSDN
|
|
soundinternal->wfx.wFormatTag = WAVE_FORMAT_PCM;
|
|
soundinternal->wfx.nChannels = (WORD)channels;
|
|
soundinternal->wfx.nSamplesPerSec = (DWORD)sample_rate;
|
|
soundinternal->wfx.wBitsPerSample = sizeof(short) * 8;
|
|
soundinternal->wfx.nBlockAlign = (WORD)channels * sizeof(short); // is this right?
|
|
soundinternal->wfx.nAvgBytesPerSec = soundinternal->wfx.nSamplesPerSec * soundinternal->wfx.nBlockAlign;
|
|
|
|
size_t output_size = size_t(samples * channels) * sizeof(short);
|
|
soundinternal->audioData.resize(output_size);
|
|
memcpy(soundinternal->audioData.data(), output, output_size);
|
|
|
|
free(output);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
bool CreateSoundInstance(const Sound* sound, SoundInstance* instance)
|
|
{
|
|
if (audio_internal == nullptr || !audio_internal->IsValid())
|
|
return false;
|
|
if (sound == nullptr || !sound->IsValid())
|
|
return false;
|
|
HRESULT hr;
|
|
const auto& soundinternal = std::static_pointer_cast<SoundInternal>(sound->internal_state);
|
|
std::shared_ptr<SoundInstanceInternal> instanceinternal = std::make_shared<SoundInstanceInternal>();
|
|
instance->internal_state = instanceinternal;
|
|
|
|
instanceinternal->audio = audio_internal;
|
|
instanceinternal->soundinternal = soundinternal;
|
|
|
|
XAUDIO2_SEND_DESCRIPTOR SFXSend[] = {
|
|
{ XAUDIO2_SEND_USEFILTER, instanceinternal->audio->submixVoices[instance->type] },
|
|
{ XAUDIO2_SEND_USEFILTER, instanceinternal->audio->reverbSubmix }, // this should be last to enable/disable reverb simply
|
|
};
|
|
XAUDIO2_VOICE_SENDS SFXSendList = {
|
|
(instance->IsEnableReverb() && instanceinternal->audio->reverbSubmix != nullptr) ? (uint32_t)arraysize(SFXSend) : 1,
|
|
SFXSend
|
|
};
|
|
|
|
hr = xaudio_check(instanceinternal->audio->audioEngine->CreateSourceVoice(&instanceinternal->sourceVoice, &soundinternal->wfx,
|
|
0, XAUDIO2_DEFAULT_FREQ_RATIO, instanceinternal.get(), &SFXSendList, NULL));
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
instanceinternal->sourceVoice->GetVoiceDetails(&instanceinternal->voiceDetails);
|
|
|
|
instanceinternal->outputMatrix.resize(size_t(instanceinternal->voiceDetails.InputChannels) * size_t(instanceinternal->audio->masteringVoiceDetails.InputChannels));
|
|
instanceinternal->channelAzimuths.resize(instanceinternal->voiceDetails.InputChannels);
|
|
for (size_t i = 0; i < instanceinternal->channelAzimuths.size(); ++i)
|
|
{
|
|
instanceinternal->channelAzimuths[i] = X3DAUDIO_2PI * float(i) / float(instanceinternal->channelAzimuths.size());
|
|
}
|
|
|
|
const uint32_t bytes_per_second = soundinternal->wfx.nSamplesPerSec * soundinternal->wfx.nChannels * sizeof(short);
|
|
instanceinternal->buffer.pAudioData = soundinternal->audioData.data();
|
|
instanceinternal->buffer.AudioBytes = (uint32_t)soundinternal->audioData.size();
|
|
if (instance->begin > 0)
|
|
{
|
|
const uint32_t bytes_from_beginning = AlignTo(std::min(instanceinternal->buffer.AudioBytes, uint32_t(instance->begin * bytes_per_second)), 4u);
|
|
instanceinternal->buffer.pAudioData += bytes_from_beginning;
|
|
instanceinternal->buffer.AudioBytes -= bytes_from_beginning;
|
|
}
|
|
if (instance->length > 0)
|
|
{
|
|
instanceinternal->buffer.AudioBytes = AlignTo(std::min(instanceinternal->buffer.AudioBytes, uint32_t(instance->length * bytes_per_second)), 4u);
|
|
}
|
|
|
|
uint32_t num_remaining_samples = instanceinternal->buffer.AudioBytes / (soundinternal->wfx.nChannels * sizeof(short));
|
|
if (instance->loop_begin > 0)
|
|
{
|
|
instanceinternal->buffer.LoopBegin = AlignTo(std::min(num_remaining_samples, uint32_t(instance->loop_begin * soundinternal->wfx.nSamplesPerSec)), 4u);
|
|
num_remaining_samples -= instanceinternal->buffer.LoopBegin;
|
|
}
|
|
instanceinternal->buffer.LoopLength = AlignTo(std::min(num_remaining_samples, uint32_t(instance->loop_length * soundinternal->wfx.nSamplesPerSec)), 4u);
|
|
|
|
instanceinternal->buffer.Flags = XAUDIO2_END_OF_STREAM;
|
|
instanceinternal->buffer.LoopCount = instance->IsLooped() ? XAUDIO2_LOOP_INFINITE : 0;
|
|
|
|
hr = xaudio_check(instanceinternal->sourceVoice->SubmitSourceBuffer(&instanceinternal->buffer));
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
void Play(SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
xaudio_check(instanceinternal->sourceVoice->Start());
|
|
|
|
}
|
|
}
|
|
void Pause(SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
xaudio_check(instanceinternal->sourceVoice->Stop()); // preserves cursor position
|
|
|
|
}
|
|
}
|
|
void Stop(SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
xaudio_check(instanceinternal->sourceVoice->Stop()); // preserves cursor position
|
|
|
|
xaudio_check(instanceinternal->sourceVoice->FlushSourceBuffers()); // reset submitted audio buffer
|
|
|
|
if (!instanceinternal->ended) // if already ended, don't submit end again, it can cause high pitched jerky sound
|
|
{
|
|
xaudio_check(instanceinternal->sourceVoice->SubmitSourceBuffer(&audio_internal->termination_mark)); // mark this as terminated, this resets XAUDIO2_VOICE_STATE::SamplesPlayed to zero
|
|
|
|
}
|
|
xaudio_check(instanceinternal->sourceVoice->SubmitSourceBuffer(&instanceinternal->buffer)); // resubmit
|
|
|
|
}
|
|
}
|
|
void SetVolume(float volume, SoundInstance* instance)
|
|
{
|
|
if (instance == nullptr || !instance->IsValid())
|
|
{
|
|
xaudio_check(audio_internal->masteringVoice->SetVolume(volume));
|
|
|
|
}
|
|
else
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
xaudio_check(instanceinternal->sourceVoice->SetVolume(volume));
|
|
|
|
}
|
|
}
|
|
float GetVolume(const SoundInstance* instance)
|
|
{
|
|
float volume = 0;
|
|
if (instance == nullptr || !instance->IsValid())
|
|
{
|
|
audio_internal->masteringVoice->GetVolume(&volume);
|
|
}
|
|
else
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
instanceinternal->sourceVoice->GetVolume(&volume);
|
|
}
|
|
return volume;
|
|
}
|
|
void ExitLoop(SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
if (instanceinternal->buffer.LoopCount == 0)
|
|
return;
|
|
xaudio_check(instanceinternal->sourceVoice->ExitLoop());
|
|
|
|
if (instanceinternal->ended)
|
|
{
|
|
instanceinternal->buffer.LoopCount = 0;
|
|
xaudio_check(instanceinternal->sourceVoice->SubmitSourceBuffer(&instanceinternal->buffer));
|
|
|
|
}
|
|
}
|
|
}
|
|
bool IsEnded(SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
return instanceinternal->ended;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
SampleInfo GetSampleInfo(const Sound* sound)
|
|
{
|
|
SampleInfo info = {};
|
|
if (sound != nullptr && sound->IsValid())
|
|
{
|
|
auto soundinternal = to_internal(sound);
|
|
info.channel_count = soundinternal->wfx.nChannels;
|
|
info.samples = (const short*)soundinternal->audioData.data();
|
|
info.sample_count = soundinternal->audioData.size() / (info.channel_count * sizeof(short));
|
|
info.sample_rate = soundinternal->wfx.nSamplesPerSec;
|
|
}
|
|
return info;
|
|
}
|
|
uint64_t GetTotalSamplesPlayed(const SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
XAUDIO2_VOICE_STATE state = {};
|
|
instanceinternal->sourceVoice->GetState(&state, 0);
|
|
return state.SamplesPlayed;
|
|
}
|
|
return 0ull;
|
|
}
|
|
|
|
void SetSubmixVolume(SUBMIX_TYPE type, float volume)
|
|
{
|
|
xaudio_check(audio_internal->submixVoices[type]->SetVolume(volume));
|
|
|
|
}
|
|
float GetSubmixVolume(SUBMIX_TYPE type)
|
|
{
|
|
float volume;
|
|
audio_internal->submixVoices[type]->GetVolume(&volume);
|
|
return volume;
|
|
}
|
|
|
|
void Update3D(SoundInstance* instance, const SoundInstance3D& instance3D)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
|
|
X3DAUDIO_LISTENER listener = {};
|
|
listener.Position = instance3D.listenerPos;
|
|
listener.OrientFront = instance3D.listenerFront;
|
|
listener.OrientTop = instance3D.listenerUp;
|
|
listener.Velocity = instance3D.listenerVelocity;
|
|
|
|
X3DAUDIO_EMITTER emitter = {};
|
|
emitter.Position = instance3D.emitterPos;
|
|
emitter.OrientFront = instance3D.emitterFront;
|
|
emitter.OrientTop = instance3D.emitterUp;
|
|
emitter.Velocity = instance3D.emitterVelocity;
|
|
emitter.InnerRadius = instance3D.emitterRadius;
|
|
emitter.InnerRadiusAngle = X3DAUDIO_PI / 4.0f;
|
|
emitter.ChannelCount = instanceinternal->voiceDetails.InputChannels;
|
|
emitter.pChannelAzimuths = instanceinternal->channelAzimuths.data();
|
|
emitter.ChannelRadius = 0.1f;
|
|
emitter.CurveDistanceScaler = 1;
|
|
emitter.DopplerScaler = 1;
|
|
|
|
UINT32 flags = 0;
|
|
flags |= X3DAUDIO_CALCULATE_MATRIX;
|
|
flags |= X3DAUDIO_CALCULATE_LPF_DIRECT;
|
|
flags |= X3DAUDIO_CALCULATE_REVERB;
|
|
flags |= X3DAUDIO_CALCULATE_LPF_REVERB;
|
|
flags |= X3DAUDIO_CALCULATE_DOPPLER;
|
|
//flags |= X3DAUDIO_CALCULATE_DELAY;
|
|
//flags |= X3DAUDIO_CALCULATE_EMITTER_ANGLE;
|
|
//flags |= X3DAUDIO_CALCULATE_ZEROCENTER;
|
|
//flags |= X3DAUDIO_CALCULATE_REDIRECT_TO_LFE;
|
|
|
|
X3DAUDIO_DSP_SETTINGS settings = {};
|
|
settings.SrcChannelCount = instanceinternal->voiceDetails.InputChannels;
|
|
settings.DstChannelCount = instanceinternal->audio->masteringVoiceDetails.InputChannels;
|
|
settings.pMatrixCoefficients = instanceinternal->outputMatrix.data();
|
|
|
|
X3DAudioCalculate(instanceinternal->audio->audio3D, &listener, &emitter, flags, &settings);
|
|
|
|
xaudio_check(instanceinternal->sourceVoice->SetFrequencyRatio(settings.DopplerFactor));
|
|
|
|
xaudio_check(instanceinternal->sourceVoice->SetOutputMatrix(
|
|
instanceinternal->audio->submixVoices[instance->type],
|
|
settings.SrcChannelCount,
|
|
settings.DstChannelCount,
|
|
settings.pMatrixCoefficients
|
|
));
|
|
|
|
|
|
XAUDIO2_FILTER_PARAMETERS FilterParametersDirect = { LowPassFilter, 2.0f * sinf(X3DAUDIO_PI / 6.0f * settings.LPFDirectCoefficient), 1.0f };
|
|
xaudio_check(instanceinternal->sourceVoice->SetOutputFilterParameters(instanceinternal->audio->submixVoices[instance->type], &FilterParametersDirect));
|
|
|
|
|
|
if (instance->IsEnableReverb() && instanceinternal->audio->reverbSubmix != nullptr)
|
|
{
|
|
xaudio_check(instanceinternal->sourceVoice->SetOutputMatrix(instanceinternal->audio->reverbSubmix, settings.SrcChannelCount, 1, &settings.ReverbLevel));
|
|
|
|
XAUDIO2_FILTER_PARAMETERS FilterParametersReverb = { LowPassFilter, 2.0f * sinf(X3DAUDIO_PI / 6.0f * settings.LPFReverbCoefficient), 1.0f };
|
|
xaudio_check(instanceinternal->sourceVoice->SetOutputFilterParameters(instanceinternal->audio->reverbSubmix, &FilterParametersReverb));
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetReverb(REVERB_PRESET preset)
|
|
{
|
|
XAUDIO2FX_REVERB_PARAMETERS native;
|
|
ReverbConvertI3DL2ToNative(&reverbPresets[preset], &native);
|
|
xaudio_check(audio_internal->reverbSubmix->SetEffectParameters(0, &native, sizeof(native)));
|
|
|
|
}
|
|
}
|
|
|
|
#elif SDL2
|
|
|
|
//FAudio implemetation
|
|
#include <FAudio.h>
|
|
#include <FAPO.h>
|
|
#include <FAudioFX.h>
|
|
#include <F3DAudio.h>
|
|
|
|
#define SPEED_OF_SOUND 343.5f
|
|
#define fourccRIFF 0x46464952
|
|
#define fourccWAVE 0x45564157
|
|
#define fourccFMT 0x20746d66
|
|
#define fourccDATA 0x61746164
|
|
|
|
namespace wi::audio
|
|
{
|
|
static const FAudioFXReverbI3DL2Parameters reverbPresets[] = {
|
|
FAUDIOFX_I3DL2_PRESET_DEFAULT,
|
|
FAUDIOFX_I3DL2_PRESET_GENERIC,
|
|
FAUDIOFX_I3DL2_PRESET_FOREST,
|
|
FAUDIOFX_I3DL2_PRESET_PADDEDCELL,
|
|
FAUDIOFX_I3DL2_PRESET_ROOM,
|
|
FAUDIOFX_I3DL2_PRESET_BATHROOM,
|
|
FAUDIOFX_I3DL2_PRESET_LIVINGROOM,
|
|
FAUDIOFX_I3DL2_PRESET_STONEROOM,
|
|
FAUDIOFX_I3DL2_PRESET_AUDITORIUM,
|
|
FAUDIOFX_I3DL2_PRESET_CONCERTHALL,
|
|
FAUDIOFX_I3DL2_PRESET_CAVE,
|
|
FAUDIOFX_I3DL2_PRESET_ARENA,
|
|
FAUDIOFX_I3DL2_PRESET_HANGAR,
|
|
FAUDIOFX_I3DL2_PRESET_CARPETEDHALLWAY,
|
|
FAUDIOFX_I3DL2_PRESET_HALLWAY,
|
|
FAUDIOFX_I3DL2_PRESET_STONECORRIDOR,
|
|
FAUDIOFX_I3DL2_PRESET_ALLEY,
|
|
FAUDIOFX_I3DL2_PRESET_CITY,
|
|
FAUDIOFX_I3DL2_PRESET_MOUNTAINS,
|
|
FAUDIOFX_I3DL2_PRESET_QUARRY,
|
|
FAUDIOFX_I3DL2_PRESET_PLAIN,
|
|
FAUDIOFX_I3DL2_PRESET_PARKINGLOT,
|
|
FAUDIOFX_I3DL2_PRESET_SEWERPIPE,
|
|
FAUDIOFX_I3DL2_PRESET_UNDERWATER,
|
|
FAUDIOFX_I3DL2_PRESET_SMALLROOM,
|
|
FAUDIOFX_I3DL2_PRESET_MEDIUMROOM,
|
|
FAUDIOFX_I3DL2_PRESET_LARGEROOM,
|
|
FAUDIOFX_I3DL2_PRESET_MEDIUMHALL,
|
|
FAUDIOFX_I3DL2_PRESET_LARGEHALL,
|
|
FAUDIOFX_I3DL2_PRESET_PLATE,
|
|
};
|
|
|
|
struct AudioInternal{
|
|
bool success = false;
|
|
FAudio *audioEngine;
|
|
FAudioMasteringVoice* masteringVoice = nullptr;
|
|
FAudioVoiceDetails masteringVoiceDetails;
|
|
FAudioSubmixVoice* submixVoices[SUBMIX_TYPE_COUNT] = {};
|
|
F3DAUDIO_HANDLE audio3D = {};
|
|
FAPO* reverbEffect;
|
|
FAudioSubmixVoice* reverbSubmix = nullptr;
|
|
uint32_t termination_data = 0;
|
|
FAudioBuffer termination_mark = {};
|
|
|
|
AudioInternal(){
|
|
wi::Timer timer;
|
|
|
|
uint32_t res;
|
|
res = FAudioCreate(&audioEngine, 0, FAUDIO_DEFAULT_PROCESSOR);
|
|
if (res != 0)
|
|
{
|
|
std::stringstream ss("");
|
|
ss << "FAudioCreate returned error: " << res;
|
|
wi::backlog::post(ss.str(), wi::backlog::LogLevel::Error);
|
|
return;
|
|
}
|
|
|
|
res = FAudio_CreateMasteringVoice(
|
|
audioEngine,
|
|
&masteringVoice,
|
|
FAUDIO_DEFAULT_CHANNELS,
|
|
FAUDIO_DEFAULT_SAMPLERATE,
|
|
0, 0, NULL);
|
|
if (res != 0)
|
|
{
|
|
std::stringstream ss("");
|
|
ss << "FAudio_CreateMasteringVoice returned error: " << res;
|
|
wi::backlog::post(ss.str(), wi::backlog::LogLevel::Error);
|
|
return;
|
|
}
|
|
|
|
FAudioVoice_GetVoiceDetails(masteringVoice, &masteringVoiceDetails);
|
|
|
|
for (int i=0; i<SUBMIX_TYPE_COUNT; ++i){
|
|
res = FAudio_CreateSubmixVoice(
|
|
audioEngine,
|
|
&submixVoices[i],
|
|
masteringVoiceDetails.InputChannels,
|
|
masteringVoiceDetails.InputSampleRate,
|
|
0, 0, NULL, NULL);
|
|
if (res != 0)
|
|
{
|
|
std::stringstream ss("");
|
|
ss << "FAudio_CreateSubmixVoice returned error: " << res;
|
|
wi::backlog::post(ss.str(), wi::backlog::LogLevel::Error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
uint32_t channelMask;
|
|
FAudioMasteringVoice_GetChannelMask(masteringVoice, &channelMask);
|
|
|
|
F3DAudioInitialize(channelMask, SPEED_OF_SOUND, audio3D);
|
|
if (res != 0)
|
|
{
|
|
std::stringstream ss("");
|
|
ss << "F3DAudioInitialize returned error: " << res;
|
|
wi::backlog::post(ss.str(), wi::backlog::LogLevel::Error);
|
|
return;
|
|
}
|
|
|
|
// Reverb setup
|
|
{
|
|
res = FAudioCreateReverb(&reverbEffect, 0);
|
|
if (res != 0)
|
|
{
|
|
std::stringstream ss("");
|
|
ss << "FAudioCreateReverb returned error: " << res;
|
|
wi::backlog::post(ss.str(), wi::backlog::LogLevel::Error);
|
|
return;
|
|
}
|
|
|
|
FAudioEffectDescriptor effects[] = { { reverbEffect, 1, 1 } };
|
|
FAudioEffectChain effectChain = { arraysize(effects), effects };
|
|
|
|
res = FAudio_CreateSubmixVoice(
|
|
audioEngine,
|
|
&reverbSubmix,
|
|
1,
|
|
masteringVoiceDetails.InputSampleRate,
|
|
0,
|
|
0,
|
|
nullptr,
|
|
&effectChain
|
|
);
|
|
if (res != 0)
|
|
{
|
|
std::stringstream ss("");
|
|
ss << "FAudio_CreateSubmixVoice returned error: " << res;
|
|
wi::backlog::post(ss.str(), wi::backlog::LogLevel::Error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
termination_mark.Flags = FAUDIO_END_OF_STREAM;
|
|
termination_mark.pAudioData = (const uint8_t*)&termination_data;
|
|
termination_mark.AudioBytes = sizeof(termination_data);
|
|
|
|
success = true;
|
|
wilog("wi::audio Initialized [FAudio] (%d ms)", (int)std::round(timer.elapsed()));
|
|
}
|
|
~AudioInternal(){
|
|
if(reverbSubmix != nullptr)
|
|
FAudioVoice_DestroyVoice(reverbSubmix);
|
|
|
|
for (int i = 0; i < SUBMIX_TYPE_COUNT; ++i){
|
|
if(submixVoices[i] != nullptr)
|
|
FAudioVoice_DestroyVoice(submixVoices[i]);
|
|
}
|
|
|
|
if(masteringVoice != nullptr)
|
|
FAudioVoice_DestroyVoice(masteringVoice);
|
|
|
|
FAudio_StopEngine(audioEngine);
|
|
}
|
|
constexpr bool IsValid() const { return success; }
|
|
};
|
|
static std::shared_ptr<AudioInternal> audio_internal;
|
|
|
|
void Initialize()
|
|
{
|
|
audio_internal = std::make_shared<AudioInternal>();
|
|
}
|
|
|
|
struct SoundInternal{
|
|
std::shared_ptr<AudioInternal> audio;
|
|
FAudioWaveFormatEx wfx = {};
|
|
wi::vector<uint8_t> audioData;
|
|
};
|
|
struct SoundInstanceInternal{
|
|
std::shared_ptr<AudioInternal> audio;
|
|
std::shared_ptr<SoundInternal> soundinternal;
|
|
FAudioSourceVoice* sourceVoice = nullptr;
|
|
FAudioVoiceDetails voiceDetails = {};
|
|
wi::vector<float> outputMatrix;
|
|
wi::vector<float> channelAzimuths;
|
|
FAudioBuffer buffer = {};
|
|
bool ended = true;
|
|
|
|
~SoundInstanceInternal(){
|
|
FAudioSourceVoice_Stop(sourceVoice, 0, FAUDIO_COMMIT_NOW);
|
|
FAudioVoice_DestroyVoice(sourceVoice);
|
|
}
|
|
};
|
|
|
|
SoundInternal* to_internal(const Sound* param)
|
|
{
|
|
return static_cast<SoundInternal*>(param->internal_state.get());
|
|
}
|
|
SoundInstanceInternal* to_internal(const SoundInstance* param)
|
|
{
|
|
return static_cast<SoundInstanceInternal*>(param->internal_state.get());
|
|
}
|
|
|
|
bool FindChunk(const uint8_t* data, uint32_t fourcc, uint32_t& dwChunkSize, uint32_t& dwChunkDataPosition)
|
|
{
|
|
size_t pos = 0;
|
|
|
|
uint32_t dwChunkType;
|
|
uint32_t dwChunkDataSize;
|
|
uint32_t dwRIFFDataSize = 0;
|
|
uint32_t dwFileType;
|
|
uint32_t bytesRead = 0;
|
|
uint32_t dwOffset = 0;
|
|
|
|
while(true)
|
|
{
|
|
memcpy(&dwChunkType, data + pos, sizeof(uint32_t));
|
|
pos += sizeof(uint32_t);
|
|
memcpy(&dwChunkDataSize, data + pos, sizeof(uint32_t));
|
|
pos += sizeof(uint32_t);
|
|
|
|
switch (dwChunkType)
|
|
{
|
|
case fourccRIFF: //TODO
|
|
dwRIFFDataSize = dwChunkDataSize;
|
|
dwChunkDataSize = 4;
|
|
memcpy(&dwFileType, data + pos, sizeof(uint32_t));
|
|
pos += sizeof(uint32_t);
|
|
break;
|
|
|
|
default:
|
|
pos += dwChunkDataSize;
|
|
}
|
|
|
|
dwOffset += sizeof(uint32_t) * 2;
|
|
|
|
if (dwChunkType == fourcc)
|
|
{
|
|
dwChunkSize = dwChunkDataSize;
|
|
dwChunkDataPosition = dwOffset;
|
|
return true;
|
|
}
|
|
|
|
dwOffset += dwChunkDataSize;
|
|
|
|
if (bytesRead >= dwRIFFDataSize) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool CreateSound(const std::string& filename, Sound* sound) {
|
|
wi::vector<uint8_t> filedata;
|
|
bool success = wi::helper::FileRead(filename, filedata);
|
|
if (!success)
|
|
{
|
|
return false;
|
|
}
|
|
return CreateSound(filedata.data(), filedata.size(), sound);
|
|
}
|
|
bool CreateSound(const uint8_t* data, size_t size, Sound* sound)
|
|
{
|
|
if (audio_internal == nullptr || !audio_internal->IsValid())
|
|
return false;
|
|
std::shared_ptr<SoundInternal> soundinternal = std::make_shared<SoundInternal>();
|
|
soundinternal->audio = audio_internal;
|
|
sound->internal_state = soundinternal;
|
|
|
|
uint32_t dwChunkSize;
|
|
uint32_t dwChunkPosition;
|
|
|
|
bool success;
|
|
|
|
success = FindChunk(data, fourccRIFF, dwChunkSize, dwChunkPosition);
|
|
if (success)
|
|
{
|
|
// Wav decoder:
|
|
uint32_t filetype;
|
|
memcpy(&filetype, data + dwChunkPosition, sizeof(uint32_t));
|
|
if (filetype != fourccWAVE)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
success = FindChunk(data, fourccFMT, dwChunkSize, dwChunkPosition);
|
|
if (!success)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
memcpy(&soundinternal->wfx, data + dwChunkPosition, dwChunkSize);
|
|
soundinternal->wfx.wFormatTag = FAUDIO_FORMAT_PCM;
|
|
|
|
success = FindChunk(data, fourccDATA, dwChunkSize, dwChunkPosition);
|
|
if (!success)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
soundinternal->audioData.resize(dwChunkSize);
|
|
memcpy(soundinternal->audioData.data(), data + dwChunkPosition, dwChunkSize);
|
|
}
|
|
else
|
|
{
|
|
// Ogg decoder:
|
|
int channels = 0;
|
|
int sample_rate = 0;
|
|
short* output = nullptr;
|
|
int samples = stb_vorbis_decode_memory(data, (int)size, &channels, &sample_rate, &output);
|
|
if (samples < 0)
|
|
{
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
// WAVEFORMATEX: https://docs.microsoft.com/en-us/previous-versions/dd757713(v=vs.85)?redirectedfrom=MSDN
|
|
soundinternal->wfx.wFormatTag = FAUDIO_FORMAT_PCM;
|
|
soundinternal->wfx.nChannels = (uint16_t)channels;
|
|
soundinternal->wfx.nSamplesPerSec = (uint32_t)sample_rate;
|
|
soundinternal->wfx.wBitsPerSample = sizeof(short) * 8;
|
|
soundinternal->wfx.nBlockAlign = (uint16_t)channels * sizeof(short); // is this right?
|
|
soundinternal->wfx.nAvgBytesPerSec = soundinternal->wfx.nSamplesPerSec * soundinternal->wfx.nBlockAlign;
|
|
|
|
size_t output_size = size_t(samples * channels) * sizeof(short);
|
|
soundinternal->audioData.resize(output_size);
|
|
memcpy(soundinternal->audioData.data(), output, output_size);
|
|
|
|
free(output);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
bool CreateSoundInstance(const Sound* sound, SoundInstance* instance)
|
|
{
|
|
if (audio_internal == nullptr || !audio_internal->IsValid())
|
|
return false;
|
|
if (sound == nullptr || !sound->IsValid())
|
|
return false;
|
|
uint32_t res;
|
|
const auto& soundinternal = std::static_pointer_cast<SoundInternal>(sound->internal_state);
|
|
std::shared_ptr<SoundInstanceInternal> instanceinternal = std::make_shared<SoundInstanceInternal>();
|
|
instance->internal_state = instanceinternal;
|
|
|
|
instanceinternal->audio = audio_internal;
|
|
instanceinternal->soundinternal = soundinternal;
|
|
|
|
FAudioSendDescriptor SFXSend[] = {
|
|
{ FAUDIO_SEND_USEFILTER, instanceinternal->audio->submixVoices[instance->type] },
|
|
{ FAUDIO_SEND_USEFILTER, instanceinternal->audio->reverbSubmix }, // this should be last to enable/disable reverb simply
|
|
};
|
|
|
|
FAudioVoiceSends SFXSendList = {
|
|
instance->IsEnableReverb() ? (uint32_t)arraysize(SFXSend) : 1,
|
|
SFXSend
|
|
};
|
|
|
|
res = FAudio_CreateSourceVoice(instanceinternal->audio->audioEngine, &instanceinternal->sourceVoice, &soundinternal->wfx,
|
|
0, FAUDIO_DEFAULT_FREQ_RATIO, NULL, &SFXSendList, NULL);
|
|
if(res != 0){
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
FAudioVoice_GetVoiceDetails(instanceinternal->sourceVoice, &instanceinternal->voiceDetails);
|
|
instanceinternal->outputMatrix.resize(size_t(instanceinternal->voiceDetails.InputChannels) * size_t(instanceinternal->audio->masteringVoiceDetails.InputChannels));
|
|
instanceinternal->channelAzimuths.resize(instanceinternal->voiceDetails.InputChannels);
|
|
for (size_t i = 0; i < instanceinternal->channelAzimuths.size(); ++i)
|
|
{
|
|
instanceinternal->channelAzimuths[i] = F3DAUDIO_2PI * float(i) / float(instanceinternal->channelAzimuths.size());
|
|
}
|
|
|
|
const uint32_t bytes_per_second = soundinternal->wfx.nSamplesPerSec * soundinternal->wfx.nChannels * sizeof(short);
|
|
instanceinternal->buffer.pAudioData = soundinternal->audioData.data();
|
|
instanceinternal->buffer.AudioBytes = (uint32_t)soundinternal->audioData.size();
|
|
if (instance->begin > 0)
|
|
{
|
|
const uint32_t bytes_from_beginning = AlignTo(std::min(instanceinternal->buffer.AudioBytes, uint32_t(instance->begin * bytes_per_second)), 4u);
|
|
instanceinternal->buffer.pAudioData += bytes_from_beginning;
|
|
instanceinternal->buffer.AudioBytes -= bytes_from_beginning;
|
|
}
|
|
if (instance->length > 0)
|
|
{
|
|
instanceinternal->buffer.AudioBytes = AlignTo(std::min(instanceinternal->buffer.AudioBytes, uint32_t(instance->length * bytes_per_second)), 4u);
|
|
}
|
|
|
|
uint32_t num_remaining_samples = instanceinternal->buffer.AudioBytes / (soundinternal->wfx.nChannels * sizeof(short));
|
|
if (instance->loop_begin > 0)
|
|
{
|
|
instanceinternal->buffer.LoopBegin = AlignTo(std::min(num_remaining_samples, uint32_t(instance->loop_begin * soundinternal->wfx.nSamplesPerSec)), 4u);
|
|
num_remaining_samples -= instanceinternal->buffer.LoopBegin;
|
|
}
|
|
instanceinternal->buffer.LoopLength = AlignTo(std::min(num_remaining_samples, uint32_t(instance->loop_length * soundinternal->wfx.nSamplesPerSec)), 4u);
|
|
|
|
instanceinternal->buffer.Flags = FAUDIO_END_OF_STREAM;
|
|
instanceinternal->buffer.LoopCount = instance->IsLooped() ? FAUDIO_LOOP_INFINITE : 0;
|
|
|
|
res = FAudioSourceVoice_SubmitSourceBuffer(instanceinternal->sourceVoice, &(instanceinternal->buffer), nullptr);
|
|
if(res != 0){
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Play(SoundInstance* instance) {
|
|
if (instance != nullptr && instance->IsValid()){
|
|
auto instanceinternal = to_internal(instance);
|
|
uint32_t res = FAudioSourceVoice_Start(instanceinternal->sourceVoice, 0, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
void Pause(SoundInstance* instance) {
|
|
if (instance != nullptr && instance->IsValid()){
|
|
auto instanceinternal = to_internal(instance);
|
|
uint32_t res = FAudioSourceVoice_Stop(instanceinternal->sourceVoice, 0, FAUDIO_COMMIT_NOW); // preserves cursor position
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
void Stop(SoundInstance* instance) {
|
|
if (instance != nullptr && instance->IsValid()){
|
|
auto instanceinternal = to_internal(instance);
|
|
uint32_t res = FAudioSourceVoice_Stop(instanceinternal->sourceVoice, 0, FAUDIO_COMMIT_NOW); // preserves cursor position
|
|
assert(res == 0);
|
|
res = FAudioSourceVoice_FlushSourceBuffers(instanceinternal->sourceVoice); // reset submitted audio buffer
|
|
assert(res == 0);
|
|
res = FAudioSourceVoice_SubmitSourceBuffer(instanceinternal->sourceVoice, &audio_internal->termination_mark, nullptr); // mark this as terminated, this resets XAUDIO2_VOICE_STATE::SamplesPlayed to zero
|
|
assert(res == 0);
|
|
res = FAudioSourceVoice_SubmitSourceBuffer(instanceinternal->sourceVoice, &(instanceinternal->buffer), nullptr);
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
void SetVolume(float volume, SoundInstance* instance) {
|
|
if (instance == nullptr || !instance->IsValid()){
|
|
uint32_t res = FAudioVoice_SetVolume(audio_internal->masteringVoice, volume, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
}
|
|
else {
|
|
auto instanceinternal = to_internal(instance);
|
|
uint32_t res = FAudioVoice_SetVolume(instanceinternal->sourceVoice, volume, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
float GetVolume(const SoundInstance* instance) {
|
|
float volume = 0;
|
|
if (instance == nullptr || !instance->IsValid()){
|
|
FAudioVoice_GetVolume(audio_internal->masteringVoice, &volume);
|
|
}
|
|
else {
|
|
auto instanceinternal = to_internal(instance);
|
|
FAudioVoice_GetVolume(instanceinternal->sourceVoice, &volume);
|
|
}
|
|
return volume;
|
|
}
|
|
void ExitLoop(SoundInstance* instance) {
|
|
if (instance != nullptr && instance->IsValid()){
|
|
auto instanceinternal = to_internal(instance);
|
|
if (instanceinternal->buffer.LoopCount == 0)
|
|
return;
|
|
uint32_t res = FAudioSourceVoice_ExitLoop(instanceinternal->sourceVoice, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
if (instanceinternal->ended)
|
|
{
|
|
instanceinternal->buffer.LoopCount = 0;
|
|
res = FAudioSourceVoice_SubmitSourceBuffer(instanceinternal->sourceVoice, &(instanceinternal->buffer), nullptr);
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
}
|
|
bool IsEnded(SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
return instanceinternal->ended;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
SampleInfo GetSampleInfo(const Sound* sound)
|
|
{
|
|
SampleInfo info = {};
|
|
if (sound != nullptr && sound->IsValid())
|
|
{
|
|
auto soundinternal = to_internal(sound);
|
|
info.samples = (const short*)soundinternal->audioData.data();
|
|
info.sample_count = soundinternal->audioData.size() / sizeof(short);
|
|
info.sample_rate = soundinternal->wfx.nSamplesPerSec;
|
|
info.channel_count = soundinternal->wfx.nChannels;
|
|
}
|
|
return info;
|
|
}
|
|
uint64_t GetTotalSamplesPlayed(const SoundInstance* instance)
|
|
{
|
|
if (instance != nullptr && instance->IsValid())
|
|
{
|
|
auto instanceinternal = to_internal(instance);
|
|
FAudioVoiceState state = {};
|
|
FAudioSourceVoice_GetState(instanceinternal->sourceVoice, &state, 0);
|
|
return state.SamplesPlayed;
|
|
}
|
|
return 0ull;
|
|
}
|
|
|
|
void SetSubmixVolume(SUBMIX_TYPE type, float volume) {
|
|
uint32_t res = FAudioVoice_SetVolume(audio_internal->submixVoices[type], volume, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
}
|
|
float GetSubmixVolume(SUBMIX_TYPE type) {
|
|
float volume;
|
|
FAudioVoice_GetVolume(audio_internal->submixVoices[type], &volume);
|
|
return volume;
|
|
}
|
|
|
|
void Update3D(SoundInstance* instance, const SoundInstance3D& instance3D) {
|
|
if (instance != nullptr && instance->IsValid()){
|
|
auto instanceinternal = to_internal(instance);
|
|
F3DAUDIO_LISTENER listener = {};
|
|
listener.Position = (F3DAUDIO_VECTOR){ instance3D.listenerPos.x, instance3D.listenerPos.y, instance3D.listenerPos.z };
|
|
listener.OrientFront = (F3DAUDIO_VECTOR){ instance3D.listenerFront.x, instance3D.listenerFront.y, instance3D.listenerFront.z };
|
|
listener.OrientTop = (F3DAUDIO_VECTOR){ instance3D.listenerUp.x, instance3D.listenerUp.y, instance3D.listenerUp.z };
|
|
listener.Velocity = (F3DAUDIO_VECTOR){ instance3D.listenerVelocity.x, instance3D.listenerVelocity.y, instance3D.listenerVelocity.z };
|
|
|
|
F3DAUDIO_EMITTER emitter = {};
|
|
emitter.Position = (F3DAUDIO_VECTOR){ instance3D.emitterPos.x, instance3D.emitterPos.y, instance3D.emitterPos.z };
|
|
emitter.OrientFront = (F3DAUDIO_VECTOR){ instance3D.emitterFront.x, instance3D.emitterFront.y, instance3D.emitterFront.z };
|
|
emitter.OrientTop = (F3DAUDIO_VECTOR){ instance3D.emitterUp.x, instance3D.emitterUp.y, instance3D.emitterUp.z };
|
|
emitter.Velocity = (F3DAUDIO_VECTOR){ instance3D.emitterVelocity.x, instance3D.emitterVelocity.y, instance3D.emitterVelocity.z };
|
|
emitter.InnerRadius = instance3D.emitterRadius;
|
|
emitter.InnerRadiusAngle = F3DAUDIO_PI / 4.0f;
|
|
emitter.ChannelCount = instanceinternal->voiceDetails.InputChannels;
|
|
emitter.pChannelAzimuths = instanceinternal->channelAzimuths.data();
|
|
emitter.ChannelRadius = 0.1f;
|
|
emitter.CurveDistanceScaler = 1;
|
|
emitter.DopplerScaler = 1;
|
|
|
|
uint32_t flags = 0;
|
|
flags |= F3DAUDIO_CALCULATE_MATRIX;
|
|
flags |= F3DAUDIO_CALCULATE_LPF_DIRECT;
|
|
flags |= F3DAUDIO_CALCULATE_REVERB;
|
|
flags |= F3DAUDIO_CALCULATE_LPF_REVERB;
|
|
flags |= F3DAUDIO_CALCULATE_DOPPLER;
|
|
// flags |= F3DAUDIO_CALCULATE_DELAY;
|
|
// flags |= F3DAUDIO_CALCULATE_EMITTER_ANGLE;
|
|
// flags |= F3DAUDIO_CALCULATE_ZEROCENTER;
|
|
// flags |= F3DAUDIO_CALCULATE_REDIRECT_TO_LFE;
|
|
|
|
F3DAUDIO_DSP_SETTINGS settings = {};
|
|
settings.SrcChannelCount = instanceinternal->voiceDetails.InputChannels;
|
|
settings.DstChannelCount = instanceinternal->audio->masteringVoiceDetails.InputChannels;
|
|
settings.pMatrixCoefficients = instanceinternal->outputMatrix.data();
|
|
|
|
F3DAudioCalculate(instanceinternal->audio->audio3D, &listener, &emitter, flags, &settings);
|
|
|
|
uint32_t res;
|
|
|
|
res = FAudioSourceVoice_SetFrequencyRatio(instanceinternal->sourceVoice, settings.DopplerFactor, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
|
|
res = FAudioVoice_SetOutputMatrix(
|
|
instanceinternal->sourceVoice,
|
|
instanceinternal->audio->submixVoices[instance->type],
|
|
settings.SrcChannelCount,
|
|
settings.DstChannelCount,
|
|
settings.pMatrixCoefficients,
|
|
FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
|
|
FAudioFilterParameters FilterParametersDirect = { FAudioLowPassFilter, 2.0f * sinf(F3DAUDIO_PI / 6.0f * settings.LPFDirectCoefficient), 1.0f };
|
|
res = FAudioVoice_SetOutputFilterParameters(instanceinternal->sourceVoice, instanceinternal->audio->submixVoices[instance->type], &FilterParametersDirect, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
|
|
if(instance->IsEnableReverb()){
|
|
res = FAudioVoice_SetOutputMatrix(instanceinternal->sourceVoice, instanceinternal->audio->reverbSubmix, settings.SrcChannelCount, 1, &settings.ReverbLevel, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
FAudioFilterParameters FilterParametersReverb = { FAudioLowPassFilter, 2.0f * sinf(F3DAUDIO_PI / 6.0f * settings.LPFReverbCoefficient), 1.0f };
|
|
res = FAudioVoice_SetOutputFilterParameters(instanceinternal->sourceVoice, instanceinternal->audio->reverbSubmix, &FilterParametersReverb, FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetReverb(REVERB_PRESET preset) {
|
|
FAudioFXReverbParameters native;
|
|
ReverbConvertI3DL2ToNative(&reverbPresets[preset], &native);
|
|
uint32_t res = FAudioVoice_SetEffectParameters(audio_internal->reverbSubmix, 0, &native, sizeof(native), FAUDIO_COMMIT_NOW);
|
|
assert(res == 0);
|
|
}
|
|
}
|
|
|
|
#elif __SCE__
|
|
// PS5 audio implementation in wiAudio_PS5.cpp extension file
|
|
#else
|
|
|
|
namespace wi::audio
|
|
{
|
|
void Initialize() {}
|
|
|
|
bool CreateSound(const std::string& filename, Sound* sound) { return false; }
|
|
bool CreateSound(const uint8_t* data, size_t size, Sound* sound) { return false; }
|
|
bool CreateSoundInstance(const Sound* sound, SoundInstance* instance) { return false; }
|
|
|
|
void Play(SoundInstance* instance) {}
|
|
void Pause(SoundInstance* instance) {}
|
|
void Stop(SoundInstance* instance) {}
|
|
void SetVolume(float volume, SoundInstance* instance) {}
|
|
float GetVolume(const SoundInstance* instance) { return 0; }
|
|
void ExitLoop(SoundInstance* instance) {}
|
|
bool IsEnded(SoundInstance* instance) { return true; }
|
|
|
|
SampleInfo GetSampleInfo(const Sound* sound) { return {}; }
|
|
uint64_t GetTotalSamplesPlayed(const SoundInstance* instance) { return 0; }
|
|
|
|
void SetSubmixVolume(SUBMIX_TYPE type, float volume) {}
|
|
float GetSubmixVolume(SUBMIX_TYPE type) { return 0; }
|
|
|
|
void Update3D(SoundInstance* instance, const SoundInstance3D& instance3D) {}
|
|
|
|
void SetReverb(REVERB_PRESET preset) {}
|
|
}
|
|
|
|
#endif // _WIN32
|