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