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

4317 lines
129 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>
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"
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 {
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
};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
struct 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
};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
ALsizei BackendListSize = COUNTOF(BackendList);
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
struct BackendInfo PlaybackBackend;
struct BackendInfo CaptureBackend;
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) }
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
constexpr 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 "
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);
TRACEREF("%p decreasing refcount to %u\n", context, ref);
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[] =
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -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[] =
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
"ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
"ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
Finalize ALC_SOFT_device_clock
2018-01-15 06:45:53 -08:00
"ALC_EXT_thread_local_context ALC_SOFT_device_clock ALC_SOFT_HRTF "
Finalize ALC_SOFT_output_limiter
2017-05-25 04:16:07 -07:00
"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
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Device lists
************************************************/
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
std::atomic<ALCdevice*> DeviceList{nullptr};
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;
} // namespace
/* Mixing thread piority level */
ALint RTPrioLevel;
Rename a couple global variables Avoid clashing with an enum name
2018-12-09 15:07:44 -08:00
FILE *gLogFile{stderr};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
#ifdef _DEBUG
Rename a couple global variables Avoid clashing with an enum name
2018-12-09 15:07:44 -08:00
LogLevel gLogLevel{LogWarning};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
#else
Rename a couple global variables Avoid clashing with an enum name
2018-12-09 15:07:44 -08:00
LogLevel gLogLevel{LogError};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
#endif
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
/************************************************
* Library initialization
************************************************/
Avoid static global initialization functions
2018-12-08 21:58:44 -08:00
#if defined(_WIN32) && !defined(AL_LIBTYPE_STATIC)
BOOL APIENTRY DllMain(HINSTANCE module, DWORD reason, LPVOID /*reserved*/)
Move (de)initialization into ALc.c and remove unneeded file
2008-07-17 18:38:07 -07:00
{
Don't use DllMain to call altss destructors
2014-04-17 00:56:02 -07:00
switch(reason)
Move (de)initialization into ALc.c and remove unneeded file
2008-07-17 18:38:07 -07:00
{
case DLL_PROCESS_ATTACH:
Pin the DLL for Windows The mmdevapi backend does not react well to being unloaded dynamically. It has a message-handling thread running in the background which can't quit before DllMain is called with DLL_PROCESS_DETACH, at which point it's too late to safely message and wait for it shutddown, thus it can continue running after the DLL is unloaded from memory.
2012-03-08 17:42:16 -08:00
/* 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,
Avoid static global initialization functions
2018-12-08 21:58:44 -08:00
(WCHAR*)module, &module);
Move (de)initialization into ALc.c and remove unneeded file
2008-07-17 18:38:07 -07:00
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
Get rid of deinit code duplication
2009-09-12 17:29:35 -07:00
#endif
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
static void alc_initconfig(void)
{
const char *devs, *str;
Move the CPU capability flags to a separate header
2018-01-11 07:19:19 -08:00
int capfilter;
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
float valf;
Use only the first available backend for playback or capture devices This should help cut down on the number of duplicate devices when enumerating on a system that supports multiple backends. It will also avoid the problem of backends that don't play well with others (eg, PulseAudio).
2011-08-19 01:41:16 -07:00
int i, n;
Create TLS for contexts earlier
2011-06-14 06:57:51 -07:00
Add some macros for logging at various levels, and use them
2011-07-10 21:30:25 -07:00
str = getenv("ALSOFT_LOGLEVEL");
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
}
Trace the commit ID and branch the library was built from
2016-12-21 01:08:33 -08: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 variable counter for an array size limit
2017-02-28 04:21:16 -08:00
if(BackendListSize > 0)
Avoid a fixed-size string buffer
2018-11-18 07:00:43 -08:00
names += BackendList[0].name;
Use a variable counter for an array size limit
2017-02-28 04:21:16 -08:00
for(i = 1;i < BackendListSize;i++)
Avoid a fixed-size string buffer
2018-11-18 07:00:43 -08:00
{
names += ", ";
names += BackendList[i].name;
}
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);
}
Add cmake options to disable or require support for CPU extensions
2012-08-15 01:24:50 -07:00
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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueStr(nullptr, nullptr, "disable-cpu-exts", &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 static global initialization functions
2018-12-08 21:58:44 -08:00
size_t len{next ? (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
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
RTPrioLevel = 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
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
RTPrioLevel = 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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueInt(nullptr, nullptr, "rt-prio", &RTPrioLevel);
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
{
TrapALError = AL_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))
Read ALSOFT_TRAP_*ERROR when reading the config
2012-04-16 20:13:50 -07:00
TrapALError = AL_TRUE;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueFloat(nullptr, "reverb", "boost", &valf))
Use std::pow and std::log2
2018-11-14 17:01:19 -08:00
ReverbBoost *= std::pow(10.0f, valf / 20.0f);
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
Check for the ALSOFT_DRIVERS env var for a list of backend drivers This overrides the 'drivers' config option
2012-02-19 14:27:00 -08:00
if(((devs=getenv("ALSOFT_DRIVERS")) && devs[0]) ||
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueStr(nullptr, nullptr, "drivers", &devs))
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
{
int n;
size_t len;
const char *next = devs;
Allow prepending backend names with - to remove them from the available devices
2010-06-05 19:33:06 -07:00
int endlist, delitem;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
i = 0;
do {
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, ',');
Allow prepending backend names with - to remove them from the available devices
2010-06-05 19:33:06 -07:00
delitem = (devs[0] == '-');
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
{
endlist = 0;
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
}
endlist = 1;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
len = (next ? ((size_t)(next-devs)) : strlen(devs));
Better handle spaces between string list entries
2013-06-16 15:44:41 -07:00
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
Use a variable counter for an array size limit
2017-02-28 04:21:16 -08:00
for(n = i;n < BackendListSize;n++)
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
{
if(len == strlen(BackendList[n].name) &&
strncmp(BackendList[n].name, devs, len) == 0)
{
Allow prepending backend names with - to remove them from the available devices
2010-06-05 19:33:06 -07:00
if(delitem)
Allow unlisted backends to stay available when the drivers list ends with ,
2009-11-22 01:06:05 -08:00
{
Use a variable counter for an array size limit
2017-02-28 04:21:16 -08:00
for(;n+1 < BackendListSize;n++)
Allow prepending backend names with - to remove them from the available devices
2010-06-05 19:33:06 -07:00
BackendList[n] = BackendList[n+1];
Use a variable counter for an array size limit
2017-02-28 04:21:16 -08:00
BackendListSize--;
Allow prepending backend names with - to remove them from the available devices
2010-06-05 19:33:06 -07:00
}
else
{
Remove a typedef
2011-08-18 23:58:00 -07:00
struct BackendInfo Bkp = BackendList[n];
Use a variable counter for an array size limit
2017-02-28 04:21:16 -08:00
for(;n > i;n--)
Allow prepending backend names with - to remove them from the available devices
2010-06-05 19:33:06 -07:00
BackendList[n] = BackendList[n-1];
BackendList[n] = Bkp;
i++;
Allow unlisted backends to stay available when the drivers list ends with ,
2009-11-22 01:06:05 -08:00
}
break;
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)
Use a variable counter for an array size limit
2017-02-28 04:21:16 -08:00
BackendListSize = i;
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
}
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
for(n = i = 0;i < BackendListSize && (!PlaybackBackend.name || !CaptureBackend.name);i++)
Remove backends that fail to initialize
2011-08-17 06:15:43 -07:00
{
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
BackendList[n] = BackendList[i];
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 &factory = BackendList[n].getFactory();
if(!factory.init())
Use separate lists for playback and capture backends
2011-08-19 00:23:26 -07:00
{
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
WARN("Failed to initialize backend \"%s\"\n", BackendList[n].name);
Don't remove backends that fail to initialize
2011-08-19 01:54:55 -07:00
continue;
}
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
TRACE("Initialized backend \"%s\"\n", BackendList[n].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
if(!PlaybackBackend.name && factory.querySupport(ALCbackend_Playback))
Don't remove backends that fail to initialize
2011-08-19 01:54:55 -07:00
{
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
PlaybackBackend = BackendList[n];
Don't remove backends that fail to initialize
2011-08-19 01:54:55 -07:00
TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
Use separate lists for playback and capture backends
2011-08-19 00:23:26 -07: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
if(!CaptureBackend.name && factory.querySupport(ALCbackend_Capture))
Remove backends that fail to initialize
2011-08-17 06:15:43 -07:00
{
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
CaptureBackend = BackendList[n];
Don't remove backends that fail to initialize
2011-08-19 01:54:55 -07:00
TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
Remove backends that fail to initialize
2011-08-17 06:15:43 -07:00
}
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
n++;
Remove backends that fail to initialize
2011-08-17 06:15:43 -07:00
}
Avoid deinitializing backends that never initialized
2018-03-08 18:53:49 -08:00
BackendListSize = n;
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 crash when there's no backend to probe
2016-04-30 17:14:55 -07:00
if(!PlaybackBackend.name)
WARN("No playback backend available!\n");
if(!CaptureBackend.name)
WARN("No capture backend available!\n");
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueStr(nullptr, nullptr, "excludefx", &str))
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
{
const char *next = str;
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 static global initialization functions
2018-12-08 21:58:44 -08:00
size_t len{next ? (size_t)(next-str) : strlen(str)};
Clean up the EffectList members and make the list size known
2018-01-11 09:34:01 -08:00
for(n = 0;n < EFFECTLIST_SIZE;n++)
Initialize OpenAL with a constructor call instead of first-use
2009-09-12 17:49:08 -07:00
{
if(len == strlen(EffectList[n].name) &&
strncmp(EffectList[n].name, str, len) == 0)
DisabledEffects[EffectList[n].type] = AL_TRUE;
}
} 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);
Remove the trailing double-underscore from a couple env vars
2012-02-19 17:24:01 -08:00
str = getenv("ALSOFT_DEFAULT_REVERB");
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if((str && str[0]) || ConfigValueStr(nullptr, nullptr, "default-reverb", &str))
Rename GetReverbEffect to LoadReverbPreset
2012-03-13 15:48:51 -07:00
LoadReverbPreset(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
************************************************/
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
static void ProbeDevices(std::string *list, struct BackendInfo *backendinfo, enum DevProbe type)
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};
Use std::string instead of al_string for enumerating
2018-11-15 04:24:33 -08:00
list->clear();
It's getFactory that may be NULL, not its return value...
2017-11-26 09:59:55 -08:00
if(backendinfo->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
backendinfo->getFactory().probe(type, list);
Rebuild device lists when retrieving them
2009-08-27 06:09:33 -07:00
}
Rename AllDevice -> AllDevices
2012-05-09 16:28:16 -07:00
static void ProbeAllDevicesList(void)
Pass the appropriate BackendInfo explicitly to ProbeDevices
2015-10-28 18:10:12 -07:00
{ ProbeDevices(&alcAllDevicesList, &PlaybackBackend, ALL_DEVICE_PROBE); }
Move some functions into a separate helper source file
2011-08-20 03:59:46 -07:00
static void ProbeCaptureDeviceList(void)
Pass the appropriate BackendInfo explicitly to ProbeDevices
2015-10-28 18:10:12 -07:00
{ ProbeDevices(&alcCaptureDeviceList, &CaptureBackend, CAPTURE_DEVICE_PROBE); }
Rebuild device lists when retrieving them
2009-08-27 06:09:33 -07:00
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
************************************************/
Add functions to get strings from the device format
2011-05-15 04:03:15 -07:00
const ALCchar *DevFmtTypeString(enum DevFmtType type)
{
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)";
}
const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
{
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)";
}
Use ALsizei in more places
2017-01-18 07:13:23 -08:00
ALsizei BytesFromDevFmt(enum DevFmtType type)
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;
}
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
ALsizei ChannelsFromDevFmt(enum DevFmtChannels chans, ALsizei ambiorder)
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;
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
case DevFmtAmbi3D: return (ambiorder >= 3) ? 16 :
(ambiorder == 2) ? 9 :
(ambiorder == 1) ? 4 : 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
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 ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,
enum DevFmtType *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
static const struct {
ALenum format;
enum DevFmtChannels channels;
enum DevFmtType type;
} 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 },
};
ALuint i;
Add a COUNTOF macro to get the number of entries in a static array
2012-02-19 12:07:40 -08:00
for(i = 0;i < COUNTOF(list);i++)
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
if(list[i].format == format)
{
*chans = list[i].channels;
*type = list[i].type;
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
return AL_TRUE;
Use arrays instead of large switches to decompose formats
2011-09-18 19:06:19 -07:00
}
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
Separate device format into 'channel config' and 'sample type' components
2010-12-04 19:50:00 -08:00
return AL_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 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)
{
Replace a couple ALuint with ALsizei
2017-03-17 15:45:39 -07:00
ALsizei i;
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
Use a separate macro for the max output channel count
2014-11-07 02:18:24 -08:00
for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[i] = InvalidChannel;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontCenter;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
device->RealOut.ChannelName[2] = BackLeft;
device->RealOut.ChannelName[3] = BackRight;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
device->RealOut.ChannelName[2] = FrontCenter;
device->RealOut.ChannelName[3] = LFE;
device->RealOut.ChannelName[4] = SideLeft;
device->RealOut.ChannelName[5] = SideRight;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
device->RealOut.ChannelName[2] = FrontCenter;
device->RealOut.ChannelName[3] = LFE;
device->RealOut.ChannelName[4] = BackLeft;
device->RealOut.ChannelName[5] = BackRight;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
device->RealOut.ChannelName[2] = FrontCenter;
device->RealOut.ChannelName[3] = LFE;
device->RealOut.ChannelName[4] = BackCenter;
device->RealOut.ChannelName[5] = SideLeft;
device->RealOut.ChannelName[6] = SideRight;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
device->RealOut.ChannelName[2] = FrontCenter;
device->RealOut.ChannelName[3] = LFE;
device->RealOut.ChannelName[4] = BackLeft;
device->RealOut.ChannelName[5] = BackRight;
device->RealOut.ChannelName[6] = SideLeft;
device->RealOut.ChannelName[7] = SideRight;
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:
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
device->RealOut.ChannelName[0] = Aux0;
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
{
device->RealOut.ChannelName[1] = Aux1;
device->RealOut.ChannelName[2] = Aux2;
device->RealOut.ChannelName[3] = Aux3;
}
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
{
device->RealOut.ChannelName[4] = Aux4;
device->RealOut.ChannelName[5] = Aux5;
device->RealOut.ChannelName[6] = Aux6;
device->RealOut.ChannelName[7] = Aux7;
device->RealOut.ChannelName[8] = Aux8;
}
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
{
device->RealOut.ChannelName[9] = Aux9;
device->RealOut.ChannelName[10] = Aux10;
device->RealOut.ChannelName[11] = Aux11;
device->RealOut.ChannelName[12] = Aux12;
device->RealOut.ChannelName[13] = Aux13;
device->RealOut.ChannelName[14] = Aux14;
device->RealOut.ChannelName[15] = Aux15;
}
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)
{
Replace a couple ALuint with ALsizei
2017-03-17 15:45:39 -07:00
ALsizei i;
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
Use a separate macro for the max output channel count
2014-11-07 02:18:24 -08:00
for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[i] = InvalidChannel;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
device->RealOut.ChannelName[2] = BackLeft;
device->RealOut.ChannelName[3] = BackRight;
device->RealOut.ChannelName[4] = FrontCenter;
device->RealOut.ChannelName[5] = LFE;
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:
Keep track of the real output's channel names
2016-03-10 01:04:28 -08:00
device->RealOut.ChannelName[0] = FrontLeft;
device->RealOut.ChannelName[1] = FrontRight;
device->RealOut.ChannelName[2] = BackLeft;
device->RealOut.ChannelName[3] = BackRight;
device->RealOut.ChannelName[4] = FrontCenter;
device->RealOut.ChannelName[5] = LFE;
device->RealOut.ChannelName[6] = SideLeft;
device->RealOut.ChannelName[7] = SideRight;
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.
*/
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
context->HoldUpdates.store(AL_TRUE);
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.
*/
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
context->HoldUpdates.store(AL_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
}
}
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
}
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
static struct 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)
{
Use standard types for the device clock times
2018-11-22 12:53:16 -08:00
using std::chrono::seconds;
using std::chrono::nanoseconds;
using std::chrono::duration_cast;
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);
Use standard types for the device clock times
2018-11-22 12:53:16 -08:00
device->ClockBase += duration_cast<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
{
Don't store the HRTF request mode in the device flags
2015-09-05 01:32:12 -07:00
enum HrtfRequestMode hrtf_userreq = Hrtf_Default;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
enum 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 an unnecessary else statement
2012-01-20 12:20:24 -08:00
enum DevFmtChannels oldChans;
enum DevFmtType oldType;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
ALboolean update_failed;
ALCsizei hrtf_id = -1;
ALCcontext *context;
Remove an unnecessary else statement
2012-01-20 12:20:24 -08:00
ALCuint oldFreq;
Start an extension to toggle the output limiter
2017-04-30 04:21:48 -07:00
int val;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
// Check for attributes
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
if(device->Type == Loopback)
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
ALCsizei numMono, numStereo, numSends;
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
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
if(!attrList)
{
WARN("Missing attributes for loopback device\n");
return ALC_INVALID_VALUE;
}
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
numMono = device->NumMonoSources;
numStereo = device->NumStereoSources;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
numSends = old_sends;
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
Trace the requested attribute values
2016-04-17 17:22:03 -07:00
#define TRACE_ATTR(a, v) TRACE("Loopback %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
{
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_FORMAT_CHANNELS_SOFT:
schans = attrList[attrIdx + 1];
TRACE_ATTR(ALC_FORMAT_CHANNELS_SOFT, schans);
if(!IsValidALCChannels(schans))
return ALC_INVALID_VALUE;
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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_FORMAT_TYPE_SOFT:
stype = attrList[attrIdx + 1];
TRACE_ATTR(ALC_FORMAT_TYPE_SOFT, stype);
if(!IsValidALCType(stype))
return ALC_INVALID_VALUE;
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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_FREQUENCY:
freq = attrList[attrIdx + 1];
TRACE_ATTR(ALC_FREQUENCY, freq);
if(freq < MIN_OUTPUT_RATE)
return ALC_INVALID_VALUE;
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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_AMBISONIC_LAYOUT_SOFT:
alayout = attrList[attrIdx + 1];
TRACE_ATTR(ALC_AMBISONIC_LAYOUT_SOFT, alayout);
if(!IsValidAmbiLayout(alayout))
return ALC_INVALID_VALUE;
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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_AMBISONIC_SCALING_SOFT:
ascale = attrList[attrIdx + 1];
TRACE_ATTR(ALC_AMBISONIC_SCALING_SOFT, ascale);
if(!IsValidAmbiScaling(ascale))
return ALC_INVALID_VALUE;
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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_AMBISONIC_ORDER_SOFT:
aorder = attrList[attrIdx + 1];
TRACE_ATTR(ALC_AMBISONIC_ORDER_SOFT, aorder);
if(aorder < 1 || aorder > MAX_AMBI_ORDER)
return ALC_INVALID_VALUE;
break;
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
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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07: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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07: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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07: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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_HRTF_ID_SOFT:
hrtf_id = attrList[attrIdx + 1];
TRACE_ATTR(ALC_HRTF_ID_SOFT, hrtf_id);
break;
Start an extension to toggle the output limiter
2017-04-30 04:21:48 -07:00
case ALC_OUTPUT_LIMITER_SOFT:
gainLimiter = attrList[attrIdx + 1];
TRACE_ATTR(ALC_OUTPUT_LIMITER_SOFT, gainLimiter);
break;
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
default:
TRACE("Loopback 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
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(!schans || !stype || !freq)
Make sure the attributes list specifies a format for loopback devices
2012-01-25 19:54:55 -08:00
{
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
WARN("Missing format for loopback device\n");
return ALC_INVALID_VALUE;
Make sure the attributes list specifies a format for loopback devices
2012-01-25 19:54:55 -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
if(schans == ALC_BFORMAT3D_SOFT && (!alayout || !ascale || !aorder))
{
WARN("Missing ambisonic info for loopback device\n");
return ALC_INVALID_VALUE;
}
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
if((device->Flags&DEVICE_RUNNING))
Rename VCALL and VCALL0 to V and V0
2013-11-02 17:30:28 -07:00
V0(device->Backend,stop)();
Don't store the HRTF request mode in the device flags
2015-09-05 01:32:12 -07:00
device->Flags &= ~DEVICE_RUNNING;
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);
Store the ambisonic order separate from the channel enum
2017-04-12 18:26:07 -07:00
device->Frequency = freq;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->FmtChans = static_cast<enum DevFmtChannels>(schans);
device->FmtType = static_cast<enum DevFmtType>(stype);
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(schans == ALC_BFORMAT3D_SOFT)
{
Avoid more cases of an enum variable and type name clash
2018-11-18 08:01:50 -08:00
device->mAmbiOrder = aorder;
Use an enum class for AmbiLayout/Norm settings
2018-11-20 22:47:24 -08:00
device->mAmbiLayout = static_cast<AmbiLayout>(alayout);
device->mAmbiScale = static_cast<AmbiNorm>(ascale);
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
}
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;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueInt(nullptr, nullptr, "sources", &numMono))
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 <= 0)
numMono = 256;
}
else
numMono = maxi(numMono, 256);
numStereo = mini(numStereo, numMono);
numMono -= numStereo;
device->SourcesMax = numMono + numStereo;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
device->NumMonoSources = numMono;
device->NumStereoSources = numStereo;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueInt(nullptr, nullptr, "sends", &new_sends))
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 = mini(numSends, clampi(new_sends, 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;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
}
else if(attrList && attrList[0])
{
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
ALCsizei numMono, numStereo, numSends;
ALCsizei attrIdx = 0;
ALCuint freq;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
/* If a context is already running on the device, stop playback so the
* device attributes can be updated. */
if((device->Flags&DEVICE_RUNNING))
Stop the device when updating parameters, don't close it
2014-01-15 16:30:23 -08:00
V0(device->Backend,stop)();
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
device->Flags &= ~DEVICE_RUNNING;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
UpdateClockBase(device);
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
freq = device->Frequency;
numMono = device->NumMonoSources;
numStereo = device->NumStereoSources;
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
numSends = old_sends;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Trace the requested attribute values
2016-04-17 17:22:03 -07:00
#define TRACE_ATTR(a, v) TRACE("%s = %d\n", #a, v)
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
while(attrList[attrIdx])
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
{
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
switch(attrList[attrIdx])
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
{
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_FREQUENCY:
freq = attrList[attrIdx + 1];
TRACE_ATTR(ALC_FREQUENCY, freq);
device->Flags |= DEVICE_FREQUENCY_REQUEST;
break;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07: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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_STEREO_SOURCES:
numStereo = attrList[attrIdx + 1];
TRACE_ATTR(ALC_STEREO_SOURCES, numStereo);
numStereo = maxi(numStereo, 0);
break;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_MAX_AUXILIARY_SENDS:
numSends = attrList[attrIdx + 1];
TRACE_ATTR(ALC_MAX_AUXILIARY_SENDS, numSends);
numSends = clampi(numSends, 0, MAX_SENDS);
break;
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07: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
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07:00
case ALC_HRTF_ID_SOFT:
hrtf_id = attrList[attrIdx + 1];
TRACE_ATTR(ALC_HRTF_ID_SOFT, hrtf_id);
break;
Start an extension to toggle the output limiter
2017-04-30 04:21:48 -07:00
case ALC_OUTPUT_LIMITER_SOFT:
gainLimiter = attrList[attrIdx + 1];
TRACE_ATTR(ALC_OUTPUT_LIMITER_SOFT, gainLimiter);
break;
Trace unhandled device reset attributes
2017-04-16 16:21:11 -07: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
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
attrIdx += 2;
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
}
Trace the requested attribute values
2016-04-17 17:22:03 -07:00
#undef TRACE_ATTR
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
Use a std::string for the device name
2018-11-18 18:45:45 -08:00
ConfigValueUInt(device->DeviceName.c_str(), nullptr, "frequency", &freq);
Use separate loops for getting and checking device attributes
2012-02-25 18:03:33 -08:00
freq = maxu(freq, MIN_OUTPUT_RATE);
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
device->UpdateSize = (ALuint64)device->UpdateSize * freq /
device->Frequency;
Implement dry and wet mixers for Neon Code provided by Philippe Simons <simons.philippe@gmail.com>.
2014-01-26 01:34:39 -08:00
/* SSE and Neon do best with the update size being a multiple of 4 */
if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
Help ensure the update size is a multiple of 4 with SSE
2012-09-20 14:54:28 -07:00
device->UpdateSize = (device->UpdateSize+3)&~3;
Start the device when creating a context without specified attributes
2010-08-12 17:24:55 -07:00
device->Frequency = freq;
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 a std::string for the device name
2018-11-18 18:45:45 -08:00
if(ConfigValueInt(device->DeviceName.c_str(), nullptr, "sources", &numMono))
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 <= 0)
numMono = 256;
}
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 a std::string for the device name
2018-11-18 18:45:45 -08:00
if(ConfigValueInt(device->DeviceName.c_str(), nullptr, "sends", &new_sends))
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 = mini(numSends, clampi(new_sends, 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
}
Use a flag to specify when a device is running
2011-06-15 01:59:07 -07:00
if((device->Flags&DEVICE_RUNNING))
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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->Uhj_Encoder = nullptr;
device->Bs2b = nullptr;
Use 2-channel UHJ for stereo output
2016-02-26 16:09:06 -08:00
Use a normal vector for the distance buffer storage
2018-11-21 05:06:31 -08:00
device->ChannelDelay.clear();
device->ChannelDelay.shrink_to_fit();
Dynamically allocate the channel delay buffers
2017-02-28 21:01:13 -08:00
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;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->FOAOut.Buffer = nullptr;
Remove the VirtOut buffer alias
2016-07-05 14:18:17 -07:00
device->FOAOut.NumChannels = 0;
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);
Use standard types for the device clock times
2018-11-22 12:53:16 -08:00
device->FixedLatency = std::chrono::nanoseconds::zero();
Keep track of a device clock time, based on the number of samples processed
2014-02-01 16:37:11 -08:00
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
{
Change the hrtf config option to expect auto/true/false instead of a bool
2015-09-04 20:16:48 -07:00
const char *hrtf;
Use a std::string for the device name
2018-11-18 18:45:45 -08:00
if(ConfigValueStr(device->DeviceName.c_str(), nullptr, "hrtf", &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
{
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
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
struct Hrtf *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
{
Use a regular vector for the enumerated HRTF list
2018-11-18 19:19:35 -08:00
if(hrtf_id >= 0 && (size_t)hrtf_id < device->HrtfList.size())
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;
Avoid setting an HRTF-compatible format when it's disabled
2015-09-05 14:22:19 -07:00
device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_FREQUENCY_REQUEST;
Reference count HRTFs and unload them when unused
2017-04-06 13:00:29 -07:00
if(device->HrtfHandle)
Hrtf_DecRef(device->HrtfHandle);
device->HrtfHandle = 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;
TRACE("Pre-reset: %s%s, %s%s, %s%uhz, %u update size x%d\n",
Reformat a couple lines
2014-11-21 14:40:10 -08:00
(device->Flags&DEVICE_CHANNELS_REQUEST)?"*":"", DevFmtChannelsString(device->FmtChans),
(device->Flags&DEVICE_SAMPLE_TYPE_REQUEST)?"*":"", DevFmtTypeString(device->FmtType),
(device->Flags&DEVICE_FREQUENCY_REQUEST)?"*":"", device->Frequency,
device->UpdateSize, device->NumUpdates
);
Setup the HRTF format before tracing the pre-reset format
2014-08-29 19:34:20 -07:00
Rename VCALL and VCALL0 to V and V0
2013-11-02 17:30:28 -07:00
if(V0(device->Backend,reset)() == ALC_FALSE)
Return the error code from UpdateDeviceParams
2012-01-25 20:00:34 -08:00
return ALC_INVALID_DEVICE;
Report parameter request changes in UpdateDeviceParams
2012-01-17 15:55:37 -08:00
Combine a couple if checks
2012-02-15 11:28:19 -08:00
if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
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));
Remove an unnecessary else statement
2012-01-20 12:20:24 -08:00
device->Flags &= ~DEVICE_CHANNELS_REQUEST;
Hold the global lock while the device is being updated
2011-05-29 02:56:00 -07:00
}
Add a device request flag for the sample type
2012-02-15 16:26:32 -08:00
if(device->FmtType != oldType && (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
{
ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
DevFmtTypeString(device->FmtType));
device->Flags &= ~DEVICE_SAMPLE_TYPE_REQUEST;
}
Combine a couple if checks
2012-02-15 11:28:19 -08:00
if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
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);
Remove an unnecessary else statement
2012-01-20 12:20:24 -08:00
device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
}
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);
}
Move the InitRenderer method to panning.c
2016-04-14 15:25:12 -07:00
TRACE("Post-reset: %s, %s, %uhz, %u update size x%d\n",
DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
device->Frequency, device->UpdateSize, device->NumUpdates
);
aluInitRenderer(device, hrtf_id, hrtf_appreq, hrtf_userreq);
Avoid duplicating device buffer layout logic
2017-02-20 16:57:25 -08:00
TRACE("Channel config, Dry: %d, FOA: %d, Real: %d\n", device->Dry.NumChannels,
device->FOAOut.NumChannels, 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. */
Use a vector to handle mixing buffer storage
2018-11-19 06:22:09 -08:00
ALsizei num_chans{device->Dry.NumChannels + device->FOAOut.NumChannels +
device->RealOut.NumChannels};
Don't use periphonic FOA when the HOA decoder is not periphonic
2017-02-19 17:45:27 -08:00
Use a vector to handle mixing buffer storage
2018-11-19 06:22:09 -08:00
TRACE("Allocating %d channels, " SZFMT " bytes\n", num_chans,
num_chans*sizeof(device->MixBuffer[0]));
device->MixBuffer.resize(num_chans);
Allocate the DryBuffer dynamically
2014-11-21 13:45:57 -08:00
Use a vector to handle mixing buffer storage
2018-11-19 06:22:09 -08:00
device->Dry.Buffer = &reinterpret_cast<ALfloat(&)[BUFFERSIZE]>(device->MixBuffer[0]);
Avoid duplicating device buffer layout logic
2017-02-20 16:57:25 -08:00
if(device->RealOut.NumChannels != 0)
device->RealOut.Buffer = device->Dry.Buffer + device->Dry.NumChannels +
device->FOAOut.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
Avoid duplicating device buffer layout logic
2017-02-20 16:57:25 -08:00
if(device->FOAOut.NumChannels != 0)
device->FOAOut.Buffer = device->Dry.Buffer + device->Dry.NumChannels;
Don't use periphonic FOA when the HOA decoder is not periphonic
2017-02-19 17:45:27 -08:00
else
{
Avoid duplicating device buffer layout logic
2017-02-20 16:57:25 -08:00
device->FOAOut.Buffer = device->Dry.Buffer;
device->FOAOut.NumChannels = device->Dry.NumChannels;
Don't use periphonic FOA when the HOA decoder is not periphonic
2017-02-19 17:45:27 -08:00
}
Add a specific output for first-order sources
2016-03-22 17:52:20 -07: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",
device->SourcesMax, device->NumMonoSources, device->NumStereoSources,
device->AuxiliaryEffectSlotMax, device->NumAuxSends);
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
Trace if dithering is enabled
2017-06-19 00:17:11 -07:00
device->DitherDepth = 0.0f;
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
{
ALint depth = 0;
Use a std::string for the device name
2018-11-18 18:45:45 -08:00
ConfigValueInt(device->DeviceName.c_str(), nullptr, "dither-depth", &depth);
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);
Use std::pow and std::log2
2018-11-14 17:01:19 -08:00
device->DitherDepth = std::pow(2.0f, (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;
Use a std::string for the device name
2018-11-18 18:45:45 -08:00
if(ConfigValueBool(device->DeviceName.c_str(), nullptr, "output-limiter", &val))
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
gainLimiter = val ? 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;
}
}
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
if(gainLimiter != ALC_FALSE)
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;
Use a unique_ptr for the Compressor
2018-11-21 16:46:52 -08:00
device->Limiter.reset(CreateDeviceLimiter(device, std::log10(thrshld) * 20.0f));
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. */
device->FixedLatency += std::chrono::duration_cast<std::chrono::nanoseconds>(
std::chrono::seconds(GetCompressorLookAhead(device->Limiter.get()))
) / device->Frequency;
Calculate the output limiter gain using the RMS
2017-05-05 07:38:26 -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
else
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
device->Limiter = nullptr;
Log whether the output limiter is enabled or disabled
2017-05-11 16:29:05 -07:00
TRACE("Output limiter %s\n", device->Limiter ? "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 function pointer for applying the dry mix post-process
2018-02-10 15:50:05 -08:00
aluSelectPostProcess(device);
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{};
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
context = device->ContextList.load();
Use a list of contexts in the device instead of an array
2011-08-28 19:28:41 -07:00
while(context)
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();
Use proper inheritence for the effect state objects
2018-11-19 22:34:26 -08:00
EffectState *state = slot->Effect.State;
Store the default effect slot in the context
2017-07-13 21:30:05 -07:00
Use proper inheritence for the effect state objects
2018-11-19 22:34:26 -08:00
state->mOutBuffer = device->Dry.Buffer;
state->mOutChannels = device->Dry.NumChannels;
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};
Use a normal vector for auxiliary effect slots
2018-11-18 02:39:27 -08:00
for(auto &slot : context->EffectSlotList)
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
{
Use proper inheritence for the effect state objects
2018-11-19 22:34:26 -08:00
EffectState *state = slot->Effect.State;
Update device parameters using a separate function
2010-08-09 00:28:48 -07:00
Use proper inheritence for the effect state objects
2018-11-19 22:34:26 -08:00
state->mOutBuffer = device->Dry.Buffer;
state->mOutChannels = device->Dry.NumChannels;
if(state->deviceUpdate(device) == AL_FALSE)
Dynamically allocate the ALsource Send[] array
2017-02-21 16:31:59 -08:00
update_failed = AL_TRUE;
else
Store effect slots as unique_ptrs
2018-11-20 10:01:20 -08:00
UpdateEffectSlotProps(slot.get(), 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 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
usemask &= ~(U64(1) << idx);
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;
}
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
AllocateVoices(context, context->MaxVoices, old_sends);
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
auto voices_end = context->Voices + context->VoiceCount.load(std::memory_order_relaxed);
std::for_each(context->Voices, voices_end,
[device](ALvoice *voice) -> void
{
Don't bother making ALvoiceProps dynamically sized
2018-11-30 16:56:23 -08:00
delete voice->Update.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
Store the source ID with the voice instead of the source pointer
2018-11-29 22:49:01 -08:00
if(voice->SourceID.load(std::memory_order_acquire) == 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. */
ALfloat w1 = SPEEDOFSOUNDMETRESPERSEC /
(device->AvgSpeakerDist * device->Frequency);
std::for_each(voice->Direct.Params, voice->Direct.Params+voice->NumChannels,
Use class methods for the NFC filters
2018-12-05 15:20:52 -08:00
[w1](DirectParams &params) noexcept -> void
{ params.NFCtrlFilter.init(0.0f, w1); }
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);
Store some source mixing parameters in the active source struct
2014-03-19 13:14:11 -07:00
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
context = context->next.load(std::memory_order_relaxed);
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
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
if(!(device->Flags&DEVICE_PAUSED))
{
if(V0(device->Backend,start)() == ALC_FALSE)
return ALC_INVALID_DEVICE;
device->Flags |= DEVICE_RUNNING;
}
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 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
ALCdevice_struct::ALCdevice_struct(DeviceType type)
: Type{type}
Combine common initialization code into a function
2018-01-28 18:03:54 -08: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
/* ALCdevice_struct::~ALCdevice_struct
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
*/
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
ALCdevice_struct::~ALCdevice_struct()
Add some reference counting to the device
2011-09-10 02:43:07 -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
TRACE("%p\n", this);
Hold an extra reference on the device for each of its contexts
2011-09-10 03:01:24 -07:00
Don't explicitly clear vector objects in the destructor
2018-11-25 17:51:39 -08:00
DELETE_OBJ(Backend);
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)
WARN(SZFMT " 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)
WARN(SZFMT " 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)
WARN(SZFMT " 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
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
if(HrtfHandle)
Hrtf_DecRef(HrtfHandle);
HrtfHandle = nullptr;
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
Use RAII for device references
2018-11-23 17:54:12 -08:00
static void ALCdevice_IncRef(ALCdevice *device)
Hold an extra reference on the device for each of its contexts
2011-09-10 03:01:24 -07:00
{
Simplify the RefCount type
2018-11-19 02:17:06 -08:00
auto ref = IncrementRef(&device->ref);
Make a separate log level to trace reference counts, to avoid log spam for traces
2011-09-20 12:24:23 -07:00
TRACEREF("%p increasing refcount to %u\n", device, ref);
Hold an extra reference on the device for each of its contexts
2011-09-10 03:01:24 -07:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
static void ALCdevice_DecRef(ALCdevice *device)
Add some reference counting to the device
2011-09-10 02:43:07 -07:00
{
Simplify the RefCount type
2018-11-19 02:17:06 -08:00
auto ref = DecrementRef(&device->ref);
Make a separate log level to trace reference counts, to avoid log spam for traces
2011-09-20 12:24:23 -07:00
TRACEREF("%p decreasing refcount to %u\n", device, ref);
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
if(ref == 0) delete device;
Add some reference counting to the device
2011-09-10 02:43:07 -07:00
}
Use RAII for device references
2018-11-23 17:54:12 -08:00
/* 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
{
reset();
mDev = rhs.mDev;
rhs.mDev = nullptr;
return *this;
}
operator bool() const noexcept { return mDev != nullptr; }
ALCdevice* operator->() noexcept { return mDev; }
ALCdevice* get() noexcept { return mDev; }
ALCdevice* release() noexcept
{
ALCdevice *ret{mDev};
mDev = nullptr;
return ret;
}
};
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};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *tmpDevice{DeviceList.load()};
Make VerifyDevice and VerifyContext modify its parameter
2015-10-19 18:48:33 -07:00
while(tmpDevice)
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(tmpDevice == device)
Make VerifyDevice and VerifyContext modify its parameter
2015-10-19 18:48:33 -07:00
{
ALCdevice_IncRef(tmpDevice);
Use RAII for device references
2018-11-23 17:54:12 -08:00
return DeviceRef{tmpDevice};
Make VerifyDevice and VerifyContext modify its parameter
2015-10-19 18:48:33 -07:00
}
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
tmpDevice = tmpDevice->next.load(std::memory_order_relaxed);
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
}
Use a unique_ptr for the default effect slot
2018-11-20 05:01:08 -08:00
ALCcontext_struct::ALCcontext_struct(ALCdevice *device)
: Device{device}
{
}
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;
Use an array of pointers for effects instead of a linked list
2017-03-27 23:16:23 -07:00
struct 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
Add the default auxiliary slot to the active slot array
2017-07-13 23:13:02 -07:00
if(Context->DefaultSlot)
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
auxslots = static_cast<ALeffectslotArray*>(al_calloc(DEF_ALIGN,
FAM_SIZE(struct ALeffectslotArray, slot, 1)));
Add the default auxiliary slot to the active slot array
2017-07-13 23:13:02 -07:00
auxslots->count = 1;
Use a unique_ptr for the default effect slot
2018-11-20 05:01:08 -08:00
auxslots->slot[0] = Context->DefaultSlot.get();
Add the default auxiliary slot to the active slot array
2017-07-13 23:13:02 -07:00
}
else
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
auxslots = static_cast<ALeffectslotArray*>(al_calloc(DEF_ALIGN,
sizeof(struct ALeffectslotArray)));
Add the default auxiliary slot to the active slot array
2017-07-13 23:13:02 -07:00
auxslots->count = 0;
}
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
Store the listener directly in the context
2018-11-17 23:41:11 -08:00
listener.Params.Matrix = aluMatrixf::Identity;
aluVectorSet(&listener.Params.Velocity, 0.0f, 0.0f, 0.0f, 0.0f);
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
Increase the async event queue size
2018-12-04 16:38:22 -08:00
Context->AsyncEvents = ll_ringbuffer_create(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
}
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
/* ALCcontext_struct::~ALCcontext_struct()
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
*/
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
ALCcontext_struct::~ALCcontext_struct()
Initial import
2007-11-13 18:02:18 -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
TRACE("%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;
}
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
TRACE("Freed " SZFMT " 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)
WARN(SZFMT " 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;
}
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
TRACE("Freed " SZFMT " 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
Small cleanup for ~ALCcontext_struct
2018-11-27 21:19:30 -08:00
al_free(ActiveAuxSlots.exchange(nullptr, std::memory_order_relaxed));
DefaultSlot = nullptr;
count = std::count_if(EffectSlotList.cbegin(), EffectSlotList.cend(),
[](const ALeffectslotPtr &slot) noexcept -> bool { return slot != nullptr; }
);
Avoid a separate function to clean up effect slots
2018-11-25 09:23:01 -08:00
if(count > 0)
WARN(SZFMT " 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();
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;
}
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
TRACE("Freed " SZFMT " 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
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
std::for_each(Voices, Voices + MaxVoices, DeinitVoice);
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
al_free(Voices);
Voices = nullptr;
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
VoiceCount.store(0, 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
MaxVoices = 0;
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;
}
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
TRACE("Freed " SZFMT " 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
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
ll_ringbuffer_free(AsyncEvents);
AsyncEvents = nullptr;
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
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
{
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
ALCcontext *origctx, *newhead;
bool ret = true;
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);
}
Support C11 atomics
2014-07-23 06:36:34 -07:00
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);
Make a couple functions inline
2018-01-12 02:37:48 -08:00
V0(device->Backend,lock)();
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
origctx = context;
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
newhead = context->next.load(std::memory_order_relaxed);
Remove the atomic exchange macros
2018-11-19 03:21:58 -08:00
if(!device->ContextList.compare_exchange_strong(origctx, newhead))
Properly destroy contexts that are left on the device when it's closed
2011-09-10 07:35:48 -07:00
{
Use atomic variables instead of volatile
2018-03-02 18:38:59 -08:00
ALCcontext *list;
do {
/* origctx is what the desired context failed to match. Try
* swapping out the next one in the list.
*/
list = origctx;
origctx = context;
Remove the atomic exchange macros
2018-11-19 03:21:58 -08:00
} while(!list->next.compare_exchange_strong(origctx, newhead));
Properly destroy contexts that are left on the device when it's closed
2011-09-10 07:35:48 -07:00
}
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
else
ret = !!newhead;
Make a couple functions inline
2018-01-12 02:37:48 -08:00
V0(device->Backend,unlock)();
Properly destroy contexts that are left on the device when it's closed
2011-09-10 07:35:48 -07:00
Add a comment about waiting to kill the event thread
2018-10-07 17:18:50 -07:00
/* Make sure the context is finished and no longer processing in the mixer
* before sending the message queue kill event. The backend's lock does
* this, although waiting for a non-odd mix count would work too.
*/
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
Properly destroy contexts that are left on the device when it's closed
2011-09-10 07:35:48 -07:00
ALCcontext_DecRef(context);
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);
Make a separate log level to trace reference counts, to avoid log spam for traces
2011-09-20 12:24:23 -07:00
TRACEREF("%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);
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
TRACEREF("%p decreasing refcount to %u\n", context, ref);
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(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};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *dev{DeviceList.load()};
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
while(dev)
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
ALCcontext *ctx = dev->ContextList.load(std::memory_order_acquire);
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
while(ctx)
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
if(ctx == context)
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
ALCcontext_IncRef(ctx);
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
return ContextRef{ctx};
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
ctx = ctx->next.load(std::memory_order_relaxed);
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
dev = dev->next.load(std::memory_order_relaxed);
Avoid holding the global list lock while calling some capture methods
2011-07-13 01:21:30 -07:00
}
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -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
}
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
void AllocateVoices(ALCcontext *context, ALsizei num_voices, ALsizei old_sends)
{
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
if(num_voices == context->MaxVoices && num_sends == old_sends)
return;
Make the voices' Send[] array dynamically sized The voices are still all allocated in one chunk to avoid memory fragmentation. But they're accessed as an array of pointers since the size isn't static.
2017-02-21 11:17:47 -08:00
/* Allocate the voice pointers, voices, and the voices' stored source
* property set (including the dynamically-sized Send[] array) in one
* chunk.
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
*/
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
const size_t sizeof_voice{RoundUp(FAM_SIZE(ALvoice, Send, num_sends), 16)};
const size_t size{sizeof(ALvoice*) + sizeof_voice};
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
auto voices = static_cast<ALvoice**>(al_calloc(16, RoundUp(size*num_voices, 16)));
auto voice = reinterpret_cast<ALvoice*>((char*)voices + RoundUp(num_voices*sizeof(ALvoice*), 16));
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
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
auto viter = 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)
{
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
const ALsizei v_count = mini(context->VoiceCount.load(std::memory_order_relaxed),
num_voices);
Allocate a new context's voices after updating the device params
2017-04-19 12:34:45 -07:00
const ALsizei s_count = mini(old_sends, num_sends);
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
/* Copy the old voice data to the new storage. */
auto copy_voice = [&voice,sizeof_voice,s_count](ALvoice *old_voice) -> ALvoice*
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
{
Improve construction and destruction of ALvoices
2018-11-30 19:04:38 -08:00
voice = new (voice) ALvoice{};
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
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
/* Make sure the old voice's Update (if any) is cleared so it
* doesn't get deleted on deinit.
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
*/
Improve construction and destruction of ALvoices
2018-11-30 19:04:38 -08:00
voice->Update.store(old_voice->Update.exchange(nullptr, std::memory_order_relaxed),
std::memory_order_relaxed);
voice->SourceID.store(old_voice->SourceID.load(std::memory_order_relaxed),
std::memory_order_relaxed);
voice->Playing.store(old_voice->Playing.load(std::memory_order_relaxed),
std::memory_order_relaxed);
voice->Props = old_voice->Props;
/* Clear extraneous property set sends. */
std::fill(std::begin(voice->Props.Send)+s_count, std::end(voice->Props.Send),
ALvoiceProps::SendData{});
voice->position.store(old_voice->position.load(std::memory_order_relaxed),
std::memory_order_relaxed);
voice->position_fraction.store(
old_voice->position_fraction.load(std::memory_order_relaxed),
std::memory_order_relaxed);
voice->current_buffer.store(old_voice->current_buffer.load(std::memory_order_relaxed),
std::memory_order_relaxed);
voice->loop_buffer.store(old_voice->loop_buffer.load(std::memory_order_relaxed),
std::memory_order_relaxed);
voice->NumChannels = old_voice->NumChannels;
voice->SampleSize = old_voice->SampleSize;
voice->Step = old_voice->Step;
voice->Resampler = old_voice->Resampler;
voice->Flags = old_voice->Flags;
voice->Offset = old_voice->Offset;
Use std::array for the voice's PrevSamples
2018-11-30 21:23:43 -08:00
std::copy(std::begin(old_voice->PrevSamples), std::end(old_voice->PrevSamples),
std::begin(voice->PrevSamples));
Improve construction and destruction of ALvoices
2018-11-30 19:04:38 -08:00
voice->ResampleState = old_voice->ResampleState;
voice->Direct = old_voice->Direct;
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
std::copy_n(old_voice->Send, s_count, voice->Send);
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
Don't bother making ALvoiceProps dynamically sized
2018-11-30 16:56:23 -08:00
/* Set this voice's reference. */
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
ALvoice *ret = voice;
Don't bother making ALvoiceProps dynamically sized
2018-11-30 16:56:23 -08:00
/* Increment pointer to the next storage space. */
voice = reinterpret_cast<ALvoice*>((char*)voice + sizeof_voice);
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
return ret;
};
viter = std::transform(context->Voices, context->Voices+v_count, viter, copy_voice);
Improve construction and destruction of ALvoices
2018-11-30 19:04:38 -08:00
/* Deinit old voices. */
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
auto voices_end = context->Voices + context->MaxVoices;
Improve construction and destruction of ALvoices
2018-11-30 19:04:38 -08:00
std::for_each(context->Voices, voices_end, DeinitVoice);
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
}
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
/* Finish setting the voices and references. */
auto init_voice = [&voice,sizeof_voice]() -> ALvoice*
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
{
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
ALvoice *ret = new (voice) ALvoice{};
Don't bother making ALvoiceProps dynamically sized
2018-11-30 16:56:23 -08:00
voice = reinterpret_cast<ALvoice*>((char*)voice + sizeof_voice);
Avoid more explicit loops
2018-12-04 19:45:11 -08:00
return ret;
};
std::generate(viter, voices+num_voices, init_voice);
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
al_free(context->Voices);
context->Voices = voices;
context->MaxVoices = num_voices;
Make the context VoiceCount atomic
2018-11-23 16:16:31 -08:00
context->VoiceCount = mini(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
}
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)
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
}
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)
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
}
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)
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
}
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)
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;
Use RAII for device references
2018-11-23 17:54:12 -08:00
DeviceRef dev;
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:
Use RAII for device references
2018-11-23 17:54:12 -08:00
dev = VerifyDevice(Device);
if(dev)
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:
Use RAII for device references
2018-11-23 17:54:12 -08:00
dev = VerifyDevice(Device);
if(dev)
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:
Use RAII for device references
2018-11-23 17:54:12 -08:00
dev = VerifyDevice(Device);
if(dev) 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:
Use RAII for device references
2018-11-23 17:54:12 -08:00
dev = VerifyDevice(Device);
if(!dev)
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
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
else
{
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{dev->BackendLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
value = (dev->HrtfHandle ? 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
}
break;
Initial import
2007-11-13 18:02:18 -08:00
default:
Use RAII for device references
2018-11-23 17:54:12 -08:00
dev = VerifyDevice(Device);
alcSetError(dev.get(), ALC_INVALID_ENUM);
Initial import
2007-11-13 18:02:18 -08:00
break;
}
return 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
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
}
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, 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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(size <= 0 || values == nullptr)
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;
Add missing integer queries
2017-12-21 11:46:01 -08:00
if(size < NumAttrsForDevice(device))
alcSetError(device, ALC_INVALID_VALUE);
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
else
{
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{device->BackendLock};
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;
values[i++] = V0(device->Backend,availableSamples)();
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:
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
{ std::lock_guard<std::mutex> _{device->BackendLock};
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
values[0] = V0(device->Backend,availableSamples)();
}
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:
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
{ std::lock_guard<std::mutex> _{device->BackendLock};
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;
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(size < NumAttrsForDevice(device))
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
alcSetError(device, ALC_INVALID_VALUE);
else
{
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{device->BackendLock};
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;
values[i++] = (device->HrtfHandle ? 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;
}
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
{ std::lock_guard<std::mutex> _{device->BackendLock};
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:
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
{ std::lock_guard<std::mutex> _{device->BackendLock};
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:
Dynamically allocate the device's HRTF state
2017-03-10 10:47:43 -08:00
values[0] = (device->HrtfHandle ? 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:
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
{ std::lock_guard<std::mutex> _{device->BackendLock};
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
device->HrtfList.clear();
device->HrtfList = EnumerateHrtf(device->DeviceName.c_str());
values[0] = (ALCint)device->HrtfList.size();
}
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 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 RAII for device references
2018-11-23 17:54:12 -08:00
GetIntegerv(dev.get(), param, size, values);
Avoid duplicating code in alcGetIntegerv
2014-02-01 18:40:36 -08:00
}
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)
{
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
{
Replace remaining uses of std::vector with al::vector Which uses a custom allocator that uses our allocation functions.
2018-11-24 16:58:49 -08:00
al::vector<ALCint> ivals(size);
Use RAII for device references
2018-11-23 17:54:12 -08:00
size = GetIntegerv(dev.get(), pname, size, ivals.data());
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};
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{dev->BackendLock};
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;
Use RAII for device references
2018-11-23 17:54:12 -08:00
values[i++] = (dev->HrtfHandle ? 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:
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
{ std::lock_guard<std::mutex> _{dev->BackendLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
using std::chrono::seconds;
using std::chrono::nanoseconds;
using std::chrono::duration_cast;
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));
*values = (duration_cast<nanoseconds>(seconds{samplecount})/dev->Frequency +
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:
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
{ std::lock_guard<std::mutex> _{dev->BackendLock};
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
{
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{dev->BackendLock};
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:
Replace remaining uses of std::vector with al::vector Which uses a custom allocator that uses our allocation functions.
2018-11-24 16:58:49 -08:00
al::vector<ALCint> ivals(size);
Use RAII for device references
2018-11-23 17:54:12 -08:00
size = GetIntegerv(dev.get(), pname, size, ivals.data());
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
}
}
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)
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
}
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)
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
}
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
return nullptr;
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)
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
}
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
return 0;
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)
Initial import
2007-11-13 18:02:18 -08:00
{
Parse the attribute list and reset the device before creating the context
2009-09-24 11:31:01 -07:00
ALCcontext *ALContext;
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
ALfloat valf;
Return the error code from UpdateDeviceParams
2012-01-25 20:00:34 -08:00
ALCenum err;
Initial import
2007-11-13 18:02:18 -08:00
Make ReleaseContext return if any contexts still remain
2017-03-28 05:33:43 -07:00
/* Explicitly hold the list lock while taking the BackendLock in case the
* device is asynchronously destropyed, to ensure this new context is
* 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
}
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::unique_lock<std::mutex> backlock{dev->BackendLock};
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 RAII for device references
2018-11-23 17:54:12 -08:00
ALContext = new ALCcontext{dev.get()};
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_IncRef(ALContext->Device);
Allocate a new context's voices after updating the device params
2017-04-19 12:34:45 -07:00
Use RAII for device references
2018-11-23 17:54:12 -08:00
if((err=UpdateDeviceParams(dev.get(), attrList)) != 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
V0(dev->Backend,lock)();
aluHandleDisconnect(dev.get(), "Device update failure");
V0(dev->Backend,unlock)();
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
}
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
backlock.unlock();
delete ALContext;
ALContext = nullptr;
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 RAII for device references
2018-11-23 17:54:12 -08:00
AllocateVoices(ALContext, 256, dev->NumAuxSends);
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
{
Use a unique_ptr for the default effect slot
2018-11-20 05:01:08 -08:00
ALContext->DefaultSlot.reset(new ALeffectslot{});
if(InitEffectSlot(ALContext->DefaultSlot.get()) == AL_NO_ERROR)
aluInitEffectPanning(ALContext->DefaultSlot.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
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALContext->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
}
Avoid holding the list lock when not needed
2011-09-10 05:19:08 -07:00
InitContext(ALContext);
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
if(ConfigValueFloat(dev->DeviceName.c_str(), nullptr, "volume-adjust", &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
{
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
{
ALfloat db = clampf(valf, -24.0f, 24.0f);
if(db != valf)
WARN("volume-adjust clamped: %f, range: +/-%f\n", valf, 24.0f);
Use std::pow and std::log2
2018-11-14 17:01:19 -08:00
ALContext->GainBoost = std::pow(10.0f, db/20.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
TRACE("volume-adjust gain: %f\n", ALContext->GainBoost);
}
}
UpdateListenerProps(ALContext);
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Use RAII for device references
2018-11-23 17:54:12 -08:00
ALCcontext *head = dev->ContextList.load();
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
do {
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
ALContext->next.store(head, std::memory_order_relaxed);
Use RAII for device references
2018-11-23 17:54:12 -08:00
} while(!dev->ContextList.compare_exchange_weak(head, ALContext));
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
backlock.unlock();
Initial import
2007-11-13 18:02:18 -08:00
Fix default effect initialization
2017-07-19 18:26:46 -07:00
if(ALContext->DefaultSlot)
{
Use a unique_ptr for the default effect slot
2018-11-20 05:01:08 -08:00
if(InitializeEffect(ALContext, ALContext->DefaultSlot.get(), &DefaultEffect) == AL_NO_ERROR)
UpdateEffectSlotProps(ALContext->DefaultSlot.get(), ALContext);
Fix default effect initialization
2017-07-19 18:26:46 -07:00
else
ERR("Failed to initialize the default effect\n");
}
Trace created device and context pointers
2011-09-20 11:55:40 -07:00
TRACE("Created context %p\n", ALContext);
Initial import
2007-11-13 18:02:18 -08:00
return ALContext;
}
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)
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};
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ContextRef ctx{VerifyContext(context)};
if(!ctx)
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;
}
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
ALCdevice* Device{ctx->Device};
Condense some code
2011-09-10 19:19:32 -07:00
if(Device)
Initial import
2007-11-13 18:02:18 -08:00
{
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{Device->BackendLock};
Make VerifyContext return a context reference
2018-11-21 02:02:53 -08:00
if(!ReleaseContext(ctx.get(), Device))
Condense some code
2011-09-10 19:19:32 -07:00
{
Rename VCALL and VCALL0 to V and V0
2013-11-02 17:30:28 -07:00
V0(Device->Backend,stop)();
Condense some code
2011-09-10 19:19:32 -07:00
Device->Flags &= ~DEVICE_RUNNING;
}
Use a flag to specify when a device is running
2011-06-15 01:59:07 -07:00
}
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
listlock.unlock();
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 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
}
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)
Initial import
2007-11-13 18:02:18 -08:00
{
Avoid using C-style TLS
2018-11-16 21:55:11 -08:00
return LocalContext.get();
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)
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
}
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 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
}
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)
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
}
/* 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)
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();
Make sure there's a valid backend before trying to open a device
2011-08-19 02:55:36 -07:00
if(!PlaybackBackend.name)
{
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 a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
std::unique_ptr<ALCdevice> device{new ALCdevice{Playback}};
Dynamically allocate the channel delay buffers
2017-02-28 21:01:13 -08:00
Reduce some indentation
2010-03-19 20:49:23 -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;
Don't limit output for ALC_DONT_CARE_SOFT and float samples
2018-10-03 13:48:04 -07:00
device->LimiterState = ALC_TRUE;
Reduce the default period count to 3
2017-02-22 15:56:09 -08:00
device->NumUpdates = 3;
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 = 1024;
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
Cleanup some syntax in alc.cpp
2018-11-16 00:06:54 -08:00
const ALCchar *fmt{};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueStr(deviceName, nullptr, "channels", &fmt))
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];
enum 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 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;
Use iterators instead of indexed loops
2018-11-16 05:23:42 -08:00
device->Flags |= DEVICE_CHANNELS_REQUEST;
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
}
}
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueStr(deviceName, nullptr, "sample-type", &fmt))
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];
enum 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 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;
device->Flags |= DEVICE_SAMPLE_TYPE_REQUEST;
Separate the format config option into channels and sample-type
2012-02-15 15:22:44 -08:00
}
}
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueUInt(deviceName, nullptr, "frequency", &device->Frequency))
Define a minimum output sample rate and warn if the config option goes below it
2012-02-15 12:26:19 -08:00
{
Add a frequency-request device flag
2011-05-03 02:29:26 -07:00
device->Flags |= DEVICE_FREQUENCY_REQUEST;
Define a minimum output sample rate and warn if the config option goes below it
2012-02-15 12:26:19 -08:00
if(device->Frequency < MIN_OUTPUT_RATE)
ERR("%uhz request clamped to %uhz minimum\n", device->Frequency, MIN_OUTPUT_RATE);
device->Frequency = maxu(device->Frequency, MIN_OUTPUT_RATE);
}
Initial import
2007-11-13 18:02:18 -08:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueUInt(deviceName, nullptr, "periods", &device->NumUpdates);
Enforce range limits on periods and period_size.
2012-03-04 05:44:37 -08:00
device->NumUpdates = clampu(device->NumUpdates, 2, 16);
Store the number of periods in the device instead of the buffer size Also keep all the fields in sync
2009-09-16 22:58:54 -07:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueUInt(deviceName, nullptr, "period_size", &device->UpdateSize);
Enforce range limits on periods and period_size.
2012-03-04 05:44:37 -08:00
device->UpdateSize = clampu(device->UpdateSize, 64, 8192);
Align UpdateSize for Neon, too
2014-11-17 21:33:09 -08:00
if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
Help ensure the update size is a multiple of 4 with SSE
2012-09-20 14:54:28 -07:00
device->UpdateSize = (device->UpdateSize+3)&~3;
Initial import
2007-11-13 18:02:18 -08:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueUInt(deviceName, nullptr, "sources", &device->SourcesMax);
Rename MaxNoOfSources for consistency
2016-06-08 11:19:33 -07:00
if(device->SourcesMax == 0) device->SourcesMax = 256;
Remove duplication of setting the max source count
2008-01-19 19:28:34 -08:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueUInt(deviceName, nullptr, "slots", &device->AuxiliaryEffectSlotMax);
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
if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 64;
Properly limit the max number of effect slots to 2^31 - 1
2018-03-04 14:00:28 -08:00
else device->AuxiliaryEffectSlotMax = minu(device->AuxiliaryEffectSlotMax, INT_MAX);
Store the max number of auxiliary slots in the device
2009-06-07 14:53:22 -07:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueInt(deviceName, nullptr, "sends", &device->NumAuxSends))
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
device->NumAuxSends = clampi(
DEFAULT_SENDS, 0, clampi(device->NumAuxSends, 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 a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device->Backend = PlaybackBackend.getFactory().createBackend(
device.get(), ALCbackend_Playback);
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
if(!device->Backend)
{
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device = nullptr;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_OUT_OF_MEMORY);
return nullptr;
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
}
Reduce some indentation
2010-03-19 20:49:23 -07:00
// Find a playback device to open
Cleanup some syntax in alc.cpp
2018-11-16 00:06:54 -08:00
ALCenum err{V(device->Backend,open)(deviceName)};
if(err != ALC_NO_ERROR)
Reduce some indentation
2010-03-19 20:49:23 -07:00
{
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device = nullptr;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, err);
return nullptr;
Initial import
2007-11-13 18:02:18 -08:00
}
Use a std::string for the device name
2018-11-18 18:45:45 -08:00
if(ConfigValueStr(device->DeviceName.c_str(), nullptr, "ambi-format", &fmt))
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
{
Use an enum class for AmbiLayout/Norm settings
2018-11-20 22:47:24 -08:00
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
}
Add an option to specify the ambisonic output configuration
2016-07-31 07:46:38 -07:00
else if(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
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *head{DeviceList.load()};
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
do {
Use an enum class for AmbiLayout/Norm settings
2018-11-20 22:47:24 -08:00
device->next.store(head, std::memory_order_relaxed);
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
} while(!DeviceList.compare_exchange_weak(head, 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());
return device.release();
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)
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};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *iter{DeviceList.load()};
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
do {
Remove the non-atomic COMPARE_EXCHANGE macro
2016-11-22 03:00:16 -08:00
if(iter == device)
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
break;
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
iter = iter->next.load(std::memory_order_relaxed);
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
} while(iter != nullptr);
Remove the non-atomic COMPARE_EXCHANGE macro
2016-11-22 03:00:16 -08:00
if(!iter || iter->Type == Capture)
Initial import
2007-11-13 18:02:18 -08:00
{
Remove the non-atomic COMPARE_EXCHANGE macro
2016-11-22 03:00:16 -08:00
alcSetError(iter, ALC_INVALID_DEVICE);
Reduce some indentation
2010-03-19 20:49:23 -07:00
return ALC_FALSE;
}
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::unique_lock<std::mutex> backlock{device->BackendLock};
Keep track of open devices
2008-01-14 10:39:54 -08:00
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *origdev{device};
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
ALCdevice *nextdev{device->next.load(std::memory_order_relaxed)};
Use C++ a bit more with alc.cpp
2018-11-14 06:17:47 -08:00
if(!DeviceList.compare_exchange_strong(origdev, nextdev))
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Use atomic variables instead of volatile
2018-03-02 18:38:59 -08:00
ALCdevice *list;
do {
list = origdev;
origdev = device;
Remove the atomic exchange macros
2018-11-19 03:21:58 -08:00
} while(!list->next.compare_exchange_strong(origdev, nextdev));
Use atomics for the device and context list heads
2014-08-01 02:04:40 -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
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
ALCcontext *ctx{device->ContextList.load()};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
while(ctx != nullptr)
Reduce some indentation
2010-03-19 20:49:23 -07:00
{
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
ALCcontext *next = ctx->next.load(std::memory_order_relaxed);
Make sure the device gets stopped when closing even if there's no contexts
2012-03-02 00:10:24 -08:00
WARN("Releasing context %p\n", ctx);
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
ReleaseContext(ctx, device);
ctx = next;
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
if((device->Flags&DEVICE_RUNNING))
V0(device->Backend,stop)();
device->Flags &= ~DEVICE_RUNNING;
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
backlock.unlock();
Make sure the device gets stopped when closing even if there's no contexts
2012-03-02 00:10:24 -08:00
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
ALCdevice_DecRef(device);
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
}
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)
{
DO_INITCONFIG();
if(!CaptureBackend.name)
{
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 a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
std::unique_ptr<ALCdevice> device{new ALCdevice{Capture}};
Enumerate and list HRTFs per-device
2015-10-06 00:23:11 -07:00
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
device->Frequency = frequency;
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
device->Flags |= DEVICE_FREQUENCY_REQUEST;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
{
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device = nullptr;
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
}
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_SAMPLE_TYPE_REQUEST;
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
device->UpdateSize = samples;
device->NumUpdates = 1;
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device->Backend = CaptureBackend.getFactory().createBackend(device.get(), ALCbackend_Capture);
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
if(!device->Backend)
{
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device = nullptr;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_OUT_OF_MEMORY);
return nullptr;
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
}
Trace the capture device format
2017-04-10 09:28:25 -07:00
TRACE("Capture format: %s, %s, %uhz, %u update size x%d\n",
DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
device->Frequency, device->UpdateSize, device->NumUpdates
);
Cleanup some syntax in alc.cpp
2018-11-16 00:06:54 -08:00
ALCenum err{V(device->Backend,open)(deviceName)};
if(err != ALC_NO_ERROR)
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
device = nullptr;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, err);
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
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *head{DeviceList.load()};
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
do {
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
device->next.store(head, std::memory_order_relaxed);
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
} while(!DeviceList.compare_exchange_weak(head, 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());
return device.release();
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)
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};
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
ALCdevice *iter{DeviceList.load()};
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
do {
Remove the non-atomic COMPARE_EXCHANGE macro
2016-11-22 03:00:16 -08:00
if(iter == device)
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
break;
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
iter = iter->next.load(std::memory_order_relaxed);
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
} while(iter != nullptr);
Remove the non-atomic COMPARE_EXCHANGE macro
2016-11-22 03:00:16 -08:00
if(!iter || iter->Type != Capture)
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
{
Remove the non-atomic COMPARE_EXCHANGE macro
2016-11-22 03:00:16 -08:00
alcSetError(iter, ALC_INVALID_DEVICE);
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
return ALC_FALSE;
}
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *origdev{device};
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
ALCdevice *nextdev{device->next.load(std::memory_order_relaxed)};
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(!DeviceList.compare_exchange_strong(origdev, nextdev))
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Use atomic variables instead of volatile
2018-03-02 18:38:59 -08:00
ALCdevice *list;
do {
list = origdev;
origdev = device;
Remove the atomic exchange macros
2018-11-19 03:21:58 -08:00
} while(!list->next.compare_exchange_strong(origdev, nextdev));
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
}
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
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
{ std::lock_guard<std::mutex> _{device->BackendLock};
Use RAII locks with the BackendLock
2018-11-20 23:42:21 -08:00
if((device->Flags&DEVICE_RUNNING))
V0(device->Backend,stop)();
device->Flags &= ~DEVICE_RUNNING;
}
Stop capture devices while closing In 'alcCaptureCloseDevice', check if the capture device is running and stop it if necessary. This fixes the case where the device data is deallocated while a background thread is still running (Issue #199)
2018-06-08 01:42:13 +00:00
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
ALCdevice_DecRef(device);
Reorganize ALC functions and fixup some comments
2012-04-20 01:18:38 -07:00
return ALC_TRUE;
}
ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
{
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;
}
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{dev->BackendLock};
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);
else if(!(dev->Flags&DEVICE_RUNNING))
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
if(V0(dev->Backend,start)())
dev->Flags |= DEVICE_RUNNING;
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
}
}
ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
{
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
{
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{dev->BackendLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
if((dev->Flags&DEVICE_RUNNING))
V0(dev->Backend,stop)();
dev->Flags &= ~DEVICE_RUNNING;
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)
{
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};
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
{ std::lock_guard<std::mutex> _{dev->BackendLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(samples >= 0 && V0(dev->Backend,availableSamples)() >= (ALCuint)samples)
err = V(dev->Backend,captureSamples)(buffer, samples);
}
if(err != ALC_NO_ERROR)
alcSetError(dev.get(), err);
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)
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 a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
std::unique_ptr<ALCdevice> 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
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->NumUpdates = 0;
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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueUInt(nullptr, nullptr, "sources", &device->SourcesMax);
Rename MaxNoOfSources for consistency
2016-06-08 11:19:33 -07:00
if(device->SourcesMax == 0) device->SourcesMax = 256;
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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ConfigValueUInt(nullptr, nullptr, "slots", &device->AuxiliaryEffectSlotMax);
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
if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 64;
Properly limit the max number of effect slots to 2^31 - 1
2018-03-04 14:00:28 -08:00
else device->AuxiliaryEffectSlotMax = minu(device->AuxiliaryEffectSlotMax, 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
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
if(ConfigValueInt(nullptr, nullptr, "sends", &device->NumAuxSends))
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
device->NumAuxSends = clampi(
DEFAULT_SENDS, 0, clampi(device->NumAuxSends, 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
Update the loopback backend
2018-11-15 19:42:13 -08:00
device->Backend = LoopbackBackendFactory::getFactory().createBackend(
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device.get(), ALCbackend_Loopback);
Combine common initialization code into a function
2018-01-28 18:03:54 -08:00
if(!device->Backend)
{
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
device = nullptr;
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
alcSetError(nullptr, ALC_OUT_OF_MEMORY);
return nullptr;
Combine common initialization code into a function
2018-01-28 18:03:54 -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
// Open the "backend"
Rename VCALL and VCALL0 to V and V0
2013-11-02 17:30:28 -07:00
V(device->Backend,open)("Loopback");
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
{
Convert ALc.c to C++
2018-11-14 04:15:44 -08:00
ALCdevice *head{DeviceList.load()};
Use atomics for the device and context list heads
2014-08-01 02:04:40 -07:00
do {
Avoid using ATOMIC macros
2018-11-21 07:52:17 -08:00
device->next.store(head, std::memory_order_relaxed);
Use a unique_ptr while opening a device
2018-11-23 20:16:34 -08:00
} while(!DeviceList.compare_exchange_weak(head, 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());
return device.release();
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)
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
}
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)
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 RAII for device references
2018-11-23 17:54:12 -08:00
V0(dev->Backend,lock)();
aluMixData(dev.get(), buffer, samples);
V0(dev->Backend,unlock)();
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 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)
{
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
{
Use a standard mutex for the backend lock
2018-11-26 21:29:11 -08:00
std::lock_guard<std::mutex> _{dev->BackendLock};
Use RAII for device references
2018-11-23 17:54:12 -08:00
if((dev->Flags&DEVICE_RUNNING))
V0(dev->Backend,stop)();
dev->Flags &= ~DEVICE_RUNNING;
dev->Flags |= DEVICE_PAUSED;
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)
{
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;
}
std::lock_guard<std::mutex> _{dev->BackendLock};
if(!(dev->Flags&DEVICE_PAUSED))
return;
dev->Flags &= ~DEVICE_PAUSED;
if(dev->ContextList.load() == nullptr)
return;
if(V0(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
V0(dev->Backend,lock)();
aluHandleDisconnect(dev.get(), "Device start failure");
V0(dev->Backend,unlock)();
alcSetError(dev.get(), ALC_INVALID_DEVICE);
return;
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
dev->Flags |= DEVICE_RUNNING;
Add an extension to pause audio processing
2014-01-15 16:27:17 -08:00
}
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 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:
Use RAII for device references
2018-11-23 17:54:12 -08:00
if(index >= 0 && (size_t)index < dev->HrtfList.size())
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
}
/* alcResetDeviceSOFT
*
* Resets the given device output, using the specified attribute list.
*/
ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs)
{
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;
}
Reduce some indentation
2018-11-28 11:55:43 -08:00
std::lock_guard<std::mutex> _{dev->BackendLock};
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.
*/
if((dev->Flags&DEVICE_RUNNING))
V0(dev->Backend,stop)();
dev->Flags &= ~DEVICE_RUNNING;
device->Connected.store(AL_TRUE);
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)
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
{
Reduce some indentation
2018-11-28 11:55:43 -08:00
V0(dev->Backend,lock)();
aluHandleDisconnect(dev.get(), "Device start failure");
V0(dev->Backend,unlock)();
Add methods to enumerate and query device HRTFs Currently just returns a dummy entry.
2015-10-02 23:54:30 -07:00
}
Reduce some indentation
2018-11-28 11:55:43 -08:00
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
}
Reference in New Issue Copy Permalink