mirror/OpenMW
1
0
Fork 0
mirror of https://gitlab.com/OpenMW/openmw.git synced 2025-01-11 00:39:59 +00:00
Code Issues Projects Releases Wiki Activity
0b74146b05
OpenMW/apps/openmw/mwsound/openal_output.cpp

1673 lines
56 KiB
C++
Raw Blame History

#include <algorithm>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstring>
#include <memory>
#include <string_view>
#include <thread>
#include <vector>
#include <cstdint>
#include <components/debug/debuglog.hpp>
#include <components/misc/constants.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/misc/thread.hpp>
#include <components/vfs/manager.hpp>
#include "loudness.hpp"
#include "openal_output.hpp"
#include "sound.hpp"
#include "sound_decoder.hpp"
#include "soundmanagerimp.hpp"
#include "efx-presets.h"
#ifndef ALC_ALL_DEVICES_SPECIFIER
#define ALC_ALL_DEVICES_SPECIFIER 0x1013
#endif
#define MAKE_PTRID(id) ((void*)(uintptr_t)id)
#define GET_PTRID(ptr) ((ALuint)(uintptr_t)ptr)
namespace
{
const int sLoudnessFPS = 20; // loudness values per second of audio
ALCenum checkALCError(ALCdevice* device, const char* func, int line)
{
ALCenum err = alcGetError(device);
if (err != ALC_NO_ERROR)
Log(Debug::Error) << "ALC error " << alcGetString(device, err) << " (" << err << ") @ " << func << ":"
<< line;
return err;
}
#define getALCError(d) checkALCError((d), __FUNCTION__, __LINE__)
ALenum checkALError(const char* func, int line)
{
ALenum err = alGetError();
if (err != AL_NO_ERROR)
Log(Debug::Error) << "AL error " << alGetString(err) << " (" << err << ") @ " << func << ":" << line;
return err;
}
#define getALError() checkALError(__FUNCTION__, __LINE__)
// Helper to get an OpenAL extension function
template <typename T, typename R>
void convertPointer(T& dest, R src)
{
memcpy(&dest, &src, sizeof(src));
}
template <typename T>
void getALCFunc(T& func, ALCdevice* device, const char* name)
{
void* funcPtr = alcGetProcAddress(device, name);
convertPointer(func, funcPtr);
}
template <typename T>
void getALFunc(T& func, const char* name)
{
void* funcPtr = alGetProcAddress(name);
convertPointer(func, funcPtr);
}
// Effect objects
LPALGENEFFECTS alGenEffects;
LPALDELETEEFFECTS alDeleteEffects;
LPALISEFFECT alIsEffect;
LPALEFFECTI alEffecti;
LPALEFFECTIV alEffectiv;
LPALEFFECTF alEffectf;
LPALEFFECTFV alEffectfv;
LPALGETEFFECTI alGetEffecti;
LPALGETEFFECTIV alGetEffectiv;
LPALGETEFFECTF alGetEffectf;
LPALGETEFFECTFV alGetEffectfv;
// Filter objects
LPALGENFILTERS alGenFilters;
LPALDELETEFILTERS alDeleteFilters;
LPALISFILTER alIsFilter;
LPALFILTERI alFilteri;
LPALFILTERIV alFilteriv;
LPALFILTERF alFilterf;
LPALFILTERFV alFilterfv;
LPALGETFILTERI alGetFilteri;
LPALGETFILTERIV alGetFilteriv;
LPALGETFILTERF alGetFilterf;
LPALGETFILTERFV alGetFilterfv;
// Auxiliary slot objects
LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots;
LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots;
LPALISAUXILIARYEFFECTSLOT alIsAuxiliaryEffectSlot;
LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti;
LPALAUXILIARYEFFECTSLOTIV alAuxiliaryEffectSlotiv;
LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf;
LPALAUXILIARYEFFECTSLOTFV alAuxiliaryEffectSlotfv;
LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti;
LPALGETAUXILIARYEFFECTSLOTIV alGetAuxiliaryEffectSlotiv;
LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf;
LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv;
LPALEVENTCONTROLSOFT alEventControlSOFT;
LPALEVENTCALLBACKSOFT alEventCallbackSOFT;
LPALCREOPENDEVICESOFT alcReopenDeviceSOFT;
void LoadEffect(ALuint effect, const EFXEAXREVERBPROPERTIES& props)
{
ALint type = AL_NONE;
alGetEffecti(effect, AL_EFFECT_TYPE, &type);
if (type == AL_EFFECT_EAXREVERB)
{
alEffectf(effect, AL_EAXREVERB_DIFFUSION, props.flDiffusion);
alEffectf(effect, AL_EAXREVERB_DENSITY, props.flDensity);
alEffectf(effect, AL_EAXREVERB_GAIN, props.flGain);
alEffectf(effect, AL_EAXREVERB_GAINHF, props.flGainHF);
alEffectf(effect, AL_EAXREVERB_GAINLF, props.flGainLF);
alEffectf(effect, AL_EAXREVERB_DECAY_TIME, props.flDecayTime);
alEffectf(effect, AL_EAXREVERB_DECAY_HFRATIO, props.flDecayHFRatio);
alEffectf(effect, AL_EAXREVERB_DECAY_LFRATIO, props.flDecayLFRatio);
alEffectf(effect, AL_EAXREVERB_REFLECTIONS_GAIN, props.flReflectionsGain);
alEffectf(effect, AL_EAXREVERB_REFLECTIONS_DELAY, props.flReflectionsDelay);
alEffectfv(effect, AL_EAXREVERB_REFLECTIONS_PAN, props.flReflectionsPan);
alEffectf(effect, AL_EAXREVERB_LATE_REVERB_GAIN, props.flLateReverbGain);
alEffectf(effect, AL_EAXREVERB_LATE_REVERB_DELAY, props.flLateReverbDelay);
alEffectfv(effect, AL_EAXREVERB_LATE_REVERB_PAN, props.flLateReverbPan);
alEffectf(effect, AL_EAXREVERB_ECHO_TIME, props.flEchoTime);
alEffectf(effect, AL_EAXREVERB_ECHO_DEPTH, props.flEchoDepth);
alEffectf(effect, AL_EAXREVERB_MODULATION_TIME, props.flModulationTime);
alEffectf(effect, AL_EAXREVERB_MODULATION_DEPTH, props.flModulationDepth);
alEffectf(effect, AL_EAXREVERB_AIR_ABSORPTION_GAINHF, props.flAirAbsorptionGainHF);
alEffectf(effect, AL_EAXREVERB_HFREFERENCE, props.flHFReference);
alEffectf(effect, AL_EAXREVERB_LFREFERENCE, props.flLFReference);
alEffectf(effect, AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, props.flRoomRolloffFactor);
alEffecti(effect, AL_EAXREVERB_DECAY_HFLIMIT, props.iDecayHFLimit ? AL_TRUE : AL_FALSE);
}
else if (type == AL_EFFECT_REVERB)
{
alEffectf(effect, AL_REVERB_DIFFUSION, props.flDiffusion);
alEffectf(effect, AL_REVERB_DENSITY, props.flDensity);
alEffectf(effect, AL_REVERB_GAIN, props.flGain);
alEffectf(effect, AL_REVERB_GAINHF, props.flGainHF);
alEffectf(effect, AL_REVERB_DECAY_TIME, props.flDecayTime);
alEffectf(effect, AL_REVERB_DECAY_HFRATIO, props.flDecayHFRatio);
alEffectf(effect, AL_REVERB_REFLECTIONS_GAIN, props.flReflectionsGain);
alEffectf(effect, AL_REVERB_REFLECTIONS_DELAY, props.flReflectionsDelay);
alEffectf(effect, AL_REVERB_LATE_REVERB_GAIN, props.flLateReverbGain);
alEffectf(effect, AL_REVERB_LATE_REVERB_DELAY, props.flLateReverbDelay);
alEffectf(effect, AL_REVERB_AIR_ABSORPTION_GAINHF, props.flAirAbsorptionGainHF);
alEffectf(effect, AL_REVERB_ROOM_ROLLOFF_FACTOR, props.flRoomRolloffFactor);
alEffecti(effect, AL_REVERB_DECAY_HFLIMIT, props.iDecayHFLimit ? AL_TRUE : AL_FALSE);
}
getALError();
}
std::basic_string_view<ALCchar> getDeviceName(ALCdevice* device)
{
const ALCchar* name = nullptr;
if (alcIsExtensionPresent(device, "ALC_ENUMERATE_ALL_EXT"))
name = alcGetString(device, ALC_ALL_DEVICES_SPECIFIER);
if (alcGetError(device) != AL_NO_ERROR || !name)
name = alcGetString(device, ALC_DEVICE_SPECIFIER);
if (name == nullptr) // Prevent assigning nullptr to std::string
return {};
return name;
}
}
namespace MWSound
{
static ALenum getALFormat(ChannelConfig chans, SampleType type)
{
struct FormatEntry
{
ALenum format;
ChannelConfig chans;
SampleType type;
};
struct FormatEntryExt
{
const char name[32];
ChannelConfig chans;
SampleType type;
};
static const std::array<FormatEntry, 4> fmtlist{ {
{ AL_FORMAT_MONO16, ChannelConfig_Mono, SampleType_Int16 },
{ AL_FORMAT_MONO8, ChannelConfig_Mono, SampleType_UInt8 },
{ AL_FORMAT_STEREO16, ChannelConfig_Stereo, SampleType_Int16 },
{ AL_FORMAT_STEREO8, ChannelConfig_Stereo, SampleType_UInt8 },
} };
for (auto& fmt : fmtlist)
{
if (fmt.chans == chans && fmt.type == type)
return fmt.format;
}
if (alIsExtensionPresent("AL_EXT_MCFORMATS"))
{
static const std::array<FormatEntryExt, 6> mcfmtlist{ {
{ "AL_FORMAT_QUAD16", ChannelConfig_Quad, SampleType_Int16 },
{ "AL_FORMAT_QUAD8", ChannelConfig_Quad, SampleType_UInt8 },
{ "AL_FORMAT_51CHN16", ChannelConfig_5point1, SampleType_Int16 },
{ "AL_FORMAT_51CHN8", ChannelConfig_5point1, SampleType_UInt8 },
{ "AL_FORMAT_71CHN16", ChannelConfig_7point1, SampleType_Int16 },
{ "AL_FORMAT_71CHN8", ChannelConfig_7point1, SampleType_UInt8 },
} };
for (auto& fmt : mcfmtlist)
{
if (fmt.chans == chans && fmt.type == type)
{
ALenum format = alGetEnumValue(fmt.name);
if (format != 0 && format != -1)
return format;
}
}
}
if (alIsExtensionPresent("AL_EXT_FLOAT32"))
{
static const std::array<FormatEntryExt, 2> fltfmtlist{ {
{ "AL_FORMAT_MONO_FLOAT32", ChannelConfig_Mono, SampleType_Float32 },
{ "AL_FORMAT_STEREO_FLOAT32", ChannelConfig_Stereo, SampleType_Float32 },
} };
for (auto& fmt : fltfmtlist)
{
if (fmt.chans == chans && fmt.type == type)
{
ALenum format = alGetEnumValue(fmt.name);
if (format != 0 && format != -1)
return format;
}
}
if (alIsExtensionPresent("AL_EXT_MCFORMATS"))
{
static const std::array<FormatEntryExt, 3> fltmcfmtlist{ {
{ "AL_FORMAT_QUAD32", ChannelConfig_Quad, SampleType_Float32 },
{ "AL_FORMAT_51CHN32", ChannelConfig_5point1, SampleType_Float32 },
{ "AL_FORMAT_71CHN32", ChannelConfig_7point1, SampleType_Float32 },
} };
for (auto& fmt : fltmcfmtlist)
{
if (fmt.chans == chans && fmt.type == type)
{
ALenum format = alGetEnumValue(fmt.name);
if (format != 0 && format != -1)
return format;
}
}
}
}
Log(Debug::Warning) << "Unsupported sound format (" << getChannelConfigName(chans) << ", "
<< getSampleTypeName(type) << ")";
return AL_NONE;
}
//
// A streaming OpenAL sound.
//
class OpenAL_SoundStream
{
static const ALfloat sBufferLength;
private:
ALuint mSource;
std::array<ALuint, 6> mBuffers;
ALint mCurrentBufIdx;
ALenum mFormat;
ALsizei mSampleRate;
ALuint mBufferSize;
ALuint mFrameSize;
ALint mSilence;
DecoderPtr mDecoder;
std::unique_ptr<Sound_Loudness> mLoudnessAnalyzer;
std::atomic<bool> mIsFinished;
void updateAll(bool local);
OpenAL_SoundStream(const OpenAL_SoundStream& rhs);
OpenAL_SoundStream& operator=(const OpenAL_SoundStream& rhs);
friend class OpenAL_Output;
public:
OpenAL_SoundStream(ALuint src, DecoderPtr decoder);
~OpenAL_SoundStream();
bool init(bool getLoudnessData = false);
bool isPlaying();
double getStreamDelay() const;
double getStreamOffset() const;
float getCurrentLoudness() const;
bool process();
ALint refillQueue();
};
const ALfloat OpenAL_SoundStream::sBufferLength = 0.125f;
//
// A background streaming thread (keeps active streams processed)
//
struct OpenAL_Output::StreamThread
{
std::vector<OpenAL_SoundStream*> mStreams;
std::atomic<bool> mQuitNow;
std::mutex mMutex;
std::condition_variable mCondVar;
std::thread mThread;
StreamThread()
: mQuitNow(false)
, mThread([this] { run(); })
{
}
~StreamThread()
{
mQuitNow = true;
mMutex.lock();
mMutex.unlock();
mCondVar.notify_all();
mThread.join();
}
// thread entry point
void run()
{
std::unique_lock<std::mutex> lock(mMutex);
while (!mQuitNow)
{
auto iter = mStreams.begin();
while (iter != mStreams.end())
{
if ((*iter)->process() == false)
iter = mStreams.erase(iter);
else
++iter;
}
mCondVar.wait_for(lock, std::chrono::milliseconds(50));
}
}
void add(OpenAL_SoundStream* stream)
{
std::lock_guard<std::mutex> lock(mMutex);
if (std::find(mStreams.begin(), mStreams.end(), stream) == mStreams.end())
{
mStreams.push_back(stream);
mCondVar.notify_all();
}
}
void remove(OpenAL_SoundStream* stream)
{
std::lock_guard<std::mutex> lock(mMutex);
auto iter = std::find(mStreams.begin(), mStreams.end(), stream);
if (iter != mStreams.end())
mStreams.erase(iter);
}
void removeAll()
{
std::lock_guard<std::mutex> lock(mMutex);
mStreams.clear();
}
StreamThread(const StreamThread& rhs) = delete;
StreamThread& operator=(const StreamThread& rhs) = delete;
};
class OpenAL_Output::DefaultDeviceThread
{
public:
std::basic_string<ALCchar> mCurrentName;
private:
OpenAL_Output& mOutput;
std::atomic<bool> mQuitNow;
std::mutex mMutex;
std::condition_variable mCondVar;
std::thread mThread;
DefaultDeviceThread(const DefaultDeviceThread&) = delete;
DefaultDeviceThread& operator=(const DefaultDeviceThread&) = delete;
void run()
{
Misc::setCurrentThreadIdlePriority();
std::unique_lock<std::mutex> lock(mMutex);
while (!mQuitNow)
{
{
const std::lock_guard<std::mutex> openLock(mOutput.mReopenMutex);
auto defaultName = getDeviceName(nullptr);
if (mCurrentName != defaultName)
{
Log(Debug::Info) << "Default audio device changed";
ALCboolean reopened
= alcReopenDeviceSOFT(mOutput.mDevice, nullptr, mOutput.mContextAttributes.data());
if (reopened == AL_FALSE)
{
mCurrentName = defaultName;
Log(Debug::Warning) << "Failed to switch to new audio device";
}
else
mCurrentName = getDeviceName(mOutput.mDevice);
}
}
mCondVar.wait_for(lock, std::chrono::seconds(2));
}
}
public:
DefaultDeviceThread(OpenAL_Output& output, std::basic_string_view<ALCchar> name = {})
: mCurrentName(name)
, mOutput(output)
, mQuitNow(false)
, mThread([this] { run(); })
{
}
~DefaultDeviceThread()
{
mQuitNow = true;
mMutex.lock();
mMutex.unlock();
mCondVar.notify_all();
mThread.join();
}
};
OpenAL_SoundStream::OpenAL_SoundStream(ALuint src, DecoderPtr decoder)
: mSource(src)
, mCurrentBufIdx(0)
, mFormat(AL_NONE)
, mSampleRate(0)
, mBufferSize(0)
, mFrameSize(0)
, mSilence(0)
, mDecoder(std::move(decoder))
, mLoudnessAnalyzer(nullptr)
, mIsFinished(true)
{
mBuffers.fill(0);
}
OpenAL_SoundStream::~OpenAL_SoundStream()
{
if (mBuffers[0] && alIsBuffer(mBuffers[0]))
alDeleteBuffers(mBuffers.size(), mBuffers.data());
alGetError();
mDecoder->close();
}
bool OpenAL_SoundStream::init(bool getLoudnessData)
{
alGenBuffers(mBuffers.size(), mBuffers.data());
ALenum err = getALError();
if (err != AL_NO_ERROR)
return false;
ChannelConfig chans;
SampleType type;
try
{
mDecoder->getInfo(&mSampleRate, &chans, &type);
mFormat = getALFormat(chans, type);
}
catch (std::exception& e)
{
Log(Debug::Error) << "Failed to get stream info: " << e.what();
return false;
}
switch (type)
{
case SampleType_UInt8:
mSilence = 0x80;
break;
case SampleType_Int16:
mSilence = 0x00;
break;
case SampleType_Float32:
mSilence = 0x00;
break;
}
mFrameSize = framesToBytes(1, chans, type);
mBufferSize = static_cast<ALuint>(sBufferLength * mSampleRate);
mBufferSize *= mFrameSize;
if (getLoudnessData)
mLoudnessAnalyzer = std::make_unique<Sound_Loudness>(sLoudnessFPS, mSampleRate, chans, type);
mIsFinished = false;
return true;
}
bool OpenAL_SoundStream::isPlaying()
{
ALint state;
alGetSourcei(mSource, AL_SOURCE_STATE, &state);
getALError();
if (state == AL_PLAYING || state == AL_PAUSED)
return true;
return !mIsFinished;
}
double OpenAL_SoundStream::getStreamDelay() const
{
ALint state = AL_STOPPED;
double d = 0.0;
ALint offset;
alGetSourcei(mSource, AL_SAMPLE_OFFSET, &offset);
alGetSourcei(mSource, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING || state == AL_PAUSED)
{
ALint queued;
alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
ALint inqueue = mBufferSize / mFrameSize * queued - offset;
d = (double)inqueue / (double)mSampleRate;
}
getALError();
return d;
}
double OpenAL_SoundStream::getStreamOffset() const
{
ALint state = AL_STOPPED;
ALint offset;
double t;
alGetSourcei(mSource, AL_SAMPLE_OFFSET, &offset);
alGetSourcei(mSource, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING || state == AL_PAUSED)
{
ALint queued;
alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
ALint inqueue = mBufferSize / mFrameSize * queued - offset;
t = (double)(mDecoder->getSampleOffset() - inqueue) / (double)mSampleRate;
}
else
{
/* Underrun, or not started yet. The decoder offset is where we'll play
* next. */
t = (double)mDecoder->getSampleOffset() / (double)mSampleRate;
}
getALError();
return t;
}
float OpenAL_SoundStream::getCurrentLoudness() const
{
if (!mLoudnessAnalyzer.get())
return 0.f;
float time = getStreamOffset();
return mLoudnessAnalyzer->getLoudnessAtTime(time);
}
bool OpenAL_SoundStream::process()
{
try
{
if (refillQueue() > 0)
{
ALint state;
alGetSourcei(mSource, AL_SOURCE_STATE, &state);
if (state != AL_PLAYING && state != AL_PAUSED)
{
// Ensure all processed buffers are removed so we don't replay them.
refillQueue();
alSourcePlay(mSource);
}
}
}
catch (std::exception&)
{
Log(Debug::Error) << "Error updating stream \"" << mDecoder->getName() << "\"";
mIsFinished = true;
}
return !mIsFinished;
}
ALint OpenAL_SoundStream::refillQueue()
{
ALint processed;
alGetSourcei(mSource, AL_BUFFERS_PROCESSED, &processed);
while (processed > 0)
{
ALuint buf;
alSourceUnqueueBuffers(mSource, 1, &buf);
--processed;
}
ALint queued;
alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queued);
if (!mIsFinished && (ALuint)queued < mBuffers.size())
{
std::vector<char> data(mBufferSize);
for (; !mIsFinished && (ALuint)queued < mBuffers.size(); ++queued)
{
size_t got = mDecoder->read(data.data(), data.size());
if (got < data.size())
{
mIsFinished = true;
std::fill(data.begin() + got, data.end(), mSilence);
}
if (got > 0)
{
if (mLoudnessAnalyzer.get())
mLoudnessAnalyzer->analyzeLoudness(data);
ALuint bufid = mBuffers[mCurrentBufIdx];
alBufferData(bufid, mFormat, data.data(), data.size(), mSampleRate);
alSourceQueueBuffers(mSource, 1, &bufid);
mCurrentBufIdx = (mCurrentBufIdx + 1) % mBuffers.size();
}
}
}
return queued;
}
//
// An OpenAL output device
//
std::vector<std::string> OpenAL_Output::enumerate()
{
std::vector<std::string> devlist;
const ALCchar* devnames;
if (alcIsExtensionPresent(nullptr, "ALC_ENUMERATE_ALL_EXT"))
devnames = alcGetString(nullptr, ALC_ALL_DEVICES_SPECIFIER);
else
devnames = alcGetString(nullptr, ALC_DEVICE_SPECIFIER);
while (devnames && *devnames)
{
devlist.emplace_back(devnames);
devnames += strlen(devnames) + 1;
}
return devlist;
}
void OpenAL_Output::eventCallback(
ALenum eventType, ALuint object, ALuint param, ALsizei length, const ALchar* message, void* userParam)
{
if (eventType == AL_EVENT_TYPE_DISCONNECTED_SOFT)
static_cast<OpenAL_Output*>(userParam)->onDisconnect();
}
void OpenAL_Output::onDisconnect()
{
if (!mInitialized || !alcReopenDeviceSOFT)
return;
const std::lock_guard<std::mutex> lock(mReopenMutex);
Log(Debug::Warning) << "Audio device disconnected, attempting to reopen...";
ALCboolean reopened = alcReopenDeviceSOFT(mDevice, mDeviceName.c_str(), mContextAttributes.data());
if (reopened == AL_FALSE && !mDeviceName.empty())
{
reopened = alcReopenDeviceSOFT(mDevice, nullptr, mContextAttributes.data());
if (reopened == AL_TRUE && !mDefaultDeviceThread)
mDefaultDeviceThread = std::make_unique<DefaultDeviceThread>(*this);
}
if (reopened == AL_FALSE)
Log(Debug::Error) << "Failed to reopen audio device";
else
{
Log(Debug::Info) << "Reopened audio device";
if (mDefaultDeviceThread)
mDefaultDeviceThread->mCurrentName = getDeviceName(mDevice);
}
}
bool OpenAL_Output::init(const std::string& devname, const std::string& hrtfname, HrtfMode hrtfmode)
{
deinit();
std::lock_guard<std::mutex> lock(mReopenMutex);
Log(Debug::Info) << "Initializing OpenAL...";
mDeviceName = devname;
mDevice = alcOpenDevice(devname.c_str());
if (!mDevice && !devname.empty())
{
Log(Debug::Warning) << "Failed to open \"" << devname << "\", trying default";
mDevice = alcOpenDevice(nullptr);
mDeviceName.clear();
}
if (!mDevice)
{
Log(Debug::Error) << "Failed to open default audio device";
return false;
}
auto name = getDeviceName(mDevice);
Log(Debug::Info) << "Opened \"" << name << "\"";
ALCint major = 0, minor = 0;
alcGetIntegerv(mDevice, ALC_MAJOR_VERSION, 1, &major);
alcGetIntegerv(mDevice, ALC_MINOR_VERSION, 1, &minor);
Log(Debug::Info) << " ALC Version: " << major << "." << minor << "\n"
<< " ALC Extensions: " << alcGetString(mDevice, ALC_EXTENSIONS);
ALC.EXT_EFX = alcIsExtensionPresent(mDevice, "ALC_EXT_EFX");
ALC.SOFT_HRTF = alcIsExtensionPresent(mDevice, "ALC_SOFT_HRTF");
mContextAttributes.clear();
mContextAttributes.reserve(15);
if (ALC.SOFT_HRTF)
{
LPALCGETSTRINGISOFT alcGetStringiSOFT = nullptr;
getALCFunc(alcGetStringiSOFT, mDevice, "alcGetStringiSOFT");
mContextAttributes.push_back(ALC_HRTF_SOFT);
mContextAttributes.push_back(hrtfmode == HrtfMode::Disable ? ALC_FALSE
: hrtfmode == HrtfMode::Enable ? ALC_TRUE
:
/*hrtfmode == HrtfMode::Auto ?*/ ALC_DONT_CARE_SOFT);
if (!hrtfname.empty())
{
ALCint index = -1;
ALCint num_hrtf;
alcGetIntegerv(mDevice, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtf);
for (ALCint i = 0; i < num_hrtf; ++i)
{
const ALCchar* entry = alcGetStringiSOFT(mDevice, ALC_HRTF_SPECIFIER_SOFT, i);
if (hrtfname == entry)
{
index = i;
break;
}
}
if (index < 0)
Log(Debug::Warning) << "Failed to find HRTF \"" << hrtfname << "\", using default";
else
{
mContextAttributes.push_back(ALC_HRTF_ID_SOFT);
mContextAttributes.push_back(index);
}
}
}
mContextAttributes.push_back(0);
mContext = alcCreateContext(mDevice, mContextAttributes.data());
if (!mContext || alcMakeContextCurrent(mContext) == ALC_FALSE)
{
Log(Debug::Error) << "Failed to setup audio context: " << alcGetString(mDevice, alcGetError(mDevice));
if (mContext)
alcDestroyContext(mContext);
mContext = nullptr;
alcCloseDevice(mDevice);
mDevice = nullptr;
return false;
}
Log(Debug::Info) << " Vendor: " << alGetString(AL_VENDOR) << "\n"
<< " Renderer: " << alGetString(AL_RENDERER) << "\n"
<< " Version: " << alGetString(AL_VERSION) << "\n"
<< " Extensions: " << alGetString(AL_EXTENSIONS);
if (alIsExtensionPresent("AL_SOFT_events"))
{
getALFunc(alEventControlSOFT, "alEventControlSOFT");
getALFunc(alEventCallbackSOFT, "alEventCallbackSOFT");
}
if (alcIsExtensionPresent(mDevice, "ALC_SOFT_reopen_device"))
getALFunc(alcReopenDeviceSOFT, "alcReopenDeviceSOFT");
if (alEventControlSOFT)
{
static const std::array<ALenum, 1> events{ { AL_EVENT_TYPE_DISCONNECTED_SOFT } };
alEventControlSOFT(events.size(), events.data(), AL_TRUE);
alEventCallbackSOFT(&OpenAL_Output::eventCallback, this);
}
else
Log(Debug::Warning) << "Cannot detect audio device changes";
if (mDeviceName.empty() && !name.empty())
{
// If we opened the default device, switch devices if a new default is selected
if (alcReopenDeviceSOFT)
mDefaultDeviceThread = std::make_unique<DefaultDeviceThread>(*this, name);
else
Log(Debug::Warning) << "Cannot switch audio devices if the default changes";
}
if (!ALC.SOFT_HRTF)
Log(Debug::Warning) << "HRTF status unavailable";
else
{
ALCint hrtf_state;
alcGetIntegerv(mDevice, ALC_HRTF_SOFT, 1, &hrtf_state);
if (!hrtf_state)
Log(Debug::Info) << "HRTF disabled";
else
{
const ALCchar* hrtf = alcGetString(mDevice, ALC_HRTF_SPECIFIER_SOFT);
Log(Debug::Info) << "Enabled HRTF " << hrtf;
}
}
AL.SOFT_source_spatialize = alIsExtensionPresent("AL_SOFT_source_spatialize");
ALCuint maxtotal;
ALCint maxmono = 0, maxstereo = 0;
alcGetIntegerv(mDevice, ALC_MONO_SOURCES, 1, &maxmono);
alcGetIntegerv(mDevice, ALC_STEREO_SOURCES, 1, &maxstereo);
if (getALCError(mDevice) != ALC_NO_ERROR)
maxtotal = 256;
else
{
maxtotal = std::min<ALCuint>(maxmono + maxstereo, 256);
if (maxtotal == 0) // workaround for broken implementations
maxtotal = 256;
}
for (size_t i = 0; i < maxtotal; i++)
{
ALuint src = 0;
alGenSources(1, &src);
if (alGetError() != AL_NO_ERROR)
break;
mFreeSources.push_back(src);
}
if (mFreeSources.empty())
{
Log(Debug::Warning) << "Could not allocate any sound sourcess";
alcMakeContextCurrent(nullptr);
alcDestroyContext(mContext);
mContext = nullptr;
alcCloseDevice(mDevice);
mDevice = nullptr;
return false;
}
Log(Debug::Info) << "Allocated " << mFreeSources.size() << " sound sources";
if (ALC.EXT_EFX)
{
#define LOAD_FUNC(x) getALFunc(x, #x)
LOAD_FUNC(alGenEffects);
LOAD_FUNC(alDeleteEffects);
LOAD_FUNC(alIsEffect);
LOAD_FUNC(alEffecti);
LOAD_FUNC(alEffectiv);
LOAD_FUNC(alEffectf);
LOAD_FUNC(alEffectfv);
LOAD_FUNC(alGetEffecti);
LOAD_FUNC(alGetEffectiv);
LOAD_FUNC(alGetEffectf);
LOAD_FUNC(alGetEffectfv);
LOAD_FUNC(alGenFilters);
LOAD_FUNC(alDeleteFilters);
LOAD_FUNC(alIsFilter);
LOAD_FUNC(alFilteri);
LOAD_FUNC(alFilteriv);
LOAD_FUNC(alFilterf);
LOAD_FUNC(alFilterfv);
LOAD_FUNC(alGetFilteri);
LOAD_FUNC(alGetFilteriv);
LOAD_FUNC(alGetFilterf);
LOAD_FUNC(alGetFilterfv);
LOAD_FUNC(alGenAuxiliaryEffectSlots);
LOAD_FUNC(alDeleteAuxiliaryEffectSlots);
LOAD_FUNC(alIsAuxiliaryEffectSlot);
LOAD_FUNC(alAuxiliaryEffectSloti);
LOAD_FUNC(alAuxiliaryEffectSlotiv);
LOAD_FUNC(alAuxiliaryEffectSlotf);
LOAD_FUNC(alAuxiliaryEffectSlotfv);
LOAD_FUNC(alGetAuxiliaryEffectSloti);
LOAD_FUNC(alGetAuxiliaryEffectSlotiv);
LOAD_FUNC(alGetAuxiliaryEffectSlotf);
LOAD_FUNC(alGetAuxiliaryEffectSlotfv);
#undef LOAD_FUNC
if (getALError() != AL_NO_ERROR)
{
ALC.EXT_EFX = false;
goto skip_efx;
}
alGenFilters(1, &mWaterFilter);
if (alGetError() == AL_NO_ERROR)
{
alFilteri(mWaterFilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
if (alGetError() == AL_NO_ERROR)
{
Log(Debug::Info) << "Low-pass filter supported";
alFilterf(mWaterFilter, AL_LOWPASS_GAIN, 0.9f);
alFilterf(mWaterFilter, AL_LOWPASS_GAINHF, 0.125f);
}
else
{
alDeleteFilters(1, &mWaterFilter);
mWaterFilter = 0;
}
alGetError();
}
alGenAuxiliaryEffectSlots(1, &mEffectSlot);
alGetError();
alGenEffects(1, &mDefaultEffect);
if (alGetError() == AL_NO_ERROR)
{
alEffecti(mDefaultEffect, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
if (alGetError() == AL_NO_ERROR)
Log(Debug::Info) << "EAX Reverb supported";
else
{
alEffecti(mDefaultEffect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
if (alGetError() == AL_NO_ERROR)
Log(Debug::Info) << "Standard Reverb supported";
}
EFXEAXREVERBPROPERTIES props = EFX_REVERB_PRESET_LIVINGROOM;
props.flGain = 0.0f;
LoadEffect(mDefaultEffect, props);
}
alGenEffects(1, &mWaterEffect);
if (alGetError() == AL_NO_ERROR)
{
alEffecti(mWaterEffect, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
if (alGetError() != AL_NO_ERROR)
{
alEffecti(mWaterEffect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
alGetError();
}
LoadEffect(mWaterEffect, EFX_REVERB_PRESET_UNDERWATER);
}
alListenerf(AL_METERS_PER_UNIT, 1.0f / Constants::UnitsPerMeter);
}
skip_efx:
alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
// Speed of sound is in units per second. Take the sound speed in air (assumed
// meters per second), multiply by the units per meter to get the speed in u/s.
alSpeedOfSound(Constants::SoundSpeedInAir * Constants::UnitsPerMeter);
alGetError();
mInitialized = true;
return true;
}
void OpenAL_Output::deinit()
{
mStreamThread->removeAll();
mDefaultDeviceThread.reset();
for (ALuint source : mFreeSources)
alDeleteSources(1, &source);
mFreeSources.clear();
if (mEffectSlot)
alDeleteAuxiliaryEffectSlots(1, &mEffectSlot);
mEffectSlot = 0;
if (mDefaultEffect)
alDeleteEffects(1, &mDefaultEffect);
mDefaultEffect = 0;
if (mWaterEffect)
alDeleteEffects(1, &mWaterEffect);
mWaterEffect = 0;
if (mWaterFilter)
alDeleteFilters(1, &mWaterFilter);
mWaterFilter = 0;
if (alEventCallbackSOFT)
alEventCallbackSOFT(nullptr, nullptr);
alcMakeContextCurrent(nullptr);
if (mContext)
alcDestroyContext(mContext);
mContext = nullptr;
if (mDevice)
alcCloseDevice(mDevice);
mDevice = nullptr;
mInitialized = false;
}
std::vector<std::string> OpenAL_Output::enumerateHrtf()
{
std::vector<std::string> ret;
if (!mDevice || !ALC.SOFT_HRTF)
return ret;
LPALCGETSTRINGISOFT alcGetStringiSOFT = nullptr;
getALCFunc(alcGetStringiSOFT, mDevice, "alcGetStringiSOFT");
ALCint num_hrtf;
alcGetIntegerv(mDevice, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtf);
ret.reserve(num_hrtf);
for (ALCint i = 0; i < num_hrtf; ++i)
{
const ALCchar* entry = alcGetStringiSOFT(mDevice, ALC_HRTF_SPECIFIER_SOFT, i);
ret.emplace_back(entry);
}
return ret;
}
void OpenAL_Output::setHrtf(const std::string& hrtfname, HrtfMode hrtfmode)
{
if (!mDevice || !ALC.SOFT_HRTF)
{
Log(Debug::Info) << "HRTF extension not present";
return;
}
LPALCGETSTRINGISOFT alcGetStringiSOFT = nullptr;
getALCFunc(alcGetStringiSOFT, mDevice, "alcGetStringiSOFT");
LPALCRESETDEVICESOFT alcResetDeviceSOFT = nullptr;
getALCFunc(alcResetDeviceSOFT, mDevice, "alcResetDeviceSOFT");
std::vector<ALCint> attrs;
attrs.reserve(15);
attrs.push_back(ALC_HRTF_SOFT);
attrs.push_back(hrtfmode == HrtfMode::Disable ? ALC_FALSE
: hrtfmode == HrtfMode::Enable ? ALC_TRUE
:
/*hrtfmode == HrtfMode::Auto ?*/ ALC_DONT_CARE_SOFT);
if (!hrtfname.empty())
{
ALCint index = -1;
ALCint num_hrtf;
alcGetIntegerv(mDevice, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtf);
for (ALCint i = 0; i < num_hrtf; ++i)
{
const ALCchar* entry = alcGetStringiSOFT(mDevice, ALC_HRTF_SPECIFIER_SOFT, i);
if (hrtfname == entry)
{
index = i;
break;
}
}
if (index < 0)
Log(Debug::Warning) << "Failed to find HRTF name \"" << hrtfname << "\", using default";
else
{
attrs.push_back(ALC_HRTF_ID_SOFT);
attrs.push_back(index);
}
}
attrs.push_back(0);
alcResetDeviceSOFT(mDevice, attrs.data());
ALCint hrtf_state;
alcGetIntegerv(mDevice, ALC_HRTF_SOFT, 1, &hrtf_state);
if (!hrtf_state)
Log(Debug::Info) << "HRTF disabled";
else
{
const ALCchar* hrtf = alcGetString(mDevice, ALC_HRTF_SPECIFIER_SOFT);
Log(Debug::Info) << "Enabled HRTF " << hrtf;
}
}
std::pair<Sound_Handle, size_t> OpenAL_Output::loadSound(const std::string& fname)
{
getALError();
std::vector<char> data;
ALenum format = AL_NONE;
int srate = 0;
try
{
DecoderPtr decoder = mManager.getDecoder();
decoder->open(Misc::ResourceHelpers::correctSoundPath(fname, decoder->mResourceMgr));
ChannelConfig chans;
SampleType type;
decoder->getInfo(&srate, &chans, &type);
format = getALFormat(chans, type);
if (format)
decoder->readAll(data);
}
catch (std::exception& e)
{
Log(Debug::Error) << "Failed to load audio from " << fname << ": " << e.what();
}
if (data.empty())
{
// If we failed to get any usable audio, substitute with silence.
format = AL_FORMAT_MONO8;
srate = 8000;
data.assign(8000, -128);
}
ALint size;
ALuint buf = 0;
alGenBuffers(1, &buf);
alBufferData(buf, format, data.data(), data.size(), srate);
alGetBufferi(buf, AL_SIZE, &size);
if (getALError() != AL_NO_ERROR)
{
if (buf && alIsBuffer(buf))
alDeleteBuffers(1, &buf);
getALError();
return std::make_pair(nullptr, 0);
}
return std::make_pair(MAKE_PTRID(buf), size);
}
size_t OpenAL_Output::unloadSound(Sound_Handle data)
{
ALuint buffer = GET_PTRID(data);
if (!buffer)
return 0;
// Make sure no sources are playing this buffer before unloading it.
SoundVec::const_iterator iter = mActiveSounds.begin();
for (; iter != mActiveSounds.end(); ++iter)
{
if (!(*iter)->mHandle)
continue;
ALuint source = GET_PTRID((*iter)->mHandle);
ALint srcbuf;
alGetSourcei(source, AL_BUFFER, &srcbuf);
if ((ALuint)srcbuf == buffer)
{
alSourceStop(source);
alSourcei(source, AL_BUFFER, 0);
}
}
ALint size = 0;
alGetBufferi(buffer, AL_SIZE, &size);
alDeleteBuffers(1, &buffer);
getALError();
return size;
}
void OpenAL_Output::initCommon2D(
ALuint source, const osg::Vec3f& pos, ALfloat gain, ALfloat pitch, bool loop, bool useenv)
{
alSourcef(source, AL_REFERENCE_DISTANCE, 1.0f);
alSourcef(source, AL_MAX_DISTANCE, 1000.0f);
alSourcef(source, AL_ROLLOFF_FACTOR, 0.0f);
alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
alSourcei(source, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
if (AL.SOFT_source_spatialize)
alSourcei(source, AL_SOURCE_SPATIALIZE_SOFT, AL_FALSE);
if (useenv)
{
if (mWaterFilter)
alSourcei(source, AL_DIRECT_FILTER, (mListenerEnv == Env_Underwater) ? mWaterFilter : AL_FILTER_NULL);
else if (mListenerEnv == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
if (mEffectSlot)
alSource3i(source, AL_AUXILIARY_SEND_FILTER, mEffectSlot, 0, AL_FILTER_NULL);
}
else
{
if (mWaterFilter)
alSourcei(source, AL_DIRECT_FILTER, AL_FILTER_NULL);
if (mEffectSlot)
alSource3i(source, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, 0, AL_FILTER_NULL);
}
alSourcef(source, AL_GAIN, gain);
alSourcef(source, AL_PITCH, pitch);
alSourcefv(source, AL_POSITION, pos.ptr());
alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
}
void OpenAL_Output::initCommon3D(ALuint source, const osg::Vec3f& pos, ALfloat mindist, ALfloat maxdist,
ALfloat gain, ALfloat pitch, bool loop, bool useenv)
{
alSourcef(source, AL_REFERENCE_DISTANCE, mindist);
alSourcef(source, AL_MAX_DISTANCE, maxdist);
alSourcef(source, AL_ROLLOFF_FACTOR, 1.0f);
alSourcei(source, AL_SOURCE_RELATIVE, AL_FALSE);
alSourcei(source, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
if (AL.SOFT_source_spatialize)
alSourcei(source, AL_SOURCE_SPATIALIZE_SOFT, AL_TRUE);
if ((pos - mListenerPos).length2() > maxdist * maxdist)
gain = 0.0f;
if (useenv)
{
if (mWaterFilter)
alSourcei(source, AL_DIRECT_FILTER, (mListenerEnv == Env_Underwater) ? mWaterFilter : AL_FILTER_NULL);
else if (mListenerEnv == Env_Underwater)
{
gain *= 0.9f;
pitch *= 0.7f;
}
if (mEffectSlot)
alSource3i(source, AL_AUXILIARY_SEND_FILTER, mEffectSlot, 0, AL_FILTER_NULL);
}
else
{
if (mWaterFilter)
alSourcei(source, AL_DIRECT_FILTER, AL_FILTER_NULL);
if (mEffectSlot)
alSource3i(source, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, 0, AL_FILTER_NULL);
}
alSourcef(source, AL_GAIN, gain);
alSourcef(source, AL_PITCH, pitch);
alSourcefv(source, AL_POSITION, pos.ptr());
alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
}
void OpenAL_Output::updateCommon(
ALuint source, const osg::Vec3f& pos, ALfloat maxdist, ALfloat gain, ALfloat pitch, bool useenv)
{
if (useenv && mListenerEnv == Env_Underwater && !mWaterFilter)
{
gain *= 0.9f;
pitch *= 0.7f;
}
alSourcef(source, AL_GAIN, gain);
alSourcef(source, AL_PITCH, pitch);
alSourcefv(source, AL_POSITION, pos.ptr());
alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
}
bool OpenAL_Output::playSound(Sound* sound, Sound_Handle data, float offset)
{
ALuint source;
if (mFreeSources.empty())
{
Log(Debug::Warning) << "No free sources!";
return false;
}
source = mFreeSources.front();
initCommon2D(source, sound->getPosition(), sound->getRealVolume(), getTimeScaledPitch(sound),
sound->getIsLooping(), sound->getUseEnv());
alSourcei(source, AL_BUFFER, GET_PTRID(data));
alSourcef(source, AL_SEC_OFFSET, offset);
if (getALError() != AL_NO_ERROR)
{
alSourceRewind(source);
alSourcei(source, AL_BUFFER, 0);
alGetError();
return false;
}
alSourcePlay(source);
if (getALError() != AL_NO_ERROR)
{
alSourceRewind(source);
alSourcei(source, AL_BUFFER, 0);
alGetError();
return false;
}
mFreeSources.pop_front();
sound->mHandle = MAKE_PTRID(source);
mActiveSounds.push_back(sound);
return true;
}
bool OpenAL_Output::playSound3D(Sound* sound, Sound_Handle data, float offset)
{
ALuint source;
if (mFreeSources.empty())
{
Log(Debug::Warning) << "No free sources!";
return false;
}
source = mFreeSources.front();
initCommon3D(source, sound->getPosition(), sound->getMinDistance(), sound->getMaxDistance(),
sound->getRealVolume(), getTimeScaledPitch(sound), sound->getIsLooping(), sound->getUseEnv());
alSourcei(source, AL_BUFFER, GET_PTRID(data));
alSourcef(source, AL_SEC_OFFSET, offset);
if (getALError() != AL_NO_ERROR)
{
alSourceRewind(source);
alSourcei(source, AL_BUFFER, 0);
alGetError();
return false;
}
alSourcePlay(source);
if (getALError() != AL_NO_ERROR)
{
alSourceRewind(source);
alSourcei(source, AL_BUFFER, 0);
alGetError();
return false;
}
mFreeSources.pop_front();
sound->mHandle = MAKE_PTRID(source);
mActiveSounds.push_back(sound);
return true;
}
void OpenAL_Output::finishSound(Sound* sound)
{
if (!sound->mHandle)
return;
ALuint source = GET_PTRID(sound->mHandle);
sound->mHandle = nullptr;
// Rewind the stream to put the source back into an AL_INITIAL state, for
// the next time it's used.
alSourceRewind(source);
alSourcei(source, AL_BUFFER, 0);
getALError();
mFreeSources.push_back(source);
mActiveSounds.erase(std::find(mActiveSounds.begin(), mActiveSounds.end(), sound));
}
bool OpenAL_Output::isSoundPlaying(Sound* sound)
{
if (!sound->mHandle)
return false;
ALuint source = GET_PTRID(sound->mHandle);
ALint state = AL_STOPPED;
alGetSourcei(source, AL_SOURCE_STATE, &state);
getALError();
return state == AL_PLAYING || state == AL_PAUSED;
}
void OpenAL_Output::updateSound(Sound* sound)
{
if (!sound->mHandle)
return;
ALuint source = GET_PTRID(sound->mHandle);
updateCommon(source, sound->getPosition(), sound->getMaxDistance(), sound->getRealVolume(),
getTimeScaledPitch(sound), sound->getUseEnv());
getALError();
}
bool OpenAL_Output::streamSound(DecoderPtr decoder, Stream* sound, bool getLoudnessData)
{
if (mFreeSources.empty())
{
Log(Debug::Warning) << "No free sources!";
return false;
}
ALuint source = mFreeSources.front();
if (sound->getIsLooping())
Log(Debug::Warning) << "Warning: cannot loop stream \"" << decoder->getName() << "\"";
initCommon2D(
source, sound->getPosition(), sound->getRealVolume(), getTimeScaledPitch(sound), false, sound->getUseEnv());
if (getALError() != AL_NO_ERROR)
return false;
OpenAL_SoundStream* stream = new OpenAL_SoundStream(source, std::move(decoder));
if (!stream->init(getLoudnessData))
{
delete stream;
return false;
}
mStreamThread->add(stream);
mFreeSources.pop_front();
sound->mHandle = stream;
mActiveStreams.push_back(sound);
return true;
}
bool OpenAL_Output::streamSound3D(DecoderPtr decoder, Stream* sound, bool getLoudnessData)
{
if (mFreeSources.empty())
{
Log(Debug::Warning) << "No free sources!";
return false;
}
ALuint source = mFreeSources.front();
if (sound->getIsLooping())
Log(Debug::Warning) << "Warning: cannot loop stream \"" << decoder->getName() << "\"";
initCommon3D(source, sound->getPosition(), sound->getMinDistance(), sound->getMaxDistance(),
sound->getRealVolume(), getTimeScaledPitch(sound), false, sound->getUseEnv());
if (getALError() != AL_NO_ERROR)
return false;
OpenAL_SoundStream* stream = new OpenAL_SoundStream(source, std::move(decoder));
if (!stream->init(getLoudnessData))
{
delete stream;
return false;
}
mStreamThread->add(stream);
mFreeSources.pop_front();
sound->mHandle = stream;
mActiveStreams.push_back(sound);
return true;
}
void OpenAL_Output::finishStream(Stream* sound)
{
if (!sound->mHandle)
return;
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
ALuint source = stream->mSource;
sound->mHandle = nullptr;
mStreamThread->remove(stream);
// Rewind the stream to put the source back into an AL_INITIAL state, for
// the next time it's used.
alSourceRewind(source);
alSourcei(source, AL_BUFFER, 0);
getALError();
mFreeSources.push_back(source);
mActiveStreams.erase(std::find(mActiveStreams.begin(), mActiveStreams.end(), sound));
delete stream;
}
double OpenAL_Output::getStreamDelay(Stream* sound)
{
if (!sound->mHandle)
return 0.0;
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
return stream->getStreamDelay();
}
double OpenAL_Output::getStreamOffset(Stream* sound)
{
if (!sound->mHandle)
return 0.0;
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
std::lock_guard<std::mutex> lock(mStreamThread->mMutex);
return stream->getStreamOffset();
}
float OpenAL_Output::getStreamLoudness(Stream* sound)
{
if (!sound->mHandle)
return 0.0;
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
std::lock_guard<std::mutex> lock(mStreamThread->mMutex);
return stream->getCurrentLoudness();
}
bool OpenAL_Output::isStreamPlaying(Stream* sound)
{
if (!sound->mHandle)
return false;
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
std::lock_guard<std::mutex> lock(mStreamThread->mMutex);
return stream->isPlaying();
}
void OpenAL_Output::updateStream(Stream* sound)
{
if (!sound->mHandle)
return;
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
ALuint source = stream->mSource;
updateCommon(source, sound->getPosition(), sound->getMaxDistance(), sound->getRealVolume(),
getTimeScaledPitch(sound), sound->getUseEnv());
getALError();
}
void OpenAL_Output::startUpdate()
{
alcSuspendContext(alcGetCurrentContext());
}
void OpenAL_Output::finishUpdate()
{
alcProcessContext(alcGetCurrentContext());
}
void OpenAL_Output::updateListener(
const osg::Vec3f& pos, const osg::Vec3f& atdir, const osg::Vec3f& updir, Environment env)
{
if (mContext)
{
ALfloat orient[6] = { atdir.x(), atdir.y(), atdir.z(), updir.x(), updir.y(), updir.z() };
alListenerfv(AL_POSITION, pos.ptr());
alListenerfv(AL_ORIENTATION, orient);
if (env != mListenerEnv)
{
alSpeedOfSound(((env == Env_Underwater) ? Constants::SoundSpeedUnderwater : Constants::SoundSpeedInAir)
* Constants::UnitsPerMeter);
// Update active sources with the environment's direct filter
if (mWaterFilter)
{
ALuint filter = (env == Env_Underwater) ? mWaterFilter : AL_FILTER_NULL;
for (Sound* sound : mActiveSounds)
{
if (sound->getUseEnv())
alSourcei(GET_PTRID(sound->mHandle), AL_DIRECT_FILTER, filter);
}
for (Stream* sound : mActiveStreams)
{
if (sound->getUseEnv())
alSourcei(reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle)->mSource, AL_DIRECT_FILTER,
filter);
}
}
// Update the environment effect
if (mEffectSlot)
alAuxiliaryEffectSloti(
mEffectSlot, AL_EFFECTSLOT_EFFECT, (env == Env_Underwater) ? mWaterEffect : mDefaultEffect);
}
getALError();
}
mListenerPos = pos;
mListenerEnv = env;
}
void OpenAL_Output::pauseSounds(int types)
{
std::vector<ALuint> sources;
for (Sound* sound : mActiveSounds)
{
if ((types & sound->getPlayType()))
sources.push_back(GET_PTRID(sound->mHandle));
}
for (Stream* sound : mActiveStreams)
{
if ((types & sound->getPlayType()))
{
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
sources.push_back(stream->mSource);
}
}
if (!sources.empty())
{
alSourcePausev(sources.size(), sources.data());
getALError();
}
}
void OpenAL_Output::pauseActiveDevice()
{
if (mDevice == nullptr)
return;
if (alcIsExtensionPresent(mDevice, "ALC_SOFT_PAUSE_DEVICE"))
{
LPALCDEVICEPAUSESOFT alcDevicePauseSOFT = nullptr;
getALCFunc(alcDevicePauseSOFT, mDevice, "alcDevicePauseSOFT");
alcDevicePauseSOFT(mDevice);
getALCError(mDevice);
}
alListenerf(AL_GAIN, 0.0f);
}
void OpenAL_Output::resumeActiveDevice()
{
if (mDevice == nullptr)
return;
if (alcIsExtensionPresent(mDevice, "ALC_SOFT_PAUSE_DEVICE"))
{
LPALCDEVICERESUMESOFT alcDeviceResumeSOFT = nullptr;
getALCFunc(alcDeviceResumeSOFT, mDevice, "alcDeviceResumeSOFT");
alcDeviceResumeSOFT(mDevice);
getALCError(mDevice);
}
alListenerf(AL_GAIN, 1.0f);
}
void OpenAL_Output::resumeSounds(int types)
{
std::vector<ALuint> sources;
for (Sound* sound : mActiveSounds)
{
if ((types & sound->getPlayType()))
sources.push_back(GET_PTRID(sound->mHandle));
}
for (Stream* sound : mActiveStreams)
{
if ((types & sound->getPlayType()))
{
OpenAL_SoundStream* stream = reinterpret_cast<OpenAL_SoundStream*>(sound->mHandle);
sources.push_back(stream->mSource);
}
}
if (!sources.empty())
{
alSourcePlayv(sources.size(), sources.data());
getALError();
}
}
OpenAL_Output::OpenAL_Output(SoundManager& mgr)
: Sound_Output(mgr)
, mDevice(nullptr)
, mContext(nullptr)
, mListenerPos(0.0f, 0.0f, 0.0f)
, mListenerEnv(Env_Normal)
, mWaterFilter(0)
, mWaterEffect(0)
, mDefaultEffect(0)
, mEffectSlot(0)
, mStreamThread(std::make_unique<StreamThread>())
{
}
OpenAL_Output::~OpenAL_Output()
{
OpenAL_Output::deinit();
}
float OpenAL_Output::getTimeScaledPitch(SoundBase* sound)
{
const bool shouldScale = !(sound->mParams.mFlags & PlayMode::NoScaling);
return shouldScale ? sound->getPitch() * mManager.getSimulationTimeScale() : sound->getPitch();
}
}
Reference in New Issue View Git Blame Copy Permalink