diff options
Diffstat (limited to 'al/state.cpp')
| -rw-r--r-- | al/state.cpp | 880 |
1 files changed, 880 insertions, 0 deletions
diff --git a/al/state.cpp b/al/state.cpp new file mode 100644 index 00000000..25a0efd1 --- /dev/null +++ b/al/state.cpp @@ -0,0 +1,880 @@ +/** + * OpenAL cross platform audio library + * Copyright (C) 1999-2000 by authors. + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * Or go to http://www.gnu.org/copyleft/lgpl.html + */ + +#include "config.h" + +#include "version.h" + +#include <atomic> +#include <cmath> +#include <cstdlib> +#include <cstring> +#include <mutex> + +#include "AL/al.h" +#include "AL/alc.h" +#include "AL/alext.h" + +#include "alcontext.h" +#include "alexcpt.h" +#include "almalloc.h" +#include "alnumeric.h" +#include "alspan.h" +#include "alu.h" +#include "atomic.h" +#include "event.h" +#include "inprogext.h" +#include "opthelpers.h" +#include "strutils.h" + + +namespace { + +constexpr ALchar alVendor[] = "OpenAL Community"; +constexpr ALchar alVersion[] = "1.1 ALSOFT " ALSOFT_VERSION; +constexpr ALchar alRenderer[] = "OpenAL Soft"; + +// Error Messages +constexpr ALchar alNoError[] = "No Error"; +constexpr ALchar alErrInvalidName[] = "Invalid Name"; +constexpr ALchar alErrInvalidEnum[] = "Invalid Enum"; +constexpr ALchar alErrInvalidValue[] = "Invalid Value"; +constexpr ALchar alErrInvalidOp[] = "Invalid Operation"; +constexpr ALchar alErrOutOfMemory[] = "Out of Memory"; + +/* Resampler strings */ +template<Resampler rtype> struct ResamplerName { }; +template<> struct ResamplerName<Resampler::Point> +{ static constexpr const ALchar *Get() noexcept { return "Nearest"; } }; +template<> struct ResamplerName<Resampler::Linear> +{ static constexpr const ALchar *Get() noexcept { return "Linear"; } }; +template<> struct ResamplerName<Resampler::Cubic> +{ static constexpr const ALchar *Get() noexcept { return "Cubic"; } }; +template<> struct ResamplerName<Resampler::FastBSinc12> +{ static constexpr const ALchar *Get() noexcept { return "11th order Sinc (fast)"; } }; +template<> struct ResamplerName<Resampler::BSinc12> +{ static constexpr const ALchar *Get() noexcept { return "11th order Sinc"; } }; +template<> struct ResamplerName<Resampler::FastBSinc24> +{ static constexpr const ALchar *Get() noexcept { return "23rd order Sinc (fast)"; } }; +template<> struct ResamplerName<Resampler::BSinc24> +{ static constexpr const ALchar *Get() noexcept { return "23rd order Sinc"; } }; + +const ALchar *GetResamplerName(const Resampler rtype) +{ +#define HANDLE_RESAMPLER(r) case r: return ResamplerName<r>::Get() + switch(rtype) + { + HANDLE_RESAMPLER(Resampler::Point); + HANDLE_RESAMPLER(Resampler::Linear); + HANDLE_RESAMPLER(Resampler::Cubic); + HANDLE_RESAMPLER(Resampler::FastBSinc12); + HANDLE_RESAMPLER(Resampler::BSinc12); + HANDLE_RESAMPLER(Resampler::FastBSinc24); + HANDLE_RESAMPLER(Resampler::BSinc24); + } +#undef HANDLE_RESAMPLER + /* Should never get here. */ + throw std::runtime_error{"Unexpected resampler index"}; +} + +} // namespace + +/* WARNING: Non-standard export! Not part of any extension, or exposed in the + * alcFunctions list. + */ +extern "C" AL_API const ALchar* AL_APIENTRY alsoft_get_version(void) +START_API_FUNC +{ + static const auto spoof = al::getenv("ALSOFT_SPOOF_VERSION"); + if(spoof) return spoof->c_str(); + return ALSOFT_VERSION; +} +END_API_FUNC + +#define DO_UPDATEPROPS() do { \ + if(!context->mDeferUpdates.load(std::memory_order_acquire)) \ + UpdateContextProps(context.get()); \ + else \ + context->mPropsClean.clear(std::memory_order_release); \ +} while(0) + + +AL_API ALvoid AL_APIENTRY alEnable(ALenum capability) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + std::lock_guard<std::mutex> _{context->mPropLock}; + switch(capability) + { + case AL_SOURCE_DISTANCE_MODEL: + context->mSourceDistanceModel = AL_TRUE; + DO_UPDATEPROPS(); + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid enable property 0x%04x", capability); + } +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alDisable(ALenum capability) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + std::lock_guard<std::mutex> _{context->mPropLock}; + switch(capability) + { + case AL_SOURCE_DISTANCE_MODEL: + context->mSourceDistanceModel = AL_FALSE; + DO_UPDATEPROPS(); + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid disable property 0x%04x", capability); + } +} +END_API_FUNC + +AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return AL_FALSE; + + std::lock_guard<std::mutex> _{context->mPropLock}; + ALboolean value{AL_FALSE}; + switch(capability) + { + case AL_SOURCE_DISTANCE_MODEL: + value = context->mSourceDistanceModel; + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid is enabled property 0x%04x", capability); + } + + return value; +} +END_API_FUNC + +AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum pname) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return AL_FALSE; + + std::lock_guard<std::mutex> _{context->mPropLock}; + ALboolean value{AL_FALSE}; + switch(pname) + { + case AL_DOPPLER_FACTOR: + if(context->mDopplerFactor != 0.0f) + value = AL_TRUE; + break; + + case AL_DOPPLER_VELOCITY: + if(context->mDopplerVelocity != 0.0f) + value = AL_TRUE; + break; + + case AL_DISTANCE_MODEL: + if(context->mDistanceModel == DistanceModel::Default) + value = AL_TRUE; + break; + + case AL_SPEED_OF_SOUND: + if(context->mSpeedOfSound != 0.0f) + value = AL_TRUE; + break; + + case AL_DEFERRED_UPDATES_SOFT: + if(context->mDeferUpdates.load(std::memory_order_acquire)) + value = AL_TRUE; + break; + + case AL_GAIN_LIMIT_SOFT: + if(GAIN_MIX_MAX/context->mGainBoost != 0.0f) + value = AL_TRUE; + break; + + case AL_NUM_RESAMPLERS_SOFT: + /* Always non-0. */ + value = AL_TRUE; + break; + + case AL_DEFAULT_RESAMPLER_SOFT: + value = static_cast<int>(ResamplerDefault) ? AL_TRUE : AL_FALSE; + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid boolean property 0x%04x", pname); + } + + return value; +} +END_API_FUNC + +AL_API ALdouble AL_APIENTRY alGetDouble(ALenum pname) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return 0.0; + + std::lock_guard<std::mutex> _{context->mPropLock}; + ALdouble value{0.0}; + switch(pname) + { + case AL_DOPPLER_FACTOR: + value = context->mDopplerFactor; + break; + + case AL_DOPPLER_VELOCITY: + value = context->mDopplerVelocity; + break; + + case AL_DISTANCE_MODEL: + value = static_cast<ALdouble>(context->mDistanceModel); + break; + + case AL_SPEED_OF_SOUND: + value = context->mSpeedOfSound; + break; + + case AL_DEFERRED_UPDATES_SOFT: + if(context->mDeferUpdates.load(std::memory_order_acquire)) + value = static_cast<ALdouble>(AL_TRUE); + break; + + case AL_GAIN_LIMIT_SOFT: + value = ALdouble{GAIN_MIX_MAX}/context->mGainBoost; + break; + + case AL_NUM_RESAMPLERS_SOFT: + value = static_cast<ALdouble>(Resampler::Max) + 1.0; + break; + + case AL_DEFAULT_RESAMPLER_SOFT: + value = static_cast<ALdouble>(ResamplerDefault); + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid double property 0x%04x", pname); + } + + return value; +} +END_API_FUNC + +AL_API ALfloat AL_APIENTRY alGetFloat(ALenum pname) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return 0.0f; + + std::lock_guard<std::mutex> _{context->mPropLock}; + ALfloat value{0.0f}; + switch(pname) + { + case AL_DOPPLER_FACTOR: + value = context->mDopplerFactor; + break; + + case AL_DOPPLER_VELOCITY: + value = context->mDopplerVelocity; + break; + + case AL_DISTANCE_MODEL: + value = static_cast<ALfloat>(context->mDistanceModel); + break; + + case AL_SPEED_OF_SOUND: + value = context->mSpeedOfSound; + break; + + case AL_DEFERRED_UPDATES_SOFT: + if(context->mDeferUpdates.load(std::memory_order_acquire)) + value = static_cast<ALfloat>(AL_TRUE); + break; + + case AL_GAIN_LIMIT_SOFT: + value = GAIN_MIX_MAX/context->mGainBoost; + break; + + case AL_NUM_RESAMPLERS_SOFT: + value = static_cast<ALfloat>(Resampler::Max) + 1.0f; + break; + + case AL_DEFAULT_RESAMPLER_SOFT: + value = static_cast<ALfloat>(ResamplerDefault); + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid float property 0x%04x", pname); + } + + return value; +} +END_API_FUNC + +AL_API ALint AL_APIENTRY alGetInteger(ALenum pname) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return 0; + + std::lock_guard<std::mutex> _{context->mPropLock}; + ALint value{0}; + switch(pname) + { + case AL_DOPPLER_FACTOR: + value = static_cast<ALint>(context->mDopplerFactor); + break; + + case AL_DOPPLER_VELOCITY: + value = static_cast<ALint>(context->mDopplerVelocity); + break; + + case AL_DISTANCE_MODEL: + value = static_cast<ALint>(context->mDistanceModel); + break; + + case AL_SPEED_OF_SOUND: + value = static_cast<ALint>(context->mSpeedOfSound); + break; + + case AL_DEFERRED_UPDATES_SOFT: + if(context->mDeferUpdates.load(std::memory_order_acquire)) + value = AL_TRUE; + break; + + case AL_GAIN_LIMIT_SOFT: + value = static_cast<ALint>(GAIN_MIX_MAX/context->mGainBoost); + break; + + case AL_NUM_RESAMPLERS_SOFT: + value = static_cast<int>(Resampler::Max) + 1; + break; + + case AL_DEFAULT_RESAMPLER_SOFT: + value = static_cast<int>(ResamplerDefault); + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid integer property 0x%04x", pname); + } + + return value; +} +END_API_FUNC + +extern "C" AL_API ALint64SOFT AL_APIENTRY alGetInteger64SOFT(ALenum pname) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return 0_i64; + + std::lock_guard<std::mutex> _{context->mPropLock}; + ALint64SOFT value{0}; + switch(pname) + { + case AL_DOPPLER_FACTOR: + value = static_cast<ALint64SOFT>(context->mDopplerFactor); + break; + + case AL_DOPPLER_VELOCITY: + value = static_cast<ALint64SOFT>(context->mDopplerVelocity); + break; + + case AL_DISTANCE_MODEL: + value = static_cast<ALint64SOFT>(context->mDistanceModel); + break; + + case AL_SPEED_OF_SOUND: + value = static_cast<ALint64SOFT>(context->mSpeedOfSound); + break; + + case AL_DEFERRED_UPDATES_SOFT: + if(context->mDeferUpdates.load(std::memory_order_acquire)) + value = AL_TRUE; + break; + + case AL_GAIN_LIMIT_SOFT: + value = static_cast<ALint64SOFT>(GAIN_MIX_MAX/context->mGainBoost); + break; + + case AL_NUM_RESAMPLERS_SOFT: + value = static_cast<ALint64SOFT>(Resampler::Max) + 1; + break; + + case AL_DEFAULT_RESAMPLER_SOFT: + value = static_cast<ALint64SOFT>(ResamplerDefault); + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid integer64 property 0x%04x", pname); + } + + return value; +} +END_API_FUNC + +AL_API void* AL_APIENTRY alGetPointerSOFT(ALenum pname) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return nullptr; + + std::lock_guard<std::mutex> _{context->mPropLock}; + void *value{nullptr}; + switch(pname) + { + case AL_EVENT_CALLBACK_FUNCTION_SOFT: + value = reinterpret_cast<void*>(context->mEventCb); + break; + + case AL_EVENT_CALLBACK_USER_PARAM_SOFT: + value = context->mEventParam; + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid pointer property 0x%04x", pname); + } + + return value; +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alGetBooleanv(ALenum pname, ALboolean *values) +START_API_FUNC +{ + if(values) + { + switch(pname) + { + case AL_DOPPLER_FACTOR: + case AL_DOPPLER_VELOCITY: + case AL_DISTANCE_MODEL: + case AL_SPEED_OF_SOUND: + case AL_DEFERRED_UPDATES_SOFT: + case AL_GAIN_LIMIT_SOFT: + case AL_NUM_RESAMPLERS_SOFT: + case AL_DEFAULT_RESAMPLER_SOFT: + values[0] = alGetBoolean(pname); + return; + } + } + + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!values) + context->setError(AL_INVALID_VALUE, "NULL pointer"); + else switch(pname) + { + default: + context->setError(AL_INVALID_VALUE, "Invalid boolean-vector property 0x%04x", pname); + } +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alGetDoublev(ALenum pname, ALdouble *values) +START_API_FUNC +{ + if(values) + { + switch(pname) + { + case AL_DOPPLER_FACTOR: + case AL_DOPPLER_VELOCITY: + case AL_DISTANCE_MODEL: + case AL_SPEED_OF_SOUND: + case AL_DEFERRED_UPDATES_SOFT: + case AL_GAIN_LIMIT_SOFT: + case AL_NUM_RESAMPLERS_SOFT: + case AL_DEFAULT_RESAMPLER_SOFT: + values[0] = alGetDouble(pname); + return; + } + } + + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!values) + context->setError(AL_INVALID_VALUE, "NULL pointer"); + else switch(pname) + { + default: + context->setError(AL_INVALID_VALUE, "Invalid double-vector property 0x%04x", pname); + } +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alGetFloatv(ALenum pname, ALfloat *values) +START_API_FUNC +{ + if(values) + { + switch(pname) + { + case AL_DOPPLER_FACTOR: + case AL_DOPPLER_VELOCITY: + case AL_DISTANCE_MODEL: + case AL_SPEED_OF_SOUND: + case AL_DEFERRED_UPDATES_SOFT: + case AL_GAIN_LIMIT_SOFT: + case AL_NUM_RESAMPLERS_SOFT: + case AL_DEFAULT_RESAMPLER_SOFT: + values[0] = alGetFloat(pname); + return; + } + } + + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!values) + context->setError(AL_INVALID_VALUE, "NULL pointer"); + else switch(pname) + { + default: + context->setError(AL_INVALID_VALUE, "Invalid float-vector property 0x%04x", pname); + } +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alGetIntegerv(ALenum pname, ALint *values) +START_API_FUNC +{ + if(values) + { + switch(pname) + { + case AL_DOPPLER_FACTOR: + case AL_DOPPLER_VELOCITY: + case AL_DISTANCE_MODEL: + case AL_SPEED_OF_SOUND: + case AL_DEFERRED_UPDATES_SOFT: + case AL_GAIN_LIMIT_SOFT: + case AL_NUM_RESAMPLERS_SOFT: + case AL_DEFAULT_RESAMPLER_SOFT: + values[0] = alGetInteger(pname); + return; + } + } + + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!values) + context->setError(AL_INVALID_VALUE, "NULL pointer"); + else switch(pname) + { + default: + context->setError(AL_INVALID_VALUE, "Invalid integer-vector property 0x%04x", pname); + } +} +END_API_FUNC + +extern "C" AL_API void AL_APIENTRY alGetInteger64vSOFT(ALenum pname, ALint64SOFT *values) +START_API_FUNC +{ + if(values) + { + switch(pname) + { + case AL_DOPPLER_FACTOR: + case AL_DOPPLER_VELOCITY: + case AL_DISTANCE_MODEL: + case AL_SPEED_OF_SOUND: + case AL_DEFERRED_UPDATES_SOFT: + case AL_GAIN_LIMIT_SOFT: + case AL_NUM_RESAMPLERS_SOFT: + case AL_DEFAULT_RESAMPLER_SOFT: + values[0] = alGetInteger64SOFT(pname); + return; + } + } + + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!values) + context->setError(AL_INVALID_VALUE, "NULL pointer"); + else switch(pname) + { + default: + context->setError(AL_INVALID_VALUE, "Invalid integer64-vector property 0x%04x", pname); + } +} +END_API_FUNC + +AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, void **values) +START_API_FUNC +{ + if(values) + { + switch(pname) + { + case AL_EVENT_CALLBACK_FUNCTION_SOFT: + case AL_EVENT_CALLBACK_USER_PARAM_SOFT: + values[0] = alGetPointerSOFT(pname); + return; + } + } + + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!values) + context->setError(AL_INVALID_VALUE, "NULL pointer"); + else switch(pname) + { + default: + context->setError(AL_INVALID_VALUE, "Invalid pointer-vector property 0x%04x", pname); + } +} +END_API_FUNC + +AL_API const ALchar* AL_APIENTRY alGetString(ALenum pname) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return nullptr; + + const ALchar *value{nullptr}; + switch(pname) + { + case AL_VENDOR: + value = alVendor; + break; + + case AL_VERSION: + value = alVersion; + break; + + case AL_RENDERER: + value = alRenderer; + break; + + case AL_EXTENSIONS: + value = context->mExtensionList; + break; + + case AL_NO_ERROR: + value = alNoError; + break; + + case AL_INVALID_NAME: + value = alErrInvalidName; + break; + + case AL_INVALID_ENUM: + value = alErrInvalidEnum; + break; + + case AL_INVALID_VALUE: + value = alErrInvalidValue; + break; + + case AL_INVALID_OPERATION: + value = alErrInvalidOp; + break; + + case AL_OUT_OF_MEMORY: + value = alErrOutOfMemory; + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid string property 0x%04x", pname); + } + return value; +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alDopplerFactor(ALfloat value) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!(value >= 0.0f && std::isfinite(value))) + context->setError(AL_INVALID_VALUE, "Doppler factor %f out of range", value); + else + { + std::lock_guard<std::mutex> _{context->mPropLock}; + context->mDopplerFactor = value; + DO_UPDATEPROPS(); + } +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alDopplerVelocity(ALfloat value) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if((context->mEnabledEvts.load(std::memory_order_relaxed)&EventType_Deprecated)) + { + std::lock_guard<std::mutex> _{context->mEventCbLock}; + ALbitfieldSOFT enabledevts{context->mEnabledEvts.load(std::memory_order_relaxed)}; + if((enabledevts&EventType_Deprecated) && context->mEventCb) + { + static const char msg[] = + "alDopplerVelocity is deprecated in AL1.1, use alSpeedOfSound"; + const ALsizei msglen{sizeof(msg)-1}; + (*context->mEventCb)(AL_EVENT_TYPE_DEPRECATED_SOFT, 0, 0, msglen, msg, + context->mEventParam); + } + } + + if(!(value >= 0.0f && std::isfinite(value))) + context->setError(AL_INVALID_VALUE, "Doppler velocity %f out of range", value); + else + { + std::lock_guard<std::mutex> _{context->mPropLock}; + context->mDopplerVelocity = value; + DO_UPDATEPROPS(); + } +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alSpeedOfSound(ALfloat value) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!(value > 0.0f && std::isfinite(value))) + context->setError(AL_INVALID_VALUE, "Speed of sound %f out of range", value); + else + { + std::lock_guard<std::mutex> _{context->mPropLock}; + context->mSpeedOfSound = value; + DO_UPDATEPROPS(); + } +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alDistanceModel(ALenum value) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + if(!(value == AL_INVERSE_DISTANCE || value == AL_INVERSE_DISTANCE_CLAMPED || + value == AL_LINEAR_DISTANCE || value == AL_LINEAR_DISTANCE_CLAMPED || + value == AL_EXPONENT_DISTANCE || value == AL_EXPONENT_DISTANCE_CLAMPED || + value == AL_NONE)) + context->setError(AL_INVALID_VALUE, "Distance model 0x%04x out of range", value); + else + { + std::lock_guard<std::mutex> _{context->mPropLock}; + context->mDistanceModel = static_cast<DistanceModel>(value); + if(!context->mSourceDistanceModel) + DO_UPDATEPROPS(); + } +} +END_API_FUNC + + +AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + context->deferUpdates(); +} +END_API_FUNC + +AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return; + + context->processUpdates(); +} +END_API_FUNC + + +AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index) +START_API_FUNC +{ + ContextRef context{GetContextRef()}; + if UNLIKELY(!context) return nullptr; + + const ALchar *value{nullptr}; + switch(pname) + { + case AL_RESAMPLER_NAME_SOFT: + if(index < 0 || index > static_cast<ALint>(Resampler::Max)) + context->setError(AL_INVALID_VALUE, "Resampler name index %d out of range", index); + else + value = GetResamplerName(static_cast<Resampler>(index)); + break; + + default: + context->setError(AL_INVALID_VALUE, "Invalid string indexed property"); + } + return value; +} +END_API_FUNC + + +void UpdateContextProps(ALCcontext *context) +{ + /* Get an unused proprty container, or allocate a new one as needed. */ + ALcontextProps *props{context->mFreeContextProps.load(std::memory_order_acquire)}; + if(!props) + props = new ALcontextProps{}; + else + { + ALcontextProps *next; + do { + next = props->next.load(std::memory_order_relaxed); + } while(context->mFreeContextProps.compare_exchange_weak(props, next, + std::memory_order_seq_cst, std::memory_order_acquire) == 0); + } + + /* Copy in current property values. */ + props->DopplerFactor = context->mDopplerFactor; + props->DopplerVelocity = context->mDopplerVelocity; + props->SpeedOfSound = context->mSpeedOfSound; + + props->SourceDistanceModel = context->mSourceDistanceModel; + props->mDistanceModel = context->mDistanceModel; + + /* Set the new container for updating internal parameters. */ + props = context->mUpdate.exchange(props, std::memory_order_acq_rel); + if(props) + { + /* If there was an unused update container, put it back in the + * freelist. + */ + AtomicReplaceHead(context->mFreeContextProps, props); + } +} |