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