kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
openal-soft/Alc/alc.cpp

4356 lines
131 KiB
C++
Raw Normal View History

Initial import
2007-11-13 18:02:18 -08:00
/**
* 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
Update COPYING to the latest https://www.gnu.org/licenses/old-licenses/lgpl-2.0.txt to fix the FSF' address Fix the FSF' address in the source
2014-08-18 14:11:03 +02:00
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Initial import
2007-11-13 18:02:18 -08:00
* Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#include "config.h"
Trace the commit ID and branch the library was built from
2016-12-21 01:08:33 -08:00
#include "version.h"
Initial import
2007-11-13 18:02:18 -08:00
#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
Don't use a multiple lists for extensions
2008-01-19 20:02:40 -08:00
#include <ctype.h>
Add an option to trap device errors in a debugger
2011-09-10 01:23:59 -07:00
#include <signal.h>
Constify and properly type some variables and struct members
2010-03-24 22:43:08 -07:00
Use std::pow and std::log2
2018-11-14 17:01:19 -08:00
#include <cmath>
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
#include <atomic>
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
#include <mutex>
#include <thread>
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
#include <vector>
#include <string>
Avoid some explicit loops
2018-11-28 11:30:44 -08:00
#include <numeric>
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
#include <algorithm>
Copy the voice's ambisonic upsampler state when reallocating
2019-04-01 17:27:31 -07:00
#include <functional>
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
Initial import
2007-11-13 18:02:18 -08:00
#include "alMain.h"
Move the ALCcontext definition to its own header
2018-11-17 23:02:27 -08:00
#include "alcontext.h"
Report one max auxiliary send per source
2007-12-18 18:13:49 -08:00
#include "alSource.h"
Don't include alListener.h from alMain.h
2012-10-09 04:48:12 -07:00
#include "alListener.h"
Fix includes so alMain.h doesn't include so much by itself
2007-12-31 01:09:57 -08:00
#include "alSource.h"
Move (de)initialization into ALc.c and remove unneeded file
2008-07-17 18:38:07 -07:00
#include "alBuffer.h"
Move the filter implementation to a separate directory
2018-03-22 07:05:40 -07:00
#include "alFilter.h"
#include "alEffect.h"
Don't include alAuxEffectSlot.h in alSource.h
2008-01-16 14:01:24 -08:00
#include "alAuxEffectSlot.h"
Add an option to trap context errors in a debugger
2011-09-10 01:12:34 -07:00
#include "alError.h"
Move the compressor/limiter declarations to their own header
2018-01-11 06:50:53 -08:00
#include "mastering.h"
Add a dual-band ambisonic decoder This uses a virtual B-Format buffer for mixing, and then uses a dual-band decoder for improved positional quality. This currently only works with first- order output since first-order input (from the AL_EXT_BFROMAT extension) would not sound correct when fed through a second- or third-order decoder. This also does not currently implement near-field compensation since near-field rendering effects are not implemented.
2016-03-15 05:08:05 -07:00
#include "bformatdec.h"
Use a unique_ptr for Uhj2Encoder
2018-11-21 15:31:32 -08:00
#include "uhjfilter.h"
Reimplement panning using lookup tables, based on a patch by Christian Borss This allows speaker positions to be specified by discrete angles around the listener, providing more flexibility and configurability in placement. Additional patches to take advantage of this are forthcoming.
2009-01-24 10:38:04 -08:00
#include "alu.h"
Move the config function declarations to their own header And rename alcConfig.c to alconfig.c for consistency.
2018-01-11 07:56:54 -08:00
#include "alconfig.h"
Add a thread to marshal events from the mixer To avoid having unknown user code running in the mixer thread that could significantly delay the mixed output, a lockless ringbuffer is used for the mixer to provide events that a secondary thread will pop off and process.
2018-01-31 20:21:54 -08:00
#include "ringbuffer.h"
Use a unique_ptr for the FrontStablizer
2018-11-22 04:53:29 -08:00
#include "filters/splitter.h"
Use unique_ptr for bs2b
2018-11-22 06:49:37 -08:00
#include "bs2b.h"
Initial import
2007-11-13 18:02:18 -08:00
Move the FPU mode declarations to a separate header Also don't use inheritance with FPUCtl.
2018-01-11 08:44:52 -08:00
#include "fpu_modes.h"
Move the CPU capability flags to a separate header
2018-01-11 07:19:19 -08:00
#include "cpu_caps.h"
Use a C11-like mutex wrapper instead of CRITICAL_SECTIONs
2014-04-16 01:39:11 -07:00
#include "compat.h"
#include "threads.h"
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
#include "alexcpt.h"
Move the aligned malloc functions to the common lib
2016-03-29 00:44:58 -07:00
#include "almalloc.h"
Add an al_string type and use it for the device lists
2014-03-28 05:40:24 -07:00
Use an ALCbackend object to access playback backends This is the start of a backend redesign. Currently, a wrapper object is used to avoid having to redo all the backends at once, but they should slowly be converted to derive from ALCbackend instead. The ALCbackend interface can change as needed.
2013-10-27 14:24:55 -07:00
#include "backends/base.h"
Start a new backend factory API Using proper class inheritance. Be aware this breaks all backends except null (and loopback). They will be restored individually in due time.
2018-11-15 19:15:14 -08:00
#include "backends/null.h"
Update the loopback backend
2018-11-15 19:42:13 -08:00
#include "backends/loopback.h"
Convert the JACK backend factory
2018-11-15 22:03:20 -08:00
#ifdef HAVE_JACK
#include "backends/jack.h"
#endif
Convert the PulseAudio backend factory
2018-11-15 19:55:56 -08:00
#ifdef HAVE_PULSEAUDIO
#include "backends/pulseaudio.h"
#endif
Convert the ALSA backend factory
2018-11-15 21:33:44 -08:00
#ifdef HAVE_ALSA
#include "backends/alsa.h"
#endif
Convert the WASAPI backend factory
2018-11-15 21:14:20 -08:00
#ifdef HAVE_WASAPI
#include "backends/wasapi.h"
#endif
Convert the CoreAudio backend factory
2018-11-15 21:24:09 -08:00
#ifdef HAVE_COREAUDIO
#include "backends/coreaudio.h"
#endif
Convert the OpenSL backend factory
2018-11-15 21:42:17 -08:00
#ifdef HAVE_OPENSL
#include "backends/opensl.h"
#endif
Convert the Solaris backend factory
2018-11-15 22:23:29 -08:00
#ifdef HAVE_SOLARIS
#include "backends/solaris.h"
#endif
Convert the SndIO backend factory
2018-11-15 22:36:49 -08:00
#ifdef HAVE_SNDIO
#include "backends/sndio.h"
#endif
Convert the OSS backend factory
2018-11-15 23:02:26 -08:00
#ifdef HAVE_OSS
#include "backends/oss.h"
#endif
Convert the QSA backend factory
2018-11-15 23:10:06 -08:00
#ifdef HAVE_QSA
#include "backends/qsa.h"
#endif
Convert the DSound backend factory
2018-11-15 23:32:28 -08:00
#ifdef HAVE_DSOUND
#include "backends/dsound.h"
#endif
Convert the WinMM backend factory
2018-11-15 23:41:09 -08:00
#ifdef HAVE_WINMM
#include "backends/winmm.h"
#endif
Convert the PortAudio backend factory
2018-11-15 23:50:15 -08:00
#ifdef HAVE_PORTAUDIO
#include "backends/portaudio.h"
#endif
Convert the SDL2 backend factory
2018-11-15 22:15:10 -08:00
#ifdef HAVE_SDL2
#include "backends/sdl2.h"
#endif
Convert the Wave Writer backend factory
2018-11-15 21:53:14 -08:00
#ifdef HAVE_WAVE
#include "backends/wave.h"
#endif
Use an ALCbackend object to access playback backends This is the start of a backend redesign. Currently, a wrapper object is used to avoid having to redo all the backends at once, but they should slowly be converted to derive from ALCbackend instead. The ALCbackend interface can change as needed.
2013-10-27 14:24:55 -07:00
Initial import
2007-11-13 18:02:18 -08:00
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
namespace {
Copy the voice's ambisonic upsampler state when reallocating
2019-04-01 17:27:31 -07:00
using namespace std::placeholders;
Avoid multiple using statements for the same things
2019-04-01 21:35:52 -07:00
using std::chrono::seconds;
using std::chrono::nanoseconds;
Copy the voice's ambisonic upsampler state when reallocating
2019-04-01 17:27:31 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Backends
************************************************/
Use an ALCbackend object to access playback backends This is the start of a backend redesign. Currently, a wrapper object is used to avoid having to redo all the backends at once, but they should slowly be converted to derive from ALCbackend instead. The ALCbackend interface can change as needed.
2013-10-27 14:24:55 -07:00
struct BackendInfo {
const char *name;
Start a new backend factory API Using proper class inheritance. Be aware this breaks all backends except null (and loopback). They will be restored individually in due time.
2018-11-15 19:15:14 -08:00
BackendFactory& (*getFactory)(void);
Use an ALCbackend object to access playback backends This is the start of a backend redesign. Currently, a wrapper object is used to avoid having to redo all the backends at once, but they should slowly be converted to derive from ALCbackend instead. The ALCbackend interface can change as needed.
2013-10-27 14:24:55 -07:00
};
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
BackendInfo BackendList[] = {
Convert the JACK backend factory
2018-11-15 22:03:20 -08:00
#ifdef HAVE_JACK
{ "jack", JackBackendFactory::getFactory },
#endif
Convert the PulseAudio backend factory
2018-11-15 19:55:56 -08:00
#ifdef HAVE_PULSEAUDIO
{ "pulse", PulseBackendFactory::getFactory },
#endif
Convert the ALSA backend factory
2018-11-15 21:33:44 -08:00
#ifdef HAVE_ALSA
{ "alsa", AlsaBackendFactory::getFactory },
#endif
Convert the WASAPI backend factory
2018-11-15 21:14:20 -08:00
#ifdef HAVE_WASAPI
{ "wasapi", WasapiBackendFactory::getFactory },
#endif
Convert the CoreAudio backend factory
2018-11-15 21:24:09 -08:00
#ifdef HAVE_COREAUDIO
{ "core", CoreAudioBackendFactory::getFactory },
#endif
Convert the OpenSL backend factory
2018-11-15 21:42:17 -08:00
#ifdef HAVE_OPENSL
{ "opensl", OSLBackendFactory::getFactory },
#endif
Convert the Solaris backend factory
2018-11-15 22:23:29 -08:00
#ifdef HAVE_SOLARIS
{ "solaris", SolarisBackendFactory::getFactory },
#endif
Convert the SndIO backend factory
2018-11-15 22:36:49 -08:00
#ifdef HAVE_SNDIO
{ "sndio", SndIOBackendFactory::getFactory },
#endif
Convert the OSS backend factory
2018-11-15 23:02:26 -08:00
#ifdef HAVE_OSS
{ "oss", OSSBackendFactory::getFactory },
#endif
Convert the QSA backend factory
2018-11-15 23:10:06 -08:00
#ifdef HAVE_QSA
{ "qsa", QSABackendFactory::getFactory },
#endif
Convert the DSound backend factory
2018-11-15 23:32:28 -08:00
#ifdef HAVE_DSOUND
{ "dsound", DSoundBackendFactory::getFactory },
#endif
Convert the WinMM backend factory
2018-11-15 23:41:09 -08:00
#ifdef HAVE_WINMM
{ "winmm", WinMMBackendFactory::getFactory },
#endif
Convert the PortAudio backend factory
2018-11-15 23:50:15 -08:00
#ifdef HAVE_PORTAUDIO
{ "port", PortBackendFactory::getFactory },
#endif
Convert the SDL2 backend factory
2018-11-15 22:15:10 -08:00
#ifdef HAVE_SDL2
{ "sdl2", SDL2BackendFactory::getFactory },
#endif
Convert the PulseAudio backend factory
2018-11-15 19:55:56 -08:00
Start a new backend factory API Using proper class inheritance. Be aware this breaks all backends except null (and loopback). They will be restored individually in due time.
2018-11-15 19:15:14 -08:00
{ "null", NullBackendFactory::getFactory },
Convert the Wave Writer backend factory
2018-11-15 21:53:14 -08:00
#ifdef HAVE_WAVE
{ "wave", WaveBackendFactory::getFactory },
#endif
Initial import
2007-11-13 18:02:18 -08:00
};
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
auto BackendListEnd = std::end(BackendList);
Initial import
2007-11-13 18:02:18 -08:00
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
BackendFactory *PlaybackFactory{};
BackendFactory *CaptureFactory{};
Use separate lists for playback and capture backends
2011-08-19 00:23:26 -07:00
Use an ALCbackend object to access playback backends This is the start of a backend redesign. Currently, a wrapper object is used to avoid having to redo all the backends at once, but they should slowly be converted to derive from ALCbackend instead. The ALCbackend interface can change as needed.
2013-10-27 14:24:55 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Functions, enums, and errors
************************************************/
Remove a couple unneeded typedefs
2017-03-14 08:37:50 -07:00
#define DECL(x) { #x, (ALCvoid*)(x) }
Fix the error "a reinterpret_cast is not a constant expression" on GCC 9
2019-06-27 22:29:42 -07:00
const struct {
Constify and properly type some variables and struct members
2010-03-24 22:43:08 -07:00
const ALCchar *funcName;
ALCvoid *address;
Remove a couple unneeded typedefs
2017-03-14 08:37:50 -07:00
} alcFunctions[] = {
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(alcCreateContext),
DECL(alcMakeContextCurrent),
DECL(alcProcessContext),
DECL(alcSuspendContext),
DECL(alcDestroyContext),
DECL(alcGetCurrentContext),
DECL(alcGetContextsDevice),
DECL(alcOpenDevice),
DECL(alcCloseDevice),
DECL(alcGetError),
DECL(alcIsExtensionPresent),
DECL(alcGetProcAddress),
DECL(alcGetEnumValue),
DECL(alcGetString),
DECL(alcGetIntegerv),
DECL(alcCaptureOpenDevice),
DECL(alcCaptureCloseDevice),
DECL(alcCaptureStart),
DECL(alcCaptureStop),
DECL(alcCaptureSamples),
DECL(alcSetThreadContext),
DECL(alcGetThreadContext),
DECL(alcLoopbackOpenDeviceSOFT),
DECL(alcIsRenderFormatSupportedSOFT),
DECL(alcRenderSamplesSOFT),
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
DECL(alcDevicePauseSOFT),
DECL(alcDeviceResumeSOFT),
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
DECL(alcGetStringiSOFT),
Add a method to reset the device This basically acts as if the app created a new context with the specified attributes (causing the device to reset with new parameters), then immediately delete it. Existing contexts remain undisturbed, except for a temporary pause while the device output is reconfigured.
2015-05-16 01:46:06 -07:00
DECL(alcResetDeviceSOFT),
Finalize ALC_SOFT_HRTF
2015-10-28 13:38:30 -07:00
DECL(alcGetInteger64vSOFT),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(alEnable),
DECL(alDisable),
DECL(alIsEnabled),
DECL(alGetString),
DECL(alGetBooleanv),
DECL(alGetIntegerv),
DECL(alGetFloatv),
DECL(alGetDoublev),
DECL(alGetBoolean),
DECL(alGetInteger),
DECL(alGetFloat),
DECL(alGetDouble),
DECL(alGetError),
DECL(alIsExtensionPresent),
DECL(alGetProcAddress),
DECL(alGetEnumValue),
DECL(alListenerf),
DECL(alListener3f),
DECL(alListenerfv),
DECL(alListeneri),
DECL(alListener3i),
DECL(alListeneriv),
DECL(alGetListenerf),
DECL(alGetListener3f),
DECL(alGetListenerfv),
DECL(alGetListeneri),
DECL(alGetListener3i),
DECL(alGetListeneriv),
DECL(alGenSources),
DECL(alDeleteSources),
DECL(alIsSource),
DECL(alSourcef),
DECL(alSource3f),
DECL(alSourcefv),
DECL(alSourcei),
DECL(alSource3i),
DECL(alSourceiv),
DECL(alGetSourcef),
DECL(alGetSource3f),
DECL(alGetSourcefv),
DECL(alGetSourcei),
DECL(alGetSource3i),
DECL(alGetSourceiv),
DECL(alSourcePlayv),
DECL(alSourceStopv),
DECL(alSourceRewindv),
DECL(alSourcePausev),
DECL(alSourcePlay),
DECL(alSourceStop),
DECL(alSourceRewind),
DECL(alSourcePause),
DECL(alSourceQueueBuffers),
DECL(alSourceUnqueueBuffers),
DECL(alGenBuffers),
DECL(alDeleteBuffers),
DECL(alIsBuffer),
DECL(alBufferData),
DECL(alBufferf),
DECL(alBuffer3f),
DECL(alBufferfv),
DECL(alBufferi),
DECL(alBuffer3i),
DECL(alBufferiv),
DECL(alGetBufferf),
DECL(alGetBuffer3f),
DECL(alGetBufferfv),
DECL(alGetBufferi),
DECL(alGetBuffer3i),
DECL(alGetBufferiv),
DECL(alDopplerFactor),
DECL(alDopplerVelocity),
DECL(alSpeedOfSound),
DECL(alDistanceModel),
DECL(alGenFilters),
DECL(alDeleteFilters),
DECL(alIsFilter),
DECL(alFilteri),
DECL(alFilteriv),
DECL(alFilterf),
DECL(alFilterfv),
DECL(alGetFilteri),
DECL(alGetFilteriv),
DECL(alGetFilterf),
DECL(alGetFilterfv),
DECL(alGenEffects),
DECL(alDeleteEffects),
DECL(alIsEffect),
DECL(alEffecti),
DECL(alEffectiv),
DECL(alEffectf),
DECL(alEffectfv),
DECL(alGetEffecti),
DECL(alGetEffectiv),
DECL(alGetEffectf),
DECL(alGetEffectfv),
DECL(alGenAuxiliaryEffectSlots),
DECL(alDeleteAuxiliaryEffectSlots),
DECL(alIsAuxiliaryEffectSlot),
DECL(alAuxiliaryEffectSloti),
DECL(alAuxiliaryEffectSlotiv),
DECL(alAuxiliaryEffectSlotf),
DECL(alAuxiliaryEffectSlotfv),
DECL(alGetAuxiliaryEffectSloti),
DECL(alGetAuxiliaryEffectSlotiv),
DECL(alGetAuxiliaryEffectSlotf),
DECL(alGetAuxiliaryEffectSlotfv),
DECL(alDeferUpdatesSOFT),
DECL(alProcessUpdatesSOFT),
Implement the double and int64 source setters Note that currently the int64 setters do not range check before being passed to the int setters, erroneously chopping off the upper bits.
2012-10-13 00:56:39 -07:00
DECL(alSourcedSOFT),
DECL(alSource3dSOFT),
DECL(alSourcedvSOFT),
Add methods to get source properties as doubles
2012-08-20 15:26:35 -07:00
DECL(alGetSourcedSOFT),
DECL(alGetSource3dSOFT),
DECL(alGetSourcedvSOFT),
Implement the double and int64 source setters Note that currently the int64 setters do not range check before being passed to the int setters, erroneously chopping off the upper bits.
2012-10-13 00:56:39 -07:00
DECL(alSourcei64SOFT),
DECL(alSource3i64SOFT),
DECL(alSourcei64vSOFT),
Add the start of AL_SOFT_source_latency This extension will provide a way for apps to get accurate latency and playback position information
2012-08-18 11:02:54 -07:00
DECL(alGetSourcei64SOFT),
Properly export alGetSource3i64SOFT
2012-08-20 14:48:08 -07:00
DECL(alGetSource3i64SOFT),
Add the start of AL_SOFT_source_latency This extension will provide a way for apps to get accurate latency and playback position information
2012-08-18 11:02:54 -07:00
DECL(alGetSourcei64vSOFT),
Add a method to enumerate resamplers
2017-04-21 04:15:08 -07:00
DECL(alGetStringiSOFT),
Expose a preliminary AL_SOFT_map_buffer extension for testing
2018-01-20 13:37:43 -08:00
Use a new proper buffer function with a flags parameter Rather than hackily combining bit flags with the format, to increase the number of potential flags. alBufferData now behaves as if calling alBufferStorageSOFT with a flags value of 0.
2018-01-23 14:33:30 -08:00
DECL(alBufferStorageSOFT),
Expose a preliminary AL_SOFT_map_buffer extension for testing
2018-01-20 13:37:43 -08:00
DECL(alMapBufferSOFT),
DECL(alUnmapBufferSOFT),
Use a new proper buffer function with a flags parameter Rather than hackily combining bit flags with the format, to increase the number of potential flags. alBufferData now behaves as if calling alBufferStorageSOFT with a flags value of 0.
2018-01-23 14:33:30 -08:00
DECL(alFlushMappedBufferSOFT),
Handle event properties This just implements the event methods insofar as tracked state. No events are generated/reported yet.
2018-01-23 18:25:59 -08:00
DECL(alEventControlSOFT),
DECL(alEventCallbackSOFT),
DECL(alGetPointerSOFT),
DECL(alGetPointervSOFT),
Initial import
2007-11-13 18:02:18 -08:00
};
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
#undef DECL
Initial import
2007-11-13 18:02:18 -08:00
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
#define DECL(x) { #x, (x) }
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr struct {
Remove a couple unneeded typedefs
2017-03-14 08:37:50 -07:00
const ALCchar *enumName;
ALCenum value;
} alcEnumerations[] = {
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(ALC_INVALID),
DECL(ALC_FALSE),
DECL(ALC_TRUE),
DECL(ALC_MAJOR_VERSION),
DECL(ALC_MINOR_VERSION),
DECL(ALC_ATTRIBUTES_SIZE),
DECL(ALC_ALL_ATTRIBUTES),
DECL(ALC_DEFAULT_DEVICE_SPECIFIER),
DECL(ALC_DEVICE_SPECIFIER),
DECL(ALC_ALL_DEVICES_SPECIFIER),
DECL(ALC_DEFAULT_ALL_DEVICES_SPECIFIER),
DECL(ALC_EXTENSIONS),
DECL(ALC_FREQUENCY),
DECL(ALC_REFRESH),
DECL(ALC_SYNC),
DECL(ALC_MONO_SOURCES),
DECL(ALC_STEREO_SOURCES),
DECL(ALC_CAPTURE_DEVICE_SPECIFIER),
DECL(ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER),
DECL(ALC_CAPTURE_SAMPLES),
DECL(ALC_CONNECTED),
DECL(ALC_EFX_MAJOR_VERSION),
DECL(ALC_EFX_MINOR_VERSION),
DECL(ALC_MAX_AUXILIARY_SENDS),
DECL(ALC_FORMAT_CHANNELS_SOFT),
DECL(ALC_FORMAT_TYPE_SOFT),
DECL(ALC_MONO_SOFT),
DECL(ALC_STEREO_SOFT),
DECL(ALC_QUAD_SOFT),
DECL(ALC_5POINT1_SOFT),
DECL(ALC_6POINT1_SOFT),
DECL(ALC_7POINT1_SOFT),
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
DECL(ALC_BFORMAT3D_SOFT),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(ALC_BYTE_SOFT),
DECL(ALC_UNSIGNED_BYTE_SOFT),
DECL(ALC_SHORT_SOFT),
DECL(ALC_UNSIGNED_SHORT_SOFT),
DECL(ALC_INT_SOFT),
DECL(ALC_UNSIGNED_INT_SOFT),
DECL(ALC_FLOAT_SOFT),
Add missing enum values Spotted by Xavier Bouchoux.
2015-09-17 04:01:46 -07:00
DECL(ALC_HRTF_SOFT),
DECL(ALC_DONT_CARE_SOFT),
DECL(ALC_HRTF_STATUS_SOFT),
DECL(ALC_HRTF_DISABLED_SOFT),
DECL(ALC_HRTF_ENABLED_SOFT),
DECL(ALC_HRTF_DENIED_SOFT),
DECL(ALC_HRTF_REQUIRED_SOFT),
DECL(ALC_HRTF_HEADPHONES_DETECTED_SOFT),
DECL(ALC_HRTF_UNSUPPORTED_FORMAT_SOFT),
Rename ALC_NUM_HRTF_SPECIFIER_SOFT to ALC_NUM_HRTF_SPECIFIERS_SOFT
2015-10-26 22:34:02 -07:00
DECL(ALC_NUM_HRTF_SPECIFIERS_SOFT),
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
DECL(ALC_HRTF_SPECIFIER_SOFT),
Allow apps to request a specific HRTF
2015-10-07 03:29:53 -07:00
DECL(ALC_HRTF_ID_SOFT),
Add missing enum values Spotted by Xavier Bouchoux.
2015-09-17 04:01:46 -07:00
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
DECL(ALC_AMBISONIC_LAYOUT_SOFT),
DECL(ALC_AMBISONIC_SCALING_SOFT),
DECL(ALC_AMBISONIC_ORDER_SOFT),
DECL(ALC_ACN_SOFT),
DECL(ALC_FUMA_SOFT),
DECL(ALC_N3D_SOFT),
DECL(ALC_SN3D_SOFT),
Start an extension to toggle the output limiter
2017-04-30 04:21:48 -07:00
DECL(ALC_OUTPUT_LIMITER_SOFT),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(ALC_NO_ERROR),
DECL(ALC_INVALID_DEVICE),
DECL(ALC_INVALID_CONTEXT),
DECL(ALC_INVALID_ENUM),
DECL(ALC_INVALID_VALUE),
DECL(ALC_OUT_OF_MEMORY),
DECL(AL_INVALID),
DECL(AL_NONE),
DECL(AL_FALSE),
DECL(AL_TRUE),
DECL(AL_SOURCE_RELATIVE),
DECL(AL_CONE_INNER_ANGLE),
DECL(AL_CONE_OUTER_ANGLE),
DECL(AL_PITCH),
DECL(AL_POSITION),
DECL(AL_DIRECTION),
DECL(AL_VELOCITY),
DECL(AL_LOOPING),
DECL(AL_BUFFER),
DECL(AL_GAIN),
DECL(AL_MIN_GAIN),
DECL(AL_MAX_GAIN),
DECL(AL_ORIENTATION),
DECL(AL_REFERENCE_DISTANCE),
DECL(AL_ROLLOFF_FACTOR),
DECL(AL_CONE_OUTER_GAIN),
DECL(AL_MAX_DISTANCE),
DECL(AL_SEC_OFFSET),
DECL(AL_SAMPLE_OFFSET),
DECL(AL_BYTE_OFFSET),
DECL(AL_SOURCE_TYPE),
DECL(AL_STATIC),
DECL(AL_STREAMING),
DECL(AL_UNDETERMINED),
DECL(AL_METERS_PER_UNIT),
Add missing enum values Spotted by Xavier Bouchoux.
2015-09-17 04:01:46 -07:00
DECL(AL_LOOP_POINTS_SOFT),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_DIRECT_CHANNELS_SOFT),
DECL(AL_DIRECT_FILTER),
DECL(AL_AUXILIARY_SEND_FILTER),
DECL(AL_AIR_ABSORPTION_FACTOR),
DECL(AL_ROOM_ROLLOFF_FACTOR),
DECL(AL_CONE_OUTER_GAINHF),
DECL(AL_DIRECT_FILTER_GAINHF_AUTO),
DECL(AL_AUXILIARY_SEND_FILTER_GAIN_AUTO),
DECL(AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO),
DECL(AL_SOURCE_STATE),
DECL(AL_INITIAL),
DECL(AL_PLAYING),
DECL(AL_PAUSED),
DECL(AL_STOPPED),
DECL(AL_BUFFERS_QUEUED),
DECL(AL_BUFFERS_PROCESSED),
DECL(AL_FORMAT_MONO8),
DECL(AL_FORMAT_MONO16),
DECL(AL_FORMAT_MONO_FLOAT32),
DECL(AL_FORMAT_MONO_DOUBLE_EXT),
DECL(AL_FORMAT_STEREO8),
DECL(AL_FORMAT_STEREO16),
DECL(AL_FORMAT_STEREO_FLOAT32),
DECL(AL_FORMAT_STEREO_DOUBLE_EXT),
DECL(AL_FORMAT_MONO_IMA4),
DECL(AL_FORMAT_STEREO_IMA4),
Add an extension to support MSADPCM buffer formats
2014-03-04 22:44:30 -08:00
DECL(AL_FORMAT_MONO_MSADPCM_SOFT),
DECL(AL_FORMAT_STEREO_MSADPCM_SOFT),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_FORMAT_QUAD8_LOKI),
DECL(AL_FORMAT_QUAD16_LOKI),
DECL(AL_FORMAT_QUAD8),
DECL(AL_FORMAT_QUAD16),
DECL(AL_FORMAT_QUAD32),
DECL(AL_FORMAT_51CHN8),
DECL(AL_FORMAT_51CHN16),
DECL(AL_FORMAT_51CHN32),
DECL(AL_FORMAT_61CHN8),
DECL(AL_FORMAT_61CHN16),
DECL(AL_FORMAT_61CHN32),
DECL(AL_FORMAT_71CHN8),
DECL(AL_FORMAT_71CHN16),
DECL(AL_FORMAT_71CHN32),
DECL(AL_FORMAT_REAR8),
DECL(AL_FORMAT_REAR16),
DECL(AL_FORMAT_REAR32),
DECL(AL_FORMAT_MONO_MULAW),
DECL(AL_FORMAT_MONO_MULAW_EXT),
DECL(AL_FORMAT_STEREO_MULAW),
DECL(AL_FORMAT_STEREO_MULAW_EXT),
DECL(AL_FORMAT_QUAD_MULAW),
DECL(AL_FORMAT_51CHN_MULAW),
DECL(AL_FORMAT_61CHN_MULAW),
DECL(AL_FORMAT_71CHN_MULAW),
DECL(AL_FORMAT_REAR_MULAW),
DECL(AL_FORMAT_MONO_ALAW_EXT),
DECL(AL_FORMAT_STEREO_ALAW_EXT),
Start AL_SOFT_buffer_samples2 as a replacement for AL_SOFT_buffer_samples
2016-04-25 18:56:59 -07:00
DECL(AL_FORMAT_BFORMAT2D_8),
DECL(AL_FORMAT_BFORMAT2D_16),
DECL(AL_FORMAT_BFORMAT2D_FLOAT32),
DECL(AL_FORMAT_BFORMAT2D_MULAW),
DECL(AL_FORMAT_BFORMAT3D_8),
DECL(AL_FORMAT_BFORMAT3D_16),
DECL(AL_FORMAT_BFORMAT3D_FLOAT32),
DECL(AL_FORMAT_BFORMAT3D_MULAW),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_FREQUENCY),
DECL(AL_BITS),
DECL(AL_CHANNELS),
DECL(AL_SIZE),
Add an extension to alter the block alignment for buffer unpack/pack ops This is for unpacking (reading, e.g. alBufferData) and packing (writing, e.g. alGetBufferSamplesSOFT) operations. The alignments are specified in sample frames, with 0 meaning the default (65 for IMA4, 1 otherwise). IMA4 alignment must be a multiple of 8, plus 1 (e.g. alignment = n*8 + 1), otherwise an error will occur during (un)packing. Chenging the block alignment does not affect already-loaded sample data, only future unpack/pack operations... so for example, this is perfectly valid: // Load mono IMA4 data with a block alignment of 1024 bytes, or 2041 sample // frames. alBufferi(buffer, AL_UNPACK_BLOCK_ALIGNMENT_SOFT, 2041); alBufferData(buffer, AL_FORMAT_MONO_IMA4, data, data_len, srate); alBufferi(buffer, AL_UNPACK_BLOCK_ALIGNMENT_SOFT, 0);
2014-03-04 05:16:45 -08:00
DECL(AL_UNPACK_BLOCK_ALIGNMENT_SOFT),
DECL(AL_PACK_BLOCK_ALIGNMENT_SOFT),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
Add support for AL_EXT_SOURCE_RADIUS
2016-04-25 00:30:47 -07:00
DECL(AL_SOURCE_RADIUS),
Implement AL_EXT_STEREO_ANGLES support
2016-03-25 14:40:44 -07:00
DECL(AL_STEREO_ANGLES),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_UNUSED),
DECL(AL_PENDING),
DECL(AL_PROCESSED),
DECL(AL_NO_ERROR),
DECL(AL_INVALID_NAME),
DECL(AL_INVALID_ENUM),
DECL(AL_INVALID_VALUE),
DECL(AL_INVALID_OPERATION),
DECL(AL_OUT_OF_MEMORY),
DECL(AL_VENDOR),
DECL(AL_VERSION),
DECL(AL_RENDERER),
DECL(AL_EXTENSIONS),
DECL(AL_DOPPLER_FACTOR),
DECL(AL_DOPPLER_VELOCITY),
DECL(AL_DISTANCE_MODEL),
DECL(AL_SPEED_OF_SOUND),
DECL(AL_SOURCE_DISTANCE_MODEL),
DECL(AL_DEFERRED_UPDATES_SOFT),
Add a query for the maximum source gain limit
2016-08-28 18:21:09 -07:00
DECL(AL_GAIN_LIMIT_SOFT),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_INVERSE_DISTANCE),
DECL(AL_INVERSE_DISTANCE_CLAMPED),
DECL(AL_LINEAR_DISTANCE),
DECL(AL_LINEAR_DISTANCE_CLAMPED),
DECL(AL_EXPONENT_DISTANCE),
DECL(AL_EXPONENT_DISTANCE_CLAMPED),
DECL(AL_FILTER_TYPE),
DECL(AL_FILTER_NULL),
DECL(AL_FILTER_LOWPASS),
DECL(AL_FILTER_HIGHPASS),
DECL(AL_FILTER_BANDPASS),
Combine ALCenum and ALenum lists
2012-04-20 01:24:58 -07:00
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_LOWPASS_GAIN),
DECL(AL_LOWPASS_GAINHF),
Combine ALCenum and ALenum lists
2012-04-20 01:24:58 -07:00
Implementing handling high-pass filter properties
2014-05-17 07:29:50 -07:00
DECL(AL_HIGHPASS_GAIN),
DECL(AL_HIGHPASS_GAINLF),
Support the band-pass filter
2014-05-17 08:04:14 -07:00
DECL(AL_BANDPASS_GAIN),
DECL(AL_BANDPASS_GAINHF),
DECL(AL_BANDPASS_GAINLF),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_EFFECT_TYPE),
DECL(AL_EFFECT_NULL),
DECL(AL_EFFECT_REVERB),
DECL(AL_EFFECT_EAXREVERB),
DECL(AL_EFFECT_CHORUS),
DECL(AL_EFFECT_DISTORTION),
DECL(AL_EFFECT_ECHO),
DECL(AL_EFFECT_FLANGER),
EFX:Pitch Shifter implementation Add pitch shifter effect using standard phase vocoder, based on work of Stephan Bernsee. Only mono signal processing by now.
2018-03-18 17:47:17 +01:00
DECL(AL_EFFECT_PITCH_SHIFTER),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_EFFECT_FREQUENCY_SHIFTER),
EFX: Frequency Shifter implementation Add frequency shifter effect using discrete Hilbert transform. Only mono signal processing by now (LEFT_DIRECTION).
2018-05-20 17:23:03 +02:00
#if 0
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_EFFECT_VOCAL_MORPHER),
Combine ALCenum and ALenum lists
2012-04-20 01:24:58 -07:00
#endif
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_EFFECT_RING_MODULATOR),
DECL(AL_EFFECT_AUTOWAH),
DECL(AL_EFFECT_COMPRESSOR),
Implement distortion and equalizer effects Code provided by Mike Gorchak
2013-05-18 01:33:01 -07:00
DECL(AL_EFFECT_EQUALIZER),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT),
DECL(AL_EFFECT_DEDICATED_DIALOGUE),
Add missing AL_EFFECTSLOT_ properties for al(c)GetEnumValue
2017-01-05 20:06:24 -08:00
DECL(AL_EFFECTSLOT_EFFECT),
DECL(AL_EFFECTSLOT_GAIN),
DECL(AL_EFFECTSLOT_AUXILIARY_SEND_AUTO),
DECL(AL_EFFECTSLOT_NULL),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_EAXREVERB_DENSITY),
DECL(AL_EAXREVERB_DIFFUSION),
DECL(AL_EAXREVERB_GAIN),
DECL(AL_EAXREVERB_GAINHF),
DECL(AL_EAXREVERB_GAINLF),
DECL(AL_EAXREVERB_DECAY_TIME),
DECL(AL_EAXREVERB_DECAY_HFRATIO),
DECL(AL_EAXREVERB_DECAY_LFRATIO),
DECL(AL_EAXREVERB_REFLECTIONS_GAIN),
DECL(AL_EAXREVERB_REFLECTIONS_DELAY),
DECL(AL_EAXREVERB_REFLECTIONS_PAN),
DECL(AL_EAXREVERB_LATE_REVERB_GAIN),
DECL(AL_EAXREVERB_LATE_REVERB_DELAY),
DECL(AL_EAXREVERB_LATE_REVERB_PAN),
DECL(AL_EAXREVERB_ECHO_TIME),
DECL(AL_EAXREVERB_ECHO_DEPTH),
DECL(AL_EAXREVERB_MODULATION_TIME),
DECL(AL_EAXREVERB_MODULATION_DEPTH),
DECL(AL_EAXREVERB_AIR_ABSORPTION_GAINHF),
DECL(AL_EAXREVERB_HFREFERENCE),
DECL(AL_EAXREVERB_LFREFERENCE),
DECL(AL_EAXREVERB_ROOM_ROLLOFF_FACTOR),
DECL(AL_EAXREVERB_DECAY_HFLIMIT),
DECL(AL_REVERB_DENSITY),
DECL(AL_REVERB_DIFFUSION),
DECL(AL_REVERB_GAIN),
DECL(AL_REVERB_GAINHF),
DECL(AL_REVERB_DECAY_TIME),
DECL(AL_REVERB_DECAY_HFRATIO),
DECL(AL_REVERB_REFLECTIONS_GAIN),
DECL(AL_REVERB_REFLECTIONS_DELAY),
DECL(AL_REVERB_LATE_REVERB_GAIN),
DECL(AL_REVERB_LATE_REVERB_DELAY),
DECL(AL_REVERB_AIR_ABSORPTION_GAINHF),
DECL(AL_REVERB_ROOM_ROLLOFF_FACTOR),
DECL(AL_REVERB_DECAY_HFLIMIT),
Add Chorus and Flanger effects Code provided by Mike Gorchak
2013-03-13 23:31:12 -07:00
DECL(AL_CHORUS_WAVEFORM),
DECL(AL_CHORUS_PHASE),
DECL(AL_CHORUS_RATE),
DECL(AL_CHORUS_DEPTH),
DECL(AL_CHORUS_FEEDBACK),
DECL(AL_CHORUS_DELAY),
Implement the Compressor effect
2013-10-03 07:55:12 -07:00
DECL(AL_DISTORTION_EDGE),
DECL(AL_DISTORTION_GAIN),
DECL(AL_DISTORTION_LOWPASS_CUTOFF),
DECL(AL_DISTORTION_EQCENTER),
DECL(AL_DISTORTION_EQBANDWIDTH),
DECL(AL_ECHO_DELAY),
DECL(AL_ECHO_LRDELAY),
DECL(AL_ECHO_DAMPING),
DECL(AL_ECHO_FEEDBACK),
DECL(AL_ECHO_SPREAD),
Add Chorus and Flanger effects Code provided by Mike Gorchak
2013-03-13 23:31:12 -07:00
DECL(AL_FLANGER_WAVEFORM),
DECL(AL_FLANGER_PHASE),
DECL(AL_FLANGER_RATE),
DECL(AL_FLANGER_DEPTH),
DECL(AL_FLANGER_FEEDBACK),
DECL(AL_FLANGER_DELAY),
EFX: Frequency Shifter implementation Add frequency shifter effect using discrete Hilbert transform. Only mono signal processing by now (LEFT_DIRECTION).
2018-05-20 17:23:03 +02:00
DECL(AL_FREQUENCY_SHIFTER_FREQUENCY),
DECL(AL_FREQUENCY_SHIFTER_LEFT_DIRECTION),
DECL(AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION),
Implement the Compressor effect
2013-10-03 07:55:12 -07:00
DECL(AL_RING_MODULATOR_FREQUENCY),
DECL(AL_RING_MODULATOR_HIGHPASS_CUTOFF),
DECL(AL_RING_MODULATOR_WAVEFORM),
EFX:Pitch Shifter implementation Add pitch shifter effect using standard phase vocoder, based on work of Stephan Bernsee. Only mono signal processing by now.
2018-03-18 17:47:17 +01:00
DECL(AL_PITCH_SHIFTER_COARSE_TUNE),
DECL(AL_PITCH_SHIFTER_FINE_TUNE),
Implement the Compressor effect
2013-10-03 07:55:12 -07:00
DECL(AL_COMPRESSOR_ONOFF),
Implement distortion and equalizer effects Code provided by Mike Gorchak
2013-05-18 01:33:01 -07:00
DECL(AL_EQUALIZER_LOW_GAIN),
DECL(AL_EQUALIZER_LOW_CUTOFF),
DECL(AL_EQUALIZER_MID1_GAIN),
DECL(AL_EQUALIZER_MID1_CENTER),
DECL(AL_EQUALIZER_MID1_WIDTH),
DECL(AL_EQUALIZER_MID2_GAIN),
DECL(AL_EQUALIZER_MID2_CENTER),
DECL(AL_EQUALIZER_MID2_WIDTH),
DECL(AL_EQUALIZER_HIGH_GAIN),
DECL(AL_EQUALIZER_HIGH_CUTOFF),
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
DECL(AL_DEDICATED_GAIN),
Add a method to enumerate resamplers
2017-04-21 04:15:08 -07:00
Rename ALCsndioBackend
2018-09-07 18:45:24 -07:00
DECL(AL_AUTOWAH_ATTACK_TIME),
DECL(AL_AUTOWAH_RELEASE_TIME),
DECL(AL_AUTOWAH_RESONANCE),
EFX: Autowah implementation Add autowah effect using biquad peaking filter and envelope follower
2018-07-22 00:48:54 +02:00
DECL(AL_AUTOWAH_PEAK_GAIN),
Add a method to enumerate resamplers
2017-04-21 04:15:08 -07:00
DECL(AL_NUM_RESAMPLERS_SOFT),
DECL(AL_DEFAULT_RESAMPLER_SOFT),
DECL(AL_SOURCE_RESAMPLER_SOFT),
DECL(AL_RESAMPLER_NAME_SOFT),
Start an extension to change the source's spatialize property
2017-05-05 02:41:34 -07:00
DECL(AL_SOURCE_SPATIALIZE_SOFT),
DECL(AL_AUTO_SOFT),
Expose a preliminary AL_SOFT_map_buffer extension for testing
2018-01-20 13:37:43 -08:00
DECL(AL_MAP_READ_BIT_SOFT),
DECL(AL_MAP_WRITE_BIT_SOFT),
Use a new proper buffer function with a flags parameter Rather than hackily combining bit flags with the format, to increase the number of potential flags. alBufferData now behaves as if calling alBufferStorageSOFT with a flags value of 0.
2018-01-23 14:33:30 -08:00
DECL(AL_MAP_PERSISTENT_BIT_SOFT),
DECL(AL_PRESERVE_DATA_BIT_SOFT),
Handle event properties This just implements the event methods insofar as tracked state. No events are generated/reported yet.
2018-01-23 18:25:59 -08:00
DECL(AL_EVENT_CALLBACK_FUNCTION_SOFT),
DECL(AL_EVENT_CALLBACK_USER_PARAM_SOFT),
DECL(AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT),
DECL(AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT),
DECL(AL_EVENT_TYPE_ERROR_SOFT),
DECL(AL_EVENT_TYPE_PERFORMANCE_SOFT),
Add a deprecated event type for alDopplerVelocity
2018-01-24 18:42:00 -08:00
DECL(AL_EVENT_TYPE_DEPRECATED_SOFT),
Initial import
2007-11-13 18:02:18 -08:00
};
Use a macro to declare the function and enum list members
2012-04-20 22:38:03 -07:00
#undef DECL
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr ALCchar alcNoError[] = "No Error";
constexpr ALCchar alcErrInvalidDevice[] = "Invalid Device";
constexpr ALCchar alcErrInvalidContext[] = "Invalid Context";
constexpr ALCchar alcErrInvalidEnum[] = "Invalid Enum";
constexpr ALCchar alcErrInvalidValue[] = "Invalid Value";
constexpr ALCchar alcErrOutOfMemory[] = "Out of Memory";
Initial import
2007-11-13 18:02:18 -08:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Global variables
************************************************/
/* Enumerated device names */
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr ALCchar alcDefaultName[] = "OpenAL Soft\0";
Add an al_string type and use it for the device lists
2014-03-28 05:40:24 -07:00
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
std::string alcAllDevicesList;
std::string alcCaptureDeviceList;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Move some functions into a separate helper source file
2011-08-20 03:59:46 -07:00
/* Default is always the first in the list */
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::string alcDefaultAllDevicesSpecifier;
std::string alcCaptureDefaultDeviceSpecifier;
Initial import
2007-11-13 18:02:18 -08:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* Default context extensions */
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr ALchar alExtList[] =
Expose a preliminary AL_SOFT_map_buffer extension for testing
2018-01-20 13:37:43 -08:00
"AL_EXT_ALAW "
"AL_EXT_BFORMAT "
"AL_EXT_DOUBLE "
"AL_EXT_EXPONENT_DISTANCE "
"AL_EXT_FLOAT32 "
"AL_EXT_IMA4 "
"AL_EXT_LINEAR_DISTANCE "
"AL_EXT_MCFORMATS "
"AL_EXT_MULAW "
"AL_EXT_MULAW_BFORMAT "
"AL_EXT_MULAW_MCFORMATS "
"AL_EXT_OFFSET "
"AL_EXT_source_distance_model "
"AL_EXT_SOURCE_RADIUS "
"AL_EXT_STEREO_ANGLES "
"AL_LOKI_quadriphonic "
"AL_SOFT_block_alignment "
"AL_SOFT_deferred_updates "
"AL_SOFT_direct_channels "
Add an in-progress extension to set the effect slot target
2018-12-24 15:52:37 -08:00
"AL_SOFTX_effect_chain "
Report AL_SOFTX_events as an in-progress extension
2018-01-24 19:59:22 -08:00
"AL_SOFTX_events "
Start an extension to allow source filter gains greater than 1
2018-07-15 21:01:26 -07:00
"AL_SOFTX_filter_gain_ex "
Expose a preliminary AL_SOFT_map_buffer extension for testing
2018-01-20 13:37:43 -08:00
"AL_SOFT_gain_clamp_ex "
"AL_SOFT_loop_points "
"AL_SOFTX_map_buffer "
"AL_SOFT_MSADPCM "
"AL_SOFT_source_latency "
"AL_SOFT_source_length "
"AL_SOFT_source_resampler "
"AL_SOFT_source_spatialize";
Hold the default context extensions globally
2010-01-09 02:48:18 -08:00
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::atomic<ALCenum> LastNullDeviceError{ALC_NO_ERROR};
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* Thread-local current context */
Avoid static global initialization functions
2018-12-08 21:58:44 -08:00
void ReleaseThreadCtx(ALCcontext *context)
{
auto ref = DecrementRef(&context->ref);
Don't log the function or prefix It's ultimately unnecessary since the message is an indicator about where it was logged from. The message itself is generally more important than where it was from, too.
2019-06-04 01:37:36 -07:00
TRACEREF("ALCcontext %p decreasing refcount to %u\n", context, ref);
Avoid static global initialization functions
2018-12-08 21:58:44 -08:00
ERR("Context %p current for thread being destroyed, possible leak!\n", context);
}
std::atomic<void(*)(ALCcontext*)> ThreadCtxProc{ReleaseThreadCtx};
Separate class and variable definitions
2018-11-18 06:46:50 -08:00
class ThreadCtx {
Avoid using C-style TLS
2018-11-16 21:55:11 -08:00
ALCcontext *ctx{nullptr};
public:
~ThreadCtx()
{
auto destruct = ThreadCtxProc.load();
if(destruct && ctx)
destruct(ctx);
ctx = nullptr;
}
ALCcontext *get() const noexcept { return ctx; }
void set(ALCcontext *ctx_) noexcept { ctx = ctx_; }
Separate class and variable definitions
2018-11-18 06:46:50 -08:00
};
thread_local ThreadCtx LocalContext;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* Process-wide current context */
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::atomic<ALCcontext*> GlobalContext{nullptr};
Add some macros for logging at various levels, and use them
2011-07-10 21:30:25 -07:00
Add an option to trap device errors in a debugger
2011-09-10 01:23:59 -07:00
/* Flag to trap ALC device errors */
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
bool TrapALCError{false};
Add an option to trap device errors in a debugger
2011-09-10 01:23:59 -07:00
Move some functions into a separate helper source file
2011-08-20 03:59:46 -07:00
/* One-time configuration init control */
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::once_flag alc_config_once{};
Move some functions into a separate helper source file
2011-08-20 03:59:46 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* Default effect that applies to sources that don't have an effect on send 0 */
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
ALeffect DefaultEffect;
Add a global option to apply a reverb effect on source send 0 A special slot on the device is created and processed, so it can be shared across all contexts on the device. Sources that don't have a slot set on send 0 will use this special slot instead.
2012-01-19 19:30:03 -08:00
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
/* Flag to specify if alcSuspendContext/alcProcessContext should defer/process
* updates.
*/
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
bool SuspendDefers{true};
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* ALC information
************************************************/
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr ALCchar alcNoDeviceExtList[] =
Spread out the ALC extensions like the AL extensions
2019-04-01 21:41:11 -07:00
"ALC_ENUMERATE_ALL_EXT "
"ALC_ENUMERATION_EXT "
"ALC_EXT_CAPTURE "
"ALC_EXT_thread_local_context "
"ALC_SOFT_loopback";
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr ALCchar alcExtensionList[] =
Spread out the ALC extensions like the AL extensions
2019-04-01 21:41:11 -07:00
"ALC_ENUMERATE_ALL_EXT "
"ALC_ENUMERATION_EXT "
"ALC_EXT_CAPTURE "
"ALC_EXT_DEDICATED "
"ALC_EXT_disconnect "
"ALC_EXT_EFX "
"ALC_EXT_thread_local_context "
"ALC_SOFT_device_clock "
"ALC_SOFT_HRTF "
"ALC_SOFT_loopback "
"ALC_SOFT_output_limiter "
"ALC_SOFT_pause_device";
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr ALCint alcMajorVersion = 1;
constexpr ALCint alcMinorVersion = 1;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr ALCint alcEFXMajorVersion = 1;
constexpr ALCint alcEFXMinorVersion = 0;
Initial import
2007-11-13 18:02:18 -08:00
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
/* To avoid extraneous allocations, a 0-sized FlexArray<ALCcontext*> is defined
* globally as a sharable object.
*/
al::FlexArray<ALCcontext*> EmptyContextArray{0u};
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
void ALCdevice_IncRef(ALCdevice *device)
{
auto ref = IncrementRef(&device->ref);
TRACEREF("ALCdevice %p increasing refcount to %u\n", device, ref);
}
void ALCdevice_DecRef(ALCdevice *device)
{
auto ref = DecrementRef(&device->ref);
TRACEREF("ALCdevice %p decreasing refcount to %u\n", device, ref);
if(UNLIKELY(ref == 0)) delete device;
}
/* Simple RAII device reference. Takes the reference of the provided ALCdevice,
* and decrements it when leaving scope. Movable (transfer reference) but not
* copyable (no new references).
*/
class DeviceRef {
ALCdevice *mDev{nullptr};
void reset() noexcept
{
if(mDev)
ALCdevice_DecRef(mDev);
mDev = nullptr;
}
public:
DeviceRef() noexcept = default;
DeviceRef(DeviceRef&& rhs) noexcept : mDev{rhs.mDev}
{ rhs.mDev = nullptr; }
explicit DeviceRef(ALCdevice *dev) noexcept : mDev(dev) { }
~DeviceRef() { reset(); }
DeviceRef& operator=(const DeviceRef&) = delete;
DeviceRef& operator=(DeviceRef&& rhs) noexcept
{
std::swap(mDev, rhs.mDev);
return *this;
}
operator bool() const noexcept { return mDev != nullptr; }
ALCdevice* operator->() const noexcept { return mDev; }
ALCdevice* get() const noexcept { return mDev; }
ALCdevice* release() noexcept
{
ALCdevice *ret{mDev};
mDev = nullptr;
return ret;
}
};
inline bool operator==(const DeviceRef &lhs, const ALCdevice *rhs) noexcept
{ return lhs.get() == rhs; }
inline bool operator!=(const DeviceRef &lhs, const ALCdevice *rhs) noexcept
{ return !(lhs == rhs); }
inline bool operator<(const DeviceRef &lhs, const ALCdevice *rhs) noexcept
{ return lhs.get() < rhs; }
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Device lists
************************************************/
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
al::vector<DeviceRef> DeviceList;
al::vector<ContextRef> ContextList;
Make a function static
2010-12-02 01:05:29 -08:00
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::recursive_mutex ListLock;
Get rid of deinit code duplication
2009-09-12 17:29:35 -07:00
Put some static functions in an anonymous namespace
2019-06-29 12:16:38 -07:00
void alc_initconfig(void)
Separate config init from library init OSX has a bug where the file descriptor resource limit can't be increased once certain functions (such as fopen) are used. Since lib initialization happens in a global constructor and includes opening and parsing config files, it prevents apps from being able to increase the rlimit once the lib is loaded, which is usually before main(). By delaying config init, it allows apps the opportunity to change the rlimit before calling certain OpenAL functions.
2011-06-14 09:43:33 -07:00
{
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
const char *str{getenv("ALSOFT_LOGLEVEL")};
Add some macros for logging at various levels, and use them
2011-07-10 21:30:25 -07:00
if(str)
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
long lvl = strtol(str, nullptr, 0);
Make a separate log level to trace reference counts, to avoid log spam for traces
2011-09-20 12:24:23 -07:00
if(lvl >= NoLog && lvl <= LogRef)
Rename a couple global variables Avoid clashing with an enum name
2018-12-09 15:07:44 -08:00
gLogLevel = static_cast<LogLevel>(lvl);
Add some macros for logging at various levels, and use them
2011-07-10 21:30:25 -07:00
}
Open the log file with config initialization
2011-06-17 18:54:05 -07:00
str = getenv("ALSOFT_LOGFILE");
if(str && str[0])
{
Get rid of the last few al_fopen calls
2018-11-10 04:27:10 -08:00
#ifdef _WIN32
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
std::wstring wname{utf8_to_wstr(str)};
FILE *logfile = _wfopen(wname.c_str(), L"wt");
Get rid of the last few al_fopen calls
2018-11-10 04:27:10 -08:00
#else
FILE *logfile = fopen(str, "wt");
#endif
Rename a couple global variables Avoid clashing with an enum name
2018-12-09 15:07:44 -08:00
if(logfile) gLogFile = logfile;
Rename the ERROR macro to ERR
2011-07-13 01:43:00 -07:00
else ERR("Failed to open log file '%s'\n", str);
Open the log file with config initialization
2011-06-17 18:54:05 -07:00
}
Use a range-for loop to concatenate available backends
2019-06-29 10:23:29 -07:00
TRACE("Initializing library v%s-%s %s\n", ALSOFT_VERSION, ALSOFT_GIT_COMMIT_HASH,
ALSOFT_GIT_BRANCH);
Trace the list of supported backends
2012-12-04 13:46:51 -08:00
{
Avoid a fixed-size string buffer
2018-11-18 07:00:43 -08:00
std::string names;
Use a range-for loop to concatenate available backends
2019-06-29 10:23:29 -07:00
if(std::begin(BackendList) == BackendListEnd)
names += "(none)";
else
Avoid a fixed-size string buffer
2018-11-18 07:00:43 -08:00
{
Use a range-for loop to concatenate available backends
2019-06-29 10:23:29 -07:00
const al::span<const BackendInfo> infos{std::begin(BackendList), BackendListEnd};
names += infos[0].name;
for(const auto &backend : infos.subspan(1))
{
names += ", ";
names += backend.name;
}
Avoid a fixed-size string buffer
2018-11-18 07:00:43 -08:00
}
TRACE("Supported backends: %s\n", names.c_str());
Trace the list of supported backends
2012-12-04 13:46:51 -08:00
}
Make sure the log file is set before initializing the rest of the lib
2010-06-08 02:02:48 -07:00
ReadALConfig();
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
str = getenv("__ALSOFT_SUSPEND_CONTEXT");
if(str && *str)
{
if(strcasecmp(str, "ignore") == 0)
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
SuspendDefers = false;
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
TRACE("Selected context suspend behavior, \"ignore\"\n");
}
else
ERR("Unhandled context suspend behavior setting: \"%s\"\n", str);
}
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
int capfilter{0};
Add SSE2 and SSE4.1 linear resamplers Currently the only way SSE 4.1 is detected is by using __get_cpuid, i.e. with GCC. Windows' IsProcessorFeaturePresent does not report SSE4.1 capabilities.
2014-06-04 02:57:13 -07:00
#if defined(HAVE_SSE4_1)
Move the FIR4 from SSE2 to SSE3 SSE3 can avoid the slow _MM_TRANSPOSE_PS4 call thanks to the inclusion of horizontal adds.
2015-10-11 06:38:00 -07:00
capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3 | CPU_CAP_SSE4_1;
#elif defined(HAVE_SSE3)
capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3;
Add SSE2 and SSE4.1 linear resamplers Currently the only way SSE 4.1 is detected is by using __get_cpuid, i.e. with GCC. Windows' IsProcessorFeaturePresent does not report SSE4.1 capabilities.
2014-06-04 02:57:13 -07:00
#elif defined(HAVE_SSE2)
Check for SSE2 and set the denormals-are-zero bit for mixing if available
2013-05-22 16:59:20 -07:00
capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2;
Add SSE2 and SSE4.1 linear resamplers Currently the only way SSE 4.1 is detected is by using __get_cpuid, i.e. with GCC. Windows' IsProcessorFeaturePresent does not report SSE4.1 capabilities.
2014-06-04 02:57:13 -07:00
#elif defined(HAVE_SSE)
capfilter |= CPU_CAP_SSE;
Add cmake options to disable or require support for CPU extensions
2012-08-15 01:24:50 -07:00
#endif
#ifdef HAVE_NEON
capfilter |= CPU_CAP_NEON;
#endif
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
if(auto cpuopt = ConfigValueStr(nullptr, nullptr, "disable-cpu-exts"))
Add a config option to disable use of CPU extensions
2012-08-13 10:37:49 -07:00
{
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
str = cpuopt->c_str();
Add a config option to disable use of CPU extensions
2012-08-13 10:37:49 -07:00
if(strcasecmp(str, "all") == 0)
capfilter = 0;
else
{
const char *next = str;
do {
str = next;
while(isspace(str[0]))
str++;
Better handle spaces between string list entries
2013-06-16 15:44:41 -07:00
next = strchr(str, ',');
Add a config option to disable use of CPU extensions
2012-08-13 10:37:49 -07:00
if(!str[0] || str[0] == ',')
continue;
Avoid using old style casts To think about: examples/alffplay.cpp:600 OpenAL32/Include/alMain.h:295
2019-01-08 19:42:44 +01:00
size_t len{next ? static_cast<size_t>(next-str) : strlen(str)};
Better handle spaces between string list entries
2013-06-16 15:44:41 -07:00
while(len > 0 && isspace(str[len-1]))
len--;
if(len == 3 && strncasecmp(str, "sse", len) == 0)
Add an SSE-enhanced HRTF mixer using intrinsics Not as good as it could be, but it's something
2012-08-14 03:53:07 -07:00
capfilter &= ~CPU_CAP_SSE;
Better handle spaces between string list entries
2013-06-16 15:44:41 -07:00
else if(len == 4 && strncasecmp(str, "sse2", len) == 0)
Check for SSE2 and set the denormals-are-zero bit for mixing if available
2013-05-22 16:59:20 -07:00
capfilter &= ~CPU_CAP_SSE2;
Move the FIR4 from SSE2 to SSE3 SSE3 can avoid the slow _MM_TRANSPOSE_PS4 call thanks to the inclusion of horizontal adds.
2015-10-11 06:38:00 -07:00
else if(len == 4 && strncasecmp(str, "sse3", len) == 0)
capfilter &= ~CPU_CAP_SSE3;
Add SSE2 and SSE4.1 linear resamplers Currently the only way SSE 4.1 is detected is by using __get_cpuid, i.e. with GCC. Windows' IsProcessorFeaturePresent does not report SSE4.1 capabilities.
2014-06-04 02:57:13 -07:00
else if(len == 6 && strncasecmp(str, "sse4.1", len) == 0)
capfilter &= ~CPU_CAP_SSE4_1;
Better handle spaces between string list entries
2013-06-16 15:44:41 -07:00
else if(len == 4 && strncasecmp(str, "neon", len) == 0)
Add a config option to disable use of CPU extensions
2012-08-13 10:37:49 -07:00
capfilter &= ~CPU_CAP_NEON;
else
WARN("Invalid CPU extension \"%s\"\n", str);
} while(next++);
}
}
FillCPUCaps(capfilter);
Use real-time priority by default on Windows It's actually "time-critical", but it seems normal priority doesn't cope as well when the system is under moderate load.
2011-07-23 05:44:55 -07:00
#ifdef _WIN32
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
#define DEF_MIXER_PRIO 1
Use real-time priority by default on Windows It's actually "time-critical", but it seems normal priority doesn't cope as well when the system is under moderate load.
2011-07-23 05:44:55 -07:00
#else
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
#define DEF_MIXER_PRIO 0
Use real-time priority by default on Windows It's actually "time-critical", but it seems normal priority doesn't cope as well when the system is under moderate load.
2011-07-23 05:44:55 -07:00
#endif
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
RTPrioLevel = ConfigValueInt(nullptr, nullptr, "rt-prio").value_or(DEF_MIXER_PRIO);
#undef DEF_MIXER_PRIO
Add an option for real-time priority mixing Default to disable for now, as a safety precaution
2009-12-01 23:15:09 -08:00
Avoid re-selecting the direct HRTF mix function
2017-08-07 01:38:26 -07:00
aluInit();
Don't keep selecting the mixer to use
2015-09-27 20:55:39 -07:00
aluInitMixer();
Add an option for point resampling
2010-01-11 05:37:20 -08:00
Read ALSOFT_TRAP_*ERROR when reading the config
2012-04-16 20:13:50 -07:00
str = getenv("ALSOFT_TRAP_ERROR");
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(str && (strcasecmp(str, "true") == 0 || strtol(str, nullptr, 0) == 1))
Read ALSOFT_TRAP_*ERROR when reading the config
2012-04-16 20:13:50 -07:00
{
Use a bool for the TrapALError flag
2019-06-29 11:22:29 -07:00
TrapALError = true;
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
TrapALCError = true;
Read ALSOFT_TRAP_*ERROR when reading the config
2012-04-16 20:13:50 -07:00
}
else
{
str = getenv("ALSOFT_TRAP_AL_ERROR");
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(str && (strcasecmp(str, "true") == 0 || strtol(str, nullptr, 0) == 1))
Use a bool for the TrapALError flag
2019-06-29 11:22:29 -07:00
TrapALError = true;
TrapALError = !!GetConfigValueBool(nullptr, nullptr, "trap-al-error", TrapALError);
Add an option to trap device errors in a debugger
2011-09-10 01:23:59 -07:00
Read ALSOFT_TRAP_*ERROR when reading the config
2012-04-16 20:13:50 -07:00
str = getenv("ALSOFT_TRAP_ALC_ERROR");
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(str && (strcasecmp(str, "true") == 0 || strtol(str, nullptr, 0) == 1))
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
TrapALCError = true;
TrapALCError = !!GetConfigValueBool(nullptr, nullptr, "trap-alc-error", TrapALCError);
Read ALSOFT_TRAP_*ERROR when reading the config
2012-04-16 20:13:50 -07:00
}
Add an option to trap context errors in a debugger
2011-09-10 01:12:34 -07:00
Return optionals from the remaining ConfigValue* methods
2019-06-30 16:38:25 -07:00
if(auto boostopt = ConfigValueFloat(nullptr, "reverb", "boost"))
{
const float valf{std::isfinite(*boostopt) ? clampf(*boostopt, -24.0f, 24.0f) : 0.0f};
Use std::pow and std::log2
2018-11-14 17:01:19 -08:00
ReverbBoost *= std::pow(10.0f, valf / 20.0f);
Return optionals from the remaining ConfigValue* methods
2019-06-30 16:38:25 -07:00
}
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
auto devopt = ConfigValueStr(nullptr, nullptr, "drivers");
if(const char *devs{getenv("ALSOFT_DRIVERS")})
{
if(devs[0])
devopt = al::optional<std::string>{al::in_place, devs};
}
if(devopt)
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
{
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
auto backendlist_cur = std::begin(BackendList);
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
bool endlist{true};
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
const char *next{devopt->c_str()};
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
do {
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
const char *devs{next};
Better handle spaces between string list entries
2013-06-16 15:44:41 -07:00
while(isspace(devs[0]))
devs++;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
next = strchr(devs, ',');
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
const bool delitem{devs[0] == '-'};
Allow prepending backend names with - to remove them from the available devices
2010-06-05 19:33:06 -07:00
if(devs[0] == '-') devs++;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
if(!devs[0] || devs[0] == ',')
Allow unlisted backends to stay available when the drivers list ends with ,
2009-11-22 01:06:05 -08:00
{
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
endlist = false;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
continue;
Allow unlisted backends to stay available when the drivers list ends with ,
2009-11-22 01:06:05 -08:00
}
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
endlist = true;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
size_t len{next ? (static_cast<size_t>(next-devs)) : strlen(devs)};
while(len > 0 && isspace(devs[len-1])) --len;
Rename the mmdevapi backend to wasapi
2018-03-09 18:56:24 -08:00
#ifdef HAVE_WASAPI
/* HACK: For backwards compatibility, convert backend references of
* mmdevapi to wasapi. This should eventually be removed.
*/
if(len == 8 && strncmp(devs, "mmdevapi", len) == 0)
{
devs = "wasapi";
len = 6;
}
#endif
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
auto find_backend = [devs,len](const BackendInfo &backend) -> bool
{ return len == strlen(backend.name) && strncmp(backend.name, devs, len) == 0; };
auto this_backend = std::find_if(std::begin(BackendList), 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);
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
} while(next++);
Allow unlisted backends to stay available when the drivers list ends with ,
2009-11-22 01:06:05 -08:00
if(endlist)
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
BackendListEnd = backendlist_cur;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
}
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
auto init_backend = [](BackendInfo &backend) -> bool
Remove backends that fail to initialize
2011-08-17 06:15:43 -07:00
{
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
if(PlaybackFactory && CaptureFactory)
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
return true;
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
BackendFactory &factory = backend.getFactory();
Start a new backend factory API Using proper class inheritance. Be aware this breaks all backends except null (and loopback). They will be restored individually in due time.
2018-11-15 19:15:14 -08:00
if(!factory.init())
Use separate lists for playback and capture backends
2011-08-19 00:23:26 -07:00
{
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
WARN("Failed to initialize backend \"%s\"\n", backend.name);
return true;
Don't remove backends that fail to initialize
2011-08-19 01:54:55 -07:00
}
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
TRACE("Initialized backend \"%s\"\n", backend.name);
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
if(!PlaybackFactory && factory.querySupport(BackendType::Playback))
Don't remove backends that fail to initialize
2011-08-19 01:54:55 -07:00
{
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
PlaybackFactory = &factory;
TRACE("Added \"%s\" for playback\n", backend.name);
Use separate lists for playback and capture backends
2011-08-19 00:23:26 -07:00
}
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
if(!CaptureFactory && factory.querySupport(BackendType::Capture))
Remove backends that fail to initialize
2011-08-17 06:15:43 -07:00
{
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
CaptureFactory = &factory;
TRACE("Added \"%s\" for capture\n", backend.name);
Remove backends that fail to initialize
2011-08-17 06:15:43 -07:00
}
Simplify sorting and initializing the backends
2019-04-11 02:49:13 -07:00
return false;
};
BackendListEnd = std::remove_if(std::begin(BackendList), BackendListEnd, init_backend);
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
Update the loopback backend
2018-11-15 19:42:13 -08:00
LoopbackBackendFactory::getFactory().init();
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
if(!PlaybackFactory)
Don't crash when there's no backend to probe
2016-04-30 17:14:55 -07:00
WARN("No playback backend available!\n");
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
if(!CaptureFactory)
Don't crash when there's no backend to probe
2016-04-30 17:14:55 -07:00
WARN("No capture backend available!\n");
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
if(auto exclopt = ConfigValueStr(nullptr, nullptr, "excludefx"))
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
{
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
const char *next{exclopt->c_str()};
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
do {
str = next;
next = strchr(str, ',');
Add a method to deinitialize backends
2009-08-26 23:45:00 -07:00
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
if(!str[0] || next == str)
continue;
Avoid using old style casts To think about: examples/alffplay.cpp:600 OpenAL32/Include/alMain.h:295
2019-01-08 19:42:44 +01:00
size_t len{next ? static_cast<size_t>(next-str) : strlen(str)};
Get rid of the COUNTOF macro
2019-05-26 21:28:51 -07:00
for(const EffectList &effectitem : gEffectList)
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
{
Get rid of the COUNTOF macro
2019-05-26 21:28:51 -07:00
if(len == strlen(effectitem.name) &&
strncmp(effectitem.name, str, len) == 0)
DisabledEffects[effectitem.type] = AL_TRUE;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
}
} while(next++);
}
Add a global option to apply a reverb effect on source send 0 A special slot on the device is created and processed, so it can be shared across all contexts on the device. Sources that don't have a slot set on send 0 will use this special slot instead.
2012-01-19 19:30:03 -08:00
Rename ForcedEffect to DefaultEffect
2012-03-13 14:38:09 -07:00
InitEffect(&DefaultEffect);
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
auto defrevopt = ConfigValueStr(nullptr, nullptr, "default-reverb");
if((str=getenv("ALSOFT_DEFAULT_REVERB")) && str[0])
defrevopt = al::optional<std::string>{al::in_place, str};
if(defrevopt) LoadReverbPreset(defrevopt->c_str(), &DefaultEffect);
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
}
Put a lambda in the call_once call This optimizes better and avoids a visible symbol (templating to an anonymous lambda type will generate a unique anonymous instantiation, making inlining more likely, whereas passing a general function pointer/reference type will likely use or generate a publically available instance).
2018-11-16 22:41:04 -08:00
#define DO_INITCONFIG() std::call_once(alc_config_once, [](){alc_initconfig();})
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Device enumeration
************************************************/
Put some static functions in an anonymous namespace
2019-06-29 12:16:38 -07:00
void ProbeAllDevicesList()
Rebuild device lists when retrieving them
2009-08-27 06:09:33 -07:00
{
Lock the lists while probing devices
2011-09-10 09:12:02 -07:00
DO_INITCONFIG();
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::lock_guard<std::recursive_mutex> _{ListLock};
Avoid a generic function for specialized behavior
2019-06-29 11:45:55 -07:00
alcAllDevicesList.clear();
if(PlaybackFactory)
PlaybackFactory->probe(DevProbe::Playback, &alcAllDevicesList);
}
Put some static functions in an anonymous namespace
2019-06-29 12:16:38 -07:00
void ProbeCaptureDeviceList()
Avoid a generic function for specialized behavior
2019-06-29 11:45:55 -07:00
{
DO_INITCONFIG();
std::lock_guard<std::recursive_mutex> _{ListLock};
alcCaptureDeviceList.clear();
if(CaptureFactory)
CaptureFactory->probe(DevProbe::Capture, &alcCaptureDeviceList);
Rebuild device lists when retrieving them
2009-08-27 06:09:33 -07:00
}
Put some static functions in an anonymous namespace
2019-06-29 12:16:38 -07:00
} // namespace
/* Mixing thread piority level */
ALint RTPrioLevel;
FILE *gLogFile{stderr};
#ifdef _DEBUG
LogLevel gLogLevel{LogWarning};
#else
LogLevel gLogLevel{LogError};
#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,
(WCHAR*)module, &module);
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
#endif
Initial import
2007-11-13 18:02:18 -08:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Device format information
************************************************/
Don't hardcode the channel count from the device ambisonic order
2018-12-19 03:13:15 -08:00
const ALCchar *DevFmtTypeString(DevFmtType type) noexcept
Add functions to get strings from the device format
2011-05-15 04:03:15 -07:00
{
switch(type)
{
case DevFmtByte: return "Signed Byte";
case DevFmtUByte: return "Unsigned Byte";
case DevFmtShort: return "Signed Short";
case DevFmtUShort: return "Unsigned Short";
Support signed and unsigned 32-bit int output
2012-02-14 11:44:57 -08:00
case DevFmtInt: return "Signed Int";
case DevFmtUInt: return "Unsigned Int";
Add functions to get strings from the device format
2011-05-15 04:03:15 -07:00
case DevFmtFloat: return "Float";
}
return "(unknown type)";
}
Don't hardcode the channel count from the device ambisonic order
2018-12-19 03:13:15 -08:00
const ALCchar *DevFmtChannelsString(DevFmtChannels chans) noexcept
Add functions to get strings from the device format
2011-05-15 04:03:15 -07:00
{
switch(chans)
{
case DevFmtMono: return "Mono";
case DevFmtStereo: return "Stereo";
Rename Quad to Quadraphonic
2011-05-24 14:34:53 -07:00
case DevFmtQuad: return "Quadraphonic";
Add functions to get strings from the device format
2011-05-15 04:03:15 -07:00
case DevFmtX51: return "5.1 Surround";
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
case DevFmtX51Rear: return "5.1 Surround (Rear)";
Add functions to get strings from the device format
2011-05-15 04:03:15 -07:00
case DevFmtX61: return "6.1 Surround";
case DevFmtX71: return "7.1 Surround";
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
case DevFmtAmbi3D: return "Ambisonic 3D";
Add functions to get strings from the device format
2011-05-15 04:03:15 -07:00
}
return "(unknown channels)";
}
Don't hardcode the channel count from the device ambisonic order
2018-12-19 03:13:15 -08:00
ALsizei BytesFromDevFmt(DevFmtType type) noexcept
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
{
switch(type)
{
case DevFmtByte: return sizeof(ALbyte);
case DevFmtUByte: return sizeof(ALubyte);
case DevFmtShort: return sizeof(ALshort);
case DevFmtUShort: return sizeof(ALushort);
Support signed and unsigned 32-bit int output
2012-02-14 11:44:57 -08:00
case DevFmtInt: return sizeof(ALint);
case DevFmtUInt: return sizeof(ALuint);
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
case DevFmtFloat: return sizeof(ALfloat);
}
return 0;
}
Don't hardcode the channel count from the device ambisonic order
2018-12-19 03:13:15 -08:00
ALsizei ChannelsFromDevFmt(DevFmtChannels chans, ALsizei ambiorder) noexcept
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
{
switch(chans)
{
case DevFmtMono: return 1;
case DevFmtStereo: return 2;
case DevFmtQuad: return 4;
case DevFmtX51: return 6;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
case DevFmtX51Rear: return 6;
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
case DevFmtX61: return 7;
case DevFmtX71: return 8;
Don't hardcode the channel count from the device ambisonic order
2018-12-19 03:13:15 -08:00
case DevFmtAmbi3D: return (ambiorder+1) * (ambiorder+1);
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
}
return 0;
}
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Use optionals where methods may not return a valid value
2019-06-30 16:57:10 -07:00
struct DevFmtPair { DevFmtChannels chans; DevFmtType type; };
static al::optional<DevFmtPair> DecomposeDevFormat(ALenum format)
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
{
Use arrays instead of large switches to decompose formats
2011-09-18 19:06:19 -07:00
static const struct {
ALenum format;
Remove extraneous typedef, struct, and enum keywords
2018-12-24 19:29:01 -08:00
DevFmtChannels channels;
DevFmtType type;
Use arrays instead of large switches to decompose formats
2011-09-18 19:06:19 -07:00
} list[] = {
{ AL_FORMAT_MONO8, DevFmtMono, DevFmtUByte },
{ AL_FORMAT_MONO16, DevFmtMono, DevFmtShort },
{ AL_FORMAT_MONO_FLOAT32, DevFmtMono, DevFmtFloat },
{ AL_FORMAT_STEREO8, DevFmtStereo, DevFmtUByte },
{ AL_FORMAT_STEREO16, DevFmtStereo, DevFmtShort },
{ AL_FORMAT_STEREO_FLOAT32, DevFmtStereo, DevFmtFloat },
{ AL_FORMAT_QUAD8, DevFmtQuad, DevFmtUByte },
{ AL_FORMAT_QUAD16, DevFmtQuad, DevFmtShort },
{ AL_FORMAT_QUAD32, DevFmtQuad, DevFmtFloat },
{ AL_FORMAT_51CHN8, DevFmtX51, DevFmtUByte },
{ AL_FORMAT_51CHN16, DevFmtX51, DevFmtShort },
{ AL_FORMAT_51CHN32, DevFmtX51, DevFmtFloat },
{ AL_FORMAT_61CHN8, DevFmtX61, DevFmtUByte },
{ AL_FORMAT_61CHN16, DevFmtX61, DevFmtShort },
{ AL_FORMAT_61CHN32, DevFmtX61, DevFmtFloat },
{ AL_FORMAT_71CHN8, DevFmtX71, DevFmtUByte },
{ AL_FORMAT_71CHN16, DevFmtX71, DevFmtShort },
{ AL_FORMAT_71CHN32, DevFmtX71, DevFmtFloat },
};
Get rid of the COUNTOF macro
2019-05-26 21:28:51 -07:00
for(const auto &item : list)
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
{
Get rid of the COUNTOF macro
2019-05-26 21:28:51 -07:00
if(item.format == format)
Use optionals where methods may not return a valid value
2019-06-30 16:57:10 -07:00
return al::optional<DevFmtPair>{al::in_place, DevFmtPair{item.channels, item.type}};
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
}
Use arrays instead of large switches to decompose formats
2011-09-18 19:06:19 -07:00
Use optionals where methods may not return a valid value
2019-06-30 16:57:10 -07:00
return al::nullopt;
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
}
Remove use of DECL_CONST No idea if it was really gaining us anything, but removing it fixes a crash I was getting with libs built with Clang.
2016-09-06 09:09:25 -07:00
static ALCboolean IsValidALCType(ALCenum type)
Use separate functions to find valid ALC loopback device formats
2011-07-02 02:51:33 -07:00
{
switch(type)
{
Append _SOFT to the ALC loopback format enums
2011-11-01 16:00:47 -07:00
case ALC_BYTE_SOFT:
case ALC_UNSIGNED_BYTE_SOFT:
case ALC_SHORT_SOFT:
case ALC_UNSIGNED_SHORT_SOFT:
case ALC_INT_SOFT:
case ALC_UNSIGNED_INT_SOFT:
case ALC_FLOAT_SOFT:
Use separate functions to find valid ALC loopback device formats
2011-07-02 02:51:33 -07:00
return ALC_TRUE;
}
return ALC_FALSE;
}
Remove use of DECL_CONST No idea if it was really gaining us anything, but removing it fixes a crash I was getting with libs built with Clang.
2016-09-06 09:09:25 -07:00
static ALCboolean IsValidALCChannels(ALCenum channels)
Use separate functions to find valid ALC loopback device formats
2011-07-02 02:51:33 -07:00
{
switch(channels)
{
Append _SOFT to the ALC loopback format enums
2011-11-01 16:00:47 -07:00
case ALC_MONO_SOFT:
case ALC_STEREO_SOFT:
case ALC_QUAD_SOFT:
case ALC_5POINT1_SOFT:
case ALC_6POINT1_SOFT:
case ALC_7POINT1_SOFT:
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
case ALC_BFORMAT3D_SOFT:
Use separate functions to find valid ALC loopback device formats
2011-07-02 02:51:33 -07:00
return ALC_TRUE;
}
return ALC_FALSE;
}
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
static ALCboolean IsValidAmbiLayout(ALCenum layout)
{
switch(layout)
{
case ALC_ACN_SOFT:
case ALC_FUMA_SOFT:
return ALC_TRUE;
}
return ALC_FALSE;
}
static ALCboolean IsValidAmbiScaling(ALCenum scaling)
{
switch(scaling)
{
case ALC_N3D_SOFT:
case ALC_SN3D_SOFT:
case ALC_FUMA_SOFT:
return ALC_TRUE;
}
return ALC_FALSE;
}
Initial import
2007-11-13 18:02:18 -08:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Miscellaneous ALC helpers
************************************************/
Don't store the HRTF request mode in the device flags
2015-09-05 01:32:12 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* SetDefaultWFXChannelOrder
*
* Sets the default channel order used by WaveFormatEx.
*/
void SetDefaultWFXChannelOrder(ALCdevice *device)
{
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex.fill(-1);
Use an array to specify the offset for each channel of the device buffer This effectively inverts the DevChannels array
2012-11-04 04:41:11 -08:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
switch(device->FmtChans)
{
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
case DevFmtMono:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontCenter] = 0;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
break;
case DevFmtStereo:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
break;
case DevFmtQuad:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
device->RealOut.ChannelIndex[BackLeft] = 2;
device->RealOut.ChannelIndex[BackRight] = 3;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
break;
case DevFmtX51:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
device->RealOut.ChannelIndex[FrontCenter] = 2;
device->RealOut.ChannelIndex[LFE] = 3;
device->RealOut.ChannelIndex[SideLeft] = 4;
device->RealOut.ChannelIndex[SideRight] = 5;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
break;
case DevFmtX51Rear:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
device->RealOut.ChannelIndex[FrontCenter] = 2;
device->RealOut.ChannelIndex[LFE] = 3;
device->RealOut.ChannelIndex[BackLeft] = 4;
device->RealOut.ChannelIndex[BackRight] = 5;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
break;
case DevFmtX61:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
device->RealOut.ChannelIndex[FrontCenter] = 2;
device->RealOut.ChannelIndex[LFE] = 3;
device->RealOut.ChannelIndex[BackCenter] = 4;
device->RealOut.ChannelIndex[SideLeft] = 5;
device->RealOut.ChannelIndex[SideRight] = 6;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
break;
case DevFmtX71:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
device->RealOut.ChannelIndex[FrontCenter] = 2;
device->RealOut.ChannelIndex[LFE] = 3;
device->RealOut.ChannelIndex[BackLeft] = 4;
device->RealOut.ChannelIndex[BackRight] = 5;
device->RealOut.ChannelIndex[SideLeft] = 6;
device->RealOut.ChannelIndex[SideRight] = 7;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
break;
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
case DevFmtAmbi3D:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[Aux0] = 0;
Avoid more cases of an enum variable and type name clash
2018-11-18 08:01:50 -08:00
if(device->mAmbiOrder > 0)
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
{
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[Aux1] = 1;
device->RealOut.ChannelIndex[Aux2] = 2;
device->RealOut.ChannelIndex[Aux3] = 3;
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
}
Avoid more cases of an enum variable and type name clash
2018-11-18 08:01:50 -08:00
if(device->mAmbiOrder > 1)
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
{
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[Aux4] = 4;
device->RealOut.ChannelIndex[Aux5] = 5;
device->RealOut.ChannelIndex[Aux6] = 6;
device->RealOut.ChannelIndex[Aux7] = 7;
device->RealOut.ChannelIndex[Aux8] = 8;
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
}
Avoid more cases of an enum variable and type name clash
2018-11-18 08:01:50 -08:00
if(device->mAmbiOrder > 2)
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
{
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[Aux9] = 9;
device->RealOut.ChannelIndex[Aux10] = 10;
device->RealOut.ChannelIndex[Aux11] = 11;
device->RealOut.ChannelIndex[Aux12] = 12;
device->RealOut.ChannelIndex[Aux13] = 13;
device->RealOut.ChannelIndex[Aux14] = 14;
device->RealOut.ChannelIndex[Aux15] = 15;
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
}
Add a config to output first-, second-, or third-order ambisonics Currently incomplete, as second- and third-order output will not correctly handle B-Format input buffers. A standalone up-sampler will be needed, similar to the high-quality decoder. Also, output is ACN ordering with SN3D normalization. A config option will eventually be provided to change this if desired.
2016-07-29 21:55:43 -07:00
break;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
}
/* SetDefaultChannelOrder
*
* Sets the default channel order used by most non-WaveFormatEx-based APIs.
*/
void SetDefaultChannelOrder(ALCdevice *device)
{
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex.fill(-1);
Use an array to specify the offset for each channel of the device buffer This effectively inverts the DevChannels array
2012-11-04 04:41:11 -08:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
switch(device->FmtChans)
{
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
case DevFmtX51Rear:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
device->RealOut.ChannelIndex[BackLeft] = 2;
device->RealOut.ChannelIndex[BackRight] = 3;
device->RealOut.ChannelIndex[FrontCenter] = 4;
device->RealOut.ChannelIndex[LFE] = 5;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
return;
case DevFmtX71:
Change RealMixParams::ChannelName to better reflect its use
2019-04-02 15:53:27 -07:00
device->RealOut.ChannelIndex[FrontLeft] = 0;
device->RealOut.ChannelIndex[FrontRight] = 1;
device->RealOut.ChannelIndex[BackLeft] = 2;
device->RealOut.ChannelIndex[BackRight] = 3;
device->RealOut.ChannelIndex[FrontCenter] = 4;
device->RealOut.ChannelIndex[LFE] = 5;
device->RealOut.ChannelIndex[SideLeft] = 6;
device->RealOut.ChannelIndex[SideRight] = 7;
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
return;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* Same as WFX order */
case DevFmtMono:
case DevFmtStereo:
case DevFmtQuad:
Fix 5.1 surround sound Apparently, 5.1 surround sound is supposed to use the "side" channels, not the back channels, and we've been wrong this whole time. That means the "5.1 Side" is actually the correct 5.1 setup, and using the back channels is anomalous. Additionally, this means the 5.1 buffer format should also use the the side channels instead of the back channels. A final note: the 5.1 mixing coefficients are changed so both use the original 5.1 surround sound set (with the surround channels at +/-110 degrees). So the only difference now between 5.1 "side" and 5.1 "back" is the channel labels.
2014-11-07 00:54:16 -08:00
case DevFmtX51:
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
case DevFmtX61:
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
case DevFmtAmbi3D:
Invert the ChannelOffsets array
2014-09-10 16:52:54 -07:00
SetDefaultWFXChannelOrder(device);
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
break;
}
}
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
/* ALCcontext_DeferUpdates
*
* Defers/suspends updates for the given context's listener and sources. This
* does *NOT* stop mixing, but rather prevents certain property changes from
* taking effect.
*/
Don't defer source state or offset changes
2017-03-19 13:48:40 -07:00
void ALCcontext_DeferUpdates(ALCcontext *context)
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
{
Use atomic_flags and atomic<bools>s where appropriate
2018-11-20 10:45:01 -08:00
context->DeferUpdates.store(true);
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
}
/* ALCcontext_ProcessUpdates
*
* Resumes update processing after being deferred.
*/
void ALCcontext_ProcessUpdates(ALCcontext *context)
{
Use a standard mutex for the proplock
2018-11-26 21:37:58 -08:00
std::lock_guard<std::mutex> _{context->PropLock};
Use atomic_flags and atomic<bools>s where appropriate
2018-11-20 10:45:01 -08:00
if(context->DeferUpdates.exchange(false))
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
{
Hold updates for both listener and source updates
2016-08-23 19:37:26 -07:00
/* Tell the mixer to stop applying updates, then wait for any active
* updating to finish, before providing updates.
*/
Change a true/false ALenum atomic into a bool
2019-01-09 01:06:19 -08:00
context->HoldUpdates.store(true, std::memory_order_release);
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
while((context->UpdateCount.load(std::memory_order_acquire)&1) != 0)
Remove althrd_yield
2018-11-26 23:06:49 -08:00
std::this_thread::yield();
Hold updates for both listener and source updates
2016-08-23 19:37:26 -07:00
Use atomic_flags and atomic<bools>s where appropriate
2018-11-20 10:45:01 -08:00
if(!context->PropsClean.test_and_set(std::memory_order_acq_rel))
Don't update context and listener props unnecessarily
2017-09-27 09:36:34 -07:00
UpdateContextProps(context);
Use atomic_flags and atomic<bools>s where appropriate
2018-11-20 10:45:01 -08:00
if(!context->Listener.PropsClean.test_and_set(std::memory_order_acq_rel))
Don't update context and listener props unnecessarily
2017-09-27 09:36:34 -07:00
UpdateListenerProps(context);
Properly defer effect slot changes Note that this now also causes all playing sources to update when an effect slot is updated. This is a bit wasteful, as it should only need to re-update sources that are using the effect slot (and only when a relevant property is changed), but it's good enough. Especially with deferring since all playing sources are going to get updated on the process call anyway.
2016-08-25 06:17:36 -07:00
UpdateAllEffectSlotProps(context);
Provide asynchronous property updates for sources This necessitates a change in how source updates are handled. Rather than just being able to update sources when a dependent object state is changed (e.g. a listener gain change), now all source updates must be proactively provided. Consequently, apps that do not utilize any deferring (AL_SOFT_defer_updates or alcSuspendContext/alcProcessContext) may utilize more CPU since it'll be filling out more update containers for the mixer thread to use. The upside is that there's less blocking between the app's calling thread and the mixer thread, particularly for vectors and other multi-value properties (filters and sends). Deferring behavior when used is also improved, since updates that shouldn't be applied yet are simply not provided. And when they are provided, the mixer doesn't have to ignore them, meaning the actual deferring of a context doesn't have to synchrnously force an update -- the process call will send any pending updates, which the mixer will apply even if another deferral occurs before the mixer runs, because it'll still be there waiting on the next mixer invocation. There is one slight bug introduced by this commit. When a listener change is made, or changes to multiple sources while updates are being deferred, it is possible for the mixer to run while the sources are prepping their updates, causing some of the source updates to be seen before the other. This will be fixed in short order.
2016-05-14 23:43:40 -07:00
UpdateAllSourceProps(context);
Hold updates for both listener and source updates
2016-08-23 19:37:26 -07:00
/* Now with all updates declared, let the mixer continue applying them
* so they all happen at once.
*/
Change a true/false ALenum atomic into a bool
2019-01-09 01:06:19 -08:00
context->HoldUpdates.store(false, std::memory_order_release);
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
}
}
Make alcSetError static
2011-09-14 11:58:51 -07:00
/* alcSetError
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Stores the latest ALC device error
Make alcSetError static
2011-09-14 11:58:51 -07:00
*/
static void alcSetError(ALCdevice *device, ALCenum errorCode)
{
Print WARNs when a device or context error is generated
2017-02-27 20:56:34 -08:00
WARN("Error generated on device %p, code 0x%04x\n", device, errorCode);
Make alcSetError static
2011-09-14 11:58:51 -07:00
if(TrapALCError)
{
#ifdef _WIN32
/* DebugBreak() will cause an exception if there is no debugger */
if(IsDebuggerPresent())
DebugBreak();
#elif defined(SIGTRAP)
Use raise(SIGTRAP) instead of kill(getpid(),SIGTRAP)
2011-09-30 20:46:18 -07:00
raise(SIGTRAP);
Make alcSetError static
2011-09-14 11:58:51 -07:00
#endif
}
if(device)
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
device->LastError.store(errorCode);
Make alcSetError static
2011-09-14 11:58:51 -07:00
else
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
LastNullDeviceError.store(errorCode);
Make alcSetError static
2011-09-14 11:58:51 -07:00
}
Make the Compressor more class-like
2018-12-24 09:17:00 -08:00
static std::unique_ptr<Compressor> CreateDeviceLimiter(const ALCdevice *device, const ALfloat threshold)
Add a new compressor/limiter This is just for the output limiter right now, but in the future can be used for the compressor EFX effect. The parameters are also hardcoded, but can be made configurable after 1.18.
2017-05-27 03:36:34 -07:00
{
Update the output limiter/compressor This provides better characteristics for an amplitude limiter. In particular, it utilizes the peak amplitude instead of the RMS, and the used parameters basically guarantee no output samples exceed the given threshold... almost, due to floating-point errors as the threshold is converted from dB to log-e for the envelope, then is negated and converted to linear amplitude to apply to the signal. It's quite possible for some rounding errors to creep in and not perfectly saturate the result.
2018-09-25 10:04:14 -07:00
return CompressorInit(device->RealOut.NumChannels, device->Frequency,
AL_TRUE, AL_TRUE, AL_TRUE, AL_TRUE, AL_TRUE, 0.001f, 0.002f,
Don't hardcode the limiter threshold It's now calculated from the output sample type and dither depth.
2018-09-25 10:29:38 -07:00
0.0f, 0.0f, threshold, INFINITY, 0.0f, 0.020f, 0.200f);
Add a new compressor/limiter This is just for the output limiter right now, but in the future can be used for the compressor EFX effect. The parameters are also hardcoded, but can be made configurable after 1.18.
2017-05-27 03:36:34 -07:00
}
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
/* UpdateClockBase
*
* 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
Increment MixCount in UpdateClockBase This is to protect clocktime reads since the backend lock won't protect it.
2017-02-28 23:18:51 -08:00
* to jump forward or back. Must not be called while the device is running/
* mixing.
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
*/
static inline void UpdateClockBase(ALCdevice *device)
{
Increment MixCount in UpdateClockBase This is to protect clocktime reads since the backend lock won't protect it.
2017-02-28 23:18:51 -08:00
IncrementRef(&device->MixCount);
Remove a couple unnecessary duration_casts
2019-03-26 10:18:02 -07:00
device->ClockBase += nanoseconds{seconds{device->SamplesDone}} / device->Frequency;
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
device->SamplesDone = 0;
Increment MixCount in UpdateClockBase This is to protect clocktime reads since the backend lock won't protect it.
2017-02-28 23:18:51 -08:00
IncrementRef(&device->MixCount);
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
}
Clean up some comments
2011-09-10 09:00:01 -07:00
/* UpdateDeviceParams
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
*
Clean up some comments
2011-09-10 09:00:01 -07:00
* Updates device parameters according to the attribute list (caller is
* responsible for holding the list lock).
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
*/
Return the error code from UpdateDeviceParams
2012-01-25 20:00:34 -08:00
static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Remove extraneous typedef, struct, and enum keywords
2018-12-24 19:29:01 -08:00
HrtfRequestMode hrtf_userreq = Hrtf_Default;
HrtfRequestMode hrtf_appreq = Hrtf_Default;
Don't limit output for ALC_DONT_CARE_SOFT and float samples
2018-10-03 13:48:04 -07:00
ALCenum gainLimiter = device->LimiterState;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
const ALsizei old_sends = device->NumAuxSends;
ALsizei new_sends = device->NumAuxSends;
Remove extraneous typedef, struct, and enum keywords
2018-12-24 19:29:01 -08:00
DevFmtChannels oldChans;
DevFmtType oldType;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
ALboolean update_failed;
ALCsizei hrtf_id = -1;
Remove an unnecessary else statement
2012-01-20 12:20:24 -08:00
ALCuint oldFreq;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if((!attrList || !attrList[0]) && device->Type == Loopback)
{
WARN("Missing attributes for loopback device\n");
return ALC_INVALID_VALUE;
}
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
// Check for attributes
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if(attrList && attrList[0])
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
ALCenum alayout = AL_NONE;
ALCenum ascale = AL_NONE;
ALCenum schans = AL_NONE;
ALCenum stype = AL_NONE;
ALCsizei attrIdx = 0;
ALCsizei aorder = 0;
ALCuint freq = 0;
Declare some variables where they're used
2011-06-15 06:45:51 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
const char *devname{nullptr};
const bool loopback{device->Type == Loopback};
if(!loopback)
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
{
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
devname = device->DeviceName.c_str();
/* If a context is already running on the device, stop playback so
* the device attributes can be updated.
*/
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(device->Flags.get<DeviceRunning>())
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
device->Backend->stop();
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.unset<DeviceRunning>();
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
}
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
auto numMono = static_cast<ALsizei>(device->NumMonoSources);
auto numStereo = static_cast<ALsizei>(device->NumStereoSources);
auto numSends = ALsizei{old_sends};
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
#define TRACE_ATTR(a, v) TRACE("%s = %d\n", #a, v)
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
while(attrList[attrIdx])
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
switch(attrList[attrIdx])
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
{
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_FORMAT_CHANNELS_SOFT:
schans = attrList[attrIdx + 1];
TRACE_ATTR(ALC_FORMAT_CHANNELS_SOFT, schans);
break;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_FORMAT_TYPE_SOFT:
stype = attrList[attrIdx + 1];
TRACE_ATTR(ALC_FORMAT_TYPE_SOFT, stype);
break;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_FREQUENCY:
freq = attrList[attrIdx + 1];
TRACE_ATTR(ALC_FREQUENCY, freq);
break;
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_AMBISONIC_LAYOUT_SOFT:
alayout = attrList[attrIdx + 1];
TRACE_ATTR(ALC_AMBISONIC_LAYOUT_SOFT, alayout);
break;
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_AMBISONIC_SCALING_SOFT:
ascale = attrList[attrIdx + 1];
TRACE_ATTR(ALC_AMBISONIC_SCALING_SOFT, ascale);
break;
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_AMBISONIC_ORDER_SOFT:
aorder = attrList[attrIdx + 1];
TRACE_ATTR(ALC_AMBISONIC_ORDER_SOFT, aorder);
break;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_MONO_SOURCES:
numMono = attrList[attrIdx + 1];
TRACE_ATTR(ALC_MONO_SOURCES, numMono);
numMono = maxi(numMono, 0);
break;
Allow increasing the maximum source limit If the requested number of mono and stereo sources exceeds 256, the source limit will be expanded. Any config file setting overrides this. If the device is reset to have fewer sources than are currently allocated, excess sources will remain and be usable as normal, but no more can be generated until enough are delated to go back below the limit.
2017-04-14 22:56:54 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_STEREO_SOURCES:
numStereo = attrList[attrIdx + 1];
TRACE_ATTR(ALC_STEREO_SOURCES, numStereo);
numStereo = maxi(numStereo, 0);
break;
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_MAX_AUXILIARY_SENDS:
numSends = attrList[attrIdx + 1];
TRACE_ATTR(ALC_MAX_AUXILIARY_SENDS, numSends);
numSends = clampi(numSends, 0, MAX_SENDS);
break;
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_HRTF_SOFT:
TRACE_ATTR(ALC_HRTF_SOFT, attrList[attrIdx + 1]);
if(attrList[attrIdx + 1] == ALC_FALSE)
hrtf_appreq = Hrtf_Disable;
else if(attrList[attrIdx + 1] == ALC_TRUE)
hrtf_appreq = Hrtf_Enable;
else
hrtf_appreq = Hrtf_Default;
break;
Allow enabling HRTF through a context creation attribute
2013-05-31 19:29:32 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_HRTF_ID_SOFT:
hrtf_id = attrList[attrIdx + 1];
TRACE_ATTR(ALC_HRTF_ID_SOFT, hrtf_id);
break;
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
case ALC_OUTPUT_LIMITER_SOFT:
gainLimiter = attrList[attrIdx + 1];
TRACE_ATTR(ALC_OUTPUT_LIMITER_SOFT, gainLimiter);
break;
Start an extension to toggle the output limiter
2017-04-30 04:21:48 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
default:
TRACE("0x%04X = %d (0x%x)\n", attrList[attrIdx],
attrList[attrIdx + 1], attrList[attrIdx + 1]);
break;
Trace the requested attribute values
2016-04-17 17:22:03 -07:00
}
Allow apps to request a specific HRTF
2015-10-07 03:29:53 -07:00
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
attrIdx += 2;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
}
Trace the requested attribute values
2016-04-17 17:22:03 -07:00
#undef TRACE_ATTR
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if(loopback)
Make sure the attributes list specifies a format for loopback devices
2012-01-25 19:54:55 -08:00
{
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if(!schans || !stype || !freq)
{
WARN("Missing format for loopback device\n");
return ALC_INVALID_VALUE;
}
if(!IsValidALCChannels(schans) || !IsValidALCType(stype) || freq < MIN_OUTPUT_RATE)
return ALC_INVALID_VALUE;
Only check ambisonic attributes with B-Format output
2018-12-24 07:33:38 -08:00
if(schans == ALC_BFORMAT3D_SOFT)
{
if(!alayout || !ascale || !aorder)
{
WARN("Missing ambisonic info for loopback device\n");
return ALC_INVALID_VALUE;
}
if(!IsValidAmbiLayout(alayout) || !IsValidAmbiScaling(ascale))
return ALC_INVALID_VALUE;
if(aorder < 1 || aorder > MAX_AMBI_ORDER)
return ALC_INVALID_VALUE;
if((alayout == ALC_FUMA_SOFT || ascale == ALC_FUMA_SOFT) && aorder > 3)
return ALC_INVALID_VALUE;
}
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
}
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(device->Flags.get<DeviceRunning>())
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
device->Backend->stop();
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.unset<DeviceRunning>();
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Setup the HRTF format before tracing the pre-reset format
2014-08-29 19:34:20 -07:00
UpdateClockBase(device);
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if(!loopback)
Allow increasing the maximum source limit If the requested number of mono and stereo sources exceeds 256, the source limit will be expanded. Any config file setting overrides this. If the device is reset to have fewer sources than are currently allocated, excess sources will remain and be usable as normal, but no more can be generated until enough are delated to go back below the limit.
2017-04-14 22:56:54 -07:00
{
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->BufferSize = DEFAULT_UPDATE_SIZE * DEFAULT_NUM_UPDATES;
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
device->UpdateSize = DEFAULT_UPDATE_SIZE;
device->Frequency = DEFAULT_OUTPUT_RATE;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
freq = ConfigValueUInt(devname, nullptr, "frequency").value_or(freq);
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if(freq < 1)
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.unset<FrequencyRequest>();
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
else
{
freq = maxi(freq, MIN_OUTPUT_RATE);
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Scale the update size with sample rate changes
2019-04-26 18:04:22 -07:00
device->UpdateSize = (device->UpdateSize*freq + device->Frequency/2) /
device->Frequency;
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->BufferSize = (device->BufferSize*freq + device->Frequency/2) /
device->Frequency;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
device->Frequency = freq;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.set<FrequencyRequest>();
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
}
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto persizeopt = ConfigValueUInt(devname, nullptr, "period_size"))
device->UpdateSize = clampu(*persizeopt, 64, 8192);
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto peropt = ConfigValueUInt(devname, nullptr, "periods"))
device->BufferSize = device->UpdateSize * clampu(*peropt, 2, 16);
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
else
device->BufferSize = maxu(device->BufferSize, device->UpdateSize*2);
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
}
else
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
{
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
device->Frequency = freq;
Remove extraneous typedef, struct, and enum keywords
2018-12-24 19:29:01 -08:00
device->FmtChans = static_cast<DevFmtChannels>(schans);
device->FmtType = static_cast<DevFmtType>(stype);
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if(schans == ALC_BFORMAT3D_SOFT)
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
{
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
device->mAmbiOrder = aorder;
device->mAmbiLayout = static_cast<AmbiLayout>(alayout);
device->mAmbiScale = static_cast<AmbiNorm>(ascale);
Trace the requested attribute values
2016-04-17 17:22:03 -07:00
}
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
}
Allow increasing the maximum source limit If the requested number of mono and stereo sources exceeds 256, the source limit will be expanded. Any config file setting overrides this. If the device is reset to have fewer sources than are currently allocated, excess sources will remain and be usable as normal, but no more can be generated until enough are delated to go back below the limit.
2017-04-14 22:56:54 -07:00
if(numMono > INT_MAX-numStereo)
numMono = INT_MAX-numStereo;
numMono += numStereo;
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
if(auto srcsopt = ConfigValueInt(devname, nullptr, "sources"))
Allow increasing the maximum source limit If the requested number of mono and stereo sources exceeds 256, the source limit will be expanded. Any config file setting overrides this. If the device is reset to have fewer sources than are currently allocated, excess sources will remain and be usable as normal, but no more can be generated until enough are delated to go back below the limit.
2017-04-14 22:56:54 -07:00
{
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
if(*srcsopt <= 0) numMono = 256;
else numMono = *srcsopt;
Allow increasing the maximum source limit If the requested number of mono and stereo sources exceeds 256, the source limit will be expanded. Any config file setting overrides this. If the device is reset to have fewer sources than are currently allocated, excess sources will remain and be usable as normal, but no more can be generated until enough are delated to go back below the limit.
2017-04-14 22:56:54 -07:00
}
else
numMono = maxi(numMono, 256);
numStereo = mini(numStereo, numMono);
numMono -= numStereo;
device->SourcesMax = numMono + numStereo;
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
device->NumMonoSources = numMono;
device->NumStereoSources = numStereo;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
if(auto sendsopt = ConfigValueInt(devname, nullptr, "sends"))
new_sends = mini(numSends, clampi(*sendsopt, 0, MAX_SENDS));
Make the "sends" config option act as a limit Instead of forcing the device to always use the specified send count, it simply limits requests to it.
2017-02-21 17:19:02 -08:00
else
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
new_sends = numSends;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
}
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(device->Flags.get<DeviceRunning>())
Return the error code from UpdateDeviceParams
2012-01-25 20:00:34 -08:00
return ALC_NO_ERROR;
Report parameter request changes in UpdateDeviceParams
2012-01-17 15:55:37 -08:00
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
device->AvgSpeakerDist = 0.0f;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->Uhj_Encoder = nullptr;
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
device->AmbiDecoder = nullptr;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->Bs2b = nullptr;
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
device->PostProcess = nullptr;
Use 2-channel UHJ for stereo output
2016-02-26 16:09:06 -08:00
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
device->Stablizer = nullptr;
Make the Compressor more class-like
2018-12-24 09:17:00 -08:00
device->Limiter = nullptr;
Use a normal vector for the distance buffer storage
2018-11-21 05:06:31 -08:00
device->ChannelDelay.clear();
Dynamically allocate the channel delay buffers
2017-02-28 21:01:13 -08:00
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
device->Dry.AmbiMap.fill(BFChannelConfig{});
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->Dry.Buffer = nullptr;
Organize the dry buffer properties into a struct
2016-03-09 23:43:57 -08:00
device->Dry.NumChannels = 0;
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
std::fill(std::begin(device->NumChannelsPerOrder), std::end(device->NumChannelsPerOrder), 0u);
device->RealOut.ChannelIndex.fill(-1);
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->RealOut.Buffer = nullptr;
Track the virtual and real output buffers ecplicitly
2016-03-09 22:57:38 -08:00
device->RealOut.NumChannels = 0;
Use a vector to handle mixing buffer storage
2018-11-19 06:22:09 -08:00
device->MixBuffer.clear();
device->MixBuffer.shrink_to_fit();
Use a different method for HRTF mixing This new method mixes sources normally into a 14-channel buffer with the channels placed all around the listener. HRTF is then applied to the channels given their positions and written to a 2-channel buffer, which gets written out to the device. This method has the benefit that HRTF processing becomes more scalable. The costly HRTF filters are applied to the 14-channel buffer after the mix is done, turning it into a post-process with a fixed overhead. Mixing sources is done with normal non-HRTF methods, so increasing the number of playing sources only incurs normal mixing costs. Another benefit is that it improves B-Format playback since the soundfield gets mixed into speakers covering all three dimensions, which then get filtered based on their locations. The main downside to this is that the spatial resolution of the HRTF dataset does not play a big role anymore. However, the hope is that with ambisonics- based panning, the perceptual position of panned sounds will still be good. It is also an option to increase the number of virtual channels for systems that can handle it, or maybe even decrease it for weaker systems.
2014-11-22 04:20:17 -08:00
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
UpdateClockBase(device);
Remove a couple unnecessary duration_casts
2019-03-26 10:18:02 -07:00
device->FixedLatency = nanoseconds::zero();
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
device->DitherDepth = 0.0f;
Add an option to dither 8- and 16-bit output
2017-05-23 00:02:04 -07:00
device->DitherSeed = DITHER_RNG_SEED;
Separate some long if-else blocks into a separate function
2016-04-14 14:24:52 -07:00
/*************************************************************************
* Update device format request if HRTF is requested
*/
Dynamically allocate the device's HRTF state
2017-03-10 10:47:43 -08:00
device->HrtfStatus = ALC_HRTF_DISABLED_SOFT;
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
if(device->Type != Loopback)
Allow enabling HRTF through a context creation attribute
2013-05-31 19:29:32 -07:00
{
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
if(auto hrtfopt = ConfigValueStr(device->DeviceName.c_str(), nullptr, "hrtf"))
Add an HRTF status query This can report the status of HRTF, specifying if it's enabled or not and why (currently only reports unsupported formats, but this may be extended).
2015-05-15 23:28:03 -07:00
{
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
const char *hrtf{hrtfopt->c_str()};
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
if(strcasecmp(hrtf, "true") == 0)
Don't store the HRTF request mode in the device flags
2015-09-05 01:32:12 -07:00
hrtf_userreq = Hrtf_Enable;
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
else if(strcasecmp(hrtf, "false") == 0)
Don't store the HRTF request mode in the device flags
2015-09-05 01:32:12 -07:00
hrtf_userreq = Hrtf_Disable;
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
else if(strcasecmp(hrtf, "auto") != 0)
ERR("Unexpected hrtf value: %s\n", hrtf);
}
Avoid setting an HRTF-compatible format when it's disabled
2015-09-05 14:22:19 -07:00
if(hrtf_userreq == Hrtf_Enable || (hrtf_userreq != Hrtf_Disable && hrtf_appreq == Hrtf_Enable))
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
{
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
HrtfEntry *hrtf{nullptr};
Use a regular vector for the enumerated HRTF list
2018-11-18 19:19:35 -08:00
if(device->HrtfList.empty())
Use a std::string for the device name
2018-11-18 18:45:45 -08:00
device->HrtfList = EnumerateHrtf(device->DeviceName.c_str());
Use a regular vector for the enumerated HRTF list
2018-11-18 19:19:35 -08:00
if(!device->HrtfList.empty())
Use the enumerated HRTF list for selecting an HRTF Also report the proper specifier of the one currently in use.
2015-10-06 06:48:53 -07:00
{
Avoid using old style casts To think about: examples/alffplay.cpp:600 OpenAL32/Include/alMain.h:295
2019-01-08 19:42:44 +01:00
if(hrtf_id >= 0 && static_cast<size_t>(hrtf_id) < device->HrtfList.size())
Use a regular vector for the enumerated HRTF list
2018-11-18 19:19:35 -08:00
hrtf = GetLoadedHrtf(device->HrtfList[hrtf_id].hrtf);
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 12:27:30 -07:00
else
Use a regular vector for the enumerated HRTF list
2018-11-18 19:19:35 -08:00
hrtf = GetLoadedHrtf(device->HrtfList.front().hrtf);
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 12:27:30 -07:00
}
if(hrtf)
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 11:29:58 -07:00
device->FmtChans = DevFmtStereo;
device->Frequency = hrtf->sampleRate;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.set<ChannelsRequest, FrequencyRequest>();
Make IncRef and DecRef member functions
2019-01-24 10:05:37 -08:00
if(HrtfEntry *oldhrtf{device->mHrtf})
oldhrtf->DecRef();
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
device->mHrtf = hrtf;
Use the enumerated HRTF list for selecting an HRTF Also report the proper specifier of the one currently in use.
2015-10-06 06:48:53 -07:00
}
Avoid setting an HRTF-compatible format when it's disabled
2015-09-05 14:22:19 -07:00
else
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
{
Separate some long if-else blocks into a separate function
2016-04-14 14:24:52 -07:00
hrtf_userreq = Hrtf_Default;
hrtf_appreq = Hrtf_Disable;
Dynamically allocate the device's HRTF state
2017-03-10 10:47:43 -08:00
device->HrtfStatus = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
}
Add an HRTF status query This can report the status of HRTF, specifying if it's enabled or not and why (currently only reports unsupported formats, but this may be extended).
2015-05-15 23:28:03 -07:00
}
Handle loopback devices when deciding to use HRTF
2014-11-23 08:38:33 -08:00
}
Allow enabling HRTF through a context creation attribute
2013-05-31 19:29:32 -07:00
Setup the HRTF format before tracing the pre-reset format
2014-08-29 19:34:20 -07:00
oldFreq = device->Frequency;
oldChans = device->FmtChans;
oldType = device->FmtType;
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
TRACE("Pre-reset: %s%s, %s%s, %s%uhz, %u / %u buffer\n",
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.get<ChannelsRequest>()?"*":"", DevFmtChannelsString(device->FmtChans),
device->Flags.get<SampleTypeRequest>()?"*":"", DevFmtTypeString(device->FmtType),
device->Flags.get<FrequencyRequest>()?"*":"", device->Frequency,
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->UpdateSize, device->BufferSize);
Setup the HRTF format before tracing the pre-reset format
2014-08-29 19:34:20 -07:00
Catch exceptions from backend reset
2019-05-04 20:17:54 -07:00
try {
if(device->Backend->reset() == ALC_FALSE)
return ALC_INVALID_DEVICE;
}
catch(std::exception &e) {
ERR("Device reset failed: %s\n", e.what());
Return the error code from UpdateDeviceParams
2012-01-25 20:00:34 -08:00
return ALC_INVALID_DEVICE;
Catch exceptions from backend reset
2019-05-04 20:17:54 -07:00
}
Report parameter request changes in UpdateDeviceParams
2012-01-17 15:55:37 -08:00
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(device->FmtChans != oldChans && device->Flags.get<ChannelsRequest>())
Remove an unnecessary else statement
2012-01-20 12:20:24 -08:00
{
Combine a couple if checks
2012-02-15 11:28:19 -08:00
ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
DevFmtChannelsString(device->FmtChans));
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.unset<ChannelsRequest>();
Hold the global lock while the device is being updated
2011-05-29 02:56:00 -07:00
}
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(device->FmtType != oldType && device->Flags.get<SampleTypeRequest>())
Add a device request flag for the sample type
2012-02-15 16:26:32 -08:00
{
ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
DevFmtTypeString(device->FmtType));
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.unset<SampleTypeRequest>();
Add a device request flag for the sample type
2012-02-15 16:26:32 -08:00
}
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(device->Frequency != oldFreq && device->Flags.get<FrequencyRequest>())
Remove an unnecessary else statement
2012-01-20 12:20:24 -08:00
{
Combine a couple if checks
2012-02-15 11:28:19 -08:00
ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.unset<FrequencyRequest>();
Remove an unnecessary else statement
2012-01-20 12:20:24 -08:00
}
Move a warning check earlier
2014-11-22 04:51:34 -08:00
if((device->UpdateSize&3) != 0)
{
if((CPUCapFlags&CPU_CAP_SSE))
WARN("SSE performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
if((CPUCapFlags&CPU_CAP_NEON))
WARN("NEON performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
}
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
TRACE("Post-reset: %s, %s, %uhz, %u / %u buffer\n",
Move the InitRenderer method to panning.c
2016-04-14 15:25:12 -07:00
DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->Frequency, device->UpdateSize, device->BufferSize);
Move the InitRenderer method to panning.c
2016-04-14 15:25:12 -07:00
aluInitRenderer(device, hrtf_id, hrtf_appreq, hrtf_userreq);
Make some more channel counts unsigned
2019-06-05 19:26:54 -07:00
TRACE("Channel config, Main: %u, Real: %u\n", device->Dry.NumChannels,
Remove the FOAOut mixing buffer and associated post-processes
2019-02-22 22:35:37 -08:00
device->RealOut.NumChannels);
Initialize panning after setting up HRTF
2014-11-21 14:35:19 -08:00
Add a dual-band ambisonic decoder This uses a virtual B-Format buffer for mixing, and then uses a dual-band decoder for improved positional quality. This currently only works with first- order output since first-order input (from the AL_EXT_BFROMAT extension) would not sound correct when fed through a second- or third-order decoder. This also does not currently implement near-field compensation since near-field rendering effects are not implemented.
2016-03-15 05:08:05 -07:00
/* Allocate extra channels for any post-filter output. */
Make RealMixParams channel count unsigned
2019-06-05 18:54:17 -07:00
const ALuint num_chans{device->Dry.NumChannels + device->RealOut.NumChannels};
Don't use periphonic FOA when the HOA decoder is not periphonic
2017-02-19 17:45:27 -08:00
Make RealMixParams channel count unsigned
2019-06-05 18:54:17 -07:00
TRACE("Allocating %u channels, %zu bytes\n", num_chans,
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
num_chans*sizeof(device->MixBuffer[0]));
Use a vector to handle mixing buffer storage
2018-11-19 06:22:09 -08:00
device->MixBuffer.resize(num_chans);
Allocate the DryBuffer dynamically
2014-11-21 13:45:57 -08:00
Use std::array for most mixing buffer arrays
2019-05-28 16:22:36 -07:00
device->Dry.Buffer = device->MixBuffer.data();
Avoid duplicating device buffer layout logic
2017-02-20 16:57:25 -08:00
if(device->RealOut.NumChannels != 0)
Remove the FOAOut mixing buffer and associated post-processes
2019-02-22 22:35:37 -08:00
device->RealOut.Buffer = device->Dry.Buffer + device->Dry.NumChannels;
Add a specific output for first-order sources
2016-03-22 17:52:20 -07:00
else
{
Avoid duplicating device buffer layout logic
2017-02-20 16:57:25 -08:00
device->RealOut.Buffer = device->Dry.Buffer;
device->RealOut.NumChannels = device->Dry.NumChannels;
Add a specific output for first-order sources
2016-03-22 17:52:20 -07:00
}
Don't use periphonic FOA when the HOA decoder is not periphonic
2017-02-19 17:45:27 -08:00
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
device->NumAuxSends = new_sends;
Allow increasing the maximum source limit If the requested number of mono and stereo sources exceeds 256, the source limit will be expanded. Any config file setting overrides this. If the device is reset to have fewer sources than are currently allocated, excess sources will remain and be usable as normal, but no more can be generated until enough are delated to go back below the limit.
2017-04-14 22:56:54 -07:00
TRACE("Max sources: %d (%d + %d), effect slots: %d, sends: %d\n",
Reorganize how some device fields are set and reset
2019-06-15 23:10:11 -07:00
device->SourcesMax, device->NumMonoSources, device->NumStereoSources,
device->AuxiliaryEffectSlotMax, device->NumAuxSends);
/* Enable the stablizer only for formats that have front-left, front-right,
* and front-center outputs.
*/
switch(device->FmtChans)
{
case DevFmtX51:
case DevFmtX51Rear:
case DevFmtX61:
case DevFmtX71:
if(GetConfigValueBool(device->DeviceName.c_str(), nullptr, "front-stablizer", 0))
{
auto stablizer = al::make_unique<FrontStablizer>();
/* Initialize band-splitting filters for the front-left and
* front-right channels, with a crossover at 5khz (could be
* higher).
*/
const ALfloat scale{static_cast<ALfloat>(5000.0 / device->Frequency)};
stablizer->LFilter.init(scale);
stablizer->RFilter = stablizer->LFilter;
device->Stablizer = std::move(stablizer);
/* NOTE: Don't know why this has to be "copied" into a local static
* constexpr variable to avoid a reference on
* FrontStablizer::DelayLength...
*/
static constexpr size_t StablizerDelay{FrontStablizer::DelayLength};
device->FixedLatency += nanoseconds{seconds{StablizerDelay}} / device->Frequency;
}
break;
case DevFmtMono:
case DevFmtStereo:
case DevFmtQuad:
case DevFmtAmbi3D:
break;
}
TRACE("Front stablizer %s\n", device->Stablizer ? "enabled" : "disabled");
Implement a limiter on the device output This reduces the output volume when the mixed samples extend outside of -1,+1, to prevent excessive clipping. It can reduce the volume by -80dB in 50ms, and increase it by +80dB in 1s (it will not go below -80dB or above 0dB).
2017-04-26 18:38:09 -07:00
Use a std::string for the device name
2018-11-18 18:45:45 -08:00
if(GetConfigValueBool(device->DeviceName.c_str(), nullptr, "dither", 1))
Make the dithering depth configurable
2017-06-17 23:09:51 -07:00
{
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
ALint depth{
ConfigValueInt(device->DeviceName.c_str(), nullptr, "dither-depth").value_or(0)};
Make the dithering depth configurable
2017-06-17 23:09:51 -07:00
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;
}
}
Clamp the dither depth between 2 and 20 bits
2018-05-23 19:49:49 -07:00
if(depth > 0)
{
Use a 24-bit dither depth limit
2018-10-03 13:51:21 -07:00
depth = clampi(depth, 2, 24);
Avoid using old style casts To think about: examples/alffplay.cpp:600 OpenAL32/Include/alMain.h:295
2019-01-08 19:42:44 +01:00
device->DitherDepth = std::pow(2.0f, static_cast<ALfloat>(depth-1));
Clamp the dither depth between 2 and 20 bits
2018-05-23 19:49:49 -07:00
}
Make the dithering depth configurable
2017-06-17 23:09:51 -07:00
}
Trace if dithering is enabled
2017-06-19 00:17:11 -07:00
if(!(device->DitherDepth > 0.0f))
TRACE("Dithering disabled\n");
else
Fix a float constant type
2018-11-18 08:03:22 -08:00
TRACE("Dithering enabled (%d-bit, %g)\n", float2int(std::log2(device->DitherDepth)+0.5f)+1,
Trace if dithering is enabled
2017-06-19 00:17:11 -07:00
device->DitherDepth);
Make the dithering depth configurable
2017-06-17 23:09:51 -07:00
Don't limit output for ALC_DONT_CARE_SOFT and float samples
2018-10-03 13:48:04 -07:00
device->LimiterState = gainLimiter;
Return optionals from the remaining ConfigValue* methods
2019-06-30 16:38:25 -07:00
if(auto limopt = ConfigValueBool(device->DeviceName.c_str(), nullptr, "output-limiter"))
gainLimiter = *limopt ? ALC_TRUE : ALC_FALSE;
Don't limit output for ALC_DONT_CARE_SOFT and float samples
2018-10-03 13:48:04 -07:00
Update ALC_OUTPUT_LIMITER_SOFT to handle ALC_DONT_CARE_SOFT Essentially just adding a comment about it. Since we default to on, the behavior already fit.
2017-05-11 11:04:25 -07:00
/* Valid values for gainLimiter are ALC_DONT_CARE_SOFT, ALC_TRUE, and
Don't limit output for ALC_DONT_CARE_SOFT and float samples
2018-10-03 13:48:04 -07:00
* ALC_FALSE. For ALC_DONT_CARE_SOFT, use the limiter for integer-based
* output (where samples must be clamped), and don't for floating-point
* (which can take unclamped samples).
Update ALC_OUTPUT_LIMITER_SOFT to handle ALC_DONT_CARE_SOFT Essentially just adding a comment about it. Since we default to on, the behavior already fit.
2017-05-11 11:04:25 -07:00
*/
Don't limit output for ALC_DONT_CARE_SOFT and float samples
2018-10-03 13:48:04 -07:00
if(gainLimiter == ALC_DONT_CARE_SOFT)
{
switch(device->FmtType)
{
case DevFmtByte:
case DevFmtUByte:
case DevFmtShort:
case DevFmtUShort:
case DevFmtInt:
case DevFmtUInt:
gainLimiter = ALC_TRUE;
break;
case DevFmtFloat:
gainLimiter = ALC_FALSE;
break;
}
}
Report the threshold limit for the output limiter
2019-05-04 13:53:11 -07:00
if(gainLimiter == ALC_FALSE)
TRACE("Output limiter disabled\n");
else
Calculate the output limiter gain using the RMS
2017-05-05 07:38:26 -07:00
{
Don't hardcode the limiter threshold It's now calculated from the output sample type and dither depth.
2018-09-25 10:29:38 -07:00
ALfloat thrshld = 1.0f;
switch(device->FmtType)
Add a new compressor/limiter This is just for the output limiter right now, but in the future can be used for the compressor EFX effect. The parameters are also hardcoded, but can be made configurable after 1.18.
2017-05-27 03:36:34 -07:00
{
Don't hardcode the limiter threshold It's now calculated from the output sample type and dither depth.
2018-09-25 10:29:38 -07:00
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;
Add a new compressor/limiter This is just for the output limiter right now, but in the future can be used for the compressor EFX effect. The parameters are also hardcoded, but can be made configurable after 1.18.
2017-05-27 03:36:34 -07:00
}
Don't hardcode the limiter threshold It's now calculated from the output sample type and dither depth.
2018-09-25 10:29:38 -07:00
if(device->DitherDepth > 0.0f)
thrshld -= 1.0f / device->DitherDepth;
Report the threshold limit for the output limiter
2019-05-04 13:53:11 -07:00
const float thrshld_dB{std::log10(thrshld) * 20.0f};
auto limiter = CreateDeviceLimiter(device, thrshld_dB);
Use standard types for the device clock times
2018-11-22 12:53:16 -08:00
/* Convert the lookahead from samples to nanosamples to nanoseconds. */
Remove a couple unnecessary duration_casts
2019-03-26 10:18:02 -07:00
device->FixedLatency += nanoseconds{seconds{limiter->getLookAhead()}} / device->Frequency;
Make the Compressor more class-like
2018-12-24 09:17:00 -08:00
device->Limiter = std::move(limiter);
Report the threshold limit for the output limiter
2019-05-04 13:53:11 -07:00
TRACE("Output limiter enabled, %.4fdB limit\n", thrshld_dB);
Calculate the output limiter gain using the RMS
2017-05-05 07:38:26 -07:00
}
Implement a limiter on the device output This reduces the output volume when the mixed samples extend outside of -1,+1, to prevent excessive clipping. It can reduce the volume by -80dB in 50ms, and increase it by +80dB in 1s (it will not go below -80dB or above 0dB).
2017-04-26 18:38:09 -07:00
Use standard types for the device clock times
2018-11-22 12:53:16 -08:00
TRACE("Fixed device latency: %ldns\n", (long)device->FixedLatency.count());
Include the limiter's lookAhead delay in the device latency
2018-09-25 23:05:27 -07:00
Implement a limiter on the device output This reduces the output volume when the mixed samples extend outside of -1,+1, to prevent excessive clipping. It can reduce the volume by -80dB in 50ms, and increase it by +80dB in 1s (it will not go below -80dB or above 0dB).
2017-04-26 18:38:09 -07:00
/* Need to delay returning failure until replacement Send arrays have been
* allocated with the appropriate size.
*/
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
update_failed = AL_FALSE;
Use RAII when handling the mixer's FPU state
2018-11-21 09:07:02 -08:00
FPUCtl mixer_mode{};
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
for(ALCcontext *context : *device->mContexts.load())
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
if(context->DefaultSlot)
{
Use a unique_ptr for the default effect slot
2018-11-20 05:01:08 -08:00
ALeffectslot *slot = context->DefaultSlot.get();
Allow processing some effects in higher order ambisonics Reverb notably is still only first-order (any higher order channels are dropped, and it writes to FOAOut). But others, like the equalizer, work on all available channels.
2019-02-21 04:23:01 -08:00
aluInitEffectPanning(slot, device);
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
Allocate the effect slot wet buffer dynamically
2019-02-20 21:01:08 -08:00
EffectState *state{slot->Effect.State};
Use a span for the effect state's output target
2019-06-05 19:58:58 -07:00
state->mOutTarget = {device->Dry.Buffer, device->Dry.NumChannels};
Use proper inheritence for the effect state objects
2018-11-19 22:34:26 -08:00
if(state->deviceUpdate(device) == AL_FALSE)
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
update_failed = AL_TRUE;
else
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
UpdateEffectSlotProps(slot, context);
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
}
Use a standard mutex for the proplock
2018-11-26 21:37:58 -08:00
std::unique_lock<std::mutex> proplock{context->PropLock};
Use a standard mutex for the source and effect slot locks
2018-11-26 21:50:48 -08:00
std::unique_lock<std::mutex> slotlock{context->EffectSlotLock};
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
for(auto &sublist : context->EffectSlotList)
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
uint64_t usemask = ~sublist.FreeMask;
while(usemask)
{
ALsizei idx = CTZ64(usemask);
ALeffectslot *slot = sublist.EffectSlots + idx;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
usemask &= ~(1_u64 << idx);
Allow processing some effects in higher order ambisonics Reverb notably is still only first-order (any higher order channels are dropped, and it writes to FOAOut). But others, like the equalizer, work on all available channels.
2019-02-21 04:23:01 -08:00
aluInitEffectPanning(slot, device);
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
EffectState *state{slot->Effect.State};
Use a span for the effect state's output target
2019-06-05 19:58:58 -07:00
state->mOutTarget = {device->Dry.Buffer, device->Dry.NumChannels};
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
if(state->deviceUpdate(device) == AL_FALSE)
update_failed = AL_TRUE;
else
UpdateEffectSlotProps(slot, context);
}
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
}
Always use RAII with EffectSlotLock
2018-11-21 05:35:47 -08:00
slotlock.unlock();
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Use a standard mutex for the source and effect slot locks
2018-11-26 21:50:48 -08:00
std::unique_lock<std::mutex> srclock{context->SourceLock};
Use a proper vector for the source sublists
2018-11-18 02:15:31 -08:00
for(auto &sublist : context->SourceList)
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Use a proper vector for the source sublists
2018-11-18 02:15:31 -08:00
uint64_t usemask = ~sublist.FreeMask;
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
while(usemask)
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
ALsizei idx = CTZ64(usemask);
Use a proper vector for the source sublists
2018-11-18 02:15:31 -08:00
ALsource *source = sublist.Sources + idx;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
Use user-defined literals for 64-bit literals
2019-01-07 04:06:40 -08:00
usemask &= ~(1_u64 << idx);
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
if(old_sends != device->NumAuxSends)
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
{
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
ALsizei s;
for(s = device->NumAuxSends;s < old_sends;s++)
{
if(source->Send[s].Slot)
DecrementRef(&source->Send[s].Slot->ref);
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
source->Send[s].Slot = nullptr;
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
}
Use a normal vector for the source send properties
2018-11-20 12:25:15 -08:00
source->Send.resize(device->NumAuxSends);
source->Send.shrink_to_fit();
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
for(s = old_sends;s < device->NumAuxSends;s++)
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
source->Send[s].Slot = nullptr;
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
source->Send[s].Gain = 1.0f;
source->Send[s].GainHF = 1.0f;
source->Send[s].HFReference = LOWPASSFREQREF;
source->Send[s].GainLF = 1.0f;
source->Send[s].LFReference = HIGHPASSFREQREF;
}
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
}
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
Use atomic_flags and atomic<bools>s where appropriate
2018-11-20 10:45:01 -08:00
source->PropsClean.clear(std::memory_order_release);
Use an array lookup for source IDs This is now similar to buffers, being stored in groups of 64 in a vector with the ID providing the array indices.
2018-01-27 13:02:17 -08:00
}
Store the source prop updates with the mixer voice Also move its declaration and rename it for consistency.
2017-04-17 21:16:01 -07:00
}
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
/* Clear any pre-existing voice property structs, in case the number of
* auxiliary sends is changing. Active sources will have updates
* respecified in UpdateAllSourceProps.
*/
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
ALvoiceProps *vprops{context->FreeVoiceProps.exchange(nullptr, std::memory_order_acq_rel)};
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
while(vprops)
{
Don't bother making ALvoiceProps dynamically sized
2018-11-30 16:56:23 -08:00
ALvoiceProps *next = vprops->next.load(std::memory_order_relaxed);
delete vprops;
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
vprops = next;
}
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
auto voices = context->Voices.get();
auto voices_end = voices->begin() + context->VoiceCount.load(std::memory_order_relaxed);
if(device->NumAuxSends < old_sends)
{
const ALsizei num_sends{device->NumAuxSends};
/* Clear extraneous property set sends. */
auto clear_sends = [num_sends](ALvoice &voice) -> void
{
std::fill(std::begin(voice.mProps.Send)+num_sends, std::end(voice.mProps.Send),
ALvoiceProps::SendData{});
std::fill(voice.mSend.begin()+num_sends, voice.mSend.end(), ALvoice::SendData{});
auto clear_chan_sends = [num_sends](ALvoice::ChannelData &chandata) -> void
{
std::fill(chandata.mWetParams.begin()+num_sends, chandata.mWetParams.end(),
SendParams{});
};
std::for_each(voice.mChans.begin(), voice.mChans.end(), clear_chan_sends);
};
std::for_each(voices->begin(), voices_end, clear_sends);
}
std::for_each(voices->begin(), voices_end,
[device](ALvoice &voice) -> void
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
{
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
delete voice.mUpdate.exchange(nullptr, std::memory_order_acq_rel);
Store the source prop updates with the mixer voice Also move its declaration and rename it for consistency.
2017-04-17 21:16:01 -07:00
Add a Stopping state for voices This currently doesn't do much, except have the mixer progress it to Stopped. It's valid to have without a source or buffers, and in the future will allow fading out when a source is paused or stopped.
2019-03-09 16:48:07 -08:00
/* Force the voice to stopped if it was stopping. */
ALvoice::State vstate{ALvoice::Stopping};
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
voice.mPlayState.compare_exchange_strong(vstate, ALvoice::Stopped,
Add a Stopping state for voices This currently doesn't do much, except have the mixer progress it to Stopped. It's valid to have without a source or buffers, and in the future will allow fading out when a source is paused or stopped.
2019-03-09 16:48:07 -08:00
std::memory_order_acquire, std::memory_order_acquire);
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
if(voice.mSourceID.load(std::memory_order_relaxed) == 0u)
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
return;
Implement NFC filters for Ambisonic rendering NFC filters currently only work when rendering to ambisonic buffers, which includes HQ rendering and ambisonic output. There are two new config options: 'decoder/nfc' (default on) enables or disables use of NFC filters globally, and 'decoder/nfc-ref-delay' (default 0) specifies the reference delay parameter for NFC-HOA rendering with ambisonic output (a value of 0 disables NFC). Currently, NFC filters rely on having an appropriate value set for AL_METERS_PER_UNIT to get the correct scaling. HQ rendering uses the averaged speaker distances as a control/reference, and currently doesn't correct for individual speaker distances (if the speakers are all equidistant, this is fine, otherwise per-speaker correction should be done as well).
2017-03-10 04:35:32 -08:00
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
if(device->AvgSpeakerDist > 0.0f)
{
/* Reinitialize the NFC filters for new parameters. */
Restructure voice data members This should improve access patters by packing each buffer channel's data together, which is more inline with its use.
2019-06-03 22:24:26 -07:00
const ALfloat w1{SPEEDOFSOUNDMETRESPERSEC /
(device->AvgSpeakerDist * device->Frequency)};
auto init_nfc = [w1](ALvoice::ChannelData &chandata) -> void
{ chandata.mDryParams.NFCtrlFilter.init(w1); };
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
std::for_each(voice.mChans.begin(), voice.mChans.begin()+voice.mNumChannels,
Restructure voice data members This should improve access patters by packing each buffer channel's data together, which is more inline with its use.
2019-06-03 22:24:26 -07:00
init_nfc);
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
}
Implement NFC filters for Ambisonic rendering NFC filters currently only work when rendering to ambisonic buffers, which includes HQ rendering and ambisonic output. There are two new config options: 'decoder/nfc' (default on) enables or disables use of NFC filters globally, and 'decoder/nfc-ref-delay' (default 0) specifies the reference delay parameter for NFC-HOA rendering with ambisonic output (a value of 0 disables NFC). Currently, NFC filters rely on having an appropriate value set for AL_METERS_PER_UNIT to get the correct scaling. HQ rendering uses the averaged speaker distances as a control/reference, and currently doesn't correct for individual speaker distances (if the speakers are all equidistant, this is fine, otherwise per-speaker correction should be done as well).
2017-03-10 04:35:32 -08:00
}
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
);
Replace a couple more almtx_lock/unlock calls
2018-11-21 06:41:49 -08:00
srclock.unlock();
Use a list of contexts in the device instead of an array
2011-08-28 19:28:41 -07:00
Use atomic_flags and atomic<bools>s where appropriate
2018-11-20 10:45:01 -08:00
context->PropsClean.test_and_set(std::memory_order_release);
Don't update context and listener props unnecessarily
2017-09-27 09:36:34 -07:00
UpdateContextProps(context);
Use atomic_flags and atomic<bools>s where appropriate
2018-11-20 10:45:01 -08:00
context->Listener.PropsClean.test_and_set(std::memory_order_release);
Only send source updates for sources that have updated
2016-11-23 01:31:13 -08:00
UpdateListenerProps(context);
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
UpdateAllSourceProps(context);
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
}
Use RAII when handling the mixer's FPU state
2018-11-21 09:07:02 -08:00
mixer_mode.leave();
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
if(update_failed)
return ALC_INVALID_DEVICE;
Use a separate backend callback to start playback of the device This allows us to properly update the ALCdevice and its resources with the new parameters before starting playback, instead of expecting the mixer to block and wait after it has begun. This also lets us avoid holding the device lock while resetting and starting the device, which helps prevent lock inversion on some backends (ie, one thread locking A then B, and another thread locking B then A), ultimately allowing certain backends to asynchronously update the ALCdevice without risk of lockup. Capture still has issues here, however.
2012-03-05 07:11:09 -08:00
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(!device->Flags.get<DevicePaused>())
Add a flag to specify the device being paused Used to prevent UpdateDeviceParams from restarting the device, if a new context is created while paused.
2014-01-15 16:44:12 -08:00
{
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
if(device->Backend->start() == ALC_FALSE)
Add a flag to specify the device being paused Used to prevent UpdateDeviceParams from restarting the device, if a new context is created while paused.
2014-01-15 16:44:12 -08:00
return ALC_INVALID_DEVICE;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.set<DeviceRunning>();
Add a flag to specify the device being paused Used to prevent UpdateDeviceParams from restarting the device, if a new context is created while paused.
2014-01-15 16:44:12 -08:00
}
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Return the error code from UpdateDeviceParams
2012-01-25 20:00:34 -08:00
return ALC_NO_ERROR;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
}
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
ALCdevice::ALCdevice(DeviceType type) : Type{type}, mContexts{&EmptyContextArray}
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
{
}
Rename ALCdevice_struct and ALCcontext_struct A (possibly contentious?) change in the public headers. Those names were never part of any specification, and I don't know why the struct names differed from the actual type name. But with C++, which takes the original struct declaration as the original name, it was affecting the type's internal symbols. This shouldn't affect user code since ALCdevice_struct and ALCcontext_struct were never part of the spec. If issues arise from this change, it should be reported.
2019-01-01 18:13:33 -08:00
/* ALCdevice::~ALCdevice
Clean up some comments
2011-09-10 09:00:01 -07:00
*
* Frees the device structure, and destroys any objects the app failed to
Add a comment about when FreeContext and FreeDevice are called
2011-09-10 20:52:19 -07:00
* delete. Called once there's no more references on the device.
Clean up some comments
2011-09-10 09:00:01 -07:00
*/
Rename ALCdevice_struct and ALCcontext_struct A (possibly contentious?) change in the public headers. Those names were never part of any specification, and I don't know why the struct names differed from the actual type name. But with C++, which takes the original struct declaration as the original name, it was affecting the type's internal symbols. This shouldn't affect user code since ALCdevice_struct and ALCcontext_struct were never part of the spec. If issues arise from this change, it should be reported.
2019-01-01 18:13:33 -08:00
ALCdevice::~ALCdevice()
Add some reference counting to the device
2011-09-10 02:43:07 -07:00
{
Don't log the function or prefix It's ultimately unnecessary since the message is an indicator about where it was logged from. The message itself is generally more important than where it was from, too.
2019-06-04 01:37:36 -07:00
TRACE("Freeing device %p\n", this);
Hold an extra reference on the device for each of its contexts
2011-09-10 03:01:24 -07:00
Use constructors/destructors with ALCdevice As with ALCcontext, this is really ALCdevice_struct because of the way it's declared in the public header.
2018-11-18 07:33:42 -08:00
Backend = nullptr;
Keep the backend device open until the last reference is released This should generally happen with the next ALCdevice_DecRef call unless the device is in the middle of being used in another thread, in which case it's probably best to not remove the resources.
2012-08-18 14:49:42 -07:00
Avoid some explicit loops
2018-11-28 11:30:44 -08:00
size_t count{std::accumulate(BufferList.cbegin(), BufferList.cend(), size_t{0u},
[](size_t cur, const BufferSubList &sublist) noexcept -> size_t
{ return cur + POPCNT64(~sublist.FreeMask); }
)};
Automatically clean up buffers with ther sublist
2018-11-25 15:30:32 -08:00
if(count > 0)
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
WARN("%zu Buffer%s not deleted\n", count, (count==1)?"":"s");
Add some reference counting to the device
2011-09-10 02:43:07 -07:00
Avoid some explicit loops
2018-11-28 11:30:44 -08:00
count = std::accumulate(EffectList.cbegin(), EffectList.cend(), size_t{0u},
[](size_t cur, const EffectSubList &sublist) noexcept -> size_t
{ return cur + POPCNT64(~sublist.FreeMask); }
);
Automatically clean up filters and effects with their sublists
2018-11-25 16:13:07 -08:00
if(count > 0)
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
WARN("%zu Effect%s not deleted\n", count, (count==1)?"":"s");
Add some reference counting to the device
2011-09-10 02:43:07 -07:00
Avoid some explicit loops
2018-11-28 11:30:44 -08:00
count = std::accumulate(FilterList.cbegin(), FilterList.cend(), size_t{0u},
[](size_t cur, const FilterSubList &sublist) noexcept -> size_t
{ return cur + POPCNT64(~sublist.FreeMask); }
);
Automatically clean up filters and effects with their sublists
2018-11-25 16:13:07 -08:00
if(count > 0)
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
WARN("%zu Filter%s not deleted\n", count, (count==1)?"":"s");
Don't explicitly clear vector objects in the destructor
2018-11-25 17:51:39 -08:00
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
if(mHrtf)
Make IncRef and DecRef member functions
2019-01-24 10:05:37 -08:00
mHrtf->DecRef();
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
mHrtf = nullptr;
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
auto *oldarray = mContexts.exchange(nullptr, std::memory_order_relaxed);
if(oldarray != &EmptyContextArray) delete oldarray;
Add some reference counting to the device
2011-09-10 02:43:07 -07:00
}
Clean up some comments
2011-09-10 09:00:01 -07:00
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
/* VerifyDevice
*
Use RAII for device references
2018-11-23 17:54:12 -08:00
* Checks if the device handle is valid, and returns a new reference if so.
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
*/
Use RAII for device references
2018-11-23 17:54:12 -08:00
static DeviceRef VerifyDevice(ALCdevice *device)
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::lock_guard<std::recursive_mutex> _{ListLock};
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device);
if(iter != DeviceList.cend() && *iter == device)
Make VerifyDevice and VerifyContext modify its parameter
2015-10-19 18:48:33 -07:00
{
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
ALCdevice_IncRef(iter->get());
return DeviceRef{iter->get()};
Make VerifyDevice and VerifyContext modify its parameter
2015-10-19 18:48:33 -07:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
return DeviceRef{};
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
}
Rename ALCdevice_struct and ALCcontext_struct A (possibly contentious?) change in the public headers. Those names were never part of any specification, and I don't know why the struct names differed from the actual type name. But with C++, which takes the original struct declaration as the original name, it was affecting the type's internal symbols. This shouldn't affect user code since ALCdevice_struct and ALCcontext_struct were never part of the spec. If issues arise from this change, it should be reported.
2019-01-01 18:13:33 -08:00
ALCcontext::ALCcontext(ALCdevice *device) : Device{device}
Use a unique_ptr for the default effect slot
2018-11-20 05:01:08 -08:00
{
Use relaxed memory ordering for initializing atomic_flags
2019-02-04 21:28:37 -08:00
PropsClean.test_and_set(std::memory_order_relaxed);
Use a unique_ptr for the default effect slot
2018-11-20 05:01:08 -08:00
}
Clean up some comments
2011-09-10 09:00:01 -07:00
/* InitContext
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Initializes context fields
Clean up some comments
2011-09-10 09:00:01 -07:00
*/
Remove some more hungarian notation
2012-04-19 23:00:58 -07:00
static ALvoid InitContext(ALCcontext *Context)
Initial import
2007-11-13 18:02:18 -08:00
{
Store the listener directly in the context
2018-11-17 23:41:11 -08:00
ALlistener &listener = Context->Listener;
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
ALeffectslotArray *auxslots;
Use a lockless method for updating listener and context properties This uses a separate container to provide the relevant properties to the internal update method, using atomic pointer swaps. A free-list is used to avoid having too many individual containers. This allows the mixer to update the internal listener properties without requiring the lock to protect against async updates. It also allows concurrent read access to the user-facing property values, even the multi-value ones (e.g. the vectors).
2016-05-11 18:40:17 -07:00
Remove some more hungarian notation
2012-04-19 23:00:58 -07:00
//Validate Context
Use a vector for ALeffectslotArray
2019-01-09 18:29:22 -08:00
if(!Context->DefaultSlot)
Use a flexible array for the active effect slots
2019-01-11 07:28:44 -08:00
auxslots = ALeffectslot::CreatePtrArray(0);
Use a vector for ALeffectslotArray
2019-01-09 18:29:22 -08:00
else
Add the default auxiliary slot to the active slot array
2017-07-13 23:13:02 -07:00
{
Use a flexible array for the active effect slots
2019-01-11 07:28:44 -08:00
auxslots = ALeffectslot::CreatePtrArray(1);
(*auxslots)[0] = Context->DefaultSlot.get();
Add the default auxiliary slot to the active slot array
2017-07-13 23:13:02 -07:00
}
Avoid using ATOMIC_INIT
2018-11-26 14:31:54 -08:00
Context->ActiveAuxSlots.store(auxslots, std::memory_order_relaxed);
Use an array of pointers for effects instead of a linked list
2017-03-27 23:16:23 -07:00
Initial import
2007-11-13 18:02:18 -08:00
//Set globals
Avoid naming a struct member the same as an enum type
2018-11-18 03:39:32 -08:00
Context->mDistanceModel = DistanceModel::Default;
Remove some more hungarian notation
2012-04-19 23:00:58 -07:00
Context->SourceDistanceModel = AL_FALSE;
Context->DopplerFactor = 1.0f;
Context->DopplerVelocity = 1.0f;
Context->SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
Update the context state properties separately The context state properties are less likely to change compared to the listener state, and future changes may prefer more infrequent updates to the context state. Note that this puts the MetersPerUnit in as a context state, even though it's handled through the listener functions. Considering the infrequency that it's updated at (generally set just once for the context's lifetime), it makes more sense to put it there than with the more frequently updated listener properties. The aforementioned future changes would also prefer MetersPerUnit to not be updated unnecessarily.
2017-09-27 08:55:42 -07:00
Context->MetersPerUnit = AL_DEFAULT_METERS_PER_UNIT;
Remove some more hungarian notation
2012-04-19 23:00:58 -07:00
Context->ExtensionList = alExtList;
Update the context state properties separately The context state properties are less likely to change compared to the listener state, and future changes may prefer more infrequent updates to the context state. Note that this puts the MetersPerUnit in as a context state, even though it's handled through the listener functions. Considering the infrequency that it's updated at (generally set just once for the context's lifetime), it makes more sense to put it there than with the more frequently updated listener properties. The aforementioned future changes would also prefer MetersPerUnit to not be updated unnecessarily.
2017-09-27 08:55:42 -07:00
Use proper classes for Vector and Matrix types
2018-12-12 04:22:11 -08:00
listener.Params.Matrix = alu::Matrix::Identity();
listener.Params.Velocity = alu::Vector{};
Store the listener directly in the context
2018-11-17 23:41:11 -08:00
listener.Params.Gain = listener.Gain;
listener.Params.MetersPerUnit = Context->MetersPerUnit;
listener.Params.DopplerFactor = Context->DopplerFactor;
listener.Params.SpeedOfSound = Context->SpeedOfSound * Context->DopplerVelocity;
listener.Params.ReverbSpeedOfSound = listener.Params.SpeedOfSound *
listener.Params.MetersPerUnit;
listener.Params.SourceDistanceModel = Context->SourceDistanceModel;
Avoid naming a struct member the same as an enum type
2018-11-18 03:39:32 -08:00
listener.Params.mDistanceModel = Context->mDistanceModel;
Always start the event thread with the context
2018-09-20 19:58:01 -07:00
Return unique_ptrs instead of raw pointers For the ring buffer, channel converter, and sample converter.
2018-12-27 12:55:43 -08:00
Context->AsyncEvents = CreateRingBuffer(511, sizeof(AsyncEvent), false);
Use a std::thread for the event thread
2018-11-18 18:04:27 -08:00
StartEventThrd(Context);
Initial import
2007-11-13 18:02:18 -08:00
}
Rename ALCdevice_struct and ALCcontext_struct A (possibly contentious?) change in the public headers. Those names were never part of any specification, and I don't know why the struct names differed from the actual type name. But with C++, which takes the original struct declaration as the original name, it was affecting the type's internal symbols. This shouldn't affect user code since ALCdevice_struct and ALCcontext_struct were never part of the spec. If issues arise from this change, it should be reported.
2019-01-01 18:13:33 -08:00
/* ALCcontext::~ALCcontext()
Clean up some comments
2011-09-10 09:00:01 -07:00
*
Add a comment about when FreeContext and FreeDevice are called
2011-09-10 20:52:19 -07:00
* Cleans up the context, and destroys any remaining objects the app failed to
* delete. Called once there's no more references on the context.
Clean up some comments
2011-09-10 09:00:01 -07:00
*/
Rename ALCdevice_struct and ALCcontext_struct A (possibly contentious?) change in the public headers. Those names were never part of any specification, and I don't know why the struct names differed from the actual type name. But with C++, which takes the original struct declaration as the original name, it was affecting the type's internal symbols. This shouldn't affect user code since ALCdevice_struct and ALCcontext_struct were never part of the spec. If issues arise from this change, it should be reported.
2019-01-01 18:13:33 -08:00
ALCcontext::~ALCcontext()
Initial import
2007-11-13 18:02:18 -08:00
{
Don't log the function or prefix It's ultimately unnecessary since the message is an indicator about where it was logged from. The message itself is generally more important than where it was from, too.
2019-06-04 01:37:36 -07:00
TRACE("Freeing context %p\n", this);
Log the function name instead of the source file and line number
2011-09-02 02:00:37 -07:00
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALcontextProps *cprops{Update.exchange(nullptr, std::memory_order_relaxed)};
Use cleaner constructor/destructor calls for ALCcontext Note that the actual type name is ALCcontext_struct, because of how it's defined in AL/alc.h (ALCcontext is just an alias to struct ALCcontext_struct).
2018-11-18 05:40:00 -08:00
if(cprops)
Update the context state properties separately The context state properties are less likely to change compared to the listener state, and future changes may prefer more infrequent updates to the context state. Note that this puts the MetersPerUnit in as a context state, even though it's handled through the listener functions. Considering the infrequency that it's updated at (generally set just once for the context's lifetime), it makes more sense to put it there than with the more frequently updated listener properties. The aforementioned future changes would also prefer MetersPerUnit to not be updated unnecessarily.
2017-09-27 08:55:42 -07:00
{
TRACE("Freed unapplied context update %p\n", cprops);
al_free(cprops);
}
Use cleaner constructor/destructor calls for ALCcontext Note that the actual type name is ALCcontext_struct, because of how it's defined in AL/alc.h (ALCcontext is just an alias to struct ALCcontext_struct).
2018-11-18 05:40:00 -08:00
size_t count{0};
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
cprops = FreeContextProps.exchange(nullptr, std::memory_order_acquire);
Update the context state properties separately The context state properties are less likely to change compared to the listener state, and future changes may prefer more infrequent updates to the context state. Note that this puts the MetersPerUnit in as a context state, even though it's handled through the listener functions. Considering the infrequency that it's updated at (generally set just once for the context's lifetime), it makes more sense to put it there than with the more frequently updated listener properties. The aforementioned future changes would also prefer MetersPerUnit to not be updated unnecessarily.
2017-09-27 08:55:42 -07:00
while(cprops)
{
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALcontextProps *next{cprops->next.load(std::memory_order_relaxed)};
Update the context state properties separately The context state properties are less likely to change compared to the listener state, and future changes may prefer more infrequent updates to the context state. Note that this puts the MetersPerUnit in as a context state, even though it's handled through the listener functions. Considering the infrequency that it's updated at (generally set just once for the context's lifetime), it makes more sense to put it there than with the more frequently updated listener properties. The aforementioned future changes would also prefer MetersPerUnit to not be updated unnecessarily.
2017-09-27 08:55:42 -07:00
al_free(cprops);
cprops = next;
++count;
}
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
TRACE("Freed %zu context property object%s\n", count, (count==1)?"":"s");
Update the context state properties separately The context state properties are less likely to change compared to the listener state, and future changes may prefer more infrequent updates to the context state. Note that this puts the MetersPerUnit in as a context state, even though it's handled through the listener functions. Considering the infrequency that it's updated at (generally set just once for the context's lifetime), it makes more sense to put it there than with the more frequently updated listener properties. The aforementioned future changes would also prefer MetersPerUnit to not be updated unnecessarily.
2017-09-27 08:55:42 -07:00
Avoid some explicit loops
2018-11-28 11:30:44 -08:00
count = std::accumulate(SourceList.cbegin(), SourceList.cend(), size_t{0u},
[](size_t cur, const SourceSubList &sublist) noexcept -> size_t
{ return cur + POPCNT64(~sublist.FreeMask); }
);
Atuomatically clean up sources with its sublist's destruction
2018-11-25 08:42:43 -08:00
if(count > 0)
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
WARN("%zu Source%s not deleted\n", count, (count==1)?"":"s");
Use cleaner constructor/destructor calls for ALCcontext Note that the actual type name is ALCcontext_struct, because of how it's defined in AL/alc.h (ALCcontext is just an alias to struct ALCcontext_struct).
2018-11-18 05:40:00 -08:00
SourceList.clear();
NumSources = 0;
Add reference counting to the ALC contexts
2011-08-28 15:44:03 -07:00
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
count = 0;
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALeffectslotProps *eprops{FreeEffectslotProps.exchange(nullptr, std::memory_order_acquire)};
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
while(eprops)
{
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALeffectslotProps *next{eprops->next.load(std::memory_order_relaxed)};
Use proper inheritence for the effect state objects
2018-11-19 22:34:26 -08:00
if(eprops->State) eprops->State->DecRef();
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
al_free(eprops);
eprops = next;
++count;
}
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
TRACE("Freed %zu AuxiliaryEffectSlot property object%s\n", count, (count==1)?"":"s");
Use a vector to store the effect slot pointers And make the ID a simple index into it (1-base, to avoid ID 0).
2018-01-27 17:24:18 -08:00
Use a vector for ALeffectslotArray
2019-01-09 18:29:22 -08:00
delete ActiveAuxSlots.exchange(nullptr, std::memory_order_relaxed);
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
DefaultSlot = nullptr;
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
count = std::accumulate(EffectSlotList.cbegin(), EffectSlotList.cend(), size_t{0u},
[](size_t cur, const EffectSlotSubList &sublist) noexcept -> size_t
{ return cur + POPCNT64(~sublist.FreeMask); }
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
);
Avoid a separate function to clean up effect slots
2018-11-25 09:23:01 -08:00
if(count > 0)
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
WARN("%zu AuxiliaryEffectSlot%s not deleted\n", count, (count==1)?"":"s");
Use cleaner constructor/destructor calls for ALCcontext Note that the actual type name is ALCcontext_struct, because of how it's defined in AL/alc.h (ALCcontext is just an alias to struct ALCcontext_struct).
2018-11-18 05:40:00 -08:00
EffectSlotList.clear();
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
NumEffectSlots = 0;
Add reference counting to the ALC contexts
2011-08-28 15:44:03 -07:00
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
count = 0;
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALvoiceProps *vprops{FreeVoiceProps.exchange(nullptr, std::memory_order_acquire)};
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
while(vprops)
{
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALvoiceProps *next{vprops->next.load(std::memory_order_relaxed)};
Don't bother making ALvoiceProps dynamically sized
2018-11-30 16:56:23 -08:00
delete vprops;
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
vprops = next;
++count;
}
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
TRACE("Freed %zu voice property object%s\n", count, (count==1)?"":"s");
Re-update effect slots when context properties change Also keep all free property update structs together in the context instead of per-object.
2017-09-27 11:13:18 -07:00
Use cleaner constructor/destructor calls for ALCcontext Note that the actual type name is ALCcontext_struct, because of how it's defined in AL/alc.h (ALCcontext is just an alias to struct ALCcontext_struct).
2018-11-18 05:40:00 -08:00
Voices = nullptr;
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
VoiceCount.store(0, std::memory_order_relaxed);
Use a separate array for the auxiliary slots in the mixer
2011-08-30 20:13:42 -07:00
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALlistenerProps *lprops{Listener.Update.exchange(nullptr, std::memory_order_relaxed)};
Use cleaner constructor/destructor calls for ALCcontext Note that the actual type name is ALCcontext_struct, because of how it's defined in AL/alc.h (ALCcontext is just an alias to struct ALCcontext_struct).
2018-11-18 05:40:00 -08:00
if(lprops)
Use a lockless method for updating listener and context properties This uses a separate container to provide the relevant properties to the internal update method, using atomic pointer swaps. A free-list is used to avoid having too many individual containers. This allows the mixer to update the internal listener properties without requiring the lock to protect against async updates. It also allows concurrent read access to the user-facing property values, even the multi-value ones (e.g. the vectors).
2016-05-11 18:40:17 -07:00
{
TRACE("Freed unapplied listener update %p\n", lprops);
al_free(lprops);
}
count = 0;
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
lprops = FreeListenerProps.exchange(nullptr, std::memory_order_acquire);
Use a lockless method for updating listener and context properties This uses a separate container to provide the relevant properties to the internal update method, using atomic pointer swaps. A free-list is used to avoid having too many individual containers. This allows the mixer to update the internal listener properties without requiring the lock to protect against async updates. It also allows concurrent read access to the user-facing property values, even the multi-value ones (e.g. the vectors).
2016-05-11 18:40:17 -07:00
while(lprops)
{
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
ALlistenerProps *next{lprops->next.load(std::memory_order_relaxed)};
Use a lockless method for updating listener and context properties This uses a separate container to provide the relevant properties to the internal update method, using atomic pointer swaps. A free-list is used to avoid having too many individual containers. This allows the mixer to update the internal listener properties without requiring the lock to protect against async updates. It also allows concurrent read access to the user-facing property values, even the multi-value ones (e.g. the vectors).
2016-05-11 18:40:17 -07:00
al_free(lprops);
lprops = next;
++count;
}
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
TRACE("Freed %zu listener property object%s\n", count, (count==1)?"":"s");
Use a lockless method for updating listener and context properties This uses a separate container to provide the relevant properties to the internal update method, using atomic pointer swaps. A free-list is used to avoid having too many individual containers. This allows the mixer to update the internal listener properties without requiring the lock to protect against async updates. It also allows concurrent read access to the user-facing property values, even the multi-value ones (e.g. the vectors).
2016-05-11 18:40:17 -07:00
Don't try to clean up the async ringbuffer if it isn't allocated
2019-01-26 19:29:26 -08:00
if(AsyncEvents)
Construct AsyncEvent objects directly in the ringbuffer
2018-12-25 09:32:38 -08:00
{
Don't try to clean up the async ringbuffer if it isn't allocated
2019-01-26 19:29:26 -08:00
count = 0;
auto evt_vec = AsyncEvents->getReadVector();
Avoid manually looping to destroy orphaned async events
2019-06-16 18:58:56 -07:00
if(evt_vec.first.len > 0)
Don't try to clean up the async ringbuffer if it isn't allocated
2019-01-26 19:29:26 -08:00
{
Avoid manually looping to destroy orphaned async events
2019-06-16 18:58:56 -07:00
al::destroy_n(reinterpret_cast<AsyncEvent*>(evt_vec.first.buf), evt_vec.first.len);
count += evt_vec.first.len;
Don't try to clean up the async ringbuffer if it isn't allocated
2019-01-26 19:29:26 -08:00
}
Avoid manually looping to destroy orphaned async events
2019-06-16 18:58:56 -07:00
if(evt_vec.second.len > 0)
Don't try to clean up the async ringbuffer if it isn't allocated
2019-01-26 19:29:26 -08:00
{
Avoid manually looping to destroy orphaned async events
2019-06-16 18:58:56 -07:00
al::destroy_n(reinterpret_cast<AsyncEvent*>(evt_vec.second.buf), evt_vec.second.len);
count += evt_vec.second.len;
Don't try to clean up the async ringbuffer if it isn't allocated
2019-01-26 19:29:26 -08:00
}
if(count > 0)
Remove the SZFMT macro C++11 mandates the %zu/d formatter
2019-04-11 16:01:11 -07:00
TRACE("Destructed %zu orphaned event%s\n", count, (count==1)?"":"s");
Avoid manually looping to destroy orphaned async events
2019-06-16 18:58:56 -07:00
AsyncEvents->readAdvance(count);
Construct AsyncEvent objects directly in the ringbuffer
2018-12-25 09:32:38 -08:00
}
Use cleaner constructor/destructor calls for ALCcontext Note that the actual type name is ALCcontext_struct, because of how it's defined in AL/alc.h (ALCcontext is just an alias to struct ALCcontext_struct).
2018-11-18 05:40:00 -08:00
ALCdevice_DecRef(Device);
Initial import
2007-11-13 18:02:18 -08:00
}
Clean up some comments
2011-09-10 09:00:01 -07:00
/* ReleaseContext
*
* Removes the context reference from the given device and removes it from
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
* being current on the running thread or globally. Returns true if other
* contexts still exist on the device.
Clean up some comments
2011-09-10 09:00:01 -07:00
*/
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
static bool ReleaseContext(ALCcontext *context, ALCdevice *device)
Properly destroy contexts that are left on the device when it's closed
2011-09-10 07:35:48 -07:00
{
Avoid using C-style TLS
2018-11-16 21:55:11 -08:00
if(LocalContext.get() == context)
Remove the context from being current before removing it from the device
2011-09-12 03:35:21 -07:00
{
WARN("%p released while current on thread\n", context);
Avoid using C-style TLS
2018-11-16 21:55:11 -08:00
LocalContext.set(nullptr);
Remove the context from being current before removing it from the device
2011-09-12 03:35:21 -07:00
ALCcontext_DecRef(context);
}
Use standard unique_lock and lock_guard for the backend lock
2019-01-01 16:38:54 -08:00
ALCcontext *origctx{context};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
if(GlobalContext.compare_exchange_strong(origctx, nullptr))
Remove the context from being current before removing it from the device
2011-09-12 03:35:21 -07:00
ALCcontext_DecRef(context);
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
bool ret{};
{
using ContextArray = al::FlexArray<ALCcontext*>;
/* First make sure this context exists in the device's list. */
auto *oldarray = device->mContexts.load(std::memory_order_acquire);
if(auto toremove = std::count(oldarray->begin(), oldarray->end(), context))
Use standard unique_lock and lock_guard for the backend lock
2019-01-01 16:38:54 -08:00
{
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
auto alloc_ctx_array = [](const size_t count) -> ContextArray*
{
if(count == 0) return &EmptyContextArray;
void *ptr{al_calloc(alignof(ContextArray), ContextArray::Sizeof(count))};
return new (ptr) ContextArray{count};
};
auto *newarray = alloc_ctx_array(oldarray->size() - toremove);
/* Copy the current/old context handles to the new array, excluding
* the given context.
*/
std::copy_if(oldarray->begin(), oldarray->end(), newarray->begin(),
std::bind(std::not_equal_to<ALCcontext*>{}, _1, context));
/* Store the new context array in the device. Wait for any current
* mix to finish before deleting the old array.
*/
device->mContexts.store(newarray);
if(oldarray != &EmptyContextArray)
{
while((device->MixCount.load(std::memory_order_acquire)&1))
std::this_thread::yield();
delete oldarray;
}
ret = !newarray->empty();
Use standard unique_lock and lock_guard for the backend lock
2019-01-01 16:38:54 -08:00
}
else
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
ret = !oldarray->empty();
Properly destroy contexts that are left on the device when it's closed
2011-09-10 07:35:48 -07:00
}
Use a std::thread for the event thread
2018-11-18 18:04:27 -08:00
StopEventThrd(context);
Stop the event thread when releasing the context To ensure no user callback gets called after alcDestroyContext.
2018-09-20 22:44:58 -07:00
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
return ret;
Properly destroy contexts that are left on the device when it's closed
2011-09-10 07:35:48 -07:00
}
Make a couple functions inline
2018-01-12 02:37:48 -08:00
static void ALCcontext_IncRef(ALCcontext *context)
Hold a reference on the context when being set as current on the thread This should vastly improve efficiency for retrieving the current thread context, as we can be assured the stored context pointer will always be valid.
2011-08-28 18:08:48 -07:00
{
Simplify the RefCount type
2018-11-19 02:17:06 -08:00
auto ref = IncrementRef(&context->ref);
Don't log the function or prefix It's ultimately unnecessary since the message is an indicator about where it was logged from. The message itself is generally more important than where it was from, too.
2019-06-04 01:37:36 -07:00
TRACEREF("ALCcontext %p increasing refcount to %u\n", context, ref);
Hold a reference on the context when being set as current on the thread This should vastly improve efficiency for retrieving the current thread context, as we can be assured the stored context pointer will always be valid.
2011-08-28 18:08:48 -07:00
}
Lock the context as needed for the defer and process calls
2011-08-29 13:22:07 -07:00
void ALCcontext_DecRef(ALCcontext *context)
Add reference counting to the ALC contexts
2011-08-28 15:44:03 -07:00
{
Simplify the RefCount type
2018-11-19 02:17:06 -08:00
auto ref = DecrementRef(&context->ref);
Don't log the function or prefix It's ultimately unnecessary since the message is an indicator about where it was logged from. The message itself is generally more important than where it was from, too.
2019-06-04 01:37:36 -07:00
TRACEREF("ALCcontext %p decreasing refcount to %u\n", context, ref);
Mark the device and context deletes as unlikely
2019-03-24 13:54:49 -07:00
if(UNLIKELY(ref == 0)) delete context;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* VerifyContext
*
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
* Checks if the given context is valid, returning a new reference to it if so.
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
*/
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
static ContextRef VerifyContext(ALCcontext *context)
Initial import
2007-11-13 18:02:18 -08:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::lock_guard<std::recursive_mutex> _{ListLock};
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
auto iter = std::lower_bound(ContextList.cbegin(), ContextList.cend(), context);
if(iter != ContextList.cend() && *iter == context)
Avoid holding the global list lock while calling some capture methods
2011-07-13 01:21:30 -07:00
{
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
ALCcontext_IncRef(iter->get());
return ContextRef{iter->get()};
Avoid holding the global list lock while calling some capture methods
2011-07-13 01:21:30 -07:00
}
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
return ContextRef{};
Initial import
2007-11-13 18:02:18 -08:00
}
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/* GetContextRef
*
Make GetContextRef return a ContextRef
2018-11-24 14:07:32 -08:00
* Returns a new reference to the currently active context for this thread.
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
*/
Make GetContextRef return a ContextRef
2018-11-24 14:07:32 -08:00
ContextRef GetContextRef(void)
Initial import
2007-11-13 18:02:18 -08:00
{
Avoid using C-style TLS
2018-11-16 21:55:11 -08:00
ALCcontext *context{LocalContext.get()};
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
if(context)
ALCcontext_IncRef(context);
else
Avoid holding the global list lock while calling some capture methods
2011-07-13 01:21:30 -07:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::lock_guard<std::recursive_mutex> _{ListLock};
context = GlobalContext.load(std::memory_order_acquire);
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(context) ALCcontext_IncRef(context);
Avoid holding the global list lock while calling some capture methods
2011-07-13 01:21:30 -07:00
}
Make GetContextRef return a ContextRef
2018-11-24 14:07:32 -08:00
return ContextRef{context};
Initial import
2007-11-13 18:02:18 -08:00
}
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
void AllocateVoices(ALCcontext *context, size_t num_voices)
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
{
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
ALCdevice *device{context->Device};
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
const ALsizei num_sends{device->NumAuxSends};
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
if(context->Voices && num_voices == context->Voices->size())
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
return;
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
std::unique_ptr<al::FlexArray<ALvoice>> voices;
{
void *ptr{al_calloc(16, al::FlexArray<ALvoice>::Sizeof(num_voices))};
voices.reset(new (ptr) al::FlexArray<ALvoice>{num_voices});
}
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
Make the voice count unsigned
2019-06-09 19:27:15 -07:00
const size_t v_count{minz(context->VoiceCount.load(std::memory_order_relaxed), num_voices)};
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
if(context->Voices)
{
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
/* Copy the old voice data to the new storage. */
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
auto viter = std::move(context->Voices->begin(), context->Voices->begin()+v_count,
voices->begin());
Improve construction and destruction of ALvoices
2018-11-30 19:04:38 -08:00
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
/* Clear extraneous property set sends. */
auto clear_sends = [num_sends](ALvoice &voice) -> void
{
std::fill(std::begin(voice.mProps.Send)+num_sends, std::end(voice.mProps.Send),
Improve construction and destruction of ALvoices
2018-11-30 19:04:38 -08:00
ALvoiceProps::SendData{});
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
std::fill(voice.mSend.begin()+num_sends, voice.mSend.end(), ALvoice::SendData{});
auto clear_chan_sends = [num_sends](ALvoice::ChannelData &chandata) -> void
Restructure voice data members This should improve access patters by packing each buffer channel's data together, which is more inline with its use.
2019-06-03 22:24:26 -07:00
{
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
std::fill(chandata.mWetParams.begin()+num_sends, chandata.mWetParams.end(),
Restructure voice data members This should improve access patters by packing each buffer channel's data together, which is more inline with its use.
2019-06-03 22:24:26 -07:00
SendParams{});
};
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
std::for_each(voice.mChans.begin(), voice.mChans.end(), clear_chan_sends);
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
};
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
std::for_each(voices->begin(), viter, clear_sends);
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
}
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
context->Voices = std::move(voices);
Make the voice count unsigned
2019-06-09 19:27:15 -07:00
context->VoiceCount.store(static_cast<ALuint>(v_count), std::memory_order_relaxed);
Make ALsourceProps' Send array dynamically sized ALsourceProps' Send[] array is placed at the end of the struct, and given an indeterminate size. Extra space is allocated at the end of each struct given the number of auxiliary sends set for the device.
2017-02-14 19:59:39 -08:00
}
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Standard ALC functions
************************************************/
/* alcGetError
*
* Return last ALC generated error code for the given device
Use RAII for device references
2018-11-23 17:54:12 -08:00
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(dev) return dev->LastError.exchange(ALC_NO_ERROR);
return LastNullDeviceError.exchange(ALC_NO_ERROR);
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcSuspendContext
*
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
* Suspends updates for the given context
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *context)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
if(!SuspendDefers)
return;
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ContextRef ctx{VerifyContext(context)};
if(!ctx)
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_CONTEXT);
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
else
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ALCcontext_DeferUpdates(ctx.get());
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcProcessContext
*
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
* Resumes processing updates for the given context
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *context)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
if(!SuspendDefers)
return;
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ContextRef ctx{VerifyContext(context)};
if(!ctx)
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_CONTEXT);
Make alcSuspendContext and alcProcessContext batch updates This behavior better matches Creative's hardware drivers and Rapture3D's OpenAL driver. A compatibility environment variable is provided to restore the old no-op behavior for any app that behaves badly from this change (set __ALSOFT_SUSPEND_CONTEXT to "ignore"). If too many apps have a problem with this, the default behavior may need to be changed to ignore, with the env var providing an option to defer/batch instead.
2014-10-12 09:03:08 -07:00
else
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ALCcontext_ProcessUpdates(ctx.get());
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcGetString
*
Remove some more hungarian notation
2012-04-19 23:28:34 -07:00
* Returns information about the device, and error strings
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Remove some more hungarian notation
2012-04-19 23:28:34 -07:00
ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
const ALCchar *value = nullptr;
Initial import
2007-11-13 18:02:18 -08:00
Separate config init from library init OSX has a bug where the file descriptor resource limit can't be increased once certain functions (such as fopen) are used. Since lib initialization happens in a global constructor and includes opening and parsing config files, it prevents apps from being able to increase the rlimit once the lib is loaded, which is usually before main(). By delaying config init, it allows apps the opportunity to change the rlimit before calling certain OpenAL functions.
2011-06-14 09:43:33 -07:00
switch(param)
Initial import
2007-11-13 18:02:18 -08:00
{
case ALC_NO_ERROR:
value = alcNoError;
break;
case ALC_INVALID_ENUM:
value = alcErrInvalidEnum;
break;
case ALC_INVALID_VALUE:
value = alcErrInvalidValue;
break;
case ALC_INVALID_DEVICE:
value = alcErrInvalidDevice;
break;
case ALC_INVALID_CONTEXT:
value = alcErrInvalidContext;
break;
case ALC_OUT_OF_MEMORY:
value = alcErrOutOfMemory;
break;
case ALC_DEVICE_SPECIFIER:
Give "OpenAL Soft" for the standard device name
2012-02-28 03:36:16 -08:00
value = alcDefaultName;
break;
case ALC_ALL_DEVICES_SPECIFIER:
Declare variables closer to their use
2019-06-29 15:04:20 -07:00
if(DeviceRef dev{VerifyDevice(Device)})
Use RAII for device references
2018-11-23 17:54:12 -08:00
value = dev->DeviceName.c_str();
Give "OpenAL Soft" for the standard device name
2012-02-28 03:36:16 -08:00
else
{
Rename AllDevice -> AllDevices
2012-05-09 16:28:16 -07:00
ProbeAllDevicesList();
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
value = alcAllDevicesList.c_str();
Give "OpenAL Soft" for the standard device name
2012-02-28 03:36:16 -08:00
}
Initial import
2007-11-13 18:02:18 -08:00
break;
case ALC_CAPTURE_DEVICE_SPECIFIER:
Declare variables closer to their use
2019-06-29 15:04:20 -07:00
if(DeviceRef dev{VerifyDevice(Device)})
Use RAII for device references
2018-11-23 17:54:12 -08:00
value = dev->DeviceName.c_str();
Initial import
2007-11-13 18:02:18 -08:00
else
Rebuild device lists when retrieving them
2009-08-27 06:09:33 -07:00
{
ProbeCaptureDeviceList();
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
value = alcCaptureDeviceList.c_str();
Rebuild device lists when retrieving them
2009-08-27 06:09:33 -07:00
}
Initial import
2007-11-13 18:02:18 -08:00
break;
Make a copy of the default device name for the app The pointer to it could otherwise change if the device list is rebuilt, which would be bad if the app has it
2009-08-27 20:13:35 -07:00
/* Default devices are always first in the list */
case ALC_DEFAULT_DEVICE_SPECIFIER:
Always use "OpenAL Soft" for the short device enumeration list
2012-02-20 20:45:22 -08:00
value = alcDefaultName;
Make a copy of the default device name for the app The pointer to it could otherwise change if the device list is rebuilt, which would be bad if the app has it
2009-08-27 20:13:35 -07:00
break;
case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
if(alcAllDevicesList.empty())
Rename AllDevice -> AllDevices
2012-05-09 16:28:16 -07:00
ProbeAllDevicesList();
Avoid probing for devices on lib initialization
2010-02-10 16:34:43 -08:00
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
/* Copy first entry as default. */
alcDefaultAllDevicesSpecifier = alcAllDevicesList.c_str();
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
value = alcDefaultAllDevicesSpecifier.c_str();
Make a copy of the default device name for the app The pointer to it could otherwise change if the device list is rebuilt, which would be bad if the app has it
2009-08-27 20:13:35 -07:00
break;
Initial import
2007-11-13 18:02:18 -08:00
case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
if(alcCaptureDeviceList.empty())
Avoid probing for devices on lib initialization
2010-02-10 16:34:43 -08:00
ProbeCaptureDeviceList();
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
/* Copy first entry as default. */
alcCaptureDefaultDeviceSpecifier = alcCaptureDeviceList.c_str();
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
value = alcCaptureDefaultDeviceSpecifier.c_str();
Initial import
2007-11-13 18:02:18 -08:00
break;
case ALC_EXTENSIONS:
Declare variables closer to their use
2019-06-29 15:04:20 -07:00
if(VerifyDevice(Device))
value = alcExtensionList;
else
value = alcNoDeviceExtList;
Initial import
2007-11-13 18:02:18 -08:00
break;
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
case ALC_HRTF_SPECIFIER_SOFT:
Declare variables closer to their use
2019-06-29 15:04:20 -07:00
if(DeviceRef dev{VerifyDevice(Device)})
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
{
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
value = (dev->mHrtf ? dev->HrtfName.c_str() : "");
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
}
Declare variables closer to their use
2019-06-29 15:04:20 -07:00
else
alcSetError(nullptr, ALC_INVALID_DEVICE);
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
break;
Initial import
2007-11-13 18:02:18 -08:00
default:
Declare variables closer to their use
2019-06-29 15:04:20 -07:00
alcSetError(VerifyDevice(Device).get(), ALC_INVALID_ENUM);
Initial import
2007-11-13 18:02:18 -08:00
break;
}
return value;
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
static inline ALCsizei NumAttrsForDevice(ALCdevice *device)
{
Add missing integer queries
2017-12-21 11:46:01 -08:00
if(device->Type == Capture) return 9;
Make NumAttrsForDevice do similar type checks as alcGetIntegerv
2018-01-12 11:34:23 -08:00
if(device->Type != Loopback) return 29;
if(device->FmtChans == DevFmtAmbi3D)
Add missing integer queries
2017-12-21 11:46:01 -08:00
return 35;
return 29;
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
}
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, const al::span<ALCint> values)
Initial import
2007-11-13 18:02:18 -08:00
{
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
ALCsizei i;
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
if(values.empty())
Reduce some indentation
2010-01-08 01:21:57 -08:00
{
alcSetError(device, ALC_INVALID_VALUE);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 0;
Reduce some indentation
2010-01-08 01:21:57 -08:00
}
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
if(!device)
Initial import
2007-11-13 18:02:18 -08:00
{
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
switch(param)
Initial import
2007-11-13 18:02:18 -08:00
{
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
case ALC_MAJOR_VERSION:
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
values[0] = alcMajorVersion;
return 1;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
case ALC_MINOR_VERSION:
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
values[0] = alcMinorVersion;
return 1;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
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:
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
case ALC_AMBISONIC_LAYOUT_SOFT:
case ALC_AMBISONIC_SCALING_SOFT:
case ALC_AMBISONIC_ORDER_SOFT:
Avoid a separate function to query ambisonic mode support Now FuMa and ACN channel orders are required, as are FuMa, SN3D, and N3D normalization schemes. An integer query (alcGetIntegerv) is added for the maximum ambisonic order.
2017-09-27 11:58:36 -07:00
case ALC_MAX_AMBISONIC_ORDER_SOFT:
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_DEVICE);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 0;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
default:
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_ENUM);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 0;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 0;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
if(device->Type == Capture)
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
{
switch(param)
{
Add missing integer queries
2017-12-21 11:46:01 -08:00
case ALC_ATTRIBUTES_SIZE:
values[0] = NumAttrsForDevice(device);
return 1;
case ALC_ALL_ATTRIBUTES:
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
i = 0;
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
if(values.size() < static_cast<size_t>(NumAttrsForDevice(device)))
Add missing integer queries
2017-12-21 11:46:01 -08:00
alcSetError(device, ALC_INVALID_VALUE);
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
else
{
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{device->StateLock};
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_MAJOR_VERSION;
values[i++] = alcMajorVersion;
values[i++] = ALC_MINOR_VERSION;
values[i++] = alcMinorVersion;
values[i++] = ALC_CAPTURE_SAMPLES;
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
values[i++] = device->Backend->availableSamples();
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_CONNECTED;
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
values[i++] = device->Connected.load(std::memory_order_relaxed);
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = 0;
Add missing integer queries
2017-12-21 11:46:01 -08:00
}
return i;
case ALC_MAJOR_VERSION:
values[0] = alcMajorVersion;
return 1;
case ALC_MINOR_VERSION:
values[0] = alcMinorVersion;
return 1;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
case ALC_CAPTURE_SAMPLES:
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{device->StateLock};
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
values[0] = device->Backend->availableSamples();
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 1;
Initial import
2007-11-13 18:02:18 -08:00
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
case ALC_CONNECTED:
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{device->StateLock};
Attempt to reconnect lost devices with alcResetDeviceSOFT Be aware there's currently possible race conditions with PulseAudio's callbacks (the state callbacks need to be cleared while not playing). Also paused sources will assert/crash if attempted to play again without being explicitly stopped or rewound first. Both of these will eventually be fixed (though a paused source's offset will be lost regardless).
2018-11-28 12:24:12 -08:00
values[0] = device->Connected.load(std::memory_order_acquire);
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 1;
Add base support for ALC_EXT_disconnect Individual backends need to be updated to handle disconnection events
2009-08-26 19:15:17 -07:00
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
default:
alcSetError(device, ALC_INVALID_ENUM);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 0;
Initial import
2007-11-13 18:02:18 -08:00
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 0;
Initial import
2007-11-13 18:02:18 -08:00
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
/* render device */
switch(param)
Initial import
2007-11-13 18:02:18 -08:00
{
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_ATTRIBUTES_SIZE:
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
values[0] = NumAttrsForDevice(device);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 1;
Initial import
2007-11-13 18:02:18 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_ALL_ATTRIBUTES:
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
i = 0;
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
if(values.size() < static_cast<size_t>(NumAttrsForDevice(device)))
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
alcSetError(device, ALC_INVALID_VALUE);
else
{
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{device->StateLock};
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
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++] = device->Frequency;
if(device->Type != Loopback)
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
{
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_REFRESH;
values[i++] = device->Frequency / device->UpdateSize;
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_SYNC;
values[i++] = ALC_FALSE;
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
}
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
else
{
if(device->FmtChans == DevFmtAmbi3D)
{
values[i++] = ALC_AMBISONIC_LAYOUT_SOFT;
values[i++] = static_cast<ALCint>(device->mAmbiLayout);
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_AMBISONIC_SCALING_SOFT;
values[i++] = static_cast<ALCint>(device->mAmbiScale);
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_AMBISONIC_ORDER_SOFT;
values[i++] = device->mAmbiOrder;
}
values[i++] = ALC_FORMAT_CHANNELS_SOFT;
values[i++] = device->FmtChans;
values[i++] = ALC_FORMAT_TYPE_SOFT;
values[i++] = device->FmtType;
}
Initial import
2007-11-13 18:02:18 -08:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_MONO_SOURCES;
values[i++] = device->NumMonoSources;
Initial import
2007-11-13 18:02:18 -08:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_STEREO_SOURCES;
values[i++] = device->NumStereoSources;
Implement ALC properties
2007-12-17 16:55:07 -08:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_MAX_AUXILIARY_SENDS;
values[i++] = device->NumAuxSends;
Initial import
2007-11-13 18:02:18 -08:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_HRTF_SOFT;
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
values[i++] = (device->mHrtf ? ALC_TRUE : ALC_FALSE);
Start an extension that can query the status of HRTF rendering
2013-05-31 15:49:56 -07:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_HRTF_STATUS_SOFT;
values[i++] = device->HrtfStatus;
Allow querying the output limiter state
2017-04-30 08:54:49 -07:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_OUTPUT_LIMITER_SOFT;
values[i++] = device->Limiter ? ALC_TRUE : ALC_FALSE;
Avoid a separate function to query ambisonic mode support Now FuMa and ACN channel orders are required, as are FuMa, SN3D, and N3D normalization schemes. An integer query (alcGetIntegerv) is added for the maximum ambisonic order.
2017-09-27 11:58:36 -07:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = ALC_MAX_AMBISONIC_ORDER_SOFT;
values[i++] = MAX_AMBI_ORDER;
Add an HRTF status query This can report the status of HRTF, specifying if it's enabled or not and why (currently only reports unsupported formats, but this may be extended).
2015-05-15 23:28:03 -07:00
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[i++] = 0;
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return i;
Initial import
2007-11-13 18:02:18 -08:00
Add missing integer queries
2017-12-21 11:46:01 -08:00
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;
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_FREQUENCY:
values[0] = device->Frequency;
return 1;
Initial import
2007-11-13 18:02:18 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_REFRESH:
if(device->Type == Loopback)
{
alcSetError(device, ALC_INVALID_DEVICE);
return 0;
}
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{device->StateLock};
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[0] = device->Frequency / device->UpdateSize;
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 1;
Initial import
2007-11-13 18:02:18 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_SYNC:
if(device->Type == Loopback)
{
alcSetError(device, ALC_INVALID_DEVICE);
return 0;
}
values[0] = ALC_FALSE;
return 1;
Initial import
2007-11-13 18:02:18 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_FORMAT_CHANNELS_SOFT:
if(device->Type != Loopback)
{
alcSetError(device, ALC_INVALID_DEVICE);
return 0;
}
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
values[0] = device->FmtChans;
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 1;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_FORMAT_TYPE_SOFT:
if(device->Type != Loopback)
{
alcSetError(device, ALC_INVALID_DEVICE);
return 0;
}
values[0] = device->FmtType;
return 1;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
case ALC_AMBISONIC_LAYOUT_SOFT:
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
if(device->Type != Loopback || device->FmtChans != DevFmtAmbi3D)
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
{
alcSetError(device, ALC_INVALID_DEVICE);
return 0;
}
Use an enum class for AmbiLayout/Norm settings
2018-11-20 22:47:24 -08:00
values[0] = static_cast<ALCint>(device->mAmbiLayout);
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
return 1;
case ALC_AMBISONIC_SCALING_SOFT:
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
if(device->Type != Loopback || device->FmtChans != DevFmtAmbi3D)
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
{
alcSetError(device, ALC_INVALID_DEVICE);
return 0;
}
Use an enum class for AmbiLayout/Norm settings
2018-11-20 22:47:24 -08:00
values[0] = static_cast<ALCint>(device->mAmbiScale);
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
return 1;
case ALC_AMBISONIC_ORDER_SOFT:
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
if(device->Type != Loopback || device->FmtChans != DevFmtAmbi3D)
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
{
alcSetError(device, ALC_INVALID_DEVICE);
return 0;
}
Avoid more cases of an enum variable and type name clash
2018-11-18 08:01:50 -08:00
values[0] = device->mAmbiOrder;
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
return 1;
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_MONO_SOURCES:
values[0] = device->NumMonoSources;
return 1;
Allow querying of ALC_MONO_SOURCES and ALC_STEREO_SOURCES Based on a patch by Xavier Bouchoux
2008-01-10 08:24:23 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_STEREO_SOURCES:
values[0] = device->NumStereoSources;
return 1;
Allow querying of ALC_MONO_SOURCES and ALC_STEREO_SOURCES Based on a patch by Xavier Bouchoux
2008-01-10 08:24:23 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_MAX_AUXILIARY_SENDS:
values[0] = device->NumAuxSends;
return 1;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_CONNECTED:
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{device->StateLock};
Attempt to reconnect lost devices with alcResetDeviceSOFT Be aware there's currently possible race conditions with PulseAudio's callbacks (the state callbacks need to be cleared while not playing). Also paused sources will assert/crash if attempted to play again without being explicitly stopped or rewound first. Both of these will eventually be fixed (though a paused source's offset will be lost regardless).
2018-11-28 12:24:12 -08:00
values[0] = device->Connected.load(std::memory_order_acquire);
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 1;
Add experimental device attributes for apps to query These will be part of the ALC_EXT_device_time extension. Behavior, values, etc, are all subject to change.
2010-07-30 20:23:55 -07:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
case ALC_HRTF_SOFT:
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
values[0] = (device->mHrtf ? ALC_TRUE : ALC_FALSE);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 1;
Start an extension that can query the status of HRTF rendering
2013-05-31 15:49:56 -07:00
Add an HRTF status query This can report the status of HRTF, specifying if it's enabled or not and why (currently only reports unsupported formats, but this may be extended).
2015-05-15 23:28:03 -07:00
case ALC_HRTF_STATUS_SOFT:
Dynamically allocate the device's HRTF state
2017-03-10 10:47:43 -08:00
values[0] = device->HrtfStatus;
Return the number of properties written
2015-09-24 10:45:34 -07:00
return 1;
Add an HRTF status query This can report the status of HRTF, specifying if it's enabled or not and why (currently only reports unsupported formats, but this may be extended).
2015-05-15 23:28:03 -07:00
Rename ALC_NUM_HRTF_SPECIFIER_SOFT to ALC_NUM_HRTF_SPECIFIERS_SOFT
2015-10-26 22:34:02 -07:00
case ALC_NUM_HRTF_SPECIFIERS_SOFT:
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{device->StateLock};
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
device->HrtfList.clear();
device->HrtfList = EnumerateHrtf(device->DeviceName.c_str());
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
values[0] = static_cast<ALCint>(minz(device->HrtfList.size(),
std::numeric_limits<ALCint>::max()));
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
}
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
return 1;
Allow querying the output limiter state
2017-04-30 08:54:49 -07:00
case ALC_OUTPUT_LIMITER_SOFT:
Calculate the output limiter gain using the RMS
2017-05-05 07:38:26 -07:00
values[0] = device->Limiter ? ALC_TRUE : ALC_FALSE;
Allow querying the output limiter state
2017-04-30 08:54:49 -07:00
return 1;
Add missing integer queries
2017-12-21 11:46:01 -08:00
case ALC_MAX_AMBISONIC_ORDER_SOFT:
values[0] = MAX_AMBI_ORDER;
return 1;
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
default:
alcSetError(device, ALC_INVALID_ENUM);
return 0;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
return 0;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
/* alcGetIntegerv
*
* Returns information about the device and the version of OpenAL
*/
ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(size <= 0 || values == nullptr)
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_VALUE);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
else
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
GetIntegerv(dev.get(), param, {values, values+size});
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALCsizei size, ALCint64SOFT *values)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(size <= 0 || values == nullptr)
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_VALUE);
else if(!dev || dev->Type == Capture)
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
{
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
auto ivals = al::vector<ALCint>(size);
size = GetIntegerv(dev.get(), pname, {ivals.data(), ivals.size()});
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
std::copy(ivals.begin(), ivals.begin()+size, values);
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
}
else /* render device */
{
switch(pname)
{
case ALC_ATTRIBUTES_SIZE:
Use RAII for device references
2018-11-23 17:54:12 -08:00
*values = NumAttrsForDevice(dev.get())+4;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
break;
case ALC_ALL_ATTRIBUTES:
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(size < NumAttrsForDevice(dev.get())+4)
alcSetError(dev.get(), ALC_INVALID_VALUE);
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
else
{
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
ALsizei i{0};
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = ALC_FREQUENCY;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->Frequency;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(dev->Type != Loopback)
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
{
values[i++] = ALC_REFRESH;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->Frequency / dev->UpdateSize;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = ALC_SYNC;
values[i++] = ALC_FALSE;
}
else
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(dev->FmtChans == DevFmtAmbi3D)
Fix alcGetInteger64vSOFT to handle ambisonic attributes
2017-03-18 14:33:40 -07:00
{
values[i++] = ALC_AMBISONIC_LAYOUT_SOFT;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = static_cast<ALCint64SOFT>(dev->mAmbiLayout);
Fix alcGetInteger64vSOFT to handle ambisonic attributes
2017-03-18 14:33:40 -07:00
values[i++] = ALC_AMBISONIC_SCALING_SOFT;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = static_cast<ALCint64SOFT>(dev->mAmbiScale);
Fix alcGetInteger64vSOFT to handle ambisonic attributes
2017-03-18 14:33:40 -07:00
values[i++] = ALC_AMBISONIC_ORDER_SOFT;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->mAmbiOrder;
Fix alcGetInteger64vSOFT to handle ambisonic attributes
2017-03-18 14:33:40 -07:00
}
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
values[i++] = ALC_FORMAT_CHANNELS_SOFT;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->FmtChans;
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = ALC_FORMAT_TYPE_SOFT;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->FmtType;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
}
values[i++] = ALC_MONO_SOURCES;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->NumMonoSources;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = ALC_STEREO_SOURCES;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->NumStereoSources;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = ALC_MAX_AUXILIARY_SENDS;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->NumAuxSends;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = ALC_HRTF_SOFT;
Rename a couple HRTF structs
2018-12-22 09:20:50 -08:00
values[i++] = (dev->mHrtf ? ALC_TRUE : ALC_FALSE);
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
Add an HRTF status query This can report the status of HRTF, specifying if it's enabled or not and why (currently only reports unsupported formats, but this may be extended).
2015-05-15 23:28:03 -07:00
values[i++] = ALC_HRTF_STATUS_SOFT;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->HrtfStatus;
Add an HRTF status query This can report the status of HRTF, specifying if it's enabled or not and why (currently only reports unsupported formats, but this may be extended).
2015-05-15 23:28:03 -07:00
Allow querying the output limiter state
2017-04-30 08:54:49 -07:00
values[i++] = ALC_OUTPUT_LIMITER_SOFT;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = dev->Limiter ? ALC_TRUE : ALC_FALSE;
Allow querying the output limiter state
2017-04-30 08:54:49 -07:00
Use RAII for device references
2018-11-23 17:54:12 -08:00
ClockLatency clock{GetClockLatency(dev.get())};
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = ALC_DEVICE_CLOCK_SOFT;
Use proper time types for the device clock time and latency
2018-11-22 14:32:48 -08:00
values[i++] = clock.ClockTime.count();
Add property queries to get the device latency with the clock
2016-06-03 09:40:30 -07:00
values[i++] = ALC_DEVICE_LATENCY_SOFT;
Use proper time types for the device clock time and latency
2018-11-22 14:32:48 -08:00
values[i++] = clock.Latency.count();
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
values[i++] = 0;
}
break;
case ALC_DEVICE_CLOCK_SOFT:
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{dev->StateLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
nanoseconds basecount;
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
ALuint samplecount;
ALuint refcount;
do {
Use RAII for device references
2018-11-23 17:54:12 -08:00
while(((refcount=ReadRef(&dev->MixCount))&1) != 0)
Remove althrd_yield
2018-11-26 23:06:49 -08:00
std::this_thread::yield();
Use RAII for device references
2018-11-23 17:54:12 -08:00
basecount = dev->ClockBase;
samplecount = dev->SamplesDone;
} while(refcount != ReadRef(&dev->MixCount));
Remove a couple unnecessary duration_casts
2019-03-26 10:18:02 -07:00
basecount += nanoseconds{seconds{samplecount}} / dev->Frequency;
*values = basecount.count();
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
}
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
break;
Add property queries to get the device latency with the clock
2016-06-03 09:40:30 -07:00
case ALC_DEVICE_LATENCY_SOFT:
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{dev->StateLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
ClockLatency clock{GetClockLatency(dev.get())};
Use proper time types for the device clock time and latency
2018-11-22 14:32:48 -08:00
*values = clock.Latency.count();
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
}
Add property queries to get the device latency with the clock
2016-06-03 09:40:30 -07:00
break;
case ALC_DEVICE_CLOCK_LATENCY_SOFT:
if(size < 2)
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_VALUE);
Add property queries to get the device latency with the clock
2016-06-03 09:40:30 -07:00
else
{
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
ClockLatency clock{GetClockLatency(dev.get())};
Use proper time types for the device clock time and latency
2018-11-22 14:32:48 -08:00
values[0] = clock.ClockTime.count();
values[1] = clock.Latency.count();
Add property queries to get the device latency with the clock
2016-06-03 09:40:30 -07:00
}
break;
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
default:
Use a span instead of pointer+size parameters
2019-06-17 20:05:38 -07:00
auto ivals = al::vector<ALCint>(size);
size = GetIntegerv(dev.get(), pname, {ivals.data(), ivals.size()});
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
std::copy(ivals.begin(), ivals.begin()+size, values);
Add an alcGetInteger64vSOFT method and a way to get the device clock
2014-02-01 17:55:42 -08:00
break;
Separate device-type parameter checks for alcGetIntegerv
2011-05-29 23:20:33 -07:00
}
Initial import
2007-11-13 18:02:18 -08:00
}
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcIsExtensionPresent
*
* Determines if there is support for a particular extension
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
Reduce some indentation
2010-03-19 20:49:23 -07:00
if(!extName)
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_VALUE);
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
else
Reduce some indentation
2010-03-19 20:49:23 -07:00
{
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
size_t len = strlen(extName);
Use RAII for device references
2018-11-23 17:54:12 -08:00
const char *ptr = (dev ? alcExtensionList : alcNoDeviceExtList);
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
while(ptr && *ptr)
Don't use a multiple lists for extensions
2008-01-19 20:02:40 -08:00
{
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
if(strncasecmp(ptr, extName, len) == 0 &&
(ptr[len] == '\0' || isspace(ptr[len])))
Use RAII for device references
2018-11-23 17:54:12 -08:00
return ALC_TRUE;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if((ptr=strchr(ptr, ' ')) != nullptr)
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
{
do {
++ptr;
} while(isspace(*ptr));
}
Don't use a multiple lists for extensions
2008-01-19 20:02:40 -08:00
}
Initial import
2007-11-13 18:02:18 -08:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
return ALC_FALSE;
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcGetProcAddress
*
* Retrieves the function address for a particular extension function
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Reduce some indentation
2010-03-19 20:49:23 -07:00
if(!funcName)
Don't needlessly verify a device
2012-06-19 00:25:45 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
alcSetError(dev.get(), ALC_INVALID_VALUE);
Don't needlessly verify a device
2012-06-19 00:25:45 -07:00
}
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
else
{
Use C++ methods a bit more
2018-11-24 19:16:21 -08:00
for(const auto &func : alcFunctions)
Remove a couple unneeded typedefs
2017-03-14 08:37:50 -07:00
{
Use C++ methods a bit more
2018-11-24 19:16:21 -08:00
if(strcmp(func.funcName, funcName) == 0)
return func.address;
Remove a couple unneeded typedefs
2017-03-14 08:37:50 -07:00
}
Reduce some indentation
2010-03-19 20:49:23 -07:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
return nullptr;
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcGetEnumValue
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Get the value for a particular ALC enumeration name
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Fix alcGetEnumValue error handling
2010-03-24 22:57:35 -07:00
if(!enumName)
Combine ALCenum and ALenum lists
2012-04-20 01:24:58 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
alcSetError(dev.get(), ALC_INVALID_VALUE);
Combine ALCenum and ALenum lists
2012-04-20 01:24:58 -07:00
}
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
else
{
Use C++ methods a bit more
2018-11-24 19:16:21 -08:00
for(const auto &enm : alcEnumerations)
Remove a couple unneeded typedefs
2017-03-14 08:37:50 -07:00
{
Use C++ methods a bit more
2018-11-24 19:16:21 -08:00
if(strcmp(enm.enumName, enumName) == 0)
return enm.value;
Remove a couple unneeded typedefs
2017-03-14 08:37:50 -07:00
}
Fix alcGetEnumValue error handling
2010-03-24 22:57:35 -07:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
return 0;
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcCreateContext
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Create and attach a context to the given device.
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
/* Explicitly hold the list lock while taking the StateLock in case the
* device is asynchronously destroyed, to ensure this new context is
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
* properly cleaned up after being made.
*/
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::unique_lock<std::recursive_mutex> listlock{ListLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type == Capture || !dev->Connected.load(std::memory_order_relaxed))
Parse the attribute list and reset the device before creating the context
2009-09-24 11:31:01 -07:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
return nullptr;
Parse the attribute list and reset the device before creating the context
2009-09-24 11:31:01 -07:00
}
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::unique_lock<std::mutex> statelock{dev->StateLock};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
Parse the attribute list and reset the device before creating the context
2009-09-24 11:31:01 -07:00
Use RAII for device references
2018-11-23 17:54:12 -08:00
dev->LastError.store(ALC_NO_ERROR);
Parse the attribute list and reset the device before creating the context
2009-09-24 11:31:01 -07:00
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
ContextRef context{new ALCcontext{dev.get()}};
ALCdevice_IncRef(context->Device);
Allocate a new context's voices after updating the device params
2017-04-19 12:34:45 -07:00
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
ALCenum err{UpdateDeviceParams(dev.get(), attrList)};
if(err != ALC_NO_ERROR)
Allocate context storage before starting/resetting the device In case allocation fails, we don't have to worry about the playing status of the backend.
2016-05-15 14:12:56 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), err);
Allocate context storage before starting/resetting the device In case allocation fails, we don't have to worry about the playing status of the backend.
2016-05-15 14:12:56 -07:00
if(err == ALC_INVALID_DEVICE)
Use RAII for device references
2018-11-23 17:54:12 -08:00
aluHandleDisconnect(dev.get(), "Device update failure");
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
statelock.unlock();
Attempt to reconnect lost devices with alcResetDeviceSOFT Be aware there's currently possible race conditions with PulseAudio's callbacks (the state callbacks need to be cleared while not playing). Also paused sources will assert/crash if attempted to play again without being explicitly stopped or rewound first. Both of these will eventually be fixed (though a paused source's offset will be lost regardless).
2018-11-28 12:24:12 -08:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
return nullptr;
Allocate context storage before starting/resetting the device In case allocation fails, we don't have to worry about the playing status of the backend.
2016-05-15 14:12:56 -07:00
}
Use a FlexArray for the context's voices
2019-06-09 18:13:54 -07:00
AllocateVoices(context.get(), 256);
Allocate context storage before starting/resetting the device In case allocation fails, we don't have to worry about the playing status of the backend.
2016-05-15 14:12:56 -07:00
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(DefaultEffect.type != AL_EFFECT_NULL && dev->Type == Playback)
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
{
Store effect slots in groups of 64 Now that their wet buffers are allocated dynamically, the ALeffectslot object itself is rather small.
2019-02-20 22:00:26 -08:00
void *ptr{al_calloc(16, sizeof(ALeffectslot))};
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
context->DefaultSlot = std::unique_ptr<ALeffectslot>{new (ptr) ALeffectslot{}};
if(InitEffectSlot(context->DefaultSlot.get()) == AL_NO_ERROR)
aluInitEffectPanning(context->DefaultSlot.get(), dev.get());
Fix default effect initialization
2017-07-19 18:26:46 -07:00
else
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
{
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
context->DefaultSlot = nullptr;
Initialize the default effect after device update
2017-07-13 22:33:13 -07:00
ERR("Failed to initialize the default effect slot\n");
}
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
}
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
InitContext(context.get());
Parse the attribute list and reset the device before creating the context
2009-09-24 11:31:01 -07:00
Return optionals from the remaining ConfigValue* methods
2019-06-30 16:38:25 -07:00
if(auto volopt = ConfigValueFloat(dev->DeviceName.c_str(), nullptr, "volume-adjust"))
Add a volume-adjust config option to adjust the source output volume Designed for apps that either don't change the listener's AL_GAIN, or don't allow the listener's AL_GAIN to go above 1. This allows the volume to still be increased further than such apps may allow, if users find it too quiet. Be aware that increasing this can easily cause clipping. The gain limit reported by AL_GAIN_LIMIT_SOFT is also affected by this.
2016-09-24 18:46:41 -07:00
{
Return optionals from the remaining ConfigValue* methods
2019-06-30 16:38:25 -07:00
const ALfloat valf{*volopt};
Use std::isfinite from the cmath header
2018-11-15 06:48:52 -08:00
if(!std::isfinite(valf))
Add a volume-adjust config option to adjust the source output volume Designed for apps that either don't change the listener's AL_GAIN, or don't allow the listener's AL_GAIN to go above 1. This allows the volume to still be increased further than such apps may allow, if users find it too quiet. Be aware that increasing this can easily cause clipping. The gain limit reported by AL_GAIN_LIMIT_SOFT is also affected by this.
2016-09-24 18:46:41 -07:00
ERR("volume-adjust must be finite: %f\n", valf);
else
{
Return optionals from the remaining ConfigValue* methods
2019-06-30 16:38:25 -07:00
const ALfloat db{clampf(valf, -24.0f, 24.0f)};
Add a volume-adjust config option to adjust the source output volume Designed for apps that either don't change the listener's AL_GAIN, or don't allow the listener's AL_GAIN to go above 1. This allows the volume to still be increased further than such apps may allow, if users find it too quiet. Be aware that increasing this can easily cause clipping. The gain limit reported by AL_GAIN_LIMIT_SOFT is also affected by this.
2016-09-24 18:46:41 -07:00
if(db != valf)
WARN("volume-adjust clamped: %f, range: +/-%f\n", valf, 24.0f);
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
context->GainBoost = std::pow(10.0f, db/20.0f);
TRACE("volume-adjust gain: %f\n", context->GainBoost);
Add a volume-adjust config option to adjust the source output volume Designed for apps that either don't change the listener's AL_GAIN, or don't allow the listener's AL_GAIN to go above 1. This allows the volume to still be increased further than such apps may allow, if users find it too quiet. Be aware that increasing this can easily cause clipping. The gain limit reported by AL_GAIN_LIMIT_SOFT is also affected by this.
2016-09-24 18:46:41 -07:00
}
}
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
UpdateListenerProps(context.get());
Add a volume-adjust config option to adjust the source output volume Designed for apps that either don't change the listener's AL_GAIN, or don't allow the listener's AL_GAIN to go above 1. This allows the volume to still be increased further than such apps may allow, if users find it too quiet. Be aware that increasing this can easily cause clipping. The gain limit reported by AL_GAIN_LIMIT_SOFT is also affected by this.
2016-09-24 18:46:41 -07:00
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
using ContextArray = al::FlexArray<ALCcontext*>;
/* Allocate a new context array, which holds 1 more than the current/
* old array.
*/
auto *oldarray = device->mContexts.load();
const size_t newcount{oldarray->size()+1};
void *ptr{al_calloc(alignof(ContextArray), ContextArray::Sizeof(newcount))};
auto *newarray = new (ptr) ContextArray{newcount};
/* 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.
*/
dev->mContexts.store(newarray);
if(oldarray != &EmptyContextArray)
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
{
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
while((dev->MixCount.load(std::memory_order_acquire)&1))
std::this_thread::yield();
delete oldarray;
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
}
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
statelock.unlock();
Initial import
2007-11-13 18:02:18 -08:00
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
{
std::lock_guard<std::recursive_mutex> _{ListLock};
auto iter = std::lower_bound(ContextList.cbegin(), ContextList.cend(), context.get());
ALCcontext_IncRef(context.get());
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
ContextList.insert(iter, ContextRef{context.get()});
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
}
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
if(context->DefaultSlot)
Fix default effect initialization
2017-07-19 18:26:46 -07:00
{
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
if(InitializeEffect(context.get(), context->DefaultSlot.get(), &DefaultEffect) == AL_NO_ERROR)
UpdateEffectSlotProps(context->DefaultSlot.get(), context.get());
Fix default effect initialization
2017-07-19 18:26:46 -07:00
else
ERR("Failed to initialize the default effect\n");
}
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
TRACE("Created context %p\n", context.get());
return context.get();
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcDestroyContext
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Remove a context from its device
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::unique_lock<std::recursive_mutex> listlock{ListLock};
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
auto iter = std::lower_bound(ContextList.begin(), ContextList.end(), context);
if(iter == ContextList.end() || *iter != context)
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_CONTEXT);
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
return;
}
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
/* Hold an extra reference to this context so it remains valid until the
* ListLock is released.
*/
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
ContextRef ctx{std::move(*iter)};
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
ContextList.erase(iter);
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
ALCdevice *Device{ctx->Device};
std::lock_guard<std::mutex> _{Device->StateLock};
if(!ReleaseContext(ctx.get(), Device) && Device->Flags.get<DeviceRunning>())
Initial import
2007-11-13 18:02:18 -08:00
{
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
Device->Backend->stop();
Device->Flags.unset<DeviceRunning>();
Use a flag to specify when a device is running
2011-06-15 01:59:07 -07:00
}
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcGetCurrentContext
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Returns the currently active context on the calling thread
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Add support for the in-progress ALC_EXT_thread_local_context extension
2009-09-12 16:45:46 -07:00
{
Avoid using C-style TLS
2018-11-16 21:55:11 -08:00
ALCcontext *Context{LocalContext.get()};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
if(!Context) Context = GlobalContext.load();
Avoid an unnecessary lock when retrieving the current context
2011-06-15 23:22:34 -07:00
return Context;
Add support for the in-progress ALC_EXT_thread_local_context extension
2009-09-12 16:45:46 -07:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Add support for the in-progress ALC_EXT_thread_local_context extension
2009-09-12 16:45:46 -07:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcGetThreadContext
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Returns the currently active thread-local context
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Mark extension functions with AL_API/ALC_API
2010-03-23 17:44:01 -07:00
ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
{ return LocalContext.get(); }
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcMakeContextCurrent
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Makes the given context the active process-wide context, and removes the
* thread-local context for the calling thread.
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
/* context must be valid or nullptr */
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ContextRef ctx;
if(context)
Initial import
2007-11-13 18:02:18 -08:00
{
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ctx = VerifyContext(context);
if(!ctx)
{
alcSetError(nullptr, ALC_INVALID_CONTEXT);
return ALC_FALSE;
}
Initial import
2007-11-13 18:02:18 -08:00
}
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
/* Release this reference (if any) to store it in the GlobalContext
* pointer. Take ownership of the reference (if any) that was previously
* stored there.
*/
ctx = ContextRef{GlobalContext.exchange(ctx.release())};
Initial import
2007-11-13 18:02:18 -08:00
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
/* Reset (decrement) the previous global reference by replacing it with the
* thread-local context. Take ownership of the thread-local context
* reference (if any), clearing the storage to null.
*/
ctx = ContextRef{LocalContext.get()};
if(ctx) LocalContext.set(nullptr);
/* Reset (decrement) the previous thread-local reference. */
Initial import
2007-11-13 18:02:18 -08:00
Get rid of IsContext
2011-09-12 03:18:27 -07:00
return ALC_TRUE;
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcSetThreadContext
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Makes the given context the active context for the current thread
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Rename alcMakeCurrent to alcSetThreadContext
2010-03-23 19:49:31 -07:00
ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Add support for the in-progress ALC_EXT_thread_local_context extension
2009-09-12 16:45:46 -07:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
/* context must be valid or nullptr */
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ContextRef ctx;
if(context)
Hold a reference on the context when being set as current on the thread This should vastly improve efficiency for retrieving the current thread context, as we can be assured the stored context pointer will always be valid.
2011-08-28 18:08:48 -07:00
{
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ctx = VerifyContext(context);
if(!ctx)
{
alcSetError(nullptr, ALC_INVALID_CONTEXT);
return ALC_FALSE;
}
Hold a reference on the context when being set as current on the thread This should vastly improve efficiency for retrieving the current thread context, as we can be assured the stored context pointer will always be valid.
2011-08-28 18:08:48 -07:00
}
Get rid of IsContext
2011-09-12 03:18:27 -07:00
/* context's reference count is already incremented */
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ContextRef old{LocalContext.get()};
LocalContext.set(ctx.release());
Add support for the in-progress ALC_EXT_thread_local_context extension
2009-09-12 16:45:46 -07:00
Get rid of IsContext
2011-09-12 03:18:27 -07:00
return ALC_TRUE;
Add support for the in-progress ALC_EXT_thread_local_context extension
2009-09-12 16:45:46 -07:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Add support for the in-progress ALC_EXT_thread_local_context extension
2009-09-12 16:45:46 -07:00
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcGetContextsDevice
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Returns the device that a particular context is attached to
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Get rid of IsContext
2011-09-12 03:18:27 -07:00
ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Clean up some code comments
2011-09-10 19:14:14 -07:00
{
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ContextRef ctx{VerifyContext(Context)};
if(!ctx)
Get rid of IsContext
2011-09-12 03:18:27 -07:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_CONTEXT);
return nullptr;
Get rid of IsContext
2011-09-12 03:18:27 -07:00
}
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
return ctx->Device;
Clean up some code comments
2011-09-10 19:14:14 -07:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcOpenDevice
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Opens the named device.
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Don't use deprecated macros
2010-03-19 14:34:18 -07:00
ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Separate config init from library init OSX has a bug where the file descriptor resource limit can't be increased once certain functions (such as fopen) are used. Since lib initialization happens in a global constructor and includes opening and parsing config files, it prevents apps from being able to increase the rlimit once the lib is loaded, which is usually before main(). By delaying config init, it allows apps the opportunity to change the rlimit before calling certain OpenAL functions.
2011-06-14 09:43:33 -07:00
DO_INITCONFIG();
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
if(!PlaybackFactory)
Make sure there's a valid backend before trying to open a device
2011-08-19 02:55:36 -07:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_VALUE);
return nullptr;
Make sure there's a valid backend before trying to open a device
2011-08-19 02:55:36 -07:00
}
Recognize "DirectSound3D" as a device name on Windows
2015-08-13 21:18:39 -07:00
if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0
#ifdef _WIN32
Also recognize "DirectSound" and "MMSYSTEM" on Windows
2015-08-14 17:02:11 -07:00
/* 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.
Recognize "DirectSound3D" as a device name on Windows
2015-08-13 21:18:39 -07:00
*/
Also recognize "DirectSound" and "MMSYSTEM" on Windows
2015-08-14 17:02:11 -07:00
|| strcasecmp(deviceName, "DirectSound3D") == 0 || strcasecmp(deviceName, "DirectSound") == 0
|| strcasecmp(deviceName, "MMSYSTEM") == 0
Recognize "DirectSound3D" as a device name on Windows
2015-08-13 21:18:39 -07:00
#endif
))
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
deviceName = nullptr;
Allow empty device specifiers when opening; treat them like NULL
2007-12-26 17:38:42 -08:00
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
DeviceRef device{new ALCdevice{Playback}};
Dynamically allocate the channel delay buffers
2017-02-28 21:01:13 -08:00
Open the playback device earlier So we actually have a device name to get the initial settings for. Be aware that some backends set a format when opening instead of on reset, so such devices will only set the default format (it can't get a desired format without the device name, but the format will already be set once that's known). The affected backends are WinMM, SDL2, and PortAudio (none of which are generally used). This could be fixed by reopening the device during reset, but it would need to be done carefully.
2019-04-20 19:29:33 -07:00
/* Set output format */
Use enums to specify the default channel configuration and sample type
2012-03-13 15:32:44 -07:00
device->FmtChans = DevFmtChannelsDefault;
device->FmtType = DevFmtTypeDefault;
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
device->Frequency = DEFAULT_OUTPUT_RATE;
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
device->UpdateSize = DEFAULT_UPDATE_SIZE;
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->BufferSize = DEFAULT_UPDATE_SIZE * DEFAULT_NUM_UPDATES;
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
device->SourcesMax = 256;
device->AuxiliaryEffectSlotMax = 64;
device->NumAuxSends = DEFAULT_SENDS;
Use an ALCbackend object to access playback backends This is the start of a backend redesign. Currently, a wrapper object is used to avoid having to redo all the backends at once, but they should slowly be converted to derive from ALCbackend instead. The ALCbackend interface can change as needed.
2013-10-27 14:24:55 -07:00
Add an exception class to cover backend creation and opening
2019-05-04 18:03:25 -07:00
try {
/* Create the device backend. */
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
device->Backend = PlaybackFactory->createBackend(device.get(), BackendType::Playback);
Add an exception class to cover backend creation and opening
2019-05-04 18:03:25 -07:00
/* Find a playback device to open */
ALCenum err{device->Backend->open(deviceName)};
if(err != ALC_NO_ERROR)
{
alcSetError(nullptr, err);
return nullptr;
}
Open the playback device earlier So we actually have a device name to get the initial settings for. Be aware that some backends set a format when opening instead of on reset, so such devices will only set the default format (it can't get a desired format without the device name, but the format will already be set once that's known). The affected backends are WinMM, SDL2, and PortAudio (none of which are generally used). This could be fixed by reopening the device during reset, but it would need to be done carefully.
2019-04-20 19:29:33 -07:00
}
Add an exception class to cover backend creation and opening
2019-05-04 18:03:25 -07:00
catch(al::backend_exception &e) {
WARN("Failed to open playback device: %s\n", e.what());
alcSetError(nullptr, e.errorCode());
Open the playback device earlier So we actually have a device name to get the initial settings for. Be aware that some backends set a format when opening instead of on reset, so such devices will only set the default format (it can't get a desired format without the device name, but the format will already be set once that's known). The affected backends are WinMM, SDL2, and PortAudio (none of which are generally used). This could be fixed by reopening the device during reset, but it would need to be done carefully.
2019-04-20 19:29:33 -07:00
return nullptr;
}
deviceName = device->DeviceName.c_str();
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
if(auto chanopt = ConfigValueStr(deviceName, nullptr, "channels"))
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
{
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
static constexpr struct ChannelMap {
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
const char name[16];
Remove extraneous typedef, struct, and enum keywords
2018-12-24 19:29:01 -08:00
DevFmtChannels chans;
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
ALsizei order;
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
} chanlist[] = {
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
{ "mono", DevFmtMono, 0 },
{ "stereo", DevFmtStereo, 0 },
{ "quad", DevFmtQuad, 0 },
{ "surround51", DevFmtX51, 0 },
{ "surround61", DevFmtX61, 0 },
{ "surround71", DevFmtX71, 0 },
{ "surround51rear", DevFmtX51Rear, 0 },
{ "ambi1", DevFmtAmbi3D, 1 },
{ "ambi2", DevFmtAmbi3D, 2 },
{ "ambi3", DevFmtAmbi3D, 3 },
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
};
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
const ALCchar *fmt{chanopt->c_str()};
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
auto iter = std::find_if(std::begin(chanlist), std::end(chanlist),
[fmt](const ChannelMap &entry) -> bool
{ return strcasecmp(entry.name, fmt) == 0; }
);
if(iter == std::end(chanlist))
ERR("Unsupported channels: %s\n", fmt);
else
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
{
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
device->FmtChans = iter->chans;
Avoid more cases of an enum variable and type name clash
2018-11-18 08:01:50 -08:00
device->mAmbiOrder = iter->order;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.set<ChannelsRequest>();
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
}
}
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
if(auto typeopt = ConfigValueStr(deviceName, nullptr, "sample-type"))
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
{
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
static constexpr struct TypeMap {
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
const char name[16];
Remove extraneous typedef, struct, and enum keywords
2018-12-24 19:29:01 -08:00
DevFmtType type;
Fix a misnamed variable
2012-02-19 11:56:01 -08:00
} typelist[] = {
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
{ "int8", DevFmtByte },
{ "uint8", DevFmtUByte },
{ "int16", DevFmtShort },
{ "uint16", DevFmtUShort },
{ "int32", DevFmtInt },
{ "uint32", DevFmtUInt },
{ "float32", DevFmtFloat },
};
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
const ALCchar *fmt{typeopt->c_str()};
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
auto iter = std::find_if(std::begin(typelist), std::end(typelist),
[fmt](const TypeMap &entry) -> bool
{ return strcasecmp(entry.name, fmt) == 0; }
);
if(iter == std::end(typelist))
ERR("Unsupported sample-type: %s\n", fmt);
else
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
{
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
device->FmtType = iter->type;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.set<SampleTypeRequest>();
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
}
}
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(ALuint freq{ConfigValueUInt(deviceName, nullptr, "frequency").value_or(0)})
Define a minimum output sample rate and warn if the config option goes below it
2012-02-15 12:26:19 -08:00
{
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
if(freq < MIN_OUTPUT_RATE)
{
ERR("%uhz request clamped to %uhz minimum\n", freq, MIN_OUTPUT_RATE);
freq = MIN_OUTPUT_RATE;
}
Scale the update size with sample rate changes
2019-04-26 18:04:22 -07:00
device->UpdateSize = (device->UpdateSize*freq + device->Frequency/2) / device->Frequency;
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->BufferSize = (device->BufferSize*freq + device->Frequency/2) / device->Frequency;
Combine handling of attribute processing
2018-12-18 09:27:00 -08:00
device->Frequency = freq;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.set<FrequencyRequest>();
Define a minimum output sample rate and warn if the config option goes below it
2012-02-15 12:26:19 -08:00
}
Initial import
2007-11-13 18:02:18 -08:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto persizeopt = ConfigValueUInt(deviceName, nullptr, "period_size"))
device->UpdateSize = clampu(*persizeopt, 64, 8192);
Initial import
2007-11-13 18:02:18 -08:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto peropt = ConfigValueUInt(deviceName, nullptr, "periods"))
device->BufferSize = device->UpdateSize * clampu(*peropt, 2, 16);
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
else
device->BufferSize = maxu(device->BufferSize, device->UpdateSize*2);
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto srcsopt = ConfigValueUInt(deviceName, nullptr, "sources"))
{
if(*srcsopt > 0) device->SourcesMax = *srcsopt;
}
Remove duplication of setting the max source count
2008-01-19 19:28:34 -08:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto slotsopt = ConfigValueUInt(deviceName, nullptr, "slots"))
{
if(*slotsopt > 0)
device->AuxiliaryEffectSlotMax = minu(*slotsopt, INT_MAX);
}
Store the max number of auxiliary slots in the device
2009-06-07 14:53:22 -07:00
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
if(auto sendsopt = ConfigValueInt(deviceName, nullptr, "sends"))
device->NumAuxSends = clampi(DEFAULT_SENDS, 0, clampi(*sendsopt, 0, MAX_SENDS));
Store the requested mono/stereo source count and sends in the device Although the properties are set as context attributes, they are queried from the device. If multiple contexts per device are ever supported, it would not be straight forward about where to read the values from. This way, the attributes can be treated as device-specific attributes that are updated when a new context is created.
2009-07-06 03:09:01 -07:00
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
device->NumStereoSources = 1;
Rename MaxNoOfSources for consistency
2016-06-08 11:19:33 -07:00
device->NumMonoSources = device->SourcesMax - device->NumStereoSources;
Move the stereo-to-binaural filter to the device
2009-09-15 19:06:47 -07:00
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
if(auto ambiopt = ConfigValueStr(deviceName, nullptr, "ambi-format"))
Add an option to specify the ambisonic output configuration
2016-07-31 07:46:38 -07:00
{
Use an optional for ConfigValueStr
2019-06-30 16:15:15 -07:00
const ALCchar *fmt{ambiopt->c_str()};
Add an option to specify the ambisonic output configuration
2016-07-31 07:46:38 -07:00
if(strcasecmp(fmt, "fuma") == 0)
Use separate enums for the ambisonic channel order and normalization
2017-02-27 16:11:45 -08:00
{
Don't allow FuMa ordering or normalization above third-order
2018-12-19 02:55:21 -08:00
if(device->mAmbiOrder > 3)
ERR("FuMa is incompatible with %d%s order ambisonics (up to third-order only)\n",
device->mAmbiOrder,
(((device->mAmbiOrder%100)/10) == 1) ? "th" :
((device->mAmbiOrder%10) == 1) ? "st" :
((device->mAmbiOrder%10) == 2) ? "nd" :
((device->mAmbiOrder%10) == 3) ? "rd" : "th");
else
{
device->mAmbiLayout = AmbiLayout::FuMa;
device->mAmbiScale = AmbiNorm::FuMa;
}
Use separate enums for the ambisonic channel order and normalization
2017-02-27 16:11:45 -08:00
}
Recognize ambix as an alias for acn+sn3d
2018-12-27 01:18:10 -08:00
else if(strcasecmp(fmt, "ambix") == 0 || strcasecmp(fmt, "acn+sn3d") == 0)
Use separate enums for the ambisonic channel order and normalization
2017-02-27 16:11:45 -08:00
{
Use an enum class for AmbiLayout/Norm settings
2018-11-20 22:47:24 -08:00
device->mAmbiLayout = AmbiLayout::ACN;
device->mAmbiScale = AmbiNorm::SN3D;
Use separate enums for the ambisonic channel order and normalization
2017-02-27 16:11:45 -08:00
}
Add an option to specify the ambisonic output configuration
2016-07-31 07:46:38 -07:00
else if(strcasecmp(fmt, "acn+n3d") == 0)
Use separate enums for the ambisonic channel order and normalization
2017-02-27 16:11:45 -08:00
{
Use an enum class for AmbiLayout/Norm settings
2018-11-20 22:47:24 -08:00
device->mAmbiLayout = AmbiLayout::ACN;
device->mAmbiScale = AmbiNorm::N3D;
Use separate enums for the ambisonic channel order and normalization
2017-02-27 16:11:45 -08:00
}
Add an option to specify the ambisonic output configuration
2016-07-31 07:46:38 -07:00
else
ERR("Unsupported ambi-format: %s\n", fmt);
}
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
std::lock_guard<std::recursive_mutex> _{ListLock};
auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get());
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
ALCdevice_IncRef(device.get());
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
DeviceList.insert(iter, DeviceRef{device.get()});
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
Be a bit more robust while handling the global device list
2011-09-12 03:57:53 -07:00
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
TRACE("Created device %p, \"%s\"\n", device.get(), device->DeviceName.c_str());
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
return device.get();
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcCloseDevice
*
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
* Closes the given device.
Clean up some code comments
2011-09-10 19:14:14 -07:00
*/
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Initial import
2007-11-13 18:02:18 -08:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::unique_lock<std::recursive_mutex> listlock{ListLock};
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
auto iter = std::lower_bound(DeviceList.begin(), DeviceList.end(), device);
if(iter == DeviceList.end() || *iter != device)
Initial import
2007-11-13 18:02:18 -08:00
{
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
alcSetError(nullptr, ALC_INVALID_DEVICE);
Reduce some indentation
2010-03-19 20:49:23 -07:00
return ALC_FALSE;
}
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
if((*iter)->Type == Capture)
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
alcSetError(iter->get(), ALC_INVALID_DEVICE);
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
return ALC_FALSE;
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
/* Erase the device, and any remaining contexts left on it, from their
* respective lists.
*/
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
DeviceRef dev{std::move(*iter)};
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
DeviceList.erase(iter);
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
std::unique_lock<std::mutex> statelock{dev->StateLock};
al::vector<ContextRef> orphanctxs;
for(ALCcontext *ctx : *dev->mContexts.load())
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
{
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
auto iter = std::lower_bound(ContextList.begin(), ContextList.end(), ctx);
if(iter != ContextList.end() && *iter == ctx)
{
orphanctxs.emplace_back(std::move(*iter));
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
ContextList.erase(iter);
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
}
Use a sorted vector for looking up contexts Note that the device still holds and uses a linked list of its contexts. The sorted vector is used to verify handles given by callers.
2019-03-19 18:53:32 -07:00
}
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
Reduce some indentation
2010-03-19 20:49:23 -07:00
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
for(ContextRef &context : orphanctxs)
Reduce some indentation
2010-03-19 20:49:23 -07:00
{
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
WARN("Releasing context %p\n", context.get());
ReleaseContext(context.get(), dev.get());
Clean up some code comments
2011-09-10 19:14:14 -07:00
}
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
orphanctxs.clear();
Make sure the device gets stopped when closing even if there's no contexts
2012-03-02 00:10:24 -08:00
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
if(dev->Flags.get<DeviceRunning>())
dev->Backend->stop();
dev->Flags.unset<DeviceRunning>();
Initial import
2007-11-13 18:02:18 -08:00
Reduce some indentation
2010-03-19 20:49:23 -07:00
return ALC_TRUE;
Initial import
2007-11-13 18:02:18 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Close dangling devices when exiting
2008-01-14 10:54:33 -08:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* ALC capture functions
************************************************/
ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
DO_INITCONFIG();
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
if(!CaptureFactory)
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_VALUE);
return nullptr;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
if(samples <= 0)
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_VALUE);
return nullptr;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
deviceName = nullptr;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
DeviceRef device{new ALCdevice{Capture}};
Enumerate and list HRTFs per-device
2015-10-06 00:23:11 -07:00
Use optionals where methods may not return a valid value
2019-06-30 16:57:10 -07:00
auto decompfmt = DecomposeDevFormat(format);
if(!decompfmt)
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_ENUM);
return nullptr;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
Use optionals where methods may not return a valid value
2019-06-30 16:57:10 -07:00
device->Frequency = frequency;
device->FmtChans = decompfmt->chans;
device->FmtType = decompfmt->type;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
device->Flags.set<FrequencyRequest, ChannelsRequest, SampleTypeRequest>();
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
device->UpdateSize = samples;
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->BufferSize = samples;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Add an exception class to cover backend creation and opening
2019-05-04 18:03:25 -07:00
try {
Don't keep retrieving the backend factories
2019-06-28 18:54:31 -07:00
device->Backend = CaptureFactory->createBackend(device.get(), BackendType::Capture);
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
Add an exception class to cover backend creation and opening
2019-05-04 18:03:25 -07:00
TRACE("Capture format: %s, %s, %uhz, %u / %u buffer\n",
DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
device->Frequency, device->UpdateSize, device->BufferSize);
ALCenum err{device->Backend->open(deviceName)};
if(err != ALC_NO_ERROR)
{
alcSetError(nullptr, err);
return nullptr;
}
}
catch(al::backend_exception &e) {
WARN("Failed to open capture device: %s\n", e.what());
alcSetError(nullptr, e.errorCode());
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
return nullptr;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
std::lock_guard<std::recursive_mutex> _{ListLock};
auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get());
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
ALCdevice_IncRef(device.get());
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
DeviceList.insert(iter, DeviceRef{device.get()});
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
TRACE("Created device %p, \"%s\"\n", device.get(), device->DeviceName.c_str());
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
return device.get();
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::unique_lock<std::recursive_mutex> listlock{ListLock};
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
auto iter = std::lower_bound(DeviceList.begin(), DeviceList.end(), device);
if(iter == DeviceList.end() || *iter != device)
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
alcSetError(nullptr, ALC_INVALID_DEVICE);
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
return ALC_FALSE;
}
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
if((*iter)->Type != Capture)
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
alcSetError(iter->get(), ALC_INVALID_DEVICE);
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
return ALC_FALSE;
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
DeviceRef dev{std::move(*iter)};
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
DeviceList.erase(iter);
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
std::lock_guard<std::mutex> _{dev->StateLock};
if(dev->Flags.get<DeviceRunning>())
dev->Backend->stop();
dev->Flags.unset<DeviceRunning>();
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
return ALC_TRUE;
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type != Capture)
{
alcSetError(dev.get(), ALC_INVALID_DEVICE);
return;
}
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(!dev->Connected.load(std::memory_order_acquire))
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
else if(!dev->Flags.get<DeviceRunning>())
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
if(dev->Backend->start())
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
dev->Flags.set<DeviceRunning>();
Use RAII for device references
2018-11-23 17:54:12 -08:00
else
Avoid unnecessarily locking the list lock
2012-10-07 00:13:23 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
aluHandleDisconnect(dev.get(), "Device start failure");
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Avoid unnecessarily locking the list lock
2012-10-07 00:13:23 -07:00
}
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type != Capture)
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Avoid unnecessarily locking the list lock
2012-10-07 00:13:23 -07:00
else
{
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(dev->Flags.get<DeviceRunning>())
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
dev->Backend->stop();
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
dev->Flags.unset<DeviceRunning>();
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type != Capture)
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_DEVICE);
return;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
ALCenum err{ALC_INVALID_VALUE};
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
{ std::lock_guard<std::mutex> _{dev->StateLock};
Return a unique_ptr for the backend
2018-12-29 02:16:16 -08:00
BackendBase *backend{dev->Backend.get()};
Avoid using old style casts To think about: examples/alffplay.cpp:600 OpenAL32/Include/alMain.h:295
2019-01-08 19:42:44 +01:00
if(samples >= 0 && backend->availableSamples() >= static_cast<ALCuint>(samples))
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
err = backend->captureSamples(buffer, samples);
Use RAII for device references
2018-11-23 17:54:12 -08:00
}
if(err != ALC_NO_ERROR)
alcSetError(dev.get(), err);
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* ALC loopback functions
************************************************/
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcLoopbackOpenDeviceSOFT
*
* Open a loopback device, for manual rendering.
*/
Make alcLoopbackOpenDeviceSOFT take a standard "device" name for a parameter
2012-03-01 08:30:21 -08:00
ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
{
Separate config init from library init OSX has a bug where the file descriptor resource limit can't be increased once certain functions (such as fopen) are used. Since lib initialization happens in a global constructor and includes opening and parsing config files, it prevents apps from being able to increase the rlimit once the lib is loaded, which is usually before main(). By delaying config init, it allows apps the opportunity to change the rlimit before calling certain OpenAL functions.
2011-06-14 09:43:33 -07:00
DO_INITCONFIG();
Make alcLoopbackOpenDeviceSOFT take a standard "device" name for a parameter
2012-03-01 08:30:21 -08:00
/* Make sure the device name, if specified, is us. */
if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
Add a device parameter to alcLoopbackOpenDeviceSOFT
2012-02-15 20:52:49 -08:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_INVALID_VALUE);
return nullptr;
Add a device parameter to alcLoopbackOpenDeviceSOFT
2012-02-15 20:52:49 -08:00
}
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
DeviceRef device{new ALCdevice{Loopback}};
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
Rename MaxNoOfSources for consistency
2016-06-08 11:19:33 -07:00
device->SourcesMax = 256;
Increase the default effect slot and send count The default number of auxiliary effect slots is now 64. This can still be raised by the config file without a hard maximum, but incurs processing cost for each effect slot generated by the app. The default number of source sends is now actually 2, as per the EFX docs. However, it can be raised up to 16 via ALC_MAX_AUXILIARY_SENDS attribute requests, rather than the previous 4.
2017-02-21 16:54:55 -08:00
device->AuxiliaryEffectSlotMax = 64;
device->NumAuxSends = DEFAULT_SENDS;
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
//Set output format
Specify the buffer size as itself instead of the period count Certain backends don't need a buffer size to be a strict multiple of the period count, which allows a little more flexibility. The period/update size simply acts as the minimum request, which helps control CPU load by determining how often parameter and other pre-mixing updates are processed.
2019-04-26 15:58:25 -07:00
device->BufferSize = 0;
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
device->UpdateSize = 0;
Use enums to specify the default channel configuration and sample type
2012-03-13 15:32:44 -07:00
device->Frequency = DEFAULT_OUTPUT_RATE;
device->FmtChans = DevFmtChannelsDefault;
device->FmtType = DevFmtTypeDefault;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto srcsopt = ConfigValueUInt(nullptr, nullptr, "sources"))
{
if(*srcsopt > 0) device->SourcesMax = *srcsopt;
}
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
Use an optional for ConfigValueUInt
2019-06-30 13:04:23 -07:00
if(auto slotsopt = ConfigValueUInt(nullptr, nullptr, "slots"))
{
if(*slotsopt > 0)
device->AuxiliaryEffectSlotMax = minu(*slotsopt, INT_MAX);
}
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Use an optional for ConfigValueInt
2019-06-30 12:00:10 -07:00
if(auto sendsopt = ConfigValueInt(nullptr, nullptr, "sends"))
device->NumAuxSends = clampi(DEFAULT_SENDS, 0, clampi(*sendsopt, 0, MAX_SENDS));
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
device->NumStereoSources = 1;
Rename MaxNoOfSources for consistency
2016-06-08 11:19:33 -07:00
device->NumMonoSources = device->SourcesMax - device->NumStereoSources;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Add an exception class to cover backend creation and opening
2019-05-04 18:03:25 -07:00
try {
device->Backend = LoopbackBackendFactory::getFactory().createBackend(device.get(),
BackendType::Playback);
// Open the "backend"
device->Backend->open("Loopback");
}
catch(al::backend_exception &e) {
WARN("Failed to open loopback device: %s\n", e.what());
alcSetError(nullptr, e.errorCode());
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
return nullptr;
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
}
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Use a sorted vector for devices instead of a linked list
2019-03-19 15:41:01 -07:00
std::lock_guard<std::recursive_mutex> _{ListLock};
auto iter = std::lower_bound(DeviceList.cbegin(), DeviceList.cend(), device.get());
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
ALCdevice_IncRef(device.get());
Hold references in the global device and context lists
2019-06-29 22:38:38 -07:00
DeviceList.insert(iter, DeviceRef{device.get()});
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
Return int and float config values through a parameter This allows the getter functions to return whether or not the option exists without a separate call and check.
2011-09-18 16:16:55 -07:00
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
TRACE("Created device %p\n", device.get());
Use DeviceRef and ContextRef when creating a new device and context
2019-01-01 22:44:46 -08:00
return device.get();
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcIsRenderFormatSupportedSOFT
*
* Determines if the loopback device supports the given format for rendering.
*/
Use separate functions to find valid ALC loopback device formats
2011-07-02 02:51:33 -07:00
ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type != Loopback)
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Better protect the device for multi-threading access
2011-03-12 06:23:17 -08:00
else if(freq <= 0)
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_VALUE);
Better protect the device for multi-threading access
2011-03-12 06:23:17 -08:00
else
{
Start a ALC_SOFT_loopback2 extension This extends the base ALC_SOFT_loopback extension with support for B-Format. When ALC_FORMAT_CHANNELS_SOFT is set to ALC_BFORMAT3D_SOFT, then additional attributes must be specified. ALC_AMBISONIC_LAYOUT_SOFT must be set to ALC_ACN_SOFT or ALC_FUMA_SOFT for the desired channel layout, ALC_AMBISONIC_SCALING_SOFT must be set to ALC_N3D_SOFT, ALC_SN3D_SOFT, or ALC_FUMA_SOFT for the desired channel scaling/normalization scheme, and ALC_AMBISONIC_ORDER_SOFT must be set to an integer value greater than 0 for the ambisonic order (maximum allowed is implementation-dependent). Note that the number of channels required for ALC_BFORMAT3D_SOFT is dependent on the ambisonic order. The number of channels can be calculated by: num_channels = (order+1) * (order+1); /* or pow(order+1, 2); */ In addition, a new alcIsAmbisonicFormatSupportedSOFT function allows apps to determine which layout/scaling/order combinations are supported by the loopback device. For example, alcIsAmbisonicFormatSupported(device, ALC_ACN_SOFT, ALC_SN3D_SOFT, 2) will check if 2nd order AmbiX (ACN layout and SN3D scaling) rendering is supported for ALC_BFORMAT3D_SOFT output.
2017-02-28 18:34:23 -08:00
if(IsValidALCType(type) && IsValidALCChannels(channels) && freq >= MIN_OUTPUT_RATE)
Use RAII for device references
2018-11-23 17:54:12 -08:00
return ALC_TRUE;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
return ALC_FALSE;
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
Clean up some code comments
2011-09-10 19:14:14 -07:00
/* alcRenderSamplesSOFT
*
* Renders some samples into a buffer, using the format last set by the
* attributes given to alcCreateContext.
*/
Add a macro for GCC to ensure stack alignment
2013-11-25 17:29:39 -08:00
FORCE_ALIGN ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type != Loopback)
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
else if(samples < 0 || (samples > 0 && buffer == nullptr))
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_VALUE);
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
else
Always lock the device backend before calling aluMixData
2017-02-18 17:32:07 -08:00
{
Use standard unique_lock and lock_guard for the backend lock
2019-01-01 16:38:54 -08:00
BackendLockGuard _{*device->Backend};
Use RAII for device references
2018-11-23 17:54:12 -08:00
aluMixData(dev.get(), buffer, samples);
Always lock the device backend before calling aluMixData
2017-02-18 17:32:07 -08:00
}
Implement a basic non-real-time loopback device Currently it behaves just like a normal device except contexts are only processed during calls to alcRenderSamples. Additionally, the ALC_SYNC and ALC_REFRESH context attributes are not valid for these devices, and there are two new context attributes to specify the rendering format: ALC_FORMAT_TYPE and ALC_FORMAT_CHANNELS. These each take one of the type and channel enums added. This stuff is subject to change.
2011-03-11 00:13:44 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
/************************************************
* ALC DSP pause/resume functions
************************************************/
/* alcDevicePauseSOFT
*
* Pause the DSP to stop audio processing.
*/
ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type != Playback)
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
else
{
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(dev->Flags.get<DeviceRunning>())
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
dev->Backend->stop();
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
dev->Flags.unset<DeviceRunning>();
dev->Flags.set<DevicePaused>();
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
}
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
/* alcDeviceResumeSOFT
*
* Resume the DSP to restart audio processing.
*/
ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type != Playback)
Reduce some indentation
2018-11-28 11:55:43 -08:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Reduce some indentation
2018-11-28 11:55:43 -08:00
return;
}
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(!dev->Flags.get<DevicePaused>())
Reduce some indentation
2018-11-28 11:55:43 -08:00
return;
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
dev->Flags.unset<DevicePaused>();
Use a FlexArray for a device's contexts
2019-06-29 21:32:36 -07:00
if(dev->mContexts.load()->empty())
Reduce some indentation
2018-11-28 11:55:43 -08:00
return;
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
if(dev->Backend->start() == ALC_FALSE)
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
{
Reduce some indentation
2018-11-28 11:55:43 -08:00
aluHandleDisconnect(dev.get(), "Device start failure");
alcSetError(dev.get(), ALC_INVALID_DEVICE);
return;
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
}
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
dev->Flags.set<DeviceRunning>();
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
/************************************************
* ALC HRTF functions
************************************************/
/* alcGetStringiSOFT
*
* Gets a string parameter at the given index.
*/
Allow apps to request a specific HRTF
2015-10-07 03:29:53 -07:00
ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum paramName, ALCsizei index)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
if(!dev || dev->Type == Capture)
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
else switch(paramName)
{
case ALC_HRTF_SPECIFIER_SOFT:
Avoid using old style casts To think about: examples/alffplay.cpp:600 OpenAL32/Include/alMain.h:295
2019-01-08 19:42:44 +01:00
if(index >= 0 && static_cast<size_t>(index) < dev->HrtfList.size())
Use RAII for device references
2018-11-23 17:54:12 -08:00
return dev->HrtfList[index].name.c_str();
alcSetError(dev.get(), ALC_INVALID_VALUE);
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
break;
default:
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_ENUM);
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
break;
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
return nullptr;
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
/* alcResetDeviceSOFT
*
* Resets the given device output, using the specified attribute list.
*/
ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs)
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
START_API_FUNC
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::unique_lock<std::recursive_mutex> listlock{ListLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev{VerifyDevice(device)};
Remove an improper Connected check
2018-11-28 19:29:20 -08:00
if(!dev || dev->Type == Capture)
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
{
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
Use RAII for device references
2018-11-23 17:54:12 -08:00
alcSetError(dev.get(), ALC_INVALID_DEVICE);
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
return ALC_FALSE;
}
Rename BackendLock to StateLock
2018-12-30 21:38:42 -08:00
std::lock_guard<std::mutex> _{dev->StateLock};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
Attempt to reconnect lost devices with alcResetDeviceSOFT Be aware there's currently possible race conditions with PulseAudio's callbacks (the state callbacks need to be cleared while not playing). Also paused sources will assert/crash if attempted to play again without being explicitly stopped or rewound first. Both of these will eventually be fixed (though a paused source's offset will be lost regardless).
2018-11-28 12:24:12 -08:00
/* Force the backend to stop mixing first since we're resetting. Also reset
* the connected state so lost devices can attempt recover.
*/
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
if(dev->Flags.get<DeviceRunning>())
Convert the backends to use proper inheritence
2018-12-28 22:56:20 -08:00
dev->Backend->stop();
Make sure the bitfield indices are constants
2019-06-09 02:20:30 -07:00
dev->Flags.unset<DeviceRunning>();
Use an atomic bool on things that only take true or false
2018-12-30 21:58:14 -08:00
device->Connected.store(true);
Attempt to reconnect lost devices with alcResetDeviceSOFT Be aware there's currently possible race conditions with PulseAudio's callbacks (the state callbacks need to be cleared while not playing). Also paused sources will assert/crash if attempted to play again without being explicitly stopped or rewound first. Both of these will eventually be fixed (though a paused source's offset will be lost regardless).
2018-11-28 12:24:12 -08:00
Use RAII for device references
2018-11-23 17:54:12 -08:00
ALCenum err{UpdateDeviceParams(dev.get(), attribs)};
Reduce some indentation
2018-11-28 11:55:43 -08:00
if(LIKELY(err == ALC_NO_ERROR)) return ALC_TRUE;
Use a specific lock for the backend's stop/reset/play calls This helps protect against the device changing unexpectedly from multiple threads, instead of using the global list/library lock.
2016-05-27 19:23:39 -07:00
Reduce some indentation
2018-11-28 11:55:43 -08:00
alcSetError(dev.get(), err);
if(err == ALC_INVALID_DEVICE)
aluHandleDisconnect(dev.get(), "Device start failure");
return ALC_FALSE;
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
}
Add macros to stop exceptions from leaving API functions Effectively makes the functions act as noexcept, since there's no meaningful reason to propogate exceptions from "C" functions. Currently only applied to ALC functions, but can incrementally be applied to AL functions too. In the future, this could also handle ALC and AL errors with unique exception types (functions that utilize this behavior would need to ensure proper cleanup).
2019-04-09 20:48:01 -07:00
END_API_FUNC
Reference in New Issue Copy Permalink