Use a specific lock for the backend's stop/reset/play calls
[openal-soft.git] / Alc / ALc.c
blobe8e5c3ee51d551aec2178e600ae9100e8e310cc1
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
21 #include "config.h"
23 #include <math.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <memory.h>
27 #include <ctype.h>
28 #include <signal.h>
30 #include "alMain.h"
31 #include "alSource.h"
32 #include "alListener.h"
33 #include "alThunk.h"
34 #include "alSource.h"
35 #include "alBuffer.h"
36 #include "alAuxEffectSlot.h"
37 #include "alError.h"
38 #include "bformatdec.h"
39 #include "alu.h"
41 #include "compat.h"
42 #include "threads.h"
43 #include "alstring.h"
44 #include "almalloc.h"
46 #include "backends/base.h"
49 /************************************************
50 * Backends
51 ************************************************/
52 struct BackendInfo {
53 const char *name;
54 ALCbackendFactory* (*getFactory)(void);
55 ALCboolean (*Init)(BackendFuncs*);
56 void (*Deinit)(void);
57 void (*Probe)(enum DevProbe);
58 BackendFuncs Funcs;
61 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
62 static struct BackendInfo BackendList[] = {
63 #ifdef HAVE_JACK
64 { "jack", ALCjackBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
65 #endif
66 #ifdef HAVE_PULSEAUDIO
67 { "pulse", ALCpulseBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
68 #endif
69 #ifdef HAVE_ALSA
70 { "alsa", ALCalsaBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
71 #endif
72 #ifdef HAVE_COREAUDIO
73 { "core", NULL, alc_ca_init, alc_ca_deinit, alc_ca_probe, EmptyFuncs },
74 #endif
75 #ifdef HAVE_OSS
76 { "oss", ALCossBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
77 #endif
78 #ifdef HAVE_SOLARIS
79 { "solaris", ALCsolarisBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
80 #endif
81 #ifdef HAVE_SNDIO
82 { "sndio", NULL, alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },
83 #endif
84 #ifdef HAVE_QSA
85 { "qsa", NULL, alc_qsa_init, alc_qsa_deinit, alc_qsa_probe, EmptyFuncs },
86 #endif
87 #ifdef HAVE_MMDEVAPI
88 { "mmdevapi", ALCmmdevBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
89 #endif
90 #ifdef HAVE_DSOUND
91 { "dsound", ALCdsoundBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
92 #endif
93 #ifdef HAVE_WINMM
94 { "winmm", ALCwinmmBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
95 #endif
96 #ifdef HAVE_PORTAUDIO
97 { "port", ALCportBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
98 #endif
99 #ifdef HAVE_OPENSL
100 { "opensl", NULL, alc_opensl_init, alc_opensl_deinit, alc_opensl_probe, EmptyFuncs },
101 #endif
103 { "null", ALCnullBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
104 #ifdef HAVE_WAVE
105 { "wave", ALCwaveBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
106 #endif
108 { NULL, NULL, NULL, NULL, NULL, EmptyFuncs }
110 #undef EmptyFuncs
112 static struct BackendInfo PlaybackBackend;
113 static struct BackendInfo CaptureBackend;
116 /************************************************
117 * Functions, enums, and errors
118 ************************************************/
119 typedef struct ALCfunction {
120 const ALCchar *funcName;
121 ALCvoid *address;
122 } ALCfunction;
124 typedef struct ALCenums {
125 const ALCchar *enumName;
126 ALCenum value;
127 } ALCenums;
129 #define DECL(x) { #x, (ALCvoid*)(x) }
130 static const ALCfunction alcFunctions[] = {
131 DECL(alcCreateContext),
132 DECL(alcMakeContextCurrent),
133 DECL(alcProcessContext),
134 DECL(alcSuspendContext),
135 DECL(alcDestroyContext),
136 DECL(alcGetCurrentContext),
137 DECL(alcGetContextsDevice),
138 DECL(alcOpenDevice),
139 DECL(alcCloseDevice),
140 DECL(alcGetError),
141 DECL(alcIsExtensionPresent),
142 DECL(alcGetProcAddress),
143 DECL(alcGetEnumValue),
144 DECL(alcGetString),
145 DECL(alcGetIntegerv),
146 DECL(alcCaptureOpenDevice),
147 DECL(alcCaptureCloseDevice),
148 DECL(alcCaptureStart),
149 DECL(alcCaptureStop),
150 DECL(alcCaptureSamples),
152 DECL(alcSetThreadContext),
153 DECL(alcGetThreadContext),
155 DECL(alcLoopbackOpenDeviceSOFT),
156 DECL(alcIsRenderFormatSupportedSOFT),
157 DECL(alcRenderSamplesSOFT),
159 DECL(alcDevicePauseSOFT),
160 DECL(alcDeviceResumeSOFT),
162 DECL(alcGetStringiSOFT),
163 DECL(alcResetDeviceSOFT),
165 DECL(alcGetInteger64vSOFT),
167 DECL(alEnable),
168 DECL(alDisable),
169 DECL(alIsEnabled),
170 DECL(alGetString),
171 DECL(alGetBooleanv),
172 DECL(alGetIntegerv),
173 DECL(alGetFloatv),
174 DECL(alGetDoublev),
175 DECL(alGetBoolean),
176 DECL(alGetInteger),
177 DECL(alGetFloat),
178 DECL(alGetDouble),
179 DECL(alGetError),
180 DECL(alIsExtensionPresent),
181 DECL(alGetProcAddress),
182 DECL(alGetEnumValue),
183 DECL(alListenerf),
184 DECL(alListener3f),
185 DECL(alListenerfv),
186 DECL(alListeneri),
187 DECL(alListener3i),
188 DECL(alListeneriv),
189 DECL(alGetListenerf),
190 DECL(alGetListener3f),
191 DECL(alGetListenerfv),
192 DECL(alGetListeneri),
193 DECL(alGetListener3i),
194 DECL(alGetListeneriv),
195 DECL(alGenSources),
196 DECL(alDeleteSources),
197 DECL(alIsSource),
198 DECL(alSourcef),
199 DECL(alSource3f),
200 DECL(alSourcefv),
201 DECL(alSourcei),
202 DECL(alSource3i),
203 DECL(alSourceiv),
204 DECL(alGetSourcef),
205 DECL(alGetSource3f),
206 DECL(alGetSourcefv),
207 DECL(alGetSourcei),
208 DECL(alGetSource3i),
209 DECL(alGetSourceiv),
210 DECL(alSourcePlayv),
211 DECL(alSourceStopv),
212 DECL(alSourceRewindv),
213 DECL(alSourcePausev),
214 DECL(alSourcePlay),
215 DECL(alSourceStop),
216 DECL(alSourceRewind),
217 DECL(alSourcePause),
218 DECL(alSourceQueueBuffers),
219 DECL(alSourceUnqueueBuffers),
220 DECL(alGenBuffers),
221 DECL(alDeleteBuffers),
222 DECL(alIsBuffer),
223 DECL(alBufferData),
224 DECL(alBufferf),
225 DECL(alBuffer3f),
226 DECL(alBufferfv),
227 DECL(alBufferi),
228 DECL(alBuffer3i),
229 DECL(alBufferiv),
230 DECL(alGetBufferf),
231 DECL(alGetBuffer3f),
232 DECL(alGetBufferfv),
233 DECL(alGetBufferi),
234 DECL(alGetBuffer3i),
235 DECL(alGetBufferiv),
236 DECL(alDopplerFactor),
237 DECL(alDopplerVelocity),
238 DECL(alSpeedOfSound),
239 DECL(alDistanceModel),
241 DECL(alGenFilters),
242 DECL(alDeleteFilters),
243 DECL(alIsFilter),
244 DECL(alFilteri),
245 DECL(alFilteriv),
246 DECL(alFilterf),
247 DECL(alFilterfv),
248 DECL(alGetFilteri),
249 DECL(alGetFilteriv),
250 DECL(alGetFilterf),
251 DECL(alGetFilterfv),
252 DECL(alGenEffects),
253 DECL(alDeleteEffects),
254 DECL(alIsEffect),
255 DECL(alEffecti),
256 DECL(alEffectiv),
257 DECL(alEffectf),
258 DECL(alEffectfv),
259 DECL(alGetEffecti),
260 DECL(alGetEffectiv),
261 DECL(alGetEffectf),
262 DECL(alGetEffectfv),
263 DECL(alGenAuxiliaryEffectSlots),
264 DECL(alDeleteAuxiliaryEffectSlots),
265 DECL(alIsAuxiliaryEffectSlot),
266 DECL(alAuxiliaryEffectSloti),
267 DECL(alAuxiliaryEffectSlotiv),
268 DECL(alAuxiliaryEffectSlotf),
269 DECL(alAuxiliaryEffectSlotfv),
270 DECL(alGetAuxiliaryEffectSloti),
271 DECL(alGetAuxiliaryEffectSlotiv),
272 DECL(alGetAuxiliaryEffectSlotf),
273 DECL(alGetAuxiliaryEffectSlotfv),
275 DECL(alDeferUpdatesSOFT),
276 DECL(alProcessUpdatesSOFT),
278 DECL(alSourcedSOFT),
279 DECL(alSource3dSOFT),
280 DECL(alSourcedvSOFT),
281 DECL(alGetSourcedSOFT),
282 DECL(alGetSource3dSOFT),
283 DECL(alGetSourcedvSOFT),
284 DECL(alSourcei64SOFT),
285 DECL(alSource3i64SOFT),
286 DECL(alSourcei64vSOFT),
287 DECL(alGetSourcei64SOFT),
288 DECL(alGetSource3i64SOFT),
289 DECL(alGetSourcei64vSOFT),
291 DECL(alBufferSamplesSOFT),
292 DECL(alGetBufferSamplesSOFT),
293 DECL(alIsBufferFormatSupportedSOFT),
295 { NULL, NULL }
297 #undef DECL
299 #define DECL(x) { #x, (x) }
300 static const ALCenums enumeration[] = {
301 DECL(ALC_INVALID),
302 DECL(ALC_FALSE),
303 DECL(ALC_TRUE),
305 DECL(ALC_MAJOR_VERSION),
306 DECL(ALC_MINOR_VERSION),
307 DECL(ALC_ATTRIBUTES_SIZE),
308 DECL(ALC_ALL_ATTRIBUTES),
309 DECL(ALC_DEFAULT_DEVICE_SPECIFIER),
310 DECL(ALC_DEVICE_SPECIFIER),
311 DECL(ALC_ALL_DEVICES_SPECIFIER),
312 DECL(ALC_DEFAULT_ALL_DEVICES_SPECIFIER),
313 DECL(ALC_EXTENSIONS),
314 DECL(ALC_FREQUENCY),
315 DECL(ALC_REFRESH),
316 DECL(ALC_SYNC),
317 DECL(ALC_MONO_SOURCES),
318 DECL(ALC_STEREO_SOURCES),
319 DECL(ALC_CAPTURE_DEVICE_SPECIFIER),
320 DECL(ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER),
321 DECL(ALC_CAPTURE_SAMPLES),
322 DECL(ALC_CONNECTED),
324 DECL(ALC_EFX_MAJOR_VERSION),
325 DECL(ALC_EFX_MINOR_VERSION),
326 DECL(ALC_MAX_AUXILIARY_SENDS),
328 DECL(ALC_FORMAT_CHANNELS_SOFT),
329 DECL(ALC_FORMAT_TYPE_SOFT),
331 DECL(ALC_MONO_SOFT),
332 DECL(ALC_STEREO_SOFT),
333 DECL(ALC_QUAD_SOFT),
334 DECL(ALC_5POINT1_SOFT),
335 DECL(ALC_6POINT1_SOFT),
336 DECL(ALC_7POINT1_SOFT),
338 DECL(ALC_BYTE_SOFT),
339 DECL(ALC_UNSIGNED_BYTE_SOFT),
340 DECL(ALC_SHORT_SOFT),
341 DECL(ALC_UNSIGNED_SHORT_SOFT),
342 DECL(ALC_INT_SOFT),
343 DECL(ALC_UNSIGNED_INT_SOFT),
344 DECL(ALC_FLOAT_SOFT),
346 DECL(ALC_HRTF_SOFT),
347 DECL(ALC_DONT_CARE_SOFT),
348 DECL(ALC_HRTF_STATUS_SOFT),
349 DECL(ALC_HRTF_DISABLED_SOFT),
350 DECL(ALC_HRTF_ENABLED_SOFT),
351 DECL(ALC_HRTF_DENIED_SOFT),
352 DECL(ALC_HRTF_REQUIRED_SOFT),
353 DECL(ALC_HRTF_HEADPHONES_DETECTED_SOFT),
354 DECL(ALC_HRTF_UNSUPPORTED_FORMAT_SOFT),
355 DECL(ALC_NUM_HRTF_SPECIFIERS_SOFT),
356 DECL(ALC_HRTF_SPECIFIER_SOFT),
357 DECL(ALC_HRTF_ID_SOFT),
359 DECL(ALC_NO_ERROR),
360 DECL(ALC_INVALID_DEVICE),
361 DECL(ALC_INVALID_CONTEXT),
362 DECL(ALC_INVALID_ENUM),
363 DECL(ALC_INVALID_VALUE),
364 DECL(ALC_OUT_OF_MEMORY),
367 DECL(AL_INVALID),
368 DECL(AL_NONE),
369 DECL(AL_FALSE),
370 DECL(AL_TRUE),
372 DECL(AL_SOURCE_RELATIVE),
373 DECL(AL_CONE_INNER_ANGLE),
374 DECL(AL_CONE_OUTER_ANGLE),
375 DECL(AL_PITCH),
376 DECL(AL_POSITION),
377 DECL(AL_DIRECTION),
378 DECL(AL_VELOCITY),
379 DECL(AL_LOOPING),
380 DECL(AL_BUFFER),
381 DECL(AL_GAIN),
382 DECL(AL_MIN_GAIN),
383 DECL(AL_MAX_GAIN),
384 DECL(AL_ORIENTATION),
385 DECL(AL_REFERENCE_DISTANCE),
386 DECL(AL_ROLLOFF_FACTOR),
387 DECL(AL_CONE_OUTER_GAIN),
388 DECL(AL_MAX_DISTANCE),
389 DECL(AL_SEC_OFFSET),
390 DECL(AL_SAMPLE_OFFSET),
391 DECL(AL_BYTE_OFFSET),
392 DECL(AL_SOURCE_TYPE),
393 DECL(AL_STATIC),
394 DECL(AL_STREAMING),
395 DECL(AL_UNDETERMINED),
396 DECL(AL_METERS_PER_UNIT),
397 DECL(AL_LOOP_POINTS_SOFT),
398 DECL(AL_DIRECT_CHANNELS_SOFT),
400 DECL(AL_DIRECT_FILTER),
401 DECL(AL_AUXILIARY_SEND_FILTER),
402 DECL(AL_AIR_ABSORPTION_FACTOR),
403 DECL(AL_ROOM_ROLLOFF_FACTOR),
404 DECL(AL_CONE_OUTER_GAINHF),
405 DECL(AL_DIRECT_FILTER_GAINHF_AUTO),
406 DECL(AL_AUXILIARY_SEND_FILTER_GAIN_AUTO),
407 DECL(AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO),
409 DECL(AL_SOURCE_STATE),
410 DECL(AL_INITIAL),
411 DECL(AL_PLAYING),
412 DECL(AL_PAUSED),
413 DECL(AL_STOPPED),
415 DECL(AL_BUFFERS_QUEUED),
416 DECL(AL_BUFFERS_PROCESSED),
418 DECL(AL_FORMAT_MONO8),
419 DECL(AL_FORMAT_MONO16),
420 DECL(AL_FORMAT_MONO_FLOAT32),
421 DECL(AL_FORMAT_MONO_DOUBLE_EXT),
422 DECL(AL_FORMAT_STEREO8),
423 DECL(AL_FORMAT_STEREO16),
424 DECL(AL_FORMAT_STEREO_FLOAT32),
425 DECL(AL_FORMAT_STEREO_DOUBLE_EXT),
426 DECL(AL_FORMAT_MONO_IMA4),
427 DECL(AL_FORMAT_STEREO_IMA4),
428 DECL(AL_FORMAT_MONO_MSADPCM_SOFT),
429 DECL(AL_FORMAT_STEREO_MSADPCM_SOFT),
430 DECL(AL_FORMAT_QUAD8_LOKI),
431 DECL(AL_FORMAT_QUAD16_LOKI),
432 DECL(AL_FORMAT_QUAD8),
433 DECL(AL_FORMAT_QUAD16),
434 DECL(AL_FORMAT_QUAD32),
435 DECL(AL_FORMAT_51CHN8),
436 DECL(AL_FORMAT_51CHN16),
437 DECL(AL_FORMAT_51CHN32),
438 DECL(AL_FORMAT_61CHN8),
439 DECL(AL_FORMAT_61CHN16),
440 DECL(AL_FORMAT_61CHN32),
441 DECL(AL_FORMAT_71CHN8),
442 DECL(AL_FORMAT_71CHN16),
443 DECL(AL_FORMAT_71CHN32),
444 DECL(AL_FORMAT_REAR8),
445 DECL(AL_FORMAT_REAR16),
446 DECL(AL_FORMAT_REAR32),
447 DECL(AL_FORMAT_MONO_MULAW),
448 DECL(AL_FORMAT_MONO_MULAW_EXT),
449 DECL(AL_FORMAT_STEREO_MULAW),
450 DECL(AL_FORMAT_STEREO_MULAW_EXT),
451 DECL(AL_FORMAT_QUAD_MULAW),
452 DECL(AL_FORMAT_51CHN_MULAW),
453 DECL(AL_FORMAT_61CHN_MULAW),
454 DECL(AL_FORMAT_71CHN_MULAW),
455 DECL(AL_FORMAT_REAR_MULAW),
456 DECL(AL_FORMAT_MONO_ALAW_EXT),
457 DECL(AL_FORMAT_STEREO_ALAW_EXT),
459 DECL(AL_FORMAT_BFORMAT2D_8),
460 DECL(AL_FORMAT_BFORMAT2D_16),
461 DECL(AL_FORMAT_BFORMAT2D_FLOAT32),
462 DECL(AL_FORMAT_BFORMAT2D_MULAW),
463 DECL(AL_FORMAT_BFORMAT3D_8),
464 DECL(AL_FORMAT_BFORMAT3D_16),
465 DECL(AL_FORMAT_BFORMAT3D_FLOAT32),
466 DECL(AL_FORMAT_BFORMAT3D_MULAW),
468 DECL(AL_MONO8_SOFT),
469 DECL(AL_MONO16_SOFT),
470 DECL(AL_MONO32F_SOFT),
471 DECL(AL_STEREO8_SOFT),
472 DECL(AL_STEREO16_SOFT),
473 DECL(AL_STEREO32F_SOFT),
474 DECL(AL_QUAD8_SOFT),
475 DECL(AL_QUAD16_SOFT),
476 DECL(AL_QUAD32F_SOFT),
477 DECL(AL_REAR8_SOFT),
478 DECL(AL_REAR16_SOFT),
479 DECL(AL_REAR32F_SOFT),
480 DECL(AL_5POINT1_8_SOFT),
481 DECL(AL_5POINT1_16_SOFT),
482 DECL(AL_5POINT1_32F_SOFT),
483 DECL(AL_6POINT1_8_SOFT),
484 DECL(AL_6POINT1_16_SOFT),
485 DECL(AL_6POINT1_32F_SOFT),
486 DECL(AL_7POINT1_8_SOFT),
487 DECL(AL_7POINT1_16_SOFT),
488 DECL(AL_7POINT1_32F_SOFT),
489 DECL(AL_BFORMAT2D_8_SOFT),
490 DECL(AL_BFORMAT2D_16_SOFT),
491 DECL(AL_BFORMAT2D_32F_SOFT),
492 DECL(AL_BFORMAT3D_8_SOFT),
493 DECL(AL_BFORMAT3D_16_SOFT),
494 DECL(AL_BFORMAT3D_32F_SOFT),
496 DECL(AL_MONO_SOFT),
497 DECL(AL_STEREO_SOFT),
498 DECL(AL_QUAD_SOFT),
499 DECL(AL_REAR_SOFT),
500 DECL(AL_5POINT1_SOFT),
501 DECL(AL_6POINT1_SOFT),
502 DECL(AL_7POINT1_SOFT),
503 DECL(AL_BFORMAT2D_SOFT),
504 DECL(AL_BFORMAT3D_SOFT),
506 DECL(AL_BYTE_SOFT),
507 DECL(AL_UNSIGNED_BYTE_SOFT),
508 DECL(AL_SHORT_SOFT),
509 DECL(AL_UNSIGNED_SHORT_SOFT),
510 DECL(AL_INT_SOFT),
511 DECL(AL_UNSIGNED_INT_SOFT),
512 DECL(AL_FLOAT_SOFT),
513 DECL(AL_DOUBLE_SOFT),
514 DECL(AL_BYTE3_SOFT),
515 DECL(AL_UNSIGNED_BYTE3_SOFT),
516 DECL(AL_MULAW_SOFT),
518 DECL(AL_FREQUENCY),
519 DECL(AL_BITS),
520 DECL(AL_CHANNELS),
521 DECL(AL_SIZE),
522 DECL(AL_INTERNAL_FORMAT_SOFT),
523 DECL(AL_BYTE_LENGTH_SOFT),
524 DECL(AL_SAMPLE_LENGTH_SOFT),
525 DECL(AL_SEC_LENGTH_SOFT),
526 DECL(AL_UNPACK_BLOCK_ALIGNMENT_SOFT),
527 DECL(AL_PACK_BLOCK_ALIGNMENT_SOFT),
529 DECL(AL_SOURCE_RADIUS),
531 DECL(AL_STEREO_ANGLES),
533 DECL(AL_UNUSED),
534 DECL(AL_PENDING),
535 DECL(AL_PROCESSED),
537 DECL(AL_NO_ERROR),
538 DECL(AL_INVALID_NAME),
539 DECL(AL_INVALID_ENUM),
540 DECL(AL_INVALID_VALUE),
541 DECL(AL_INVALID_OPERATION),
542 DECL(AL_OUT_OF_MEMORY),
544 DECL(AL_VENDOR),
545 DECL(AL_VERSION),
546 DECL(AL_RENDERER),
547 DECL(AL_EXTENSIONS),
549 DECL(AL_DOPPLER_FACTOR),
550 DECL(AL_DOPPLER_VELOCITY),
551 DECL(AL_DISTANCE_MODEL),
552 DECL(AL_SPEED_OF_SOUND),
553 DECL(AL_SOURCE_DISTANCE_MODEL),
554 DECL(AL_DEFERRED_UPDATES_SOFT),
556 DECL(AL_INVERSE_DISTANCE),
557 DECL(AL_INVERSE_DISTANCE_CLAMPED),
558 DECL(AL_LINEAR_DISTANCE),
559 DECL(AL_LINEAR_DISTANCE_CLAMPED),
560 DECL(AL_EXPONENT_DISTANCE),
561 DECL(AL_EXPONENT_DISTANCE_CLAMPED),
563 DECL(AL_FILTER_TYPE),
564 DECL(AL_FILTER_NULL),
565 DECL(AL_FILTER_LOWPASS),
566 DECL(AL_FILTER_HIGHPASS),
567 DECL(AL_FILTER_BANDPASS),
569 DECL(AL_LOWPASS_GAIN),
570 DECL(AL_LOWPASS_GAINHF),
572 DECL(AL_HIGHPASS_GAIN),
573 DECL(AL_HIGHPASS_GAINLF),
575 DECL(AL_BANDPASS_GAIN),
576 DECL(AL_BANDPASS_GAINHF),
577 DECL(AL_BANDPASS_GAINLF),
579 DECL(AL_EFFECT_TYPE),
580 DECL(AL_EFFECT_NULL),
581 DECL(AL_EFFECT_REVERB),
582 DECL(AL_EFFECT_EAXREVERB),
583 DECL(AL_EFFECT_CHORUS),
584 DECL(AL_EFFECT_DISTORTION),
585 DECL(AL_EFFECT_ECHO),
586 DECL(AL_EFFECT_FLANGER),
587 #if 0
588 DECL(AL_EFFECT_FREQUENCY_SHIFTER),
589 DECL(AL_EFFECT_VOCAL_MORPHER),
590 DECL(AL_EFFECT_PITCH_SHIFTER),
591 #endif
592 DECL(AL_EFFECT_RING_MODULATOR),
593 #if 0
594 DECL(AL_EFFECT_AUTOWAH),
595 #endif
596 DECL(AL_EFFECT_COMPRESSOR),
597 DECL(AL_EFFECT_EQUALIZER),
598 DECL(AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT),
599 DECL(AL_EFFECT_DEDICATED_DIALOGUE),
601 DECL(AL_EAXREVERB_DENSITY),
602 DECL(AL_EAXREVERB_DIFFUSION),
603 DECL(AL_EAXREVERB_GAIN),
604 DECL(AL_EAXREVERB_GAINHF),
605 DECL(AL_EAXREVERB_GAINLF),
606 DECL(AL_EAXREVERB_DECAY_TIME),
607 DECL(AL_EAXREVERB_DECAY_HFRATIO),
608 DECL(AL_EAXREVERB_DECAY_LFRATIO),
609 DECL(AL_EAXREVERB_REFLECTIONS_GAIN),
610 DECL(AL_EAXREVERB_REFLECTIONS_DELAY),
611 DECL(AL_EAXREVERB_REFLECTIONS_PAN),
612 DECL(AL_EAXREVERB_LATE_REVERB_GAIN),
613 DECL(AL_EAXREVERB_LATE_REVERB_DELAY),
614 DECL(AL_EAXREVERB_LATE_REVERB_PAN),
615 DECL(AL_EAXREVERB_ECHO_TIME),
616 DECL(AL_EAXREVERB_ECHO_DEPTH),
617 DECL(AL_EAXREVERB_MODULATION_TIME),
618 DECL(AL_EAXREVERB_MODULATION_DEPTH),
619 DECL(AL_EAXREVERB_AIR_ABSORPTION_GAINHF),
620 DECL(AL_EAXREVERB_HFREFERENCE),
621 DECL(AL_EAXREVERB_LFREFERENCE),
622 DECL(AL_EAXREVERB_ROOM_ROLLOFF_FACTOR),
623 DECL(AL_EAXREVERB_DECAY_HFLIMIT),
625 DECL(AL_REVERB_DENSITY),
626 DECL(AL_REVERB_DIFFUSION),
627 DECL(AL_REVERB_GAIN),
628 DECL(AL_REVERB_GAINHF),
629 DECL(AL_REVERB_DECAY_TIME),
630 DECL(AL_REVERB_DECAY_HFRATIO),
631 DECL(AL_REVERB_REFLECTIONS_GAIN),
632 DECL(AL_REVERB_REFLECTIONS_DELAY),
633 DECL(AL_REVERB_LATE_REVERB_GAIN),
634 DECL(AL_REVERB_LATE_REVERB_DELAY),
635 DECL(AL_REVERB_AIR_ABSORPTION_GAINHF),
636 DECL(AL_REVERB_ROOM_ROLLOFF_FACTOR),
637 DECL(AL_REVERB_DECAY_HFLIMIT),
639 DECL(AL_CHORUS_WAVEFORM),
640 DECL(AL_CHORUS_PHASE),
641 DECL(AL_CHORUS_RATE),
642 DECL(AL_CHORUS_DEPTH),
643 DECL(AL_CHORUS_FEEDBACK),
644 DECL(AL_CHORUS_DELAY),
646 DECL(AL_DISTORTION_EDGE),
647 DECL(AL_DISTORTION_GAIN),
648 DECL(AL_DISTORTION_LOWPASS_CUTOFF),
649 DECL(AL_DISTORTION_EQCENTER),
650 DECL(AL_DISTORTION_EQBANDWIDTH),
652 DECL(AL_ECHO_DELAY),
653 DECL(AL_ECHO_LRDELAY),
654 DECL(AL_ECHO_DAMPING),
655 DECL(AL_ECHO_FEEDBACK),
656 DECL(AL_ECHO_SPREAD),
658 DECL(AL_FLANGER_WAVEFORM),
659 DECL(AL_FLANGER_PHASE),
660 DECL(AL_FLANGER_RATE),
661 DECL(AL_FLANGER_DEPTH),
662 DECL(AL_FLANGER_FEEDBACK),
663 DECL(AL_FLANGER_DELAY),
665 DECL(AL_RING_MODULATOR_FREQUENCY),
666 DECL(AL_RING_MODULATOR_HIGHPASS_CUTOFF),
667 DECL(AL_RING_MODULATOR_WAVEFORM),
669 #if 0
670 DECL(AL_AUTOWAH_ATTACK_TIME),
671 DECL(AL_AUTOWAH_PEAK_GAIN),
672 DECL(AL_AUTOWAH_RELEASE_TIME),
673 DECL(AL_AUTOWAH_RESONANCE),
674 #endif
676 DECL(AL_COMPRESSOR_ONOFF),
678 DECL(AL_EQUALIZER_LOW_GAIN),
679 DECL(AL_EQUALIZER_LOW_CUTOFF),
680 DECL(AL_EQUALIZER_MID1_GAIN),
681 DECL(AL_EQUALIZER_MID1_CENTER),
682 DECL(AL_EQUALIZER_MID1_WIDTH),
683 DECL(AL_EQUALIZER_MID2_GAIN),
684 DECL(AL_EQUALIZER_MID2_CENTER),
685 DECL(AL_EQUALIZER_MID2_WIDTH),
686 DECL(AL_EQUALIZER_HIGH_GAIN),
687 DECL(AL_EQUALIZER_HIGH_CUTOFF),
689 DECL(AL_DEDICATED_GAIN),
691 { NULL, (ALCenum)0 }
693 #undef DECL
695 static const ALCchar alcNoError[] = "No Error";
696 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
697 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
698 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
699 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
700 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
703 /************************************************
704 * Global variables
705 ************************************************/
707 /* Enumerated device names */
708 static const ALCchar alcDefaultName[] = "OpenAL Soft\0";
710 static al_string alcAllDevicesList;
711 static al_string alcCaptureDeviceList;
713 /* Default is always the first in the list */
714 static ALCchar *alcDefaultAllDevicesSpecifier;
715 static ALCchar *alcCaptureDefaultDeviceSpecifier;
717 /* Default context extensions */
718 static const ALchar alExtList[] =
719 "AL_EXT_ALAW AL_EXT_BFORMAT AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE "
720 "AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS "
721 "AL_EXT_MULAW AL_EXT_MULAW_BFORMAT AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET "
722 "AL_EXT_source_distance_model AL_EXT_SOURCE_RADIUS AL_EXT_STEREO_ANGLES "
723 "AL_LOKI_quadriphonic AL_SOFT_block_alignment AL_SOFT_deferred_updates "
724 "AL_SOFT_direct_channels AL_SOFT_loop_points AL_SOFT_MSADPCM "
725 "AL_SOFT_source_latency AL_SOFT_source_length";
727 static ATOMIC(ALCenum) LastNullDeviceError = ATOMIC_INIT_STATIC(ALC_NO_ERROR);
729 /* Thread-local current context */
730 static altss_t LocalContext;
731 /* Process-wide current context */
732 static ATOMIC(ALCcontext*) GlobalContext = ATOMIC_INIT_STATIC(NULL);
734 /* Mixing thread piority level */
735 ALint RTPrioLevel;
737 FILE *LogFile;
738 #ifdef _DEBUG
739 enum LogLevel LogLevel = LogWarning;
740 #else
741 enum LogLevel LogLevel = LogError;
742 #endif
744 /* Flag to trap ALC device errors */
745 static ALCboolean TrapALCError = ALC_FALSE;
747 /* One-time configuration init control */
748 static alonce_flag alc_config_once = AL_ONCE_FLAG_INIT;
750 /* Default effect that applies to sources that don't have an effect on send 0 */
751 static ALeffect DefaultEffect;
753 /* Flag to specify if alcSuspendContext/alcProcessContext should defer/process
754 * updates.
756 static ALCboolean SuspendDefers = ALC_TRUE;
759 /************************************************
760 * ALC information
761 ************************************************/
762 static const ALCchar alcNoDeviceExtList[] =
763 "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
764 "ALC_EXT_thread_local_context ALC_SOFT_loopback";
765 static const ALCchar alcExtensionList[] =
766 "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
767 "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
768 "ALC_EXT_thread_local_context ALC_SOFTX_device_clock ALC_SOFT_HRTF "
769 "ALC_SOFT_loopback ALC_SOFT_pause_device";
770 static const ALCint alcMajorVersion = 1;
771 static const ALCint alcMinorVersion = 1;
773 static const ALCint alcEFXMajorVersion = 1;
774 static const ALCint alcEFXMinorVersion = 0;
777 /************************************************
778 * Device lists
779 ************************************************/
780 static ATOMIC(ALCdevice*) DeviceList = ATOMIC_INIT_STATIC(NULL);
782 static almtx_t ListLock;
783 static inline void LockLists(void)
785 int lockret = almtx_lock(&ListLock);
786 assert(lockret == althrd_success);
788 static inline void UnlockLists(void)
790 int unlockret = almtx_unlock(&ListLock);
791 assert(unlockret == althrd_success);
794 /************************************************
795 * Library initialization
796 ************************************************/
797 #if defined(_WIN32)
798 static void alc_init(void);
799 static void alc_deinit(void);
800 static void alc_deinit_safe(void);
802 #ifndef AL_LIBTYPE_STATIC
803 BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD reason, LPVOID lpReserved)
805 switch(reason)
807 case DLL_PROCESS_ATTACH:
808 /* Pin the DLL so we won't get unloaded until the process terminates */
809 GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
810 (WCHAR*)hModule, &hModule);
811 alc_init();
812 break;
814 case DLL_THREAD_DETACH:
815 break;
817 case DLL_PROCESS_DETACH:
818 if(!lpReserved)
819 alc_deinit();
820 else
821 alc_deinit_safe();
822 break;
824 return TRUE;
826 #elif defined(_MSC_VER)
827 #pragma section(".CRT$XCU",read)
828 static void alc_constructor(void);
829 static void alc_destructor(void);
830 __declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;
832 static void alc_constructor(void)
834 atexit(alc_destructor);
835 alc_init();
838 static void alc_destructor(void)
840 alc_deinit();
842 #elif defined(HAVE_GCC_DESTRUCTOR)
843 static void alc_init(void) __attribute__((constructor));
844 static void alc_deinit(void) __attribute__((destructor));
845 #else
846 #error "No static initialization available on this platform!"
847 #endif
849 #elif defined(HAVE_GCC_DESTRUCTOR)
851 static void alc_init(void) __attribute__((constructor));
852 static void alc_deinit(void) __attribute__((destructor));
854 #else
855 #error "No global initialization available on this platform!"
856 #endif
858 static void ReleaseThreadCtx(void *ptr);
859 static void alc_init(void)
861 const char *str;
862 int ret;
864 LogFile = stderr;
866 AL_STRING_INIT(alcAllDevicesList);
867 AL_STRING_INIT(alcCaptureDeviceList);
869 str = getenv("__ALSOFT_HALF_ANGLE_CONES");
870 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
871 ConeScale *= 0.5f;
873 str = getenv("__ALSOFT_REVERSE_Z");
874 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
875 ZScale *= -1.0f;
877 ret = altss_create(&LocalContext, ReleaseThreadCtx);
878 assert(ret == althrd_success);
880 ret = almtx_init(&ListLock, almtx_recursive);
881 assert(ret == althrd_success);
883 ThunkInit();
886 static void alc_initconfig(void)
888 const char *devs, *str;
889 ALuint capfilter;
890 float valf;
891 int i, n;
893 str = getenv("ALSOFT_LOGLEVEL");
894 if(str)
896 long lvl = strtol(str, NULL, 0);
897 if(lvl >= NoLog && lvl <= LogRef)
898 LogLevel = lvl;
901 str = getenv("ALSOFT_LOGFILE");
902 if(str && str[0])
904 FILE *logfile = al_fopen(str, "wt");
905 if(logfile) LogFile = logfile;
906 else ERR("Failed to open log file '%s'\n", str);
910 char buf[1024] = "";
911 int len = snprintf(buf, sizeof(buf), "%s", BackendList[0].name);
912 for(i = 1;BackendList[i].name;i++)
913 len += snprintf(buf+len, sizeof(buf)-len, ", %s", BackendList[i].name);
914 TRACE("Supported backends: %s\n", buf);
916 ReadALConfig();
918 str = getenv("__ALSOFT_SUSPEND_CONTEXT");
919 if(str && *str)
921 if(strcasecmp(str, "ignore") == 0)
923 SuspendDefers = ALC_FALSE;
924 TRACE("Selected context suspend behavior, \"ignore\"\n");
926 else
927 ERR("Unhandled context suspend behavior setting: \"%s\"\n", str);
930 capfilter = 0;
931 #if defined(HAVE_SSE4_1)
932 capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3 | CPU_CAP_SSE4_1;
933 #elif defined(HAVE_SSE3)
934 capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE3;
935 #elif defined(HAVE_SSE2)
936 capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2;
937 #elif defined(HAVE_SSE)
938 capfilter |= CPU_CAP_SSE;
939 #endif
940 #ifdef HAVE_NEON
941 capfilter |= CPU_CAP_NEON;
942 #endif
943 if(ConfigValueStr(NULL, NULL, "disable-cpu-exts", &str))
945 if(strcasecmp(str, "all") == 0)
946 capfilter = 0;
947 else
949 size_t len;
950 const char *next = str;
952 do {
953 str = next;
954 while(isspace(str[0]))
955 str++;
956 next = strchr(str, ',');
958 if(!str[0] || str[0] == ',')
959 continue;
961 len = (next ? ((size_t)(next-str)) : strlen(str));
962 while(len > 0 && isspace(str[len-1]))
963 len--;
964 if(len == 3 && strncasecmp(str, "sse", len) == 0)
965 capfilter &= ~CPU_CAP_SSE;
966 else if(len == 4 && strncasecmp(str, "sse2", len) == 0)
967 capfilter &= ~CPU_CAP_SSE2;
968 else if(len == 4 && strncasecmp(str, "sse3", len) == 0)
969 capfilter &= ~CPU_CAP_SSE3;
970 else if(len == 6 && strncasecmp(str, "sse4.1", len) == 0)
971 capfilter &= ~CPU_CAP_SSE4_1;
972 else if(len == 4 && strncasecmp(str, "neon", len) == 0)
973 capfilter &= ~CPU_CAP_NEON;
974 else
975 WARN("Invalid CPU extension \"%s\"\n", str);
976 } while(next++);
979 FillCPUCaps(capfilter);
981 #ifdef _WIN32
982 RTPrioLevel = 1;
983 #else
984 RTPrioLevel = 0;
985 #endif
986 ConfigValueInt(NULL, NULL, "rt-prio", &RTPrioLevel);
988 aluInitMixer();
990 str = getenv("ALSOFT_TRAP_ERROR");
991 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
993 TrapALError = AL_TRUE;
994 TrapALCError = AL_TRUE;
996 else
998 str = getenv("ALSOFT_TRAP_AL_ERROR");
999 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
1000 TrapALError = AL_TRUE;
1001 TrapALError = GetConfigValueBool(NULL, NULL, "trap-al-error", TrapALError);
1003 str = getenv("ALSOFT_TRAP_ALC_ERROR");
1004 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
1005 TrapALCError = ALC_TRUE;
1006 TrapALCError = GetConfigValueBool(NULL, NULL, "trap-alc-error", TrapALCError);
1009 if(ConfigValueFloat(NULL, "reverb", "boost", &valf))
1010 ReverbBoost *= powf(10.0f, valf / 20.0f);
1012 EmulateEAXReverb = GetConfigValueBool(NULL, "reverb", "emulate-eax", AL_FALSE);
1014 if(((devs=getenv("ALSOFT_DRIVERS")) && devs[0]) ||
1015 ConfigValueStr(NULL, NULL, "drivers", &devs))
1017 int n;
1018 size_t len;
1019 const char *next = devs;
1020 int endlist, delitem;
1022 i = 0;
1023 do {
1024 devs = next;
1025 while(isspace(devs[0]))
1026 devs++;
1027 next = strchr(devs, ',');
1029 delitem = (devs[0] == '-');
1030 if(devs[0] == '-') devs++;
1032 if(!devs[0] || devs[0] == ',')
1034 endlist = 0;
1035 continue;
1037 endlist = 1;
1039 len = (next ? ((size_t)(next-devs)) : strlen(devs));
1040 while(len > 0 && isspace(devs[len-1]))
1041 len--;
1042 for(n = i;BackendList[n].name;n++)
1044 if(len == strlen(BackendList[n].name) &&
1045 strncmp(BackendList[n].name, devs, len) == 0)
1047 if(delitem)
1049 do {
1050 BackendList[n] = BackendList[n+1];
1051 ++n;
1052 } while(BackendList[n].name);
1054 else
1056 struct BackendInfo Bkp = BackendList[n];
1057 while(n > i)
1059 BackendList[n] = BackendList[n-1];
1060 --n;
1062 BackendList[n] = Bkp;
1064 i++;
1066 break;
1069 } while(next++);
1071 if(endlist)
1073 BackendList[i].name = NULL;
1074 BackendList[i].getFactory = NULL;
1075 BackendList[i].Init = NULL;
1076 BackendList[i].Deinit = NULL;
1077 BackendList[i].Probe = NULL;
1081 for(i = 0;(BackendList[i].Init || BackendList[i].getFactory) && (!PlaybackBackend.name || !CaptureBackend.name);i++)
1083 if(BackendList[i].getFactory)
1085 ALCbackendFactory *factory = BackendList[i].getFactory();
1086 if(!V0(factory,init)())
1088 WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
1089 continue;
1092 TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
1093 if(!PlaybackBackend.name && V(factory,querySupport)(ALCbackend_Playback))
1095 PlaybackBackend = BackendList[i];
1096 TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
1098 if(!CaptureBackend.name && V(factory,querySupport)(ALCbackend_Capture))
1100 CaptureBackend = BackendList[i];
1101 TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
1104 continue;
1107 if(!BackendList[i].Init(&BackendList[i].Funcs))
1109 WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
1110 continue;
1113 TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
1114 if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
1116 PlaybackBackend = BackendList[i];
1117 TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
1119 if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
1121 CaptureBackend = BackendList[i];
1122 TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
1126 ALCbackendFactory *factory = ALCloopbackFactory_getFactory();
1127 V0(factory,init)();
1130 if(!PlaybackBackend.name)
1131 WARN("No playback backend available!\n");
1132 if(!CaptureBackend.name)
1133 WARN("No capture backend available!\n");
1135 if(ConfigValueStr(NULL, NULL, "excludefx", &str))
1137 size_t len;
1138 const char *next = str;
1140 do {
1141 str = next;
1142 next = strchr(str, ',');
1144 if(!str[0] || next == str)
1145 continue;
1147 len = (next ? ((size_t)(next-str)) : strlen(str));
1148 for(n = 0;EffectList[n].name;n++)
1150 if(len == strlen(EffectList[n].name) &&
1151 strncmp(EffectList[n].name, str, len) == 0)
1152 DisabledEffects[EffectList[n].type] = AL_TRUE;
1154 } while(next++);
1157 InitEffectFactoryMap();
1159 InitEffect(&DefaultEffect);
1160 str = getenv("ALSOFT_DEFAULT_REVERB");
1161 if((str && str[0]) || ConfigValueStr(NULL, NULL, "default-reverb", &str))
1162 LoadReverbPreset(str, &DefaultEffect);
1164 #define DO_INITCONFIG() alcall_once(&alc_config_once, alc_initconfig)
1167 /************************************************
1168 * Library deinitialization
1169 ************************************************/
1170 static void alc_cleanup(void)
1172 ALCdevice *dev;
1174 AL_STRING_DEINIT(alcAllDevicesList);
1175 AL_STRING_DEINIT(alcCaptureDeviceList);
1177 free(alcDefaultAllDevicesSpecifier);
1178 alcDefaultAllDevicesSpecifier = NULL;
1179 free(alcCaptureDefaultDeviceSpecifier);
1180 alcCaptureDefaultDeviceSpecifier = NULL;
1182 if((dev=ATOMIC_EXCHANGE(ALCdevice*, &DeviceList, NULL)) != NULL)
1184 ALCuint num = 0;
1185 do {
1186 num++;
1187 } while((dev=dev->next) != NULL);
1188 ERR("%u device%s not closed\n", num, (num>1)?"s":"");
1191 DeinitEffectFactoryMap();
1194 static void alc_deinit_safe(void)
1196 alc_cleanup();
1198 FreeHrtfs();
1199 FreeALConfig();
1201 ThunkExit();
1202 almtx_destroy(&ListLock);
1203 altss_delete(LocalContext);
1205 if(LogFile != stderr)
1206 fclose(LogFile);
1207 LogFile = NULL;
1210 static void alc_deinit(void)
1212 int i;
1214 alc_cleanup();
1216 memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
1217 memset(&CaptureBackend, 0, sizeof(CaptureBackend));
1219 for(i = 0;BackendList[i].Deinit || BackendList[i].getFactory;i++)
1221 if(!BackendList[i].getFactory)
1222 BackendList[i].Deinit();
1223 else
1225 ALCbackendFactory *factory = BackendList[i].getFactory();
1226 V0(factory,deinit)();
1230 ALCbackendFactory *factory = ALCloopbackFactory_getFactory();
1231 V0(factory,deinit)();
1234 alc_deinit_safe();
1238 /************************************************
1239 * Device enumeration
1240 ************************************************/
1241 static void ProbeDevices(al_string *list, struct BackendInfo *backendinfo, enum DevProbe type)
1243 DO_INITCONFIG();
1245 LockLists();
1246 al_string_clear(list);
1248 if(backendinfo->Probe)
1249 backendinfo->Probe(type);
1250 else if(backendinfo->getFactory)
1252 ALCbackendFactory *factory = backendinfo->getFactory();
1253 V(factory,probe)(type);
1256 UnlockLists();
1258 static void ProbeAllDevicesList(void)
1259 { ProbeDevices(&alcAllDevicesList, &PlaybackBackend, ALL_DEVICE_PROBE); }
1260 static void ProbeCaptureDeviceList(void)
1261 { ProbeDevices(&alcCaptureDeviceList, &CaptureBackend, CAPTURE_DEVICE_PROBE); }
1263 static void AppendDevice(const ALCchar *name, al_string *devnames)
1265 size_t len = strlen(name);
1266 if(len > 0)
1267 al_string_append_range(devnames, name, name+len+1);
1269 void AppendAllDevicesList(const ALCchar *name)
1270 { AppendDevice(name, &alcAllDevicesList); }
1271 void AppendCaptureDeviceList(const ALCchar *name)
1272 { AppendDevice(name, &alcCaptureDeviceList); }
1275 /************************************************
1276 * Device format information
1277 ************************************************/
1278 const ALCchar *DevFmtTypeString(enum DevFmtType type)
1280 switch(type)
1282 case DevFmtByte: return "Signed Byte";
1283 case DevFmtUByte: return "Unsigned Byte";
1284 case DevFmtShort: return "Signed Short";
1285 case DevFmtUShort: return "Unsigned Short";
1286 case DevFmtInt: return "Signed Int";
1287 case DevFmtUInt: return "Unsigned Int";
1288 case DevFmtFloat: return "Float";
1290 return "(unknown type)";
1292 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
1294 switch(chans)
1296 case DevFmtMono: return "Mono";
1297 case DevFmtStereo: return "Stereo";
1298 case DevFmtQuad: return "Quadraphonic";
1299 case DevFmtX51: return "5.1 Surround";
1300 case DevFmtX51Rear: return "5.1 Surround (Rear)";
1301 case DevFmtX61: return "6.1 Surround";
1302 case DevFmtX71: return "7.1 Surround";
1303 case DevFmtBFormat3D: return "B-Format 3D";
1305 return "(unknown channels)";
1308 extern inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans, enum DevFmtType type);
1309 ALuint BytesFromDevFmt(enum DevFmtType type)
1311 switch(type)
1313 case DevFmtByte: return sizeof(ALbyte);
1314 case DevFmtUByte: return sizeof(ALubyte);
1315 case DevFmtShort: return sizeof(ALshort);
1316 case DevFmtUShort: return sizeof(ALushort);
1317 case DevFmtInt: return sizeof(ALint);
1318 case DevFmtUInt: return sizeof(ALuint);
1319 case DevFmtFloat: return sizeof(ALfloat);
1321 return 0;
1323 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
1325 switch(chans)
1327 case DevFmtMono: return 1;
1328 case DevFmtStereo: return 2;
1329 case DevFmtQuad: return 4;
1330 case DevFmtX51: return 6;
1331 case DevFmtX51Rear: return 6;
1332 case DevFmtX61: return 7;
1333 case DevFmtX71: return 8;
1334 case DevFmtBFormat3D: return 4;
1336 return 0;
1339 DECL_CONST static ALboolean DecomposeDevFormat(ALenum format,
1340 enum DevFmtChannels *chans, enum DevFmtType *type)
1342 static const struct {
1343 ALenum format;
1344 enum DevFmtChannels channels;
1345 enum DevFmtType type;
1346 } list[] = {
1347 { AL_FORMAT_MONO8, DevFmtMono, DevFmtUByte },
1348 { AL_FORMAT_MONO16, DevFmtMono, DevFmtShort },
1349 { AL_FORMAT_MONO_FLOAT32, DevFmtMono, DevFmtFloat },
1351 { AL_FORMAT_STEREO8, DevFmtStereo, DevFmtUByte },
1352 { AL_FORMAT_STEREO16, DevFmtStereo, DevFmtShort },
1353 { AL_FORMAT_STEREO_FLOAT32, DevFmtStereo, DevFmtFloat },
1355 { AL_FORMAT_QUAD8, DevFmtQuad, DevFmtUByte },
1356 { AL_FORMAT_QUAD16, DevFmtQuad, DevFmtShort },
1357 { AL_FORMAT_QUAD32, DevFmtQuad, DevFmtFloat },
1359 { AL_FORMAT_51CHN8, DevFmtX51, DevFmtUByte },
1360 { AL_FORMAT_51CHN16, DevFmtX51, DevFmtShort },
1361 { AL_FORMAT_51CHN32, DevFmtX51, DevFmtFloat },
1363 { AL_FORMAT_61CHN8, DevFmtX61, DevFmtUByte },
1364 { AL_FORMAT_61CHN16, DevFmtX61, DevFmtShort },
1365 { AL_FORMAT_61CHN32, DevFmtX61, DevFmtFloat },
1367 { AL_FORMAT_71CHN8, DevFmtX71, DevFmtUByte },
1368 { AL_FORMAT_71CHN16, DevFmtX71, DevFmtShort },
1369 { AL_FORMAT_71CHN32, DevFmtX71, DevFmtFloat },
1371 ALuint i;
1373 for(i = 0;i < COUNTOF(list);i++)
1375 if(list[i].format == format)
1377 *chans = list[i].channels;
1378 *type = list[i].type;
1379 return AL_TRUE;
1383 return AL_FALSE;
1386 DECL_CONST static ALCboolean IsValidALCType(ALCenum type)
1388 switch(type)
1390 case ALC_BYTE_SOFT:
1391 case ALC_UNSIGNED_BYTE_SOFT:
1392 case ALC_SHORT_SOFT:
1393 case ALC_UNSIGNED_SHORT_SOFT:
1394 case ALC_INT_SOFT:
1395 case ALC_UNSIGNED_INT_SOFT:
1396 case ALC_FLOAT_SOFT:
1397 return ALC_TRUE;
1399 return ALC_FALSE;
1402 DECL_CONST static ALCboolean IsValidALCChannels(ALCenum channels)
1404 switch(channels)
1406 case ALC_MONO_SOFT:
1407 case ALC_STEREO_SOFT:
1408 case ALC_QUAD_SOFT:
1409 case ALC_5POINT1_SOFT:
1410 case ALC_6POINT1_SOFT:
1411 case ALC_7POINT1_SOFT:
1412 return ALC_TRUE;
1414 return ALC_FALSE;
1418 /************************************************
1419 * Miscellaneous ALC helpers
1420 ************************************************/
1422 extern inline void LockContext(ALCcontext *context);
1423 extern inline void UnlockContext(ALCcontext *context);
1425 void ALCdevice_Lock(ALCdevice *device)
1427 V0(device->Backend,lock)();
1430 void ALCdevice_Unlock(ALCdevice *device)
1432 V0(device->Backend,unlock)();
1436 /* SetDefaultWFXChannelOrder
1438 * Sets the default channel order used by WaveFormatEx.
1440 void SetDefaultWFXChannelOrder(ALCdevice *device)
1442 ALuint i;
1444 for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
1445 device->RealOut.ChannelName[i] = InvalidChannel;
1447 switch(device->FmtChans)
1449 case DevFmtMono:
1450 device->RealOut.ChannelName[0] = FrontCenter;
1451 break;
1452 case DevFmtStereo:
1453 device->RealOut.ChannelName[0] = FrontLeft;
1454 device->RealOut.ChannelName[1] = FrontRight;
1455 break;
1456 case DevFmtQuad:
1457 device->RealOut.ChannelName[0] = FrontLeft;
1458 device->RealOut.ChannelName[1] = FrontRight;
1459 device->RealOut.ChannelName[2] = BackLeft;
1460 device->RealOut.ChannelName[3] = BackRight;
1461 break;
1462 case DevFmtX51:
1463 device->RealOut.ChannelName[0] = FrontLeft;
1464 device->RealOut.ChannelName[1] = FrontRight;
1465 device->RealOut.ChannelName[2] = FrontCenter;
1466 device->RealOut.ChannelName[3] = LFE;
1467 device->RealOut.ChannelName[4] = SideLeft;
1468 device->RealOut.ChannelName[5] = SideRight;
1469 break;
1470 case DevFmtX51Rear:
1471 device->RealOut.ChannelName[0] = FrontLeft;
1472 device->RealOut.ChannelName[1] = FrontRight;
1473 device->RealOut.ChannelName[2] = FrontCenter;
1474 device->RealOut.ChannelName[3] = LFE;
1475 device->RealOut.ChannelName[4] = BackLeft;
1476 device->RealOut.ChannelName[5] = BackRight;
1477 break;
1478 case DevFmtX61:
1479 device->RealOut.ChannelName[0] = FrontLeft;
1480 device->RealOut.ChannelName[1] = FrontRight;
1481 device->RealOut.ChannelName[2] = FrontCenter;
1482 device->RealOut.ChannelName[3] = LFE;
1483 device->RealOut.ChannelName[4] = BackCenter;
1484 device->RealOut.ChannelName[5] = SideLeft;
1485 device->RealOut.ChannelName[6] = SideRight;
1486 break;
1487 case DevFmtX71:
1488 device->RealOut.ChannelName[0] = FrontLeft;
1489 device->RealOut.ChannelName[1] = FrontRight;
1490 device->RealOut.ChannelName[2] = FrontCenter;
1491 device->RealOut.ChannelName[3] = LFE;
1492 device->RealOut.ChannelName[4] = BackLeft;
1493 device->RealOut.ChannelName[5] = BackRight;
1494 device->RealOut.ChannelName[6] = SideLeft;
1495 device->RealOut.ChannelName[7] = SideRight;
1496 break;
1497 case DevFmtBFormat3D:
1498 device->RealOut.ChannelName[0] = Aux0;
1499 device->RealOut.ChannelName[1] = Aux1;
1500 device->RealOut.ChannelName[2] = Aux2;
1501 device->RealOut.ChannelName[3] = Aux3;
1502 break;
1506 /* SetDefaultChannelOrder
1508 * Sets the default channel order used by most non-WaveFormatEx-based APIs.
1510 void SetDefaultChannelOrder(ALCdevice *device)
1512 ALuint i;
1514 for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
1515 device->RealOut.ChannelName[i] = InvalidChannel;
1517 switch(device->FmtChans)
1519 case DevFmtX51Rear:
1520 device->RealOut.ChannelName[0] = FrontLeft;
1521 device->RealOut.ChannelName[1] = FrontRight;
1522 device->RealOut.ChannelName[2] = BackLeft;
1523 device->RealOut.ChannelName[3] = BackRight;
1524 device->RealOut.ChannelName[4] = FrontCenter;
1525 device->RealOut.ChannelName[5] = LFE;
1526 return;
1527 case DevFmtX71:
1528 device->RealOut.ChannelName[0] = FrontLeft;
1529 device->RealOut.ChannelName[1] = FrontRight;
1530 device->RealOut.ChannelName[2] = BackLeft;
1531 device->RealOut.ChannelName[3] = BackRight;
1532 device->RealOut.ChannelName[4] = FrontCenter;
1533 device->RealOut.ChannelName[5] = LFE;
1534 device->RealOut.ChannelName[6] = SideLeft;
1535 device->RealOut.ChannelName[7] = SideRight;
1536 return;
1538 /* Same as WFX order */
1539 case DevFmtMono:
1540 case DevFmtStereo:
1541 case DevFmtQuad:
1542 case DevFmtX51:
1543 case DevFmtX61:
1544 case DevFmtBFormat3D:
1545 SetDefaultWFXChannelOrder(device);
1546 break;
1550 extern inline ALint GetChannelIndex(const enum Channel names[MAX_OUTPUT_CHANNELS], enum Channel chan);
1553 /* ALCcontext_DeferUpdates
1555 * Defers/suspends updates for the given context's listener and sources. This
1556 * does *NOT* stop mixing, but rather prevents certain property changes from
1557 * taking effect.
1559 void ALCcontext_DeferUpdates(ALCcontext *context)
1561 ATOMIC_STORE(&context->DeferUpdates, AL_TRUE);
1564 /* ALCcontext_ProcessUpdates
1566 * Resumes update processing after being deferred.
1568 void ALCcontext_ProcessUpdates(ALCcontext *context)
1570 ALCdevice *device = context->Device;
1572 ReadLock(&context->PropLock);
1573 if(ATOMIC_EXCHANGE(ALenum, &context->DeferUpdates, AL_FALSE))
1575 ALsizei pos;
1577 UpdateListenerProps(context);
1579 LockUIntMapRead(&context->SourceMap);
1580 V0(device->Backend,lock)();
1581 for(pos = 0;pos < context->SourceMap.size;pos++)
1583 ALsource *Source = context->SourceMap.array[pos].value;
1584 ALenum new_state;
1586 if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
1587 Source->OffsetType != AL_NONE)
1589 WriteLock(&Source->queue_lock);
1590 ApplyOffset(Source);
1591 WriteUnlock(&Source->queue_lock);
1594 new_state = Source->new_state;
1595 Source->new_state = AL_NONE;
1596 if(new_state)
1597 SetSourceState(Source, context, new_state);
1599 V0(device->Backend,unlock)();
1600 UnlockUIntMapRead(&context->SourceMap);
1601 UpdateAllSourceProps(context);
1603 ReadUnlock(&context->PropLock);
1607 /* alcSetError
1609 * Stores the latest ALC device error
1611 static void alcSetError(ALCdevice *device, ALCenum errorCode)
1613 if(TrapALCError)
1615 #ifdef _WIN32
1616 /* DebugBreak() will cause an exception if there is no debugger */
1617 if(IsDebuggerPresent())
1618 DebugBreak();
1619 #elif defined(SIGTRAP)
1620 raise(SIGTRAP);
1621 #endif
1624 if(device)
1625 ATOMIC_STORE(&device->LastError, errorCode);
1626 else
1627 ATOMIC_STORE(&LastNullDeviceError, errorCode);
1631 /* UpdateClockBase
1633 * Updates the device's base clock time with however many samples have been
1634 * done. This is used so frequency changes on the device don't cause the time
1635 * to jump forward or back.
1637 static inline void UpdateClockBase(ALCdevice *device)
1639 device->ClockBase += device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency;
1640 device->SamplesDone = 0;
1643 /* UpdateDeviceParams
1645 * Updates device parameters according to the attribute list (caller is
1646 * responsible for holding the list lock).
1648 static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
1650 ALCcontext *context;
1651 enum HrtfRequestMode hrtf_appreq = Hrtf_Default;
1652 enum HrtfRequestMode hrtf_userreq = Hrtf_Default;
1653 enum DevFmtChannels oldChans;
1654 enum DevFmtType oldType;
1655 ALCuint oldFreq;
1656 FPUCtl oldMode;
1657 ALCsizei hrtf_id = -1;
1658 size_t size;
1660 // Check for attributes
1661 if(device->Type == Loopback)
1663 enum {
1664 GotFreq = 1<<0,
1665 GotChans = 1<<1,
1666 GotType = 1<<2,
1667 GotAll = GotFreq|GotChans|GotType
1669 ALCuint freq, numMono, numStereo, numSends;
1670 enum DevFmtChannels schans;
1671 enum DevFmtType stype;
1672 ALCuint attrIdx = 0;
1673 ALCint gotFmt = 0;
1675 if(!attrList)
1677 WARN("Missing attributes for loopback device\n");
1678 return ALC_INVALID_VALUE;
1681 numMono = device->NumMonoSources;
1682 numStereo = device->NumStereoSources;
1683 numSends = device->NumAuxSends;
1684 schans = device->FmtChans;
1685 stype = device->FmtType;
1686 freq = device->Frequency;
1688 #define TRACE_ATTR(a, v) TRACE("Loopback %s = %d\n", #a, v)
1689 while(attrList[attrIdx])
1691 if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT)
1693 ALCint val = attrList[attrIdx + 1];
1694 TRACE_ATTR(ALC_FORMAT_CHANNELS_SOFT, val);
1695 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
1696 return ALC_INVALID_VALUE;
1697 schans = val;
1698 gotFmt |= GotChans;
1701 if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT)
1703 ALCint val = attrList[attrIdx + 1];
1704 TRACE_ATTR(ALC_FORMAT_TYPE_SOFT, val);
1705 if(!IsValidALCType(val) || !BytesFromDevFmt(val))
1706 return ALC_INVALID_VALUE;
1707 stype = val;
1708 gotFmt |= GotType;
1711 if(attrList[attrIdx] == ALC_FREQUENCY)
1713 freq = attrList[attrIdx + 1];
1714 TRACE_ATTR(ALC_FREQUENCY, freq);
1715 if(freq < MIN_OUTPUT_RATE)
1716 return ALC_INVALID_VALUE;
1717 gotFmt |= GotFreq;
1720 if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1722 numStereo = attrList[attrIdx + 1];
1723 TRACE_ATTR(ALC_STEREO_SOURCES, numStereo);
1724 if(numStereo > device->MaxNoOfSources)
1725 numStereo = device->MaxNoOfSources;
1727 numMono = device->MaxNoOfSources - numStereo;
1730 if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1732 numSends = attrList[attrIdx + 1];
1733 TRACE_ATTR(ALC_MAX_AUXILIARY_SENDS, numSends);
1736 if(attrList[attrIdx] == ALC_HRTF_SOFT)
1738 TRACE_ATTR(ALC_HRTF_SOFT, attrList[attrIdx + 1]);
1739 if(attrList[attrIdx + 1] == ALC_FALSE)
1740 hrtf_appreq = Hrtf_Disable;
1741 else if(attrList[attrIdx + 1] == ALC_TRUE)
1742 hrtf_appreq = Hrtf_Enable;
1743 else
1744 hrtf_appreq = Hrtf_Default;
1747 if(attrList[attrIdx] == ALC_HRTF_ID_SOFT)
1749 hrtf_id = attrList[attrIdx + 1];
1750 TRACE_ATTR(ALC_HRTF_ID_SOFT, hrtf_id);
1753 attrIdx += 2;
1755 #undef TRACE_ATTR
1757 if(gotFmt != GotAll)
1759 WARN("Missing format for loopback device\n");
1760 return ALC_INVALID_VALUE;
1763 ConfigValueUInt(NULL, NULL, "sends", &numSends);
1764 numSends = minu(MAX_SENDS, numSends);
1766 if((device->Flags&DEVICE_RUNNING))
1767 V0(device->Backend,stop)();
1768 device->Flags &= ~DEVICE_RUNNING;
1770 UpdateClockBase(device);
1772 device->Frequency = freq;
1773 device->FmtChans = schans;
1774 device->FmtType = stype;
1775 device->NumMonoSources = numMono;
1776 device->NumStereoSources = numStereo;
1777 device->NumAuxSends = numSends;
1779 else if(attrList && attrList[0])
1781 ALCuint freq, numMono, numStereo, numSends;
1782 ALCuint attrIdx = 0;
1784 /* If a context is already running on the device, stop playback so the
1785 * device attributes can be updated. */
1786 if((device->Flags&DEVICE_RUNNING))
1787 V0(device->Backend,stop)();
1788 device->Flags &= ~DEVICE_RUNNING;
1790 freq = device->Frequency;
1791 numMono = device->NumMonoSources;
1792 numStereo = device->NumStereoSources;
1793 numSends = device->NumAuxSends;
1795 #define TRACE_ATTR(a, v) TRACE("%s = %d\n", #a, v)
1796 while(attrList[attrIdx])
1798 if(attrList[attrIdx] == ALC_FREQUENCY)
1800 freq = attrList[attrIdx + 1];
1801 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1802 TRACE_ATTR(ALC_FREQUENCY, freq);
1805 if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1807 numStereo = attrList[attrIdx + 1];
1808 TRACE_ATTR(ALC_STEREO_SOURCES, numStereo);
1809 if(numStereo > device->MaxNoOfSources)
1810 numStereo = device->MaxNoOfSources;
1812 numMono = device->MaxNoOfSources - numStereo;
1815 if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1817 numSends = attrList[attrIdx + 1];
1818 TRACE_ATTR(ALC_MAX_AUXILIARY_SENDS, numSends);
1821 if(attrList[attrIdx] == ALC_HRTF_SOFT)
1823 TRACE_ATTR(ALC_HRTF_SOFT, attrList[attrIdx + 1]);
1824 if(attrList[attrIdx + 1] == ALC_FALSE)
1825 hrtf_appreq = Hrtf_Disable;
1826 else if(attrList[attrIdx + 1] == ALC_TRUE)
1827 hrtf_appreq = Hrtf_Enable;
1828 else
1829 hrtf_appreq = Hrtf_Default;
1832 if(attrList[attrIdx] == ALC_HRTF_ID_SOFT)
1834 hrtf_id = attrList[attrIdx + 1];
1835 TRACE_ATTR(ALC_HRTF_ID_SOFT, hrtf_id);
1838 attrIdx += 2;
1840 #undef TRACE_ATTR
1842 ConfigValueUInt(al_string_get_cstr(device->DeviceName), NULL, "frequency", &freq);
1843 freq = maxu(freq, MIN_OUTPUT_RATE);
1845 ConfigValueUInt(al_string_get_cstr(device->DeviceName), NULL, "sends", &numSends);
1846 numSends = minu(MAX_SENDS, numSends);
1848 UpdateClockBase(device);
1850 device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1851 device->Frequency;
1852 /* SSE and Neon do best with the update size being a multiple of 4 */
1853 if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
1854 device->UpdateSize = (device->UpdateSize+3)&~3;
1856 device->Frequency = freq;
1857 device->NumMonoSources = numMono;
1858 device->NumStereoSources = numStereo;
1859 device->NumAuxSends = numSends;
1862 if((device->Flags&DEVICE_RUNNING))
1863 return ALC_NO_ERROR;
1865 al_free(device->Uhj_Encoder);
1866 device->Uhj_Encoder = NULL;
1868 al_free(device->Bs2b);
1869 device->Bs2b = NULL;
1871 al_free(device->Dry.Buffer);
1872 device->Dry.Buffer = NULL;
1873 device->Dry.NumChannels = 0;
1874 device->VirtOut.Buffer = NULL;
1875 device->VirtOut.NumChannels = 0;
1876 device->RealOut.Buffer = NULL;
1877 device->RealOut.NumChannels = 0;
1879 UpdateClockBase(device);
1881 /*************************************************************************
1882 * Update device format request if HRTF is requested
1884 device->Hrtf_Status = ALC_HRTF_DISABLED_SOFT;
1885 if(device->Type != Loopback)
1887 const char *hrtf;
1888 if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "hrtf", &hrtf))
1890 if(strcasecmp(hrtf, "true") == 0)
1891 hrtf_userreq = Hrtf_Enable;
1892 else if(strcasecmp(hrtf, "false") == 0)
1893 hrtf_userreq = Hrtf_Disable;
1894 else if(strcasecmp(hrtf, "auto") != 0)
1895 ERR("Unexpected hrtf value: %s\n", hrtf);
1898 if(hrtf_userreq == Hrtf_Enable || (hrtf_userreq != Hrtf_Disable && hrtf_appreq == Hrtf_Enable))
1900 if(VECTOR_SIZE(device->Hrtf_List) == 0)
1902 VECTOR_DEINIT(device->Hrtf_List);
1903 device->Hrtf_List = EnumerateHrtf(device->DeviceName);
1905 if(VECTOR_SIZE(device->Hrtf_List) > 0)
1907 device->FmtChans = DevFmtStereo;
1908 if(hrtf_id >= 0 && (size_t)hrtf_id < VECTOR_SIZE(device->Hrtf_List))
1909 device->Frequency = GetHrtfSampleRate(VECTOR_ELEM(device->Hrtf_List, hrtf_id).hrtf);
1910 else
1911 device->Frequency = GetHrtfSampleRate(VECTOR_ELEM(device->Hrtf_List, 0).hrtf);
1912 device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_FREQUENCY_REQUEST;
1914 else
1916 hrtf_userreq = Hrtf_Default;
1917 hrtf_appreq = Hrtf_Disable;
1918 device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
1922 else if(hrtf_appreq == Hrtf_Enable)
1924 size_t i = VECTOR_SIZE(device->Hrtf_List);
1925 /* Loopback device. We don't need to match to a specific HRTF entry
1926 * here. If the requested ID matches, we'll pick that later, if not,
1927 * we'll try to auto-select one anyway. Just make sure one exists
1928 * that'll work.
1930 if(device->FmtChans == DevFmtStereo)
1932 if(VECTOR_SIZE(device->Hrtf_List) == 0)
1934 VECTOR_DEINIT(device->Hrtf_List);
1935 device->Hrtf_List = EnumerateHrtf(device->DeviceName);
1937 for(i = 0;i < VECTOR_SIZE(device->Hrtf_List);i++)
1939 const struct Hrtf *hrtf = VECTOR_ELEM(device->Hrtf_List, i).hrtf;
1940 if(GetHrtfSampleRate(hrtf) == device->Frequency)
1941 break;
1944 if(i == VECTOR_SIZE(device->Hrtf_List))
1946 ERR("Requested format not HRTF compatible: %s, %uhz\n",
1947 DevFmtChannelsString(device->FmtChans), device->Frequency);
1948 hrtf_appreq = Hrtf_Disable;
1949 device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
1953 oldFreq = device->Frequency;
1954 oldChans = device->FmtChans;
1955 oldType = device->FmtType;
1957 TRACE("Pre-reset: %s%s, %s%s, %s%uhz, %u update size x%d\n",
1958 (device->Flags&DEVICE_CHANNELS_REQUEST)?"*":"", DevFmtChannelsString(device->FmtChans),
1959 (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST)?"*":"", DevFmtTypeString(device->FmtType),
1960 (device->Flags&DEVICE_FREQUENCY_REQUEST)?"*":"", device->Frequency,
1961 device->UpdateSize, device->NumUpdates
1964 if(V0(device->Backend,reset)() == ALC_FALSE)
1965 return ALC_INVALID_DEVICE;
1967 if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
1969 ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
1970 DevFmtChannelsString(device->FmtChans));
1971 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
1973 if(device->FmtType != oldType && (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
1975 ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
1976 DevFmtTypeString(device->FmtType));
1977 device->Flags &= ~DEVICE_SAMPLE_TYPE_REQUEST;
1979 if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
1981 ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
1982 device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
1985 if((device->UpdateSize&3) != 0)
1987 if((CPUCapFlags&CPU_CAP_SSE))
1988 WARN("SSE performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
1989 if((CPUCapFlags&CPU_CAP_NEON))
1990 WARN("NEON performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
1993 TRACE("Post-reset: %s, %s, %uhz, %u update size x%d\n",
1994 DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
1995 device->Frequency, device->UpdateSize, device->NumUpdates
1998 aluInitRenderer(device, hrtf_id, hrtf_appreq, hrtf_userreq);
2000 /* Allocate extra channels for any post-filter output. */
2001 size = device->Dry.NumChannels * sizeof(device->Dry.Buffer[0]);
2002 if(device->AmbiDecoder && bformatdec_getOrder(device->AmbiDecoder) >= 2)
2003 size += (ChannelsFromDevFmt(device->FmtChans)+4) * sizeof(device->Dry.Buffer[0]);
2004 else if(device->Hrtf || device->Uhj_Encoder || device->AmbiDecoder)
2005 size += ChannelsFromDevFmt(device->FmtChans) * sizeof(device->Dry.Buffer[0]);
2006 device->Dry.Buffer = al_calloc(16, size);
2007 if(!device->Dry.Buffer)
2009 ERR("Failed to allocate "SZFMT" bytes for mix buffer\n", size);
2010 return ALC_INVALID_DEVICE;
2013 if(device->Hrtf || device->Uhj_Encoder || device->AmbiDecoder)
2015 device->VirtOut.Buffer = device->Dry.Buffer;
2016 device->VirtOut.NumChannels = device->Dry.NumChannels;
2017 device->RealOut.Buffer = device->Dry.Buffer + device->Dry.NumChannels;
2018 device->RealOut.NumChannels = ChannelsFromDevFmt(device->FmtChans);
2020 else
2022 device->VirtOut.Buffer = NULL;
2023 device->VirtOut.NumChannels = 0;
2024 device->RealOut.Buffer = device->Dry.Buffer;
2025 device->RealOut.NumChannels = device->Dry.NumChannels;
2028 if(device->AmbiDecoder && bformatdec_getOrder(device->AmbiDecoder) >= 2)
2030 /* Higher-order high quality decoding requires upsampling first-order
2031 * content, so make sure to mix it separately.
2033 device->FOAOut.Buffer = device->RealOut.Buffer + device->RealOut.NumChannels;
2034 device->FOAOut.NumChannels = 4;
2036 else
2038 device->FOAOut.Buffer = device->Dry.Buffer;
2039 device->FOAOut.NumChannels = device->Dry.NumChannels;
2042 SetMixerFPUMode(&oldMode);
2043 if(device->DefaultSlot)
2045 ALeffectslot *slot = device->DefaultSlot;
2046 ALeffectState *state = slot->Effect.State;
2048 state->OutBuffer = device->Dry.Buffer;
2049 state->OutChannels = device->Dry.NumChannels;
2050 if(V(state,deviceUpdate)(device) == AL_FALSE)
2052 RestoreFPUMode(&oldMode);
2053 return ALC_INVALID_DEVICE;
2055 UpdateEffectSlotProps(slot);
2058 context = ATOMIC_LOAD(&device->ContextList);
2059 while(context)
2061 ALsizei pos;
2063 ReadLock(&context->PropLock);
2064 LockUIntMapRead(&context->EffectSlotMap);
2065 for(pos = 0;pos < context->EffectSlotMap.size;pos++)
2067 ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
2068 ALeffectState *state = slot->Effect.State;
2070 state->OutBuffer = device->Dry.Buffer;
2071 state->OutChannels = device->Dry.NumChannels;
2072 if(V(state,deviceUpdate)(device) == AL_FALSE)
2074 UnlockUIntMapRead(&context->EffectSlotMap);
2075 ReadUnlock(&context->PropLock);
2076 RestoreFPUMode(&oldMode);
2077 return ALC_INVALID_DEVICE;
2080 UpdateEffectSlotProps(slot);
2082 UnlockUIntMapRead(&context->EffectSlotMap);
2084 LockUIntMapRead(&context->SourceMap);
2085 for(pos = 0;pos < context->SourceMap.size;pos++)
2087 ALsource *source = context->SourceMap.array[pos].value;
2088 ALuint s = device->NumAuxSends;
2089 while(s < MAX_SENDS)
2091 if(source->Send[s].Slot)
2092 DecrementRef(&source->Send[s].Slot->ref);
2093 source->Send[s].Slot = NULL;
2094 source->Send[s].Gain = 1.0f;
2095 source->Send[s].GainHF = 1.0f;
2096 source->Send[s].HFReference = LOWPASSFREQREF;
2097 source->Send[s].GainLF = 1.0f;
2098 source->Send[s].LFReference = HIGHPASSFREQREF;
2099 s++;
2102 UnlockUIntMapRead(&context->SourceMap);
2104 UpdateAllSourceProps(context);
2105 ReadUnlock(&context->PropLock);
2107 context = context->next;
2109 RestoreFPUMode(&oldMode);
2111 if(!(device->Flags&DEVICE_PAUSED))
2113 if(V0(device->Backend,start)() == ALC_FALSE)
2114 return ALC_INVALID_DEVICE;
2115 device->Flags |= DEVICE_RUNNING;
2118 return ALC_NO_ERROR;
2121 /* FreeDevice
2123 * Frees the device structure, and destroys any objects the app failed to
2124 * delete. Called once there's no more references on the device.
2126 static ALCvoid FreeDevice(ALCdevice *device)
2128 TRACE("%p\n", device);
2130 V0(device->Backend,close)();
2131 DELETE_OBJ(device->Backend);
2132 device->Backend = NULL;
2134 almtx_destroy(&device->BackendLock);
2136 if(device->DefaultSlot)
2138 DeinitEffectSlot(device->DefaultSlot);
2139 device->DefaultSlot = NULL;
2142 if(device->BufferMap.size > 0)
2144 WARN("(%p) Deleting %d Buffer%s\n", device, device->BufferMap.size,
2145 (device->BufferMap.size==1)?"":"s");
2146 ReleaseALBuffers(device);
2148 ResetUIntMap(&device->BufferMap);
2150 if(device->EffectMap.size > 0)
2152 WARN("(%p) Deleting %d Effect%s\n", device, device->EffectMap.size,
2153 (device->EffectMap.size==1)?"":"s");
2154 ReleaseALEffects(device);
2156 ResetUIntMap(&device->EffectMap);
2158 if(device->FilterMap.size > 0)
2160 WARN("(%p) Deleting %d Filter%s\n", device, device->FilterMap.size,
2161 (device->FilterMap.size==1)?"":"s");
2162 ReleaseALFilters(device);
2164 ResetUIntMap(&device->FilterMap);
2166 AL_STRING_DEINIT(device->Hrtf_Name);
2167 FreeHrtfList(&device->Hrtf_List);
2169 al_free(device->Bs2b);
2170 device->Bs2b = NULL;
2172 al_free(device->Uhj_Encoder);
2173 device->Uhj_Encoder = NULL;
2175 bformatdec_free(device->AmbiDecoder);
2176 device->AmbiDecoder = NULL;
2178 AL_STRING_DEINIT(device->DeviceName);
2180 al_free(device->Dry.Buffer);
2181 device->Dry.Buffer = NULL;
2182 device->Dry.NumChannels = 0;
2183 device->VirtOut.Buffer = NULL;
2184 device->VirtOut.NumChannels = 0;
2185 device->RealOut.Buffer = NULL;
2186 device->RealOut.NumChannels = 0;
2188 al_free(device);
2192 void ALCdevice_IncRef(ALCdevice *device)
2194 uint ref;
2195 ref = IncrementRef(&device->ref);
2196 TRACEREF("%p increasing refcount to %u\n", device, ref);
2199 void ALCdevice_DecRef(ALCdevice *device)
2201 uint ref;
2202 ref = DecrementRef(&device->ref);
2203 TRACEREF("%p decreasing refcount to %u\n", device, ref);
2204 if(ref == 0) FreeDevice(device);
2207 /* VerifyDevice
2209 * Checks if the device handle is valid, and increments its ref count if so.
2211 static ALCboolean VerifyDevice(ALCdevice **device)
2213 ALCdevice *tmpDevice;
2215 LockLists();
2216 tmpDevice = ATOMIC_LOAD(&DeviceList);
2217 while(tmpDevice)
2219 if(tmpDevice == *device)
2221 ALCdevice_IncRef(tmpDevice);
2222 UnlockLists();
2223 return ALC_TRUE;
2225 tmpDevice = tmpDevice->next;
2227 UnlockLists();
2229 *device = NULL;
2230 return ALC_FALSE;
2234 /* InitContext
2236 * Initializes context fields
2238 static ALvoid InitContext(ALCcontext *Context)
2240 ALlistener *listener = Context->Listener;
2242 //Initialise listener
2243 listener->Gain = 1.0f;
2244 listener->MetersPerUnit = 1.0f;
2245 listener->Position[0] = 0.0f;
2246 listener->Position[1] = 0.0f;
2247 listener->Position[2] = 0.0f;
2248 listener->Velocity[0] = 0.0f;
2249 listener->Velocity[1] = 0.0f;
2250 listener->Velocity[2] = 0.0f;
2251 listener->Forward[0] = 0.0f;
2252 listener->Forward[1] = 0.0f;
2253 listener->Forward[2] = -1.0f;
2254 listener->Up[0] = 0.0f;
2255 listener->Up[1] = 1.0f;
2256 listener->Up[2] = 0.0f;
2258 aluMatrixfSet(&listener->Params.Matrix,
2259 1.0f, 0.0f, 0.0f, 0.0f,
2260 0.0f, 1.0f, 0.0f, 0.0f,
2261 0.0f, 0.0f, 1.0f, 0.0f,
2262 0.0f, 0.0f, 0.0f, 1.0f
2264 aluVectorSet(&listener->Params.Velocity, 0.0f, 0.0f, 0.0f, 0.0f);
2265 listener->Params.Gain = 1.0f;
2266 listener->Params.MetersPerUnit = 1.0f;
2267 listener->Params.DopplerFactor = 1.0f;
2268 listener->Params.SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
2270 ATOMIC_INIT(&listener->Update, NULL);
2271 ATOMIC_INIT(&listener->FreeList, NULL);
2273 //Validate Context
2274 InitRef(&Context->UpdateCount, 0);
2275 ATOMIC_INIT(&Context->HoldUpdates, AL_FALSE);
2276 RWLockInit(&Context->PropLock);
2277 ATOMIC_INIT(&Context->LastError, AL_NO_ERROR);
2278 InitUIntMap(&Context->SourceMap, Context->Device->MaxNoOfSources);
2279 InitUIntMap(&Context->EffectSlotMap, Context->Device->AuxiliaryEffectSlotMax);
2281 //Set globals
2282 Context->DistanceModel = DefaultDistanceModel;
2283 Context->SourceDistanceModel = AL_FALSE;
2284 Context->DopplerFactor = 1.0f;
2285 Context->DopplerVelocity = 1.0f;
2286 Context->SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
2287 ATOMIC_INIT(&Context->DeferUpdates, AL_FALSE);
2289 Context->ExtensionList = alExtList;
2293 /* FreeContext
2295 * Cleans up the context, and destroys any remaining objects the app failed to
2296 * delete. Called once there's no more references on the context.
2298 static void FreeContext(ALCcontext *context)
2300 ALlistener *listener = context->Listener;
2301 struct ALlistenerProps *lprops;
2302 size_t count;
2304 TRACE("%p\n", context);
2306 if(context->SourceMap.size > 0)
2308 WARN("(%p) Deleting %d Source%s\n", context, context->SourceMap.size,
2309 (context->SourceMap.size==1)?"":"s");
2310 ReleaseALSources(context);
2312 ResetUIntMap(&context->SourceMap);
2314 if(context->EffectSlotMap.size > 0)
2316 WARN("(%p) Deleting %d AuxiliaryEffectSlot%s\n", context, context->EffectSlotMap.size,
2317 (context->EffectSlotMap.size==1)?"":"s");
2318 ReleaseALAuxiliaryEffectSlots(context);
2320 ResetUIntMap(&context->EffectSlotMap);
2322 al_free(context->Voices);
2323 context->Voices = NULL;
2324 context->VoiceCount = 0;
2325 context->MaxVoices = 0;
2327 VECTOR_DEINIT(context->ActiveAuxSlots);
2329 if((lprops=ATOMIC_LOAD(&listener->Update, almemory_order_acquire)) != NULL)
2331 TRACE("Freed unapplied listener update %p\n", lprops);
2332 al_free(lprops);
2334 count = 0;
2335 lprops = ATOMIC_LOAD(&listener->FreeList, almemory_order_consume);
2336 while(lprops)
2338 struct ALlistenerProps *next = ATOMIC_LOAD(&lprops->next, almemory_order_consume);
2339 al_free(lprops);
2340 lprops = next;
2341 ++count;
2343 TRACE("Freed "SZFMT" listener property object%s\n", count, (count==1)?"":"s");
2345 ALCdevice_DecRef(context->Device);
2346 context->Device = NULL;
2348 //Invalidate context
2349 memset(context, 0, sizeof(ALCcontext));
2350 al_free(context);
2353 /* ReleaseContext
2355 * Removes the context reference from the given device and removes it from
2356 * being current on the running thread or globally.
2358 static void ReleaseContext(ALCcontext *context, ALCdevice *device)
2360 ALCcontext *nextctx;
2361 ALCcontext *origctx;
2363 if(altss_get(LocalContext) == context)
2365 WARN("%p released while current on thread\n", context);
2366 altss_set(LocalContext, NULL);
2367 ALCcontext_DecRef(context);
2370 origctx = context;
2371 if(ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &GlobalContext, &origctx, NULL))
2372 ALCcontext_DecRef(context);
2374 ALCdevice_Lock(device);
2375 origctx = context;
2376 nextctx = context->next;
2377 if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &device->ContextList, &origctx, nextctx))
2379 ALCcontext *list;
2380 do {
2381 list = origctx;
2382 origctx = context;
2383 } while(!COMPARE_EXCHANGE(&list->next, &origctx, nextctx));
2385 ALCdevice_Unlock(device);
2387 ALCcontext_DecRef(context);
2390 void ALCcontext_IncRef(ALCcontext *context)
2392 uint ref;
2393 ref = IncrementRef(&context->ref);
2394 TRACEREF("%p increasing refcount to %u\n", context, ref);
2397 void ALCcontext_DecRef(ALCcontext *context)
2399 uint ref;
2400 ref = DecrementRef(&context->ref);
2401 TRACEREF("%p decreasing refcount to %u\n", context, ref);
2402 if(ref == 0) FreeContext(context);
2405 static void ReleaseThreadCtx(void *ptr)
2407 WARN("%p current for thread being destroyed\n", ptr);
2408 ALCcontext_DecRef(ptr);
2411 /* VerifyContext
2413 * Checks that the given context is valid, and increments its reference count.
2415 static ALCboolean VerifyContext(ALCcontext **context)
2417 ALCdevice *dev;
2419 LockLists();
2420 dev = ATOMIC_LOAD(&DeviceList);
2421 while(dev)
2423 ALCcontext *ctx = ATOMIC_LOAD(&dev->ContextList);
2424 while(ctx)
2426 if(ctx == *context)
2428 ALCcontext_IncRef(ctx);
2429 UnlockLists();
2430 return ALC_TRUE;
2432 ctx = ctx->next;
2434 dev = dev->next;
2436 UnlockLists();
2438 *context = NULL;
2439 return ALC_FALSE;
2443 /* GetContextRef
2445 * Returns the currently active context for this thread, and adds a reference
2446 * without locking it.
2448 ALCcontext *GetContextRef(void)
2450 ALCcontext *context;
2452 context = altss_get(LocalContext);
2453 if(context)
2454 ALCcontext_IncRef(context);
2455 else
2457 LockLists();
2458 context = ATOMIC_LOAD(&GlobalContext);
2459 if(context)
2460 ALCcontext_IncRef(context);
2461 UnlockLists();
2464 return context;
2468 /************************************************
2469 * Standard ALC functions
2470 ************************************************/
2472 /* alcGetError
2474 * Return last ALC generated error code for the given device
2476 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
2478 ALCenum errorCode;
2480 if(VerifyDevice(&device))
2482 errorCode = ATOMIC_EXCHANGE(ALCenum, &device->LastError, ALC_NO_ERROR);
2483 ALCdevice_DecRef(device);
2485 else
2486 errorCode = ATOMIC_EXCHANGE(ALCenum, &LastNullDeviceError, ALC_NO_ERROR);
2488 return errorCode;
2492 /* alcSuspendContext
2494 * Suspends updates for the given context
2496 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *context)
2498 if(!SuspendDefers)
2499 return;
2501 if(!VerifyContext(&context))
2502 alcSetError(NULL, ALC_INVALID_CONTEXT);
2503 else
2505 ALCcontext_DeferUpdates(context);
2506 ALCcontext_DecRef(context);
2510 /* alcProcessContext
2512 * Resumes processing updates for the given context
2514 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *context)
2516 if(!SuspendDefers)
2517 return;
2519 if(!VerifyContext(&context))
2520 alcSetError(NULL, ALC_INVALID_CONTEXT);
2521 else
2523 ALCcontext_ProcessUpdates(context);
2524 ALCcontext_DecRef(context);
2529 /* alcGetString
2531 * Returns information about the device, and error strings
2533 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
2535 const ALCchar *value = NULL;
2537 switch(param)
2539 case ALC_NO_ERROR:
2540 value = alcNoError;
2541 break;
2543 case ALC_INVALID_ENUM:
2544 value = alcErrInvalidEnum;
2545 break;
2547 case ALC_INVALID_VALUE:
2548 value = alcErrInvalidValue;
2549 break;
2551 case ALC_INVALID_DEVICE:
2552 value = alcErrInvalidDevice;
2553 break;
2555 case ALC_INVALID_CONTEXT:
2556 value = alcErrInvalidContext;
2557 break;
2559 case ALC_OUT_OF_MEMORY:
2560 value = alcErrOutOfMemory;
2561 break;
2563 case ALC_DEVICE_SPECIFIER:
2564 value = alcDefaultName;
2565 break;
2567 case ALC_ALL_DEVICES_SPECIFIER:
2568 if(VerifyDevice(&Device))
2570 value = al_string_get_cstr(Device->DeviceName);
2571 ALCdevice_DecRef(Device);
2573 else
2575 ProbeAllDevicesList();
2576 value = al_string_get_cstr(alcAllDevicesList);
2578 break;
2580 case ALC_CAPTURE_DEVICE_SPECIFIER:
2581 if(VerifyDevice(&Device))
2583 value = al_string_get_cstr(Device->DeviceName);
2584 ALCdevice_DecRef(Device);
2586 else
2588 ProbeCaptureDeviceList();
2589 value = al_string_get_cstr(alcCaptureDeviceList);
2591 break;
2593 /* Default devices are always first in the list */
2594 case ALC_DEFAULT_DEVICE_SPECIFIER:
2595 value = alcDefaultName;
2596 break;
2598 case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
2599 if(al_string_empty(alcAllDevicesList))
2600 ProbeAllDevicesList();
2602 VerifyDevice(&Device);
2604 free(alcDefaultAllDevicesSpecifier);
2605 alcDefaultAllDevicesSpecifier = strdup(al_string_get_cstr(alcAllDevicesList));
2606 if(!alcDefaultAllDevicesSpecifier)
2607 alcSetError(Device, ALC_OUT_OF_MEMORY);
2609 value = alcDefaultAllDevicesSpecifier;
2610 if(Device) ALCdevice_DecRef(Device);
2611 break;
2613 case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
2614 if(al_string_empty(alcCaptureDeviceList))
2615 ProbeCaptureDeviceList();
2617 VerifyDevice(&Device);
2619 free(alcCaptureDefaultDeviceSpecifier);
2620 alcCaptureDefaultDeviceSpecifier = strdup(al_string_get_cstr(alcCaptureDeviceList));
2621 if(!alcCaptureDefaultDeviceSpecifier)
2622 alcSetError(Device, ALC_OUT_OF_MEMORY);
2624 value = alcCaptureDefaultDeviceSpecifier;
2625 if(Device) ALCdevice_DecRef(Device);
2626 break;
2628 case ALC_EXTENSIONS:
2629 if(!VerifyDevice(&Device))
2630 value = alcNoDeviceExtList;
2631 else
2633 value = alcExtensionList;
2634 ALCdevice_DecRef(Device);
2636 break;
2638 case ALC_HRTF_SPECIFIER_SOFT:
2639 if(!VerifyDevice(&Device))
2640 alcSetError(NULL, ALC_INVALID_DEVICE);
2641 else
2643 almtx_lock(&Device->BackendLock);
2644 value = (Device->Hrtf ? al_string_get_cstr(Device->Hrtf_Name) : "");
2645 almtx_unlock(&Device->BackendLock);
2646 ALCdevice_DecRef(Device);
2648 break;
2650 default:
2651 VerifyDevice(&Device);
2652 alcSetError(Device, ALC_INVALID_ENUM);
2653 if(Device) ALCdevice_DecRef(Device);
2654 break;
2657 return value;
2661 static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
2663 ALCsizei i;
2665 if(size <= 0 || values == NULL)
2667 alcSetError(device, ALC_INVALID_VALUE);
2668 return 0;
2671 if(!device)
2673 switch(param)
2675 case ALC_MAJOR_VERSION:
2676 values[0] = alcMajorVersion;
2677 return 1;
2678 case ALC_MINOR_VERSION:
2679 values[0] = alcMinorVersion;
2680 return 1;
2682 case ALC_ATTRIBUTES_SIZE:
2683 case ALC_ALL_ATTRIBUTES:
2684 case ALC_FREQUENCY:
2685 case ALC_REFRESH:
2686 case ALC_SYNC:
2687 case ALC_MONO_SOURCES:
2688 case ALC_STEREO_SOURCES:
2689 case ALC_CAPTURE_SAMPLES:
2690 case ALC_FORMAT_CHANNELS_SOFT:
2691 case ALC_FORMAT_TYPE_SOFT:
2692 alcSetError(NULL, ALC_INVALID_DEVICE);
2693 return 0;
2695 default:
2696 alcSetError(NULL, ALC_INVALID_ENUM);
2697 return 0;
2699 return 0;
2702 if(device->Type == Capture)
2704 switch(param)
2706 case ALC_CAPTURE_SAMPLES:
2707 almtx_lock(&device->BackendLock);
2708 values[0] = V0(device->Backend,availableSamples)();
2709 almtx_unlock(&device->BackendLock);
2710 return 1;
2712 case ALC_CONNECTED:
2713 values[0] = device->Connected;
2714 return 1;
2716 default:
2717 alcSetError(device, ALC_INVALID_ENUM);
2718 return 0;
2720 return 0;
2723 /* render device */
2724 switch(param)
2726 case ALC_MAJOR_VERSION:
2727 values[0] = alcMajorVersion;
2728 return 1;
2730 case ALC_MINOR_VERSION:
2731 values[0] = alcMinorVersion;
2732 return 1;
2734 case ALC_EFX_MAJOR_VERSION:
2735 values[0] = alcEFXMajorVersion;
2736 return 1;
2738 case ALC_EFX_MINOR_VERSION:
2739 values[0] = alcEFXMinorVersion;
2740 return 1;
2742 case ALC_ATTRIBUTES_SIZE:
2743 values[0] = 17;
2744 return 1;
2746 case ALC_ALL_ATTRIBUTES:
2747 if(size < 17)
2749 alcSetError(device, ALC_INVALID_VALUE);
2750 return 0;
2753 i = 0;
2754 almtx_lock(&device->BackendLock);
2755 values[i++] = ALC_FREQUENCY;
2756 values[i++] = device->Frequency;
2758 if(device->Type != Loopback)
2760 values[i++] = ALC_REFRESH;
2761 values[i++] = device->Frequency / device->UpdateSize;
2763 values[i++] = ALC_SYNC;
2764 values[i++] = ALC_FALSE;
2766 else
2768 values[i++] = ALC_FORMAT_CHANNELS_SOFT;
2769 values[i++] = device->FmtChans;
2771 values[i++] = ALC_FORMAT_TYPE_SOFT;
2772 values[i++] = device->FmtType;
2775 values[i++] = ALC_MONO_SOURCES;
2776 values[i++] = device->NumMonoSources;
2778 values[i++] = ALC_STEREO_SOURCES;
2779 values[i++] = device->NumStereoSources;
2781 values[i++] = ALC_MAX_AUXILIARY_SENDS;
2782 values[i++] = device->NumAuxSends;
2784 values[i++] = ALC_HRTF_SOFT;
2785 values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2787 values[i++] = ALC_HRTF_STATUS_SOFT;
2788 values[i++] = device->Hrtf_Status;
2789 almtx_unlock(&device->BackendLock);
2791 values[i++] = 0;
2792 return i;
2794 case ALC_FREQUENCY:
2795 values[0] = device->Frequency;
2796 return 1;
2798 case ALC_REFRESH:
2799 if(device->Type == Loopback)
2801 alcSetError(device, ALC_INVALID_DEVICE);
2802 return 0;
2804 almtx_lock(&device->BackendLock);
2805 values[0] = device->Frequency / device->UpdateSize;
2806 almtx_unlock(&device->BackendLock);
2807 return 1;
2809 case ALC_SYNC:
2810 if(device->Type == Loopback)
2812 alcSetError(device, ALC_INVALID_DEVICE);
2813 return 0;
2815 values[0] = ALC_FALSE;
2816 return 1;
2818 case ALC_FORMAT_CHANNELS_SOFT:
2819 if(device->Type != Loopback)
2821 alcSetError(device, ALC_INVALID_DEVICE);
2822 return 0;
2824 values[0] = device->FmtChans;
2825 return 1;
2827 case ALC_FORMAT_TYPE_SOFT:
2828 if(device->Type != Loopback)
2830 alcSetError(device, ALC_INVALID_DEVICE);
2831 return 0;
2833 values[0] = device->FmtType;
2834 return 1;
2836 case ALC_MONO_SOURCES:
2837 values[0] = device->NumMonoSources;
2838 return 1;
2840 case ALC_STEREO_SOURCES:
2841 values[0] = device->NumStereoSources;
2842 return 1;
2844 case ALC_MAX_AUXILIARY_SENDS:
2845 values[0] = device->NumAuxSends;
2846 return 1;
2848 case ALC_CONNECTED:
2849 values[0] = device->Connected;
2850 return 1;
2852 case ALC_HRTF_SOFT:
2853 values[0] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2854 return 1;
2856 case ALC_HRTF_STATUS_SOFT:
2857 values[0] = device->Hrtf_Status;
2858 return 1;
2860 case ALC_NUM_HRTF_SPECIFIERS_SOFT:
2861 almtx_lock(&device->BackendLock);
2862 FreeHrtfList(&device->Hrtf_List);
2863 device->Hrtf_List = EnumerateHrtf(device->DeviceName);
2864 values[0] = (ALCint)VECTOR_SIZE(device->Hrtf_List);
2865 almtx_unlock(&device->BackendLock);
2866 return 1;
2868 default:
2869 alcSetError(device, ALC_INVALID_ENUM);
2870 return 0;
2872 return 0;
2875 /* alcGetIntegerv
2877 * Returns information about the device and the version of OpenAL
2879 ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
2881 VerifyDevice(&device);
2882 if(size <= 0 || values == NULL)
2883 alcSetError(device, ALC_INVALID_VALUE);
2884 else
2885 GetIntegerv(device, param, size, values);
2886 if(device) ALCdevice_DecRef(device);
2889 ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALCsizei size, ALCint64SOFT *values)
2891 ALCint *ivals;
2892 ALsizei i;
2894 VerifyDevice(&device);
2895 if(size <= 0 || values == NULL)
2896 alcSetError(device, ALC_INVALID_VALUE);
2897 else if(!device || device->Type == Capture)
2899 ivals = malloc(size * sizeof(ALCint));
2900 size = GetIntegerv(device, pname, size, ivals);
2901 for(i = 0;i < size;i++)
2902 values[i] = ivals[i];
2903 free(ivals);
2905 else /* render device */
2907 ALuint64 basecount;
2908 ALuint samplecount;
2909 ALuint refcount;
2911 switch(pname)
2913 case ALC_ATTRIBUTES_SIZE:
2914 *values = 19;
2915 break;
2917 case ALC_ALL_ATTRIBUTES:
2918 if(size < 19)
2919 alcSetError(device, ALC_INVALID_VALUE);
2920 else
2922 int i = 0;
2924 almtx_lock(&device->BackendLock);
2925 values[i++] = ALC_FREQUENCY;
2926 values[i++] = device->Frequency;
2928 if(device->Type != Loopback)
2930 values[i++] = ALC_REFRESH;
2931 values[i++] = device->Frequency / device->UpdateSize;
2933 values[i++] = ALC_SYNC;
2934 values[i++] = ALC_FALSE;
2936 else
2938 values[i++] = ALC_FORMAT_CHANNELS_SOFT;
2939 values[i++] = device->FmtChans;
2941 values[i++] = ALC_FORMAT_TYPE_SOFT;
2942 values[i++] = device->FmtType;
2945 values[i++] = ALC_MONO_SOURCES;
2946 values[i++] = device->NumMonoSources;
2948 values[i++] = ALC_STEREO_SOURCES;
2949 values[i++] = device->NumStereoSources;
2951 values[i++] = ALC_MAX_AUXILIARY_SENDS;
2952 values[i++] = device->NumAuxSends;
2954 values[i++] = ALC_HRTF_SOFT;
2955 values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2957 values[i++] = ALC_HRTF_STATUS_SOFT;
2958 values[i++] = device->Hrtf_Status;
2960 values[i++] = ALC_DEVICE_CLOCK_SOFT;
2961 do {
2962 while(((refcount=ReadRef(&device->MixCount))&1) != 0)
2963 althrd_yield();
2964 basecount = device->ClockBase;
2965 samplecount = device->SamplesDone;
2966 } while(refcount != ReadRef(&device->MixCount));
2967 values[i++] = basecount + (samplecount*DEVICE_CLOCK_RES/device->Frequency);
2968 almtx_unlock(&device->BackendLock);
2970 values[i++] = 0;
2972 break;
2974 case ALC_DEVICE_CLOCK_SOFT:
2975 almtx_lock(&device->BackendLock);
2976 do {
2977 while(((refcount=ReadRef(&device->MixCount))&1) != 0)
2978 althrd_yield();
2979 basecount = device->ClockBase;
2980 samplecount = device->SamplesDone;
2981 } while(refcount != ReadRef(&device->MixCount));
2982 *values = basecount + (samplecount*DEVICE_CLOCK_RES/device->Frequency);
2983 almtx_unlock(&device->BackendLock);
2984 break;
2986 default:
2987 ivals = malloc(size * sizeof(ALCint));
2988 size = GetIntegerv(device, pname, size, ivals);
2989 for(i = 0;i < size;i++)
2990 values[i] = ivals[i];
2991 free(ivals);
2992 break;
2995 if(device)
2996 ALCdevice_DecRef(device);
3000 /* alcIsExtensionPresent
3002 * Determines if there is support for a particular extension
3004 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
3006 ALCboolean bResult = ALC_FALSE;
3008 VerifyDevice(&device);
3010 if(!extName)
3011 alcSetError(device, ALC_INVALID_VALUE);
3012 else
3014 size_t len = strlen(extName);
3015 const char *ptr = (device ? alcExtensionList : alcNoDeviceExtList);
3016 while(ptr && *ptr)
3018 if(strncasecmp(ptr, extName, len) == 0 &&
3019 (ptr[len] == '\0' || isspace(ptr[len])))
3021 bResult = ALC_TRUE;
3022 break;
3024 if((ptr=strchr(ptr, ' ')) != NULL)
3026 do {
3027 ++ptr;
3028 } while(isspace(*ptr));
3032 if(device)
3033 ALCdevice_DecRef(device);
3034 return bResult;
3038 /* alcGetProcAddress
3040 * Retrieves the function address for a particular extension function
3042 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
3044 ALCvoid *ptr = NULL;
3046 if(!funcName)
3048 VerifyDevice(&device);
3049 alcSetError(device, ALC_INVALID_VALUE);
3050 if(device) ALCdevice_DecRef(device);
3052 else
3054 ALsizei i = 0;
3055 while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName, funcName) != 0)
3056 i++;
3057 ptr = alcFunctions[i].address;
3060 return ptr;
3064 /* alcGetEnumValue
3066 * Get the value for a particular ALC enumeration name
3068 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
3070 ALCenum val = 0;
3072 if(!enumName)
3074 VerifyDevice(&device);
3075 alcSetError(device, ALC_INVALID_VALUE);
3076 if(device) ALCdevice_DecRef(device);
3078 else
3080 ALsizei i = 0;
3081 while(enumeration[i].enumName && strcmp(enumeration[i].enumName, enumName) != 0)
3082 i++;
3083 val = enumeration[i].value;
3086 return val;
3090 /* alcCreateContext
3092 * Create and attach a context to the given device.
3094 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
3096 ALCcontext *ALContext;
3097 ALCenum err;
3099 LockLists();
3100 if(!VerifyDevice(&device) || device->Type == Capture || !device->Connected)
3102 UnlockLists();
3103 alcSetError(device, ALC_INVALID_DEVICE);
3104 if(device) ALCdevice_DecRef(device);
3105 return NULL;
3107 almtx_lock(&device->BackendLock);
3108 UnlockLists();
3110 ATOMIC_STORE(&device->LastError, ALC_NO_ERROR);
3112 ALContext = al_calloc(16, sizeof(ALCcontext)+sizeof(ALlistener));
3113 if(ALContext)
3115 InitRef(&ALContext->ref, 1);
3116 ALContext->Listener = (ALlistener*)ALContext->_listener_mem;
3118 VECTOR_INIT(ALContext->ActiveAuxSlots);
3120 ALContext->VoiceCount = 0;
3121 ALContext->MaxVoices = 256;
3122 ALContext->Voices = al_calloc(16, ALContext->MaxVoices * sizeof(ALContext->Voices[0]));
3124 if(!ALContext || !ALContext->Voices)
3126 almtx_unlock(&device->BackendLock);
3128 if(ALContext)
3130 al_free(ALContext->Voices);
3131 ALContext->Voices = NULL;
3133 VECTOR_DEINIT(ALContext->ActiveAuxSlots);
3135 al_free(ALContext);
3136 ALContext = NULL;
3139 alcSetError(device, ALC_OUT_OF_MEMORY);
3140 ALCdevice_DecRef(device);
3141 return NULL;
3144 if((err=UpdateDeviceParams(device, attrList)) != ALC_NO_ERROR)
3146 almtx_unlock(&device->BackendLock);
3148 al_free(ALContext->Voices);
3149 ALContext->Voices = NULL;
3151 VECTOR_DEINIT(ALContext->ActiveAuxSlots);
3153 al_free(ALContext);
3154 ALContext = NULL;
3156 alcSetError(device, err);
3157 if(err == ALC_INVALID_DEVICE)
3159 V0(device->Backend,lock)();
3160 aluHandleDisconnect(device);
3161 V0(device->Backend,unlock)();
3163 ALCdevice_DecRef(device);
3164 return NULL;
3167 ALContext->Device = device;
3168 ALCdevice_IncRef(device);
3169 InitContext(ALContext);
3172 ALCcontext *head = ATOMIC_LOAD(&device->ContextList);
3173 do {
3174 ALContext->next = head;
3175 } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCcontext*, &device->ContextList, &head, ALContext));
3177 almtx_unlock(&device->BackendLock);
3179 ALCdevice_DecRef(device);
3181 TRACE("Created context %p\n", ALContext);
3182 return ALContext;
3185 /* alcDestroyContext
3187 * Remove a context from its device
3189 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
3191 ALCdevice *Device;
3193 LockLists();
3194 /* alcGetContextsDevice sets an error for invalid contexts */
3195 Device = alcGetContextsDevice(context);
3196 if(Device)
3198 almtx_lock(&Device->BackendLock);
3199 ReleaseContext(context, Device);
3200 if(!ATOMIC_LOAD(&Device->ContextList))
3202 V0(Device->Backend,stop)();
3203 Device->Flags &= ~DEVICE_RUNNING;
3205 almtx_unlock(&Device->BackendLock);
3207 UnlockLists();
3211 /* alcGetCurrentContext
3213 * Returns the currently active context on the calling thread
3215 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
3217 ALCcontext *Context = altss_get(LocalContext);
3218 if(!Context) Context = ATOMIC_LOAD(&GlobalContext);
3219 return Context;
3222 /* alcGetThreadContext
3224 * Returns the currently active thread-local context
3226 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
3228 return altss_get(LocalContext);
3232 /* alcMakeContextCurrent
3234 * Makes the given context the active process-wide context, and removes the
3235 * thread-local context for the calling thread.
3237 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
3239 /* context must be valid or NULL */
3240 if(context && !VerifyContext(&context))
3242 alcSetError(NULL, ALC_INVALID_CONTEXT);
3243 return ALC_FALSE;
3245 /* context's reference count is already incremented */
3246 context = ATOMIC_EXCHANGE(ALCcontext*, &GlobalContext, context);
3247 if(context) ALCcontext_DecRef(context);
3249 if((context=altss_get(LocalContext)) != NULL)
3251 altss_set(LocalContext, NULL);
3252 ALCcontext_DecRef(context);
3255 return ALC_TRUE;
3258 /* alcSetThreadContext
3260 * Makes the given context the active context for the current thread
3262 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
3264 ALCcontext *old;
3266 /* context must be valid or NULL */
3267 if(context && !VerifyContext(&context))
3269 alcSetError(NULL, ALC_INVALID_CONTEXT);
3270 return ALC_FALSE;
3272 /* context's reference count is already incremented */
3273 old = altss_get(LocalContext);
3274 altss_set(LocalContext, context);
3275 if(old) ALCcontext_DecRef(old);
3277 return ALC_TRUE;
3281 /* alcGetContextsDevice
3283 * Returns the device that a particular context is attached to
3285 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
3287 ALCdevice *Device;
3289 if(!VerifyContext(&Context))
3291 alcSetError(NULL, ALC_INVALID_CONTEXT);
3292 return NULL;
3294 Device = Context->Device;
3295 ALCcontext_DecRef(Context);
3297 return Device;
3301 /* alcOpenDevice
3303 * Opens the named device.
3305 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
3307 const ALCchar *fmt;
3308 ALCdevice *device;
3309 ALCenum err;
3311 DO_INITCONFIG();
3313 if(!PlaybackBackend.name)
3315 alcSetError(NULL, ALC_INVALID_VALUE);
3316 return NULL;
3319 if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0
3320 #ifdef _WIN32
3321 /* Some old Windows apps hardcode these expecting OpenAL to use a
3322 * specific audio API, even when they're not enumerated. Creative's
3323 * router effectively ignores them too.
3325 || strcasecmp(deviceName, "DirectSound3D") == 0 || strcasecmp(deviceName, "DirectSound") == 0
3326 || strcasecmp(deviceName, "MMSYSTEM") == 0
3327 #endif
3329 deviceName = NULL;
3331 device = al_calloc(16, sizeof(ALCdevice)+sizeof(ALeffectslot));
3332 if(!device)
3334 alcSetError(NULL, ALC_OUT_OF_MEMORY);
3335 return NULL;
3338 //Validate device
3339 InitRef(&device->ref, 1);
3340 device->Connected = ALC_TRUE;
3341 device->Type = Playback;
3342 ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
3344 device->Flags = 0;
3345 device->Bs2b = NULL;
3346 device->Uhj_Encoder = NULL;
3347 VECTOR_INIT(device->Hrtf_List);
3348 AL_STRING_INIT(device->Hrtf_Name);
3349 device->Render_Mode = NormalRender;
3350 AL_STRING_INIT(device->DeviceName);
3351 device->Dry.Buffer = NULL;
3352 device->Dry.NumChannels = 0;
3353 device->VirtOut.Buffer = NULL;
3354 device->VirtOut.NumChannels = 0;
3355 device->RealOut.Buffer = NULL;
3356 device->RealOut.NumChannels = 0;
3358 ATOMIC_INIT(&device->ContextList, NULL);
3360 device->ClockBase = 0;
3361 device->SamplesDone = 0;
3363 device->MaxNoOfSources = 256;
3364 device->AuxiliaryEffectSlotMax = 4;
3365 device->NumAuxSends = MAX_SENDS;
3367 InitUIntMap(&device->BufferMap, ~0);
3368 InitUIntMap(&device->EffectMap, ~0);
3369 InitUIntMap(&device->FilterMap, ~0);
3371 //Set output format
3372 device->FmtChans = DevFmtChannelsDefault;
3373 device->FmtType = DevFmtTypeDefault;
3374 device->Frequency = DEFAULT_OUTPUT_RATE;
3375 device->IsHeadphones = AL_FALSE;
3376 device->NumUpdates = 4;
3377 device->UpdateSize = 1024;
3379 if(!PlaybackBackend.getFactory)
3380 device->Backend = create_backend_wrapper(device, &PlaybackBackend.Funcs,
3381 ALCbackend_Playback);
3382 else
3384 ALCbackendFactory *factory = PlaybackBackend.getFactory();
3385 device->Backend = V(factory,createBackend)(device, ALCbackend_Playback);
3387 if(!device->Backend)
3389 al_free(device);
3390 alcSetError(NULL, ALC_OUT_OF_MEMORY);
3391 return NULL;
3395 if(ConfigValueStr(deviceName, NULL, "channels", &fmt))
3397 static const struct {
3398 const char name[16];
3399 enum DevFmtChannels chans;
3400 } chanlist[] = {
3401 { "mono", DevFmtMono },
3402 { "stereo", DevFmtStereo },
3403 { "quad", DevFmtQuad },
3404 { "surround51", DevFmtX51 },
3405 { "surround61", DevFmtX61 },
3406 { "surround71", DevFmtX71 },
3407 { "surround51rear", DevFmtX51Rear },
3409 size_t i;
3411 for(i = 0;i < COUNTOF(chanlist);i++)
3413 if(strcasecmp(chanlist[i].name, fmt) == 0)
3415 device->FmtChans = chanlist[i].chans;
3416 device->Flags |= DEVICE_CHANNELS_REQUEST;
3417 break;
3420 if(i == COUNTOF(chanlist))
3421 ERR("Unsupported channels: %s\n", fmt);
3423 if(ConfigValueStr(deviceName, NULL, "sample-type", &fmt))
3425 static const struct {
3426 const char name[16];
3427 enum DevFmtType type;
3428 } typelist[] = {
3429 { "int8", DevFmtByte },
3430 { "uint8", DevFmtUByte },
3431 { "int16", DevFmtShort },
3432 { "uint16", DevFmtUShort },
3433 { "int32", DevFmtInt },
3434 { "uint32", DevFmtUInt },
3435 { "float32", DevFmtFloat },
3437 size_t i;
3439 for(i = 0;i < COUNTOF(typelist);i++)
3441 if(strcasecmp(typelist[i].name, fmt) == 0)
3443 device->FmtType = typelist[i].type;
3444 device->Flags |= DEVICE_SAMPLE_TYPE_REQUEST;
3445 break;
3448 if(i == COUNTOF(typelist))
3449 ERR("Unsupported sample-type: %s\n", fmt);
3452 if(ConfigValueUInt(deviceName, NULL, "frequency", &device->Frequency))
3454 device->Flags |= DEVICE_FREQUENCY_REQUEST;
3455 if(device->Frequency < MIN_OUTPUT_RATE)
3456 ERR("%uhz request clamped to %uhz minimum\n", device->Frequency, MIN_OUTPUT_RATE);
3457 device->Frequency = maxu(device->Frequency, MIN_OUTPUT_RATE);
3460 ConfigValueUInt(deviceName, NULL, "periods", &device->NumUpdates);
3461 device->NumUpdates = clampu(device->NumUpdates, 2, 16);
3463 ConfigValueUInt(deviceName, NULL, "period_size", &device->UpdateSize);
3464 device->UpdateSize = clampu(device->UpdateSize, 64, 8192);
3465 if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
3466 device->UpdateSize = (device->UpdateSize+3)&~3;
3468 ConfigValueUInt(deviceName, NULL, "sources", &device->MaxNoOfSources);
3469 if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
3471 ConfigValueUInt(deviceName, NULL, "slots", &device->AuxiliaryEffectSlotMax);
3472 if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
3474 ConfigValueUInt(deviceName, NULL, "sends", &device->NumAuxSends);
3475 if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
3477 device->NumStereoSources = 1;
3478 device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
3480 // Find a playback device to open
3481 if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
3483 DELETE_OBJ(device->Backend);
3484 al_free(device);
3485 alcSetError(NULL, err);
3486 return NULL;
3488 almtx_init(&device->BackendLock, almtx_plain);
3490 if(DefaultEffect.type != AL_EFFECT_NULL)
3492 device->DefaultSlot = (ALeffectslot*)device->_slot_mem;
3493 if(InitEffectSlot(device->DefaultSlot) != AL_NO_ERROR)
3495 device->DefaultSlot = NULL;
3496 ERR("Failed to initialize the default effect slot\n");
3498 else
3500 aluInitEffectPanning(device->DefaultSlot);
3501 if(InitializeEffect(device, device->DefaultSlot, &DefaultEffect) != AL_NO_ERROR)
3503 DeinitEffectSlot(device->DefaultSlot);
3504 device->DefaultSlot = NULL;
3505 ERR("Failed to initialize the default effect\n");
3511 ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3512 do {
3513 device->next = head;
3514 } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3517 TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
3518 return device;
3521 /* alcCloseDevice
3523 * Closes the given device.
3525 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
3527 ALCdevice *list, *origdev, *nextdev;
3528 ALCcontext *ctx;
3530 LockLists();
3531 list = ATOMIC_LOAD(&DeviceList);
3532 do {
3533 if(list == device)
3534 break;
3535 } while((list=list->next) != NULL);
3536 if(!list || list->Type == Capture)
3538 alcSetError(list, ALC_INVALID_DEVICE);
3539 UnlockLists();
3540 return ALC_FALSE;
3542 almtx_lock(&device->BackendLock);
3544 origdev = device;
3545 nextdev = device->next;
3546 if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &origdev, nextdev))
3548 do {
3549 list = origdev;
3550 origdev = device;
3551 } while(!COMPARE_EXCHANGE(&list->next, &origdev, nextdev));
3553 UnlockLists();
3555 ctx = ATOMIC_LOAD(&device->ContextList);
3556 while(ctx != NULL)
3558 ALCcontext *next = ctx->next;
3559 WARN("Releasing context %p\n", ctx);
3560 ReleaseContext(ctx, device);
3561 ctx = next;
3563 if((device->Flags&DEVICE_RUNNING))
3564 V0(device->Backend,stop)();
3565 device->Flags &= ~DEVICE_RUNNING;
3566 almtx_unlock(&device->BackendLock);
3568 ALCdevice_DecRef(device);
3570 return ALC_TRUE;
3574 /************************************************
3575 * ALC capture functions
3576 ************************************************/
3577 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
3579 ALCdevice *device = NULL;
3580 ALCenum err;
3582 DO_INITCONFIG();
3584 if(!CaptureBackend.name)
3586 alcSetError(NULL, ALC_INVALID_VALUE);
3587 return NULL;
3590 if(samples <= 0)
3592 alcSetError(NULL, ALC_INVALID_VALUE);
3593 return NULL;
3596 if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
3597 deviceName = NULL;
3599 device = al_calloc(16, sizeof(ALCdevice));
3600 if(!device)
3602 alcSetError(NULL, ALC_OUT_OF_MEMORY);
3603 return NULL;
3606 //Validate device
3607 InitRef(&device->ref, 1);
3608 device->Connected = ALC_TRUE;
3609 device->Type = Capture;
3611 VECTOR_INIT(device->Hrtf_List);
3612 AL_STRING_INIT(device->Hrtf_Name);
3614 AL_STRING_INIT(device->DeviceName);
3615 device->Dry.Buffer = NULL;
3616 device->Dry.NumChannels = 0;
3617 device->VirtOut.Buffer = NULL;
3618 device->VirtOut.NumChannels = 0;
3619 device->RealOut.Buffer = NULL;
3620 device->RealOut.NumChannels = 0;
3622 InitUIntMap(&device->BufferMap, ~0);
3623 InitUIntMap(&device->EffectMap, ~0);
3624 InitUIntMap(&device->FilterMap, ~0);
3626 if(!CaptureBackend.getFactory)
3627 device->Backend = create_backend_wrapper(device, &CaptureBackend.Funcs,
3628 ALCbackend_Capture);
3629 else
3631 ALCbackendFactory *factory = CaptureBackend.getFactory();
3632 device->Backend = V(factory,createBackend)(device, ALCbackend_Capture);
3634 if(!device->Backend)
3636 al_free(device);
3637 alcSetError(NULL, ALC_OUT_OF_MEMORY);
3638 return NULL;
3641 device->Flags |= DEVICE_FREQUENCY_REQUEST;
3642 device->Frequency = frequency;
3644 device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_SAMPLE_TYPE_REQUEST;
3645 if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
3647 al_free(device);
3648 alcSetError(NULL, ALC_INVALID_ENUM);
3649 return NULL;
3651 device->IsHeadphones = AL_FALSE;
3653 device->UpdateSize = samples;
3654 device->NumUpdates = 1;
3656 if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
3658 al_free(device);
3659 alcSetError(NULL, err);
3660 return NULL;
3662 almtx_init(&device->BackendLock, almtx_plain);
3665 ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3666 do {
3667 device->next = head;
3668 } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3671 TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
3672 return device;
3675 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device)
3677 ALCdevice *list, *next, *nextdev;
3679 LockLists();
3680 list = ATOMIC_LOAD(&DeviceList);
3681 do {
3682 if(list == device)
3683 break;
3684 } while((list=list->next) != NULL);
3685 if(!list || list->Type != Capture)
3687 alcSetError(list, ALC_INVALID_DEVICE);
3688 UnlockLists();
3689 return ALC_FALSE;
3692 next = device;
3693 nextdev = device->next;
3694 if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &next, nextdev))
3696 do {
3697 list = next;
3698 next = device;
3699 } while(!COMPARE_EXCHANGE(&list->next, &next, nextdev));
3701 UnlockLists();
3703 ALCdevice_DecRef(device);
3705 return ALC_TRUE;
3708 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
3710 if(!VerifyDevice(&device) || device->Type != Capture)
3711 alcSetError(device, ALC_INVALID_DEVICE);
3712 else
3714 almtx_lock(&device->BackendLock);
3715 if(!device->Connected)
3716 alcSetError(device, ALC_INVALID_DEVICE);
3717 else if(!(device->Flags&DEVICE_RUNNING))
3719 if(V0(device->Backend,start)())
3720 device->Flags |= DEVICE_RUNNING;
3721 else
3723 aluHandleDisconnect(device);
3724 alcSetError(device, ALC_INVALID_DEVICE);
3727 almtx_unlock(&device->BackendLock);
3730 if(device) ALCdevice_DecRef(device);
3733 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
3735 if(!VerifyDevice(&device) || device->Type != Capture)
3736 alcSetError(device, ALC_INVALID_DEVICE);
3737 else
3739 almtx_lock(&device->BackendLock);
3740 if((device->Flags&DEVICE_RUNNING))
3741 V0(device->Backend,stop)();
3742 device->Flags &= ~DEVICE_RUNNING;
3743 almtx_unlock(&device->BackendLock);
3746 if(device) ALCdevice_DecRef(device);
3749 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
3751 if(!VerifyDevice(&device) || device->Type != Capture)
3752 alcSetError(device, ALC_INVALID_DEVICE);
3753 else
3755 ALCenum err = ALC_INVALID_VALUE;
3757 almtx_lock(&device->BackendLock);
3758 if(samples >= 0 && V0(device->Backend,availableSamples)() >= (ALCuint)samples)
3759 err = V(device->Backend,captureSamples)(buffer, samples);
3760 almtx_unlock(&device->BackendLock);
3762 if(err != ALC_NO_ERROR)
3763 alcSetError(device, err);
3765 if(device) ALCdevice_DecRef(device);
3769 /************************************************
3770 * ALC loopback functions
3771 ************************************************/
3773 /* alcLoopbackOpenDeviceSOFT
3775 * Open a loopback device, for manual rendering.
3777 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
3779 ALCbackendFactory *factory;
3780 ALCdevice *device;
3782 DO_INITCONFIG();
3784 /* Make sure the device name, if specified, is us. */
3785 if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
3787 alcSetError(NULL, ALC_INVALID_VALUE);
3788 return NULL;
3791 device = al_calloc(16, sizeof(ALCdevice));
3792 if(!device)
3794 alcSetError(NULL, ALC_OUT_OF_MEMORY);
3795 return NULL;
3798 //Validate device
3799 InitRef(&device->ref, 1);
3800 device->Connected = ALC_TRUE;
3801 device->Type = Loopback;
3802 ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
3804 device->Flags = 0;
3805 VECTOR_INIT(device->Hrtf_List);
3806 AL_STRING_INIT(device->Hrtf_Name);
3807 device->Bs2b = NULL;
3808 device->Uhj_Encoder = NULL;
3809 device->Render_Mode = NormalRender;
3810 AL_STRING_INIT(device->DeviceName);
3811 device->Dry.Buffer = NULL;
3812 device->Dry.NumChannels = 0;
3813 device->VirtOut.Buffer = NULL;
3814 device->VirtOut.NumChannels = 0;
3815 device->RealOut.Buffer = NULL;
3816 device->RealOut.NumChannels = 0;
3818 ATOMIC_INIT(&device->ContextList, NULL);
3820 device->ClockBase = 0;
3821 device->SamplesDone = 0;
3823 device->MaxNoOfSources = 256;
3824 device->AuxiliaryEffectSlotMax = 4;
3825 device->NumAuxSends = MAX_SENDS;
3827 InitUIntMap(&device->BufferMap, ~0);
3828 InitUIntMap(&device->EffectMap, ~0);
3829 InitUIntMap(&device->FilterMap, ~0);
3831 factory = ALCloopbackFactory_getFactory();
3832 device->Backend = V(factory,createBackend)(device, ALCbackend_Loopback);
3833 if(!device->Backend)
3835 al_free(device);
3836 alcSetError(NULL, ALC_OUT_OF_MEMORY);
3837 return NULL;
3839 almtx_init(&device->BackendLock, almtx_plain);
3841 //Set output format
3842 device->NumUpdates = 0;
3843 device->UpdateSize = 0;
3845 device->Frequency = DEFAULT_OUTPUT_RATE;
3846 device->FmtChans = DevFmtChannelsDefault;
3847 device->FmtType = DevFmtTypeDefault;
3848 device->IsHeadphones = AL_FALSE;
3850 ConfigValueUInt(NULL, NULL, "sources", &device->MaxNoOfSources);
3851 if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
3853 ConfigValueUInt(NULL, NULL, "slots", &device->AuxiliaryEffectSlotMax);
3854 if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
3856 ConfigValueUInt(NULL, NULL, "sends", &device->NumAuxSends);
3857 if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
3859 device->NumStereoSources = 1;
3860 device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
3862 // Open the "backend"
3863 V(device->Backend,open)("Loopback");
3866 ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3867 do {
3868 device->next = head;
3869 } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3872 TRACE("Created device %p\n", device);
3873 return device;
3876 /* alcIsRenderFormatSupportedSOFT
3878 * Determines if the loopback device supports the given format for rendering.
3880 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
3882 ALCboolean ret = ALC_FALSE;
3884 if(!VerifyDevice(&device) || device->Type != Loopback)
3885 alcSetError(device, ALC_INVALID_DEVICE);
3886 else if(freq <= 0)
3887 alcSetError(device, ALC_INVALID_VALUE);
3888 else
3890 if(IsValidALCType(type) && BytesFromDevFmt(type) > 0 &&
3891 IsValidALCChannels(channels) && ChannelsFromDevFmt(channels) > 0 &&
3892 freq >= MIN_OUTPUT_RATE)
3893 ret = ALC_TRUE;
3895 if(device) ALCdevice_DecRef(device);
3897 return ret;
3900 /* alcRenderSamplesSOFT
3902 * Renders some samples into a buffer, using the format last set by the
3903 * attributes given to alcCreateContext.
3905 FORCE_ALIGN ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
3907 if(!VerifyDevice(&device) || device->Type != Loopback)
3908 alcSetError(device, ALC_INVALID_DEVICE);
3909 else if(samples < 0 || (samples > 0 && buffer == NULL))
3910 alcSetError(device, ALC_INVALID_VALUE);
3911 else
3912 aluMixData(device, buffer, samples);
3913 if(device) ALCdevice_DecRef(device);
3917 /************************************************
3918 * ALC DSP pause/resume functions
3919 ************************************************/
3921 /* alcDevicePauseSOFT
3923 * Pause the DSP to stop audio processing.
3925 ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device)
3927 if(!VerifyDevice(&device) || device->Type != Playback)
3928 alcSetError(device, ALC_INVALID_DEVICE);
3929 else
3931 almtx_lock(&device->BackendLock);
3932 if((device->Flags&DEVICE_RUNNING))
3933 V0(device->Backend,stop)();
3934 device->Flags &= ~DEVICE_RUNNING;
3935 device->Flags |= DEVICE_PAUSED;
3936 almtx_unlock(&device->BackendLock);
3938 if(device) ALCdevice_DecRef(device);
3941 /* alcDeviceResumeSOFT
3943 * Resume the DSP to restart audio processing.
3945 ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device)
3947 if(!VerifyDevice(&device) || device->Type != Playback)
3948 alcSetError(device, ALC_INVALID_DEVICE);
3949 else
3951 almtx_lock(&device->BackendLock);
3952 if((device->Flags&DEVICE_PAUSED))
3954 device->Flags &= ~DEVICE_PAUSED;
3955 if(ATOMIC_LOAD(&device->ContextList) != NULL)
3957 if(V0(device->Backend,start)() != ALC_FALSE)
3958 device->Flags |= DEVICE_RUNNING;
3959 else
3961 alcSetError(device, ALC_INVALID_DEVICE);
3962 V0(device->Backend,lock)();
3963 aluHandleDisconnect(device);
3964 V0(device->Backend,unlock)();
3968 almtx_unlock(&device->BackendLock);
3970 if(device) ALCdevice_DecRef(device);
3974 /************************************************
3975 * ALC HRTF functions
3976 ************************************************/
3978 /* alcGetStringiSOFT
3980 * Gets a string parameter at the given index.
3982 ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum paramName, ALCsizei index)
3984 const ALCchar *str = NULL;
3986 if(!VerifyDevice(&device) || device->Type == Capture)
3987 alcSetError(device, ALC_INVALID_DEVICE);
3988 else switch(paramName)
3990 case ALC_HRTF_SPECIFIER_SOFT:
3991 if(index >= 0 && (size_t)index < VECTOR_SIZE(device->Hrtf_List))
3992 str = al_string_get_cstr(VECTOR_ELEM(device->Hrtf_List, index).name);
3993 else
3994 alcSetError(device, ALC_INVALID_VALUE);
3995 break;
3997 default:
3998 alcSetError(device, ALC_INVALID_ENUM);
3999 break;
4001 if(device) ALCdevice_DecRef(device);
4003 return str;
4006 /* alcResetDeviceSOFT
4008 * Resets the given device output, using the specified attribute list.
4010 ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs)
4012 ALCenum err;
4014 LockLists();
4015 if(!VerifyDevice(&device) || device->Type == Capture || !device->Connected)
4017 UnlockLists();
4018 alcSetError(device, ALC_INVALID_DEVICE);
4019 if(device) ALCdevice_DecRef(device);
4020 return ALC_FALSE;
4022 almtx_lock(&device->BackendLock);
4023 UnlockLists();
4025 err = UpdateDeviceParams(device, attribs);
4026 almtx_unlock(&device->BackendLock);
4028 if(err != ALC_NO_ERROR)
4030 alcSetError(device, err);
4031 if(err == ALC_INVALID_DEVICE)
4033 V0(device->Backend,lock)();
4034 aluHandleDisconnect(device);
4035 V0(device->Backend,unlock)();
4037 ALCdevice_DecRef(device);
4038 return ALC_FALSE;
4040 ALCdevice_DecRef(device);
4042 return ALC_TRUE;