/** * OpenAL cross platform audio library * Copyright (C) 1999-2007 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 "config_backends.h" #include "config_simd.h" #include "version.h" #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "AL/al.h" #include "AL/alc.h" #include "AL/alext.h" #include "AL/efx.h" #include "al/auxeffectslot.h" #include "al/buffer.h" #include "al/debug.h" #include "al/effect.h" #include "al/filter.h" #include "al/source.h" #include "alc/events.h" #include "albit.h" #include "alconfig.h" #include "almalloc.h" #include "alnumbers.h" #include "alnumeric.h" #include "alspan.h" #include "alstring.h" #include "alu.h" #include "atomic.h" #include "context.h" #include "core/ambidefs.h" #include "core/bformatdec.h" #include "core/bs2b.h" #include "core/context.h" #include "core/cpu_caps.h" #include "core/devformat.h" #include "core/device.h" #include "core/effects/base.h" #include "core/effectslot.h" #include "core/filters/nfc.h" #include "core/helpers.h" #include "core/mastering.h" #include "core/fpu_ctrl.h" #include "core/logging.h" #include "core/uhjfilter.h" #include "core/voice.h" #include "core/voice_change.h" #include "device.h" #include "effects/base.h" #include "export_list.h" #include "flexarray.h" #include "fmt/core.h" #include "inprogext.h" #include "intrusive_ptr.h" #include "opthelpers.h" #include "strutils.h" #include "backends/base.h" #include "backends/null.h" #include "backends/loopback.h" #if HAVE_PIPEWIRE #include "backends/pipewire.h" #endif #if HAVE_JACK #include "backends/jack.h" #endif #if HAVE_PULSEAUDIO #include "backends/pulseaudio.h" #endif #if HAVE_ALSA #include "backends/alsa.h" #endif #if HAVE_WASAPI #include "backends/wasapi.h" #endif #if HAVE_COREAUDIO #include "backends/coreaudio.h" #endif #if HAVE_OPENSL #include "backends/opensl.h" #endif #if HAVE_OBOE #include "backends/oboe.h" #endif #if HAVE_SOLARIS #include "backends/solaris.h" #endif #if HAVE_SNDIO #include "backends/sndio.hpp" #endif #if HAVE_OSS #include "backends/oss.h" #endif #if HAVE_DSOUND #include "backends/dsound.h" #endif #if HAVE_WINMM #include "backends/winmm.h" #endif #if HAVE_PORTAUDIO #include "backends/portaudio.hpp" #endif #if HAVE_SDL3 #include "backends/sdl3.h" #endif #if HAVE_SDL2 #include "backends/sdl2.h" #endif #if HAVE_OTHERIO #include "backends/otherio.h" #endif #if HAVE_WAVE #include "backends/wave.h" #endif #if ALSOFT_EAX #include "al/eax/api.h" #include "al/eax/globals.h" #endif /************************************************ * Library initialization ************************************************/ #if defined(_WIN32) && !defined(AL_LIBTYPE_STATIC) BOOL APIENTRY DllMain(HINSTANCE module, DWORD reason, LPVOID /*reserved*/) { switch(reason) { case DLL_PROCESS_ATTACH: /* Pin the DLL so we won't get unloaded until the process terminates */ GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, reinterpret_cast(module), &module); break; } return TRUE; } #endif namespace { using namespace std::string_view_literals; using std::chrono::seconds; using std::chrono::nanoseconds; using voidp = void*; using float2 = std::array; auto gProcessRunning = true; struct ProcessWatcher { ProcessWatcher() = default; ProcessWatcher(const ProcessWatcher&) = delete; ProcessWatcher& operator=(const ProcessWatcher&) = delete; ~ProcessWatcher() { gProcessRunning = false; } }; ProcessWatcher gProcessWatcher; /************************************************ * Backends ************************************************/ struct BackendInfo { const char *name; BackendFactory& (*getFactory)(); }; std::array BackendList{ #if HAVE_PIPEWIRE BackendInfo{"pipewire", PipeWireBackendFactory::getFactory}, #endif #if HAVE_PULSEAUDIO BackendInfo{"pulse", PulseBackendFactory::getFactory}, #endif #if HAVE_WASAPI BackendInfo{"wasapi", WasapiBackendFactory::getFactory}, #endif #if HAVE_COREAUDIO BackendInfo{"core", CoreAudioBackendFactory::getFactory}, #endif #if HAVE_OBOE BackendInfo{"oboe", OboeBackendFactory::getFactory}, #endif #if HAVE_OPENSL BackendInfo{"opensl", OSLBackendFactory::getFactory}, #endif #if HAVE_ALSA BackendInfo{"alsa", AlsaBackendFactory::getFactory}, #endif #if HAVE_SOLARIS BackendInfo{"solaris", SolarisBackendFactory::getFactory}, #endif #if HAVE_SNDIO BackendInfo{"sndio", SndIOBackendFactory::getFactory}, #endif #if HAVE_OSS BackendInfo{"oss", OSSBackendFactory::getFactory}, #endif #if HAVE_DSOUND BackendInfo{"dsound", DSoundBackendFactory::getFactory}, #endif #if HAVE_WINMM BackendInfo{"winmm", WinMMBackendFactory::getFactory}, #endif #if HAVE_PORTAUDIO BackendInfo{"port", PortBackendFactory::getFactory}, #endif #if HAVE_SDL3 BackendInfo{"sdl3", SDL3BackendFactory::getFactory}, #endif #if HAVE_SDL2 BackendInfo{"sdl2", SDL2BackendFactory::getFactory}, #endif #if HAVE_JACK BackendInfo{"jack", JackBackendFactory::getFactory}, #endif #if HAVE_OTHERIO BackendInfo{"otherio", OtherIOBackendFactory::getFactory}, #endif BackendInfo{"null", NullBackendFactory::getFactory}, #if HAVE_WAVE BackendInfo{"wave", WaveBackendFactory::getFactory}, #endif }; BackendFactory *PlaybackFactory{}; BackendFactory *CaptureFactory{}; [[nodiscard]] constexpr auto GetNoErrorString() noexcept { return "No Error"; } [[nodiscard]] constexpr auto GetInvalidDeviceString() noexcept { return "Invalid Device"; } [[nodiscard]] constexpr auto GetInvalidContextString() noexcept { return "Invalid Context"; } [[nodiscard]] constexpr auto GetInvalidEnumString() noexcept { return "Invalid Enum"; } [[nodiscard]] constexpr auto GetInvalidValueString() noexcept { return "Invalid Value"; } [[nodiscard]] constexpr auto GetOutOfMemoryString() noexcept { return "Out of Memory"; } [[nodiscard]] constexpr auto GetDefaultName() noexcept { return "OpenAL Soft\0"; } #ifdef _WIN32 [[nodiscard]] constexpr auto GetDevicePrefix() noexcept { return "OpenAL Soft on "sv; } #else [[nodiscard]] constexpr auto GetDevicePrefix() noexcept { return std::string_view{}; } #endif /************************************************ * Global variables ************************************************/ /* Enumerated device names */ std::vector alcAllDevicesArray; std::vector alcCaptureDeviceArray; std::string alcAllDevicesList; std::string alcCaptureDeviceList; /* Default is always the first in the list */ std::string alcDefaultAllDevicesSpecifier; std::string alcCaptureDefaultDeviceSpecifier; std::atomic LastNullDeviceError{ALC_NO_ERROR}; /* Flag to trap ALC device errors */ bool TrapALCError{false}; /* One-time configuration init control */ std::once_flag alc_config_once{}; /* Flag to specify if alcSuspendContext/alcProcessContext should defer/process * updates. */ bool SuspendDefers{true}; /* Initial seed for dithering. */ constexpr uint DitherRNGSeed{22222u}; /************************************************ * ALC information ************************************************/ [[nodiscard]] constexpr auto GetNoDeviceExtList() noexcept -> const char* { return "ALC_ENUMERATE_ALL_EXT " "ALC_ENUMERATION_EXT " "ALC_EXT_CAPTURE " "ALC_EXT_direct_context " "ALC_EXT_EFX " "ALC_EXT_thread_local_context " "ALC_SOFT_loopback " "ALC_SOFT_loopback_bformat " "ALC_SOFT_reopen_device " "ALC_SOFT_system_events"; } [[nodiscard]] constexpr auto GetExtensionList() noexcept -> const char* { return "ALC_ENUMERATE_ALL_EXT " "ALC_ENUMERATION_EXT " "ALC_EXT_CAPTURE " "ALC_EXT_debug " "ALC_EXT_DEDICATED " "ALC_EXT_direct_context " "ALC_EXT_disconnect " "ALC_EXT_EFX " "ALC_EXT_thread_local_context " "ALC_SOFT_device_clock " "ALC_SOFT_HRTF " "ALC_SOFT_loopback " "ALC_SOFT_loopback_bformat " "ALC_SOFT_output_limiter " "ALC_SOFT_output_mode " "ALC_SOFT_pause_device " "ALC_SOFT_reopen_device " "ALC_SOFT_system_events"; } constexpr int alcMajorVersion{1}; constexpr int alcMinorVersion{1}; constexpr int alcEFXMajorVersion{1}; constexpr int alcEFXMinorVersion{0}; using DeviceRef = al::intrusive_ptr; /************************************************ * Device lists ************************************************/ std::vector DeviceList; std::vector ContextList; std::recursive_mutex ListLock; void alc_initconfig() { if(auto loglevel = al::getenv("ALSOFT_LOGLEVEL")) { long lvl = strtol(loglevel->c_str(), nullptr, 0); if(lvl >= static_cast(LogLevel::Trace)) gLogLevel = LogLevel::Trace; else if(lvl <= static_cast(LogLevel::Disable)) gLogLevel = LogLevel::Disable; else gLogLevel = static_cast(lvl); } #ifdef _WIN32 if(const auto logfile = al::getenv(L"ALSOFT_LOGFILE")) { FILE *logf{_wfopen(logfile->c_str(), L"wt")}; if(logf) gLogFile = logf; else { auto u8name = wstr_to_utf8(*logfile); ERR("Failed to open log file '{}'", u8name); } } #else if(const auto logfile = al::getenv("ALSOFT_LOGFILE")) { FILE *logf{fopen(logfile->c_str(), "wt")}; if(logf) gLogFile = logf; else ERR("Failed to open log file '{}'", *logfile); } #endif TRACE("Initializing library v{}-{} {}", ALSOFT_VERSION, ALSOFT_GIT_COMMIT_HASH, ALSOFT_GIT_BRANCH); { std::string names; if(std::size(BackendList) < 1) names = "(none)"; else { const al::span infos{BackendList}; names = infos[0].name; for(const auto &backend : infos.subspan<1>()) { names += ", "; names += backend.name; } } TRACE("Supported backends: {}", names); } ReadALConfig(); if(auto suspendmode = al::getenv("__ALSOFT_SUSPEND_CONTEXT")) { if(al::case_compare(*suspendmode, "ignore"sv) == 0) { SuspendDefers = false; TRACE("Selected context suspend behavior, \"ignore\""); } else ERR("Unhandled context suspend behavior setting: \"{}\"", *suspendmode); } int capfilter{0}; #if HAVE_SSE4_1 capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3 | CPU_CAP_SSE4_1; #elif HAVE_SSE3 capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3; #elif HAVE_SSE2 capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2; #elif HAVE_SSE capfilter |= CPU_CAP_SSE; #endif #if HAVE_NEON capfilter |= CPU_CAP_NEON; #endif if(auto cpuopt = ConfigValueStr({}, {}, "disable-cpu-exts"sv)) { std::string_view cpulist{*cpuopt}; if(al::case_compare(cpulist, "all"sv) == 0) capfilter = 0; else while(!cpulist.empty()) { auto nextpos = std::min(cpulist.find(','), cpulist.size()); auto entry = cpulist.substr(0, nextpos); while(nextpos < cpulist.size() && cpulist[nextpos] == ',') ++nextpos; cpulist.remove_prefix(nextpos); while(!entry.empty() && std::isspace(entry.front())) entry.remove_prefix(1); while(!entry.empty() && std::isspace(entry.back())) entry.remove_suffix(1); if(entry.empty()) continue; if(al::case_compare(entry, "sse"sv) == 0) capfilter &= ~CPU_CAP_SSE; else if(al::case_compare(entry, "sse2"sv) == 0) capfilter &= ~CPU_CAP_SSE2; else if(al::case_compare(entry, "sse3"sv) == 0) capfilter &= ~CPU_CAP_SSE3; else if(al::case_compare(entry, "sse4.1"sv) == 0) capfilter &= ~CPU_CAP_SSE4_1; else if(al::case_compare(entry, "neon"sv) == 0) capfilter &= ~CPU_CAP_NEON; else WARN("Invalid CPU extension \"{}\"", entry); } } if(auto cpuopt = GetCPUInfo()) { if(!cpuopt->mVendor.empty() || !cpuopt->mName.empty()) { TRACE("Vendor ID: \"{}\"", cpuopt->mVendor); TRACE("Name: \"{}\"", cpuopt->mName); } const int caps{cpuopt->mCaps}; TRACE("Extensions:{}{}{}{}{}{}", ((capfilter&CPU_CAP_SSE) ?(caps&CPU_CAP_SSE) ?" +SSE"sv : " -SSE"sv : ""sv), ((capfilter&CPU_CAP_SSE2) ?(caps&CPU_CAP_SSE2) ?" +SSE2"sv : " -SSE2"sv : ""sv), ((capfilter&CPU_CAP_SSE3) ?(caps&CPU_CAP_SSE3) ?" +SSE3"sv : " -SSE3"sv : ""sv), ((capfilter&CPU_CAP_SSE4_1)?(caps&CPU_CAP_SSE4_1)?" +SSE4.1"sv : " -SSE4.1"sv : ""sv), ((capfilter&CPU_CAP_NEON) ?(caps&CPU_CAP_NEON) ?" +NEON"sv : " -NEON"sv : ""sv), (!capfilter) ? " -none-"sv : ""sv); CPUCapFlags = caps & capfilter; } if(auto priopt = ConfigValueInt({}, {}, "rt-prio"sv)) RTPrioLevel = *priopt; if(auto limopt = ConfigValueBool({}, {}, "rt-time-limit"sv)) AllowRTTimeLimit = *limopt; { CompatFlagBitset compatflags{}; auto checkflag = [](const char *envname, const std::string_view optname) -> bool { if(auto optval = al::getenv(envname)) { return al::case_compare(*optval, "true"sv) == 0 || strtol(optval->c_str(), nullptr, 0) == 1; } return GetConfigValueBool({}, "game_compat", optname, false); }; sBufferSubDataCompat = checkflag("__ALSOFT_ENABLE_SUB_DATA_EXT", "enable-sub-data-ext"sv); compatflags.set(CompatFlags::ReverseX, checkflag("__ALSOFT_REVERSE_X", "reverse-x"sv)); compatflags.set(CompatFlags::ReverseY, checkflag("__ALSOFT_REVERSE_Y", "reverse-y"sv)); compatflags.set(CompatFlags::ReverseZ, checkflag("__ALSOFT_REVERSE_Z", "reverse-z"sv)); aluInit(compatflags, ConfigValueFloat({}, "game_compat"sv, "nfc-scale"sv).value_or(1.0f)); } Voice::InitMixer(ConfigValueStr({}, {}, "resampler"sv)); if(auto uhjfiltopt = ConfigValueStr({}, "uhj"sv, "decode-filter"sv)) { if(al::case_compare(*uhjfiltopt, "fir256"sv) == 0) UhjDecodeQuality = UhjQualityType::FIR256; else if(al::case_compare(*uhjfiltopt, "fir512"sv) == 0) UhjDecodeQuality = UhjQualityType::FIR512; else if(al::case_compare(*uhjfiltopt, "iir"sv) == 0) UhjDecodeQuality = UhjQualityType::IIR; else WARN("Unsupported uhj/decode-filter: {}", *uhjfiltopt); } if(auto uhjfiltopt = ConfigValueStr({}, "uhj"sv, "encode-filter"sv)) { if(al::case_compare(*uhjfiltopt, "fir256"sv) == 0) UhjEncodeQuality = UhjQualityType::FIR256; else if(al::case_compare(*uhjfiltopt, "fir512"sv) == 0) UhjEncodeQuality = UhjQualityType::FIR512; else if(al::case_compare(*uhjfiltopt, "iir"sv) == 0) UhjEncodeQuality = UhjQualityType::IIR; else WARN("Unsupported uhj/encode-filter: {}", *uhjfiltopt); } if(auto traperr = al::getenv("ALSOFT_TRAP_ERROR"); traperr && (al::case_compare(*traperr, "true"sv) == 0 || std::strtol(traperr->c_str(), nullptr, 0) == 1)) { TrapALError = true; TrapALCError = true; } else { traperr = al::getenv("ALSOFT_TRAP_AL_ERROR"); if(traperr) TrapALError = al::case_compare(*traperr, "true"sv) == 0 || strtol(traperr->c_str(), nullptr, 0) == 1; else TrapALError = GetConfigValueBool({}, {}, "trap-al-error"sv, false); traperr = al::getenv("ALSOFT_TRAP_ALC_ERROR"); if(traperr) TrapALCError = al::case_compare(*traperr, "true"sv) == 0 || strtol(traperr->c_str(), nullptr, 0) == 1; else TrapALCError = GetConfigValueBool({}, {}, "trap-alc-error"sv, false); } if(auto boostopt = ConfigValueFloat({}, "reverb"sv, "boost"sv)) { const float valf{std::isfinite(*boostopt) ? std::clamp(*boostopt, -24.0f, 24.0f) : 0.0f}; ReverbBoost *= std::pow(10.0f, valf / 20.0f); } auto BackendListEnd = BackendList.end(); auto devopt = al::getenv("ALSOFT_DRIVERS"); if(!devopt) devopt = ConfigValueStr({}, {}, "drivers"sv); if(devopt) { auto backendlist_cur = BackendList.begin(); bool endlist{true}; std::string_view drvlist{*devopt}; while(!drvlist.empty()) { auto nextpos = std::min(drvlist.find(','), drvlist.size()); auto entry = drvlist.substr(0, nextpos); endlist = true; if(nextpos < drvlist.size()) { endlist = false; while(nextpos < drvlist.size() && drvlist[nextpos] == ',') ++nextpos; } drvlist.remove_prefix(nextpos); while(!entry.empty() && std::isspace(entry.front())) entry.remove_prefix(1); const bool delitem{!entry.empty() && entry.front() == '-'}; if(delitem) entry.remove_prefix(1); while(!entry.empty() && std::isspace(entry.back())) entry.remove_suffix(1); if(entry.empty()) continue; #ifdef HAVE_WASAPI /* HACK: For backwards compatibility, convert backend references of * mmdevapi to wasapi. This should eventually be removed. */ if(entry == "mmdevapi"sv) entry = "wasapi"sv; #endif auto find_backend = [entry](const BackendInfo &backend) -> bool { return entry == backend.name; }; auto this_backend = std::find_if(BackendList.begin(), BackendListEnd, find_backend); if(this_backend == BackendListEnd) continue; if(delitem) BackendListEnd = std::move(this_backend+1, BackendListEnd, this_backend); else backendlist_cur = std::rotate(backendlist_cur, this_backend, this_backend+1); } if(endlist) BackendListEnd = backendlist_cur; } else { /* Exclude the null and wave writer backends from being considered by * default. This ensures there will be no available devices if none of * the normal backends are usable, rather than pretending there is a * device but outputs nowhere. */ while(BackendListEnd != BackendList.begin()) { --BackendListEnd; if(BackendListEnd->name == "null"sv) break; } } auto init_backend = [](BackendInfo &backend) -> void { if(PlaybackFactory && CaptureFactory) return; BackendFactory &factory = backend.getFactory(); if(!factory.init()) { WARN("Failed to initialize backend \"{}\"", backend.name); return; } TRACE("Initialized backend \"{}\"", backend.name); if(!PlaybackFactory && factory.querySupport(BackendType::Playback)) { PlaybackFactory = &factory; TRACE("Added \"{}\" for playback", backend.name); } if(!CaptureFactory && factory.querySupport(BackendType::Capture)) { CaptureFactory = &factory; TRACE("Added \"{}\" for capture", backend.name); } }; std::for_each(BackendList.begin(), BackendListEnd, init_backend); LoopbackBackendFactory::getFactory().init(); if(!PlaybackFactory) WARN("No playback backend available!"); if(!CaptureFactory) WARN("No capture backend available!"); if(auto exclopt = ConfigValueStr({}, {}, "excludefx"sv)) { std::string_view exclude{*exclopt}; while(!exclude.empty()) { const auto nextpos = exclude.find(','); const auto entry = exclude.substr(0, nextpos); exclude.remove_prefix((nextpos < exclude.size()) ? nextpos+1 : exclude.size()); std::for_each(gEffectList.cbegin(), gEffectList.cend(), [entry](const EffectList &effectitem) noexcept { if(entry == std::data(effectitem.name)) DisabledEffects.set(effectitem.type); }); } } InitEffect(&ALCcontext::sDefaultEffect); auto defrevopt = al::getenv("ALSOFT_DEFAULT_REVERB"); if(!defrevopt) defrevopt = ConfigValueStr({}, {}, "default-reverb"sv); if(defrevopt) LoadReverbPreset(*defrevopt, &ALCcontext::sDefaultEffect); #if ALSOFT_EAX if(const auto eax_enable_opt = ConfigValueBool({}, "eax", "enable")) { eax_g_is_enabled = *eax_enable_opt; if(!eax_g_is_enabled) TRACE("EAX disabled by a configuration."); } else eax_g_is_enabled = true; if((DisabledEffects.test(EAXREVERB_EFFECT) || DisabledEffects.test(CHORUS_EFFECT)) && eax_g_is_enabled) { eax_g_is_enabled = false; TRACE("EAX disabled because {} disabled.", (DisabledEffects.test(EAXREVERB_EFFECT) && DisabledEffects.test(CHORUS_EFFECT)) ? "EAXReverb and Chorus are"sv : DisabledEffects.test(EAXREVERB_EFFECT) ? "EAXReverb is"sv : DisabledEffects.test(CHORUS_EFFECT) ? "Chorus is"sv : ""sv); } if(eax_g_is_enabled) { if(auto optval = al::getenv("ALSOFT_EAX_TRACE_COMMITS")) { EaxTraceCommits = al::case_compare(*optval, "true"sv) == 0 || strtol(optval->c_str(), nullptr, 0) == 1; } else EaxTraceCommits = GetConfigValueBool({}, "eax"sv, "trace-commits"sv, false); } #endif // ALSOFT_EAX } inline void InitConfig() { std::call_once(alc_config_once, [](){alc_initconfig();}); } /************************************************ * Device enumeration ************************************************/ void ProbeAllDevicesList() { InitConfig(); std::lock_guard listlock{ListLock}; if(!PlaybackFactory) { decltype(alcAllDevicesArray){}.swap(alcAllDevicesArray); decltype(alcAllDevicesList){}.swap(alcAllDevicesList); } else { alcAllDevicesArray = PlaybackFactory->enumerate(BackendType::Playback); if(const auto prefix = GetDevicePrefix(); !prefix.empty()) std::for_each(alcAllDevicesArray.begin(), alcAllDevicesArray.end(), [prefix](std::string &name) { name.insert(0, prefix); }); decltype(alcAllDevicesList){}.swap(alcAllDevicesList); if(alcAllDevicesArray.empty()) alcAllDevicesList += '\0'; else for(auto &devname : alcAllDevicesArray) alcAllDevicesList.append(devname) += '\0'; } } void ProbeCaptureDeviceList() { InitConfig(); std::lock_guard listlock{ListLock}; if(!CaptureFactory) { decltype(alcCaptureDeviceArray){}.swap(alcCaptureDeviceArray); decltype(alcCaptureDeviceList){}.swap(alcCaptureDeviceList); } else { alcCaptureDeviceArray = CaptureFactory->enumerate(BackendType::Capture); if(const auto prefix = GetDevicePrefix(); !prefix.empty()) std::for_each(alcCaptureDeviceArray.begin(), alcCaptureDeviceArray.end(), [prefix](std::string &name) { name.insert(0, prefix); }); decltype(alcCaptureDeviceList){}.swap(alcCaptureDeviceList); if(alcCaptureDeviceArray.empty()) alcCaptureDeviceList += '\0'; else for(auto &devname : alcCaptureDeviceArray) alcCaptureDeviceList.append(devname) += '\0'; } } al::span SpanFromAttributeList(const ALCint *attribs) noexcept { al::span attrSpan; if(attribs) { const ALCint *attrEnd{attribs}; while(*attrEnd != 0) attrEnd += 2; /* NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic) */ attrSpan = {attribs, attrEnd}; } return attrSpan; } struct DevFmtPair { DevFmtChannels chans; DevFmtType type; }; std::optional DecomposeDevFormat(ALenum format) { struct FormatType { ALenum format; DevFmtChannels channels; DevFmtType type; }; static constexpr std::array list{ FormatType{AL_FORMAT_MONO8, DevFmtMono, DevFmtUByte}, FormatType{AL_FORMAT_MONO16, DevFmtMono, DevFmtShort}, FormatType{AL_FORMAT_MONO_I32, DevFmtMono, DevFmtInt}, FormatType{AL_FORMAT_MONO_FLOAT32, DevFmtMono, DevFmtFloat}, FormatType{AL_FORMAT_STEREO8, DevFmtStereo, DevFmtUByte}, FormatType{AL_FORMAT_STEREO16, DevFmtStereo, DevFmtShort}, FormatType{AL_FORMAT_STEREO_I32, DevFmtStereo, DevFmtInt}, FormatType{AL_FORMAT_STEREO_FLOAT32, DevFmtStereo, DevFmtFloat}, FormatType{AL_FORMAT_QUAD8, DevFmtQuad, DevFmtUByte}, FormatType{AL_FORMAT_QUAD16, DevFmtQuad, DevFmtShort}, FormatType{AL_FORMAT_QUAD32, DevFmtQuad, DevFmtFloat}, FormatType{AL_FORMAT_QUAD_I32, DevFmtQuad, DevFmtInt}, FormatType{AL_FORMAT_QUAD_FLOAT32, DevFmtQuad, DevFmtFloat}, FormatType{AL_FORMAT_51CHN8, DevFmtX51, DevFmtUByte}, FormatType{AL_FORMAT_51CHN16, DevFmtX51, DevFmtShort}, FormatType{AL_FORMAT_51CHN32, DevFmtX51, DevFmtFloat}, FormatType{AL_FORMAT_51CHN_I32, DevFmtX51, DevFmtInt}, FormatType{AL_FORMAT_51CHN_FLOAT32, DevFmtX51, DevFmtFloat}, FormatType{AL_FORMAT_61CHN8, DevFmtX61, DevFmtUByte}, FormatType{AL_FORMAT_61CHN16, DevFmtX61, DevFmtShort}, FormatType{AL_FORMAT_61CHN32, DevFmtX61, DevFmtFloat}, FormatType{AL_FORMAT_61CHN_I32, DevFmtX61, DevFmtInt}, FormatType{AL_FORMAT_61CHN_FLOAT32, DevFmtX61, DevFmtFloat}, FormatType{AL_FORMAT_71CHN8, DevFmtX71, DevFmtUByte}, FormatType{AL_FORMAT_71CHN16, DevFmtX71, DevFmtShort}, FormatType{AL_FORMAT_71CHN32, DevFmtX71, DevFmtFloat}, FormatType{AL_FORMAT_71CHN_I32, DevFmtX71, DevFmtInt}, FormatType{AL_FORMAT_71CHN_FLOAT32, DevFmtX71, DevFmtFloat}, }; for(const auto &item : list) { if(item.format == format) return DevFmtPair{item.channels, item.type}; } return std::nullopt; } std::optional DevFmtTypeFromEnum(ALCenum type) { switch(type) { case ALC_BYTE_SOFT: return DevFmtByte; case ALC_UNSIGNED_BYTE_SOFT: return DevFmtUByte; case ALC_SHORT_SOFT: return DevFmtShort; case ALC_UNSIGNED_SHORT_SOFT: return DevFmtUShort; case ALC_INT_SOFT: return DevFmtInt; case ALC_UNSIGNED_INT_SOFT: return DevFmtUInt; case ALC_FLOAT_SOFT: return DevFmtFloat; } WARN("Unsupported format type: {:#04x}", as_unsigned(type)); return std::nullopt; } ALCenum EnumFromDevFmt(DevFmtType type) { switch(type) { case DevFmtByte: return ALC_BYTE_SOFT; case DevFmtUByte: return ALC_UNSIGNED_BYTE_SOFT; case DevFmtShort: return ALC_SHORT_SOFT; case DevFmtUShort: return ALC_UNSIGNED_SHORT_SOFT; case DevFmtInt: return ALC_INT_SOFT; case DevFmtUInt: return ALC_UNSIGNED_INT_SOFT; case DevFmtFloat: return ALC_FLOAT_SOFT; } throw std::runtime_error{fmt::format("Invalid DevFmtType: {}", int{al::to_underlying(type)})}; } std::optional DevFmtChannelsFromEnum(ALCenum channels) { switch(channels) { case ALC_MONO_SOFT: return DevFmtMono; case ALC_STEREO_SOFT: return DevFmtStereo; case ALC_QUAD_SOFT: return DevFmtQuad; case ALC_5POINT1_SOFT: return DevFmtX51; case ALC_6POINT1_SOFT: return DevFmtX61; case ALC_7POINT1_SOFT: return DevFmtX71; case ALC_BFORMAT3D_SOFT: return DevFmtAmbi3D; } WARN("Unsupported format channels: {:#04x}", as_unsigned(channels)); return std::nullopt; } ALCenum EnumFromDevFmt(DevFmtChannels channels) { switch(channels) { case DevFmtMono: return ALC_MONO_SOFT; case DevFmtStereo: return ALC_STEREO_SOFT; case DevFmtQuad: return ALC_QUAD_SOFT; case DevFmtX51: return ALC_5POINT1_SOFT; case DevFmtX61: return ALC_6POINT1_SOFT; case DevFmtX71: return ALC_7POINT1_SOFT; case DevFmtAmbi3D: return ALC_BFORMAT3D_SOFT; /* FIXME: Shouldn't happen. */ case DevFmtX714: case DevFmtX7144: case DevFmtX3D71: break; } throw std::runtime_error{fmt::format("Invalid DevFmtChannels: {}", int{al::to_underlying(channels)})}; } std::optional DevAmbiLayoutFromEnum(ALCenum layout) { switch(layout) { case ALC_FUMA_SOFT: return DevAmbiLayout::FuMa; case ALC_ACN_SOFT: return DevAmbiLayout::ACN; } WARN("Unsupported ambisonic layout: {:#04x}", as_unsigned(layout)); return std::nullopt; } ALCenum EnumFromDevAmbi(DevAmbiLayout layout) { switch(layout) { case DevAmbiLayout::FuMa: return ALC_FUMA_SOFT; case DevAmbiLayout::ACN: return ALC_ACN_SOFT; } throw std::runtime_error{fmt::format("Invalid DevAmbiLayout: {}", int{al::to_underlying(layout)})}; } std::optional DevAmbiScalingFromEnum(ALCenum scaling) { switch(scaling) { case ALC_FUMA_SOFT: return DevAmbiScaling::FuMa; case ALC_SN3D_SOFT: return DevAmbiScaling::SN3D; case ALC_N3D_SOFT: return DevAmbiScaling::N3D; } WARN("Unsupported ambisonic scaling: {:#04x}", as_unsigned(scaling)); return std::nullopt; } ALCenum EnumFromDevAmbi(DevAmbiScaling scaling) { switch(scaling) { case DevAmbiScaling::FuMa: return ALC_FUMA_SOFT; case DevAmbiScaling::SN3D: return ALC_SN3D_SOFT; case DevAmbiScaling::N3D: return ALC_N3D_SOFT; } throw std::runtime_error{fmt::format("Invalid DevAmbiScaling: {}", int{al::to_underlying(scaling)})}; } /* Downmixing channel arrays, to map a device format's missing channels to * existing ones. Based on what PipeWire does, though simplified. */ constexpr float inv_sqrt2f{static_cast(1.0 / al::numbers::sqrt2)}; constexpr std::array FrontStereo3dB{ InputRemixMap::TargetMix{FrontLeft, inv_sqrt2f}, InputRemixMap::TargetMix{FrontRight, inv_sqrt2f} }; constexpr std::array FrontStereo6dB{ InputRemixMap::TargetMix{FrontLeft, 0.5f}, InputRemixMap::TargetMix{FrontRight, 0.5f} }; constexpr std::array SideStereo3dB{ InputRemixMap::TargetMix{SideLeft, inv_sqrt2f}, InputRemixMap::TargetMix{SideRight, inv_sqrt2f} }; constexpr std::array BackStereo3dB{ InputRemixMap::TargetMix{BackLeft, inv_sqrt2f}, InputRemixMap::TargetMix{BackRight, inv_sqrt2f} }; constexpr std::array FrontLeft3dB{InputRemixMap::TargetMix{FrontLeft, inv_sqrt2f}}; constexpr std::array FrontRight3dB{InputRemixMap::TargetMix{FrontRight, inv_sqrt2f}}; constexpr std::array SideLeft0dB{InputRemixMap::TargetMix{SideLeft, 1.0f}}; constexpr std::array SideRight0dB{InputRemixMap::TargetMix{SideRight, 1.0f}}; constexpr std::array BackLeft0dB{InputRemixMap::TargetMix{BackLeft, 1.0f}}; constexpr std::array BackRight0dB{InputRemixMap::TargetMix{BackRight, 1.0f}}; constexpr std::array BackCenter3dB{InputRemixMap::TargetMix{BackCenter, inv_sqrt2f}}; constexpr std::array StereoDownmix{ InputRemixMap{FrontCenter, FrontStereo3dB}, InputRemixMap{SideLeft, FrontLeft3dB}, InputRemixMap{SideRight, FrontRight3dB}, InputRemixMap{BackLeft, FrontLeft3dB}, InputRemixMap{BackRight, FrontRight3dB}, InputRemixMap{BackCenter, FrontStereo6dB}, }; constexpr std::array QuadDownmix{ InputRemixMap{FrontCenter, FrontStereo3dB}, InputRemixMap{SideLeft, BackLeft0dB}, InputRemixMap{SideRight, BackRight0dB}, InputRemixMap{BackCenter, BackStereo3dB}, }; constexpr std::array X51Downmix{ InputRemixMap{BackLeft, SideLeft0dB}, InputRemixMap{BackRight, SideRight0dB}, InputRemixMap{BackCenter, SideStereo3dB}, }; constexpr std::array X61Downmix{ InputRemixMap{BackLeft, BackCenter3dB}, InputRemixMap{BackRight, BackCenter3dB}, }; constexpr std::array X71Downmix{ InputRemixMap{BackCenter, BackStereo3dB}, }; auto CreateDeviceLimiter(const al::Device *device, const float threshold) -> std::unique_ptr { static constexpr float LookAheadTime{0.001f}; static constexpr float HoldTime{0.002f}; static constexpr float PreGainDb{0.0f}; static constexpr float PostGainDb{0.0f}; static constexpr float Ratio{std::numeric_limits::infinity()}; static constexpr float KneeDb{0.0f}; static constexpr float AttackTime{0.02f}; static constexpr float ReleaseTime{0.2f}; const auto flags = Compressor::FlagBits{}.set(Compressor::AutoKnee).set(Compressor::AutoAttack) .set(Compressor::AutoRelease).set(Compressor::AutoPostGain).set(Compressor::AutoDeclip); return Compressor::Create(device->RealOut.Buffer.size(), static_cast(device->mSampleRate), flags, LookAheadTime, HoldTime, PreGainDb, PostGainDb, threshold, Ratio, KneeDb, AttackTime, ReleaseTime); } /** * Updates the device's base clock time with however many samples have been * done. This is used so frequency changes on the device don't cause the time * to jump forward or back. Must not be called while the device is running/ * mixing. */ inline void UpdateClockBase(al::Device *device) { using std::chrono::duration_cast; const auto mixLock = device->getWriteMixLock(); auto clockBaseSec = device->mClockBaseSec.load(std::memory_order_relaxed); auto clockBaseNSec = nanoseconds{device->mClockBaseNSec.load(std::memory_order_relaxed)}; clockBaseNSec += nanoseconds{seconds{device->mSamplesDone.load(std::memory_order_relaxed)}} / device->mSampleRate; clockBaseSec += duration_cast(clockBaseNSec); clockBaseNSec %= seconds{1}; device->mClockBaseSec.store(clockBaseSec, std::memory_order_relaxed); device->mClockBaseNSec.store(duration_cast(clockBaseNSec), std::memory_order_relaxed); device->mSamplesDone.store(0, std::memory_order_relaxed); } /** * Updates device parameters according to the attribute list (caller is * responsible for holding the list lock). */ auto UpdateDeviceParams(al::Device *device, const al::span attrList) -> ALCenum { if(attrList.empty() && device->Type == DeviceType::Loopback) { WARN("Missing attributes for loopback device"); return ALC_INVALID_VALUE; } uint numMono{device->NumMonoSources}; uint numStereo{device->NumStereoSources}; uint numSends{device->NumAuxSends}; std::optional stereomode; std::optional optlimit; std::optional optsrate; std::optional optchans; std::optional opttype; std::optional optlayout; std::optional optscale; uint period_size{DefaultUpdateSize}; uint buffer_size{DefaultUpdateSize * DefaultNumUpdates}; int hrtf_id{-1}; uint aorder{0u}; if(device->Type != DeviceType::Loopback) { /* Get default settings from the user configuration */ if(auto freqopt = device->configValue({}, "frequency")) { optsrate = std::clamp(*freqopt, MinOutputRate, MaxOutputRate); const double scale{static_cast(*optsrate) / double{DefaultOutputRate}}; period_size = static_cast(std::lround(period_size * scale)); } if(auto persizeopt = device->configValue({}, "period_size")) period_size = std::clamp(*persizeopt, 64u, 8192u); if(auto numperopt = device->configValue({}, "periods")) buffer_size = std::clamp(*numperopt, 2u, 16u) * period_size; else buffer_size = period_size * uint{DefaultNumUpdates}; if(auto typeopt = device->configValue({}, "sample-type")) { struct TypeMap { std::string_view name; DevFmtType type; }; constexpr std::array typelist{ TypeMap{"int8"sv, DevFmtByte }, TypeMap{"uint8"sv, DevFmtUByte }, TypeMap{"int16"sv, DevFmtShort }, TypeMap{"uint16"sv, DevFmtUShort}, TypeMap{"int32"sv, DevFmtInt }, TypeMap{"uint32"sv, DevFmtUInt }, TypeMap{"float32"sv, DevFmtFloat }, }; auto iter = std::find_if(typelist.begin(), typelist.end(), [svfmt=std::string_view{*typeopt}](const TypeMap &entry) -> bool { return al::case_compare(entry.name, svfmt) == 0; }); if(iter == typelist.end()) ERR("Unsupported sample-type: {}", *typeopt); else opttype = iter->type; } if(auto chanopt = device->configValue({}, "channels")) { struct ChannelMap { std::string_view name; DevFmtChannels chans; uint8_t order; }; constexpr std::array chanlist{ ChannelMap{"mono"sv, DevFmtMono, 0}, ChannelMap{"stereo"sv, DevFmtStereo, 0}, ChannelMap{"quad"sv, DevFmtQuad, 0}, ChannelMap{"surround51"sv, DevFmtX51, 0}, ChannelMap{"surround61"sv, DevFmtX61, 0}, ChannelMap{"surround71"sv, DevFmtX71, 0}, ChannelMap{"surround714"sv, DevFmtX714, 0}, ChannelMap{"surround7144"sv, DevFmtX7144, 0}, ChannelMap{"surround3d71"sv, DevFmtX3D71, 0}, ChannelMap{"surround51rear"sv, DevFmtX51, 0}, ChannelMap{"ambi1"sv, DevFmtAmbi3D, 1}, ChannelMap{"ambi2"sv, DevFmtAmbi3D, 2}, ChannelMap{"ambi3"sv, DevFmtAmbi3D, 3}, }; auto iter = std::find_if(chanlist.begin(), chanlist.end(), [svfmt=std::string_view{*chanopt}](const ChannelMap &entry) -> bool { return al::case_compare(entry.name, svfmt) == 0; }); if(iter == chanlist.end()) ERR("Unsupported channels: {}", *chanopt); else { optchans = iter->chans; aorder = iter->order; } } if(auto ambiopt = device->configValue({}, "ambi-format"sv)) { if(al::case_compare(*ambiopt, "fuma"sv) == 0) { optlayout = DevAmbiLayout::FuMa; optscale = DevAmbiScaling::FuMa; } else if(al::case_compare(*ambiopt, "acn+fuma"sv) == 0) { optlayout = DevAmbiLayout::ACN; optscale = DevAmbiScaling::FuMa; } else if(al::case_compare(*ambiopt, "ambix"sv) == 0 || al::case_compare(*ambiopt, "acn+sn3d"sv) == 0) { optlayout = DevAmbiLayout::ACN; optscale = DevAmbiScaling::SN3D; } else if(al::case_compare(*ambiopt, "acn+n3d"sv) == 0) { optlayout = DevAmbiLayout::ACN; optscale = DevAmbiScaling::N3D; } else ERR("Unsupported ambi-format: {}", *ambiopt); } if(auto hrtfopt = device->configValue({}, "hrtf"sv)) { WARN("general/hrtf is deprecated, please use stereo-encoding instead"); if(al::case_compare(*hrtfopt, "true"sv) == 0) stereomode = StereoEncoding::Hrtf; else if(al::case_compare(*hrtfopt, "false"sv) == 0) { if(!stereomode || *stereomode == StereoEncoding::Hrtf) stereomode = StereoEncoding::Default; } else if(al::case_compare(*hrtfopt, "auto"sv) != 0) ERR("Unexpected hrtf value: {}", *hrtfopt); } } if(auto encopt = device->configValue({}, "stereo-encoding"sv)) { if(al::case_compare(*encopt, "basic"sv) == 0 || al::case_compare(*encopt, "panpot"sv) == 0) stereomode = StereoEncoding::Basic; else if(al::case_compare(*encopt, "uhj") == 0) stereomode = StereoEncoding::Uhj; else if(al::case_compare(*encopt, "hrtf") == 0) stereomode = StereoEncoding::Hrtf; else ERR("Unexpected stereo-encoding: {}", *encopt); } // Check for app-specified attributes if(!attrList.empty()) { ALenum outmode{ALC_ANY_SOFT}; std::optional opthrtf; int freqAttr{}; #define ATTRIBUTE(a) a: TRACE("{} = {}", #a, attrList[attrIdx + 1]); #define ATTRIBUTE_HEX(a) a: TRACE("{} = {:#x}", #a, as_unsigned(attrList[attrIdx + 1])); for(size_t attrIdx{0};attrIdx < attrList.size();attrIdx+=2) { switch(attrList[attrIdx]) { case ATTRIBUTE_HEX(ALC_FORMAT_CHANNELS_SOFT) if(device->Type == DeviceType::Loopback) optchans = DevFmtChannelsFromEnum(attrList[attrIdx + 1]); break; case ATTRIBUTE_HEX(ALC_FORMAT_TYPE_SOFT) if(device->Type == DeviceType::Loopback) opttype = DevFmtTypeFromEnum(attrList[attrIdx + 1]); break; case ATTRIBUTE(ALC_FREQUENCY) freqAttr = attrList[attrIdx + 1]; break; case ATTRIBUTE_HEX(ALC_AMBISONIC_LAYOUT_SOFT) if(device->Type == DeviceType::Loopback) optlayout = DevAmbiLayoutFromEnum(attrList[attrIdx + 1]); break; case ATTRIBUTE_HEX(ALC_AMBISONIC_SCALING_SOFT) if(device->Type == DeviceType::Loopback) optscale = DevAmbiScalingFromEnum(attrList[attrIdx + 1]); break; case ATTRIBUTE(ALC_AMBISONIC_ORDER_SOFT) if(device->Type == DeviceType::Loopback) aorder = static_cast(attrList[attrIdx + 1]); break; case ATTRIBUTE(ALC_MONO_SOURCES) numMono = static_cast(attrList[attrIdx + 1]); if(numMono > INT_MAX) numMono = 0; break; case ATTRIBUTE(ALC_STEREO_SOURCES) numStereo = static_cast(attrList[attrIdx + 1]); if(numStereo > INT_MAX) numStereo = 0; break; case ATTRIBUTE(ALC_MAX_AUXILIARY_SENDS) numSends = static_cast(attrList[attrIdx + 1]); if(numSends > uint{std::numeric_limits::max()}) numSends = 0; else numSends = std::min(numSends, uint{MaxSendCount}); break; case ATTRIBUTE(ALC_HRTF_SOFT) if(attrList[attrIdx + 1] == ALC_FALSE) opthrtf = false; else if(attrList[attrIdx + 1] == ALC_TRUE) opthrtf = true; else if(attrList[attrIdx + 1] == ALC_DONT_CARE_SOFT) opthrtf = std::nullopt; break; case ATTRIBUTE(ALC_HRTF_ID_SOFT) hrtf_id = attrList[attrIdx + 1]; break; case ATTRIBUTE(ALC_OUTPUT_LIMITER_SOFT) if(attrList[attrIdx + 1] == ALC_FALSE) optlimit = false; else if(attrList[attrIdx + 1] == ALC_TRUE) optlimit = true; else if(attrList[attrIdx + 1] == ALC_DONT_CARE_SOFT) optlimit = std::nullopt; break; case ATTRIBUTE_HEX(ALC_OUTPUT_MODE_SOFT) outmode = attrList[attrIdx + 1]; break; case ATTRIBUTE_HEX(ALC_CONTEXT_FLAGS_EXT) /* Handled in alcCreateContext */ break; case ATTRIBUTE(ALC_SYNC) /* Ignored attribute */ break; default: TRACE("{:#04x} = {} ({:#x})", as_unsigned(attrList[attrIdx]), attrList[attrIdx + 1], as_unsigned(attrList[attrIdx + 1])); break; } } #undef ATTRIBUTE_HEX #undef ATTRIBUTE if(device->Type == DeviceType::Loopback) { if(!optchans || !opttype) return ALC_INVALID_VALUE; if(freqAttr < int{MinOutputRate} || freqAttr > int{MaxOutputRate}) return ALC_INVALID_VALUE; if(*optchans == DevFmtAmbi3D) { if(!optlayout || !optscale) return ALC_INVALID_VALUE; if(aorder < 1 || aorder > MaxAmbiOrder) return ALC_INVALID_VALUE; if((*optlayout == DevAmbiLayout::FuMa || *optscale == DevAmbiScaling::FuMa) && aorder > 3) return ALC_INVALID_VALUE; } else if(*optchans == DevFmtStereo) { if(opthrtf) { if(*opthrtf) stereomode = StereoEncoding::Hrtf; else { if(stereomode.value_or(StereoEncoding::Hrtf) == StereoEncoding::Hrtf) stereomode = StereoEncoding::Default; } } if(outmode == ALC_STEREO_BASIC_SOFT) stereomode = StereoEncoding::Basic; else if(outmode == ALC_STEREO_UHJ_SOFT) stereomode = StereoEncoding::Uhj; else if(outmode == ALC_STEREO_HRTF_SOFT) stereomode = StereoEncoding::Hrtf; } optsrate = static_cast(freqAttr); } else { if(opthrtf) { if(*opthrtf) stereomode = StereoEncoding::Hrtf; else { if(stereomode.value_or(StereoEncoding::Hrtf) == StereoEncoding::Hrtf) stereomode = StereoEncoding::Default; } } if(outmode != ALC_ANY_SOFT) { using OutputMode = al::Device::OutputMode; switch(OutputMode(outmode)) { case OutputMode::Any: break; case OutputMode::Mono: optchans = DevFmtMono; break; case OutputMode::Stereo: optchans = DevFmtStereo; break; case OutputMode::StereoBasic: optchans = DevFmtStereo; stereomode = StereoEncoding::Basic; break; case OutputMode::Uhj2: optchans = DevFmtStereo; stereomode = StereoEncoding::Uhj; break; case OutputMode::Hrtf: optchans = DevFmtStereo; stereomode = StereoEncoding::Hrtf; break; case OutputMode::Quad: optchans = DevFmtQuad; break; case OutputMode::X51: optchans = DevFmtX51; break; case OutputMode::X61: optchans = DevFmtX61; break; case OutputMode::X71: optchans = DevFmtX71; break; } } if(freqAttr) { uint oldrate = optsrate.value_or(DefaultOutputRate); freqAttr = std::clamp(freqAttr, MinOutputRate, MaxOutputRate); const double scale{static_cast(freqAttr) / oldrate}; period_size = static_cast(std::lround(period_size * scale)); buffer_size = static_cast(std::lround(buffer_size * scale)); optsrate = static_cast(freqAttr); } } /* If a context is already running on the device, stop playback so the * device attributes can be updated. */ if(device->mDeviceState == DeviceState::Playing) { device->Backend->stop(); device->mDeviceState = DeviceState::Unprepared; } UpdateClockBase(device); } if(device->mDeviceState == DeviceState::Playing) return ALC_NO_ERROR; device->mDeviceState = DeviceState::Unprepared; device->AvgSpeakerDist = 0.0f; device->mNFCtrlFilter = NfcFilter{}; device->mUhjEncoder = nullptr; device->AmbiDecoder = nullptr; device->Bs2b = nullptr; device->PostProcess = nullptr; device->Limiter = nullptr; device->ChannelDelays = nullptr; std::fill(std::begin(device->HrtfAccumData), std::end(device->HrtfAccumData), float2{}); device->Dry.AmbiMap.fill(BFChannelConfig{}); device->Dry.Buffer = {}; std::fill(std::begin(device->NumChannelsPerOrder), std::end(device->NumChannelsPerOrder), 0u); device->RealOut.RemixMap = {}; device->RealOut.ChannelIndex.fill(InvalidChannelIndex); device->RealOut.Buffer = {}; device->MixBuffer.clear(); device->MixBuffer.shrink_to_fit(); UpdateClockBase(device); device->FixedLatency = nanoseconds::zero(); device->DitherDepth = 0.0f; device->DitherSeed = DitherRNGSeed; device->mHrtfStatus = ALC_HRTF_DISABLED_SOFT; /************************************************************************* * Update device format request */ if(device->Type == DeviceType::Loopback) { device->mSampleRate = *optsrate; device->FmtChans = *optchans; device->FmtType = *opttype; if(device->FmtChans == DevFmtAmbi3D) { device->mAmbiOrder = aorder; device->mAmbiLayout = *optlayout; device->mAmbiScale = *optscale; } device->Flags.set(FrequencyRequest).set(ChannelsRequest).set(SampleTypeRequest); } else { device->FmtType = opttype.value_or(DevFmtTypeDefault); device->FmtChans = optchans.value_or(DevFmtChannelsDefault); device->mAmbiOrder = 0; device->mBufferSize = buffer_size; device->mUpdateSize = period_size; device->mSampleRate = optsrate.value_or(DefaultOutputRate); device->Flags.set(FrequencyRequest, optsrate.has_value()) .set(ChannelsRequest, optchans.has_value()) .set(SampleTypeRequest, opttype.has_value()); if(device->FmtChans == DevFmtAmbi3D) { device->mAmbiOrder = std::clamp(aorder, 1u, uint{MaxAmbiOrder}); device->mAmbiLayout = optlayout.value_or(DevAmbiLayout::Default); device->mAmbiScale = optscale.value_or(DevAmbiScaling::Default); if(device->mAmbiOrder > 3 && (device->mAmbiLayout == DevAmbiLayout::FuMa || device->mAmbiScale == DevAmbiScaling::FuMa)) { ERR("FuMa is incompatible with {}{} order ambisonics (up to 3rd order only)", device->mAmbiOrder, GetCounterSuffix(device->mAmbiOrder)); device->mAmbiOrder = 3; } } } TRACE("Pre-reset: {}{}, {}{}, {}{}hz, {} / {} buffer", device->Flags.test(ChannelsRequest)?"*":"", DevFmtChannelsString(device->FmtChans), device->Flags.test(SampleTypeRequest)?"*":"", DevFmtTypeString(device->FmtType), device->Flags.test(FrequencyRequest)?"*":"", device->mSampleRate, device->mUpdateSize, device->mBufferSize); const uint oldFreq{device->mSampleRate}; const DevFmtChannels oldChans{device->FmtChans}; const DevFmtType oldType{device->FmtType}; try { auto backend = device->Backend.get(); if(!backend->reset()) throw al::backend_exception{al::backend_error::DeviceError, "Device reset failure"}; } catch(std::exception &e) { ERR("Device error: {}", e.what()); device->handleDisconnect("{}", e.what()); return ALC_INVALID_DEVICE; } if(device->FmtChans != oldChans && device->Flags.test(ChannelsRequest)) { ERR("Failed to set {}, got {} instead", DevFmtChannelsString(oldChans), DevFmtChannelsString(device->FmtChans)); device->Flags.reset(ChannelsRequest); } if(device->FmtType != oldType && device->Flags.test(SampleTypeRequest)) { ERR("Failed to set {}, got {} instead", DevFmtTypeString(oldType), DevFmtTypeString(device->FmtType)); device->Flags.reset(SampleTypeRequest); } if(device->mSampleRate != oldFreq && device->Flags.test(FrequencyRequest)) { WARN("Failed to set {}hz, got {}hz instead", oldFreq, device->mSampleRate); device->Flags.reset(FrequencyRequest); } TRACE("Post-reset: {}, {}, {}hz, {} / {} buffer", DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType), device->mSampleRate, device->mUpdateSize, device->mBufferSize); if(device->Type != DeviceType::Loopback) { if(auto modeopt = device->configValue({}, "stereo-mode")) { if(al::case_compare(*modeopt, "headphones"sv) == 0) device->Flags.set(DirectEar); else if(al::case_compare(*modeopt, "speakers"sv) == 0) device->Flags.reset(DirectEar); else if(al::case_compare(*modeopt, "auto"sv) != 0) ERR("Unexpected stereo-mode: {}", *modeopt); } } aluInitRenderer(device, hrtf_id, stereomode); /* Calculate the max number of sources, and split them between the mono and * stereo count given the requested number of stereo sources. */ if(auto srcsopt = device->configValue({}, "sources"sv)) { if(*srcsopt <= 0) numMono = 256; else numMono = std::max(*srcsopt, 16u); } else { numMono = std::min(numMono, std::numeric_limits::max()-numStereo); numMono = std::max(numMono+numStereo, 256u); } numStereo = std::min(numStereo, numMono); numMono -= numStereo; device->SourcesMax = numMono + numStereo; device->NumMonoSources = numMono; device->NumStereoSources = numStereo; if(auto sendsopt = device->configValue({}, "sends"sv)) numSends = std::min(numSends, std::clamp(*sendsopt, 0u, uint{MaxSendCount})); device->NumAuxSends = numSends; TRACE("Max sources: {} ({} + {}), effect slots: {}, sends: {}", device->SourcesMax, device->NumMonoSources, device->NumStereoSources, device->AuxiliaryEffectSlotMax, device->NumAuxSends); switch(device->FmtChans) { case DevFmtMono: break; case DevFmtStereo: if(!device->mUhjEncoder) device->RealOut.RemixMap = StereoDownmix; break; case DevFmtQuad: device->RealOut.RemixMap = QuadDownmix; break; case DevFmtX51: device->RealOut.RemixMap = X51Downmix; break; case DevFmtX61: device->RealOut.RemixMap = X61Downmix; break; case DevFmtX71: device->RealOut.RemixMap = X71Downmix; break; case DevFmtX714: device->RealOut.RemixMap = X71Downmix; break; case DevFmtX7144: device->RealOut.RemixMap = X71Downmix; break; case DevFmtX3D71: device->RealOut.RemixMap = X51Downmix; break; case DevFmtAmbi3D: break; } size_t sample_delay{0}; if(auto *encoder{device->mUhjEncoder.get()}) sample_delay += encoder->getDelay(); if(device->getConfigValueBool({}, "dither"sv, true)) { int depth{device->configValue({}, "dither-depth"sv).value_or(0)}; if(depth <= 0) { switch(device->FmtType) { case DevFmtByte: case DevFmtUByte: depth = 8; break; case DevFmtShort: case DevFmtUShort: depth = 16; break; case DevFmtInt: case DevFmtUInt: case DevFmtFloat: break; } } if(depth > 0) { depth = std::clamp(depth, 2, 24); device->DitherDepth = std::pow(2.0f, static_cast(depth-1)); } } if(!(device->DitherDepth > 0.0f)) TRACE("Dithering disabled"); else TRACE("Dithering enabled ({}-bit, {:g})", float2int(std::log2(device->DitherDepth)+0.5f)+1, device->DitherDepth); if(!optlimit) optlimit = device->configValue({}, "output-limiter"); /* If the gain limiter is unset, use the limiter for integer-based output * (where samples must be clamped), and don't for floating-point (which can * take unclamped samples). */ if(!optlimit) { switch(device->FmtType) { case DevFmtByte: case DevFmtUByte: case DevFmtShort: case DevFmtUShort: case DevFmtInt: case DevFmtUInt: optlimit = true; break; case DevFmtFloat: break; } } if(!optlimit.value_or(false)) TRACE("Output limiter disabled"); else { float thrshld{1.0f}; switch(device->FmtType) { case DevFmtByte: case DevFmtUByte: thrshld = 127.0f / 128.0f; break; case DevFmtShort: case DevFmtUShort: thrshld = 32767.0f / 32768.0f; break; case DevFmtInt: case DevFmtUInt: case DevFmtFloat: break; } if(device->DitherDepth > 0.0f) thrshld -= 1.0f / device->DitherDepth; const float thrshld_dB{std::log10(thrshld) * 20.0f}; auto limiter = CreateDeviceLimiter(device, thrshld_dB); sample_delay += limiter->getLookAhead(); device->Limiter = std::move(limiter); TRACE("Output limiter enabled, {:.4f}dB limit", thrshld_dB); } /* Convert the sample delay from samples to nanosamples to nanoseconds. */ sample_delay = std::min(sample_delay, std::numeric_limits::max()); device->FixedLatency += nanoseconds{seconds{sample_delay}} / device->mSampleRate; TRACE("Fixed device latency: {}ns", device->FixedLatency.count()); FPUCtl mixer_mode{}; auto reset_context = [device](ContextBase *ctxbase) { auto *context = dynamic_cast(ctxbase); assert(context != nullptr); if(!context) return; std::unique_lock proplock{context->mPropLock}; std::unique_lock slotlock{context->mEffectSlotLock}; /* Clear out unused effect slot clusters. */ auto slot_cluster_not_in_use = [](ContextBase::EffectSlotCluster &clusterptr) -> bool { return std::none_of(clusterptr->begin(), clusterptr->end(), std::mem_fn(&EffectSlot::InUse)); }; auto slotcluster_end = std::remove_if(context->mEffectSlotClusters.begin(), context->mEffectSlotClusters.end(), slot_cluster_not_in_use); context->mEffectSlotClusters.erase(slotcluster_end, context->mEffectSlotClusters.end()); /* Free all wet buffers. Any in use will be reallocated with an updated * configuration in aluInitEffectPanning. */ auto clear_wetbuffers = [](ContextBase::EffectSlotCluster &clusterptr) { auto clear_buffer = [](EffectSlot &slot) { slot.mWetBuffer.clear(); slot.mWetBuffer.shrink_to_fit(); slot.Wet.Buffer = {}; }; std::for_each(clusterptr->begin(), clusterptr->end(), clear_buffer); }; std::for_each(context->mEffectSlotClusters.begin(), context->mEffectSlotClusters.end(), clear_wetbuffers); if(ALeffectslot *slot{context->mDefaultSlot.get()}) { auto *slotbase = slot->mSlot; aluInitEffectPanning(slotbase, context); if(auto *props = slotbase->Update.exchange(nullptr, std::memory_order_relaxed)) AtomicReplaceHead(context->mFreeEffectSlotProps, props); EffectState *state{slot->Effect.State.get()}; state->mOutTarget = device->Dry.Buffer; state->deviceUpdate(device, slot->Buffer); slot->mPropsDirty = true; } if(EffectSlotArray *curarray{context->mActiveAuxSlots.load(std::memory_order_relaxed)}) std::fill(curarray->begin()+ptrdiff_t(curarray->size()>>1), curarray->end(), nullptr); auto reset_slots = [device,context](EffectSlotSubList &sublist) { uint64_t usemask{~sublist.FreeMask}; while(usemask) { const auto idx = static_cast(al::countr_zero(usemask)); auto &slot = (*sublist.EffectSlots)[idx]; usemask &= ~(1_u64 << idx); auto *slotbase = slot.mSlot; aluInitEffectPanning(slotbase, context); if(auto *props = slotbase->Update.exchange(nullptr, std::memory_order_relaxed)) AtomicReplaceHead(context->mFreeEffectSlotProps, props); EffectState *state{slot.Effect.State.get()}; state->mOutTarget = device->Dry.Buffer; state->deviceUpdate(device, slot.Buffer); slot.mPropsDirty = true; } }; std::for_each(context->mEffectSlotList.begin(), context->mEffectSlotList.end(), reset_slots); /* Clear all effect slot props to let them get allocated again. */ context->mEffectSlotPropClusters.clear(); context->mFreeEffectSlotProps.store(nullptr, std::memory_order_relaxed); slotlock.unlock(); std::unique_lock srclock{context->mSourceLock}; const uint num_sends{device->NumAuxSends}; auto reset_sources = [num_sends](SourceSubList &sublist) { uint64_t usemask{~sublist.FreeMask}; while(usemask) { const auto idx = static_cast(al::countr_zero(usemask)); auto &source = (*sublist.Sources)[idx]; usemask &= ~(1_u64 << idx); auto clear_send = [](ALsource::SendData &send) -> void { if(send.Slot) DecrementRef(send.Slot->ref); send.Slot = nullptr; send.Gain = 1.0f; send.GainHF = 1.0f; send.HFReference = LowPassFreqRef; send.GainLF = 1.0f; send.LFReference = HighPassFreqRef; }; const auto sends = al::span{source.Send}.subspan(num_sends); std::for_each(sends.begin(), sends.end(), clear_send); source.mPropsDirty = true; } }; std::for_each(context->mSourceList.begin(), context->mSourceList.end(), reset_sources); auto reset_voice = [device,num_sends,context](Voice *voice) { /* Clear extraneous property set sends. */ const auto sendparams = al::span{voice->mProps.Send}.subspan(num_sends); std::fill(sendparams.begin(), sendparams.end(), VoiceProps::SendData{}); std::fill(voice->mSend.begin()+num_sends, voice->mSend.end(), Voice::TargetData{}); auto clear_wetparams = [num_sends](Voice::ChannelData &chandata) { const auto wetparams = al::span{chandata.mWetParams}.subspan(num_sends); std::fill(wetparams.begin(), wetparams.end(), SendParams{}); }; std::for_each(voice->mChans.begin(), voice->mChans.end(), clear_wetparams); if(VoicePropsItem *props{voice->mUpdate.exchange(nullptr, std::memory_order_relaxed)}) AtomicReplaceHead(context->mFreeVoiceProps, props); /* Force the voice to stopped if it was stopping. */ Voice::State vstate{Voice::Stopping}; voice->mPlayState.compare_exchange_strong(vstate, Voice::Stopped, std::memory_order_acquire, std::memory_order_acquire); if(voice->mSourceID.load(std::memory_order_relaxed) == 0u) return; voice->prepare(device); }; const auto voicespan = context->getVoicesSpan(); std::for_each(voicespan.begin(), voicespan.end(), reset_voice); /* Clear all voice props to let them get allocated again. */ context->mVoicePropClusters.clear(); context->mFreeVoiceProps.store(nullptr, std::memory_order_relaxed); srclock.unlock(); context->mPropsDirty = false; UpdateContextProps(context); UpdateAllEffectSlotProps(context); UpdateAllSourceProps(context); }; auto ctxspan = al::span{*device->mContexts.load()}; std::for_each(ctxspan.begin(), ctxspan.end(), reset_context); mixer_mode.leave(); device->mDeviceState = DeviceState::Configured; if(!device->Flags.test(DevicePaused)) { try { auto backend = device->Backend.get(); backend->start(); device->mDeviceState = DeviceState::Playing; } catch(al::backend_exception& e) { ERR("{}", e.what()); device->handleDisconnect("{}", e.what()); return ALC_INVALID_DEVICE; } TRACE("Post-start: {}, {}, {}hz, {} / {} buffer", DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType), device->mSampleRate, device->mUpdateSize, device->mBufferSize); } return ALC_NO_ERROR; } /** * Updates device parameters as above, and also first clears the disconnected * status, if set. */ auto ResetDeviceParams(al::Device *device, const al::span attrList) -> bool { /* If the device was disconnected, reset it since we're opened anew. */ if(!device->Connected.load(std::memory_order_relaxed)) UNLIKELY { /* Make sure disconnection is finished before continuing on. */ std::ignore = device->waitForMix(); for(ContextBase *ctxbase : *device->mContexts.load(std::memory_order_acquire)) { auto *ctx = dynamic_cast(ctxbase); assert(ctx != nullptr); if(!ctx || !ctx->mStopVoicesOnDisconnect.load(std::memory_order_acquire)) continue; /* Clear any pending voice changes and reallocate voices to get a * clean restart. */ std::lock_guard sourcelock{ctx->mSourceLock}; auto *vchg = ctx->mCurrentVoiceChange.load(std::memory_order_acquire); while(auto *next = vchg->mNext.load(std::memory_order_acquire)) vchg = next; ctx->mCurrentVoiceChange.store(vchg, std::memory_order_release); ctx->mVoicePropClusters.clear(); ctx->mFreeVoiceProps.store(nullptr, std::memory_order_relaxed); ctx->mVoiceClusters.clear(); ctx->allocVoices(std::max(256, ctx->mActiveVoiceCount.load(std::memory_order_relaxed))); } device->Connected.store(true); } ALCenum err{UpdateDeviceParams(device, attrList)}; if(err == ALC_NO_ERROR) LIKELY return ALC_TRUE; alcSetError(device, err); return ALC_FALSE; } /** Checks if the device handle is valid, and returns a new reference if so. */ DeviceRef VerifyDevice(ALCdevice *device) { std::lock_guard listlock{ListLock}; auto iter = std::lower_bound(DeviceList.begin(), DeviceList.end(), device); if(iter != DeviceList.end() && *iter == device) { (*iter)->add_ref(); return DeviceRef{*iter}; } return nullptr; } /** * Checks if the given context is valid, returning a new reference to it if so. */ ContextRef VerifyContext(ALCcontext *context) { std::lock_guard listlock{ListLock}; auto iter = std::lower_bound(ContextList.begin(), ContextList.end(), context); if(iter != ContextList.end() && *iter == context) { (*iter)->add_ref(); return ContextRef{*iter}; } return nullptr; } } // namespace FORCE_ALIGN void ALC_APIENTRY alsoft_set_log_callback(LPALSOFTLOGCALLBACK callback, void *userptr) noexcept { al_set_log_callback(callback, userptr); } /** Returns a new reference to the currently active context for this thread. */ ContextRef GetContextRef() noexcept { ALCcontext *context{ALCcontext::getThreadContext()}; if(context) context->add_ref(); else { while(ALCcontext::sGlobalContextLock.exchange(true, std::memory_order_acquire)) { /* Wait to make sure another thread isn't trying to change the * current context and bring its refcount to 0. */ } context = ALCcontext::sGlobalContext.load(std::memory_order_acquire); if(context) LIKELY context->add_ref(); ALCcontext::sGlobalContextLock.store(false, std::memory_order_release); } return ContextRef{context}; } void alcSetError(al::Device *device, ALCenum errorCode) { WARN("Error generated on device {}, code {:#04x}", voidp{device}, as_unsigned(errorCode)); if(TrapALCError) { #ifdef _WIN32 /* DebugBreak() will cause an exception if there is no debugger */ if(IsDebuggerPresent()) DebugBreak(); #elif defined(SIGTRAP) raise(SIGTRAP); #endif } if(device) device->LastError.store(errorCode); else LastNullDeviceError.store(errorCode); } /************************************************ * Standard ALC functions ************************************************/ ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device) noexcept { if(!gProcessRunning) return ALC_INVALID_DEVICE; DeviceRef dev{VerifyDevice(device)}; if(dev) return dev->LastError.exchange(ALC_NO_ERROR); return LastNullDeviceError.exchange(ALC_NO_ERROR); } ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context) noexcept { ContextRef ctx{VerifyContext(context)}; if(!ctx) { alcSetError(nullptr, ALC_INVALID_CONTEXT); return; } if(ctx->mContextFlags.test(ContextFlags::DebugBit)) UNLIKELY ctx->debugMessage(DebugSource::API, DebugType::Portability, 0, DebugSeverity::Medium, "alcSuspendContext behavior is not portable -- some implementations suspend all " "rendering, some only defer property changes, and some are completely no-op; consider " "using alcDevicePauseSOFT to suspend all rendering, or alDeferUpdatesSOFT to only " "defer property changes"); if(SuspendDefers) { std::lock_guard proplock{ctx->mPropLock}; ctx->deferUpdates(); } } ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context) noexcept { ContextRef ctx{VerifyContext(context)}; if(!ctx) { alcSetError(nullptr, ALC_INVALID_CONTEXT); return; } if(ctx->mContextFlags.test(ContextFlags::DebugBit)) UNLIKELY ctx->debugMessage(DebugSource::API, DebugType::Portability, 1, DebugSeverity::Medium, "alcProcessContext behavior is not portable -- some implementations resume rendering, " "some apply deferred property changes, and some are completely no-op; consider using " "alcDeviceResumeSOFT to resume rendering, or alProcessUpdatesSOFT to apply deferred " "property changes"); if(SuspendDefers) { std::lock_guard proplock{ctx->mPropLock}; ctx->processUpdates(); } } ALC_API auto ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param) noexcept -> const ALCchar* { switch(param) { case ALC_NO_ERROR: return GetNoErrorString(); case ALC_INVALID_ENUM: return GetInvalidEnumString(); case ALC_INVALID_VALUE: return GetInvalidValueString(); case ALC_INVALID_DEVICE: return GetInvalidDeviceString(); case ALC_INVALID_CONTEXT: return GetInvalidContextString(); case ALC_OUT_OF_MEMORY: return GetOutOfMemoryString(); case ALC_DEVICE_SPECIFIER: return GetDefaultName(); case ALC_ALL_DEVICES_SPECIFIER: if(DeviceRef dev{VerifyDevice(Device)}) { if(dev->Type == DeviceType::Capture) { alcSetError(dev.get(), ALC_INVALID_ENUM); return nullptr; } if(dev->Type == DeviceType::Loopback) return GetDefaultName(); auto statelock = std::lock_guard{dev->StateLock}; return dev->mDeviceName.c_str(); } ProbeAllDevicesList(); return alcAllDevicesList.c_str(); case ALC_CAPTURE_DEVICE_SPECIFIER: if(DeviceRef dev{VerifyDevice(Device)}) { if(dev->Type != DeviceType::Capture) { alcSetError(dev.get(), ALC_INVALID_ENUM); return nullptr; } auto statelock = std::lock_guard{dev->StateLock}; return dev->mDeviceName.c_str(); } ProbeCaptureDeviceList(); return alcCaptureDeviceList.c_str(); /* Default devices are always first in the list */ case ALC_DEFAULT_DEVICE_SPECIFIER: return GetDefaultName(); case ALC_DEFAULT_ALL_DEVICES_SPECIFIER: if(alcAllDevicesList.empty()) ProbeAllDevicesList(); /* Copy first entry as default. */ if(!alcAllDevicesArray.empty()) alcDefaultAllDevicesSpecifier = alcAllDevicesArray.front(); else alcDefaultAllDevicesSpecifier.clear(); return alcDefaultAllDevicesSpecifier.c_str(); case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER: if(alcCaptureDeviceList.empty()) ProbeCaptureDeviceList(); /* Copy first entry as default. */ if(!alcCaptureDeviceArray.empty()) alcCaptureDefaultDeviceSpecifier = alcCaptureDeviceArray.front(); else alcCaptureDefaultDeviceSpecifier.clear(); return alcCaptureDefaultDeviceSpecifier.c_str(); case ALC_EXTENSIONS: if(VerifyDevice(Device)) return GetExtensionList(); return GetNoDeviceExtList(); case ALC_HRTF_SPECIFIER_SOFT: if(DeviceRef dev{VerifyDevice(Device)}) { std::lock_guard statelock{dev->StateLock}; return dev->mHrtf ? dev->mHrtfName.c_str() : ""; } alcSetError(nullptr, ALC_INVALID_DEVICE); return nullptr; default: alcSetError(VerifyDevice(Device).get(), ALC_INVALID_ENUM); } return nullptr; } namespace { auto GetIntegerv(al::Device *device, ALCenum param, const al::span values) -> size_t { if(values.empty()) { alcSetError(device, ALC_INVALID_VALUE); return 0; } if(!device) { switch(param) { case ALC_MAJOR_VERSION: values[0] = alcMajorVersion; return 1; case ALC_MINOR_VERSION: values[0] = alcMinorVersion; return 1; case ALC_EFX_MAJOR_VERSION: values[0] = alcEFXMajorVersion; return 1; case ALC_EFX_MINOR_VERSION: values[0] = alcEFXMinorVersion; return 1; case ALC_MAX_AUXILIARY_SENDS: values[0] = MaxSendCount; return 1; case ALC_ATTRIBUTES_SIZE: case ALC_ALL_ATTRIBUTES: case ALC_FREQUENCY: case ALC_REFRESH: case ALC_SYNC: case ALC_MONO_SOURCES: case ALC_STEREO_SOURCES: case ALC_CAPTURE_SAMPLES: case ALC_FORMAT_CHANNELS_SOFT: case ALC_FORMAT_TYPE_SOFT: case ALC_AMBISONIC_LAYOUT_SOFT: case ALC_AMBISONIC_SCALING_SOFT: case ALC_AMBISONIC_ORDER_SOFT: case ALC_MAX_AMBISONIC_ORDER_SOFT: alcSetError(nullptr, ALC_INVALID_DEVICE); return 0; default: alcSetError(nullptr, ALC_INVALID_ENUM); } return 0; } std::lock_guard statelock{device->StateLock}; if(device->Type == DeviceType::Capture) { static constexpr int MaxCaptureAttributes{9}; switch(param) { case ALC_ATTRIBUTES_SIZE: values[0] = MaxCaptureAttributes; return 1; case ALC_ALL_ATTRIBUTES: if(values.size() >= MaxCaptureAttributes) { size_t i{0}; values[i++] = ALC_MAJOR_VERSION; values[i++] = alcMajorVersion; values[i++] = ALC_MINOR_VERSION; values[i++] = alcMinorVersion; values[i++] = ALC_CAPTURE_SAMPLES; values[i++] = static_cast(device->Backend->availableSamples()); values[i++] = ALC_CONNECTED; values[i++] = device->Connected.load(std::memory_order_relaxed); values[i++] = 0; assert(i == MaxCaptureAttributes); return i; } alcSetError(device, ALC_INVALID_VALUE); return 0; case ALC_MAJOR_VERSION: values[0] = alcMajorVersion; return 1; case ALC_MINOR_VERSION: values[0] = alcMinorVersion; return 1; case ALC_CAPTURE_SAMPLES: values[0] = static_cast(device->Backend->availableSamples()); return 1; case ALC_CONNECTED: values[0] = device->Connected.load(std::memory_order_acquire); return 1; default: alcSetError(device, ALC_INVALID_ENUM); } return 0; } /* render device */ auto NumAttrsForDevice = [device]() noexcept -> uint8_t { if(device->Type == DeviceType::Loopback && device->FmtChans == DevFmtAmbi3D) return 37; return 31; }; switch(param) { case ALC_ATTRIBUTES_SIZE: values[0] = NumAttrsForDevice(); return 1; case ALC_ALL_ATTRIBUTES: if(values.size() >= NumAttrsForDevice()) { size_t i{0}; values[i++] = ALC_MAJOR_VERSION; values[i++] = alcMajorVersion; values[i++] = ALC_MINOR_VERSION; values[i++] = alcMinorVersion; values[i++] = ALC_EFX_MAJOR_VERSION; values[i++] = alcEFXMajorVersion; values[i++] = ALC_EFX_MINOR_VERSION; values[i++] = alcEFXMinorVersion; values[i++] = ALC_FREQUENCY; values[i++] = static_cast(device->mSampleRate); if(device->Type != DeviceType::Loopback) { values[i++] = ALC_REFRESH; values[i++] = static_cast(device->mSampleRate / device->mUpdateSize); values[i++] = ALC_SYNC; values[i++] = ALC_FALSE; } else { if(device->FmtChans == DevFmtAmbi3D) { values[i++] = ALC_AMBISONIC_LAYOUT_SOFT; values[i++] = EnumFromDevAmbi(device->mAmbiLayout); values[i++] = ALC_AMBISONIC_SCALING_SOFT; values[i++] = EnumFromDevAmbi(device->mAmbiScale); values[i++] = ALC_AMBISONIC_ORDER_SOFT; values[i++] = static_cast(device->mAmbiOrder); } values[i++] = ALC_FORMAT_CHANNELS_SOFT; values[i++] = EnumFromDevFmt(device->FmtChans); values[i++] = ALC_FORMAT_TYPE_SOFT; values[i++] = EnumFromDevFmt(device->FmtType); } values[i++] = ALC_MONO_SOURCES; values[i++] = static_cast(device->NumMonoSources); values[i++] = ALC_STEREO_SOURCES; values[i++] = static_cast(device->NumStereoSources); values[i++] = ALC_MAX_AUXILIARY_SENDS; values[i++] = static_cast(device->NumAuxSends); values[i++] = ALC_HRTF_SOFT; values[i++] = (device->mHrtf ? ALC_TRUE : ALC_FALSE); values[i++] = ALC_HRTF_STATUS_SOFT; values[i++] = device->mHrtfStatus; values[i++] = ALC_OUTPUT_LIMITER_SOFT; values[i++] = device->Limiter ? ALC_TRUE : ALC_FALSE; values[i++] = ALC_MAX_AMBISONIC_ORDER_SOFT; values[i++] = MaxAmbiOrder; values[i++] = ALC_OUTPUT_MODE_SOFT; values[i++] = static_cast(device->getOutputMode1()); values[i++] = 0; assert(i == NumAttrsForDevice()); return i; } alcSetError(device, ALC_INVALID_VALUE); return 0; case ALC_MAJOR_VERSION: values[0] = alcMajorVersion; return 1; case ALC_MINOR_VERSION: values[0] = alcMinorVersion; return 1; case ALC_EFX_MAJOR_VERSION: values[0] = alcEFXMajorVersion; return 1; case ALC_EFX_MINOR_VERSION: values[0] = alcEFXMinorVersion; return 1; case ALC_FREQUENCY: values[0] = static_cast(device->mSampleRate); return 1; case ALC_REFRESH: if(device->Type == DeviceType::Loopback) { alcSetError(device, ALC_INVALID_DEVICE); return 0; } values[0] = static_cast(device->mSampleRate / device->mUpdateSize); return 1; case ALC_SYNC: if(device->Type == DeviceType::Loopback) { alcSetError(device, ALC_INVALID_DEVICE); return 0; } values[0] = ALC_FALSE; return 1; case ALC_FORMAT_CHANNELS_SOFT: if(device->Type != DeviceType::Loopback) { alcSetError(device, ALC_INVALID_DEVICE); return 0; } values[0] = EnumFromDevFmt(device->FmtChans); return 1; case ALC_FORMAT_TYPE_SOFT: if(device->Type != DeviceType::Loopback) { alcSetError(device, ALC_INVALID_DEVICE); return 0; } values[0] = EnumFromDevFmt(device->FmtType); return 1; case ALC_AMBISONIC_LAYOUT_SOFT: if(device->Type != DeviceType::Loopback || device->FmtChans != DevFmtAmbi3D) { alcSetError(device, ALC_INVALID_DEVICE); return 0; } values[0] = EnumFromDevAmbi(device->mAmbiLayout); return 1; case ALC_AMBISONIC_SCALING_SOFT: if(device->Type != DeviceType::Loopback || device->FmtChans != DevFmtAmbi3D) { alcSetError(device, ALC_INVALID_DEVICE); return 0; } values[0] = EnumFromDevAmbi(device->mAmbiScale); return 1; case ALC_AMBISONIC_ORDER_SOFT: if(device->Type != DeviceType::Loopback || device->FmtChans != DevFmtAmbi3D) { alcSetError(device, ALC_INVALID_DEVICE); return 0; } values[0] = static_cast(device->mAmbiOrder); return 1; case ALC_MONO_SOURCES: values[0] = static_cast(device->NumMonoSources); return 1; case ALC_STEREO_SOURCES: values[0] = static_cast(device->NumStereoSources); return 1; case ALC_MAX_AUXILIARY_SENDS: values[0] = static_cast(device->NumAuxSends); return 1; case ALC_CONNECTED: values[0] = device->Connected.load(std::memory_order_acquire); return 1; case ALC_HRTF_SOFT: values[0] = (device->mHrtf ? ALC_TRUE : ALC_FALSE); return 1; case ALC_HRTF_STATUS_SOFT: values[0] = device->mHrtfStatus; return 1; case ALC_NUM_HRTF_SPECIFIERS_SOFT: device->enumerateHrtfs(); values[0] = static_cast(std::min(device->mHrtfList.size(), size_t{std::numeric_limits::max()})); return 1; case ALC_OUTPUT_LIMITER_SOFT: values[0] = device->Limiter ? ALC_TRUE : ALC_FALSE; return 1; case ALC_MAX_AMBISONIC_ORDER_SOFT: values[0] = MaxAmbiOrder; return 1; case ALC_OUTPUT_MODE_SOFT: values[0] = static_cast(device->getOutputMode1()); return 1; default: alcSetError(device, ALC_INVALID_ENUM); } return 0; } } // namespace ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values) noexcept { DeviceRef dev{VerifyDevice(device)}; if(size <= 0 || values == nullptr) alcSetError(dev.get(), ALC_INVALID_VALUE); else GetIntegerv(dev.get(), param, {values, static_cast(size)}); } ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALCsizei size, ALCint64SOFT *values) noexcept { DeviceRef dev{VerifyDevice(device)}; if(size <= 0 || values == nullptr) { alcSetError(dev.get(), ALC_INVALID_VALUE); return; } const auto valuespan = al::span{values, static_cast(size)}; if(!dev || dev->Type == DeviceType::Capture) { auto ivals = std::vector(valuespan.size()); if(size_t got{GetIntegerv(dev.get(), pname, ivals)}) std::copy_n(ivals.cbegin(), got, valuespan.begin()); return; } /* render device */ auto NumAttrsForDevice = [](al::Device *aldev) noexcept -> size_t { if(aldev->Type == DeviceType::Loopback && aldev->FmtChans == DevFmtAmbi3D) return 41; return 35; }; std::lock_guard statelock{dev->StateLock}; switch(pname) { case ALC_ATTRIBUTES_SIZE: valuespan[0] = static_cast(NumAttrsForDevice(dev.get())); break; case ALC_ALL_ATTRIBUTES: if(valuespan.size() < NumAttrsForDevice(dev.get())) alcSetError(dev.get(), ALC_INVALID_VALUE); else { size_t i{0}; valuespan[i++] = ALC_FREQUENCY; valuespan[i++] = dev->mSampleRate; if(dev->Type != DeviceType::Loopback) { valuespan[i++] = ALC_REFRESH; valuespan[i++] = dev->mSampleRate / dev->mUpdateSize; valuespan[i++] = ALC_SYNC; valuespan[i++] = ALC_FALSE; } else { valuespan[i++] = ALC_FORMAT_CHANNELS_SOFT; valuespan[i++] = EnumFromDevFmt(dev->FmtChans); valuespan[i++] = ALC_FORMAT_TYPE_SOFT; valuespan[i++] = EnumFromDevFmt(dev->FmtType); if(dev->FmtChans == DevFmtAmbi3D) { valuespan[i++] = ALC_AMBISONIC_LAYOUT_SOFT; valuespan[i++] = EnumFromDevAmbi(dev->mAmbiLayout); valuespan[i++] = ALC_AMBISONIC_SCALING_SOFT; valuespan[i++] = EnumFromDevAmbi(dev->mAmbiScale); valuespan[i++] = ALC_AMBISONIC_ORDER_SOFT; valuespan[i++] = dev->mAmbiOrder; } } valuespan[i++] = ALC_MONO_SOURCES; valuespan[i++] = dev->NumMonoSources; valuespan[i++] = ALC_STEREO_SOURCES; valuespan[i++] = dev->NumStereoSources; valuespan[i++] = ALC_MAX_AUXILIARY_SENDS; valuespan[i++] = dev->NumAuxSends; valuespan[i++] = ALC_HRTF_SOFT; valuespan[i++] = (dev->mHrtf ? ALC_TRUE : ALC_FALSE); valuespan[i++] = ALC_HRTF_STATUS_SOFT; valuespan[i++] = dev->mHrtfStatus; valuespan[i++] = ALC_OUTPUT_LIMITER_SOFT; valuespan[i++] = dev->Limiter ? ALC_TRUE : ALC_FALSE; ClockLatency clock{GetClockLatency(dev.get(), dev->Backend.get())}; valuespan[i++] = ALC_DEVICE_CLOCK_SOFT; valuespan[i++] = clock.ClockTime.count(); valuespan[i++] = ALC_DEVICE_LATENCY_SOFT; valuespan[i++] = clock.Latency.count(); valuespan[i++] = ALC_OUTPUT_MODE_SOFT; valuespan[i++] = al::to_underlying(dev->getOutputMode1()); valuespan[i++] = 0; } break; case ALC_DEVICE_CLOCK_SOFT: { uint samplecount, refcount; seconds clocksec; nanoseconds clocknsec; do { refcount = dev->waitForMix(); samplecount = dev->mSamplesDone.load(std::memory_order_relaxed); clocksec = dev->mClockBaseSec.load(std::memory_order_relaxed); clocknsec = dev->mClockBaseNSec.load(std::memory_order_relaxed); std::atomic_thread_fence(std::memory_order_acquire); } while(refcount != dev->mMixCount.load(std::memory_order_relaxed)); valuespan[0] = nanoseconds{clocksec + nanoseconds{clocknsec} + nanoseconds{seconds{samplecount}}/dev->mSampleRate}.count(); } break; case ALC_DEVICE_LATENCY_SOFT: valuespan[0] = GetClockLatency(dev.get(), dev->Backend.get()).Latency.count(); break; case ALC_DEVICE_CLOCK_LATENCY_SOFT: if(size < 2) alcSetError(dev.get(), ALC_INVALID_VALUE); else { ClockLatency clock{GetClockLatency(dev.get(), dev->Backend.get())}; valuespan[0] = clock.ClockTime.count(); valuespan[1] = clock.Latency.count(); } break; default: auto ivals = std::vector(valuespan.size()); if(size_t got{GetIntegerv(dev.get(), pname, ivals)}) std::copy_n(ivals.cbegin(), got, valuespan.begin()); break; } } ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!extName) { alcSetError(dev.get(), ALC_INVALID_VALUE); return ALC_FALSE; } const std::string_view tofind{extName}; const auto extlist = dev ? std::string_view{GetExtensionList()} : std::string_view{GetNoDeviceExtList()}; auto matchpos = extlist.find(tofind); while(matchpos != std::string_view::npos) { const auto endpos = matchpos + tofind.size(); if((matchpos == 0 || std::isspace(extlist[matchpos-1])) && (endpos == extlist.size() || std::isspace(extlist[endpos]))) return ALC_TRUE; matchpos = extlist.find(tofind, matchpos+1); } return ALC_FALSE; } ALCvoid* ALC_APIENTRY alcGetProcAddress2(ALCdevice *device, const ALCchar *funcName) noexcept { return alcGetProcAddress(device, funcName); } ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName) noexcept { if(!funcName) { DeviceRef dev{VerifyDevice(device)}; alcSetError(dev.get(), ALC_INVALID_VALUE); return nullptr; } #if ALSOFT_EAX if(eax_g_is_enabled) { for(const auto &func : eaxFunctions) { if(strcmp(func.funcName, funcName) == 0) return func.address; } } #endif for(const auto &func : alcFunctions) { if(strcmp(func.funcName, funcName) == 0) return func.address; } return nullptr; } ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName) noexcept { if(!enumName) { DeviceRef dev{VerifyDevice(device)}; alcSetError(dev.get(), ALC_INVALID_VALUE); return 0; } #if ALSOFT_EAX if(eax_g_is_enabled) { for(const auto &enm : eaxEnumerations) { if(strcmp(enm.enumName, enumName) == 0) return enm.value; } } #endif for(const auto &enm : alcEnumerations) { if(strcmp(enm.enumName, enumName) == 0) return enm.value; } return 0; } ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList) noexcept { /* Explicitly hold the list lock while taking the StateLock in case the * device is asynchronously destroyed, to ensure this new context is * properly cleaned up after being made. */ std::unique_lock listlock{ListLock}; DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type == DeviceType::Capture || !dev->Connected.load(std::memory_order_relaxed)) { listlock.unlock(); alcSetError(dev.get(), ALC_INVALID_DEVICE); return nullptr; } std::unique_lock statelock{dev->StateLock}; listlock.unlock(); dev->LastError.store(ALC_NO_ERROR); const auto attrSpan = SpanFromAttributeList(attrList); ALCenum err{UpdateDeviceParams(dev.get(), attrSpan)}; if(err != ALC_NO_ERROR) { alcSetError(dev.get(), err); return nullptr; } ContextFlagBitset ctxflags{0}; for(size_t i{0};i < attrSpan.size();i+=2) { if(attrSpan[i] == ALC_CONTEXT_FLAGS_EXT) { ctxflags = static_cast(attrSpan[i+1]); break; } } auto context = ContextRef{new(std::nothrow) ALCcontext{dev, ctxflags}}; if(!context) { alcSetError(dev.get(), ALC_OUT_OF_MEMORY); return nullptr; } context->init(); if(auto volopt = dev->configValue({}, "volume-adjust")) { const float valf{*volopt}; if(!std::isfinite(valf)) ERR("volume-adjust must be finite: {:f}", valf); else { const float db{std::clamp(valf, -24.0f, 24.0f)}; if(db != valf) WARN("volume-adjust clamped: {:f}, range: +/-24", valf); context->mGainBoost = std::pow(10.0f, db/20.0f); TRACE("volume-adjust gain: {:f}", context->mGainBoost); } } { using ContextArray = al::FlexArray; /* Allocate a new context array, which holds 1 more than the current/ * old array. */ auto *oldarray = dev->mContexts.load(); auto newarray = ContextArray::Create(oldarray->size() + 1); /* Copy the current/old context handles to the new array, appending the * new context. */ auto iter = std::copy(oldarray->begin(), oldarray->end(), newarray->begin()); *iter = context.get(); /* Store the new context array in the device. Wait for any current mix * to finish before deleting the old array. */ auto prevarray = dev->mContexts.exchange(std::move(newarray)); std::ignore = dev->waitForMix(); } statelock.unlock(); { listlock.lock(); auto iter = std::lower_bound(ContextList.cbegin(), ContextList.cend(), context.get()); ContextList.emplace(iter, context.get()); listlock.unlock(); } if(ALeffectslot *slot{context->mDefaultSlot.get()}) { ALenum sloterr{slot->initEffect(0, ALCcontext::sDefaultEffect.type, ALCcontext::sDefaultEffect.Props, context.get())}; if(sloterr == AL_NO_ERROR) slot->updateProps(context.get()); else ERR("Failed to initialize the default effect"); } TRACE("Created context {}", voidp{context.get()}); return context.release(); } ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context) noexcept { if(!gProcessRunning) return; std::unique_lock listlock{ListLock}; auto iter = std::lower_bound(ContextList.begin(), ContextList.end(), context); if(iter == ContextList.end() || *iter != context) { listlock.unlock(); alcSetError(nullptr, ALC_INVALID_CONTEXT); return; } /* Hold a reference to this context so it remains valid until the ListLock * is released. */ ContextRef ctx{*iter}; ContextList.erase(iter); auto *Device = ctx->mALDevice.get(); std::lock_guard statelock{Device->StateLock}; ctx->deinit(); } ALC_API auto ALC_APIENTRY alcGetCurrentContext() noexcept -> ALCcontext* { ALCcontext *Context{ALCcontext::getThreadContext()}; if(!Context) Context = ALCcontext::sGlobalContext.load(); return Context; } /** Returns the currently active thread-local context. */ ALC_API auto ALC_APIENTRY alcGetThreadContext() noexcept -> ALCcontext* { return ALCcontext::getThreadContext(); } ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context) noexcept { /* context must be valid or nullptr */ ContextRef ctx; if(context) { ctx = VerifyContext(context); if(!ctx) { alcSetError(nullptr, ALC_INVALID_CONTEXT); return ALC_FALSE; } } /* Release this reference (if any) to store it in the GlobalContext * pointer. Take ownership of the reference (if any) that was previously * stored there, and let the reference go. */ while(ALCcontext::sGlobalContextLock.exchange(true, std::memory_order_acquire)) { /* Wait to make sure another thread isn't getting or trying to change * the current context as its refcount is decremented. */ } ctx = ContextRef{ALCcontext::sGlobalContext.exchange(ctx.release())}; ALCcontext::sGlobalContextLock.store(false, std::memory_order_release); /* Take ownership of the thread-local context reference (if any), clearing * the storage to null. */ ctx = ContextRef{ALCcontext::getThreadContext()}; if(ctx) ALCcontext::setThreadContext(nullptr); /* Reset (decrement) the previous thread-local reference. */ return ALC_TRUE; } /** Makes the given context the active context for the current thread. */ ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context) noexcept { /* context must be valid or nullptr */ ContextRef ctx; if(context) { ctx = VerifyContext(context); if(!ctx) { alcSetError(nullptr, ALC_INVALID_CONTEXT); return ALC_FALSE; } } /* context's reference count is already incremented */ ContextRef old{ALCcontext::getThreadContext()}; ALCcontext::setThreadContext(ctx.release()); return ALC_TRUE; } ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context) noexcept { ContextRef ctx{VerifyContext(Context)}; if(!ctx) { alcSetError(nullptr, ALC_INVALID_CONTEXT); return nullptr; } return ctx->mALDevice.get(); } ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName) noexcept { InitConfig(); if(!PlaybackFactory) { alcSetError(nullptr, ALC_INVALID_VALUE); return nullptr; } std::string_view devname{deviceName ? deviceName : ""}; if(!devname.empty()) { TRACE("Opening playback device \"{}\"", devname); if(al::case_compare(devname, GetDefaultName()) == 0 #ifdef _WIN32 /* Some old Windows apps hardcode these expecting OpenAL to use a * specific audio API, even when they're not enumerated. Creative's * router effectively ignores them too. */ || al::case_compare(devname, "DirectSound3D"sv) == 0 || al::case_compare(devname, "DirectSound"sv) == 0 || al::case_compare(devname, "MMSYSTEM"sv) == 0 #endif /* Some old Linux apps hardcode configuration strings that were * supported by the OpenAL SI. We can't really do anything useful * with them, so just ignore. */ || al::starts_with(devname, "'("sv) || al::case_compare(devname, "openal-soft"sv) == 0) devname = {}; else { const auto prefix = GetDevicePrefix(); if(!prefix.empty() && devname.size() > prefix.size() && al::starts_with(devname, prefix)) devname = devname.substr(prefix.size()); } } else TRACE("Opening default playback device"); const uint DefaultSends{ #if ALSOFT_EAX eax_g_is_enabled ? uint{EAX_MAX_FXSLOTS} : #endif // ALSOFT_EAX uint{DefaultSendCount} }; auto device = DeviceRef{new(std::nothrow) al::Device{DeviceType::Playback}}; if(!device) { WARN("Failed to create playback device handle"); alcSetError(nullptr, ALC_OUT_OF_MEMORY); return nullptr; } /* Set output format */ device->FmtChans = DevFmtChannelsDefault; device->FmtType = DevFmtTypeDefault; device->mSampleRate = DefaultOutputRate; device->mUpdateSize = DefaultUpdateSize; device->mBufferSize = DefaultUpdateSize * DefaultNumUpdates; device->SourcesMax = 256; device->NumStereoSources = 1; device->NumMonoSources = device->SourcesMax - device->NumStereoSources; device->AuxiliaryEffectSlotMax = 64; device->NumAuxSends = DefaultSends; try { auto backend = PlaybackFactory->createBackend(device.get(), BackendType::Playback); std::lock_guard listlock{ListLock}; backend->open(devname); device->mDeviceName = std::string{GetDevicePrefix()}+backend->mDeviceName; device->Backend = std::move(backend); } catch(al::backend_exception &e) { WARN("Failed to open playback device: {}", e.what()); alcSetError(nullptr, (e.errorCode() == al::backend_error::OutOfMemory) ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE); return nullptr; } auto checkopt = [&device](const char *envname, const std::string_view optname) { if(auto optval = al::getenv(envname)) return optval; return device->configValue("game_compat", optname); }; if(auto overrideopt = checkopt("__ALSOFT_VENDOR_OVERRIDE", "vendor-override"sv)) { device->mVendorOverride = std::move(*overrideopt); TRACE("Overriding vendor string: \"{}\"", device->mVendorOverride); } if(auto overrideopt = checkopt("__ALSOFT_VERSION_OVERRIDE", "version-override"sv)) { device->mVersionOverride = std::move(*overrideopt); TRACE("Overriding version string: \"{}\"", device->mVersionOverride); } if(auto overrideopt = checkopt("__ALSOFT_RENDERER_OVERRIDE", "renderer-override"sv)) { device->mRendererOverride = std::move(*overrideopt); TRACE("Overriding renderer string: \"{}\"", device->mRendererOverride); } { std::lock_guard listlock{ListLock}; auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get()); DeviceList.emplace(iter, device.get()); } TRACE("Created device {}, \"{}\"", voidp{device.get()}, device->mDeviceName); return device.release(); } ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device) noexcept { if(!gProcessRunning) return ALC_FALSE; std::unique_lock listlock{ListLock}; auto iter = std::lower_bound(DeviceList.begin(), DeviceList.end(), device); if(iter == DeviceList.end() || *iter != device) { alcSetError(nullptr, ALC_INVALID_DEVICE); return ALC_FALSE; } if((*iter)->Type == DeviceType::Capture) { alcSetError(*iter, ALC_INVALID_DEVICE); return ALC_FALSE; } /* Erase the device, and any remaining contexts left on it, from their * respective lists. */ DeviceRef dev{*iter}; DeviceList.erase(iter); std::unique_lock statelock{dev->StateLock}; std::vector orphanctxs; for(ContextBase *ctx : *dev->mContexts.load()) { auto ctxiter = std::lower_bound(ContextList.begin(), ContextList.end(), ctx); if(ctxiter != ContextList.end() && *ctxiter == ctx) { orphanctxs.emplace_back(*ctxiter); ContextList.erase(ctxiter); } } listlock.unlock(); for(ContextRef &context : orphanctxs) { WARN("Releasing orphaned context {}", voidp{context.get()}); context->deinit(); } orphanctxs.clear(); if(dev->mDeviceState == DeviceState::Playing) { dev->Backend->stop(); dev->mDeviceState = DeviceState::Configured; } return ALC_TRUE; } /************************************************ * ALC capture functions ************************************************/ ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples) noexcept { InitConfig(); if(!CaptureFactory) { alcSetError(nullptr, ALC_INVALID_VALUE); return nullptr; } if(samples <= 0) { alcSetError(nullptr, ALC_INVALID_VALUE); return nullptr; } std::string_view devname{deviceName ? deviceName : ""}; if(!devname.empty()) { TRACE("Opening capture device \"{}\"", devname); if(al::case_compare(devname, GetDefaultName()) == 0 || al::case_compare(devname, "openal-soft"sv) == 0) devname = {}; else { const auto prefix = GetDevicePrefix(); if(!prefix.empty() && devname.size() > prefix.size() && al::starts_with(devname, prefix)) devname = devname.substr(prefix.size()); } } else TRACE("Opening default capture device"); auto device = DeviceRef{new(std::nothrow) al::Device{DeviceType::Capture}}; if(!device) { WARN("Failed to create capture device handle"); alcSetError(nullptr, ALC_OUT_OF_MEMORY); return nullptr; } auto decompfmt = DecomposeDevFormat(format); if(!decompfmt) { alcSetError(nullptr, ALC_INVALID_ENUM); return nullptr; } device->mSampleRate = frequency; device->FmtChans = decompfmt->chans; device->FmtType = decompfmt->type; device->Flags.set(FrequencyRequest); device->Flags.set(ChannelsRequest); device->Flags.set(SampleTypeRequest); device->mUpdateSize = static_cast(samples); device->mBufferSize = static_cast(samples); TRACE("Capture format: {}, {}, {}hz, {} / {} buffer", DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType), device->mSampleRate, device->mUpdateSize, device->mBufferSize); try { auto backend = CaptureFactory->createBackend(device.get(), BackendType::Capture); std::lock_guard listlock{ListLock}; backend->open(devname); device->mDeviceName = std::string{GetDevicePrefix()}+backend->mDeviceName; device->Backend = std::move(backend); } catch(al::backend_exception &e) { WARN("Failed to open capture device: {}", e.what()); alcSetError(nullptr, (e.errorCode() == al::backend_error::OutOfMemory) ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE); return nullptr; } { std::lock_guard listlock{ListLock}; auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get()); DeviceList.emplace(iter, device.get()); } device->mDeviceState = DeviceState::Configured; TRACE("Created capture device {}, \"{}\"", voidp{device.get()}, device->mDeviceName); return device.release(); } ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device) noexcept { if(!gProcessRunning) return ALC_FALSE; std::unique_lock listlock{ListLock}; auto iter = std::lower_bound(DeviceList.begin(), DeviceList.end(), device); if(iter == DeviceList.end() || *iter != device) { alcSetError(nullptr, ALC_INVALID_DEVICE); return ALC_FALSE; } if((*iter)->Type != DeviceType::Capture) { alcSetError(*iter, ALC_INVALID_DEVICE); return ALC_FALSE; } DeviceRef dev{*iter}; DeviceList.erase(iter); listlock.unlock(); std::lock_guard statelock{dev->StateLock}; if(dev->mDeviceState == DeviceState::Playing) { dev->Backend->stop(); dev->mDeviceState = DeviceState::Configured; } return ALC_TRUE; } ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type != DeviceType::Capture) { alcSetError(dev.get(), ALC_INVALID_DEVICE); return; } std::lock_guard statelock{dev->StateLock}; if(!dev->Connected.load(std::memory_order_acquire) || dev->mDeviceState < DeviceState::Configured) alcSetError(dev.get(), ALC_INVALID_DEVICE); else if(dev->mDeviceState != DeviceState::Playing) { try { auto backend = dev->Backend.get(); backend->start(); dev->mDeviceState = DeviceState::Playing; } catch(al::backend_exception& e) { ERR("{}", e.what()); dev->handleDisconnect("{}", e.what()); alcSetError(dev.get(), ALC_INVALID_DEVICE); } } } ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type != DeviceType::Capture) alcSetError(dev.get(), ALC_INVALID_DEVICE); else { std::lock_guard statelock{dev->StateLock}; if(dev->mDeviceState == DeviceState::Playing) { dev->Backend->stop(); dev->mDeviceState = DeviceState::Configured; } } } ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type != DeviceType::Capture) { alcSetError(dev.get(), ALC_INVALID_DEVICE); return; } if(samples < 0 || (samples > 0 && buffer == nullptr)) { alcSetError(dev.get(), ALC_INVALID_VALUE); return; } if(samples < 1) return; std::lock_guard statelock{dev->StateLock}; BackendBase *backend{dev->Backend.get()}; const auto usamples = static_cast(samples); if(usamples > backend->availableSamples()) { alcSetError(dev.get(), ALC_INVALID_VALUE); return; } backend->captureSamples(static_cast(buffer), usamples); } /************************************************ * ALC loopback functions ************************************************/ /** Open a loopback device, for manual rendering. */ ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName) noexcept { InitConfig(); /* Make sure the device name, if specified, is us. */ if(deviceName && strcmp(deviceName, GetDefaultName()) != 0) { alcSetError(nullptr, ALC_INVALID_VALUE); return nullptr; } const uint DefaultSends{ #if ALSOFT_EAX eax_g_is_enabled ? uint{EAX_MAX_FXSLOTS} : #endif // ALSOFT_EAX uint{DefaultSendCount} }; auto device = DeviceRef{new(std::nothrow) al::Device{DeviceType::Loopback}}; if(!device) { WARN("Failed to create loopback device handle"); alcSetError(nullptr, ALC_OUT_OF_MEMORY); return nullptr; } device->SourcesMax = 256; device->AuxiliaryEffectSlotMax = 64; device->NumAuxSends = DefaultSends; //Set output format device->mBufferSize = 0; device->mUpdateSize = 0; device->mSampleRate = DefaultOutputRate; device->FmtChans = DevFmtChannelsDefault; device->FmtType = DevFmtTypeDefault; device->NumStereoSources = 1; device->NumMonoSources = device->SourcesMax - device->NumStereoSources; try { auto backend = LoopbackBackendFactory::getFactory().createBackend(device.get(), BackendType::Playback); backend->open("Loopback"); device->mDeviceName = std::string{GetDevicePrefix()}+backend->mDeviceName; device->Backend = std::move(backend); } catch(al::backend_exception &e) { WARN("Failed to open loopback device: {}", e.what()); alcSetError(nullptr, (e.errorCode() == al::backend_error::OutOfMemory) ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE); return nullptr; } { std::lock_guard listlock{ListLock}; auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get()); DeviceList.emplace(iter, device.get()); } TRACE("Created loopback device {}", voidp{device.get()}); return device.release(); } /** * Determines if the loopback device supports the given format for rendering. */ ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type != DeviceType::Loopback) alcSetError(dev.get(), ALC_INVALID_DEVICE); else if(freq <= 0) alcSetError(dev.get(), ALC_INVALID_VALUE); else { if(DevFmtTypeFromEnum(type).has_value() && DevFmtChannelsFromEnum(channels).has_value() && freq >= int{MinOutputRate} && freq <= int{MaxOutputRate}) return ALC_TRUE; } return ALC_FALSE; } /** * Renders some samples into a buffer, using the format last set by the * attributes given to alcCreateContext. */ #if defined(__GNUC__) && defined(__i386__) /* Needed on x86-32 even without SSE codegen, since the mixer may still use SSE * and GCC assumes the stack is aligned (x86-64 ABI guarantees alignment). */ [[gnu::force_align_arg_pointer]] #endif ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples) noexcept { auto aldev = dynamic_cast(device); if(!aldev || aldev->Type != DeviceType::Loopback) UNLIKELY alcSetError(aldev, ALC_INVALID_DEVICE); else if(samples < 0 || (samples > 0 && buffer == nullptr)) UNLIKELY alcSetError(aldev, ALC_INVALID_VALUE); else aldev->renderSamples(buffer, static_cast(samples), aldev->channelsFromFmt()); } /************************************************ * ALC DSP pause/resume functions ************************************************/ /** Pause the DSP to stop audio processing. */ ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type != DeviceType::Playback) alcSetError(dev.get(), ALC_INVALID_DEVICE); else { std::lock_guard statelock{dev->StateLock}; if(dev->mDeviceState == DeviceState::Playing) { dev->Backend->stop(); dev->mDeviceState = DeviceState::Configured; } dev->Flags.set(DevicePaused); } } /** Resume the DSP to restart audio processing. */ ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type != DeviceType::Playback) { alcSetError(dev.get(), ALC_INVALID_DEVICE); return; } std::lock_guard statelock{dev->StateLock}; if(!dev->Flags.test(DevicePaused)) return; if(dev->mDeviceState < DeviceState::Configured) { WARN("Cannot resume unconfigured device"); alcSetError(dev.get(), ALC_INVALID_DEVICE); return; } if(!dev->Connected.load()) { WARN("Cannot resume a disconnected device"); alcSetError(dev.get(), ALC_INVALID_DEVICE); return; } dev->Flags.reset(DevicePaused); if(dev->mContexts.load()->empty()) return; try { auto backend = dev->Backend.get(); backend->start(); dev->mDeviceState = DeviceState::Playing; } catch(al::backend_exception& e) { ERR("{}", e.what()); dev->handleDisconnect("{}", e.what()); alcSetError(dev.get(), ALC_INVALID_DEVICE); return; } TRACE("Post-resume: {}, {}, {}hz, {} / {} buffer", DevFmtChannelsString(dev->FmtChans), DevFmtTypeString(dev->FmtType), dev->mSampleRate, dev->mUpdateSize, dev->mBufferSize); } /************************************************ * ALC HRTF functions ************************************************/ /** Gets a string parameter at the given index. */ ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum paramName, ALCsizei index) noexcept { DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type == DeviceType::Capture) alcSetError(dev.get(), ALC_INVALID_DEVICE); else switch(paramName) { case ALC_HRTF_SPECIFIER_SOFT: if(index >= 0 && static_cast(index) < dev->mHrtfList.size()) return dev->mHrtfList[static_cast(index)].c_str(); alcSetError(dev.get(), ALC_INVALID_VALUE); break; default: alcSetError(dev.get(), ALC_INVALID_ENUM); break; } return nullptr; } /** Resets the given device output, using the specified attribute list. */ ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs) noexcept { std::unique_lock listlock{ListLock}; DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type == DeviceType::Capture) { listlock.unlock(); alcSetError(dev.get(), ALC_INVALID_DEVICE); return ALC_FALSE; } std::lock_guard statelock{dev->StateLock}; listlock.unlock(); /* Force the backend to stop mixing first since we're resetting. Also reset * the connected state so lost devices can attempt recover. */ if(dev->mDeviceState == DeviceState::Playing) { dev->Backend->stop(); dev->mDeviceState = DeviceState::Configured; } return ResetDeviceParams(dev.get(), SpanFromAttributeList(attribs)) ? ALC_TRUE : ALC_FALSE; } /************************************************ * ALC device reopen functions ************************************************/ /** Reopens the given device output, using the specified name and attribute list. */ FORCE_ALIGN ALCboolean ALC_APIENTRY alcReopenDeviceSOFT(ALCdevice *device, const ALCchar *deviceName, const ALCint *attribs) noexcept { std::unique_lock listlock{ListLock}; DeviceRef dev{VerifyDevice(device)}; if(!dev || dev->Type != DeviceType::Playback) { listlock.unlock(); alcSetError(dev.get(), ALC_INVALID_DEVICE); return ALC_FALSE; } std::lock_guard statelock{dev->StateLock}; std::string_view devname{deviceName ? deviceName : ""}; if(!devname.empty()) { if(devname.length() >= size_t{std::numeric_limits::max()}) { ERR("Device name too long ({} >= {})", devname.length(), std::numeric_limits::max()); alcSetError(dev.get(), ALC_INVALID_VALUE); return ALC_FALSE; } if(al::case_compare(devname, GetDefaultName()) == 0) devname = {}; else { const auto prefix = GetDevicePrefix(); if(!prefix.empty() && devname.size() > prefix.size() && al::starts_with(devname, prefix)) devname = devname.substr(prefix.size()); } } /* Force the backend device to stop first since we're opening another one. */ const bool wasPlaying{dev->mDeviceState == DeviceState::Playing}; if(wasPlaying) { dev->Backend->stop(); dev->mDeviceState = DeviceState::Configured; } BackendPtr newbackend; try { newbackend = PlaybackFactory->createBackend(dev.get(), BackendType::Playback); newbackend->open(devname); } catch(al::backend_exception &e) { listlock.unlock(); newbackend = nullptr; WARN("Failed to reopen playback device: {}", e.what()); alcSetError(dev.get(), (e.errorCode() == al::backend_error::OutOfMemory) ? ALC_OUT_OF_MEMORY : ALC_INVALID_VALUE); if(dev->Connected.load(std::memory_order_relaxed) && wasPlaying) { try { auto backend = dev->Backend.get(); backend->start(); dev->mDeviceState = DeviceState::Playing; } catch(al::backend_exception &be) { ERR("{}", be.what()); dev->handleDisconnect("{}", be.what()); } } return ALC_FALSE; } listlock.unlock(); dev->mDeviceName = std::string{GetDevicePrefix()}+newbackend->mDeviceName; dev->Backend = std::move(newbackend); dev->mDeviceState = DeviceState::Unprepared; TRACE("Reopened device {}, \"{}\"", voidp{dev.get()}, dev->mDeviceName); std::string{}.swap(dev->mVendorOverride); std::string{}.swap(dev->mVersionOverride); std::string{}.swap(dev->mRendererOverride); auto checkopt = [&dev](const char *envname, const std::string_view optname) { if(auto optval = al::getenv(envname)) return optval; return dev->configValue("game_compat", optname); }; if(auto overrideopt = checkopt("__ALSOFT_VENDOR_OVERRIDE", "vendor-override"sv)) { dev->mVendorOverride = std::move(*overrideopt); TRACE("Overriding vendor string: \"{}\"", dev->mVendorOverride); } if(auto overrideopt = checkopt("__ALSOFT_VERSION_OVERRIDE", "version-override"sv)) { dev->mVersionOverride = std::move(*overrideopt); TRACE("Overriding version string: \"{}\"", dev->mVersionOverride); } if(auto overrideopt = checkopt("__ALSOFT_RENDERER_OVERRIDE", "renderer-override"sv)) { dev->mRendererOverride = std::move(*overrideopt); TRACE("Overriding renderer string: \"{}\"", dev->mRendererOverride); } /* Always return true even if resetting fails. It shouldn't fail, but this * is primarily to avoid confusion by the app seeing the function return * false while the device is on the new output anyway. We could try to * restore the old backend if this fails, but the configuration would be * changed with the new backend and would need to be reset again with the * old one, and the provided attributes may not be appropriate or desirable * for the old device. * * In this way, we essentially act as if the function succeeded, but * immediately disconnects following it. */ ResetDeviceParams(dev.get(), SpanFromAttributeList(attribs)); return ALC_TRUE; } /************************************************ * ALC event query functions ************************************************/ FORCE_ALIGN ALCenum ALC_APIENTRY alcEventIsSupportedSOFT(ALCenum eventType, ALCenum deviceType) noexcept { auto etype = alc::GetEventType(eventType); if(!etype) { WARN("Invalid event type: {:#04x}", as_unsigned(eventType)); alcSetError(nullptr, ALC_INVALID_ENUM); return ALC_FALSE; } auto supported = alc::EventSupport::NoSupport; switch(deviceType) { case ALC_PLAYBACK_DEVICE_SOFT: if(PlaybackFactory) supported = PlaybackFactory->queryEventSupport(*etype, BackendType::Playback); return al::to_underlying(supported); case ALC_CAPTURE_DEVICE_SOFT: if(CaptureFactory) supported = CaptureFactory->queryEventSupport(*etype, BackendType::Capture); return al::to_underlying(supported); } WARN("Invalid device type: {:#04x}", as_unsigned(deviceType)); alcSetError(nullptr, ALC_INVALID_ENUM); return ALC_FALSE; }