/Telegram/_openal_patch/Alc/ALc.c
C | 3771 lines | 3003 code | 525 blank | 243 comment | 514 complexity | cf4dede07cefe854417a5ff6574ec021 MD5 | raw file
Possible License(s): GPL-3.0
- /**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
- #include "config.h"
- #include <math.h>
- #include <stdlib.h>
- #include <stdio.h>
- #include <memory.h>
- #include <ctype.h>
- #include <signal.h>
- #include "alMain.h"
- #include "alSource.h"
- #include "alListener.h"
- #include "alThunk.h"
- #include "alSource.h"
- #include "alBuffer.h"
- #include "alAuxEffectSlot.h"
- #include "alError.h"
- #include "alMidi.h"
- #include "bs2b.h"
- #include "alu.h"
- #include "compat.h"
- #include "threads.h"
- #include "alstring.h"
- #include "backends/base.h"
- #include "midi/base.h"
- /************************************************
- * Backends
- ************************************************/
- struct BackendInfo {
- const char *name;
- ALCbackendFactory* (*getFactory)(void);
- ALCboolean (*Init)(BackendFuncs*);
- void (*Deinit)(void);
- void (*Probe)(enum DevProbe);
- BackendFuncs Funcs;
- };
- #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
- static struct BackendInfo BackendList[] = {
- #ifdef HAVE_PULSEAUDIO
- { "pulse", ALCpulseBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
- #endif
- #ifdef HAVE_ALSA
- { "alsa", ALCalsaBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
- #endif
- #ifdef HAVE_COREAUDIO
- { "core", NULL, alc_ca_init, alc_ca_deinit, alc_ca_probe, EmptyFuncs },
- #endif
- #ifdef HAVE_OSS
- { "oss", ALCossBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
- #endif
- #ifdef HAVE_SOLARIS
- { "solaris", NULL, alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },
- #endif
- #ifdef HAVE_SNDIO
- { "sndio", NULL, alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },
- #endif
- #ifdef HAVE_QSA
- { "qsa", NULL, alc_qsa_init, alc_qsa_deinit, alc_qsa_probe, EmptyFuncs },
- #endif
- #ifdef HAVE_MMDEVAPI
- { "mmdevapi", ALCmmdevBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
- #endif
- #ifdef HAVE_DSOUND
- { "dsound", ALCdsoundBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
- #endif
- #ifdef HAVE_WINMM
- { "winmm", NULL, alcWinMMInit, alcWinMMDeinit, alcWinMMProbe, EmptyFuncs },
- #endif
- #ifdef HAVE_PORTAUDIO
- { "port", NULL, alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
- #endif
- #ifdef HAVE_OPENSL
- { "opensl", NULL, alc_opensl_init, alc_opensl_deinit, alc_opensl_probe, EmptyFuncs },
- #endif
- { "null", ALCnullBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
- #ifdef HAVE_WAVE
- { "wave", ALCwaveBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
- #endif
- { NULL, NULL, NULL, NULL, NULL, EmptyFuncs }
- };
- #undef EmptyFuncs
- static struct BackendInfo PlaybackBackend;
- static struct BackendInfo CaptureBackend;
- static bool SuspendAndProcessSupported = false;
- /************************************************
- * Functions, enums, and errors
- ************************************************/
- typedef struct ALCfunction {
- const ALCchar *funcName;
- ALCvoid *address;
- } ALCfunction;
- typedef struct ALCenums {
- const ALCchar *enumName;
- ALCenum value;
- } ALCenums;
- #define DECL(x) { #x, (ALCvoid*)(x) }
- static const ALCfunction alcFunctions[] = {
- 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),
- DECL(alcDevicePauseSOFT),
- DECL(alcDeviceResumeSOFT),
- DECL(alcGetInteger64vSOFT),
- 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(alBufferSubDataSOFT),
- DECL(alBufferSamplesSOFT),
- DECL(alBufferSubSamplesSOFT),
- DECL(alGetBufferSamplesSOFT),
- DECL(alIsBufferFormatSupportedSOFT),
- DECL(alDeferUpdatesSOFT),
- DECL(alProcessUpdatesSOFT),
- DECL(alSourcedSOFT),
- DECL(alSource3dSOFT),
- DECL(alSourcedvSOFT),
- DECL(alGetSourcedSOFT),
- DECL(alGetSource3dSOFT),
- DECL(alGetSourcedvSOFT),
- DECL(alSourcei64SOFT),
- DECL(alSource3i64SOFT),
- DECL(alSourcei64vSOFT),
- DECL(alGetSourcei64SOFT),
- DECL(alGetSource3i64SOFT),
- DECL(alGetSourcei64vSOFT),
- DECL(alGenSoundfontsSOFT),
- DECL(alDeleteSoundfontsSOFT),
- DECL(alIsSoundfontSOFT),
- DECL(alGetSoundfontivSOFT),
- DECL(alSoundfontPresetsSOFT),
- DECL(alGenPresetsSOFT),
- DECL(alDeletePresetsSOFT),
- DECL(alIsPresetSOFT),
- DECL(alPresetiSOFT),
- DECL(alPresetivSOFT),
- DECL(alGetPresetivSOFT),
- DECL(alPresetFontsoundsSOFT),
- DECL(alGenFontsoundsSOFT),
- DECL(alDeleteFontsoundsSOFT),
- DECL(alIsFontsoundSOFT),
- DECL(alFontsoundiSOFT),
- DECL(alFontsound2iSOFT),
- DECL(alFontsoundivSOFT),
- DECL(alGetFontsoundivSOFT),
- DECL(alFontsoundModulatoriSOFT),
- DECL(alGetFontsoundModulatorivSOFT),
- DECL(alMidiSoundfontSOFT),
- DECL(alMidiSoundfontvSOFT),
- DECL(alMidiEventSOFT),
- DECL(alMidiSysExSOFT),
- DECL(alMidiPlaySOFT),
- DECL(alMidiPauseSOFT),
- DECL(alMidiStopSOFT),
- DECL(alMidiResetSOFT),
- DECL(alMidiGainSOFT),
- DECL(alGetInteger64SOFT),
- DECL(alGetInteger64vSOFT),
- DECL(alLoadSoundfontSOFT),
- { NULL, NULL }
- };
- #undef DECL
- #define DECL(x) { #x, (x) }
- static const ALCenums enumeration[] = {
- 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),
- 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),
- 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_SAMPLE_RW_OFFSETS_SOFT),
- DECL(AL_BYTE_OFFSET),
- DECL(AL_BYTE_RW_OFFSETS_SOFT),
- DECL(AL_SOURCE_TYPE),
- DECL(AL_STATIC),
- DECL(AL_STREAMING),
- DECL(AL_UNDETERMINED),
- DECL(AL_METERS_PER_UNIT),
- 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),
- DECL(AL_FORMAT_MONO_MSADPCM_SOFT),
- DECL(AL_FORMAT_STEREO_MSADPCM_SOFT),
- 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),
- DECL(AL_MONO8_SOFT),
- DECL(AL_MONO16_SOFT),
- DECL(AL_MONO32F_SOFT),
- DECL(AL_STEREO8_SOFT),
- DECL(AL_STEREO16_SOFT),
- DECL(AL_STEREO32F_SOFT),
- DECL(AL_QUAD8_SOFT),
- DECL(AL_QUAD16_SOFT),
- DECL(AL_QUAD32F_SOFT),
- DECL(AL_REAR8_SOFT),
- DECL(AL_REAR16_SOFT),
- DECL(AL_REAR32F_SOFT),
- DECL(AL_5POINT1_8_SOFT),
- DECL(AL_5POINT1_16_SOFT),
- DECL(AL_5POINT1_32F_SOFT),
- DECL(AL_6POINT1_8_SOFT),
- DECL(AL_6POINT1_16_SOFT),
- DECL(AL_6POINT1_32F_SOFT),
- DECL(AL_7POINT1_8_SOFT),
- DECL(AL_7POINT1_16_SOFT),
- DECL(AL_7POINT1_32F_SOFT),
- DECL(AL_MONO_SOFT),
- DECL(AL_STEREO_SOFT),
- DECL(AL_QUAD_SOFT),
- DECL(AL_REAR_SOFT),
- DECL(AL_5POINT1_SOFT),
- DECL(AL_6POINT1_SOFT),
- DECL(AL_7POINT1_SOFT),
- DECL(AL_BYTE_SOFT),
- DECL(AL_UNSIGNED_BYTE_SOFT),
- DECL(AL_SHORT_SOFT),
- DECL(AL_UNSIGNED_SHORT_SOFT),
- DECL(AL_INT_SOFT),
- DECL(AL_UNSIGNED_INT_SOFT),
- DECL(AL_FLOAT_SOFT),
- DECL(AL_DOUBLE_SOFT),
- DECL(AL_BYTE3_SOFT),
- DECL(AL_UNSIGNED_BYTE3_SOFT),
- DECL(AL_FREQUENCY),
- DECL(AL_BITS),
- DECL(AL_CHANNELS),
- DECL(AL_SIZE),
- DECL(AL_INTERNAL_FORMAT_SOFT),
- DECL(AL_BYTE_LENGTH_SOFT),
- DECL(AL_SAMPLE_LENGTH_SOFT),
- DECL(AL_SEC_LENGTH_SOFT),
- DECL(AL_UNPACK_BLOCK_ALIGNMENT_SOFT),
- DECL(AL_PACK_BLOCK_ALIGNMENT_SOFT),
- 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),
- 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),
- DECL(AL_LOWPASS_GAIN),
- DECL(AL_LOWPASS_GAINHF),
- DECL(AL_HIGHPASS_GAIN),
- DECL(AL_HIGHPASS_GAINLF),
- DECL(AL_BANDPASS_GAIN),
- DECL(AL_BANDPASS_GAINHF),
- DECL(AL_BANDPASS_GAINLF),
- 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),
- #if 0
- DECL(AL_EFFECT_FREQUENCY_SHIFTER),
- DECL(AL_EFFECT_VOCAL_MORPHER),
- DECL(AL_EFFECT_PITCH_SHIFTER),
- #endif
- DECL(AL_EFFECT_RING_MODULATOR),
- #if 0
- DECL(AL_EFFECT_AUTOWAH),
- #endif
- DECL(AL_EFFECT_COMPRESSOR),
- DECL(AL_EFFECT_EQUALIZER),
- DECL(AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT),
- DECL(AL_EFFECT_DEDICATED_DIALOGUE),
- 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),
- DECL(AL_CHORUS_WAVEFORM),
- DECL(AL_CHORUS_PHASE),
- DECL(AL_CHORUS_RATE),
- DECL(AL_CHORUS_DEPTH),
- DECL(AL_CHORUS_FEEDBACK),
- DECL(AL_CHORUS_DELAY),
- 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),
- DECL(AL_FLANGER_WAVEFORM),
- DECL(AL_FLANGER_PHASE),
- DECL(AL_FLANGER_RATE),
- DECL(AL_FLANGER_DEPTH),
- DECL(AL_FLANGER_FEEDBACK),
- DECL(AL_FLANGER_DELAY),
- DECL(AL_RING_MODULATOR_FREQUENCY),
- DECL(AL_RING_MODULATOR_HIGHPASS_CUTOFF),
- DECL(AL_RING_MODULATOR_WAVEFORM),
- #if 0
- DECL(AL_AUTOWAH_ATTACK_TIME),
- DECL(AL_AUTOWAH_PEAK_GAIN),
- DECL(AL_AUTOWAH_RELEASE_TIME),
- DECL(AL_AUTOWAH_RESONANCE),
- #endif
- DECL(AL_COMPRESSOR_ONOFF),
- 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),
- DECL(AL_DEDICATED_GAIN),
- { NULL, (ALCenum)0 }
- };
- #undef DECL
- static const ALCchar alcNoError[] = "No Error";
- static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
- static const ALCchar alcErrInvalidContext[] = "Invalid Context";
- static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
- static const ALCchar alcErrInvalidValue[] = "Invalid Value";
- static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
- /************************************************
- * Global variables
- ************************************************/
- /* Enumerated device names */
- static const ALCchar alcDefaultName[] = "OpenAL Soft\0";
- static al_string alcAllDevicesList;
- static al_string alcCaptureDeviceList;
- /* Default is always the first in the list */
- static ALCchar *alcDefaultAllDevicesSpecifier;
- static ALCchar *alcCaptureDefaultDeviceSpecifier;
- /* Default context extensions */
- static const ALchar alExtList[] =
- "AL_EXT_ALAW 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_MCFORMATS AL_EXT_OFFSET AL_EXT_source_distance_model "
- "AL_LOKI_quadriphonic AL_SOFT_block_alignment AL_SOFT_buffer_samples "
- "AL_SOFT_buffer_sub_data AL_SOFT_deferred_updates AL_SOFT_direct_channels "
- "AL_SOFT_loop_points AL_SOFT_MSADPCM AL_SOFT_source_latency "
- "AL_SOFT_source_length";
- static ATOMIC(ALCenum) LastNullDeviceError = ATOMIC_INIT_STATIC(ALC_NO_ERROR);
- /* Thread-local current context */
- static altss_t LocalContext;
- /* Process-wide current context */
- static ATOMIC(ALCcontext*) GlobalContext = ATOMIC_INIT_STATIC(NULL);
- /* Mixing thread piority level */
- ALint RTPrioLevel;
- FILE *LogFile;
- #ifdef _DEBUG
- enum LogLevel LogLevel = LogWarning;
- #else
- enum LogLevel LogLevel = LogError;
- #endif
- /* Flag to trap ALC device errors */
- static ALCboolean TrapALCError = ALC_FALSE;
- /* One-time configuration init control */
- static alonce_flag alc_config_once = AL_ONCE_FLAG_INIT;
- /* Default effect that applies to sources that don't have an effect on send 0 */
- static ALeffect DefaultEffect;
- /************************************************
- * ALC information
- ************************************************/
- static const ALCchar alcNoDeviceExtList[] =
- "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
- "ALC_EXT_thread_local_context ALC_SOFT_loopback";
- static const ALCchar alcExtensionList[] =
- "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
- "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
- "ALC_EXT_thread_local_context ALC_SOFTX_device_clock ALC_SOFTX_HRTF "
- "ALC_SOFT_loopback ALC_SOFTX_midi_interface ALC_SOFT_pause_device";
- static const ALCint alcMajorVersion = 1;
- static const ALCint alcMinorVersion = 1;
- static const ALCint alcEFXMajorVersion = 1;
- static const ALCint alcEFXMinorVersion = 0;
- /************************************************
- * Device lists
- ************************************************/
- static ATOMIC(ALCdevice*) DeviceList = ATOMIC_INIT_STATIC(NULL);
- static almtx_t ListLock;
- static inline void LockLists(void)
- {
- int lockret = almtx_lock(&ListLock);
- assert(lockret == althrd_success);
- }
- static inline void UnlockLists(void)
- {
- int unlockret = almtx_unlock(&ListLock);
- assert(unlockret == althrd_success);
- }
- /************************************************
- * Library initialization
- ************************************************/
- #if defined(_WIN32)
- static void alc_init(void);
- static void alc_deinit(void);
- static void alc_deinit_safe(void);
- #ifndef AL_LIBTYPE_STATIC
- BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD reason, LPVOID lpReserved)
- {
- switch(reason)
- {
- case DLL_PROCESS_ATTACH:
- /* Pin the DLL so we won't get unloaded until the process terminates */
- GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
- (WCHAR*)hModule, &hModule);
- alc_init();
- break;
- case DLL_THREAD_DETACH:
- break;
- case DLL_PROCESS_DETACH:
- if(!lpReserved)
- alc_deinit();
- else
- alc_deinit_safe();
- break;
- }
- return TRUE;
- }
- #elif defined(_MSC_VER)
- #pragma section(".CRT$XCU",read)
- static void alc_constructor(void);
- static void alc_destructor(void);
- __declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;
- static void alc_constructor(void)
- {
- atexit(alc_destructor);
- alc_init();
- }
- static void alc_destructor(void)
- {
- alc_deinit();
- }
- #elif defined(HAVE_GCC_DESTRUCTOR)
- static void alc_init(void) __attribute__((constructor));
- static void alc_deinit(void) __attribute__((destructor));
- #else
- #error "No static initialization available on this platform!"
- #endif
- #elif defined(HAVE_GCC_DESTRUCTOR)
- static void alc_init(void) __attribute__((constructor));
- static void alc_deinit(void) __attribute__((destructor));
- #else
- #error "No global initialization available on this platform!"
- #endif
- static void ReleaseThreadCtx(void *ptr);
- static void alc_init(void)
- {
- const char *str;
- int ret;
- LogFile = stderr;
- AL_STRING_INIT(alcAllDevicesList);
- AL_STRING_INIT(alcCaptureDeviceList);
- str = getenv("__ALSOFT_HALF_ANGLE_CONES");
- if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
- ConeScale *= 0.5f;
- str = getenv("__ALSOFT_REVERSE_Z");
- if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
- ZScale *= -1.0f;
- ret = altss_create(&LocalContext, ReleaseThreadCtx);
- assert(ret == althrd_success);
- ret = almtx_init(&ListLock, almtx_recursive);
- assert(ret == althrd_success);
- ThunkInit();
- }
- static void alc_initconfig(void)
- {
- const char *devs, *str;
- ALuint capfilter;
- float valf;
- int i, n;
- str = getenv("ALSOFT_LOGLEVEL");
- if(str)
- {
- long lvl = strtol(str, NULL, 0);
- if(lvl >= NoLog && lvl <= LogRef)
- LogLevel = lvl;
- }
- str = getenv("ALSOFT_LOGFILE");
- if(str && str[0])
- {
- FILE *logfile = al_fopen(str, "wt");
- if(logfile) LogFile = logfile;
- else ERR("Failed to open log file '%s'\n", str);
- }
- {
- char buf[1024] = "";
- int len = snprintf(buf, sizeof(buf), "%s", BackendList[0].name);
- for(i = 1;BackendList[i].name;i++)
- len += snprintf(buf+len, sizeof(buf)-len, ", %s", BackendList[i].name);
- TRACE("Supported backends: %s\n", buf);
- }
- ReadALConfig();
- capfilter = 0;
- #if defined(HAVE_SSE4_1)
- capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE4_1;
- #elif defined(HAVE_SSE2)
- capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2;
- #elif defined(HAVE_SSE)
- capfilter |= CPU_CAP_SSE;
- #endif
- #ifdef HAVE_NEON
- capfilter |= CPU_CAP_NEON;
- #endif
- if(ConfigValueStr(NULL, "disable-cpu-exts", &str))
- {
- if(strcasecmp(str, "all") == 0)
- capfilter = 0;
- else
- {
- size_t len;
- const char *next = str;
- do {
- str = next;
- while(isspace(str[0]))
- str++;
- next = strchr(str, ',');
- if(!str[0] || str[0] == ',')
- continue;
- len = (next ? ((size_t)(next-str)) : strlen(str));
- while(len > 0 && isspace(str[len-1]))
- len--;
- if(len == 3 && strncasecmp(str, "sse", len) == 0)
- capfilter &= ~CPU_CAP_SSE;
- else if(len == 4 && strncasecmp(str, "sse2", len) == 0)
- capfilter &= ~CPU_CAP_SSE2;
- else if(len == 6 && strncasecmp(str, "sse4.1", len) == 0)
- capfilter &= ~CPU_CAP_SSE4_1;
- else if(len == 4 && strncasecmp(str, "neon", len) == 0)
- capfilter &= ~CPU_CAP_NEON;
- else
- WARN("Invalid CPU extension \"%s\"\n", str);
- } while(next++);
- }
- }
- FillCPUCaps(capfilter);
- #ifdef _WIN32
- RTPrioLevel = 1;
- #else
- RTPrioLevel = 0;
- #endif
- ConfigValueInt(NULL, "rt-prio", &RTPrioLevel);
- if(ConfigValueStr(NULL, "resampler", &str))
- {
- if(strcasecmp(str, "point") == 0 || strcasecmp(str, "none") == 0)
- DefaultResampler = PointResampler;
- else if(strcasecmp(str, "linear") == 0)
- DefaultResampler = LinearResampler;
- else if(strcasecmp(str, "cubic") == 0)
- DefaultResampler = CubicResampler;
- else
- {
- char *end;
- n = strtol(str, &end, 0);
- if(*end == '\0' && (n == PointResampler || n == LinearResampler || n == CubicResampler))
- DefaultResampler = n;
- else
- WARN("Invalid resampler: %s\n", str);
- }
- }
- str = getenv("ALSOFT_TRAP_ERROR");
- if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
- {
- TrapALError = AL_TRUE;
- TrapALCError = AL_TRUE;
- }
- else
- {
- str = getenv("ALSOFT_TRAP_AL_ERROR");
- if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
- TrapALError = AL_TRUE;
- TrapALError = GetConfigValueBool(NULL, "trap-al-error", TrapALError);
- str = getenv("ALSOFT_TRAP_ALC_ERROR");
- if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
- TrapALCError = ALC_TRUE;
- TrapALCError = GetConfigValueBool(NULL, "trap-alc-error", TrapALCError);
- }
- if(ConfigValueFloat("reverb", "boost", &valf))
- ReverbBoost *= powf(10.0f, valf / 20.0f);
- EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);
- if(((devs=getenv("ALSOFT_DRIVERS")) && devs[0]) ||
- ConfigValueStr(NULL, "drivers", &devs))
- {
- int n;
- size_t len;
- const char *next = devs;
- int endlist, delitem;
- i = 0;
- do {
- devs = next;
- while(isspace(devs[0]))
- devs++;
- next = strchr(devs, ',');
- delitem = (devs[0] == '-');
- if(devs[0] == '-') devs++;
- if(!devs[0] || devs[0] == ',')
- {
- endlist = 0;
- continue;
- }
- endlist = 1;
- len = (next ? ((size_t)(next-devs)) : strlen(devs));
- while(len > 0 && isspace(devs[len-1]))
- len--;
- for(n = i;BackendList[n].name;n++)
- {
- if(len == strlen(BackendList[n].name) &&
- strncmp(BackendList[n].name, devs, len) == 0)
- {
- if(delitem)
- {
- do {
- BackendList[n] = BackendList[n+1];
- ++n;
- } while(BackendList[n].name);
- }
- else
- {
- struct BackendInfo Bkp = BackendList[n];
- while(n > i)
- {
- BackendList[n] = BackendList[n-1];
- --n;
- }
- BackendList[n] = Bkp;
- i++;
- }
- break;
- }
- }
- } while(next++);
- if(endlist)
- {
- BackendList[i].name = NULL;
- BackendList[i].getFactory = NULL;
- BackendList[i].Init = NULL;
- BackendList[i].Deinit = NULL;
- BackendList[i].Probe = NULL;
- }
- }
- for(i = 0;(BackendList[i].Init || BackendList[i].getFactory) && (!PlaybackBackend.name || !CaptureBackend.name);i++)
- {
- if(BackendList[i].getFactory)
- {
- ALCbackendFactory *factory = BackendList[i].getFactory();
- if(!V0(factory,init)())
- {
- WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
- continue;
- }
- TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
- if(!PlaybackBackend.name && V(factory,querySupport)(ALCbackend_Playback))
- {
- PlaybackBackend = BackendList[i];
- TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
- }
- if(!CaptureBackend.name && V(factory,querySupport)(ALCbackend_Capture))
- {
- CaptureBackend = BackendList[i];
- TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
- }
- continue;
- }
- if(!BackendList[i].Init(&BackendList[i].Funcs))
- {
- WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
- continue;
- }
- TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
- if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
- {
- PlaybackBackend = BackendList[i];
- TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
- }
- if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
- {
- CaptureBackend = BackendList[i];
- TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
- }
- }
- {
- ALCbackendFactory *factory = ALCloopbackFactory_getFactory();
- V0(factory,init)();
- }
- if(ConfigValueStr(NULL, "excludefx", &str))
- {
- size_t len;
- const char *next = str;
- do {
- str = next;
- next = strchr(str, ',');
- if(!str[0] || next == str)
- continue;
- len = (next ? ((size_t)(next-str)) : strlen(str));
- for(n = 0;EffectList[n].name;n++)
- {
- if(len == strlen(EffectList[n].name) &&
- strncmp(EffectList[n].name, str, len) == 0)
- DisabledEffects[EffectList[n].type] = AL_TRUE;
- }
- } while(next++);
- }
- InitEffectFactoryMap();
- InitEffect(&DefaultEffect);
- str = getenv("ALSOFT_DEFAULT_REVERB");
- if((str && str[0]) || ConfigValueStr(NULL, "default-reverb", &str))
- LoadReverbPreset(str, &DefaultEffect);
- }
- #define DO_INITCONFIG() alcall_once(&alc_config_once, alc_initconfig)
- /************************************************
- * Library deinitialization
- ************************************************/
- static void alc_cleanup(void)
- {
- ALCdevice *dev;
- AL_STRING_DEINIT(alcAllDevicesList);
- AL_STRING_DEINIT(alcCaptureDeviceList);
- free(alcDefaultAllDevicesSpecifier);
- alcDefaultAllDevicesSpecifier = NULL;
- free(alcCaptureDefaultDeviceSpecifier);
- alcCaptureDefaultDeviceSpecifier = NULL;
- if((dev=ATOMIC_EXCHANGE(ALCdevice*, &DeviceList, NULL)) != NULL)
- {
- ALCuint num = 0;
- do {
- num++;
- } while((dev=dev->next) != NULL);
- ERR("%u device%s not closed\n", num, (num>1)?"s":"");
- }
- DeinitEffectFactoryMap();
- }
- static void alc_deinit_safe(void)
- {
- alc_cleanup();
- FreeHrtfs();
- FreeALConfig();
- ThunkExit();
- almtx_destroy(&ListLock);
- altss_delete(LocalContext);
- if(LogFile != stderr)
- fclose(LogFile);
- LogFile = NULL;
- }
- static void alc_deinit(void)
- {
- int i;
- alc_cleanup();
- memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
- memset(&CaptureBackend, 0, sizeof(CaptureBackend));
- for(i = 0;BackendList[i].Deinit || BackendList[i].getFactory;i++)
- {
- if(!BackendList[i].getFactory)
- BackendList[i].Deinit();
- else
- {
- ALCbackendFactory *factory = BackendList[i].getFactory();
- V0(factory,deinit)();
- }
- }
- {
- ALCbackendFactory *factory = ALCloopbackFactory_getFactory();
- V0(factory,deinit)();
- }
- alc_deinit_safe();
- }
- /************************************************
- * Device enumeration
- ************************************************/
- static void ProbeDevices(al_string *list, enum DevProbe type)
- {
- DO_INITCONFIG();
- LockLists();
- al_string_clear(list);
- if(type == ALL_DEVICE_PROBE && (PlaybackBackend.Probe || PlaybackBackend.getFactory))
- {
- if(!PlaybackBackend.getFactory)
- PlaybackBackend.Probe(type);
- else
- {
- ALCbackendFactory *factory = PlaybackBackend.getFactory();
- V(factory,probe)(type);
- }
- }
- else if(type == CAPTURE_DEVICE_PROBE && (CaptureBackend.Probe || CaptureBackend.getFactory))
- {
- if(!CaptureBackend.getFactory)
- CaptureBackend.Probe(type);
- else
- {
- ALCbackendFactory *factory = CaptureBackend.getFactory();
- V(factory,probe)(type);
- }
- }
- UnlockLists();
- }
- static void ProbeAllDevicesList(void)
- { ProbeDevices(&alcAllDevicesList, ALL_DEVICE_PROBE); }
- static void ProbeCaptureDeviceList(void)
- { ProbeDevices(&alcCaptureDeviceList, CAPTURE_DEVICE_PROBE); }
- static void AppendDevice(const ALCchar *name, al_string *devnames)
- {
- size_t len = strlen(name);
- if(len > 0)
- {
- al_string_append_range(devnames, name, name+len);
- al_string_append_char(devnames, '\0');
- }
- }
- void AppendAllDevicesList(const ALCchar *name)
- { AppendDevice(name, &alcAllDevicesList); }
- void AppendCaptureDeviceList(const ALCchar *name)
- { AppendDevice(name, &alcCaptureDeviceList); }
- /************************************************
- * Device format information
- ************************************************/
- 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";
- case DevFmtInt: return "Signed Int";
- case DevFmtUInt: return "Unsigned Int";
- case DevFmtFloat: return "Float";
- }
- return "(unknown type)";
- }
- const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
- {
- switch(chans)
- {
- case DevFmtMono: return "Mono";
- case DevFmtStereo: return "Stereo";
- case DevFmtQuad: return "Quadraphonic";
- case DevFmtX51: return "5.1 Surround";
- case DevFmtX51Side: return "5.1 Side";
- case DevFmtX61: return "6.1 Surround";
- case DevFmtX71: return "7.1 Surround";
- }
- return "(unknown channels)";
- }
- extern inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans, enum DevFmtType type);
- ALuint BytesFromDevFmt(enum DevFmtType type)
- {
- switch(type)
- {
- case DevFmtByte: return sizeof(ALbyte);
- case DevFmtUByte: return sizeof(ALubyte);
- case DevFmtShort: return sizeof(ALshort);
- case DevFmtUShort: return sizeof(ALushort);
- case DevFmtInt: return sizeof(ALint);
- case DevFmtUInt: return sizeof(ALuint);
- case DevFmtFloat: return sizeof(ALfloat);
- }
- return 0;
- }
- ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
- {
- switch(chans)
- {
- case DevFmtMono: return 1;
- case DevFmtStereo: return 2;
- case DevFmtQuad: return 4;
- case DevFmtX51: return 6;
- case DevFmtX51Side: return 6;
- case DevFmtX61: return 7;
- case DevFmtX71: return 8;
- }
- return 0;
- }
- DECL_CONST static ALboolean DecomposeDevFormat(ALenum format,
- enum DevFmtChannels *chans, enum DevFmtType *type)
- {
- 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;
- for(i = 0;i < COUNTOF(list);i++)
- {
- if(list[i].format == format)
- {
- *chans = list[i].channels;
- *type = list[i].type;
- return AL_TRUE;
- }
- }
- return AL_FALSE;
- }
- DECL_CONST static ALCboolean IsValidALCType(ALCenum type)
- {
- switch(type)
- {
- 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:
- return ALC_TRUE;
- }
- return ALC_FALSE;
- }
- DECL_CONST static ALCboolean IsValidALCChannels(ALCenum channels)
- {
- switch(channels)
- {
- case ALC_MONO_SOFT:
- case ALC_STEREO_SOFT:
- case ALC_QUAD_SOFT:
- case ALC_5POINT1_SOFT:
- case ALC_6POINT1_SOFT:
- case ALC_7POINT1_SOFT:
- return ALC_TRUE;
- }
- return ALC_FALSE;
- }
- /************************************************
- * Miscellaneous ALC helpers
- ************************************************/
- extern inline void LockContext(ALCcontext *context);
- extern inline void UnlockContext(ALCcontext *context);
- ALint64 ALCdevice_GetLatencyDefault(ALCdevice *UNUSED(device))
- {
- return 0;
- }
- ALint64 ALCdevice_GetLatency(ALCdevice *device)
- {
- return V0(device->Backend,getLatency)();
- }
- void ALCdevice_Lock(ALCdevice *device)
- {
- V0(device->Backend,lock)();
- }
- void ALCdevice_Unlock(ALCdevice *device)
- {
- V0(device->Backend,unlock)();
- }
- /* SetDefaultWFXChannelOrder
- *
- * Sets the default channel order used by WaveFormatEx.
- */
- void SetDefaultWFXChannelOrder(ALCdevice *device)
- {
- ALuint i;
- for(i = 0;i < MaxChannels;i++)
- device->ChannelOffsets[i] = INVALID_OFFSET;
- switch(device->FmtChans)
- {
- case DevFmtMono: device->ChannelOffsets[FrontCenter] = 0;
- break;
- case DevFmtStereo: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- break;
- case DevFmtQuad: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- device->ChannelOffsets[BackLeft] = 2;
- device->ChannelOffsets[BackRight] = 3;
- break;
- case DevFmtX51: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- device->ChannelOffsets[FrontCenter] = 2;
- device->ChannelOffsets[LFE] = 3;
- device->ChannelOffsets[BackLeft] = 4;
- device->ChannelOffsets[BackRight] = 5;
- break;
- case DevFmtX51Side: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- device->ChannelOffsets[FrontCenter] = 2;
- device->ChannelOffsets[LFE] = 3;
- device->ChannelOffsets[SideLeft] = 4;
- device->ChannelOffsets[SideRight] = 5;
- break;
- case DevFmtX61: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- device->ChannelOffsets[FrontCenter] = 2;
- device->ChannelOffsets[LFE] = 3;
- device->ChannelOffsets[BackCenter] = 4;
- device->ChannelOffsets[SideLeft] = 5;
- device->ChannelOffsets[SideRight] = 6;
- break;
- case DevFmtX71: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- device->ChannelOffsets[FrontCenter] = 2;
- device->ChannelOffsets[LFE] = 3;
- device->ChannelOffsets[BackLeft] = 4;
- device->ChannelOffsets[BackRight] = 5;
- device->ChannelOffsets[SideLeft] = 6;
- device->ChannelOffsets[SideRight] = 7;
- break;
- }
- }
- /* SetDefaultChannelOrder
- *
- * Sets the default channel order used by most non-WaveFormatEx-based APIs.
- */
- void SetDefaultChannelOrder(ALCdevice *device)
- {
- ALuint i;
- for(i = 0;i < MaxChannels;i++)
- device->ChannelOffsets[i] = INVALID_OFFSET;
- switch(device->FmtChans)
- {
- case DevFmtX51: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- device->ChannelOffsets[BackLeft] = 2;
- device->ChannelOffsets[BackRight] = 3;
- device->ChannelOffsets[FrontCenter] = 4;
- device->ChannelOffsets[LFE] = 5;
- return;
- case DevFmtX71: device->ChannelOffsets[FrontLeft] = 0;
- device->ChannelOffsets[FrontRight] = 1;
- device->ChannelOffsets[BackLeft] = 2;
- device->ChannelOffsets[BackRight] = 3;
- device->ChannelOffsets[FrontCenter] = 4;
- device->ChannelOffsets[LFE] = 5;
- device->ChannelOffsets[SideLeft] = 6;
- device->ChannelOffsets[SideRight] = 7;
- return;
- /* Same as WFX order */
- case DevFmtMono:
- case DevFmtStereo:
- case DevFmtQuad:
- case DevFmtX51Side:
- case DevFmtX61:
- break;
- }
- SetDefaultWFXChannelOrder(device);
- }
- /* alcSetError
- *
- * Stores the latest ALC device error
- */
- static void alcSetError(ALCdevice *device, ALCenum errorCode)
- {
- if(TrapALCError)
- {
- #ifdef _WIN32
- /* DebugBreak() will cause an exception if there is no debugger */
- if(IsDebuggerPresent())
- DebugBreak();
- #elif defined(SIGTRAP)
- raise(SIGTRAP);
- #endif
- }
- if(device)
- ATOMIC_STORE(&device->LastError, errorCode);
- else
- ATOMIC_STORE(&LastNullDeviceError, errorCode);
- }
- /* 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
- * to jump forward or back.
- */
- static inline void UpdateClockBase(ALCdevice *device)
- {
- device->ClockBase += device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency;
- device->SamplesDone = 0;
- }
- /* UpdateDeviceParams
- *
- * Updates device parameters according to the attribute list (caller is
- * responsible for holding the list lock).
- */
- static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
- {
- ALCcontext *context;
- enum DevFmtChannels oldChans;
- enum DevFmtType oldType;
- ALCuint oldFreq;
- FPUCtl oldMode;
- // Check for attributes
- if(device->Type == Loopback)
- {
- enum {
- GotFreq = 1<<0,
- GotChans = 1<<1,
- GotType = 1<<2,
- GotAll = GotFreq|GotChans|GotType
- };
- ALCuint freq, numMono, numStereo, numSends, flags;
- enum DevFmtChannels schans;
- enum DevFmtType stype;
- ALCuint attrIdx = 0;
- ALCint gotFmt = 0;
- if(!attrList)
- {
- WARN("Missing attributes for loopback device\n");
- return ALC_INVALID_VALUE;
- }
- numMono = device->NumMonoSources;
- numStereo = device->NumStereoSources;
- numSends = device->NumAuxSends;
- schans = device->FmtChans;
- stype = device->FmtType;
- freq = device->Frequency;
- flags = device->Flags;
- while(attrList[attrIdx])
- {
- if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT)
- {
- ALCint val = attrList[attrIdx + 1];
- if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
- return ALC_INVALID_VALUE;
- schans = val;
- gotFmt |= GotChans;
- }
- if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT)
- {
- ALCint val = attrList[attrIdx + 1];
- if(!IsValidALCType(val) || !BytesFromDevFmt(val))
- return ALC_INVALID_VALUE;
- stype = val;
- gotFmt |= GotType;
- }
- if(attrList[attrIdx] == ALC_FREQUENCY)
- {
- freq = attrList[attrIdx + 1];
- if(freq < MIN_OUTPUT_RATE)
- return ALC_INVALID_VALUE;
- gotFmt |= GotFreq;
- }
- if(attrList[attrIdx] == ALC_STEREO_SOURCES)
- {
- numStereo = attrList[attrIdx + 1];
- if(numStereo > device->MaxNoOfSources)
- numStereo = device->MaxNoOfSources;
- numMono = device->MaxNoOfSources - numStereo;
- }
- if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
- numSends = attrList[attrIdx + 1];
- if(attrList[attrIdx] == ALC_HRTF_SOFT)
- {
- if(attrList[attrIdx + 1] != ALC_FALSE)
- flags |= DEVICE_HRTF_REQUEST;
- else
- flags &= ~DEVICE_HRTF_REQUEST;
- }
- attrIdx += 2;
- }
- if(gotFmt != GotAll)
- {
- WARN("Missing format for loopback device\n");
- return ALC_INVALID_VALUE;
- }
- ConfigValueUInt(NULL, "sends", &numSends);
- numSends = minu(MAX_SENDS, numSends);
- if((device->Flags&DEVICE_RUNNING))
- V0(device->Backend,stop)();
- device->Flags = (flags & ~DEVICE_RUNNING);
- UpdateClockBase(device);
- device->Frequency = freq;
- device->FmtChans = schans;
- device->FmtType = stype;
- device->NumMonoSources = numMono;
- device->NumStereoSources = numStereo;
- device->NumAuxSends = numSends;
- }
- else if(attrList && attrList[0])
- {
- ALCuint freq, numMono, numStereo, numSends;
- ALCuint attrIdx = 0;
- /* If a context is already running on the device, stop playback so the
- * device attributes can be updated. */
- if((device->Flags&DEVICE_RUNNING))
- V0(device->Backend,stop)();
- device->Flags &= ~DEVICE_RUNNING;
- freq = device->Frequency;
- numMono = device->NumMonoSources;
- numStereo = device->NumStereoSources;
- numSends = device->NumAuxSends;
- while(attrList[attrIdx])
- {
- if(attrList[attrIdx] == ALC_FREQUENCY)
- {
- freq = attrList[attrIdx + 1];
- device->Flags |= DEVICE_FREQUENCY_REQUEST;
- }
- if(attrList[attrIdx] == ALC_STEREO_SOURCES)
- {
- numStereo = attrList[attrIdx + 1];
- if(numStereo > device->MaxNoOfSources)
- numStereo = device->MaxNoOfSources;
- numMono = device->MaxNoOfSources - numStereo;
- }
- if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
- numSends = attrList[attrIdx + 1];
- if(attrList[attrIdx] == ALC_HRTF_SOFT)
- {
- if(attrList[attrIdx + 1] != ALC_FALSE)
- device->Flags |= DEVICE_HRTF_REQUEST;
- else
- device->Flags &= ~DEVICE_HRTF_REQUEST;
- }
- attrIdx += 2;
- }
- ConfigValueUInt(NULL, "frequency", &freq);
- freq = maxu(freq, MIN_OUTPUT_RATE);
- ConfigValueUInt(NULL, "sends", &numSends);
- numSends = minu(MAX_SENDS, numSends);
- UpdateClockBase(device);
- device->UpdateSize = (ALuint64)device->UpdateSize * freq /
- device->Frequency;
- /* SSE and Neon do best with the update size being a multiple of 4 */
- if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
- device->UpdateSize = (device->UpdateSize+3)&~3;
- device->Frequency = freq;
- device->NumMonoSources = numMono;
- device->NumStereoSources = numStereo;
- device->NumAuxSends = numSends;
- }
- if((device->Flags&DEVICE_RUNNING))
- return ALC_NO_ERROR;
- UpdateClockBase(device);
- if(device->Type != Loopback)
- {
- bool usehrtf = !!(device->Flags&DEVICE_HRTF_REQUEST);
- if(GetConfigValueBool(NULL, "hrtf", usehrtf))
- device->Flags |= DEVICE_HRTF_REQUEST;
- else
- device->Flags &= ~DEVICE_HRTF_REQUEST;
- }
- if((device->Flags&DEVICE_HRTF_REQUEST))
- {
- enum DevFmtChannels chans = device->FmtChans;
- ALCuint freq = device->Frequency;
- if(FindHrtfFormat(&chans, &freq))
- {
- if(device->Type != Loopback)
- {
- device->Frequency = freq;
- device->FmtChans = chans;
- device->Flags |= DEVICE_CHANNELS_REQUEST |
- DEVICE_FREQUENCY_REQUEST;
- }
- else if(device->Frequency != freq || device->FmtChans != chans)
- {
- ERR("Requested format not HRTF compatible: %s, %uhz\n",
- DevFmtChannelsString(device->FmtChans), device->Frequency);
- device->Flags &= ~DEVICE_HRTF_REQUEST;
- }
- }
- }
- oldFreq = device->Frequency;
- oldChans = device->FmtChans;
- oldType = device->FmtType;
- TRACE("Pre-reset: %s%s, %s%s, %s%uhz, %u update size x%d\n",
- (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);
- if(V0(device->Backend,reset)() == ALC_FALSE)
- return ALC_INVALID_DEVICE;
- if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
- {
- ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
- DevFmtChannelsString(device->FmtChans));
- device->Flags &= ~DEVICE_CHANNELS_REQUEST;
- }
- 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;
- }
- if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
- {
- ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
- device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
- }
- TRACE("Post-reset: %s, %s, %uhz, %u update size x%d\n",
- DevFmtChannelsString(device->FmtChans),
- DevFmtTypeString(device->FmtType), device->Frequency,
- device->UpdateSize, device->NumUpdates);
- aluInitPanning(device);
- V(device->Synth,update)(device);
- device->Hrtf = NULL;
- if((device->Flags&DEVICE_HRTF_REQUEST))
- {
- device->Hrtf = GetHrtf(device->FmtChans, device->Frequency);
- if(!device->Hrtf)
- device->Flags &= ~DEVICE_HRTF_REQUEST;
- }
- TRACE("HRTF %s\n", device->Hrtf?"enabled":"disabled");
- if(!device->Hrtf && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
- {
- if(!device->Bs2b)
- {
- device->Bs2b = calloc(1, sizeof(*device->Bs2b));
- bs2b_clear(device->Bs2b);
- }
- bs2b_set_srate(device->Bs2b, device->Frequency);
- bs2b_set_level(device->Bs2b, device->Bs2bLevel);
- TRACE("BS2B level %d\n", device->Bs2bLevel);
- }
- else
- {
- free(device->Bs2b);
- device->Bs2b = NULL;
- TRACE("BS2B disabled\n");
- }
- device->Flags &= ~DEVICE_WIDE_STEREO;
- if(device->Type != Loopback && !device->Hrtf && GetConfigValueBool(NULL, "wide-stereo", AL_FALSE))
- device->Flags |= DEVICE_WIDE_STEREO;
- if(!device->Hrtf && (device->UpdateSize&3))
- {
- 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);
- }
- SetMixerFPUMode(&oldMode);
- ALCdevice_Lock(device);
- context = ATOMIC_LOAD(&device->ContextList);
- while(context)
- {
- ALsizei pos;
- ATOMIC_STORE(&context->UpdateSources, AL_FALSE);
- LockUIntMapRead(&context->EffectSlotMap);
- for(pos = 0;pos < context->EffectSlotMap.size;pos++)
- {
- ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
- if(V(slot->EffectState,deviceUpdate)(device) == AL_FALSE)
- {
- UnlockUIntMapRead(&context->EffectSlotMap);
- ALCdevice_Unlock(device);
- RestoreFPUMode(&oldMode);
- return ALC_INVALID_DEVICE;
- }
- ATOMIC_STORE(&slot->NeedsUpdate, AL_FALSE);
- V(slot->EffectState,update)(device, slot);
- }
- UnlockUIntMapRead(&context->EffectSlotMap);
- LockUIntMapRead(&context->SourceMap);
- for(pos = 0;pos < context->SourceMap.size;pos++)
- {
- ALsource *source = context->SourceMap.array[pos].value;
- ALuint s = device->NumAuxSends;
- while(s < MAX_SENDS)
- {
- if(source->Send[s].Slot)
- DecrementRef(&source->Send[s].Slot->ref);
- source->Send[s].Slot = NULL;
- source->Send[s].Gain = 1.0f;
- source->Send[s].GainHF = 1.0f;
- s++;
- }
- ATOMIC_STORE(&source->NeedsUpdate, AL_TRUE);
- }
- UnlockUIntMapRead(&context->SourceMap);
- for(pos = 0;pos < context->VoiceCount;pos++)
- {
- ALvoice *voice = &context->Voices[pos];
- ALsource *source = voice->Source;
- ALuint s = device->NumAuxSends;
- while(s < MAX_SENDS)
- {
- voice->Send[s].Moving = AL_FALSE;
- voice->Send[s].Counter = 0;
- s++;
- }
- if(source)
- {
- ATOMIC_STORE(&source->NeedsUpdate, AL_FALSE);
- voice->Update(voice, source, context);
- }
- }
- context = context->next;
- }
- if(device->DefaultSlot)
- {
- ALeffectslot *slot = device->DefaultSlot;
- if(V(slot->EffectState,deviceUpdate)(device) == AL_FALSE)
- {
- ALCdevice_Unlock(device);
- RestoreFPUMode(&oldMode);
- return ALC_INVALID_DEVICE;
- }
- ATOMIC_STORE(&slot->NeedsUpdate, AL_FALSE);
- V(slot->EffectState,update)(device, slot);
- }
- ALCdevice_Unlock(device);
- RestoreFPUMode(&oldMode);
- if(!(device->Flags&DEVICE_PAUSED))
- {
- if(V0(device->Backend,start)() == ALC_FALSE)
- return ALC_INVALID_DEVICE;
- device->Flags |= DEVICE_RUNNING;
- }
- return ALC_NO_ERROR;
- }
- /* FreeDevice
- *
- * Frees the device structure, and destroys any objects the app failed to
- * delete. Called once there's no more references on the device.
- */
- static ALCvoid FreeDevice(ALCdevice *device)
- {
- TRACE("%p\n", device);
- V0(device->Backend,close)();
- DELETE_OBJ(device->Backend);
- device->Backend = NULL;
- DELETE_OBJ(device->Synth);
- device->Synth = NULL;
- if(device->DefaultSlot)
- {
- ALeffectState *state = device->DefaultSlot->EffectState;
- device->DefaultSlot = NULL;
- DELETE_OBJ(state);
- }
- if(device->DefaultSfont)
- ALsoundfont_deleteSoundfont(device->DefaultSfont, device);
- device->DefaultSfont = NULL;
- if(device->BufferMap.size > 0)
- {
- WARN("(%p) Deleting %d Buffer(s)\n", device, device->BufferMap.size);
- ReleaseALBuffers(device);
- }
- ResetUIntMap(&device->BufferMap);
- if(device->EffectMap.size > 0)
- {
- WARN("(%p) Deleting %d Effect(s)\n", device, device->EffectMap.size);
- ReleaseALEffects(device);
- }
- ResetUIntMap(&device->EffectMap);
- if(device->FilterMap.size > 0)
- {
- WARN("(%p) Deleting %d Filter(s)\n", device, device->FilterMap.size);
- ReleaseALFilters(device);
- }
- ResetUIntMap(&device->FilterMap);
- if(device->SfontMap.size > 0)
- {
- WARN("(%p) Deleting %d Soundfont(s)\n", device, device->SfontMap.size);
- ReleaseALSoundfonts(device);
- }
- ResetUIntMap(&device->SfontMap);
- if(device->PresetMap.size > 0)
- {
- WARN("(%p) Deleting %d Preset(s)\n", device, device->PresetMap.size);
- ReleaseALPresets(device);
- }
- ResetUIntMap(&device->PresetMap);
- if(device->FontsoundMap.size > 0)
- {
- WARN("(%p) Deleting %d Fontsound(s)\n", device, device->FontsoundMap.size);
- ReleaseALFontsounds(device);
- }
- ResetUIntMap(&device->FontsoundMap);
- free(device->Bs2b);
- device->Bs2b = NULL;
- AL_STRING_DEINIT(device->DeviceName);
- al_free(device);
- }
- void ALCdevice_IncRef(ALCdevice *device)
- {
- uint ref;
- ref = IncrementRef(&device->ref);
- TRACEREF("%p increasing refcount to %u\n", device, ref);
- }
- void ALCdevice_DecRef(ALCdevice *device)
- {
- uint ref;
- ref = DecrementRef(&device->ref);
- TRACEREF("%p decreasing refcount to %u\n", device, ref);
- if(ref == 0) FreeDevice(device);
- }
- /* VerifyDevice
- *
- * Checks if the device handle is valid, and increments its ref count if so.
- */
- static ALCdevice *VerifyDevice(ALCdevice *device)
- {
- ALCdevice *tmpDevice;
- if(!device)
- return NULL;
- LockLists();
- tmpDevice = ATOMIC_LOAD(&DeviceList);
- while(tmpDevice && tmpDevice != device)
- tmpDevice = tmpDevice->next;
- if(tmpDevice)
- ALCdevice_IncRef(tmpDevice);
- UnlockLists();
- return tmpDevice;
- }
- /* InitContext
- *
- * Initializes context fields
- */
- static ALvoid InitContext(ALCcontext *Context)
- {
- ALint i, j;
- //Initialise listener
- Context->Listener->Gain = 1.0f;
- Context->Listener->MetersPerUnit = 1.0f;
- Context->Listener->Position[0] = 0.0f;
- Context->Listener->Position[1] = 0.0f;
- Context->Listener->Position[2] = 0.0f;
- Context->Listener->Velocity[0] = 0.0f;
- Context->Listener->Velocity[1] = 0.0f;
- Context->Listener->Velocity[2] = 0.0f;
- Context->Listener->Forward[0] = 0.0f;
- Context->Listener->Forward[1] = 0.0f;
- Context->Listener->Forward[2] = -1.0f;
- Context->Listener->Up[0] = 0.0f;
- Context->Listener->Up[1] = 1.0f;
- Context->Listener->Up[2] = 0.0f;
- for(i = 0;i < 4;i++)
- {
- for(j = 0;j < 4;j++)
- Context->Listener->Params.Matrix[i][j] = ((i==j) ? 1.0f : 0.0f);
- }
- for(i = 0;i < 3;i++)
- Context->Listener->Params.Velocity[i] = 0.0f;
- //Validate Context
- ATOMIC_INIT(&Context->LastError, AL_NO_ERROR);
- ATOMIC_INIT(&Context->UpdateSources, AL_FALSE);
- InitUIntMap(&Context->SourceMap, Context->Device->MaxNoOfSources);
- InitUIntMap(&Context->EffectSlotMap, Context->Device->AuxiliaryEffectSlotMax);
- //Set globals
- Context->DistanceModel = DefaultDistanceModel;
- Context->SourceDistanceModel = AL_FALSE;
- Context->DopplerFactor = 1.0f;
- Context->DopplerVelocity = 1.0f;
- Context->SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
- Context->DeferUpdates = AL_FALSE;
- Context->ExtensionList = alExtList;
- }
- /* FreeContext
- *
- * Cleans up the context, and destroys any remaining objects the app failed to
- * delete. Called once there's no more references on the context.
- */
- static void FreeContext(ALCcontext *context)
- {
- TRACE("%p\n", context);
- if(context->SourceMap.size > 0)
- {
- WARN("(%p) Deleting %d Source(s)\n", context, context->SourceMap.size);
- ReleaseALSources(context);
- }
- ResetUIntMap(&context->SourceMap);
- if(context->EffectSlotMap.size > 0)
- {
- WARN("(%p) Deleting %d AuxiliaryEffectSlot(s)\n", context, context->EffectSlotMap.size);
- ReleaseALAuxiliaryEffectSlots(context);
- }
- ResetUIntMap(&context->EffectSlotMap);
- al_free(context->Voices);
- context->Voices = NULL;
- context->VoiceCount = 0;
- context->MaxVoices = 0;
- VECTOR_DEINIT(context->ActiveAuxSlots);
- ALCdevice_DecRef(context->Device);
- context->Device = NULL;
- //Invalidate context
- memset(context, 0, sizeof(ALCcontext));
- al_free(context);
- }
- /* ReleaseContext
- *
- * Removes the context reference from the given device and removes it from
- * being current on the running thread or globally.
- */
- static void ReleaseContext(ALCcontext *context, ALCdevice *device)
- {
- ALCcontext *nextctx;
- ALCcontext *origctx;
- if(altss_get(LocalContext) == context)
- {
- WARN("%p released while current on thread\n", context);
- altss_set(LocalContext, NULL);
- ALCcontext_DecRef(context);
- }
- origctx = context;
- if(ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &GlobalContext, &origctx, NULL))
- ALCcontext_DecRef(context);
- ALCdevice_Lock(device);
- origctx = context;
- nextctx = context->next;
- if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &device->ContextList, &origctx, nextctx))
- {
- ALCcontext *list;
- do {
- list = origctx;
- origctx = context;
- } while(!COMPARE_EXCHANGE(&list->next, &origctx, nextctx));
- }
- ALCdevice_Unlock(device);
- ALCcontext_DecRef(context);
- }
- void ALCcontext_IncRef(ALCcontext *context)
- {
- uint ref;
- ref = IncrementRef(&context->ref);
- TRACEREF("%p increasing refcount to %u\n", context, ref);
- }
- void ALCcontext_DecRef(ALCcontext *context)
- {
- uint ref;
- ref = DecrementRef(&context->ref);
- TRACEREF("%p decreasing refcount to %u\n", context, ref);
- if(ref == 0) FreeContext(context);
- }
- static void ReleaseThreadCtx(void *ptr)
- {
- WARN("%p current for thread being destroyed\n", ptr);
- ALCcontext_DecRef(ptr);
- }
- /* VerifyContext
- *
- * Checks that the given context is valid, and increments its reference count.
- */
- static ALCcontext *VerifyContext(ALCcontext *context)
- {
- ALCdevice *dev;
- LockLists();
- dev = ATOMIC_LOAD(&DeviceList);
- while(dev)
- {
- ALCcontext *ctx = ATOMIC_LOAD(&dev->ContextList);
- while(ctx)
- {
- if(ctx == context)
- {
- ALCcontext_IncRef(ctx);
- UnlockLists();
- return ctx;
- }
- ctx = ctx->next;
- }
- dev = dev->next;
- }
- UnlockLists();
- return NULL;
- }
- /* GetContextRef
- *
- * Returns the currently active context for this thread, and adds a reference
- * without locking it.
- */
- ALCcontext *GetContextRef(void)
- {
- ALCcontext *context;
- context = altss_get(LocalContext);
- if(context)
- ALCcontext_IncRef(context);
- else
- {
- LockLists();
- context = ATOMIC_LOAD(&GlobalContext);
- if(context)
- ALCcontext_IncRef(context);
- UnlockLists();
- }
- return context;
- }
- /************************************************
- * Standard ALC functions
- ************************************************/
- /* alcGetError
- *
- * Return last ALC generated error code for the given device
- */
- ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
- {
- ALCenum errorCode;
- if(VerifyDevice(device))
- {
- errorCode = ATOMIC_EXCHANGE(ALCenum, &device->LastError, ALC_NO_ERROR);
- ALCdevice_DecRef(device);
- }
- else
- errorCode = ATOMIC_EXCHANGE(ALCenum, &LastNullDeviceError, ALC_NO_ERROR);
- return errorCode;
- }
- /* alcSuspendContext
- *
- * Not functional
- */
- ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *context)
- {
- if (!SuspendAndProcessSupported) return;
- ALCdevice *Device;
- LockLists();
- /* alcGetContextsDevice sets an error for invalid contexts */
- Device = alcGetContextsDevice(context);
- if (Device && (Device->Flags & DEVICE_RUNNING))
- {
- V0(Device->Backend, stop)();
- Device->Flags &= ~DEVICE_RUNNING;
- }
- UnlockLists();
- }
- /* alcProcessContext
- *
- * Not functional
- */
- ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *context)
- {
- if (!SuspendAndProcessSupported) return;
- ALCdevice *Device;
- LockLists();
- /* alcGetContextsDevice sets an error for invalid contexts */
- Device = alcGetContextsDevice(context);
- if (Device && !(Device->Flags & DEVICE_RUNNING))
- {
- V0(Device->Backend, start)();
- Device->Flags |= DEVICE_RUNNING;
- }
- UnlockLists();
- }
- /* alcGetString
- *
- * Returns information about the device, and error strings
- */
- ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
- {
- const ALCchar *value = NULL;
- switch(param)
- {
- 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:
- value = alcDefaultName;
- break;
- case ALC_ALL_DEVICES_SPECIFIER:
- if(VerifyDevice(Device))
- {
- value = al_string_get_cstr(Device->DeviceName);
- ALCdevice_DecRef(Device);
- }
- else
- {
- ProbeAllDevicesList();
- value = al_string_get_cstr(alcAllDevicesList);
- }
- break;
- case ALC_CAPTURE_DEVICE_SPECIFIER:
- if(VerifyDevice(Device))
- {
- value = al_string_get_cstr(Device->DeviceName);
- ALCdevice_DecRef(Device);
- }
- else
- {
- ProbeCaptureDeviceList();
- value = al_string_get_cstr(alcCaptureDeviceList);
- }
- break;
- /* Default devices are always first in the list */
- case ALC_DEFAULT_DEVICE_SPECIFIER:
- value = alcDefaultName;
- break;
- case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
- if(al_string_empty(alcAllDevicesList))
- ProbeAllDevicesList();
- Device = VerifyDevice(Device);
- free(alcDefaultAllDevicesSpecifier);
- alcDefaultAllDevicesSpecifier = strdup(al_string_get_cstr(alcAllDevicesList));
- if(!alcDefaultAllDevicesSpecifier)
- alcSetError(Device, ALC_OUT_OF_MEMORY);
- value = alcDefaultAllDevicesSpecifier;
- if(Device) ALCdevice_DecRef(Device);
- break;
- case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
- if(al_string_empty(alcCaptureDeviceList))
- ProbeCaptureDeviceList();
- Device = VerifyDevice(Device);
- free(alcCaptureDefaultDeviceSpecifier);
- alcCaptureDefaultDeviceSpecifier = strdup(al_string_get_cstr(alcCaptureDeviceList));
- if(!alcCaptureDefaultDeviceSpecifier)
- alcSetError(Device, ALC_OUT_OF_MEMORY);
- value = alcCaptureDefaultDeviceSpecifier;
- if(Device) ALCdevice_DecRef(Device);
- break;
- case ALC_EXTENSIONS:
- if(!VerifyDevice(Device))
- value = alcNoDeviceExtList;
- else
- {
- value = alcExtensionList;
- ALCdevice_DecRef(Device);
- }
- break;
- default:
- Device = VerifyDevice(Device);
- alcSetError(Device, ALC_INVALID_ENUM);
- if(Device) ALCdevice_DecRef(Device);
- break;
- }
- return value;
- }
- static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
- {
- ALCsizei i;
- if(size <= 0 || values == NULL)
- {
- alcSetError(device, ALC_INVALID_VALUE);
- return 0;
- }
- if(!device)
- {
- switch(param)
- {
- case ALC_MAJOR_VERSION:
- values[0] = alcMajorVersion;
- return 1;
- case ALC_MINOR_VERSION:
- values[0] = alcMinorVersion;
- return 1;
- case ALC_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:
- alcSetError(NULL, ALC_INVALID_DEVICE);
- return 0;
- default:
- alcSetError(NULL, ALC_INVALID_ENUM);
- return 0;
- }
- return 0;
- }
- if(device->Type == Capture)
- {
- switch(param)
- {
- case ALC_CAPTURE_SAMPLES:
- ALCdevice_Lock(device);
- values[0] = V0(device->Backend,availableSamples)();
- ALCdevice_Unlock(device);
- return 1;
- case ALC_CONNECTED:
- values[0] = device->Connected;
- return 1;
- default:
- alcSetError(device, ALC_INVALID_ENUM);
- return 0;
- }
- return 0;
- }
- /* render device */
- switch(param)
- {
- case ALC_MAJOR_VERSION:
- values[0] = alcMajorVersion;
- return 1;
- case ALC_MINOR_VERSION:
- values[0] = alcMinorVersion;
- return 1;
- case ALC_EFX_MAJOR_VERSION:
- values[0] = alcEFXMajorVersion;
- return 1;
- case ALC_EFX_MINOR_VERSION:
- values[0] = alcEFXMinorVersion;
- return 1;
- case ALC_ATTRIBUTES_SIZE:
- values[0] = 15;
- return 1;
- case ALC_ALL_ATTRIBUTES:
- if(size < 15)
- {
- alcSetError(device, ALC_INVALID_VALUE);
- return 0;
- }
- i = 0;
- values[i++] = ALC_FREQUENCY;
- values[i++] = device->Frequency;
- if(device->Type != Loopback)
- {
- values[i++] = ALC_REFRESH;
- values[i++] = device->Frequency / device->UpdateSize;
- values[i++] = ALC_SYNC;
- values[i++] = ALC_FALSE;
- }
- else
- {
- values[i++] = ALC_FORMAT_CHANNELS_SOFT;
- values[i++] = device->FmtChans;
- values[i++] = ALC_FORMAT_TYPE_SOFT;
- values[i++] = device->FmtType;
- }
- values[i++] = ALC_MONO_SOURCES;
- values[i++] = device->NumMonoSources;
- values[i++] = ALC_STEREO_SOURCES;
- values[i++] = device->NumStereoSources;
- values[i++] = ALC_MAX_AUXILIARY_SENDS;
- values[i++] = device->NumAuxSends;
- values[i++] = ALC_HRTF_SOFT;
- values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
- values[i++] = 0;
- return i;
- case ALC_FREQUENCY:
- values[0] = device->Frequency;
- return 1;
- case ALC_REFRESH:
- if(device->Type == Loopback)
- {
- alcSetError(device, ALC_INVALID_DEVICE);
- return 0;
- }
- values[0] = device->Frequency / device->UpdateSize;
- return 1;
- case ALC_SYNC:
- if(device->Type == Loopback)
- {
- alcSetError(device, ALC_INVALID_DEVICE);
- return 0;
- }
- values[0] = ALC_FALSE;
- return 1;
- case ALC_FORMAT_CHANNELS_SOFT:
- if(device->Type != Loopback)
- {
- alcSetError(device, ALC_INVALID_DEVICE);
- return 0;
- }
- values[0] = device->FmtChans;
- return 1;
- case ALC_FORMAT_TYPE_SOFT:
- if(device->Type != Loopback)
- {
- alcSetError(device, ALC_INVALID_DEVICE);
- return 0;
- }
- values[0] = device->FmtType;
- return 1;
- case ALC_MONO_SOURCES:
- values[0] = device->NumMonoSources;
- return 1;
- case ALC_STEREO_SOURCES:
- values[0] = device->NumStereoSources;
- return 1;
- case ALC_MAX_AUXILIARY_SENDS:
- values[0] = device->NumAuxSends;
- return 1;
- case ALC_CONNECTED:
- values[0] = device->Connected;
- return 1;
- case ALC_HRTF_SOFT:
- values[0] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
- return 1;
- default:
- alcSetError(device, ALC_INVALID_ENUM);
- return 0;
- }
- return 0;
- }
- /* 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)
- {
- device = VerifyDevice(device);
- if(size <= 0 || values == NULL)
- alcSetError(device, ALC_INVALID_VALUE);
- else
- GetIntegerv(device, param, size, values);
- if(device) ALCdevice_DecRef(device);
- }
- ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALCsizei size, ALCint64SOFT *values)
- {
- ALCint *ivals;
- ALsizei i;
- device = VerifyDevice(device);
- if(size <= 0 || values == NULL)
- alcSetError(device, ALC_INVALID_VALUE);
- else if(!device || device->Type == Capture)
- {
- ivals = malloc(size * sizeof(ALCint));
- size = GetIntegerv(device, pname, size, ivals);
- for(i = 0;i < size;i++)
- values[i] = ivals[i];
- free(ivals);
- }
- else /* render device */
- {
- switch(pname)
- {
- case ALC_ATTRIBUTES_SIZE:
- *values = 17;
- break;
- case ALC_ALL_ATTRIBUTES:
- if(size < 17)
- alcSetError(device, ALC_INVALID_VALUE);
- else
- {
- int i = 0;
- V0(device->Backend,lock)();
- values[i++] = ALC_FREQUENCY;
- values[i++] = device->Frequency;
- if(device->Type != Loopback)
- {
- values[i++] = ALC_REFRESH;
- values[i++] = device->Frequency / device->UpdateSize;
- values[i++] = ALC_SYNC;
- values[i++] = ALC_FALSE;
- }
- else
- {
- values[i++] = ALC_FORMAT_CHANNELS_SOFT;
- values[i++] = device->FmtChans;
- values[i++] = ALC_FORMAT_TYPE_SOFT;
- values[i++] = device->FmtType;
- }
- values[i++] = ALC_MONO_SOURCES;
- values[i++] = device->NumMonoSources;
- values[i++] = ALC_STEREO_SOURCES;
- values[i++] = device->NumStereoSources;
- values[i++] = ALC_MAX_AUXILIARY_SENDS;
- values[i++] = device->NumAuxSends;
- values[i++] = ALC_HRTF_SOFT;
- values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
- values[i++] = ALC_DEVICE_CLOCK_SOFT;
- values[i++] = device->ClockBase +
- (device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency);
- values[i++] = 0;
- V0(device->Backend,unlock)();
- }
- break;
- case ALC_DEVICE_CLOCK_SOFT:
- V0(device->Backend,lock)();
- *values = device->ClockBase +
- (device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency);
- V0(device->Backend,unlock)();
- break;
- default:
- ivals = malloc(size * sizeof(ALCint));
- size = GetIntegerv(device, pname, size, ivals);
- for(i = 0;i < size;i++)
- values[i] = ivals[i];
- free(ivals);
- break;
- }
- }
- if(device)
- ALCdevice_DecRef(device);
- }
- /* alcIsExtensionPresent
- *
- * Determines if there is support for a particular extension
- */
- ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
- {
- ALCboolean bResult = ALC_FALSE;
- device = VerifyDevice(device);
- if(!extName)
- alcSetError(device, ALC_INVALID_VALUE);
- else
- {
- size_t len = strlen(extName);
- const char *ptr = (device ? alcExtensionList : alcNoDeviceExtList);
- while(ptr && *ptr)
- {
- if(strncasecmp(ptr, extName, len) == 0 &&
- (ptr[len] == '\0' || isspace(ptr[len])))
- {
- bResult = ALC_TRUE;
- break;
- }
- if((ptr=strchr(ptr, ' ')) != NULL)
- {
- do {
- ++ptr;
- } while(isspace(*ptr));
- }
- }
- }
- if(device)
- ALCdevice_DecRef(device);
- return bResult;
- }
- /* alcGetProcAddress
- *
- * Retrieves the function address for a particular extension function
- */
- ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
- {
- ALCvoid *ptr = NULL;
- if(!funcName)
- {
- device = VerifyDevice(device);
- alcSetError(device, ALC_INVALID_VALUE);
- if(device) ALCdevice_DecRef(device);
- }
- else
- {
- ALsizei i = 0;
- while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName, funcName) != 0)
- i++;
- ptr = alcFunctions[i].address;
- }
- return ptr;
- }
- /* alcGetEnumValue
- *
- * Get the value for a particular ALC enumeration name
- */
- ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
- {
- ALCenum val = 0;
- if(!enumName)
- {
- device = VerifyDevice(device);
- alcSetError(device, ALC_INVALID_VALUE);
- if(device) ALCdevice_DecRef(device);
- }
- else
- {
- ALsizei i = 0;
- while(enumeration[i].enumName && strcmp(enumeration[i].enumName, enumName) != 0)
- i++;
- val = enumeration[i].value;
- }
- return val;
- }
- /* alcCreateContext
- *
- * Create and attach a context to the given device.
- */
- ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
- {
- ALCcontext *ALContext;
- ALCenum err;
- LockLists();
- if(!(device=VerifyDevice(device)) || device->Type == Capture || !device->Connected)
- {
- UnlockLists();
- alcSetError(device, ALC_INVALID_DEVICE);
- if(device) ALCdevice_DecRef(device);
- return NULL;
- }
- ATOMIC_STORE(&device->LastError, ALC_NO_ERROR);
- if((err=UpdateDeviceParams(device, attrList)) != ALC_NO_ERROR)
- {
- UnlockLists();
- alcSetError(device, err);
- if(err == ALC_INVALID_DEVICE)
- {
- ALCdevice_Lock(device);
- aluHandleDisconnect(device);
- ALCdevice_Unlock(device);
- }
- ALCdevice_DecRef(device);
- return NULL;
- }
- ALContext = al_calloc(16, sizeof(ALCcontext)+sizeof(ALlistener));
- if(ALContext)
- {
- InitRef(&ALContext->ref, 1);
- ALContext->Listener = (ALlistener*)ALContext->_listener_mem;
- VECTOR_INIT(ALContext->ActiveAuxSlots);
- ALContext->VoiceCount = 0;
- ALContext->MaxVoices = 256;
- ALContext->Voices = al_calloc(16, ALContext->MaxVoices * sizeof(ALContext->Voices[0]));
- }
- if(!ALContext || !ALContext->Voices)
- {
- if(!ATOMIC_LOAD(&device->ContextList))
- {
- V0(device->Backend,stop)();
- device->Flags &= ~DEVICE_RUNNING;
- }
- UnlockLists();
- if(ALContext)
- {
- al_free(ALContext->Voices);
- ALContext->Voices = NULL;
- VECTOR_DEINIT(ALContext->ActiveAuxSlots);
- al_free(ALContext);
- ALContext = NULL;
- }
- alcSetError(device, ALC_OUT_OF_MEMORY);
- ALCdevice_DecRef(device);
- return NULL;
- }
- ALContext->Device = device;
- ALCdevice_IncRef(device);
- InitContext(ALContext);
- {
- ALCcontext *head = ATOMIC_LOAD(&device->ContextList);
- do {
- ALContext->next = head;
- } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCcontext*, &device->ContextList, &head, ALContext));
- }
- UnlockLists();
- ALCdevice_DecRef(device);
- TRACE("Created context %p\n", ALContext);
- return ALContext;
- }
- /* alcDestroyContext
- *
- * Remove a context from its device
- */
- ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
- {
- ALCdevice *Device;
- LockLists();
- /* alcGetContextsDevice sets an error for invalid contexts */
- Device = alcGetContextsDevice(context);
- if(Device)
- {
- ReleaseContext(context, Device);
- if(!ATOMIC_LOAD(&Device->ContextList))
- {
- V0(Device->Backend,stop)();
- Device->Flags &= ~DEVICE_RUNNING;
- }
- }
- UnlockLists();
- }
- /* alcGetCurrentContext
- *
- * Returns the currently active context on the calling thread
- */
- ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
- {
- ALCcontext *Context = altss_get(LocalContext);
- if(!Context) Context = ATOMIC_LOAD(&GlobalContext);
- return Context;
- }
- /* alcGetThreadContext
- *
- * Returns the currently active thread-local context
- */
- ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
- {
- return altss_get(LocalContext);
- }
- /* alcMakeContextCurrent
- *
- * Makes the given context the active process-wide context, and removes the
- * thread-local context for the calling thread.
- */
- ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
- {
- /* context must be valid or NULL */
- if(context && !(context=VerifyContext(context)))
- {
- alcSetError(NULL, ALC_INVALID_CONTEXT);
- return ALC_FALSE;
- }
- /* context's reference count is already incremented */
- context = ATOMIC_EXCHANGE(ALCcontext*, &GlobalContext, context);
- if(context) ALCcontext_DecRef(context);
- if((context=altss_get(LocalContext)) != NULL)
- {
- altss_set(LocalContext, NULL);
- ALCcontext_DecRef(context);
- }
- return ALC_TRUE;
- }
- /* alcSetThreadContext
- *
- * Makes the given context the active context for the current thread
- */
- ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
- {
- ALCcontext *old;
- /* context must be valid or NULL */
- if(context && !(context=VerifyContext(context)))
- {
- alcSetError(NULL, ALC_INVALID_CONTEXT);
- return ALC_FALSE;
- }
- /* context's reference count is already incremented */
- old = altss_get(LocalContext);
- altss_set(LocalContext, context);
- if(old) ALCcontext_DecRef(old);
- return ALC_TRUE;
- }
- /* alcGetContextsDevice
- *
- * Returns the device that a particular context is attached to
- */
- ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
- {
- ALCdevice *Device;
- if(!(Context=VerifyContext(Context)))
- {
- alcSetError(NULL, ALC_INVALID_CONTEXT);
- return NULL;
- }
- Device = Context->Device;
- ALCcontext_DecRef(Context);
- return Device;
- }
- /* alcOpenDevice
- *
- * Opens the named device.
- */
- ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
- {
- const ALCchar *fmt;
- ALCdevice *device;
- ALCenum err;
- DO_INITCONFIG();
- if(!PlaybackBackend.name)
- {
- alcSetError(NULL, ALC_INVALID_VALUE);
- return NULL;
- }
- SuspendAndProcessSupported = strcasecmp(PlaybackBackend.name, "mmdevapi") == 0;
- if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
- deviceName = NULL;
- device = al_calloc(16, sizeof(ALCdevice)+sizeof(ALeffectslot));
- if(!device)
- {
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- //Validate device
- InitRef(&device->ref, 1);
- device->Connected = ALC_TRUE;
- device->Type = Playback;
- ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
- device->Flags = 0;
- device->Bs2b = NULL;
- device->Bs2bLevel = 0;
- AL_STRING_INIT(device->DeviceName);
- ATOMIC_INIT(&device->ContextList, NULL);
- device->ClockBase = 0;
- device->SamplesDone = 0;
- device->MaxNoOfSources = 256;
- device->AuxiliaryEffectSlotMax = 4;
- device->NumAuxSends = MAX_SENDS;
- InitUIntMap(&device->BufferMap, ~0);
- InitUIntMap(&device->EffectMap, ~0);
- InitUIntMap(&device->FilterMap, ~0);
- InitUIntMap(&device->SfontMap, ~0);
- InitUIntMap(&device->PresetMap, ~0);
- InitUIntMap(&device->FontsoundMap, ~0);
- //Set output format
- device->FmtChans = DevFmtChannelsDefault;
- device->FmtType = DevFmtTypeDefault;
- device->Frequency = DEFAULT_OUTPUT_RATE;
- device->NumUpdates = 4;
- device->UpdateSize = 1024;
- if(!PlaybackBackend.getFactory)
- device->Backend = create_backend_wrapper(device, &PlaybackBackend.Funcs,
- ALCbackend_Playback);
- else
- {
- ALCbackendFactory *factory = PlaybackBackend.getFactory();
- device->Backend = V(factory,createBackend)(device, ALCbackend_Playback);
- }
- if(!device->Backend)
- {
- al_free(device);
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- if(ConfigValueStr(NULL, "channels", &fmt))
- {
- static const struct {
- const char name[16];
- enum DevFmtChannels chans;
- } chanlist[] = {
- { "mono", DevFmtMono },
- { "stereo", DevFmtStereo },
- { "quad", DevFmtQuad },
- { "surround51", DevFmtX51 },
- { "surround61", DevFmtX61 },
- { "surround71", DevFmtX71 },
- };
- size_t i;
- for(i = 0;i < COUNTOF(chanlist);i++)
- {
- if(strcasecmp(chanlist[i].name, fmt) == 0)
- {
- device->FmtChans = chanlist[i].chans;
- device->Flags |= DEVICE_CHANNELS_REQUEST;
- break;
- }
- }
- if(i == COUNTOF(chanlist))
- ERR("Unsupported channels: %s\n", fmt);
- }
- if(ConfigValueStr(NULL, "sample-type", &fmt))
- {
- static const struct {
- const char name[16];
- enum DevFmtType type;
- } typelist[] = {
- { "int8", DevFmtByte },
- { "uint8", DevFmtUByte },
- { "int16", DevFmtShort },
- { "uint16", DevFmtUShort },
- { "int32", DevFmtInt },
- { "uint32", DevFmtUInt },
- { "float32", DevFmtFloat },
- };
- size_t i;
- for(i = 0;i < COUNTOF(typelist);i++)
- {
- if(strcasecmp(typelist[i].name, fmt) == 0)
- {
- device->FmtType = typelist[i].type;
- device->Flags |= DEVICE_SAMPLE_TYPE_REQUEST;
- break;
- }
- }
- if(i == COUNTOF(typelist))
- ERR("Unsupported sample-type: %s\n", fmt);
- }
- #define DEVICE_FORMAT_REQUEST (DEVICE_CHANNELS_REQUEST|DEVICE_SAMPLE_TYPE_REQUEST)
- if((device->Flags&DEVICE_FORMAT_REQUEST) != DEVICE_FORMAT_REQUEST &&
- ConfigValueStr(NULL, "format", &fmt))
- {
- static const struct {
- const char name[32];
- enum DevFmtChannels channels;
- enum DevFmtType type;
- } formats[] = {
- { "AL_FORMAT_MONO32", DevFmtMono, DevFmtFloat },
- { "AL_FORMAT_STEREO32", DevFmtStereo, DevFmtFloat },
- { "AL_FORMAT_QUAD32", DevFmtQuad, DevFmtFloat },
- { "AL_FORMAT_51CHN32", DevFmtX51, DevFmtFloat },
- { "AL_FORMAT_61CHN32", DevFmtX61, DevFmtFloat },
- { "AL_FORMAT_71CHN32", DevFmtX71, DevFmtFloat },
- { "AL_FORMAT_MONO16", DevFmtMono, DevFmtShort },
- { "AL_FORMAT_STEREO16", DevFmtStereo, DevFmtShort },
- { "AL_FORMAT_QUAD16", DevFmtQuad, DevFmtShort },
- { "AL_FORMAT_51CHN16", DevFmtX51, DevFmtShort },
- { "AL_FORMAT_61CHN16", DevFmtX61, DevFmtShort },
- { "AL_FORMAT_71CHN16", DevFmtX71, DevFmtShort },
- { "AL_FORMAT_MONO8", DevFmtMono, DevFmtByte },
- { "AL_FORMAT_STEREO8", DevFmtStereo, DevFmtByte },
- { "AL_FORMAT_QUAD8", DevFmtQuad, DevFmtByte },
- { "AL_FORMAT_51CHN8", DevFmtX51, DevFmtByte },
- { "AL_FORMAT_61CHN8", DevFmtX61, DevFmtByte },
- { "AL_FORMAT_71CHN8", DevFmtX71, DevFmtByte }
- };
- size_t i;
- ERR("Option 'format' is deprecated, please use 'channels' and 'sample-type'\n");
- for(i = 0;i < COUNTOF(formats);i++)
- {
- if(strcasecmp(fmt, formats[i].name) == 0)
- {
- if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
- device->FmtChans = formats[i].channels;
- if(!(device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
- device->FmtType = formats[i].type;
- device->Flags |= DEVICE_FORMAT_REQUEST;
- break;
- }
- }
- if(i == COUNTOF(formats))
- ERR("Unsupported format: %s\n", fmt);
- }
- #undef DEVICE_FORMAT_REQUEST
- if(ConfigValueUInt(NULL, "frequency", &device->Frequency))
- {
- device->Flags |= DEVICE_FREQUENCY_REQUEST;
- 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);
- }
- ConfigValueUInt(NULL, "periods", &device->NumUpdates);
- device->NumUpdates = clampu(device->NumUpdates, 2, 16);
- ConfigValueUInt(NULL, "period_size", &device->UpdateSize);
- device->UpdateSize = clampu(device->UpdateSize, 64, 8192);
- if((CPUCapFlags&CPU_CAP_SSE))
- device->UpdateSize = (device->UpdateSize+3)&~3;
- ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
- if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
- ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
- if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
- ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
- if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
- ConfigValueInt(NULL, "cf_level", &device->Bs2bLevel);
- device->NumStereoSources = 1;
- device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
- device->Synth = SynthCreate(device);
- if(!device->Synth)
- {
- DELETE_OBJ(device->Backend);
- al_free(device);
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- // Find a playback device to open
- if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
- {
- DELETE_OBJ(device->Synth);
- DELETE_OBJ(device->Backend);
- al_free(device);
- alcSetError(NULL, err);
- return NULL;
- }
- if(DefaultEffect.type != AL_EFFECT_NULL)
- {
- device->DefaultSlot = (ALeffectslot*)device->_slot_mem;
- if(InitEffectSlot(device->DefaultSlot) != AL_NO_ERROR)
- {
- device->DefaultSlot = NULL;
- ERR("Failed to initialize the default effect slot\n");
- }
- else if(InitializeEffect(device, device->DefaultSlot, &DefaultEffect) != AL_NO_ERROR)
- {
- ALeffectState *state = device->DefaultSlot->EffectState;
- device->DefaultSlot = NULL;
- DELETE_OBJ(state);
- ERR("Failed to initialize the default effect\n");
- }
- }
- {
- ALCdevice *head = ATOMIC_LOAD(&DeviceList);
- do {
- device->next = head;
- } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
- }
- TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
- return device;
- }
- /* alcCloseDevice
- *
- * Closes the given device.
- */
- ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
- {
- ALCdevice *list, *origdev, *nextdev;
- ALCcontext *ctx;
- LockLists();
- list = ATOMIC_LOAD(&DeviceList);
- do {
- if(list == device)
- break;
- } while((list=list->next) != NULL);
- if(!list || list->Type == Capture)
- {
- alcSetError(list, ALC_INVALID_DEVICE);
- UnlockLists();
- return ALC_FALSE;
- }
- origdev = device;
- nextdev = device->next;
- if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &origdev, nextdev))
- {
- do {
- list = origdev;
- origdev = device;
- } while(!COMPARE_EXCHANGE(&list->next, &origdev, nextdev));
- }
- UnlockLists();
- ctx = ATOMIC_LOAD(&device->ContextList);
- while(ctx != NULL)
- {
- ALCcontext *next = ctx->next;
- WARN("Releasing context %p\n", ctx);
- ReleaseContext(ctx, device);
- ctx = next;
- }
- if((device->Flags&DEVICE_RUNNING))
- V0(device->Backend,stop)();
- device->Flags &= ~DEVICE_RUNNING;
- ALCdevice_DecRef(device);
- return ALC_TRUE;
- }
- /************************************************
- * ALC capture functions
- ************************************************/
- ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
- {
- ALCdevice *device = NULL;
- ALCenum err;
- DO_INITCONFIG();
- if(!CaptureBackend.name)
- {
- alcSetError(NULL, ALC_INVALID_VALUE);
- return NULL;
- }
- if(samples <= 0)
- {
- alcSetError(NULL, ALC_INVALID_VALUE);
- return NULL;
- }
- if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
- deviceName = NULL;
- device = al_calloc(16, sizeof(ALCdevice));
- if(!device)
- {
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- //Validate device
- InitRef(&device->ref, 1);
- device->Connected = ALC_TRUE;
- device->Type = Capture;
- AL_STRING_INIT(device->DeviceName);
- InitUIntMap(&device->BufferMap, ~0);
- InitUIntMap(&device->EffectMap, ~0);
- InitUIntMap(&device->FilterMap, ~0);
- InitUIntMap(&device->SfontMap, ~0);
- InitUIntMap(&device->PresetMap, ~0);
- InitUIntMap(&device->FontsoundMap, ~0);
- if(!CaptureBackend.getFactory)
- device->Backend = create_backend_wrapper(device, &CaptureBackend.Funcs,
- ALCbackend_Capture);
- else
- {
- ALCbackendFactory *factory = CaptureBackend.getFactory();
- device->Backend = V(factory,createBackend)(device, ALCbackend_Capture);
- }
- if(!device->Backend)
- {
- al_free(device);
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- device->Flags |= DEVICE_FREQUENCY_REQUEST;
- device->Frequency = frequency;
- device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_SAMPLE_TYPE_REQUEST;
- if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
- {
- al_free(device);
- alcSetError(NULL, ALC_INVALID_ENUM);
- return NULL;
- }
- device->UpdateSize = samples;
- device->NumUpdates = 1;
- if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
- {
- al_free(device);
- alcSetError(NULL, err);
- return NULL;
- }
- {
- ALCdevice *head = ATOMIC_LOAD(&DeviceList);
- do {
- device->next = head;
- } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
- }
- TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
- return device;
- }
- ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device)
- {
- ALCdevice *list, *next, *nextdev;
- LockLists();
- list = ATOMIC_LOAD(&DeviceList);
- do {
- if(list == device)
- break;
- } while((list=list->next) != NULL);
- if(!list || list->Type != Capture)
- {
- alcSetError(list, ALC_INVALID_DEVICE);
- UnlockLists();
- return ALC_FALSE;
- }
- next = device;
- nextdev = device->next;
- if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &next, nextdev))
- {
- do {
- list = next;
- next = device;
- } while(!COMPARE_EXCHANGE(&list->next, &next, nextdev));
- }
- UnlockLists();
- ALCdevice_DecRef(device);
- return ALC_TRUE;
- }
- ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
- {
- if(!(device=VerifyDevice(device)) || device->Type != Capture)
- alcSetError(device, ALC_INVALID_DEVICE);
- else
- {
- ALCdevice_Lock(device);
- if(device->Connected)
- {
- if(!(device->Flags&DEVICE_RUNNING))
- V0(device->Backend,start)();
- device->Flags |= DEVICE_RUNNING;
- }
- ALCdevice_Unlock(device);
- }
- if(device) ALCdevice_DecRef(device);
- }
- ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
- {
- if(!(device=VerifyDevice(device)) || device->Type != Capture)
- alcSetError(device, ALC_INVALID_DEVICE);
- else
- {
- ALCdevice_Lock(device);
- if((device->Flags&DEVICE_RUNNING))
- V0(device->Backend,stop)();
- device->Flags &= ~DEVICE_RUNNING;
- ALCdevice_Unlock(device);
- }
- if(device) ALCdevice_DecRef(device);
- }
- ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
- {
- if(!(device=VerifyDevice(device)) || device->Type != Capture)
- alcSetError(device, ALC_INVALID_DEVICE);
- else
- {
- ALCenum err = ALC_INVALID_VALUE;
- ALCdevice_Lock(device);
- if(samples >= 0 && V0(device->Backend,availableSamples)() >= (ALCuint)samples)
- err = V(device->Backend,captureSamples)(buffer, samples);
- ALCdevice_Unlock(device);
- if(err != ALC_NO_ERROR)
- alcSetError(device, err);
- }
- if(device) ALCdevice_DecRef(device);
- }
- /************************************************
- * ALC loopback functions
- ************************************************/
- /* alcLoopbackOpenDeviceSOFT
- *
- * Open a loopback device, for manual rendering.
- */
- ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
- {
- ALCbackendFactory *factory;
- ALCdevice *device;
- DO_INITCONFIG();
- /* Make sure the device name, if specified, is us. */
- if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
- {
- alcSetError(NULL, ALC_INVALID_VALUE);
- return NULL;
- }
- device = al_calloc(16, sizeof(ALCdevice));
- if(!device)
- {
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- //Validate device
- InitRef(&device->ref, 1);
- device->Connected = ALC_TRUE;
- device->Type = Loopback;
- ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
- device->Flags = 0;
- device->Bs2b = NULL;
- device->Bs2bLevel = 0;
- AL_STRING_INIT(device->DeviceName);
- ATOMIC_INIT(&device->ContextList, NULL);
- device->ClockBase = 0;
- device->SamplesDone = 0;
- device->MaxNoOfSources = 256;
- device->AuxiliaryEffectSlotMax = 4;
- device->NumAuxSends = MAX_SENDS;
- InitUIntMap(&device->BufferMap, ~0);
- InitUIntMap(&device->EffectMap, ~0);
- InitUIntMap(&device->FilterMap, ~0);
- InitUIntMap(&device->SfontMap, ~0);
- InitUIntMap(&device->PresetMap, ~0);
- InitUIntMap(&device->FontsoundMap, ~0);
- factory = ALCloopbackFactory_getFactory();
- device->Backend = V(factory,createBackend)(device, ALCbackend_Loopback);
- if(!device->Backend)
- {
- al_free(device);
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- //Set output format
- device->NumUpdates = 0;
- device->UpdateSize = 0;
- device->Frequency = DEFAULT_OUTPUT_RATE;
- device->FmtChans = DevFmtChannelsDefault;
- device->FmtType = DevFmtTypeDefault;
- ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
- if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
- ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
- if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
- ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
- if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
- device->NumStereoSources = 1;
- device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
- device->Synth = SynthCreate(device);
- if(!device->Synth)
- {
- DELETE_OBJ(device->Backend);
- al_free(device);
- alcSetError(NULL, ALC_OUT_OF_MEMORY);
- return NULL;
- }
- // Open the "backend"
- V(device->Backend,open)("Loopback");
- {
- ALCdevice *head = ATOMIC_LOAD(&DeviceList);
- do {
- device->next = head;
- } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
- }
- TRACE("Created device %p\n", device);
- return device;
- }
- /* alcIsRenderFormatSupportedSOFT
- *
- * Determines if the loopback device supports the given format for rendering.
- */
- ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
- {
- ALCboolean ret = ALC_FALSE;
- if(!(device=VerifyDevice(device)) || device->Type != Loopback)
- alcSetError(device, ALC_INVALID_DEVICE);
- else if(freq <= 0)
- alcSetError(device, ALC_INVALID_VALUE);
- else
- {
- if(IsValidALCType(type) && BytesFromDevFmt(type) > 0 &&
- IsValidALCChannels(channels) && ChannelsFromDevFmt(channels) > 0 &&
- freq >= MIN_OUTPUT_RATE)
- ret = ALC_TRUE;
- }
- if(device) ALCdevice_DecRef(device);
- return ret;
- }
- /* alcRenderSamplesSOFT
- *
- * Renders some samples into a buffer, using the format last set by the
- * attributes given to alcCreateContext.
- */
- FORCE_ALIGN ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
- {
- if(!(device=VerifyDevice(device)) || device->Type != Loopback)
- alcSetError(device, ALC_INVALID_DEVICE);
- else if(samples < 0 || (samples > 0 && buffer == NULL))
- alcSetError(device, ALC_INVALID_VALUE);
- else
- aluMixData(device, buffer, samples);
- if(device) ALCdevice_DecRef(device);
- }
- /************************************************
- * ALC DSP pause/resume functions
- ************************************************/
- /* alcDevicePauseSOFT
- *
- * Pause the DSP to stop audio processing.
- */
- ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device)
- {
- if(!(device=VerifyDevice(device)) || device->Type != Playback)
- alcSetError(device, ALC_INVALID_DEVICE);
- else
- {
- LockLists();
- if((device->Flags&DEVICE_RUNNING))
- V0(device->Backend,stop)();
- device->Flags &= ~DEVICE_RUNNING;
- device->Flags |= DEVICE_PAUSED;
- UnlockLists();
- }
- if(device) ALCdevice_DecRef(device);
- }
- /* alcDeviceResumeSOFT
- *
- * Resume the DSP to restart audio processing.
- */
- ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device)
- {
- if(!(device=VerifyDevice(device)) || device->Type != Playback)
- alcSetError(device, ALC_INVALID_DEVICE);
- else
- {
- LockLists();
- if((device->Flags&DEVICE_PAUSED))
- {
- device->Flags &= ~DEVICE_PAUSED;
- if(ATOMIC_LOAD(&device->ContextList) != NULL)
- {
- if(V0(device->Backend,start)() != ALC_FALSE)
- device->Flags |= DEVICE_RUNNING;
- else
- {
- alcSetError(device, ALC_INVALID_DEVICE);
- ALCdevice_Lock(device);
- aluHandleDisconnect(device);
- ALCdevice_Unlock(device);
- }
- }
- }
- UnlockLists();
- }
- if(device) ALCdevice_DecRef(device);
- }