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