?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Combine a couple if checks
[openal-soft.git] / Alc / ALc.c
blobaac7b6d333969b2121f9192fa9dc9c47aa4c134a
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.
8 *
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.
13 *
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., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #include "config.h"
22
23 #include <math.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <memory.h>
27 #include <ctype.h>
28 #include <signal.h>
29
30 #include "alMain.h"
31 #include "alSource.h"
32 #include "AL/al.h"
33 #include "AL/alc.h"
34 #include "alThunk.h"
35 #include "alSource.h"
36 #include "alBuffer.h"
37 #include "alAuxEffectSlot.h"
38 #include "alError.h"
39 #include "bs2b.h"
40 #include "alu.h"
41
42
43 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
44 static struct BackendInfo BackendList[] = {
45 #ifdef HAVE_PULSEAUDIO
46 { "pulse", alc_pulse_init, alc_pulse_deinit, alc_pulse_probe, EmptyFuncs },
47 #endif
48 #ifdef HAVE_ALSA
49 { "alsa", alc_alsa_init, alc_alsa_deinit, alc_alsa_probe, EmptyFuncs },
50 #endif
51 #ifdef HAVE_COREAUDIO
52 { "core", alc_ca_init, alc_ca_deinit, alc_ca_probe, EmptyFuncs },
53 #endif
54 #ifdef HAVE_OSS
55 { "oss", alc_oss_init, alc_oss_deinit, alc_oss_probe, EmptyFuncs },
56 #endif
57 #ifdef HAVE_SOLARIS
58 { "solaris", alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },
59 #endif
60 #ifdef HAVE_SNDIO
61 { "sndio", alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },
62 #endif
63 #ifdef HAVE_MMDEVAPI
64 { "mmdevapi", alcMMDevApiInit, alcMMDevApiDeinit, alcMMDevApiProbe, EmptyFuncs },
65 #endif
66 #ifdef HAVE_DSOUND
67 { "dsound", alcDSoundInit, alcDSoundDeinit, alcDSoundProbe, EmptyFuncs },
68 #endif
69 #ifdef HAVE_WINMM
70 { "winmm", alcWinMMInit, alcWinMMDeinit, alcWinMMProbe, EmptyFuncs },
71 #endif
72 #ifdef HAVE_PORTAUDIO
73 { "port", alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
74 #endif
75 #ifdef HAVE_OPENSL
76 { "opensl", alc_opensl_init, alc_opensl_deinit, alc_opensl_probe, EmptyFuncs },
77 #endif
78
79 { "null", alc_null_init, alc_null_deinit, alc_null_probe, EmptyFuncs },
80 #ifdef HAVE_WAVE
81 { "wave", alc_wave_init, alc_wave_deinit, alc_wave_probe, EmptyFuncs },
82 #endif
83
84 { NULL, NULL, NULL, NULL, EmptyFuncs }
85 };
86 static struct BackendInfo BackendLoopback = {
87 "loopback", alc_loopback_init, alc_loopback_deinit, alc_loopback_probe, EmptyFuncs
88 };
89 #undef EmptyFuncs
90
91 static struct BackendInfo PlaybackBackend;
92 static struct BackendInfo CaptureBackend;
93
94 ///////////////////////////////////////////////////////
95 // STRING and EXTENSIONS
96
97 typedef struct ALCfunction {
98 const ALCchar *funcName;
99 ALCvoid *address;
100 } ALCfunction;
101
102 typedef struct ALCenums {
103 const ALCchar *enumName;
104 ALCenum value;
105 } ALCenums;
106
107
108 static const ALCfunction alcFunctions[] = {
109 { "alcCreateContext", (ALCvoid *) alcCreateContext },
110 { "alcMakeContextCurrent", (ALCvoid *) alcMakeContextCurrent },
111 { "alcProcessContext", (ALCvoid *) alcProcessContext },
112 { "alcSuspendContext", (ALCvoid *) alcSuspendContext },
113 { "alcDestroyContext", (ALCvoid *) alcDestroyContext },
114 { "alcGetCurrentContext", (ALCvoid *) alcGetCurrentContext },
115 { "alcGetContextsDevice", (ALCvoid *) alcGetContextsDevice },
116 { "alcOpenDevice", (ALCvoid *) alcOpenDevice },
117 { "alcCloseDevice", (ALCvoid *) alcCloseDevice },
118 { "alcGetError", (ALCvoid *) alcGetError },
119 { "alcIsExtensionPresent", (ALCvoid *) alcIsExtensionPresent },
120 { "alcGetProcAddress", (ALCvoid *) alcGetProcAddress },
121 { "alcGetEnumValue", (ALCvoid *) alcGetEnumValue },
122 { "alcGetString", (ALCvoid *) alcGetString },
123 { "alcGetIntegerv", (ALCvoid *) alcGetIntegerv },
124 { "alcCaptureOpenDevice", (ALCvoid *) alcCaptureOpenDevice },
125 { "alcCaptureCloseDevice", (ALCvoid *) alcCaptureCloseDevice },
126 { "alcCaptureStart", (ALCvoid *) alcCaptureStart },
127 { "alcCaptureStop", (ALCvoid *) alcCaptureStop },
128 { "alcCaptureSamples", (ALCvoid *) alcCaptureSamples },
129
130 { "alcSetThreadContext", (ALCvoid *) alcSetThreadContext },
131 { "alcGetThreadContext", (ALCvoid *) alcGetThreadContext },
132
133 { "alcLoopbackOpenDeviceSOFT", (ALCvoid *) alcLoopbackOpenDeviceSOFT},
134 { "alcIsRenderFormatSupportedSOFT",(ALCvoid *) alcIsRenderFormatSupportedSOFT},
135 { "alcRenderSamplesSOFT", (ALCvoid *) alcRenderSamplesSOFT },
136
137 { "alEnable", (ALCvoid *) alEnable },
138 { "alDisable", (ALCvoid *) alDisable },
139 { "alIsEnabled", (ALCvoid *) alIsEnabled },
140 { "alGetString", (ALCvoid *) alGetString },
141 { "alGetBooleanv", (ALCvoid *) alGetBooleanv },
142 { "alGetIntegerv", (ALCvoid *) alGetIntegerv },
143 { "alGetFloatv", (ALCvoid *) alGetFloatv },
144 { "alGetDoublev", (ALCvoid *) alGetDoublev },
145 { "alGetBoolean", (ALCvoid *) alGetBoolean },
146 { "alGetInteger", (ALCvoid *) alGetInteger },
147 { "alGetFloat", (ALCvoid *) alGetFloat },
148 { "alGetDouble", (ALCvoid *) alGetDouble },
149 { "alGetError", (ALCvoid *) alGetError },
150 { "alIsExtensionPresent", (ALCvoid *) alIsExtensionPresent },
151 { "alGetProcAddress", (ALCvoid *) alGetProcAddress },
152 { "alGetEnumValue", (ALCvoid *) alGetEnumValue },
153 { "alListenerf", (ALCvoid *) alListenerf },
154 { "alListener3f", (ALCvoid *) alListener3f },
155 { "alListenerfv", (ALCvoid *) alListenerfv },
156 { "alListeneri", (ALCvoid *) alListeneri },
157 { "alListener3i", (ALCvoid *) alListener3i },
158 { "alListeneriv", (ALCvoid *) alListeneriv },
159 { "alGetListenerf", (ALCvoid *) alGetListenerf },
160 { "alGetListener3f", (ALCvoid *) alGetListener3f },
161 { "alGetListenerfv", (ALCvoid *) alGetListenerfv },
162 { "alGetListeneri", (ALCvoid *) alGetListeneri },
163 { "alGetListener3i", (ALCvoid *) alGetListener3i },
164 { "alGetListeneriv", (ALCvoid *) alGetListeneriv },
165 { "alGenSources", (ALCvoid *) alGenSources },
166 { "alDeleteSources", (ALCvoid *) alDeleteSources },
167 { "alIsSource", (ALCvoid *) alIsSource },
168 { "alSourcef", (ALCvoid *) alSourcef },
169 { "alSource3f", (ALCvoid *) alSource3f },
170 { "alSourcefv", (ALCvoid *) alSourcefv },
171 { "alSourcei", (ALCvoid *) alSourcei },
172 { "alSource3i", (ALCvoid *) alSource3i },
173 { "alSourceiv", (ALCvoid *) alSourceiv },
174 { "alGetSourcef", (ALCvoid *) alGetSourcef },
175 { "alGetSource3f", (ALCvoid *) alGetSource3f },
176 { "alGetSourcefv", (ALCvoid *) alGetSourcefv },
177 { "alGetSourcei", (ALCvoid *) alGetSourcei },
178 { "alGetSource3i", (ALCvoid *) alGetSource3i },
179 { "alGetSourceiv", (ALCvoid *) alGetSourceiv },
180 { "alSourcePlayv", (ALCvoid *) alSourcePlayv },
181 { "alSourceStopv", (ALCvoid *) alSourceStopv },
182 { "alSourceRewindv", (ALCvoid *) alSourceRewindv },
183 { "alSourcePausev", (ALCvoid *) alSourcePausev },
184 { "alSourcePlay", (ALCvoid *) alSourcePlay },
185 { "alSourceStop", (ALCvoid *) alSourceStop },
186 { "alSourceRewind", (ALCvoid *) alSourceRewind },
187 { "alSourcePause", (ALCvoid *) alSourcePause },
188 { "alSourceQueueBuffers", (ALCvoid *) alSourceQueueBuffers },
189 { "alSourceUnqueueBuffers", (ALCvoid *) alSourceUnqueueBuffers },
190 { "alGenBuffers", (ALCvoid *) alGenBuffers },
191 { "alDeleteBuffers", (ALCvoid *) alDeleteBuffers },
192 { "alIsBuffer", (ALCvoid *) alIsBuffer },
193 { "alBufferData", (ALCvoid *) alBufferData },
194 { "alBufferf", (ALCvoid *) alBufferf },
195 { "alBuffer3f", (ALCvoid *) alBuffer3f },
196 { "alBufferfv", (ALCvoid *) alBufferfv },
197 { "alBufferi", (ALCvoid *) alBufferi },
198 { "alBuffer3i", (ALCvoid *) alBuffer3i },
199 { "alBufferiv", (ALCvoid *) alBufferiv },
200 { "alGetBufferf", (ALCvoid *) alGetBufferf },
201 { "alGetBuffer3f", (ALCvoid *) alGetBuffer3f },
202 { "alGetBufferfv", (ALCvoid *) alGetBufferfv },
203 { "alGetBufferi", (ALCvoid *) alGetBufferi },
204 { "alGetBuffer3i", (ALCvoid *) alGetBuffer3i },
205 { "alGetBufferiv", (ALCvoid *) alGetBufferiv },
206 { "alDopplerFactor", (ALCvoid *) alDopplerFactor },
207 { "alDopplerVelocity", (ALCvoid *) alDopplerVelocity },
208 { "alSpeedOfSound", (ALCvoid *) alSpeedOfSound },
209 { "alDistanceModel", (ALCvoid *) alDistanceModel },
210
211 { "alGenFilters", (ALCvoid *) alGenFilters },
212 { "alDeleteFilters", (ALCvoid *) alDeleteFilters },
213 { "alIsFilter", (ALCvoid *) alIsFilter },
214 { "alFilteri", (ALCvoid *) alFilteri },
215 { "alFilteriv", (ALCvoid *) alFilteriv },
216 { "alFilterf", (ALCvoid *) alFilterf },
217 { "alFilterfv", (ALCvoid *) alFilterfv },
218 { "alGetFilteri", (ALCvoid *) alGetFilteri },
219 { "alGetFilteriv", (ALCvoid *) alGetFilteriv },
220 { "alGetFilterf", (ALCvoid *) alGetFilterf },
221 { "alGetFilterfv", (ALCvoid *) alGetFilterfv },
222 { "alGenEffects", (ALCvoid *) alGenEffects },
223 { "alDeleteEffects", (ALCvoid *) alDeleteEffects },
224 { "alIsEffect", (ALCvoid *) alIsEffect },
225 { "alEffecti", (ALCvoid *) alEffecti },
226 { "alEffectiv", (ALCvoid *) alEffectiv },
227 { "alEffectf", (ALCvoid *) alEffectf },
228 { "alEffectfv", (ALCvoid *) alEffectfv },
229 { "alGetEffecti", (ALCvoid *) alGetEffecti },
230 { "alGetEffectiv", (ALCvoid *) alGetEffectiv },
231 { "alGetEffectf", (ALCvoid *) alGetEffectf },
232 { "alGetEffectfv", (ALCvoid *) alGetEffectfv },
233 { "alGenAuxiliaryEffectSlots", (ALCvoid *) alGenAuxiliaryEffectSlots},
234 { "alDeleteAuxiliaryEffectSlots",(ALCvoid *) alDeleteAuxiliaryEffectSlots},
235 { "alIsAuxiliaryEffectSlot", (ALCvoid *) alIsAuxiliaryEffectSlot },
236 { "alAuxiliaryEffectSloti", (ALCvoid *) alAuxiliaryEffectSloti },
237 { "alAuxiliaryEffectSlotiv", (ALCvoid *) alAuxiliaryEffectSlotiv },
238 { "alAuxiliaryEffectSlotf", (ALCvoid *) alAuxiliaryEffectSlotf },
239 { "alAuxiliaryEffectSlotfv", (ALCvoid *) alAuxiliaryEffectSlotfv },
240 { "alGetAuxiliaryEffectSloti", (ALCvoid *) alGetAuxiliaryEffectSloti},
241 { "alGetAuxiliaryEffectSlotiv", (ALCvoid *) alGetAuxiliaryEffectSlotiv},
242 { "alGetAuxiliaryEffectSlotf", (ALCvoid *) alGetAuxiliaryEffectSlotf},
243 { "alGetAuxiliaryEffectSlotfv", (ALCvoid *) alGetAuxiliaryEffectSlotfv},
244
245 { "alBufferSubDataSOFT", (ALCvoid *) alBufferSubDataSOFT },
246
247 { "alBufferSamplesSOFT", (ALCvoid *) alBufferSamplesSOFT },
248 { "alBufferSubSamplesSOFT", (ALCvoid *) alBufferSubSamplesSOFT },
249 { "alGetBufferSamplesSOFT", (ALCvoid *) alGetBufferSamplesSOFT },
250 { "alIsBufferFormatSupportedSOFT",(ALCvoid *) alIsBufferFormatSupportedSOFT},
251
252 { "alDeferUpdatesSOFT", (ALCvoid *) alDeferUpdatesSOFT },
253 { "alProcessUpdatesSOFT", (ALCvoid *) alProcessUpdatesSOFT },
254
255 { NULL, (ALCvoid *) NULL }
256 };
257
258 static const ALCenums enumeration[] = {
259 // Types
260 { "ALC_INVALID", ALC_INVALID },
261 { "ALC_FALSE", ALC_FALSE },
262 { "ALC_TRUE", ALC_TRUE },
263
264 // ALC Properties
265 { "ALC_MAJOR_VERSION", ALC_MAJOR_VERSION },
266 { "ALC_MINOR_VERSION", ALC_MINOR_VERSION },
267 { "ALC_ATTRIBUTES_SIZE", ALC_ATTRIBUTES_SIZE },
268 { "ALC_ALL_ATTRIBUTES", ALC_ALL_ATTRIBUTES },
269 { "ALC_DEFAULT_DEVICE_SPECIFIER", ALC_DEFAULT_DEVICE_SPECIFIER },
270 { "ALC_DEVICE_SPECIFIER", ALC_DEVICE_SPECIFIER },
271 { "ALC_ALL_DEVICES_SPECIFIER", ALC_ALL_DEVICES_SPECIFIER },
272 { "ALC_DEFAULT_ALL_DEVICES_SPECIFIER", ALC_DEFAULT_ALL_DEVICES_SPECIFIER },
273 { "ALC_EXTENSIONS", ALC_EXTENSIONS },
274 { "ALC_FREQUENCY", ALC_FREQUENCY },
275 { "ALC_REFRESH", ALC_REFRESH },
276 { "ALC_SYNC", ALC_SYNC },
277 { "ALC_MONO_SOURCES", ALC_MONO_SOURCES },
278 { "ALC_STEREO_SOURCES", ALC_STEREO_SOURCES },
279 { "ALC_CAPTURE_DEVICE_SPECIFIER", ALC_CAPTURE_DEVICE_SPECIFIER },
280 { "ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
281 { "ALC_CAPTURE_SAMPLES", ALC_CAPTURE_SAMPLES },
282 { "ALC_CONNECTED", ALC_CONNECTED },
283
284 // EFX Properties
285 { "ALC_EFX_MAJOR_VERSION", ALC_EFX_MAJOR_VERSION },
286 { "ALC_EFX_MINOR_VERSION", ALC_EFX_MINOR_VERSION },
287 { "ALC_MAX_AUXILIARY_SENDS", ALC_MAX_AUXILIARY_SENDS },
288
289 // Loopback device Properties
290 { "ALC_FORMAT_CHANNELS_SOFT", ALC_FORMAT_CHANNELS_SOFT },
291 { "ALC_FORMAT_TYPE_SOFT", ALC_FORMAT_TYPE_SOFT },
292
293 // Buffer Channel Configurations
294 { "ALC_MONO_SOFT", ALC_MONO_SOFT },
295 { "ALC_STEREO_SOFT", ALC_STEREO_SOFT },
296 { "ALC_QUAD_SOFT", ALC_QUAD_SOFT },
297 { "ALC_5POINT1_SOFT", ALC_5POINT1_SOFT },
298 { "ALC_6POINT1_SOFT", ALC_6POINT1_SOFT },
299 { "ALC_7POINT1_SOFT", ALC_7POINT1_SOFT },
300
301 // Buffer Sample Types
302 { "ALC_BYTE_SOFT", ALC_BYTE_SOFT },
303 { "ALC_UNSIGNED_BYTE_SOFT", ALC_UNSIGNED_BYTE_SOFT },
304 { "ALC_SHORT_SOFT", ALC_SHORT_SOFT },
305 { "ALC_UNSIGNED_SHORT_SOFT", ALC_UNSIGNED_SHORT_SOFT },
306 { "ALC_INT_SOFT", ALC_INT_SOFT },
307 { "ALC_UNSIGNED_INT_SOFT", ALC_UNSIGNED_INT_SOFT },
308 { "ALC_FLOAT_SOFT", ALC_FLOAT_SOFT },
309
310 // ALC Error Message
311 { "ALC_NO_ERROR", ALC_NO_ERROR },
312 { "ALC_INVALID_DEVICE", ALC_INVALID_DEVICE },
313 { "ALC_INVALID_CONTEXT", ALC_INVALID_CONTEXT },
314 { "ALC_INVALID_ENUM", ALC_INVALID_ENUM },
315 { "ALC_INVALID_VALUE", ALC_INVALID_VALUE },
316 { "ALC_OUT_OF_MEMORY", ALC_OUT_OF_MEMORY },
317
318 { NULL, (ALCenum)0 }
319 };
320 // Error strings
321 static const ALCchar alcNoError[] = "No Error";
322 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
323 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
324 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
325 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
326 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
327
328 /* Device lists. Sizes only include the first ending null character, not the
329 * second */
330 static ALCchar *alcDeviceList;
331 static size_t alcDeviceListSize;
332 static ALCchar *alcAllDeviceList;
333 static size_t alcAllDeviceListSize;
334 static ALCchar *alcCaptureDeviceList;
335 static size_t alcCaptureDeviceListSize;
336 /* Default is always the first in the list */
337 static ALCchar *alcDefaultDeviceSpecifier;
338 static ALCchar *alcDefaultAllDeviceSpecifier;
339 static ALCchar *alcCaptureDefaultDeviceSpecifier;
340
341
342 static const ALCchar alcNoDeviceExtList[] =
343 "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
344 "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";
345 static const ALCchar alcExtensionList[] =
346 "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
347 "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
348 "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";
349 static const ALCint alcMajorVersion = 1;
350 static const ALCint alcMinorVersion = 1;
351
352 static const ALCint alcEFXMajorVersion = 1;
353 static const ALCint alcEFXMinorVersion = 0;
354
355 ///////////////////////////////////////////////////////
356
357
358 ///////////////////////////////////////////////////////
359 // Global Variables
360
361 static CRITICAL_SECTION ListLock;
362
363 /* Device List */
364 static ALCdevice *volatile DeviceList = NULL;
365
366 // Thread-local current context
367 static pthread_key_t LocalContext;
368 // Process-wide current context
369 static ALCcontext *GlobalContext;
370
371 /* Device Error */
372 static volatile ALCenum g_eLastNullDeviceError = ALC_NO_ERROR;
373
374 // Default context extensions
375 static const ALchar alExtList[] =
376 "AL_EXT_ALAW AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 "
377 "AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_MULAW "
378 "AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET AL_EXT_source_distance_model "
379 "AL_LOKI_quadriphonic AL_SOFT_buffer_samples AL_SOFT_buffer_sub_data "
380 "AL_SOFTX_deferred_updates AL_SOFTX_direct_channels AL_SOFT_loop_points";
381
382 // Mixing Priority Level
383 ALint RTPrioLevel;
384
385 // Output Log File
386 FILE *LogFile;
387
388 // Output Log Level
389 #ifdef _DEBUG
390 enum LogLevel LogLevel = LogWarning;
391 #else
392 enum LogLevel LogLevel = LogError;
393 #endif
394
395 /* Flag to trap ALC device errors */
396 static ALCboolean TrapALCError = ALC_FALSE;
397
398 /* One-time configuration init control */
399 static pthread_once_t alc_config_once = PTHREAD_ONCE_INIT;
400
401 /* Forced effect that applies to sources that don't have an effect on send 0 */
402 static ALeffect ForcedEffect;
403
404 ///////////////////////////////////////////////////////
405
406
407 ///////////////////////////////////////////////////////
408 // ALC Related helper functions
409 static void ReleaseALC(void);
410 static void ReleaseThreadCtx(void *ptr);
411
412 static void alc_initconfig(void);
413 #define DO_INITCONFIG() pthread_once(&alc_config_once, alc_initconfig)
414
415 #if defined(_WIN32)
416 static void alc_init(void);
417 static void alc_deinit(void);
418 static void alc_deinit_safe(void);
419
420 UIntMap TlsDestructor;
421
422 #ifndef AL_LIBTYPE_STATIC
423 BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
424 {
425 ALsizei i;
426 (void)hModule;
427
428 // Perform actions based on the reason for calling.
429 switch(ul_reason_for_call)
430 {
431 case DLL_PROCESS_ATTACH:
432 InitUIntMap(&TlsDestructor, ~0);
433 alc_init();
434 break;
435
436 case DLL_THREAD_DETACH:
437 LockUIntMapRead(&TlsDestructor);
438 for(i = 0;i < TlsDestructor.size;i++)
439 {
440 void *ptr = pthread_getspecific(TlsDestructor.array[i].key);
441 void (*callback)(void*) = (void(*)(void*))TlsDestructor.array[i].value;
442 if(ptr && callback)
443 callback(ptr);
444 }
445 UnlockUIntMapRead(&TlsDestructor);
446 break;
447
448 case DLL_PROCESS_DETACH:
449 if(!lpReserved)
450 alc_deinit();
451 else
452 alc_deinit_safe();
453 ResetUIntMap(&TlsDestructor);
454 break;
455 }
456 return TRUE;
457 }
458 #elif defined(_MSC_VER)
459 #pragma section(".CRT$XCU",read)
460 static void alc_constructor(void);
461 static void alc_destructor(void);
462 __declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;
463
464 static void alc_constructor(void)
465 {
466 atexit(alc_destructor);
467 alc_init();
468 }
469
470 static void alc_destructor(void)
471 {
472 alc_deinit();
473 }
474 #elif defined(HAVE_GCC_DESTRUCTOR)
475 static void alc_init(void) __attribute__((constructor));
476 static void alc_deinit(void) __attribute__((destructor));
477 #else
478 #error "No static initialization available on this platform!"
479 #endif
480 #elif defined(HAVE_GCC_DESTRUCTOR)
481 static void alc_init(void) __attribute__((constructor));
482 static void alc_deinit(void) __attribute__((destructor));
483 #else
484 #error "No global initialization available on this platform!"
485 #endif
486
487 static void alc_init(void)
488 {
489 const char *str;
490
491 LogFile = stderr;
492
493 str = getenv("__ALSOFT_HALF_ANGLE_CONES");
494 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
495 ConeScale = 1.0f;
496
497 str = getenv("__ALSOFT_REVERSE_Z");
498 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
499 ZScale = -1.0f;
500
501 str = getenv("__ALSOFT_TRAP_ERROR");
502 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
503 {
504 TrapALError = AL_TRUE;
505 TrapALCError = AL_TRUE;
506 }
507 else
508 {
509 str = getenv("__ALSOFT_TRAP_AL_ERROR");
510 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
511 TrapALError = AL_TRUE;
512
513 str = getenv("__ALSOFT_TRAP_ALC_ERROR");
514 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
515 TrapALCError = ALC_TRUE;
516 }
517
518 pthread_key_create(&LocalContext, ReleaseThreadCtx);
519 InitializeCriticalSection(&ListLock);
520 ThunkInit();
521 }
522
523 static void alc_deinit_safe(void)
524 {
525 ReleaseALC();
526
527 FreeHrtf();
528 FreeALConfig();
529
530 ThunkExit();
531 DeleteCriticalSection(&ListLock);
532 pthread_key_delete(LocalContext);
533
534 if(LogFile != stderr)
535 fclose(LogFile);
536 LogFile = NULL;
537 }
538
539 static void alc_deinit(void)
540 {
541 int i;
542
543 ReleaseALC();
544
545 memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
546 memset(&CaptureBackend, 0, sizeof(CaptureBackend));
547
548 for(i = 0;BackendList[i].Deinit;i++)
549 BackendList[i].Deinit();
550 BackendLoopback.Deinit();
551
552 alc_deinit_safe();
553 }
554
555 static void alc_initconfig(void)
556 {
557 const char *devs, *str;
558 float valf;
559 int i, n;
560
561 str = getenv("ALSOFT_LOGLEVEL");
562 if(str)
563 {
564 long lvl = strtol(str, NULL, 0);
565 if(lvl >= NoLog && lvl <= LogRef)
566 LogLevel = lvl;
567 }
568
569 str = getenv("ALSOFT_LOGFILE");
570 if(str && str[0])
571 {
572 FILE *logfile = fopen(str, "wat");
573 if(logfile) LogFile = logfile;
574 else ERR("Failed to open log file '%s'\n", str);
575 }
576
577 ReadALConfig();
578
579 InitHrtf();
580
581 #ifdef _WIN32
582 RTPrioLevel = 1;
583 #else
584 RTPrioLevel = 0;
585 #endif
586 ConfigValueInt(NULL, "rt-prio", &RTPrioLevel);
587
588 if(ConfigValueStr(NULL, "resampler", &str))
589 {
590 if(strcasecmp(str, "point") == 0 || strcasecmp(str, "none") == 0)
591 DefaultResampler = PointResampler;
592 else if(strcasecmp(str, "linear") == 0)
593 DefaultResampler = LinearResampler;
594 else if(strcasecmp(str, "cubic") == 0)
595 DefaultResampler = CubicResampler;
596 else
597 {
598 char *end;
599
600 n = strtol(str, &end, 0);
601 if(*end == '\0' && (n == PointResampler || n == LinearResampler || n == CubicResampler))
602 DefaultResampler = n;
603 else
604 WARN("Invalid resampler: %s\n", str);
605 }
606 }
607
608 if(!TrapALCError)
609 TrapALCError = GetConfigValueBool(NULL, "trap-alc-error", ALC_FALSE);
610
611 if(!TrapALError)
612 TrapALError = GetConfigValueBool(NULL, "trap-al-error", AL_FALSE);
613
614 if(ConfigValueFloat("reverb", "boost", &valf))
615 ReverbBoost *= aluPow(10.0f, valf / 20.0f);
616
617 EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);
618
619 if(ConfigValueStr(NULL, "drivers", &devs))
620 {
621 int n;
622 size_t len;
623 const char *next = devs;
624 int endlist, delitem;
625
626 i = 0;
627 do {
628 devs = next;
629 next = strchr(devs, ',');
630
631 delitem = (devs[0] == '-');
632 if(devs[0] == '-') devs++;
633
634 if(!devs[0] || devs[0] == ',')
635 {
636 endlist = 0;
637 continue;
638 }
639 endlist = 1;
640
641 len = (next ? ((size_t)(next-devs)) : strlen(devs));
642 for(n = i;BackendList[n].Init;n++)
643 {
644 if(len == strlen(BackendList[n].name) &&
645 strncmp(BackendList[n].name, devs, len) == 0)
646 {
647 if(delitem)
648 {
649 do {
650 BackendList[n] = BackendList[n+1];
651 ++n;
652 } while(BackendList[n].Init);
653 }
654 else
655 {
656 struct BackendInfo Bkp = BackendList[n];
657 while(n > i)
658 {
659 BackendList[n] = BackendList[n-1];
660 --n;
661 }
662 BackendList[n] = Bkp;
663
664 i++;
665 }
666 break;
667 }
668 }
669 } while(next++);
670
671 if(endlist)
672 {
673 BackendList[i].name = NULL;
674 BackendList[i].Init = NULL;
675 BackendList[i].Deinit = NULL;
676 BackendList[i].Probe = NULL;
677 }
678 }
679
680 for(i = 0;BackendList[i].Init && (!PlaybackBackend.name || !CaptureBackend.name);i++)
681 {
682 if(!BackendList[i].Init(&BackendList[i].Funcs))
683 {
684 WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
685 continue;
686 }
687
688 TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
689 if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
690 {
691 PlaybackBackend = BackendList[i];
692 TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
693 }
694 if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
695 {
696 CaptureBackend = BackendList[i];
697 TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
698 }
699 }
700 BackendLoopback.Init(&BackendLoopback.Funcs);
701
702 if(ConfigValueStr(NULL, "excludefx", &str))
703 {
704 size_t len;
705 const char *next = str;
706
707 do {
708 str = next;
709 next = strchr(str, ',');
710
711 if(!str[0] || next == str)
712 continue;
713
714 len = (next ? ((size_t)(next-str)) : strlen(str));
715 for(n = 0;EffectList[n].name;n++)
716 {
717 if(len == strlen(EffectList[n].name) &&
718 strncmp(EffectList[n].name, str, len) == 0)
719 DisabledEffects[EffectList[n].type] = AL_TRUE;
720 }
721 } while(next++);
722 }
723
724 InitEffect(&ForcedEffect);
725 str = getenv("__ALSOFT_DEFAULT_REVERB");
726 if(str && str[0])
727 GetReverbEffect(str, &ForcedEffect);
728 else if(ConfigValueStr(NULL, "default-reverb", &str))
729 GetReverbEffect(str, &ForcedEffect);
730 }
731
732
733 static void LockLists(void)
734 {
735 EnterCriticalSection(&ListLock);
736 }
737
738 static void UnlockLists(void)
739 {
740 LeaveCriticalSection(&ListLock);
741 }
742
743
744 static void ProbeList(ALCchar **list, size_t *listsize, enum DevProbe type)
745 {
746 DO_INITCONFIG();
747
748 LockLists();
749 free(*list);
750 *list = NULL;
751 *listsize = 0;
752
753 if(type == CAPTURE_DEVICE_PROBE)
754 CaptureBackend.Probe(type);
755 else
756 PlaybackBackend.Probe(type);
757 UnlockLists();
758 }
759
760 static void ProbeDeviceList(void)
761 { ProbeList(&alcDeviceList, &alcDeviceListSize, DEVICE_PROBE); }
762 static void ProbeAllDeviceList(void)
763 { ProbeList(&alcAllDeviceList, &alcAllDeviceListSize, ALL_DEVICE_PROBE); }
764 static void ProbeCaptureDeviceList(void)
765 { ProbeList(&alcCaptureDeviceList, &alcCaptureDeviceListSize, CAPTURE_DEVICE_PROBE); }
766
767
768 static void AppendList(const ALCchar *name, ALCchar **List, size_t *ListSize)
769 {
770 size_t len = strlen(name);
771 void *temp;
772
773 if(len == 0)
774 return;
775
776 temp = realloc(*List, (*ListSize) + len + 2);
777 if(!temp)
778 {
779 ERR("Realloc failed to add %s!\n", name);
780 return;
781 }
782 *List = temp;
783
784 memcpy((*List)+(*ListSize), name, len+1);
785 *ListSize += len+1;
786 (*List)[*ListSize] = 0;
787 }
788
789 #define DECL_APPEND_LIST_FUNC(type) \
790 void Append##type##List(const ALCchar *name) \
791 { AppendList(name, &alc##type##List, &alc##type##ListSize); }
792
793 DECL_APPEND_LIST_FUNC(Device)
794 DECL_APPEND_LIST_FUNC(AllDevice)
795 DECL_APPEND_LIST_FUNC(CaptureDevice)
796
797 #undef DECL_APPEND_LIST_FUNC
798
799
800 /* Sets the default channel order used by most non-WaveFormatEx-based APIs */
801 void SetDefaultChannelOrder(ALCdevice *device)
802 {
803 switch(device->FmtChans)
804 {
805 case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
806 device->DevChannels[1] = FRONT_RIGHT;
807 device->DevChannels[2] = BACK_LEFT;
808 device->DevChannels[3] = BACK_RIGHT;
809 device->DevChannels[4] = FRONT_CENTER;
810 device->DevChannels[5] = LFE;
811 return;
812
813 case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
814 device->DevChannels[1] = FRONT_RIGHT;
815 device->DevChannels[2] = BACK_LEFT;
816 device->DevChannels[3] = BACK_RIGHT;
817 device->DevChannels[4] = FRONT_CENTER;
818 device->DevChannels[5] = LFE;
819 device->DevChannels[6] = SIDE_LEFT;
820 device->DevChannels[7] = SIDE_RIGHT;
821 return;
822
823 /* Same as WFX order */
824 case DevFmtMono:
825 case DevFmtStereo:
826 case DevFmtQuad:
827 case DevFmtX51Side:
828 case DevFmtX61:
829 break;
830 }
831 SetDefaultWFXChannelOrder(device);
832 }
833 /* Sets the default order used by WaveFormatEx */
834 void SetDefaultWFXChannelOrder(ALCdevice *device)
835 {
836 switch(device->FmtChans)
837 {
838 case DevFmtMono: device->DevChannels[0] = FRONT_CENTER; break;
839
840 case DevFmtStereo: device->DevChannels[0] = FRONT_LEFT;
841 device->DevChannels[1] = FRONT_RIGHT; break;
842
843 case DevFmtQuad: device->DevChannels[0] = FRONT_LEFT;
844 device->DevChannels[1] = FRONT_RIGHT;
845 device->DevChannels[2] = BACK_LEFT;
846 device->DevChannels[3] = BACK_RIGHT; break;
847
848 case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
849 device->DevChannels[1] = FRONT_RIGHT;
850 device->DevChannels[2] = FRONT_CENTER;
851 device->DevChannels[3] = LFE;
852 device->DevChannels[4] = BACK_LEFT;
853 device->DevChannels[5] = BACK_RIGHT; break;
854
855 case DevFmtX51Side: device->DevChannels[0] = FRONT_LEFT;
856 device->DevChannels[1] = FRONT_RIGHT;
857 device->DevChannels[2] = FRONT_CENTER;
858 device->DevChannels[3] = LFE;
859 device->DevChannels[4] = SIDE_LEFT;
860 device->DevChannels[5] = SIDE_RIGHT; break;
861
862 case DevFmtX61: device->DevChannels[0] = FRONT_LEFT;
863 device->DevChannels[1] = FRONT_RIGHT;
864 device->DevChannels[2] = FRONT_CENTER;
865 device->DevChannels[3] = LFE;
866 device->DevChannels[4] = BACK_CENTER;
867 device->DevChannels[5] = SIDE_LEFT;
868 device->DevChannels[6] = SIDE_RIGHT; break;
869
870 case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
871 device->DevChannels[1] = FRONT_RIGHT;
872 device->DevChannels[2] = FRONT_CENTER;
873 device->DevChannels[3] = LFE;
874 device->DevChannels[4] = BACK_LEFT;
875 device->DevChannels[5] = BACK_RIGHT;
876 device->DevChannels[6] = SIDE_LEFT;
877 device->DevChannels[7] = SIDE_RIGHT; break;
878 }
879 }
880
881
882 const ALCchar *DevFmtTypeString(enum DevFmtType type)
883 {
884 switch(type)
885 {
886 case DevFmtByte: return "Signed Byte";
887 case DevFmtUByte: return "Unsigned Byte";
888 case DevFmtShort: return "Signed Short";
889 case DevFmtUShort: return "Unsigned Short";
890 case DevFmtInt: return "Signed Int";
891 case DevFmtUInt: return "Unsigned Int";
892 case DevFmtFloat: return "Float";
893 }
894 return "(unknown type)";
895 }
896 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
897 {
898 switch(chans)
899 {
900 case DevFmtMono: return "Mono";
901 case DevFmtStereo: return "Stereo";
902 case DevFmtQuad: return "Quadraphonic";
903 case DevFmtX51: return "5.1 Surround";
904 case DevFmtX51Side: return "5.1 Side";
905 case DevFmtX61: return "6.1 Surround";
906 case DevFmtX71: return "7.1 Surround";
907 }
908 return "(unknown channels)";
909 }
910
911 ALuint BytesFromDevFmt(enum DevFmtType type)
912 {
913 switch(type)
914 {
915 case DevFmtByte: return sizeof(ALbyte);
916 case DevFmtUByte: return sizeof(ALubyte);
917 case DevFmtShort: return sizeof(ALshort);
918 case DevFmtUShort: return sizeof(ALushort);
919 case DevFmtInt: return sizeof(ALint);
920 case DevFmtUInt: return sizeof(ALuint);
921 case DevFmtFloat: return sizeof(ALfloat);
922 }
923 return 0;
924 }
925 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
926 {
927 switch(chans)
928 {
929 case DevFmtMono: return 1;
930 case DevFmtStereo: return 2;
931 case DevFmtQuad: return 4;
932 case DevFmtX51: return 6;
933 case DevFmtX51Side: return 6;
934 case DevFmtX61: return 7;
935 case DevFmtX71: return 8;
936 }
937 return 0;
938 }
939 static ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,
940 enum DevFmtType *type)
941 {
942 static const struct {
943 ALenum format;
944 enum DevFmtChannels channels;
945 enum DevFmtType type;
946 } list[] = {
947 { AL_FORMAT_MONO8, DevFmtMono, DevFmtUByte },
948 { AL_FORMAT_MONO16, DevFmtMono, DevFmtShort },
949 { AL_FORMAT_MONO_FLOAT32, DevFmtMono, DevFmtFloat },
950
951 { AL_FORMAT_STEREO8, DevFmtStereo, DevFmtUByte },
952 { AL_FORMAT_STEREO16, DevFmtStereo, DevFmtShort },
953 { AL_FORMAT_STEREO_FLOAT32, DevFmtStereo, DevFmtFloat },
954
955 { AL_FORMAT_QUAD8, DevFmtQuad, DevFmtUByte },
956 { AL_FORMAT_QUAD16, DevFmtQuad, DevFmtShort },
957 { AL_FORMAT_QUAD32, DevFmtQuad, DevFmtFloat },
958
959 { AL_FORMAT_51CHN8, DevFmtX51, DevFmtUByte },
960 { AL_FORMAT_51CHN16, DevFmtX51, DevFmtShort },
961 { AL_FORMAT_51CHN32, DevFmtX51, DevFmtFloat },
962
963 { AL_FORMAT_61CHN8, DevFmtX61, DevFmtUByte },
964 { AL_FORMAT_61CHN16, DevFmtX61, DevFmtShort },
965 { AL_FORMAT_61CHN32, DevFmtX61, DevFmtFloat },
966
967 { AL_FORMAT_71CHN8, DevFmtX71, DevFmtUByte },
968 { AL_FORMAT_71CHN16, DevFmtX71, DevFmtShort },
969 { AL_FORMAT_71CHN32, DevFmtX71, DevFmtFloat },
970 };
971 ALuint i;
972
973 for(i = 0;i < sizeof(list)/sizeof(list[0]);i++)
974 {
975 if(list[i].format == format)
976 {
977 *chans = list[i].channels;
978 *type = list[i].type;
979 return AL_TRUE;
980 }
981 }
982
983 return AL_FALSE;
984 }
985
986 static ALCboolean IsValidALCType(ALCenum type)
987 {
988 switch(type)
989 {
990 case ALC_BYTE_SOFT:
991 case ALC_UNSIGNED_BYTE_SOFT:
992 case ALC_SHORT_SOFT:
993 case ALC_UNSIGNED_SHORT_SOFT:
994 case ALC_INT_SOFT:
995 case ALC_UNSIGNED_INT_SOFT:
996 case ALC_FLOAT_SOFT:
997 return ALC_TRUE;
998 }
999 return ALC_FALSE;
1000 }
1001
1002 static ALCboolean IsValidALCChannels(ALCenum channels)
1003 {
1004 switch(channels)
1005 {
1006 case ALC_MONO_SOFT:
1007 case ALC_STEREO_SOFT:
1008 case ALC_QUAD_SOFT:
1009 case ALC_5POINT1_SOFT:
1010 case ALC_6POINT1_SOFT:
1011 case ALC_7POINT1_SOFT:
1012 return ALC_TRUE;
1013 }
1014 return ALC_FALSE;
1015 }
1016
1017
1018 /* alcSetError
1019 *
1020 * Stores the latest ALC Error
1021 */
1022 static void alcSetError(ALCdevice *device, ALCenum errorCode)
1023 {
1024 if(TrapALCError)
1025 {
1026 #ifdef _WIN32
1027 /* DebugBreak() will cause an exception if there is no debugger */
1028 if(IsDebuggerPresent())
1029 DebugBreak();
1030 #elif defined(SIGTRAP)
1031 raise(SIGTRAP);
1032 #endif
1033 }
1034
1035 if(device)
1036 device->LastError = errorCode;
1037 else
1038 g_eLastNullDeviceError = errorCode;
1039 }
1040
1041
1042 /* UpdateDeviceParams
1043 *
1044 * Updates device parameters according to the attribute list (caller is
1045 * responsible for holding the list lock).
1046 */
1047 static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
1048 {
1049 ALCcontext *context;
1050 enum DevFmtChannels oldChans;
1051 enum DevFmtType oldType;
1052 ALCuint oldFreq;
1053 int oldMode;
1054 ALuint i;
1055
1056 if(device->IsLoopbackDevice && !(attrList && attrList[0]))
1057 {
1058 WARN("Missing attributes for loopback device\n");
1059 return ALC_INVALID_VALUE;
1060 }
1061
1062 // Check for attributes
1063 if(attrList && attrList[0])
1064 {
1065 enum {
1066 GotFreq = 1<<0,
1067 GotChans = 1<<1,
1068 GotType = 1<<2,
1069 GotAll = GotFreq|GotChans|GotType
1070 };
1071 ALCuint freq, numMono, numStereo, numSends;
1072 enum DevFmtChannels schans;
1073 enum DevFmtType stype;
1074 ALCuint attrIdx = 0;
1075 ALCint gotFmt = 0;
1076
1077 // If a context is already running on the device, stop playback so the
1078 // device attributes can be updated
1079 if((device->Flags&DEVICE_RUNNING))
1080 ALCdevice_StopPlayback(device);
1081 device->Flags &= ~DEVICE_RUNNING;
1082
1083 freq = device->Frequency;
1084 schans = device->FmtChans;
1085 stype = device->FmtType;
1086 numMono = device->NumMonoSources;
1087 numStereo = device->NumStereoSources;
1088 numSends = device->NumAuxSends;
1089
1090 while(attrList[attrIdx])
1091 {
1092 if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT &&
1093 device->IsLoopbackDevice)
1094 {
1095 ALCint val = attrList[attrIdx + 1];
1096 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
1097 return ALC_INVALID_VALUE;
1098 schans = val;
1099 gotFmt |= GotChans;
1100 }
1101
1102 if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT &&
1103 device->IsLoopbackDevice)
1104 {
1105 ALCint val = attrList[attrIdx + 1];
1106 if(!IsValidALCType(val) || !BytesFromDevFmt(val))
1107 return ALC_INVALID_VALUE;
1108 stype = val;
1109 gotFmt |= GotType;
1110 }
1111
1112 if(attrList[attrIdx] == ALC_FREQUENCY)
1113 {
1114 if(device->IsLoopbackDevice)
1115 {
1116 freq = attrList[attrIdx + 1];
1117 if(freq < 8000)
1118 return ALC_INVALID_VALUE;
1119 gotFmt |= GotFreq;
1120 }
1121 else
1122 {
1123 freq = attrList[attrIdx + 1];
1124 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1125 }
1126 }
1127
1128 if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1129 {
1130 numStereo = attrList[attrIdx + 1];
1131 if(numStereo > device->MaxNoOfSources)
1132 numStereo = device->MaxNoOfSources;
1133
1134 numMono = device->MaxNoOfSources - numStereo;
1135 }
1136
1137 if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1138 numSends = attrList[attrIdx + 1];
1139
1140 attrIdx += 2;
1141 }
1142
1143 if(device->IsLoopbackDevice)
1144 {
1145 if(gotFmt != GotAll)
1146 {
1147 WARN("Missing format for loopback device\n");
1148 return ALC_INVALID_VALUE;
1149 }
1150 }
1151 else
1152 {
1153 ConfigValueUInt(NULL, "frequency", &freq);
1154 freq = maxu(freq, 8000);
1155 }
1156 ConfigValueUInt(NULL, "sends", &numSends);
1157 numSends = minu(MAX_SENDS, numSends);
1158
1159 device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1160 device->Frequency;
1161
1162 device->Frequency = freq;
1163 device->FmtChans = schans;
1164 device->FmtType = stype;
1165 device->NumMonoSources = numMono;
1166 device->NumStereoSources = numStereo;
1167 device->NumAuxSends = numSends;
1168 }
1169
1170 if((device->Flags&DEVICE_RUNNING))
1171 return ALC_NO_ERROR;
1172
1173 LockDevice(device);
1174
1175 oldFreq = device->Frequency;
1176 oldChans = device->FmtChans;
1177 oldType = device->FmtType;
1178
1179 TRACE("Format pre-setup: %s%s, %s, %uhz%s, %u update size x%d\n",
1180 DevFmtChannelsString(device->FmtChans),
1181 (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",
1182 DevFmtTypeString(device->FmtType), device->Frequency,
1183 (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",
1184 device->UpdateSize, device->NumUpdates);
1185 if(ALCdevice_ResetPlayback(device) == ALC_FALSE)
1186 {
1187 UnlockDevice(device);
1188 return ALC_INVALID_DEVICE;
1189 }
1190 device->Flags |= DEVICE_RUNNING;
1191
1192 if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
1193 {
1194 ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
1195 DevFmtChannelsString(device->FmtChans));
1196 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
1197 }
1198 if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
1199 {
1200 ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
1201 device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
1202 }
1203
1204 TRACE("Format post-setup: %s, %s, %uhz, %u update size x%d\n",
1205 DevFmtChannelsString(device->FmtChans),
1206 DevFmtTypeString(device->FmtType), device->Frequency,
1207 device->UpdateSize, device->NumUpdates);
1208
1209 aluInitPanning(device);
1210
1211 for(i = 0;i < MAXCHANNELS;i++)
1212 {
1213 device->ClickRemoval[i] = 0.0f;
1214 device->PendingClicks[i] = 0.0f;
1215 }
1216
1217 device->Hrtf = NULL;
1218 if(!device->IsLoopbackDevice && GetConfigValueBool(NULL, "hrtf", AL_FALSE))
1219 device->Hrtf = GetHrtf(device);
1220 TRACE("HRTF %s\n", device->Hrtf?"enabled":"disabled");
1221
1222 if(!device->Hrtf && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
1223 {
1224 if(!device->Bs2b)
1225 {
1226 device->Bs2b = calloc(1, sizeof(*device->Bs2b));
1227 bs2b_clear(device->Bs2b);
1228 }
1229 bs2b_set_srate(device->Bs2b, device->Frequency);
1230 bs2b_set_level(device->Bs2b, device->Bs2bLevel);
1231 TRACE("BS2B level %d\n", device->Bs2bLevel);
1232 }
1233 else
1234 {
1235 free(device->Bs2b);
1236 device->Bs2b = NULL;
1237 TRACE("BS2B disabled\n");
1238 }
1239
1240 device->Flags &= ~DEVICE_DUPLICATE_STEREO;
1241 switch(device->FmtChans)
1242 {
1243 case DevFmtMono:
1244 case DevFmtStereo:
1245 break;
1246 case DevFmtQuad:
1247 case DevFmtX51:
1248 case DevFmtX51Side:
1249 case DevFmtX61:
1250 case DevFmtX71:
1251 if(GetConfigValueBool(NULL, "stereodup", AL_TRUE))
1252 device->Flags |= DEVICE_DUPLICATE_STEREO;
1253 break;
1254 }
1255 TRACE("Stereo duplication %s\n", (device->Flags&DEVICE_DUPLICATE_STEREO)?"enabled":"disabled");
1256
1257 oldMode = SetMixerFPUMode();
1258 context = device->ContextList;
1259 while(context)
1260 {
1261 ALsizei pos;
1262
1263 context->UpdateSources = AL_FALSE;
1264 LockUIntMapRead(&context->EffectSlotMap);
1265 for(pos = 0;pos < context->EffectSlotMap.size;pos++)
1266 {
1267 ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
1268
1269 if(ALeffectState_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
1270 {
1271 UnlockUIntMapRead(&context->EffectSlotMap);
1272 RestoreFPUMode(oldMode);
1273 UnlockDevice(device);
1274 ALCdevice_StopPlayback(device);
1275 device->Flags &= ~DEVICE_RUNNING;
1276 return ALC_INVALID_DEVICE;
1277 }
1278 slot->NeedsUpdate = AL_FALSE;
1279 ALeffectState_Update(slot->EffectState, context, slot);
1280 }
1281 UnlockUIntMapRead(&context->EffectSlotMap);
1282
1283 LockUIntMapRead(&context->SourceMap);
1284 for(pos = 0;pos < context->SourceMap.size;pos++)
1285 {
1286 ALsource *source = context->SourceMap.array[pos].value;
1287 ALuint s = device->NumAuxSends;
1288 while(s < MAX_SENDS)
1289 {
1290 if(source->Send[s].Slot)
1291 DecrementRef(&source->Send[s].Slot->ref);
1292 source->Send[s].Slot = NULL;
1293 source->Send[s].WetGain = 1.0f;
1294 source->Send[s].WetGainHF = 1.0f;
1295 s++;
1296 }
1297 source->NeedsUpdate = AL_FALSE;
1298 ALsource_Update(source, context);
1299 }
1300 UnlockUIntMapRead(&context->SourceMap);
1301
1302 context = context->next;
1303 }
1304 RestoreFPUMode(oldMode);
1305 UnlockDevice(device);
1306
1307 return ALC_NO_ERROR;
1308 }
1309
1310 /* FreeDevice
1311 *
1312 * Frees the device structure, and destroys any objects the app failed to
1313 * delete. Called once there's no more references on the device.
1314 */
1315 static ALCvoid FreeDevice(ALCdevice *device)
1316 {
1317 TRACE("%p\n", device);
1318
1319 if(device->DefaultSlot)
1320 {
1321 ALeffectState_Destroy(device->DefaultSlot->EffectState);
1322 device->DefaultSlot->EffectState = NULL;
1323 }
1324
1325 if(device->BufferMap.size > 0)
1326 {
1327 WARN("(%p) Deleting %d Buffer(s)\n", device, device->BufferMap.size);
1328 ReleaseALBuffers(device);
1329 }
1330 ResetUIntMap(&device->BufferMap);
1331
1332 if(device->EffectMap.size > 0)
1333 {
1334 WARN("(%p) Deleting %d Effect(s)\n", device, device->EffectMap.size);
1335 ReleaseALEffects(device);
1336 }
1337 ResetUIntMap(&device->EffectMap);
1338
1339 if(device->FilterMap.size > 0)
1340 {
1341 WARN("(%p) Deleting %d Filter(s)\n", device, device->FilterMap.size);
1342 ReleaseALFilters(device);
1343 }
1344 ResetUIntMap(&device->FilterMap);
1345
1346 free(device->Bs2b);
1347 device->Bs2b = NULL;
1348
1349 free(device->szDeviceName);
1350 device->szDeviceName = NULL;
1351
1352 DeleteCriticalSection(&device->Mutex);
1353
1354 free(device);
1355 }
1356
1357
1358 void ALCdevice_IncRef(ALCdevice *device)
1359 {
1360 RefCount ref;
1361 ref = IncrementRef(&device->ref);
1362 TRACEREF("%p increasing refcount to %u\n", device, ref);
1363 }
1364
1365 void ALCdevice_DecRef(ALCdevice *device)
1366 {
1367 RefCount ref;
1368 ref = DecrementRef(&device->ref);
1369 TRACEREF("%p decreasing refcount to %u\n", device, ref);
1370 if(ref == 0) FreeDevice(device);
1371 }
1372
1373 /* VerifyDevice
1374 *
1375 * Checks if the device handle is valid, and increments its ref count if so.
1376 */
1377 static ALCdevice *VerifyDevice(ALCdevice *device)
1378 {
1379 ALCdevice *tmpDevice;
1380
1381 if(!device)
1382 return NULL;
1383
1384 LockLists();
1385 tmpDevice = DeviceList;
1386 while(tmpDevice && tmpDevice != device)
1387 tmpDevice = tmpDevice->next;
1388
1389 if(tmpDevice)
1390 ALCdevice_IncRef(tmpDevice);
1391 UnlockLists();
1392 return tmpDevice;
1393 }
1394
1395
1396 /* InitContext
1397 *
1398 * Initializes context variables
1399 */
1400 static ALvoid InitContext(ALCcontext *pContext)
1401 {
1402 ALint i, j;
1403
1404 //Initialise listener
1405 pContext->Listener.Gain = 1.0f;
1406 pContext->Listener.MetersPerUnit = 1.0f;
1407 pContext->Listener.Position[0] = 0.0f;
1408 pContext->Listener.Position[1] = 0.0f;
1409 pContext->Listener.Position[2] = 0.0f;
1410 pContext->Listener.Velocity[0] = 0.0f;
1411 pContext->Listener.Velocity[1] = 0.0f;
1412 pContext->Listener.Velocity[2] = 0.0f;
1413 pContext->Listener.Forward[0] = 0.0f;
1414 pContext->Listener.Forward[1] = 0.0f;
1415 pContext->Listener.Forward[2] = -1.0f;
1416 pContext->Listener.Up[0] = 0.0f;
1417 pContext->Listener.Up[1] = 1.0f;
1418 pContext->Listener.Up[2] = 0.0f;
1419 for(i = 0;i < 4;i++)
1420 {
1421 for(j = 0;j < 4;j++)
1422 pContext->Listener.Matrix[i][j] = ((i==j) ? 1.0f : 0.0f);
1423 }
1424
1425 //Validate pContext
1426 pContext->LastError = AL_NO_ERROR;
1427 pContext->UpdateSources = AL_FALSE;
1428 pContext->ActiveSourceCount = 0;
1429 InitUIntMap(&pContext->SourceMap, pContext->Device->MaxNoOfSources);
1430 InitUIntMap(&pContext->EffectSlotMap, pContext->Device->AuxiliaryEffectSlotMax);
1431
1432 //Set globals
1433 pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
1434 pContext->SourceDistanceModel = AL_FALSE;
1435 pContext->DopplerFactor = 1.0f;
1436 pContext->DopplerVelocity = 1.0f;
1437 pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
1438 pContext->DeferUpdates = AL_FALSE;
1439
1440 pContext->ExtensionList = alExtList;
1441 }
1442
1443
1444 /* FreeContext
1445 *
1446 * Cleans up the context, and destroys any remaining objects the app failed to
1447 * delete. Called once there's no more references on the context.
1448 */
1449 static ALCvoid FreeContext(ALCcontext *context)
1450 {
1451 TRACE("%p\n", context);
1452
1453 if(context->SourceMap.size > 0)
1454 {
1455 ERR("(%p) Deleting %d Source(s)\n", context, context->SourceMap.size);
1456 ReleaseALSources(context);
1457 }
1458 ResetUIntMap(&context->SourceMap);
1459
1460 if(context->EffectSlotMap.size > 0)
1461 {
1462 ERR("(%p) Deleting %d AuxiliaryEffectSlot(s)\n", context, context->EffectSlotMap.size);
1463 ReleaseALAuxiliaryEffectSlots(context);
1464 }
1465 ResetUIntMap(&context->EffectSlotMap);
1466
1467 context->ActiveSourceCount = 0;
1468 free(context->ActiveSources);
1469 context->ActiveSources = NULL;
1470 context->MaxActiveSources = 0;
1471
1472 context->ActiveEffectSlotCount = 0;
1473 free(context->ActiveEffectSlots);
1474 context->ActiveEffectSlots = NULL;
1475 context->MaxActiveEffectSlots = 0;
1476
1477 ALCdevice_DecRef(context->Device);
1478 context->Device = NULL;
1479
1480 //Invalidate context
1481 memset(context, 0, sizeof(ALCcontext));
1482 free(context);
1483 }
1484
1485 /* ReleaseContext
1486 *
1487 * Removes the context reference from the given device and removes it from
1488 * being current on the running thread or globally.
1489 */
1490 static void ReleaseContext(ALCcontext *context, ALCdevice *device)
1491 {
1492 ALCcontext *volatile*tmp_ctx;
1493
1494 if(pthread_getspecific(LocalContext) == context)
1495 {
1496 WARN("%p released while current on thread\n", context);
1497 pthread_setspecific(LocalContext, NULL);
1498 ALCcontext_DecRef(context);
1499 }
1500
1501 if(CompExchangePtr((XchgPtr*)&GlobalContext, context, NULL))
1502 ALCcontext_DecRef(context);
1503
1504 LockDevice(device);
1505 tmp_ctx = &device->ContextList;
1506 while(*tmp_ctx)
1507 {
1508 if(CompExchangePtr((XchgPtr*)tmp_ctx, context, context->next))
1509 break;
1510 tmp_ctx = &(*tmp_ctx)->next;
1511 }
1512 UnlockDevice(device);
1513
1514 ALCcontext_DecRef(context);
1515 }
1516
1517 void ALCcontext_IncRef(ALCcontext *context)
1518 {
1519 RefCount ref;
1520 ref = IncrementRef(&context->ref);
1521 TRACEREF("%p increasing refcount to %u\n", context, ref);
1522 }
1523
1524 void ALCcontext_DecRef(ALCcontext *context)
1525 {
1526 RefCount ref;
1527 ref = DecrementRef(&context->ref);
1528 TRACEREF("%p decreasing refcount to %u\n", context, ref);
1529 if(ref == 0) FreeContext(context);
1530 }
1531
1532 static void ReleaseThreadCtx(void *ptr)
1533 {
1534 WARN("%p current for thread being destroyed\n", ptr);
1535 ALCcontext_DecRef(ptr);
1536 }
1537
1538 /* VerifyContext
1539 *
1540 * Checks that the given context is valid, and increments its reference count.
1541 */
1542 static ALCcontext *VerifyContext(ALCcontext *context)
1543 {
1544 ALCdevice *dev;
1545
1546 LockLists();
1547 dev = DeviceList;
1548 while(dev)
1549 {
1550 ALCcontext *tmp_ctx = dev->ContextList;
1551 while(tmp_ctx)
1552 {
1553 if(tmp_ctx == context)
1554 {
1555 ALCcontext_IncRef(tmp_ctx);
1556 UnlockLists();
1557 return tmp_ctx;
1558 }
1559 tmp_ctx = tmp_ctx->next;
1560 }
1561 dev = dev->next;
1562 }
1563 UnlockLists();
1564
1565 return NULL;
1566 }
1567
1568
1569 /* GetContextRef
1570 *
1571 * Returns the currently active context, and adds a reference without locking
1572 * it.
1573 */
1574 ALCcontext *GetContextRef(void)
1575 {
1576 ALCcontext *context;
1577
1578 context = pthread_getspecific(LocalContext);
1579 if(context)
1580 ALCcontext_IncRef(context);
1581 else
1582 {
1583 LockLists();
1584 context = GlobalContext;
1585 if(context)
1586 ALCcontext_IncRef(context);
1587 UnlockLists();
1588 }
1589
1590 return context;
1591 }
1592
1593 ///////////////////////////////////////////////////////
1594
1595
1596 ///////////////////////////////////////////////////////
1597 // ALC Functions calls
1598
1599
1600 // This should probably move to another c file but for now ...
1601 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
1602 {
1603 ALCdevice *device = NULL;
1604 ALCenum err;
1605
1606 DO_INITCONFIG();
1607
1608 if(!CaptureBackend.name)
1609 {
1610 alcSetError(NULL, ALC_INVALID_VALUE);
1611 return NULL;
1612 }
1613
1614 if(SampleSize <= 0)
1615 {
1616 alcSetError(NULL, ALC_INVALID_VALUE);
1617 return NULL;
1618 }
1619
1620 if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))
1621 deviceName = NULL;
1622
1623 device = calloc(1, sizeof(ALCdevice));
1624 if(!device)
1625 {
1626 alcSetError(NULL, ALC_OUT_OF_MEMORY);
1627 return NULL;
1628 }
1629
1630 //Validate device
1631 device->Funcs = &CaptureBackend.Funcs;
1632 device->ref = 1;
1633 device->Connected = ALC_TRUE;
1634 device->IsCaptureDevice = AL_TRUE;
1635 device->IsLoopbackDevice = AL_FALSE;
1636 InitializeCriticalSection(&device->Mutex);
1637
1638 InitUIntMap(&device->BufferMap, ~0);
1639 InitUIntMap(&device->EffectMap, ~0);
1640 InitUIntMap(&device->FilterMap, ~0);
1641
1642 device->szDeviceName = NULL;
1643
1644 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1645 device->Frequency = frequency;
1646
1647 device->Flags |= DEVICE_CHANNELS_REQUEST;
1648 if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
1649 {
1650 DeleteCriticalSection(&device->Mutex);
1651 free(device);
1652 alcSetError(NULL, ALC_INVALID_ENUM);
1653 return NULL;
1654 }
1655
1656 device->UpdateSize = SampleSize;
1657 device->NumUpdates = 1;
1658
1659 LockLists();
1660 if((err=ALCdevice_OpenCapture(device, deviceName)) != ALC_NO_ERROR)
1661 {
1662 UnlockLists();
1663 DeleteCriticalSection(&device->Mutex);
1664 free(device);
1665 alcSetError(NULL, err);
1666 return NULL;
1667 }
1668 UnlockLists();
1669
1670 do {
1671 device->next = DeviceList;
1672 } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
1673
1674 TRACE("Created device %p\n", device);
1675 return device;
1676 }
1677
1678 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
1679 {
1680 ALCdevice *volatile*list;
1681
1682 LockLists();
1683 list = &DeviceList;
1684 while(*list && *list != pDevice)
1685 list = &(*list)->next;
1686
1687 if(!*list || !(*list)->IsCaptureDevice)
1688 {
1689 alcSetError(*list, ALC_INVALID_DEVICE);
1690 UnlockLists();
1691 return ALC_FALSE;
1692 }
1693
1694 *list = (*list)->next;
1695 UnlockLists();
1696
1697 LockDevice(pDevice);
1698 ALCdevice_CloseCapture(pDevice);
1699 UnlockDevice(pDevice);
1700
1701 ALCdevice_DecRef(pDevice);
1702
1703 return ALC_TRUE;
1704 }
1705
1706 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
1707 {
1708 if(!(device=VerifyDevice(device)) || !device->IsCaptureDevice)
1709 {
1710 alcSetError(device, ALC_INVALID_DEVICE);
1711 if(device) ALCdevice_DecRef(device);
1712 return;
1713 }
1714 LockDevice(device);
1715 if(device->Connected)
1716 ALCdevice_StartCapture(device);
1717 UnlockDevice(device);
1718
1719 ALCdevice_DecRef(device);
1720 }
1721
1722 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
1723 {
1724 if(!(device=VerifyDevice(device)) || !device->IsCaptureDevice)
1725 {
1726 alcSetError(device, ALC_INVALID_DEVICE);
1727 if(device) ALCdevice_DecRef(device);
1728 return;
1729 }
1730 LockDevice(device);
1731 if(device->Connected)
1732 ALCdevice_StopCapture(device);
1733 UnlockDevice(device);
1734
1735 ALCdevice_DecRef(device);
1736 }
1737
1738 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
1739 {
1740 ALCenum err = ALC_INVALID_DEVICE;
1741 if((device=VerifyDevice(device)) != NULL && device->IsCaptureDevice)
1742 {
1743 err = ALC_INVALID_VALUE;
1744 LockDevice(device);
1745 if(samples >= 0 && ALCdevice_AvailableSamples(device) >= (ALCuint)samples)
1746 err = ALCdevice_CaptureSamples(device, buffer, samples);
1747 UnlockDevice(device);
1748 }
1749 if(err != ALC_NO_ERROR)
1750 alcSetError(device, err);
1751 if(device) ALCdevice_DecRef(device);
1752 }
1753
1754 /*
1755 alcGetError
1756
1757 Return last ALC generated error code
1758 */
1759 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
1760 {
1761 ALCenum errorCode;
1762
1763 if(VerifyDevice(device))
1764 {
1765 errorCode = ExchangeInt(&device->LastError, ALC_NO_ERROR);
1766 ALCdevice_DecRef(device);
1767 }
1768 else
1769 errorCode = ExchangeInt(&g_eLastNullDeviceError, ALC_NO_ERROR);
1770
1771 return errorCode;
1772 }
1773
1774
1775 /* alcSuspendContext
1776 *
1777 * Not functional
1778 */
1779 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *Context)
1780 {
1781 (void)Context;
1782 }
1783
1784 /* alcProcessContext
1785 *
1786 * Not functional
1787 */
1788 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *Context)
1789 {
1790 (void)Context;
1791 }
1792
1793
1794 /* alcGetString
1795 *
1796 * Returns information about the Device, and error strings
1797 */
1798 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
1799 {
1800 const ALCchar *value = NULL;
1801
1802 switch(param)
1803 {
1804 case ALC_NO_ERROR:
1805 value = alcNoError;
1806 break;
1807
1808 case ALC_INVALID_ENUM:
1809 value = alcErrInvalidEnum;
1810 break;
1811
1812 case ALC_INVALID_VALUE:
1813 value = alcErrInvalidValue;
1814 break;
1815
1816 case ALC_INVALID_DEVICE:
1817 value = alcErrInvalidDevice;
1818 break;
1819
1820 case ALC_INVALID_CONTEXT:
1821 value = alcErrInvalidContext;
1822 break;
1823
1824 case ALC_OUT_OF_MEMORY:
1825 value = alcErrOutOfMemory;
1826 break;
1827
1828 case ALC_DEVICE_SPECIFIER:
1829 if(VerifyDevice(pDevice))
1830 {
1831 value = pDevice->szDeviceName;
1832 ALCdevice_DecRef(pDevice);
1833 }
1834 else
1835 {
1836 ProbeDeviceList();
1837 value = alcDeviceList;
1838 }
1839 break;
1840
1841 case ALC_ALL_DEVICES_SPECIFIER:
1842 ProbeAllDeviceList();
1843 value = alcAllDeviceList;
1844 break;
1845
1846 case ALC_CAPTURE_DEVICE_SPECIFIER:
1847 if(VerifyDevice(pDevice))
1848 {
1849 value = pDevice->szDeviceName;
1850 ALCdevice_DecRef(pDevice);
1851 }
1852 else
1853 {
1854 ProbeCaptureDeviceList();
1855 value = alcCaptureDeviceList;
1856 }
1857 break;
1858
1859 /* Default devices are always first in the list */
1860 case ALC_DEFAULT_DEVICE_SPECIFIER:
1861 if(!alcDeviceList)
1862 ProbeDeviceList();
1863
1864 pDevice = VerifyDevice(pDevice);
1865
1866 free(alcDefaultDeviceSpecifier);
1867 alcDefaultDeviceSpecifier = strdup(alcDeviceList ? alcDeviceList : "");
1868 if(!alcDefaultDeviceSpecifier)
1869 alcSetError(pDevice, ALC_OUT_OF_MEMORY);
1870
1871 value = alcDefaultDeviceSpecifier;
1872 if(pDevice) ALCdevice_DecRef(pDevice);
1873 break;
1874
1875 case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
1876 if(!alcAllDeviceList)
1877 ProbeAllDeviceList();
1878
1879 pDevice = VerifyDevice(pDevice);
1880
1881 free(alcDefaultAllDeviceSpecifier);
1882 alcDefaultAllDeviceSpecifier = strdup(alcAllDeviceList ?
1883 alcAllDeviceList : "");
1884 if(!alcDefaultAllDeviceSpecifier)
1885 alcSetError(pDevice, ALC_OUT_OF_MEMORY);
1886
1887 value = alcDefaultAllDeviceSpecifier;
1888 if(pDevice) ALCdevice_DecRef(pDevice);
1889 break;
1890
1891 case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
1892 if(!alcCaptureDeviceList)
1893 ProbeCaptureDeviceList();
1894
1895 pDevice = VerifyDevice(pDevice);
1896
1897 free(alcCaptureDefaultDeviceSpecifier);
1898 alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?
1899 alcCaptureDeviceList : "");
1900 if(!alcCaptureDefaultDeviceSpecifier)
1901 alcSetError(pDevice, ALC_OUT_OF_MEMORY);
1902
1903 value = alcCaptureDefaultDeviceSpecifier;
1904 if(pDevice) ALCdevice_DecRef(pDevice);
1905 break;
1906
1907 case ALC_EXTENSIONS:
1908 if(!VerifyDevice(pDevice))
1909 value = alcNoDeviceExtList;
1910 else
1911 {
1912 value = alcExtensionList;
1913 ALCdevice_DecRef(pDevice);
1914 }
1915 break;
1916
1917 default:
1918 pDevice = VerifyDevice(pDevice);
1919 alcSetError(pDevice, ALC_INVALID_ENUM);
1920 if(pDevice) ALCdevice_DecRef(pDevice);
1921 break;
1922 }
1923
1924 return value;
1925 }
1926
1927
1928 /* alcGetIntegerv
1929 *
1930 * Returns information about the Device and the version of Open AL
1931 */
1932 ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
1933 {
1934 device = VerifyDevice(device);
1935
1936 if(size == 0 || data == NULL)
1937 {
1938 alcSetError(device, ALC_INVALID_VALUE);
1939 if(device) ALCdevice_DecRef(device);
1940 return;
1941 }
1942
1943 if(!device)
1944 {
1945 switch(param)
1946 {
1947 case ALC_MAJOR_VERSION:
1948 *data = alcMajorVersion;
1949 break;
1950 case ALC_MINOR_VERSION:
1951 *data = alcMinorVersion;
1952 break;
1953
1954 case ALC_ATTRIBUTES_SIZE:
1955 case ALC_ALL_ATTRIBUTES:
1956 case ALC_FREQUENCY:
1957 case ALC_REFRESH:
1958 case ALC_SYNC:
1959 case ALC_MONO_SOURCES:
1960 case ALC_STEREO_SOURCES:
1961 case ALC_CAPTURE_SAMPLES:
1962 case ALC_FORMAT_CHANNELS_SOFT:
1963 case ALC_FORMAT_TYPE_SOFT:
1964 alcSetError(NULL, ALC_INVALID_DEVICE);
1965 break;
1966
1967 default:
1968 alcSetError(NULL, ALC_INVALID_ENUM);
1969 break;
1970 }
1971 }
1972 else if(device->IsCaptureDevice)
1973 {
1974 switch(param)
1975 {
1976 case ALC_CAPTURE_SAMPLES:
1977 LockDevice(device);
1978 *data = ALCdevice_AvailableSamples(device);
1979 UnlockDevice(device);
1980 break;
1981
1982 case ALC_CONNECTED:
1983 *data = device->Connected;
1984 break;
1985
1986 default:
1987 alcSetError(device, ALC_INVALID_ENUM);
1988 break;
1989 }
1990 }
1991 else /* render device */
1992 {
1993 switch(param)
1994 {
1995 case ALC_MAJOR_VERSION:
1996 *data = alcMajorVersion;
1997 break;
1998
1999 case ALC_MINOR_VERSION:
2000 *data = alcMinorVersion;
2001 break;
2002
2003 case ALC_EFX_MAJOR_VERSION:
2004 *data = alcEFXMajorVersion;
2005 break;
2006
2007 case ALC_EFX_MINOR_VERSION:
2008 *data = alcEFXMinorVersion;
2009 break;
2010
2011 case ALC_ATTRIBUTES_SIZE:
2012 *data = 13;
2013 break;
2014
2015 case ALC_ALL_ATTRIBUTES:
2016 if(size < 13)
2017 alcSetError(device, ALC_INVALID_VALUE);
2018 else
2019 {
2020 int i = 0;
2021
2022 data[i++] = ALC_FREQUENCY;
2023 data[i++] = device->Frequency;
2024
2025 if(!device->IsLoopbackDevice)
2026 {
2027 data[i++] = ALC_REFRESH;
2028 data[i++] = device->Frequency / device->UpdateSize;
2029
2030 data[i++] = ALC_SYNC;
2031 data[i++] = ALC_FALSE;
2032 }
2033 else
2034 {
2035 data[i++] = ALC_FORMAT_CHANNELS_SOFT;
2036 data[i++] = device->FmtChans;
2037
2038 data[i++] = ALC_FORMAT_TYPE_SOFT;
2039 data[i++] = device->FmtType;
2040 }
2041
2042 data[i++] = ALC_MONO_SOURCES;
2043 data[i++] = device->NumMonoSources;
2044
2045 data[i++] = ALC_STEREO_SOURCES;
2046 data[i++] = device->NumStereoSources;
2047
2048 data[i++] = ALC_MAX_AUXILIARY_SENDS;
2049 data[i++] = device->NumAuxSends;
2050
2051 data[i++] = 0;
2052 }
2053 break;
2054
2055 case ALC_FREQUENCY:
2056 *data = device->Frequency;
2057 break;
2058
2059 case ALC_REFRESH:
2060 if(device->IsLoopbackDevice)
2061 alcSetError(device, ALC_INVALID_DEVICE);
2062 else
2063 *data = device->Frequency / device->UpdateSize;
2064 break;
2065
2066 case ALC_SYNC:
2067 if(device->IsLoopbackDevice)
2068 alcSetError(device, ALC_INVALID_DEVICE);
2069 else
2070 *data = ALC_FALSE;
2071 break;
2072
2073 case ALC_FORMAT_CHANNELS_SOFT:
2074 if(!device->IsLoopbackDevice)
2075 alcSetError(device, ALC_INVALID_DEVICE);
2076 else
2077 *data = device->FmtChans;
2078 break;
2079
2080 case ALC_FORMAT_TYPE_SOFT:
2081 if(!device->IsLoopbackDevice)
2082 alcSetError(device, ALC_INVALID_DEVICE);
2083 else
2084 *data = device->FmtType;
2085 break;
2086
2087 case ALC_MONO_SOURCES:
2088 *data = device->NumMonoSources;
2089 break;
2090
2091 case ALC_STEREO_SOURCES:
2092 *data = device->NumStereoSources;
2093 break;
2094
2095 case ALC_MAX_AUXILIARY_SENDS:
2096 *data = device->NumAuxSends;
2097 break;
2098
2099 case ALC_CONNECTED:
2100 *data = device->Connected;
2101 break;
2102
2103 default:
2104 alcSetError(device, ALC_INVALID_ENUM);
2105 break;
2106 }
2107 }
2108 if(device)
2109 ALCdevice_DecRef(device);
2110 }
2111
2112
2113 /* alcIsExtensionPresent
2114 *
2115 * Determines if there is support for a particular extension
2116 */
2117 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
2118 {
2119 ALCboolean bResult = ALC_FALSE;
2120
2121 device = VerifyDevice(device);
2122
2123 if(!extName)
2124 alcSetError(device, ALC_INVALID_VALUE);
2125 else
2126 {
2127 size_t len = strlen(extName);
2128 const char *ptr = (device ? alcExtensionList : alcNoDeviceExtList);
2129 while(ptr && *ptr)
2130 {
2131 if(strncasecmp(ptr, extName, len) == 0 &&
2132 (ptr[len] == '\0' || isspace(ptr[len])))
2133 {
2134 bResult = ALC_TRUE;
2135 break;
2136 }
2137 if((ptr=strchr(ptr, ' ')) != NULL)
2138 {
2139 do {
2140 ++ptr;
2141 } while(isspace(*ptr));
2142 }
2143 }
2144 }
2145 if(device)
2146 ALCdevice_DecRef(device);
2147 return bResult;
2148 }
2149
2150
2151 /* alcGetProcAddress
2152 *
2153 * Retrieves the function address for a particular extension function
2154 */
2155 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
2156 {
2157 ALCvoid *ptr = NULL;
2158
2159 device = VerifyDevice(device);
2160
2161 if(!funcName)
2162 alcSetError(device, ALC_INVALID_VALUE);
2163 else
2164 {
2165 ALsizei i = 0;
2166 while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName,funcName) != 0)
2167 i++;
2168 ptr = alcFunctions[i].address;
2169 }
2170 if(device)
2171 ALCdevice_DecRef(device);
2172 return ptr;
2173 }
2174
2175
2176 /* alcGetEnumValue
2177 *
2178 * Get the value for a particular ALC Enumerated Value
2179 */
2180 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
2181 {
2182 ALCenum val = 0;
2183
2184 device = VerifyDevice(device);
2185
2186 if(!enumName)
2187 alcSetError(device, ALC_INVALID_VALUE);
2188 else
2189 {
2190 ALsizei i = 0;
2191 while(enumeration[i].enumName && strcmp(enumeration[i].enumName,enumName) != 0)
2192 i++;
2193 val = enumeration[i].value;
2194 }
2195 if(device)
2196 ALCdevice_DecRef(device);
2197 return val;
2198 }
2199
2200
2201 /* alcCreateContext
2202 *
2203 * Create and attach a Context to a particular Device.
2204 */
2205 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
2206 {
2207 ALCcontext *ALContext;
2208 ALCenum err;
2209
2210 LockLists();
2211 if(!(device=VerifyDevice(device)) || device->IsCaptureDevice || !device->Connected)
2212 {
2213 UnlockLists();
2214 alcSetError(device, ALC_INVALID_DEVICE);
2215 if(device) ALCdevice_DecRef(device);
2216 return NULL;
2217 }
2218
2219 /* Reset Context Last Error code */
2220 device->LastError = ALC_NO_ERROR;
2221
2222 if((err=UpdateDeviceParams(device, attrList)) != ALC_NO_ERROR)
2223 {
2224 UnlockLists();
2225 alcSetError(device, err);
2226 if(err == ALC_INVALID_DEVICE)
2227 aluHandleDisconnect(device);
2228 ALCdevice_DecRef(device);
2229 return NULL;
2230 }
2231
2232 ALContext = calloc(1, sizeof(ALCcontext));
2233 if(ALContext)
2234 {
2235 ALContext->ref = 1;
2236
2237 ALContext->MaxActiveSources = 256;
2238 ALContext->ActiveSources = malloc(sizeof(ALContext->ActiveSources[0]) *
2239 ALContext->MaxActiveSources);
2240 }
2241 if(!ALContext || !ALContext->ActiveSources)
2242 {
2243 if(!device->ContextList)
2244 {
2245 ALCdevice_StopPlayback(device);
2246 device->Flags &= ~DEVICE_RUNNING;
2247 }
2248 UnlockLists();
2249
2250 free(ALContext);
2251 ALContext = NULL;
2252
2253 alcSetError(device, ALC_OUT_OF_MEMORY);
2254 ALCdevice_DecRef(device);
2255 return NULL;
2256 }
2257
2258 ALContext->Device = device;
2259 ALCdevice_IncRef(device);
2260 InitContext(ALContext);
2261
2262 do {
2263 ALContext->next = device->ContextList;
2264 } while(!CompExchangePtr((XchgPtr*)&device->ContextList, ALContext->next, ALContext));
2265 UnlockLists();
2266
2267 if(device->DefaultSlot)
2268 InitializeEffect(ALContext, device->DefaultSlot, &ForcedEffect);
2269 ALContext->LastError = AL_NO_ERROR;
2270
2271 ALCdevice_DecRef(device);
2272
2273 TRACE("Created context %p\n", ALContext);
2274 return ALContext;
2275 }
2276
2277 /* alcDestroyContext
2278 *
2279 * Remove a Context
2280 */
2281 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
2282 {
2283 ALCdevice *Device;
2284
2285 LockLists();
2286 /* alcGetContextsDevice sets an error for invalid contexts */
2287 Device = alcGetContextsDevice(context);
2288 if(Device)
2289 {
2290 ReleaseContext(context, Device);
2291 if(!Device->ContextList)
2292 {
2293 ALCdevice_StopPlayback(Device);
2294 Device->Flags &= ~DEVICE_RUNNING;
2295 }
2296 }
2297 UnlockLists();
2298 }
2299
2300
2301 /* alcGetCurrentContext
2302 *
2303 * Returns the currently active Context
2304 */
2305 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(ALCvoid)
2306 {
2307 ALCcontext *Context;
2308
2309 Context = pthread_getspecific(LocalContext);
2310 if(!Context) Context = GlobalContext;
2311
2312 return Context;
2313 }
2314
2315 /* alcGetThreadContext
2316 *
2317 * Returns the currently active thread-local Context
2318 */
2319 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
2320 {
2321 ALCcontext *Context;
2322 Context = pthread_getspecific(LocalContext);
2323 return Context;
2324 }
2325
2326
2327 /* alcMakeContextCurrent
2328 *
2329 * Makes the given Context the active Context
2330 */
2331 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
2332 {
2333 /* context must be a valid Context or NULL */
2334 if(context && !(context=VerifyContext(context)))
2335 {
2336 alcSetError(NULL, ALC_INVALID_CONTEXT);
2337 return ALC_FALSE;
2338 }
2339 /* context's reference count is already incremented */
2340 context = ExchangePtr((XchgPtr*)&GlobalContext, context);
2341 if(context) ALCcontext_DecRef(context);
2342
2343 if((context=pthread_getspecific(LocalContext)) != NULL)
2344 {
2345 pthread_setspecific(LocalContext, NULL);
2346 ALCcontext_DecRef(context);
2347 }
2348
2349 return ALC_TRUE;
2350 }
2351
2352 /* alcSetThreadContext
2353 *
2354 * Makes the given Context the active Context for the current thread
2355 */
2356 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
2357 {
2358 ALCcontext *old;
2359
2360 /* context must be a valid Context or NULL */
2361 if(context && !(context=VerifyContext(context)))
2362 {
2363 alcSetError(NULL, ALC_INVALID_CONTEXT);
2364 return ALC_FALSE;
2365 }
2366 /* context's reference count is already incremented */
2367 old = pthread_getspecific(LocalContext);
2368 pthread_setspecific(LocalContext, context);
2369 if(old) ALCcontext_DecRef(old);
2370
2371 return ALC_TRUE;
2372 }
2373
2374
2375 /* alcGetContextsDevice
2376 *
2377 * Returns the Device that a particular Context is attached to
2378 */
2379 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
2380 {
2381 ALCdevice *Device;
2382
2383 if(!(Context=VerifyContext(Context)))
2384 {
2385 alcSetError(NULL, ALC_INVALID_CONTEXT);
2386 return NULL;
2387 }
2388 Device = Context->Device;
2389 ALCcontext_DecRef(Context);
2390
2391 return Device;
2392 }
2393
2394
2395 static void GetFormatFromString(const char *str, enum DevFmtChannels *chans, enum DevFmtType *type)
2396 {
2397 static const struct {
2398 const char name[32];
2399 enum DevFmtChannels channels;
2400 enum DevFmtType type;
2401 } formats[] = {
2402 { "AL_FORMAT_MONO32", DevFmtMono, DevFmtFloat },
2403 { "AL_FORMAT_STEREO32", DevFmtStereo, DevFmtFloat },
2404 { "AL_FORMAT_QUAD32", DevFmtQuad, DevFmtFloat },
2405 { "AL_FORMAT_51CHN32", DevFmtX51, DevFmtFloat },
2406 { "AL_FORMAT_61CHN32", DevFmtX61, DevFmtFloat },
2407 { "AL_FORMAT_71CHN32", DevFmtX71, DevFmtFloat },
2408
2409 { "AL_FORMAT_MONO16", DevFmtMono, DevFmtShort },
2410 { "AL_FORMAT_STEREO16", DevFmtStereo, DevFmtShort },
2411 { "AL_FORMAT_QUAD16", DevFmtQuad, DevFmtShort },
2412 { "AL_FORMAT_51CHN16", DevFmtX51, DevFmtShort },
2413 { "AL_FORMAT_61CHN16", DevFmtX61, DevFmtShort },
2414 { "AL_FORMAT_71CHN16", DevFmtX71, DevFmtShort },
2415
2416 { "AL_FORMAT_MONO8", DevFmtMono, DevFmtByte },
2417 { "AL_FORMAT_STEREO8", DevFmtStereo, DevFmtByte },
2418 { "AL_FORMAT_QUAD8", DevFmtQuad, DevFmtByte },
2419 { "AL_FORMAT_51CHN8", DevFmtX51, DevFmtByte },
2420 { "AL_FORMAT_61CHN8", DevFmtX61, DevFmtByte },
2421 { "AL_FORMAT_71CHN8", DevFmtX71, DevFmtByte }
2422 };
2423 size_t i;
2424
2425 for(i = 0;i < sizeof(formats)/sizeof(formats[0]);i++)
2426 {
2427 if(strcasecmp(str, formats[i].name) == 0)
2428 {
2429 *chans = formats[i].channels;
2430 *type = formats[i].type;
2431 return;
2432 }
2433 }
2434
2435 ERR("Unknown format: \"%s\"\n", str);
2436 *chans = DevFmtStereo;
2437 *type = DevFmtShort;
2438 }
2439
2440 /* alcOpenDevice
2441 *
2442 * Open the Device specified.
2443 */
2444 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
2445 {
2446 const ALCchar *fmt;
2447 ALCdevice *device;
2448 ALCenum err;
2449
2450 DO_INITCONFIG();
2451
2452 if(!PlaybackBackend.name)
2453 {
2454 alcSetError(NULL, ALC_INVALID_VALUE);
2455 return NULL;
2456 }
2457
2458 if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))
2459 deviceName = NULL;
2460
2461 device = calloc(1, sizeof(ALCdevice)+sizeof(ALeffectslot));
2462 if(!device)
2463 {
2464 alcSetError(NULL, ALC_OUT_OF_MEMORY);
2465 return NULL;
2466 }
2467
2468 //Validate device
2469 device->Funcs = &PlaybackBackend.Funcs;
2470 device->ref = 1;
2471 device->Connected = ALC_TRUE;
2472 device->IsCaptureDevice = AL_FALSE;
2473 device->IsLoopbackDevice = AL_FALSE;
2474 InitializeCriticalSection(&device->Mutex);
2475 device->LastError = ALC_NO_ERROR;
2476
2477 device->Flags = 0;
2478 device->Bs2b = NULL;
2479 device->Bs2bLevel = 0;
2480 device->szDeviceName = NULL;
2481
2482 device->ContextList = NULL;
2483
2484 device->MaxNoOfSources = 256;
2485 device->AuxiliaryEffectSlotMax = 4;
2486 device->NumAuxSends = MAX_SENDS;
2487
2488 InitUIntMap(&device->BufferMap, ~0);
2489 InitUIntMap(&device->EffectMap, ~0);
2490 InitUIntMap(&device->FilterMap, ~0);
2491
2492 //Set output format
2493 device->NumUpdates = 4;
2494 device->UpdateSize = 1024;
2495
2496 device->Frequency = DEFAULT_OUTPUT_RATE;
2497 if(ConfigValueUInt(NULL, "frequency", &device->Frequency))
2498 device->Flags |= DEVICE_FREQUENCY_REQUEST;
2499 device->Frequency = maxu(device->Frequency, 8000);
2500
2501 fmt = "AL_FORMAT_STEREO32";
2502 if(ConfigValueStr(NULL, "format", &fmt))
2503 device->Flags |= DEVICE_CHANNELS_REQUEST;
2504 GetFormatFromString(fmt, &device->FmtChans, &device->FmtType);
2505
2506 ConfigValueUInt(NULL, "periods", &device->NumUpdates);
2507 if(device->NumUpdates < 2) device->NumUpdates = 4;
2508
2509 ConfigValueUInt(NULL, "period_size", &device->UpdateSize);
2510 if(device->UpdateSize == 0) device->UpdateSize = 1024;
2511
2512 ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
2513 if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
2514
2515 ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
2516 if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
2517
2518 ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
2519 if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
2520
2521 ConfigValueInt(NULL, "cf_level", &device->Bs2bLevel);
2522
2523 device->NumStereoSources = 1;
2524 device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
2525
2526 device->DefaultSlot = (ALeffectslot*)(device+1);
2527 if(InitEffectSlot(device->DefaultSlot) != AL_NO_ERROR)
2528 device->DefaultSlot = NULL;
2529
2530 // Find a playback device to open
2531 LockLists();
2532 if((err=ALCdevice_OpenPlayback(device, deviceName)) != ALC_NO_ERROR)
2533 {
2534 UnlockLists();
2535 DeleteCriticalSection(&device->Mutex);
2536 free(device);
2537 alcSetError(NULL, err);
2538 return NULL;
2539 }
2540 UnlockLists();
2541
2542 do {
2543 device->next = DeviceList;
2544 } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
2545
2546 TRACE("Created device %p\n", device);
2547 return device;
2548 }
2549
2550 /* alcCloseDevice
2551 *
2552 * Close the specified Device
2553 */
2554 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *pDevice)
2555 {
2556 ALCdevice *volatile*list;
2557 ALCcontext *ctx;
2558
2559 LockLists();
2560 list = &DeviceList;
2561 while(*list && *list != pDevice)
2562 list = &(*list)->next;
2563
2564 if(!*list || (*list)->IsCaptureDevice)
2565 {
2566 alcSetError(*list, ALC_INVALID_DEVICE);
2567 UnlockLists();
2568 return ALC_FALSE;
2569 }
2570
2571 *list = (*list)->next;
2572 UnlockLists();
2573
2574 if((ctx=pDevice->ContextList) != NULL)
2575 {
2576 do {
2577 WARN("Releasing context %p\n", ctx);
2578 ReleaseContext(ctx, pDevice);
2579 } while((ctx=pDevice->ContextList) != NULL);
2580 ALCdevice_StopPlayback(pDevice);
2581 pDevice->Flags &= ~DEVICE_RUNNING;
2582 }
2583 ALCdevice_ClosePlayback(pDevice);
2584
2585 ALCdevice_DecRef(pDevice);
2586
2587 return ALC_TRUE;
2588 }
2589
2590
2591 /* alcLoopbackOpenDeviceSOFT
2592 *
2593 * Open a loopback device, for manual rendering.
2594 */
2595 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(void)
2596 {
2597 ALCdevice *device;
2598
2599 DO_INITCONFIG();
2600
2601 device = calloc(1, sizeof(ALCdevice));
2602 if(!device)
2603 {
2604 alcSetError(NULL, ALC_OUT_OF_MEMORY);
2605 return NULL;
2606 }
2607
2608 //Validate device
2609 device->Funcs = &BackendLoopback.Funcs;
2610 device->ref = 1;
2611 device->Connected = ALC_TRUE;
2612 device->IsCaptureDevice = AL_FALSE;
2613 device->IsLoopbackDevice = AL_TRUE;
2614 InitializeCriticalSection(&device->Mutex);
2615 device->LastError = ALC_NO_ERROR;
2616
2617 device->Flags = 0;
2618 device->Bs2b = NULL;
2619 device->Bs2bLevel = 0;
2620 device->szDeviceName = NULL;
2621
2622 device->ContextList = NULL;
2623
2624 device->MaxNoOfSources = 256;
2625 device->AuxiliaryEffectSlotMax = 4;
2626 device->NumAuxSends = MAX_SENDS;
2627
2628 InitUIntMap(&device->BufferMap, ~0);
2629 InitUIntMap(&device->EffectMap, ~0);
2630 InitUIntMap(&device->FilterMap, ~0);
2631
2632 //Set output format
2633 device->NumUpdates = 0;
2634 device->UpdateSize = 0;
2635
2636 device->Frequency = 44100;
2637 device->FmtChans = DevFmtStereo;
2638 device->FmtType = DevFmtShort;
2639
2640 ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
2641 if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
2642
2643 ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
2644 if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
2645
2646 ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
2647 if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
2648
2649 device->NumStereoSources = 1;
2650 device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
2651
2652 // Open the "backend"
2653 ALCdevice_OpenPlayback(device, "Loopback");
2654 do {
2655 device->next = DeviceList;
2656 } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
2657
2658 TRACE("Created device %p\n", device);
2659 return device;
2660 }
2661
2662 /* alcIsRenderFormatSupportedSOFT
2663 *
2664 * Determines if the loopback device supports the given format for rendering.
2665 */
2666 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
2667 {
2668 ALCboolean ret = ALC_FALSE;
2669
2670 if(!(device=VerifyDevice(device)) || !device->IsLoopbackDevice)
2671 alcSetError(device, ALC_INVALID_DEVICE);
2672 else if(freq <= 0)
2673 alcSetError(device, ALC_INVALID_VALUE);
2674 else if(!IsValidALCType(type) || !IsValidALCChannels(channels))
2675 alcSetError(device, ALC_INVALID_ENUM);
2676 else
2677 {
2678 if(BytesFromDevFmt(type) > 0 && ChannelsFromDevFmt(channels) > 0 &&
2679 freq >= 8000)
2680 ret = ALC_TRUE;
2681 }
2682 if(device) ALCdevice_DecRef(device);
2683
2684 return ret;
2685 }
2686
2687 /* alcRenderSamplesSOFT
2688 *
2689 * Renders some samples into a buffer, using the format last set by the
2690 * attributes given to alcCreateContext.
2691 */
2692 ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
2693 {
2694 if(!(device=VerifyDevice(device)) || !device->IsLoopbackDevice)
2695 alcSetError(device, ALC_INVALID_DEVICE);
2696 else if(samples < 0 || (samples > 0 && buffer == NULL))
2697 alcSetError(device, ALC_INVALID_VALUE);
2698 else
2699 aluMixData(device, buffer, samples);
2700 if(device) ALCdevice_DecRef(device);
2701 }
2702
2703
2704 static void ReleaseALC(void)
2705 {
2706 ALCdevice *dev;
2707
2708 free(alcDeviceList); alcDeviceList = NULL;
2709 alcDeviceListSize = 0;
2710 free(alcAllDeviceList); alcAllDeviceList = NULL;
2711 alcAllDeviceListSize = 0;
2712 free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
2713 alcCaptureDeviceListSize = 0;
2714
2715 free(alcDefaultDeviceSpecifier);
2716 alcDefaultDeviceSpecifier = NULL;
2717 free(alcDefaultAllDeviceSpecifier);
2718 alcDefaultAllDeviceSpecifier = NULL;
2719 free(alcCaptureDefaultDeviceSpecifier);
2720 alcCaptureDefaultDeviceSpecifier = NULL;
2721
2722 if((dev=ExchangePtr((XchgPtr*)&DeviceList, NULL)) != NULL)
2723 {
2724 ALCuint num = 0;
2725 do {
2726 num++;
2727 } while((dev=dev->next) != NULL);
2728 ERR("%u device%s not closed\n", num, (num>1)?"s":"");
2729 }
2730 }
2731
2732 ///////////////////////////////////////////////////////
Software OpenAL implementation