?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove some more hungarian notation
[openal-soft/openal-hmr.git] / Alc / ALc.c
blobd8211d030ec9bdf284aa152f2b5972dbbf786642
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_SOFT_loopback";
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_SOFT_loopback";
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 *volatile GlobalContext = NULL;
368
369 /* Device Error */
370 static volatile ALCenum LastNullDeviceError = 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 pthread_key_create(&LocalContext, ReleaseThreadCtx);
502 InitializeCriticalSection(&ListLock);
503 ThunkInit();
504 }
505
506 static void alc_deinit_safe(void)
507 {
508 ReleaseALC();
509
510 FreeHrtf();
511 FreeALConfig();
512
513 ThunkExit();
514 DeleteCriticalSection(&ListLock);
515 pthread_key_delete(LocalContext);
516
517 if(LogFile != stderr)
518 fclose(LogFile);
519 LogFile = NULL;
520 }
521
522 static void alc_deinit(void)
523 {
524 int i;
525
526 ReleaseALC();
527
528 memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
529 memset(&CaptureBackend, 0, sizeof(CaptureBackend));
530
531 for(i = 0;BackendList[i].Deinit;i++)
532 BackendList[i].Deinit();
533 BackendLoopback.Deinit();
534
535 alc_deinit_safe();
536 }
537
538 static void alc_initconfig(void)
539 {
540 const char *devs, *str;
541 float valf;
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 <= LogRef)
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 = 1;
566 #else
567 RTPrioLevel = 0;
568 #endif
569 ConfigValueInt(NULL, "rt-prio", &RTPrioLevel);
570
571 if(ConfigValueStr(NULL, "resampler", &str))
572 {
573 if(strcasecmp(str, "point") == 0 || strcasecmp(str, "none") == 0)
574 DefaultResampler = PointResampler;
575 else if(strcasecmp(str, "linear") == 0)
576 DefaultResampler = LinearResampler;
577 else if(strcasecmp(str, "cubic") == 0)
578 DefaultResampler = CubicResampler;
579 else
580 {
581 char *end;
582
583 n = strtol(str, &end, 0);
584 if(*end == '\0' && (n == PointResampler || n == LinearResampler || n == CubicResampler))
585 DefaultResampler = n;
586 else
587 WARN("Invalid resampler: %s\n", str);
588 }
589 }
590
591 str = getenv("ALSOFT_TRAP_ERROR");
592 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
593 {
594 TrapALError = AL_TRUE;
595 TrapALCError = AL_TRUE;
596 }
597 else
598 {
599 str = getenv("ALSOFT_TRAP_AL_ERROR");
600 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
601 TrapALError = AL_TRUE;
602 TrapALError = GetConfigValueBool(NULL, "trap-al-error", TrapALError);
603
604 str = getenv("ALSOFT_TRAP_ALC_ERROR");
605 if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
606 TrapALCError = ALC_TRUE;
607 TrapALCError = GetConfigValueBool(NULL, "trap-alc-error", TrapALCError);
608 }
609
610 if(ConfigValueFloat("reverb", "boost", &valf))
611 ReverbBoost *= aluPow(10.0f, valf / 20.0f);
612
613 EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);
614
615 if(((devs=getenv("ALSOFT_DRIVERS")) && devs[0]) ||
616 ConfigValueStr(NULL, "drivers", &devs))
617 {
618 int n;
619 size_t len;
620 const char *next = devs;
621 int endlist, delitem;
622
623 i = 0;
624 do {
625 devs = next;
626 next = strchr(devs, ',');
627
628 delitem = (devs[0] == '-');
629 if(devs[0] == '-') devs++;
630
631 if(!devs[0] || devs[0] == ',')
632 {
633 endlist = 0;
634 continue;
635 }
636 endlist = 1;
637
638 len = (next ? ((size_t)(next-devs)) : strlen(devs));
639 for(n = i;BackendList[n].Init;n++)
640 {
641 if(len == strlen(BackendList[n].name) &&
642 strncmp(BackendList[n].name, devs, len) == 0)
643 {
644 if(delitem)
645 {
646 do {
647 BackendList[n] = BackendList[n+1];
648 ++n;
649 } while(BackendList[n].Init);
650 }
651 else
652 {
653 struct BackendInfo Bkp = BackendList[n];
654 while(n > i)
655 {
656 BackendList[n] = BackendList[n-1];
657 --n;
658 }
659 BackendList[n] = Bkp;
660
661 i++;
662 }
663 break;
664 }
665 }
666 } while(next++);
667
668 if(endlist)
669 {
670 BackendList[i].name = NULL;
671 BackendList[i].Init = NULL;
672 BackendList[i].Deinit = NULL;
673 BackendList[i].Probe = NULL;
674 }
675 }
676
677 for(i = 0;BackendList[i].Init && (!PlaybackBackend.name || !CaptureBackend.name);i++)
678 {
679 if(!BackendList[i].Init(&BackendList[i].Funcs))
680 {
681 WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
682 continue;
683 }
684
685 TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
686 if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
687 {
688 PlaybackBackend = BackendList[i];
689 TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
690 }
691 if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
692 {
693 CaptureBackend = BackendList[i];
694 TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
695 }
696 }
697 BackendLoopback.Init(&BackendLoopback.Funcs);
698
699 if(ConfigValueStr(NULL, "excludefx", &str))
700 {
701 size_t len;
702 const char *next = str;
703
704 do {
705 str = next;
706 next = strchr(str, ',');
707
708 if(!str[0] || next == str)
709 continue;
710
711 len = (next ? ((size_t)(next-str)) : strlen(str));
712 for(n = 0;EffectList[n].name;n++)
713 {
714 if(len == strlen(EffectList[n].name) &&
715 strncmp(EffectList[n].name, str, len) == 0)
716 DisabledEffects[EffectList[n].type] = AL_TRUE;
717 }
718 } while(next++);
719 }
720
721 InitEffect(&DefaultEffect);
722 str = getenv("ALSOFT_DEFAULT_REVERB");
723 if((str && str[0]) || ConfigValueStr(NULL, "default-reverb", &str))
724 LoadReverbPreset(str, &DefaultEffect);
725 }
726
727
728 static void LockLists(void)
729 {
730 EnterCriticalSection(&ListLock);
731 }
732
733 static void UnlockLists(void)
734 {
735 LeaveCriticalSection(&ListLock);
736 }
737
738
739 static void ProbeList(ALCchar **list, size_t *listsize, enum DevProbe type)
740 {
741 DO_INITCONFIG();
742
743 LockLists();
744 free(*list);
745 *list = NULL;
746 *listsize = 0;
747
748 if(type == ALL_DEVICE_PROBE && PlaybackBackend.Probe)
749 PlaybackBackend.Probe(type);
750 else if(type == CAPTURE_DEVICE_PROBE && CaptureBackend.Probe)
751 CaptureBackend.Probe(type);
752 UnlockLists();
753 }
754
755 static void ProbeAllDeviceList(void)
756 { ProbeList(&alcAllDeviceList, &alcAllDeviceListSize, ALL_DEVICE_PROBE); }
757 static void ProbeCaptureDeviceList(void)
758 { ProbeList(&alcCaptureDeviceList, &alcCaptureDeviceListSize, CAPTURE_DEVICE_PROBE); }
759
760
761 static void AppendList(const ALCchar *name, ALCchar **List, size_t *ListSize)
762 {
763 size_t len = strlen(name);
764 void *temp;
765
766 if(len == 0)
767 return;
768
769 temp = realloc(*List, (*ListSize) + len + 2);
770 if(!temp)
771 {
772 ERR("Realloc failed to add %s!\n", name);
773 return;
774 }
775 *List = temp;
776
777 memcpy((*List)+(*ListSize), name, len+1);
778 *ListSize += len+1;
779 (*List)[*ListSize] = 0;
780 }
781
782 #define DECL_APPEND_LIST_FUNC(type) \
783 void Append##type##List(const ALCchar *name) \
784 { AppendList(name, &alc##type##List, &alc##type##ListSize); }
785
786 DECL_APPEND_LIST_FUNC(AllDevice)
787 DECL_APPEND_LIST_FUNC(CaptureDevice)
788
789 #undef DECL_APPEND_LIST_FUNC
790
791
792 /* Sets the default channel order used by most non-WaveFormatEx-based APIs */
793 void SetDefaultChannelOrder(ALCdevice *device)
794 {
795 switch(device->FmtChans)
796 {
797 case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
798 device->DevChannels[1] = FRONT_RIGHT;
799 device->DevChannels[2] = BACK_LEFT;
800 device->DevChannels[3] = BACK_RIGHT;
801 device->DevChannels[4] = FRONT_CENTER;
802 device->DevChannels[5] = LFE;
803 return;
804
805 case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
806 device->DevChannels[1] = FRONT_RIGHT;
807 device->DevChannels[2] = BACK_LEFT;
808 device->DevChannels[3] = BACK_RIGHT;
809 device->DevChannels[4] = FRONT_CENTER;
810 device->DevChannels[5] = LFE;
811 device->DevChannels[6] = SIDE_LEFT;
812 device->DevChannels[7] = SIDE_RIGHT;
813 return;
814
815 /* Same as WFX order */
816 case DevFmtMono:
817 case DevFmtStereo:
818 case DevFmtQuad:
819 case DevFmtX51Side:
820 case DevFmtX61:
821 break;
822 }
823 SetDefaultWFXChannelOrder(device);
824 }
825 /* Sets the default order used by WaveFormatEx */
826 void SetDefaultWFXChannelOrder(ALCdevice *device)
827 {
828 switch(device->FmtChans)
829 {
830 case DevFmtMono: device->DevChannels[0] = FRONT_CENTER; break;
831
832 case DevFmtStereo: device->DevChannels[0] = FRONT_LEFT;
833 device->DevChannels[1] = FRONT_RIGHT; break;
834
835 case DevFmtQuad: device->DevChannels[0] = FRONT_LEFT;
836 device->DevChannels[1] = FRONT_RIGHT;
837 device->DevChannels[2] = BACK_LEFT;
838 device->DevChannels[3] = BACK_RIGHT; break;
839
840 case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;
841 device->DevChannels[1] = FRONT_RIGHT;
842 device->DevChannels[2] = FRONT_CENTER;
843 device->DevChannels[3] = LFE;
844 device->DevChannels[4] = BACK_LEFT;
845 device->DevChannels[5] = BACK_RIGHT; break;
846
847 case DevFmtX51Side: device->DevChannels[0] = FRONT_LEFT;
848 device->DevChannels[1] = FRONT_RIGHT;
849 device->DevChannels[2] = FRONT_CENTER;
850 device->DevChannels[3] = LFE;
851 device->DevChannels[4] = SIDE_LEFT;
852 device->DevChannels[5] = SIDE_RIGHT; break;
853
854 case DevFmtX61: device->DevChannels[0] = FRONT_LEFT;
855 device->DevChannels[1] = FRONT_RIGHT;
856 device->DevChannels[2] = FRONT_CENTER;
857 device->DevChannels[3] = LFE;
858 device->DevChannels[4] = BACK_CENTER;
859 device->DevChannels[5] = SIDE_LEFT;
860 device->DevChannels[6] = SIDE_RIGHT; break;
861
862 case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;
863 device->DevChannels[1] = FRONT_RIGHT;
864 device->DevChannels[2] = FRONT_CENTER;
865 device->DevChannels[3] = LFE;
866 device->DevChannels[4] = BACK_LEFT;
867 device->DevChannels[5] = BACK_RIGHT;
868 device->DevChannels[6] = SIDE_LEFT;
869 device->DevChannels[7] = SIDE_RIGHT; break;
870 }
871 }
872
873
874 const ALCchar *DevFmtTypeString(enum DevFmtType type)
875 {
876 switch(type)
877 {
878 case DevFmtByte: return "Signed Byte";
879 case DevFmtUByte: return "Unsigned Byte";
880 case DevFmtShort: return "Signed Short";
881 case DevFmtUShort: return "Unsigned Short";
882 case DevFmtInt: return "Signed Int";
883 case DevFmtUInt: return "Unsigned Int";
884 case DevFmtFloat: return "Float";
885 }
886 return "(unknown type)";
887 }
888 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
889 {
890 switch(chans)
891 {
892 case DevFmtMono: return "Mono";
893 case DevFmtStereo: return "Stereo";
894 case DevFmtQuad: return "Quadraphonic";
895 case DevFmtX51: return "5.1 Surround";
896 case DevFmtX51Side: return "5.1 Side";
897 case DevFmtX61: return "6.1 Surround";
898 case DevFmtX71: return "7.1 Surround";
899 }
900 return "(unknown channels)";
901 }
902
903 ALuint BytesFromDevFmt(enum DevFmtType type)
904 {
905 switch(type)
906 {
907 case DevFmtByte: return sizeof(ALbyte);
908 case DevFmtUByte: return sizeof(ALubyte);
909 case DevFmtShort: return sizeof(ALshort);
910 case DevFmtUShort: return sizeof(ALushort);
911 case DevFmtInt: return sizeof(ALint);
912 case DevFmtUInt: return sizeof(ALuint);
913 case DevFmtFloat: return sizeof(ALfloat);
914 }
915 return 0;
916 }
917 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
918 {
919 switch(chans)
920 {
921 case DevFmtMono: return 1;
922 case DevFmtStereo: return 2;
923 case DevFmtQuad: return 4;
924 case DevFmtX51: return 6;
925 case DevFmtX51Side: return 6;
926 case DevFmtX61: return 7;
927 case DevFmtX71: return 8;
928 }
929 return 0;
930 }
931 static ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,
932 enum DevFmtType *type)
933 {
934 static const struct {
935 ALenum format;
936 enum DevFmtChannels channels;
937 enum DevFmtType type;
938 } list[] = {
939 { AL_FORMAT_MONO8, DevFmtMono, DevFmtUByte },
940 { AL_FORMAT_MONO16, DevFmtMono, DevFmtShort },
941 { AL_FORMAT_MONO_FLOAT32, DevFmtMono, DevFmtFloat },
942
943 { AL_FORMAT_STEREO8, DevFmtStereo, DevFmtUByte },
944 { AL_FORMAT_STEREO16, DevFmtStereo, DevFmtShort },
945 { AL_FORMAT_STEREO_FLOAT32, DevFmtStereo, DevFmtFloat },
946
947 { AL_FORMAT_QUAD8, DevFmtQuad, DevFmtUByte },
948 { AL_FORMAT_QUAD16, DevFmtQuad, DevFmtShort },
949 { AL_FORMAT_QUAD32, DevFmtQuad, DevFmtFloat },
950
951 { AL_FORMAT_51CHN8, DevFmtX51, DevFmtUByte },
952 { AL_FORMAT_51CHN16, DevFmtX51, DevFmtShort },
953 { AL_FORMAT_51CHN32, DevFmtX51, DevFmtFloat },
954
955 { AL_FORMAT_61CHN8, DevFmtX61, DevFmtUByte },
956 { AL_FORMAT_61CHN16, DevFmtX61, DevFmtShort },
957 { AL_FORMAT_61CHN32, DevFmtX61, DevFmtFloat },
958
959 { AL_FORMAT_71CHN8, DevFmtX71, DevFmtUByte },
960 { AL_FORMAT_71CHN16, DevFmtX71, DevFmtShort },
961 { AL_FORMAT_71CHN32, DevFmtX71, DevFmtFloat },
962 };
963 ALuint i;
964
965 for(i = 0;i < COUNTOF(list);i++)
966 {
967 if(list[i].format == format)
968 {
969 *chans = list[i].channels;
970 *type = list[i].type;
971 return AL_TRUE;
972 }
973 }
974
975 return AL_FALSE;
976 }
977
978 static ALCboolean IsValidALCType(ALCenum type)
979 {
980 switch(type)
981 {
982 case ALC_BYTE_SOFT:
983 case ALC_UNSIGNED_BYTE_SOFT:
984 case ALC_SHORT_SOFT:
985 case ALC_UNSIGNED_SHORT_SOFT:
986 case ALC_INT_SOFT:
987 case ALC_UNSIGNED_INT_SOFT:
988 case ALC_FLOAT_SOFT:
989 return ALC_TRUE;
990 }
991 return ALC_FALSE;
992 }
993
994 static ALCboolean IsValidALCChannels(ALCenum channels)
995 {
996 switch(channels)
997 {
998 case ALC_MONO_SOFT:
999 case ALC_STEREO_SOFT:
1000 case ALC_QUAD_SOFT:
1001 case ALC_5POINT1_SOFT:
1002 case ALC_6POINT1_SOFT:
1003 case ALC_7POINT1_SOFT:
1004 return ALC_TRUE;
1005 }
1006 return ALC_FALSE;
1007 }
1008
1009
1010 /* alcSetError
1011 *
1012 * Stores the latest ALC Error
1013 */
1014 static void alcSetError(ALCdevice *device, ALCenum errorCode)
1015 {
1016 if(TrapALCError)
1017 {
1018 #ifdef _WIN32
1019 /* DebugBreak() will cause an exception if there is no debugger */
1020 if(IsDebuggerPresent())
1021 DebugBreak();
1022 #elif defined(SIGTRAP)
1023 raise(SIGTRAP);
1024 #endif
1025 }
1026
1027 if(device)
1028 device->LastError = errorCode;
1029 else
1030 LastNullDeviceError = errorCode;
1031 }
1032
1033
1034 /* UpdateDeviceParams
1035 *
1036 * Updates device parameters according to the attribute list (caller is
1037 * responsible for holding the list lock).
1038 */
1039 static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
1040 {
1041 ALCcontext *context;
1042 enum DevFmtChannels oldChans;
1043 enum DevFmtType oldType;
1044 ALCuint oldFreq;
1045 int oldMode;
1046 ALuint i;
1047
1048 // Check for attributes
1049 if(device->Type == Loopback)
1050 {
1051 enum {
1052 GotFreq = 1<<0,
1053 GotChans = 1<<1,
1054 GotType = 1<<2,
1055 GotAll = GotFreq|GotChans|GotType
1056 };
1057 ALCuint freq, numMono, numStereo, numSends;
1058 enum DevFmtChannels schans;
1059 enum DevFmtType stype;
1060 ALCuint attrIdx = 0;
1061 ALCint gotFmt = 0;
1062
1063 if(!attrList)
1064 {
1065 WARN("Missing attributes for loopback device\n");
1066 return ALC_INVALID_VALUE;
1067 }
1068
1069 numMono = device->NumMonoSources;
1070 numStereo = device->NumStereoSources;
1071 numSends = device->NumAuxSends;
1072 schans = device->FmtChans;
1073 stype = device->FmtType;
1074 freq = device->Frequency;
1075
1076 while(attrList[attrIdx])
1077 {
1078 if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT)
1079 {
1080 ALCint val = attrList[attrIdx + 1];
1081 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
1082 return ALC_INVALID_VALUE;
1083 schans = val;
1084 gotFmt |= GotChans;
1085 }
1086
1087 if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT)
1088 {
1089 ALCint val = attrList[attrIdx + 1];
1090 if(!IsValidALCType(val) || !BytesFromDevFmt(val))
1091 return ALC_INVALID_VALUE;
1092 stype = val;
1093 gotFmt |= GotType;
1094 }
1095
1096 if(attrList[attrIdx] == ALC_FREQUENCY)
1097 {
1098 freq = attrList[attrIdx + 1];
1099 if(freq < MIN_OUTPUT_RATE)
1100 return ALC_INVALID_VALUE;
1101 gotFmt |= GotFreq;
1102 }
1103
1104 if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1105 {
1106 numStereo = attrList[attrIdx + 1];
1107 if(numStereo > device->MaxNoOfSources)
1108 numStereo = device->MaxNoOfSources;
1109
1110 numMono = device->MaxNoOfSources - numStereo;
1111 }
1112
1113 if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1114 numSends = attrList[attrIdx + 1];
1115
1116 attrIdx += 2;
1117 }
1118
1119 if(gotFmt != GotAll)
1120 {
1121 WARN("Missing format for loopback device\n");
1122 return ALC_INVALID_VALUE;
1123 }
1124
1125 ConfigValueUInt(NULL, "sends", &numSends);
1126 numSends = minu(MAX_SENDS, numSends);
1127
1128 if((device->Flags&DEVICE_RUNNING))
1129 ALCdevice_StopPlayback(device);
1130 device->Flags &= ~DEVICE_RUNNING;
1131
1132 device->Frequency = freq;
1133 device->FmtChans = schans;
1134 device->FmtType = stype;
1135 device->NumMonoSources = numMono;
1136 device->NumStereoSources = numStereo;
1137 device->NumAuxSends = numSends;
1138 }
1139 else if(attrList && attrList[0])
1140 {
1141 ALCuint freq, numMono, numStereo, numSends;
1142 ALCuint attrIdx = 0;
1143
1144 /* If a context is already running on the device, stop playback so the
1145 * device attributes can be updated. */
1146 if((device->Flags&DEVICE_RUNNING))
1147 ALCdevice_StopPlayback(device);
1148 device->Flags &= ~DEVICE_RUNNING;
1149
1150 freq = device->Frequency;
1151 numMono = device->NumMonoSources;
1152 numStereo = device->NumStereoSources;
1153 numSends = device->NumAuxSends;
1154
1155 while(attrList[attrIdx])
1156 {
1157 if(attrList[attrIdx] == ALC_FREQUENCY)
1158 {
1159 freq = attrList[attrIdx + 1];
1160 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1161 }
1162
1163 if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1164 {
1165 numStereo = attrList[attrIdx + 1];
1166 if(numStereo > device->MaxNoOfSources)
1167 numStereo = device->MaxNoOfSources;
1168
1169 numMono = device->MaxNoOfSources - numStereo;
1170 }
1171
1172 if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1173 numSends = attrList[attrIdx + 1];
1174
1175 attrIdx += 2;
1176 }
1177
1178 ConfigValueUInt(NULL, "frequency", &freq);
1179 freq = maxu(freq, MIN_OUTPUT_RATE);
1180
1181 ConfigValueUInt(NULL, "sends", &numSends);
1182 numSends = minu(MAX_SENDS, numSends);
1183
1184 device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1185 device->Frequency;
1186
1187 device->Frequency = freq;
1188 device->NumMonoSources = numMono;
1189 device->NumStereoSources = numStereo;
1190 device->NumAuxSends = numSends;
1191 }
1192
1193 if((device->Flags&DEVICE_RUNNING))
1194 return ALC_NO_ERROR;
1195
1196 oldFreq = device->Frequency;
1197 oldChans = device->FmtChans;
1198 oldType = device->FmtType;
1199
1200 TRACE("Format pre-setup: %s%s, %s%s, %uhz%s, %u update size x%d\n",
1201 DevFmtChannelsString(device->FmtChans),
1202 (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",
1203 DevFmtTypeString(device->FmtType),
1204 (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST)?" (requested)":"",
1205 device->Frequency,
1206 (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",
1207 device->UpdateSize, device->NumUpdates);
1208
1209 if(ALCdevice_ResetPlayback(device) == ALC_FALSE)
1210 return ALC_INVALID_DEVICE;
1211
1212 if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
1213 {
1214 ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
1215 DevFmtChannelsString(device->FmtChans));
1216 device->Flags &= ~DEVICE_CHANNELS_REQUEST;
1217 }
1218 if(device->FmtType != oldType && (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
1219 {
1220 ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
1221 DevFmtTypeString(device->FmtType));
1222 device->Flags &= ~DEVICE_SAMPLE_TYPE_REQUEST;
1223 }
1224 if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
1225 {
1226 ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
1227 device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
1228 }
1229
1230 TRACE("Format post-setup: %s, %s, %uhz, %u update size x%d\n",
1231 DevFmtChannelsString(device->FmtChans),
1232 DevFmtTypeString(device->FmtType), device->Frequency,
1233 device->UpdateSize, device->NumUpdates);
1234
1235 aluInitPanning(device);
1236
1237 for(i = 0;i < MAXCHANNELS;i++)
1238 {
1239 device->ClickRemoval[i] = 0.0f;
1240 device->PendingClicks[i] = 0.0f;
1241 }
1242
1243 device->Hrtf = NULL;
1244 if(device->Type != Loopback && GetConfigValueBool(NULL, "hrtf", AL_FALSE))
1245 device->Hrtf = GetHrtf(device);
1246 TRACE("HRTF %s\n", device->Hrtf?"enabled":"disabled");
1247
1248 if(!device->Hrtf && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
1249 {
1250 if(!device->Bs2b)
1251 {
1252 device->Bs2b = calloc(1, sizeof(*device->Bs2b));
1253 bs2b_clear(device->Bs2b);
1254 }
1255 bs2b_set_srate(device->Bs2b, device->Frequency);
1256 bs2b_set_level(device->Bs2b, device->Bs2bLevel);
1257 TRACE("BS2B level %d\n", device->Bs2bLevel);
1258 }
1259 else
1260 {
1261 free(device->Bs2b);
1262 device->Bs2b = NULL;
1263 TRACE("BS2B disabled\n");
1264 }
1265
1266 device->Flags &= ~DEVICE_DUPLICATE_STEREO;
1267 switch(device->FmtChans)
1268 {
1269 case DevFmtMono:
1270 case DevFmtStereo:
1271 break;
1272 case DevFmtQuad:
1273 case DevFmtX51:
1274 case DevFmtX51Side:
1275 case DevFmtX61:
1276 case DevFmtX71:
1277 if(GetConfigValueBool(NULL, "stereodup", AL_TRUE))
1278 device->Flags |= DEVICE_DUPLICATE_STEREO;
1279 break;
1280 }
1281 TRACE("Stereo duplication %s\n", (device->Flags&DEVICE_DUPLICATE_STEREO)?"enabled":"disabled");
1282
1283 oldMode = SetMixerFPUMode();
1284 LockDevice(device);
1285 context = device->ContextList;
1286 while(context)
1287 {
1288 ALsizei pos;
1289
1290 context->UpdateSources = AL_FALSE;
1291 LockUIntMapRead(&context->EffectSlotMap);
1292 for(pos = 0;pos < context->EffectSlotMap.size;pos++)
1293 {
1294 ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
1295
1296 if(ALeffectState_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
1297 {
1298 UnlockUIntMapRead(&context->EffectSlotMap);
1299 UnlockDevice(device);
1300 RestoreFPUMode(oldMode);
1301 return ALC_INVALID_DEVICE;
1302 }
1303 slot->NeedsUpdate = AL_FALSE;
1304 ALeffectState_Update(slot->EffectState, device, slot);
1305 }
1306 UnlockUIntMapRead(&context->EffectSlotMap);
1307
1308 LockUIntMapRead(&context->SourceMap);
1309 for(pos = 0;pos < context->SourceMap.size;pos++)
1310 {
1311 ALsource *source = context->SourceMap.array[pos].value;
1312 ALuint s = device->NumAuxSends;
1313 while(s < MAX_SENDS)
1314 {
1315 if(source->Send[s].Slot)
1316 DecrementRef(&source->Send[s].Slot->ref);
1317 source->Send[s].Slot = NULL;
1318 source->Send[s].WetGain = 1.0f;
1319 source->Send[s].WetGainHF = 1.0f;
1320 s++;
1321 }
1322 source->NeedsUpdate = AL_FALSE;
1323 ALsource_Update(source, context);
1324 }
1325 UnlockUIntMapRead(&context->SourceMap);
1326
1327 context = context->next;
1328 }
1329 if(device->DefaultSlot)
1330 {
1331 ALeffectslot *slot = device->DefaultSlot;
1332
1333 if(ALeffectState_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
1334 {
1335 UnlockDevice(device);
1336 RestoreFPUMode(oldMode);
1337 return ALC_INVALID_DEVICE;
1338 }
1339 slot->NeedsUpdate = AL_FALSE;
1340 ALeffectState_Update(slot->EffectState, device, slot);
1341 }
1342 UnlockDevice(device);
1343 RestoreFPUMode(oldMode);
1344
1345 if(ALCdevice_StartPlayback(device) == ALC_FALSE)
1346 return ALC_INVALID_DEVICE;
1347 device->Flags |= DEVICE_RUNNING;
1348
1349 return ALC_NO_ERROR;
1350 }
1351
1352 /* FreeDevice
1353 *
1354 * Frees the device structure, and destroys any objects the app failed to
1355 * delete. Called once there's no more references on the device.
1356 */
1357 static ALCvoid FreeDevice(ALCdevice *device)
1358 {
1359 TRACE("%p\n", device);
1360
1361 if(device->DefaultSlot)
1362 {
1363 ALeffectState_Destroy(device->DefaultSlot->EffectState);
1364 device->DefaultSlot->EffectState = NULL;
1365 }
1366
1367 if(device->BufferMap.size > 0)
1368 {
1369 WARN("(%p) Deleting %d Buffer(s)\n", device, device->BufferMap.size);
1370 ReleaseALBuffers(device);
1371 }
1372 ResetUIntMap(&device->BufferMap);
1373
1374 if(device->EffectMap.size > 0)
1375 {
1376 WARN("(%p) Deleting %d Effect(s)\n", device, device->EffectMap.size);
1377 ReleaseALEffects(device);
1378 }
1379 ResetUIntMap(&device->EffectMap);
1380
1381 if(device->FilterMap.size > 0)
1382 {
1383 WARN("(%p) Deleting %d Filter(s)\n", device, device->FilterMap.size);
1384 ReleaseALFilters(device);
1385 }
1386 ResetUIntMap(&device->FilterMap);
1387
1388 free(device->Bs2b);
1389 device->Bs2b = NULL;
1390
1391 free(device->DeviceName);
1392 device->DeviceName = NULL;
1393
1394 DeleteCriticalSection(&device->Mutex);
1395
1396 free(device);
1397 }
1398
1399
1400 void ALCdevice_IncRef(ALCdevice *device)
1401 {
1402 RefCount ref;
1403 ref = IncrementRef(&device->ref);
1404 TRACEREF("%p increasing refcount to %u\n", device, ref);
1405 }
1406
1407 void ALCdevice_DecRef(ALCdevice *device)
1408 {
1409 RefCount ref;
1410 ref = DecrementRef(&device->ref);
1411 TRACEREF("%p decreasing refcount to %u\n", device, ref);
1412 if(ref == 0) FreeDevice(device);
1413 }
1414
1415 /* VerifyDevice
1416 *
1417 * Checks if the device handle is valid, and increments its ref count if so.
1418 */
1419 static ALCdevice *VerifyDevice(ALCdevice *device)
1420 {
1421 ALCdevice *tmpDevice;
1422
1423 if(!device)
1424 return NULL;
1425
1426 LockLists();
1427 tmpDevice = DeviceList;
1428 while(tmpDevice && tmpDevice != device)
1429 tmpDevice = tmpDevice->next;
1430
1431 if(tmpDevice)
1432 ALCdevice_IncRef(tmpDevice);
1433 UnlockLists();
1434 return tmpDevice;
1435 }
1436
1437
1438 /* InitContext
1439 *
1440 * Initializes context variables
1441 */
1442 static ALvoid InitContext(ALCcontext *Context)
1443 {
1444 ALint i, j;
1445
1446 //Initialise listener
1447 Context->Listener.Gain = 1.0f;
1448 Context->Listener.MetersPerUnit = 1.0f;
1449 Context->Listener.Position[0] = 0.0f;
1450 Context->Listener.Position[1] = 0.0f;
1451 Context->Listener.Position[2] = 0.0f;
1452 Context->Listener.Velocity[0] = 0.0f;
1453 Context->Listener.Velocity[1] = 0.0f;
1454 Context->Listener.Velocity[2] = 0.0f;
1455 Context->Listener.Forward[0] = 0.0f;
1456 Context->Listener.Forward[1] = 0.0f;
1457 Context->Listener.Forward[2] = -1.0f;
1458 Context->Listener.Up[0] = 0.0f;
1459 Context->Listener.Up[1] = 1.0f;
1460 Context->Listener.Up[2] = 0.0f;
1461 for(i = 0;i < 4;i++)
1462 {
1463 for(j = 0;j < 4;j++)
1464 Context->Listener.Matrix[i][j] = ((i==j) ? 1.0f : 0.0f);
1465 }
1466
1467 //Validate Context
1468 Context->LastError = AL_NO_ERROR;
1469 Context->UpdateSources = AL_FALSE;
1470 Context->ActiveSourceCount = 0;
1471 InitUIntMap(&Context->SourceMap, Context->Device->MaxNoOfSources);
1472 InitUIntMap(&Context->EffectSlotMap, Context->Device->AuxiliaryEffectSlotMax);
1473
1474 //Set globals
1475 Context->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
1476 Context->SourceDistanceModel = AL_FALSE;
1477 Context->DopplerFactor = 1.0f;
1478 Context->DopplerVelocity = 1.0f;
1479 Context->SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
1480 Context->DeferUpdates = AL_FALSE;
1481
1482 Context->ExtensionList = alExtList;
1483 }
1484
1485
1486 /* FreeContext
1487 *
1488 * Cleans up the context, and destroys any remaining objects the app failed to
1489 * delete. Called once there's no more references on the context.
1490 */
1491 static ALCvoid FreeContext(ALCcontext *context)
1492 {
1493 TRACE("%p\n", context);
1494
1495 if(context->SourceMap.size > 0)
1496 {
1497 ERR("(%p) Deleting %d Source(s)\n", context, context->SourceMap.size);
1498 ReleaseALSources(context);
1499 }
1500 ResetUIntMap(&context->SourceMap);
1501
1502 if(context->EffectSlotMap.size > 0)
1503 {
1504 ERR("(%p) Deleting %d AuxiliaryEffectSlot(s)\n", context, context->EffectSlotMap.size);
1505 ReleaseALAuxiliaryEffectSlots(context);
1506 }
1507 ResetUIntMap(&context->EffectSlotMap);
1508
1509 context->ActiveSourceCount = 0;
1510 free(context->ActiveSources);
1511 context->ActiveSources = NULL;
1512 context->MaxActiveSources = 0;
1513
1514 context->ActiveEffectSlotCount = 0;
1515 free(context->ActiveEffectSlots);
1516 context->ActiveEffectSlots = NULL;
1517 context->MaxActiveEffectSlots = 0;
1518
1519 ALCdevice_DecRef(context->Device);
1520 context->Device = NULL;
1521
1522 //Invalidate context
1523 memset(context, 0, sizeof(ALCcontext));
1524 free(context);
1525 }
1526
1527 /* ReleaseContext
1528 *
1529 * Removes the context reference from the given device and removes it from
1530 * being current on the running thread or globally.
1531 */
1532 static void ReleaseContext(ALCcontext *context, ALCdevice *device)
1533 {
1534 ALCcontext *volatile*tmp_ctx;
1535
1536 if(pthread_getspecific(LocalContext) == context)
1537 {
1538 WARN("%p released while current on thread\n", context);
1539 pthread_setspecific(LocalContext, NULL);
1540 ALCcontext_DecRef(context);
1541 }
1542
1543 if(CompExchangePtr((XchgPtr*)&GlobalContext, context, NULL))
1544 ALCcontext_DecRef(context);
1545
1546 LockDevice(device);
1547 tmp_ctx = &device->ContextList;
1548 while(*tmp_ctx)
1549 {
1550 if(CompExchangePtr((XchgPtr*)tmp_ctx, context, context->next))
1551 break;
1552 tmp_ctx = &(*tmp_ctx)->next;
1553 }
1554 UnlockDevice(device);
1555
1556 ALCcontext_DecRef(context);
1557 }
1558
1559 void ALCcontext_IncRef(ALCcontext *context)
1560 {
1561 RefCount ref;
1562 ref = IncrementRef(&context->ref);
1563 TRACEREF("%p increasing refcount to %u\n", context, ref);
1564 }
1565
1566 void ALCcontext_DecRef(ALCcontext *context)
1567 {
1568 RefCount ref;
1569 ref = DecrementRef(&context->ref);
1570 TRACEREF("%p decreasing refcount to %u\n", context, ref);
1571 if(ref == 0) FreeContext(context);
1572 }
1573
1574 static void ReleaseThreadCtx(void *ptr)
1575 {
1576 WARN("%p current for thread being destroyed\n", ptr);
1577 ALCcontext_DecRef(ptr);
1578 }
1579
1580 /* VerifyContext
1581 *
1582 * Checks that the given context is valid, and increments its reference count.
1583 */
1584 static ALCcontext *VerifyContext(ALCcontext *context)
1585 {
1586 ALCdevice *dev;
1587
1588 LockLists();
1589 dev = DeviceList;
1590 while(dev)
1591 {
1592 ALCcontext *tmp_ctx = dev->ContextList;
1593 while(tmp_ctx)
1594 {
1595 if(tmp_ctx == context)
1596 {
1597 ALCcontext_IncRef(tmp_ctx);
1598 UnlockLists();
1599 return tmp_ctx;
1600 }
1601 tmp_ctx = tmp_ctx->next;
1602 }
1603 dev = dev->next;
1604 }
1605 UnlockLists();
1606
1607 return NULL;
1608 }
1609
1610
1611 /* GetContextRef
1612 *
1613 * Returns the currently active context, and adds a reference without locking
1614 * it.
1615 */
1616 ALCcontext *GetContextRef(void)
1617 {
1618 ALCcontext *context;
1619
1620 context = pthread_getspecific(LocalContext);
1621 if(context)
1622 ALCcontext_IncRef(context);
1623 else
1624 {
1625 LockLists();
1626 context = GlobalContext;
1627 if(context)
1628 ALCcontext_IncRef(context);
1629 UnlockLists();
1630 }
1631
1632 return context;
1633 }
1634
1635 ///////////////////////////////////////////////////////
1636
1637
1638 ///////////////////////////////////////////////////////
1639 // ALC Functions calls
1640
1641
1642 // This should probably move to another c file but for now ...
1643 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
1644 {
1645 ALCdevice *device = NULL;
1646 ALCenum err;
1647
1648 DO_INITCONFIG();
1649
1650 if(!CaptureBackend.name)
1651 {
1652 alcSetError(NULL, ALC_INVALID_VALUE);
1653 return NULL;
1654 }
1655
1656 if(samples <= 0)
1657 {
1658 alcSetError(NULL, ALC_INVALID_VALUE);
1659 return NULL;
1660 }
1661
1662 if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
1663 deviceName = NULL;
1664
1665 device = calloc(1, sizeof(ALCdevice));
1666 if(!device)
1667 {
1668 alcSetError(NULL, ALC_OUT_OF_MEMORY);
1669 return NULL;
1670 }
1671
1672 //Validate device
1673 device->Funcs = &CaptureBackend.Funcs;
1674 device->ref = 1;
1675 device->Connected = ALC_TRUE;
1676 device->Type = Capture;
1677 InitializeCriticalSection(&device->Mutex);
1678
1679 InitUIntMap(&device->BufferMap, ~0);
1680 InitUIntMap(&device->EffectMap, ~0);
1681 InitUIntMap(&device->FilterMap, ~0);
1682
1683 device->DeviceName = NULL;
1684
1685 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1686 device->Frequency = frequency;
1687
1688 device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_SAMPLE_TYPE_REQUEST;
1689 if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
1690 {
1691 DeleteCriticalSection(&device->Mutex);
1692 free(device);
1693 alcSetError(NULL, ALC_INVALID_ENUM);
1694 return NULL;
1695 }
1696
1697 device->UpdateSize = samples;
1698 device->NumUpdates = 1;
1699
1700 LockLists();
1701 if((err=ALCdevice_OpenCapture(device, deviceName)) != ALC_NO_ERROR)
1702 {
1703 UnlockLists();
1704 DeleteCriticalSection(&device->Mutex);
1705 free(device);
1706 alcSetError(NULL, err);
1707 return NULL;
1708 }
1709 UnlockLists();
1710
1711 do {
1712 device->next = DeviceList;
1713 } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
1714
1715 TRACE("Created device %p\n", device);
1716 return device;
1717 }
1718
1719 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *Device)
1720 {
1721 ALCdevice *volatile*list;
1722
1723 LockLists();
1724 list = &DeviceList;
1725 while(*list && *list != Device)
1726 list = &(*list)->next;
1727
1728 if(!*list || (*list)->Type != Capture)
1729 {
1730 alcSetError(*list, ALC_INVALID_DEVICE);
1731 UnlockLists();
1732 return ALC_FALSE;
1733 }
1734
1735 *list = (*list)->next;
1736 UnlockLists();
1737
1738 ALCdevice_CloseCapture(Device);
1739
1740 ALCdevice_DecRef(Device);
1741
1742 return ALC_TRUE;
1743 }
1744
1745 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
1746 {
1747 LockLists();
1748 if(!(device=VerifyDevice(device)) || device->Type != Capture)
1749 {
1750 UnlockLists();
1751 alcSetError(device, ALC_INVALID_DEVICE);
1752 if(device) ALCdevice_DecRef(device);
1753 return;
1754 }
1755 if(device->Connected)
1756 {
1757 if(!(device->Flags&DEVICE_RUNNING))
1758 ALCdevice_StartCapture(device);
1759 device->Flags |= DEVICE_RUNNING;
1760 }
1761 UnlockLists();
1762
1763 ALCdevice_DecRef(device);
1764 }
1765
1766 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
1767 {
1768 LockLists();
1769 if(!(device=VerifyDevice(device)) || device->Type != Capture)
1770 {
1771 UnlockLists();
1772 alcSetError(device, ALC_INVALID_DEVICE);
1773 if(device) ALCdevice_DecRef(device);
1774 return;
1775 }
1776 if((device->Flags&DEVICE_RUNNING))
1777 ALCdevice_StopCapture(device);
1778 device->Flags &= ~DEVICE_RUNNING;
1779 UnlockLists();
1780
1781 ALCdevice_DecRef(device);
1782 }
1783
1784 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
1785 {
1786 ALCenum err = ALC_INVALID_DEVICE;
1787 LockLists();
1788 if((device=VerifyDevice(device)) != NULL && device->Type == Capture)
1789 {
1790 err = ALC_INVALID_VALUE;
1791 if(samples >= 0 && ALCdevice_AvailableSamples(device) >= (ALCuint)samples)
1792 err = ALCdevice_CaptureSamples(device, buffer, samples);
1793 }
1794 UnlockLists();
1795 if(err != ALC_NO_ERROR)
1796 alcSetError(device, err);
1797 if(device) ALCdevice_DecRef(device);
1798 }
1799
1800 /*
1801 alcGetError
1802
1803 Return last ALC generated error code
1804 */
1805 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
1806 {
1807 ALCenum errorCode;
1808
1809 if(VerifyDevice(device))
1810 {
1811 errorCode = ExchangeInt(&device->LastError, ALC_NO_ERROR);
1812 ALCdevice_DecRef(device);
1813 }
1814 else
1815 errorCode = ExchangeInt(&LastNullDeviceError, ALC_NO_ERROR);
1816
1817 return errorCode;
1818 }
1819
1820
1821 /* alcSuspendContext
1822 *
1823 * Not functional
1824 */
1825 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *Context)
1826 {
1827 (void)Context;
1828 }
1829
1830 /* alcProcessContext
1831 *
1832 * Not functional
1833 */
1834 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *Context)
1835 {
1836 (void)Context;
1837 }
1838
1839
1840 /* alcGetString
1841 *
1842 * Returns information about the device, and error strings
1843 */
1844 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
1845 {
1846 const ALCchar *value = NULL;
1847
1848 switch(param)
1849 {
1850 case ALC_NO_ERROR:
1851 value = alcNoError;
1852 break;
1853
1854 case ALC_INVALID_ENUM:
1855 value = alcErrInvalidEnum;
1856 break;
1857
1858 case ALC_INVALID_VALUE:
1859 value = alcErrInvalidValue;
1860 break;
1861
1862 case ALC_INVALID_DEVICE:
1863 value = alcErrInvalidDevice;
1864 break;
1865
1866 case ALC_INVALID_CONTEXT:
1867 value = alcErrInvalidContext;
1868 break;
1869
1870 case ALC_OUT_OF_MEMORY:
1871 value = alcErrOutOfMemory;
1872 break;
1873
1874 case ALC_DEVICE_SPECIFIER:
1875 value = alcDefaultName;
1876 break;
1877
1878 case ALC_ALL_DEVICES_SPECIFIER:
1879 if(VerifyDevice(Device))
1880 {
1881 value = Device->DeviceName;
1882 ALCdevice_DecRef(Device);
1883 }
1884 else
1885 {
1886 ProbeAllDeviceList();
1887 value = alcAllDeviceList;
1888 }
1889 break;
1890
1891 case ALC_CAPTURE_DEVICE_SPECIFIER:
1892 if(VerifyDevice(Device))
1893 {
1894 value = Device->DeviceName;
1895 ALCdevice_DecRef(Device);
1896 }
1897 else
1898 {
1899 ProbeCaptureDeviceList();
1900 value = alcCaptureDeviceList;
1901 }
1902 break;
1903
1904 /* Default devices are always first in the list */
1905 case ALC_DEFAULT_DEVICE_SPECIFIER:
1906 value = alcDefaultName;
1907 break;
1908
1909 case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
1910 if(!alcAllDeviceList)
1911 ProbeAllDeviceList();
1912
1913 Device = VerifyDevice(Device);
1914
1915 free(alcDefaultAllDeviceSpecifier);
1916 alcDefaultAllDeviceSpecifier = strdup(alcAllDeviceList ?
1917 alcAllDeviceList : "");
1918 if(!alcDefaultAllDeviceSpecifier)
1919 alcSetError(Device, ALC_OUT_OF_MEMORY);
1920
1921 value = alcDefaultAllDeviceSpecifier;
1922 if(Device) ALCdevice_DecRef(Device);
1923 break;
1924
1925 case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
1926 if(!alcCaptureDeviceList)
1927 ProbeCaptureDeviceList();
1928
1929 Device = VerifyDevice(Device);
1930
1931 free(alcCaptureDefaultDeviceSpecifier);
1932 alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?
1933 alcCaptureDeviceList : "");
1934 if(!alcCaptureDefaultDeviceSpecifier)
1935 alcSetError(Device, ALC_OUT_OF_MEMORY);
1936
1937 value = alcCaptureDefaultDeviceSpecifier;
1938 if(Device) ALCdevice_DecRef(Device);
1939 break;
1940
1941 case ALC_EXTENSIONS:
1942 if(!VerifyDevice(Device))
1943 value = alcNoDeviceExtList;
1944 else
1945 {
1946 value = alcExtensionList;
1947 ALCdevice_DecRef(Device);
1948 }
1949 break;
1950
1951 default:
1952 Device = VerifyDevice(Device);
1953 alcSetError(Device, ALC_INVALID_ENUM);
1954 if(Device) ALCdevice_DecRef(Device);
1955 break;
1956 }
1957
1958 return value;
1959 }
1960
1961
1962 /* alcGetIntegerv
1963 *
1964 * Returns information about the Device and the version of Open AL
1965 */
1966 ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
1967 {
1968 device = VerifyDevice(device);
1969
1970 if(size == 0 || data == NULL)
1971 {
1972 alcSetError(device, ALC_INVALID_VALUE);
1973 if(device) ALCdevice_DecRef(device);
1974 return;
1975 }
1976
1977 if(!device)
1978 {
1979 switch(param)
1980 {
1981 case ALC_MAJOR_VERSION:
1982 *data = alcMajorVersion;
1983 break;
1984 case ALC_MINOR_VERSION:
1985 *data = alcMinorVersion;
1986 break;
1987
1988 case ALC_ATTRIBUTES_SIZE:
1989 case ALC_ALL_ATTRIBUTES:
1990 case ALC_FREQUENCY:
1991 case ALC_REFRESH:
1992 case ALC_SYNC:
1993 case ALC_MONO_SOURCES:
1994 case ALC_STEREO_SOURCES:
1995 case ALC_CAPTURE_SAMPLES:
1996 case ALC_FORMAT_CHANNELS_SOFT:
1997 case ALC_FORMAT_TYPE_SOFT:
1998 alcSetError(NULL, ALC_INVALID_DEVICE);
1999 break;
2000
2001 default:
2002 alcSetError(NULL, ALC_INVALID_ENUM);
2003 break;
2004 }
2005 }
2006 else if(device->Type == Capture)
2007 {
2008 switch(param)
2009 {
2010 case ALC_CAPTURE_SAMPLES:
2011 LockLists();
2012 /* Re-validate the device since it may have been closed */
2013 ALCdevice_DecRef(device);
2014 if((device=VerifyDevice(device)) != NULL)
2015 *data = ALCdevice_AvailableSamples(device);
2016 else
2017 alcSetError(NULL, ALC_INVALID_DEVICE);
2018 UnlockLists();
2019 break;
2020
2021 case ALC_CONNECTED:
2022 *data = device->Connected;
2023 break;
2024
2025 default:
2026 alcSetError(device, ALC_INVALID_ENUM);
2027 break;
2028 }
2029 }
2030 else /* render device */
2031 {
2032 switch(param)
2033 {
2034 case ALC_MAJOR_VERSION:
2035 *data = alcMajorVersion;
2036 break;
2037
2038 case ALC_MINOR_VERSION:
2039 *data = alcMinorVersion;
2040 break;
2041
2042 case ALC_EFX_MAJOR_VERSION:
2043 *data = alcEFXMajorVersion;
2044 break;
2045
2046 case ALC_EFX_MINOR_VERSION:
2047 *data = alcEFXMinorVersion;
2048 break;
2049
2050 case ALC_ATTRIBUTES_SIZE:
2051 *data = 13;
2052 break;
2053
2054 case ALC_ALL_ATTRIBUTES:
2055 if(size < 13)
2056 alcSetError(device, ALC_INVALID_VALUE);
2057 else
2058 {
2059 int i = 0;
2060
2061 data[i++] = ALC_FREQUENCY;
2062 data[i++] = device->Frequency;
2063
2064 if(device->Type != Loopback)
2065 {
2066 data[i++] = ALC_REFRESH;
2067 data[i++] = device->Frequency / device->UpdateSize;
2068
2069 data[i++] = ALC_SYNC;
2070 data[i++] = ALC_FALSE;
2071 }
2072 else
2073 {
2074 data[i++] = ALC_FORMAT_CHANNELS_SOFT;
2075 data[i++] = device->FmtChans;
2076
2077 data[i++] = ALC_FORMAT_TYPE_SOFT;
2078 data[i++] = device->FmtType;
2079 }
2080
2081 data[i++] = ALC_MONO_SOURCES;
2082 data[i++] = device->NumMonoSources;
2083
2084 data[i++] = ALC_STEREO_SOURCES;
2085 data[i++] = device->NumStereoSources;
2086
2087 data[i++] = ALC_MAX_AUXILIARY_SENDS;
2088 data[i++] = device->NumAuxSends;
2089
2090 data[i++] = 0;
2091 }
2092 break;
2093
2094 case ALC_FREQUENCY:
2095 *data = device->Frequency;
2096 break;
2097
2098 case ALC_REFRESH:
2099 if(device->Type == Loopback)
2100 alcSetError(device, ALC_INVALID_DEVICE);
2101 else
2102 *data = device->Frequency / device->UpdateSize;
2103 break;
2104
2105 case ALC_SYNC:
2106 if(device->Type == Loopback)
2107 alcSetError(device, ALC_INVALID_DEVICE);
2108 else
2109 *data = ALC_FALSE;
2110 break;
2111
2112 case ALC_FORMAT_CHANNELS_SOFT:
2113 if(device->Type != Loopback)
2114 alcSetError(device, ALC_INVALID_DEVICE);
2115 else
2116 *data = device->FmtChans;
2117 break;
2118
2119 case ALC_FORMAT_TYPE_SOFT:
2120 if(device->Type != Loopback)
2121 alcSetError(device, ALC_INVALID_DEVICE);
2122 else
2123 *data = device->FmtType;
2124 break;
2125
2126 case ALC_MONO_SOURCES:
2127 *data = device->NumMonoSources;
2128 break;
2129
2130 case ALC_STEREO_SOURCES:
2131 *data = device->NumStereoSources;
2132 break;
2133
2134 case ALC_MAX_AUXILIARY_SENDS:
2135 *data = device->NumAuxSends;
2136 break;
2137
2138 case ALC_CONNECTED:
2139 *data = device->Connected;
2140 break;
2141
2142 default:
2143 alcSetError(device, ALC_INVALID_ENUM);
2144 break;
2145 }
2146 }
2147 if(device)
2148 ALCdevice_DecRef(device);
2149 }
2150
2151
2152 /* alcIsExtensionPresent
2153 *
2154 * Determines if there is support for a particular extension
2155 */
2156 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
2157 {
2158 ALCboolean bResult = ALC_FALSE;
2159
2160 device = VerifyDevice(device);
2161
2162 if(!extName)
2163 alcSetError(device, ALC_INVALID_VALUE);
2164 else
2165 {
2166 size_t len = strlen(extName);
2167 const char *ptr = (device ? alcExtensionList : alcNoDeviceExtList);
2168 while(ptr && *ptr)
2169 {
2170 if(strncasecmp(ptr, extName, len) == 0 &&
2171 (ptr[len] == '\0' || isspace(ptr[len])))
2172 {
2173 bResult = ALC_TRUE;
2174 break;
2175 }
2176 if((ptr=strchr(ptr, ' ')) != NULL)
2177 {
2178 do {
2179 ++ptr;
2180 } while(isspace(*ptr));
2181 }
2182 }
2183 }
2184 if(device)
2185 ALCdevice_DecRef(device);
2186 return bResult;
2187 }
2188
2189
2190 /* alcGetProcAddress
2191 *
2192 * Retrieves the function address for a particular extension function
2193 */
2194 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
2195 {
2196 ALCvoid *ptr = NULL;
2197
2198 device = VerifyDevice(device);
2199
2200 if(!funcName)
2201 alcSetError(device, ALC_INVALID_VALUE);
2202 else
2203 {
2204 ALsizei i = 0;
2205 while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName,funcName) != 0)
2206 i++;
2207 ptr = alcFunctions[i].address;
2208 }
2209 if(device)
2210 ALCdevice_DecRef(device);
2211 return ptr;
2212 }
2213
2214
2215 /* alcGetEnumValue
2216 *
2217 * Get the value for a particular ALC Enumerated Value
2218 */
2219 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
2220 {
2221 ALCenum val = 0;
2222
2223 device = VerifyDevice(device);
2224
2225 if(!enumName)
2226 alcSetError(device, ALC_INVALID_VALUE);
2227 else
2228 {
2229 ALsizei i = 0;
2230 while(enumeration[i].enumName && strcmp(enumeration[i].enumName,enumName) != 0)
2231 i++;
2232 val = enumeration[i].value;
2233 }
2234 if(device)
2235 ALCdevice_DecRef(device);
2236 return val;
2237 }
2238
2239
2240 /* alcCreateContext
2241 *
2242 * Create and attach a Context to a particular Device.
2243 */
2244 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
2245 {
2246 ALCcontext *ALContext;
2247 ALCenum err;
2248
2249 LockLists();
2250 if(!(device=VerifyDevice(device)) || device->Type == Capture || !device->Connected)
2251 {
2252 UnlockLists();
2253 alcSetError(device, ALC_INVALID_DEVICE);
2254 if(device) ALCdevice_DecRef(device);
2255 return NULL;
2256 }
2257
2258 /* Reset Context Last Error code */
2259 device->LastError = ALC_NO_ERROR;
2260
2261 if((err=UpdateDeviceParams(device, attrList)) != ALC_NO_ERROR)
2262 {
2263 UnlockLists();
2264 alcSetError(device, err);
2265 if(err == ALC_INVALID_DEVICE)
2266 aluHandleDisconnect(device);
2267 ALCdevice_DecRef(device);
2268 return NULL;
2269 }
2270
2271 ALContext = calloc(1, sizeof(ALCcontext));
2272 if(ALContext)
2273 {
2274 ALContext->ref = 1;
2275
2276 ALContext->MaxActiveSources = 256;
2277 ALContext->ActiveSources = malloc(sizeof(ALContext->ActiveSources[0]) *
2278 ALContext->MaxActiveSources);
2279 }
2280 if(!ALContext || !ALContext->ActiveSources)
2281 {
2282 if(!device->ContextList)
2283 {
2284 ALCdevice_StopPlayback(device);
2285 device->Flags &= ~DEVICE_RUNNING;
2286 }
2287 UnlockLists();
2288
2289 free(ALContext);
2290 ALContext = NULL;
2291
2292 alcSetError(device, ALC_OUT_OF_MEMORY);
2293 ALCdevice_DecRef(device);
2294 return NULL;
2295 }
2296
2297 ALContext->Device = device;
2298 ALCdevice_IncRef(device);
2299 InitContext(ALContext);
2300
2301 do {
2302 ALContext->next = device->ContextList;
2303 } while(!CompExchangePtr((XchgPtr*)&device->ContextList, ALContext->next, ALContext));
2304 UnlockLists();
2305
2306 ALCdevice_DecRef(device);
2307
2308 TRACE("Created context %p\n", ALContext);
2309 return ALContext;
2310 }
2311
2312 /* alcDestroyContext
2313 *
2314 * Remove a Context
2315 */
2316 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
2317 {
2318 ALCdevice *Device;
2319
2320 LockLists();
2321 /* alcGetContextsDevice sets an error for invalid contexts */
2322 Device = alcGetContextsDevice(context);
2323 if(Device)
2324 {
2325 ReleaseContext(context, Device);
2326 if(!Device->ContextList)
2327 {
2328 ALCdevice_StopPlayback(Device);
2329 Device->Flags &= ~DEVICE_RUNNING;
2330 }
2331 }
2332 UnlockLists();
2333 }
2334
2335
2336 /* alcGetCurrentContext
2337 *
2338 * Returns the currently active Context
2339 */
2340 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(ALCvoid)
2341 {
2342 ALCcontext *Context;
2343
2344 Context = pthread_getspecific(LocalContext);
2345 if(!Context) Context = GlobalContext;
2346
2347 return Context;
2348 }
2349
2350 /* alcGetThreadContext
2351 *
2352 * Returns the currently active thread-local Context
2353 */
2354 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
2355 {
2356 ALCcontext *Context;
2357 Context = pthread_getspecific(LocalContext);
2358 return Context;
2359 }
2360
2361
2362 /* alcMakeContextCurrent
2363 *
2364 * Makes the given Context the active Context
2365 */
2366 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
2367 {
2368 /* context must be a valid Context or NULL */
2369 if(context && !(context=VerifyContext(context)))
2370 {
2371 alcSetError(NULL, ALC_INVALID_CONTEXT);
2372 return ALC_FALSE;
2373 }
2374 /* context's reference count is already incremented */
2375 context = ExchangePtr((XchgPtr*)&GlobalContext, context);
2376 if(context) ALCcontext_DecRef(context);
2377
2378 if((context=pthread_getspecific(LocalContext)) != NULL)
2379 {
2380 pthread_setspecific(LocalContext, NULL);
2381 ALCcontext_DecRef(context);
2382 }
2383
2384 return ALC_TRUE;
2385 }
2386
2387 /* alcSetThreadContext
2388 *
2389 * Makes the given Context the active Context for the current thread
2390 */
2391 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
2392 {
2393 ALCcontext *old;
2394
2395 /* context must be a valid Context or NULL */
2396 if(context && !(context=VerifyContext(context)))
2397 {
2398 alcSetError(NULL, ALC_INVALID_CONTEXT);
2399 return ALC_FALSE;
2400 }
2401 /* context's reference count is already incremented */
2402 old = pthread_getspecific(LocalContext);
2403 pthread_setspecific(LocalContext, context);
2404 if(old) ALCcontext_DecRef(old);
2405
2406 return ALC_TRUE;
2407 }
2408
2409
2410 /* alcGetContextsDevice
2411 *
2412 * Returns the Device that a particular Context is attached to
2413 */
2414 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
2415 {
2416 ALCdevice *Device;
2417
2418 if(!(Context=VerifyContext(Context)))
2419 {
2420 alcSetError(NULL, ALC_INVALID_CONTEXT);
2421 return NULL;
2422 }
2423 Device = Context->Device;
2424 ALCcontext_DecRef(Context);
2425
2426 return Device;
2427 }
2428
2429
2430 /* alcOpenDevice
2431 *
2432 * Open the Device specified.
2433 */
2434 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
2435 {
2436 const ALCchar *fmt;
2437 ALCdevice *device;
2438 ALCenum err;
2439
2440 DO_INITCONFIG();
2441
2442 if(!PlaybackBackend.name)
2443 {
2444 alcSetError(NULL, ALC_INVALID_VALUE);
2445 return NULL;
2446 }
2447
2448 if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
2449 deviceName = NULL;
2450
2451 device = calloc(1, sizeof(ALCdevice)+sizeof(ALeffectslot));
2452 if(!device)
2453 {
2454 alcSetError(NULL, ALC_OUT_OF_MEMORY);
2455 return NULL;
2456 }
2457
2458 //Validate device
2459 device->Funcs = &PlaybackBackend.Funcs;
2460 device->ref = 1;
2461 device->Connected = ALC_TRUE;
2462 device->Type = Playback;
2463 InitializeCriticalSection(&device->Mutex);
2464 device->LastError = ALC_NO_ERROR;
2465
2466 device->Flags = 0;
2467 device->Bs2b = NULL;
2468 device->Bs2bLevel = 0;
2469 device->DeviceName = NULL;
2470
2471 device->ContextList = NULL;
2472
2473 device->MaxNoOfSources = 256;
2474 device->AuxiliaryEffectSlotMax = 4;
2475 device->NumAuxSends = MAX_SENDS;
2476
2477 InitUIntMap(&device->BufferMap, ~0);
2478 InitUIntMap(&device->EffectMap, ~0);
2479 InitUIntMap(&device->FilterMap, ~0);
2480
2481 //Set output format
2482 device->FmtChans = DevFmtChannelsDefault;
2483 device->FmtType = DevFmtTypeDefault;
2484 device->Frequency = DEFAULT_OUTPUT_RATE;
2485 device->NumUpdates = 4;
2486 device->UpdateSize = 1024;
2487
2488 if(ConfigValueStr(NULL, "channels", &fmt))
2489 {
2490 static const struct {
2491 const char name[16];
2492 enum DevFmtChannels chans;
2493 } chanlist[] = {
2494 { "mono", DevFmtMono },
2495 { "stereo", DevFmtStereo },
2496 { "quad", DevFmtQuad },
2497 { "surround51", DevFmtX51 },
2498 { "surround61", DevFmtX61 },
2499 { "surround71", DevFmtX71 },
2500 };
2501 size_t i;
2502
2503 for(i = 0;i < COUNTOF(chanlist);i++)
2504 {
2505 if(strcasecmp(chanlist[i].name, fmt) == 0)
2506 {
2507 device->FmtChans = chanlist[i].chans;
2508 device->Flags |= DEVICE_CHANNELS_REQUEST;
2509 break;
2510 }
2511 }
2512 if(i == COUNTOF(chanlist))
2513 ERR("Unsupported channels: %s\n", fmt);
2514 }
2515 if(ConfigValueStr(NULL, "sample-type", &fmt))
2516 {
2517 static const struct {
2518 const char name[16];
2519 enum DevFmtType type;
2520 } typelist[] = {
2521 { "int8", DevFmtByte },
2522 { "uint8", DevFmtUByte },
2523 { "int16", DevFmtShort },
2524 { "uint16", DevFmtUShort },
2525 { "int32", DevFmtInt },
2526 { "uint32", DevFmtUInt },
2527 { "float32", DevFmtFloat },
2528 };
2529 size_t i;
2530
2531 for(i = 0;i < COUNTOF(typelist);i++)
2532 {
2533 if(strcasecmp(typelist[i].name, fmt) == 0)
2534 {
2535 device->FmtType = typelist[i].type;
2536 device->Flags |= DEVICE_SAMPLE_TYPE_REQUEST;
2537 break;
2538 }
2539 }
2540 if(i == COUNTOF(typelist))
2541 ERR("Unsupported sample-type: %s\n", fmt);
2542 }
2543 #define DEVICE_FORMAT_REQUEST (DEVICE_CHANNELS_REQUEST|DEVICE_SAMPLE_TYPE_REQUEST)
2544 if((device->Flags&DEVICE_FORMAT_REQUEST) != DEVICE_FORMAT_REQUEST &&
2545 ConfigValueStr(NULL, "format", &fmt))
2546 {
2547 static const struct {
2548 const char name[32];
2549 enum DevFmtChannels channels;
2550 enum DevFmtType type;
2551 } formats[] = {
2552 { "AL_FORMAT_MONO32", DevFmtMono, DevFmtFloat },
2553 { "AL_FORMAT_STEREO32", DevFmtStereo, DevFmtFloat },
2554 { "AL_FORMAT_QUAD32", DevFmtQuad, DevFmtFloat },
2555 { "AL_FORMAT_51CHN32", DevFmtX51, DevFmtFloat },
2556 { "AL_FORMAT_61CHN32", DevFmtX61, DevFmtFloat },
2557 { "AL_FORMAT_71CHN32", DevFmtX71, DevFmtFloat },
2558
2559 { "AL_FORMAT_MONO16", DevFmtMono, DevFmtShort },
2560 { "AL_FORMAT_STEREO16", DevFmtStereo, DevFmtShort },
2561 { "AL_FORMAT_QUAD16", DevFmtQuad, DevFmtShort },
2562 { "AL_FORMAT_51CHN16", DevFmtX51, DevFmtShort },
2563 { "AL_FORMAT_61CHN16", DevFmtX61, DevFmtShort },
2564 { "AL_FORMAT_71CHN16", DevFmtX71, DevFmtShort },
2565
2566 { "AL_FORMAT_MONO8", DevFmtMono, DevFmtByte },
2567 { "AL_FORMAT_STEREO8", DevFmtStereo, DevFmtByte },
2568 { "AL_FORMAT_QUAD8", DevFmtQuad, DevFmtByte },
2569 { "AL_FORMAT_51CHN8", DevFmtX51, DevFmtByte },
2570 { "AL_FORMAT_61CHN8", DevFmtX61, DevFmtByte },
2571 { "AL_FORMAT_71CHN8", DevFmtX71, DevFmtByte }
2572 };
2573 size_t i;
2574
2575 ERR("Option 'format' is deprecated, please use 'channels' and 'sample-type'\n");
2576 for(i = 0;i < COUNTOF(formats);i++)
2577 {
2578 if(strcasecmp(fmt, formats[i].name) == 0)
2579 {
2580 if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
2581 device->FmtChans = formats[i].channels;
2582 if(!(device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
2583 device->FmtType = formats[i].type;
2584 device->Flags |= DEVICE_FORMAT_REQUEST;
2585 break;
2586 }
2587 }
2588 if(i == COUNTOF(formats))
2589 ERR("Unsupported format: %s\n", fmt);
2590 }
2591 #undef DEVICE_FORMAT_REQUEST
2592
2593 if(ConfigValueUInt(NULL, "frequency", &device->Frequency))
2594 {
2595 device->Flags |= DEVICE_FREQUENCY_REQUEST;
2596 if(device->Frequency < MIN_OUTPUT_RATE)
2597 ERR("%uhz request clamped to %uhz minimum\n", device->Frequency, MIN_OUTPUT_RATE);
2598 device->Frequency = maxu(device->Frequency, MIN_OUTPUT_RATE);
2599 }
2600
2601 ConfigValueUInt(NULL, "periods", &device->NumUpdates);
2602 device->NumUpdates = clampu(device->NumUpdates, 2, 16);
2603
2604 ConfigValueUInt(NULL, "period_size", &device->UpdateSize);
2605 device->UpdateSize = clampu(device->UpdateSize, 64, 8192);
2606
2607 ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
2608 if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
2609
2610 ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
2611 if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
2612
2613 ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
2614 if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
2615
2616 ConfigValueInt(NULL, "cf_level", &device->Bs2bLevel);
2617
2618 device->NumStereoSources = 1;
2619 device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
2620
2621 // Find a playback device to open
2622 LockLists();
2623 if((err=ALCdevice_OpenPlayback(device, deviceName)) != ALC_NO_ERROR)
2624 {
2625 UnlockLists();
2626 DeleteCriticalSection(&device->Mutex);
2627 free(device);
2628 alcSetError(NULL, err);
2629 return NULL;
2630 }
2631 UnlockLists();
2632
2633 if(DefaultEffect.type != AL_EFFECT_NULL)
2634 {
2635 device->DefaultSlot = (ALeffectslot*)(device+1);
2636 if(InitEffectSlot(device->DefaultSlot) != AL_NO_ERROR)
2637 {
2638 device->DefaultSlot = NULL;
2639 ERR("Failed to initialize the default effect slot\n");
2640 }
2641 else if(InitializeEffect(device, device->DefaultSlot, &DefaultEffect) != AL_NO_ERROR)
2642 {
2643 ALeffectState_Destroy(device->DefaultSlot->EffectState);
2644 device->DefaultSlot = NULL;
2645 ERR("Failed to initialize the default effect\n");
2646 }
2647 }
2648
2649 do {
2650 device->next = DeviceList;
2651 } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
2652
2653 TRACE("Created device %p, \"%s\"\n", device, device->DeviceName);
2654 return device;
2655 }
2656
2657 /* alcCloseDevice
2658 *
2659 * Close the specified Device
2660 */
2661 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *Device)
2662 {
2663 ALCdevice *volatile*list;
2664 ALCcontext *ctx;
2665
2666 LockLists();
2667 list = &DeviceList;
2668 while(*list && *list != Device)
2669 list = &(*list)->next;
2670
2671 if(!*list || (*list)->Type == Capture)
2672 {
2673 alcSetError(*list, ALC_INVALID_DEVICE);
2674 UnlockLists();
2675 return ALC_FALSE;
2676 }
2677
2678 *list = (*list)->next;
2679 UnlockLists();
2680
2681 while((ctx=Device->ContextList) != NULL)
2682 {
2683 WARN("Releasing context %p\n", ctx);
2684 ReleaseContext(ctx, Device);
2685 }
2686 if((Device->Flags&DEVICE_RUNNING))
2687 ALCdevice_StopPlayback(Device);
2688 Device->Flags &= ~DEVICE_RUNNING;
2689
2690 ALCdevice_ClosePlayback(Device);
2691
2692 ALCdevice_DecRef(Device);
2693
2694 return ALC_TRUE;
2695 }
2696
2697
2698 /* alcLoopbackOpenDeviceSOFT
2699 *
2700 * Open a loopback device, for manual rendering.
2701 */
2702 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
2703 {
2704 ALCdevice *device;
2705
2706 DO_INITCONFIG();
2707
2708 /* Make sure the device name, if specified, is us. */
2709 if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
2710 {
2711 alcSetError(NULL, ALC_INVALID_VALUE);
2712 return NULL;
2713 }
2714
2715 device = calloc(1, sizeof(ALCdevice));
2716 if(!device)
2717 {
2718 alcSetError(NULL, ALC_OUT_OF_MEMORY);
2719 return NULL;
2720 }
2721
2722 //Validate device
2723 device->Funcs = &BackendLoopback.Funcs;
2724 device->ref = 1;
2725 device->Connected = ALC_TRUE;
2726 device->Type = Loopback;
2727 InitializeCriticalSection(&device->Mutex);
2728 device->LastError = ALC_NO_ERROR;
2729
2730 device->Flags = 0;
2731 device->Bs2b = NULL;
2732 device->Bs2bLevel = 0;
2733 device->DeviceName = NULL;
2734
2735 device->ContextList = NULL;
2736
2737 device->MaxNoOfSources = 256;
2738 device->AuxiliaryEffectSlotMax = 4;
2739 device->NumAuxSends = MAX_SENDS;
2740
2741 InitUIntMap(&device->BufferMap, ~0);
2742 InitUIntMap(&device->EffectMap, ~0);
2743 InitUIntMap(&device->FilterMap, ~0);
2744
2745 //Set output format
2746 device->NumUpdates = 0;
2747 device->UpdateSize = 0;
2748
2749 device->Frequency = DEFAULT_OUTPUT_RATE;
2750 device->FmtChans = DevFmtChannelsDefault;
2751 device->FmtType = DevFmtTypeDefault;
2752
2753 ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
2754 if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
2755
2756 ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
2757 if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
2758
2759 ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
2760 if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
2761
2762 device->NumStereoSources = 1;
2763 device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
2764
2765 // Open the "backend"
2766 ALCdevice_OpenPlayback(device, "Loopback");
2767 do {
2768 device->next = DeviceList;
2769 } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
2770
2771 TRACE("Created device %p\n", device);
2772 return device;
2773 }
2774
2775 /* alcIsRenderFormatSupportedSOFT
2776 *
2777 * Determines if the loopback device supports the given format for rendering.
2778 */
2779 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
2780 {
2781 ALCboolean ret = ALC_FALSE;
2782
2783 if(!(device=VerifyDevice(device)) || device->Type != Loopback)
2784 alcSetError(device, ALC_INVALID_DEVICE);
2785 else if(freq <= 0)
2786 alcSetError(device, ALC_INVALID_VALUE);
2787 else
2788 {
2789 if(IsValidALCType(type) && BytesFromDevFmt(type) > 0 &&
2790 IsValidALCChannels(channels) && ChannelsFromDevFmt(channels) > 0 &&
2791 freq >= MIN_OUTPUT_RATE)
2792 ret = ALC_TRUE;
2793 }
2794 if(device) ALCdevice_DecRef(device);
2795
2796 return ret;
2797 }
2798
2799 /* alcRenderSamplesSOFT
2800 *
2801 * Renders some samples into a buffer, using the format last set by the
2802 * attributes given to alcCreateContext.
2803 */
2804 ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
2805 {
2806 if(!(device=VerifyDevice(device)) || device->Type != Loopback)
2807 alcSetError(device, ALC_INVALID_DEVICE);
2808 else if(samples < 0 || (samples > 0 && buffer == NULL))
2809 alcSetError(device, ALC_INVALID_VALUE);
2810 else
2811 aluMixData(device, buffer, samples);
2812 if(device) ALCdevice_DecRef(device);
2813 }
2814
2815
2816 static void ReleaseALC(void)
2817 {
2818 ALCdevice *dev;
2819
2820 free(alcAllDeviceList); alcAllDeviceList = NULL;
2821 alcAllDeviceListSize = 0;
2822 free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
2823 alcCaptureDeviceListSize = 0;
2824
2825 free(alcDefaultAllDeviceSpecifier);
2826 alcDefaultAllDeviceSpecifier = NULL;
2827 free(alcCaptureDefaultDeviceSpecifier);
2828 alcCaptureDefaultDeviceSpecifier = NULL;
2829
2830 if((dev=ExchangePtr((XchgPtr*)&DeviceList, NULL)) != NULL)
2831 {
2832 ALCuint num = 0;
2833 do {
2834 num++;
2835 } while((dev=dev->next) != NULL);
2836 ERR("%u device%s not closed\n", num, (num>1)?"s":"");
2837 }
2838 }
2839
2840 ///////////////////////////////////////////////////////
fork of openal-soft for dark-hammer project