?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add experimental device attributes for apps to query
[openal-soft.git] / Alc / ALc.c
blob66fb6890cec2f18f27f52de81c8c5144c19d39bd
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #include "config.h"
22
23 #include <math.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <memory.h>
27 #include <ctype.h>
28
29 #include "alMain.h"
30 #include "alSource.h"
31 #include "AL/al.h"
32 #include "AL/alc.h"
33 #include "alThunk.h"
34 #include "alSource.h"
35 #include "alBuffer.h"
36 #include "alAuxEffectSlot.h"
37 #include "alDatabuffer.h"
38 #include "bs2b.h"
39 #include "alu.h"
40
41
42 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
43 typedef struct BackendInfo {
44 const char *name;
45 void (*Init)(BackendFuncs*);
46 void (*Deinit)(void);
47 void (*Probe)(int);
48 BackendFuncs Funcs;
49 } BackendInfo;
50 static BackendInfo BackendList[] = {
51 #ifdef HAVE_PULSEAUDIO
52 { "pulse", alc_pulse_init, alc_pulse_deinit, alc_pulse_probe, EmptyFuncs },
53 #endif
54 #ifdef HAVE_ALSA
55 { "alsa", alc_alsa_init, alc_alsa_deinit, alc_alsa_probe, EmptyFuncs },
56 #endif
57 #ifdef HAVE_OSS
58 { "oss", alc_oss_init, alc_oss_deinit, alc_oss_probe, EmptyFuncs },
59 #endif
60 #ifdef HAVE_SOLARIS
61 { "solaris", alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },
62 #endif
63 #ifdef HAVE_DSOUND
64 { "dsound", alcDSoundInit, alcDSoundDeinit, alcDSoundProbe, EmptyFuncs },
65 #endif
66 #ifdef HAVE_WINMM
67 { "winmm", alcWinMMInit, alcWinMMDeinit, alcWinMMProbe, EmptyFuncs },
68 #endif
69 #ifdef HAVE_PORTAUDIO
70 { "port", alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
71 #endif
72
73 { "null", alc_null_init, alc_null_deinit, alc_null_probe, EmptyFuncs },
74 #ifdef HAVE_WAVE
75 { "wave", alc_wave_init, alc_wave_deinit, alc_wave_probe, EmptyFuncs },
76 #endif
77
78 { NULL, NULL, NULL, NULL, EmptyFuncs }
79 };
80 #undef EmptyFuncs
81
82 ///////////////////////////////////////////////////////
83
84 #define ALC_EFX_MAJOR_VERSION 0x20001
85 #define ALC_EFX_MINOR_VERSION 0x20002
86 #define ALC_MAX_AUXILIARY_SENDS 0x20003
87
88 ///////////////////////////////////////////////////////
89 // STRING and EXTENSIONS
90
91 typedef struct ALCfunction {
92 const ALCchar *funcName;
93 ALCvoid *address;
94 } ALCfunction;
95
96 typedef struct ALCenums {
97 const ALCchar *enumName;
98 ALCenum value;
99 } ALCenums;
100
101
102 static const ALCfunction alcFunctions[] = {
103 { "alcCreateContext", (ALCvoid *) alcCreateContext },
104 { "alcMakeContextCurrent", (ALCvoid *) alcMakeContextCurrent },
105 { "alcProcessContext", (ALCvoid *) alcProcessContext },
106 { "alcSuspendContext", (ALCvoid *) alcSuspendContext },
107 { "alcDestroyContext", (ALCvoid *) alcDestroyContext },
108 { "alcGetCurrentContext", (ALCvoid *) alcGetCurrentContext },
109 { "alcGetContextsDevice", (ALCvoid *) alcGetContextsDevice },
110 { "alcOpenDevice", (ALCvoid *) alcOpenDevice },
111 { "alcCloseDevice", (ALCvoid *) alcCloseDevice },
112 { "alcGetError", (ALCvoid *) alcGetError },
113 { "alcIsExtensionPresent", (ALCvoid *) alcIsExtensionPresent },
114 { "alcGetProcAddress", (ALCvoid *) alcGetProcAddress },
115 { "alcGetEnumValue", (ALCvoid *) alcGetEnumValue },
116 { "alcGetString", (ALCvoid *) alcGetString },
117 { "alcGetIntegerv", (ALCvoid *) alcGetIntegerv },
118 { "alcCaptureOpenDevice", (ALCvoid *) alcCaptureOpenDevice },
119 { "alcCaptureCloseDevice", (ALCvoid *) alcCaptureCloseDevice },
120 { "alcCaptureStart", (ALCvoid *) alcCaptureStart },
121 { "alcCaptureStop", (ALCvoid *) alcCaptureStop },
122 { "alcCaptureSamples", (ALCvoid *) alcCaptureSamples },
123
124 { "alcSetThreadContext", (ALCvoid *) alcSetThreadContext },
125 { "alcGetThreadContext", (ALCvoid *) alcGetThreadContext },
126
127 { "alEnable", (ALCvoid *) alEnable },
128 { "alDisable", (ALCvoid *) alDisable },
129 { "alIsEnabled", (ALCvoid *) alIsEnabled },
130 { "alGetString", (ALCvoid *) alGetString },
131 { "alGetBooleanv", (ALCvoid *) alGetBooleanv },
132 { "alGetIntegerv", (ALCvoid *) alGetIntegerv },
133 { "alGetFloatv", (ALCvoid *) alGetFloatv },
134 { "alGetDoublev", (ALCvoid *) alGetDoublev },
135 { "alGetBoolean", (ALCvoid *) alGetBoolean },
136 { "alGetInteger", (ALCvoid *) alGetInteger },
137 { "alGetFloat", (ALCvoid *) alGetFloat },
138 { "alGetDouble", (ALCvoid *) alGetDouble },
139 { "alGetError", (ALCvoid *) alGetError },
140 { "alIsExtensionPresent", (ALCvoid *) alIsExtensionPresent },
141 { "alGetProcAddress", (ALCvoid *) alGetProcAddress },
142 { "alGetEnumValue", (ALCvoid *) alGetEnumValue },
143 { "alListenerf", (ALCvoid *) alListenerf },
144 { "alListener3f", (ALCvoid *) alListener3f },
145 { "alListenerfv", (ALCvoid *) alListenerfv },
146 { "alListeneri", (ALCvoid *) alListeneri },
147 { "alListener3i", (ALCvoid *) alListener3i },
148 { "alListeneriv", (ALCvoid *) alListeneriv },
149 { "alGetListenerf", (ALCvoid *) alGetListenerf },
150 { "alGetListener3f", (ALCvoid *) alGetListener3f },
151 { "alGetListenerfv", (ALCvoid *) alGetListenerfv },
152 { "alGetListeneri", (ALCvoid *) alGetListeneri },
153 { "alGetListener3i", (ALCvoid *) alGetListener3i },
154 { "alGetListeneriv", (ALCvoid *) alGetListeneriv },
155 { "alGenSources", (ALCvoid *) alGenSources },
156 { "alDeleteSources", (ALCvoid *) alDeleteSources },
157 { "alIsSource", (ALCvoid *) alIsSource },
158 { "alSourcef", (ALCvoid *) alSourcef },
159 { "alSource3f", (ALCvoid *) alSource3f },
160 { "alSourcefv", (ALCvoid *) alSourcefv },
161 { "alSourcei", (ALCvoid *) alSourcei },
162 { "alSource3i", (ALCvoid *) alSource3i },
163 { "alSourceiv", (ALCvoid *) alSourceiv },
164 { "alGetSourcef", (ALCvoid *) alGetSourcef },
165 { "alGetSource3f", (ALCvoid *) alGetSource3f },
166 { "alGetSourcefv", (ALCvoid *) alGetSourcefv },
167 { "alGetSourcei", (ALCvoid *) alGetSourcei },
168 { "alGetSource3i", (ALCvoid *) alGetSource3i },
169 { "alGetSourceiv", (ALCvoid *) alGetSourceiv },
170 { "alSourcePlayv", (ALCvoid *) alSourcePlayv },
171 { "alSourceStopv", (ALCvoid *) alSourceStopv },
172 { "alSourceRewindv", (ALCvoid *) alSourceRewindv },
173 { "alSourcePausev", (ALCvoid *) alSourcePausev },
174 { "alSourcePlay", (ALCvoid *) alSourcePlay },
175 { "alSourceStop", (ALCvoid *) alSourceStop },
176 { "alSourceRewind", (ALCvoid *) alSourceRewind },
177 { "alSourcePause", (ALCvoid *) alSourcePause },
178 { "alSourceQueueBuffers", (ALCvoid *) alSourceQueueBuffers },
179 { "alSourceUnqueueBuffers", (ALCvoid *) alSourceUnqueueBuffers },
180 { "alGenBuffers", (ALCvoid *) alGenBuffers },
181 { "alDeleteBuffers", (ALCvoid *) alDeleteBuffers },
182 { "alIsBuffer", (ALCvoid *) alIsBuffer },
183 { "alBufferData", (ALCvoid *) alBufferData },
184 { "alBufferf", (ALCvoid *) alBufferf },
185 { "alBuffer3f", (ALCvoid *) alBuffer3f },
186 { "alBufferfv", (ALCvoid *) alBufferfv },
187 { "alBufferi", (ALCvoid *) alBufferi },
188 { "alBuffer3i", (ALCvoid *) alBuffer3i },
189 { "alBufferiv", (ALCvoid *) alBufferiv },
190 { "alGetBufferf", (ALCvoid *) alGetBufferf },
191 { "alGetBuffer3f", (ALCvoid *) alGetBuffer3f },
192 { "alGetBufferfv", (ALCvoid *) alGetBufferfv },
193 { "alGetBufferi", (ALCvoid *) alGetBufferi },
194 { "alGetBuffer3i", (ALCvoid *) alGetBuffer3i },
195 { "alGetBufferiv", (ALCvoid *) alGetBufferiv },
196 { "alDopplerFactor", (ALCvoid *) alDopplerFactor },
197 { "alDopplerVelocity", (ALCvoid *) alDopplerVelocity },
198 { "alSpeedOfSound", (ALCvoid *) alSpeedOfSound },
199 { "alDistanceModel", (ALCvoid *) alDistanceModel },
200
201 { "alGenFilters", (ALCvoid *) alGenFilters },
202 { "alDeleteFilters", (ALCvoid *) alDeleteFilters },
203 { "alIsFilter", (ALCvoid *) alIsFilter },
204 { "alFilteri", (ALCvoid *) alFilteri },
205 { "alFilteriv", (ALCvoid *) alFilteriv },
206 { "alFilterf", (ALCvoid *) alFilterf },
207 { "alFilterfv", (ALCvoid *) alFilterfv },
208 { "alGetFilteri", (ALCvoid *) alGetFilteri },
209 { "alGetFilteriv", (ALCvoid *) alGetFilteriv },
210 { "alGetFilterf", (ALCvoid *) alGetFilterf },
211 { "alGetFilterfv", (ALCvoid *) alGetFilterfv },
212
213 { "alGenEffects", (ALCvoid *) alGenEffects },
214 { "alDeleteEffects", (ALCvoid *) alDeleteEffects },
215 { "alIsEffect", (ALCvoid *) alIsEffect },
216 { "alEffecti", (ALCvoid *) alEffecti },
217 { "alEffectiv", (ALCvoid *) alEffectiv },
218 { "alEffectf", (ALCvoid *) alEffectf },
219 { "alEffectfv", (ALCvoid *) alEffectfv },
220 { "alGetEffecti", (ALCvoid *) alGetEffecti },
221 { "alGetEffectiv", (ALCvoid *) alGetEffectiv },
222 { "alGetEffectf", (ALCvoid *) alGetEffectf },
223 { "alGetEffectfv", (ALCvoid *) alGetEffectfv },
224
225 { "alGenAuxiliaryEffectSlots", (ALCvoid *) alGenAuxiliaryEffectSlots},
226 { "alDeleteAuxiliaryEffectSlots",(ALCvoid *) alDeleteAuxiliaryEffectSlots},
227 { "alIsAuxiliaryEffectSlot", (ALCvoid *) alIsAuxiliaryEffectSlot },
228 { "alAuxiliaryEffectSloti", (ALCvoid *) alAuxiliaryEffectSloti },
229 { "alAuxiliaryEffectSlotiv", (ALCvoid *) alAuxiliaryEffectSlotiv },
230 { "alAuxiliaryEffectSlotf", (ALCvoid *) alAuxiliaryEffectSlotf },
231 { "alAuxiliaryEffectSlotfv", (ALCvoid *) alAuxiliaryEffectSlotfv },
232 { "alGetAuxiliaryEffectSloti", (ALCvoid *) alGetAuxiliaryEffectSloti},
233 { "alGetAuxiliaryEffectSlotiv", (ALCvoid *) alGetAuxiliaryEffectSlotiv},
234 { "alGetAuxiliaryEffectSlotf", (ALCvoid *) alGetAuxiliaryEffectSlotf},
235 { "alGetAuxiliaryEffectSlotfv", (ALCvoid *) alGetAuxiliaryEffectSlotfv},
236
237 { "alBufferSubDataEXT", (ALCvoid *) alBufferSubDataEXT },
238
239 { "alGenDatabuffersEXT", (ALCvoid *) alGenDatabuffersEXT },
240 { "alDeleteDatabuffersEXT", (ALCvoid *) alDeleteDatabuffersEXT },
241 { "alIsDatabufferEXT", (ALCvoid *) alIsDatabufferEXT },
242 { "alDatabufferDataEXT", (ALCvoid *) alDatabufferDataEXT },
243 { "alDatabufferSubDataEXT", (ALCvoid *) alDatabufferSubDataEXT },
244 { "alGetDatabufferSubDataEXT", (ALCvoid *) alGetDatabufferSubDataEXT},
245 { "alDatabufferfEXT", (ALCvoid *) alDatabufferfEXT },
246 { "alDatabufferfvEXT", (ALCvoid *) alDatabufferfvEXT },
247 { "alDatabufferiEXT", (ALCvoid *) alDatabufferiEXT },
248 { "alDatabufferivEXT", (ALCvoid *) alDatabufferivEXT },
249 { "alGetDatabufferfEXT", (ALCvoid *) alGetDatabufferfEXT },
250 { "alGetDatabufferfvEXT", (ALCvoid *) alGetDatabufferfvEXT },
251 { "alGetDatabufferiEXT", (ALCvoid *) alGetDatabufferiEXT },
252 { "alGetDatabufferivEXT", (ALCvoid *) alGetDatabufferivEXT },
253 { "alSelectDatabufferEXT", (ALCvoid *) alSelectDatabufferEXT },
254 { "alMapDatabufferEXT", (ALCvoid *) alMapDatabufferEXT },
255 { "alUnmapDatabufferEXT", (ALCvoid *) alUnmapDatabufferEXT },
256
257 { NULL, (ALCvoid *) NULL }
258 };
259
260 static const ALCenums enumeration[] = {
261 // Types
262 { "ALC_INVALID", ALC_INVALID },
263 { "ALC_FALSE", ALC_FALSE },
264 { "ALC_TRUE", ALC_TRUE },
265
266 // ALC Properties
267 { "ALC_MAJOR_VERSION", ALC_MAJOR_VERSION },
268 { "ALC_MINOR_VERSION", ALC_MINOR_VERSION },
269 { "ALC_ATTRIBUTES_SIZE", ALC_ATTRIBUTES_SIZE },
270 { "ALC_ALL_ATTRIBUTES", ALC_ALL_ATTRIBUTES },
271 { "ALC_DEFAULT_DEVICE_SPECIFIER", ALC_DEFAULT_DEVICE_SPECIFIER },
272 { "ALC_DEVICE_SPECIFIER", ALC_DEVICE_SPECIFIER },
273 { "ALC_ALL_DEVICES_SPECIFIER", ALC_ALL_DEVICES_SPECIFIER },
274 { "ALC_DEFAULT_ALL_DEVICES_SPECIFIER", ALC_DEFAULT_ALL_DEVICES_SPECIFIER },
275 { "ALC_EXTENSIONS", ALC_EXTENSIONS },
276 { "ALC_FREQUENCY", ALC_FREQUENCY },
277 { "ALC_REFRESH", ALC_REFRESH },
278 { "ALC_SYNC", ALC_SYNC },
279 { "ALC_MONO_SOURCES", ALC_MONO_SOURCES },
280 { "ALC_STEREO_SOURCES", ALC_STEREO_SOURCES },
281 { "ALC_CAPTURE_DEVICE_SPECIFIER", ALC_CAPTURE_DEVICE_SPECIFIER },
282 { "ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
283 { "ALC_CAPTURE_SAMPLES", ALC_CAPTURE_SAMPLES },
284 { "ALC_CONNECTED", ALC_CONNECTED },
285
286 // EFX Properties
287 { "ALC_EFX_MAJOR_VERSION", ALC_EFX_MAJOR_VERSION },
288 { "ALC_EFX_MINOR_VERSION", ALC_EFX_MINOR_VERSION },
289 { "ALC_MAX_AUXILIARY_SENDS", ALC_MAX_AUXILIARY_SENDS },
290
291 // ALC Error Message
292 { "ALC_NO_ERROR", ALC_NO_ERROR },
293 { "ALC_INVALID_DEVICE", ALC_INVALID_DEVICE },
294 { "ALC_INVALID_CONTEXT", ALC_INVALID_CONTEXT },
295 { "ALC_INVALID_ENUM", ALC_INVALID_ENUM },
296 { "ALC_INVALID_VALUE", ALC_INVALID_VALUE },
297 { "ALC_OUT_OF_MEMORY", ALC_OUT_OF_MEMORY },
298 { NULL, (ALCenum)0 }
299 };
300 // Error strings
301 static const ALCchar alcNoError[] = "No Error";
302 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
303 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
304 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
305 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
306 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
307
308 /* Device lists. Sizes only include the first ending null character, not the
309 * second */
310 static ALCchar *alcDeviceList;
311 static size_t alcDeviceListSize;
312 static ALCchar *alcAllDeviceList;
313 static size_t alcAllDeviceListSize;
314 static ALCchar *alcCaptureDeviceList;
315 static size_t alcCaptureDeviceListSize;
316 // Default is always the first in the list
317 static ALCchar *alcDefaultDeviceSpecifier;
318 static ALCchar *alcDefaultAllDeviceSpecifier;
319 static ALCchar *alcCaptureDefaultDeviceSpecifier;
320
321
322 static const ALCchar alcNoDeviceExtList[] =
323 "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
324 "ALC_EXT_thread_local_context";
325 static const ALCchar alcExtensionList[] =
326 "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
327 "ALC_EXT_disconnect ALC_EXT_EFX ALC_EXT_thread_local_context";
328 static const ALCint alcMajorVersion = 1;
329 static const ALCint alcMinorVersion = 1;
330
331 static const ALCint alcEFXMajorVersion = 1;
332 static const ALCint alcEFXMinorVersion = 0;
333
334 ///////////////////////////////////////////////////////
335
336
337 ///////////////////////////////////////////////////////
338 // Global Variables
339
340 static ALCdevice *g_pDeviceList = NULL;
341 static ALCuint g_ulDeviceCount = 0;
342
343 static CRITICAL_SECTION g_csMutex;
344
345 // Context List
346 static ALCcontext *g_pContextList = NULL;
347 static ALCuint g_ulContextCount = 0;
348
349 // Thread-local current context
350 static tls_type LocalContext;
351 // Process-wide current context
352 static ALCcontext *GlobalContext;
353
354 // Context Error
355 static ALCenum g_eLastNullDeviceError = ALC_NO_ERROR;
356
357 // Default context extensions
358 static const ALchar alExtList[] =
359 "AL_EXTX_buffer_sub_data AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE "
360 "AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXTX_loop_points "
361 "AL_EXT_MCFORMATS AL_EXT_MULAW AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET "
362 "AL_EXTX_sample_buffer_object AL_EXT_source_distance_model "
363 "AL_LOKI_quadriphonic";
364
365 // Mixing Priority Level
366 static ALint RTPrioLevel;
367
368 // Resampler Quality
369 resampler_t DefaultResampler;
370
371 // Output Log File
372 static FILE *LogFile;
373
374 ///////////////////////////////////////////////////////
375
376
377 ///////////////////////////////////////////////////////
378 // ALC Related helper functions
379 #ifdef _WIN32
380 static void alc_init(void);
381 static void alc_deinit(void);
382
383 BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
384 {
385 (void)lpReserved;
386
387 // Perform actions based on the reason for calling.
388 switch(ul_reason_for_call)
389 {
390 case DLL_PROCESS_ATTACH:
391 DisableThreadLibraryCalls(hModule);
392 alc_init();
393 break;
394
395 case DLL_PROCESS_DETACH:
396 alc_deinit();
397 break;
398 }
399 return TRUE;
400 }
401 #else
402 #ifdef HAVE_GCC_DESTRUCTOR
403 static void alc_init(void) __attribute__((constructor));
404 static void alc_deinit(void) __attribute__((destructor));
405 #endif
406 #endif
407
408 static void alc_init(void)
409 {
410 int i;
411 const char *devs, *str;
412
413 str = getenv("ALSOFT_LOGFILE");
414 if(str && str[0])
415 {
416 LogFile = fopen(str, "w");
417 if(!LogFile)
418 fprintf(stderr, "AL lib: Failed to open log file '%s'\n", str);
419 }
420 if(!LogFile)
421 LogFile = stderr;
422
423 InitializeCriticalSection(&g_csMutex);
424 ALTHUNK_INIT();
425 ReadALConfig();
426
427 tls_create(&LocalContext);
428
429 RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 0);
430
431 DefaultResampler = GetConfigValueInt(NULL, "resampler", RESAMPLER_DEFAULT);
432 if(DefaultResampler >= RESAMPLER_MAX || DefaultResampler <= RESAMPLER_MIN)
433 DefaultResampler = RESAMPLER_DEFAULT;
434
435 devs = GetConfigValue(NULL, "drivers", "");
436 if(devs[0])
437 {
438 int n;
439 size_t len;
440 const char *next = devs;
441 int endlist, delitem;
442
443 i = 0;
444 do {
445 devs = next;
446 next = strchr(devs, ',');
447
448 delitem = (devs[0] == '-');
449 if(devs[0] == '-') devs++;
450
451 if(!devs[0] || devs[0] == ',')
452 {
453 endlist = 0;
454 continue;
455 }
456 endlist = 1;
457
458 len = (next ? ((size_t)(next-devs)) : strlen(devs));
459 for(n = i;BackendList[n].Init;n++)
460 {
461 if(len == strlen(BackendList[n].name) &&
462 strncmp(BackendList[n].name, devs, len) == 0)
463 {
464 if(delitem)
465 {
466 do {
467 BackendList[n] = BackendList[n+1];
468 ++n;
469 } while(BackendList[n].Init);
470 }
471 else
472 {
473 BackendInfo Bkp = BackendList[n];
474 while(n > i)
475 {
476 BackendList[n] = BackendList[n-1];
477 --n;
478 }
479 BackendList[n] = Bkp;
480
481 i++;
482 }
483 break;
484 }
485 }
486 } while(next++);
487
488 if(endlist)
489 {
490 BackendList[i].name = NULL;
491 BackendList[i].Init = NULL;
492 BackendList[i].Deinit = NULL;
493 BackendList[i].Probe = NULL;
494 }
495 }
496
497 for(i = 0;BackendList[i].Init;i++)
498 BackendList[i].Init(&BackendList[i].Funcs);
499
500 str = GetConfigValue(NULL, "excludefx", "");
501 if(str[0])
502 {
503 const struct {
504 const char *name;
505 int type;
506 } EffectList[] = {
507 { "eaxreverb", EAXREVERB },
508 { "reverb", REVERB },
509 { "echo", ECHO },
510 { "modulator", MODULATOR },
511 { NULL, 0 }
512 };
513 int n;
514 size_t len;
515 const char *next = str;
516
517 do {
518 str = next;
519 next = strchr(str, ',');
520
521 if(!str[0] || next == str)
522 continue;
523
524 len = (next ? ((size_t)(next-str)) : strlen(str));
525 for(n = 0;EffectList[n].name;n++)
526 {
527 if(len == strlen(EffectList[n].name) &&
528 strncmp(EffectList[n].name, str, len) == 0)
529 DisabledEffects[EffectList[n].type] = AL_TRUE;
530 }
531 } while(next++);
532 }
533 }
534
535 static void alc_deinit(void)
536 {
537 int i;
538
539 ReleaseALC();
540
541 for(i = 0;BackendList[i].Deinit;i++)
542 BackendList[i].Deinit();
543
544 tls_delete(LocalContext);
545
546 FreeALConfig();
547 ALTHUNK_EXIT();
548 DeleteCriticalSection(&g_csMutex);
549
550 if(LogFile != stderr)
551 fclose(LogFile);
552 LogFile = NULL;
553 }
554
555
556 static void ProbeDeviceList()
557 {
558 ALint i;
559
560 free(alcDeviceList); alcDeviceList = NULL;
561 alcDeviceListSize = 0;
562
563 for(i = 0;BackendList[i].Probe;i++)
564 BackendList[i].Probe(DEVICE_PROBE);
565 }
566
567 static void ProbeAllDeviceList()
568 {
569 ALint i;
570
571 free(alcAllDeviceList); alcAllDeviceList = NULL;
572 alcAllDeviceListSize = 0;
573
574 for(i = 0;BackendList[i].Probe;i++)
575 BackendList[i].Probe(ALL_DEVICE_PROBE);
576 }
577
578 static void ProbeCaptureDeviceList()
579 {
580 ALint i;
581
582 free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
583 alcCaptureDeviceListSize = 0;
584
585 for(i = 0;BackendList[i].Probe;i++)
586 BackendList[i].Probe(CAPTURE_DEVICE_PROBE);
587 }
588
589
590 #define DECL_APPEND_LIST_FUNC(type) \
591 void Append##type##List(const ALCchar *name) \
592 { \
593 size_t len = strlen(name); \
594 void *temp; \
595 \
596 if(len == 0) \
597 return; \
598 \
599 temp = realloc(alc##type##List, alc##type##ListSize + len + 2); \
600 if(!temp) \
601 { \
602 AL_PRINT("Realloc failed to add %s!\n", name); \
603 return; \
604 } \
605 alc##type##List = temp; \
606 sprintf(alc##type##List+alc##type##ListSize, "%s", name); \
607 alc##type##ListSize += len+1; \
608 alc##type##List[alc##type##ListSize] = 0; \
609 }
610
611 DECL_APPEND_LIST_FUNC(Device)
612 DECL_APPEND_LIST_FUNC(AllDevice)
613 DECL_APPEND_LIST_FUNC(CaptureDevice)
614
615
616 void al_print(const char *fname, unsigned int line, const char *fmt, ...)
617 {
618 const char *fn;
619 char str[256];
620 int i;
621
622 fn = strrchr(fname, '/');
623 if(!fn) fn = strrchr(fname, '\\');;
624 if(!fn) fn = fname;
625 else fn += 1;
626
627 i = snprintf(str, sizeof(str), "AL lib: %s:%d: ", fn, line);
628 if(i < (int)sizeof(str) && i > 0)
629 {
630 va_list ap;
631 va_start(ap, fmt);
632 vsnprintf(str+i, sizeof(str)-i, fmt, ap);
633 va_end(ap);
634 }
635 str[sizeof(str)-1] = 0;
636
637 fprintf(LogFile, "%s", str);
638 fflush(LogFile);
639 }
640
641 void SetRTPriority(void)
642 {
643 ALboolean failed;
644
645 #ifdef _WIN32
646 if(RTPrioLevel > 0)
647 failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
648 else
649 failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
650 #elif defined(HAVE_PTHREAD_SETSCHEDPARAM)
651 struct sched_param param;
652
653 if(RTPrioLevel > 0)
654 {
655 /* Use the minimum real-time priority possible for now (on Linux this
656 * should be 1 for SCHED_RR) */
657 param.sched_priority = sched_get_priority_min(SCHED_RR);
658 failed = !!pthread_setschedparam(pthread_self(), SCHED_RR, &param);
659 }
660 else
661 {
662 param.sched_priority = 0;
663 failed = !!pthread_setschedparam(pthread_self(), SCHED_OTHER, &param);
664 }
665 #else
666 /* Real-time priority not available */
667 failed = (RTPrioLevel>0);
668 #endif
669 if(failed)
670 AL_PRINT("Failed to set priority level for thread\n");
671 }
672
673
674 void InitUIntMap(UIntMap *map)
675 {
676 map->array = NULL;
677 map->size = 0;
678 map->maxsize = 0;
679 }
680
681 void ResetUIntMap(UIntMap *map)
682 {
683 free(map->array);
684 map->array = NULL;
685 map->size = 0;
686 map->maxsize = 0;
687 }
688
689 ALenum InsertUIntMapEntry(UIntMap *map, ALuint key, ALvoid *value)
690 {
691 ALsizei pos = 0;
692
693 if(map->size > 0)
694 {
695 ALsizei low = 0;
696 ALsizei high = map->size - 1;
697 while(low < high)
698 {
699 ALsizei mid = low + (high-low)/2;
700 if(map->array[mid].key < key)
701 low = mid + 1;
702 else
703 high = mid;
704 }
705 if(map->array[low].key < key)
706 low++;
707 pos = low;
708 }
709
710 if(pos == map->size || map->array[pos].key != key)
711 {
712 if(map->size == map->maxsize)
713 {
714 ALvoid *temp;
715 ALsizei newsize;
716
717 newsize = (map->maxsize ? (map->maxsize<<1) : 4);
718 if(newsize < map->maxsize)
719 return AL_OUT_OF_MEMORY;
720
721 temp = realloc(map->array, newsize*sizeof(map->array[0]));
722 if(!temp) return AL_OUT_OF_MEMORY;
723 map->array = temp;
724 map->maxsize = newsize;
725 }
726
727 map->size++;
728 if(pos < map->size-1)
729 memmove(&map->array[pos+1], &map->array[pos],
730 (map->size-1-pos)*sizeof(map->array[0]));
731 }
732 map->array[pos].key = key;
733 map->array[pos].value = value;
734
735 return AL_NO_ERROR;
736 }
737
738 void RemoveUIntMapKey(UIntMap *map, ALuint key)
739 {
740 if(map->size > 0)
741 {
742 ALsizei low = 0;
743 ALsizei high = map->size - 1;
744 while(low < high)
745 {
746 ALsizei mid = low + (high-low)/2;
747 if(map->array[mid].key < key)
748 low = mid + 1;
749 else
750 high = mid;
751 }
752 if(map->array[low].key == key)
753 {
754 if(low < map->size-1)
755 memmove(&map->array[low], &map->array[low+1],
756 (map->size-1-low)*sizeof(map->array[0]));
757 map->size--;
758 }
759 }
760 }
761
762
763 /*
764 IsDevice
765
766 Check pDevice is a valid Device pointer
767 */
768 static ALCboolean IsDevice(ALCdevice *pDevice)
769 {
770 ALCdevice *pTempDevice;
771
772 SuspendContext(NULL);
773
774 pTempDevice = g_pDeviceList;
775 while(pTempDevice && pTempDevice != pDevice)
776 pTempDevice = pTempDevice->next;
777
778 ProcessContext(NULL);
779
780 return (pTempDevice ? ALC_TRUE : ALC_FALSE);
781 }
782
783 /*
784 IsContext
785
786 Check pContext is a valid Context pointer
787 */
788 static ALCboolean IsContext(ALCcontext *pContext)
789 {
790 ALCcontext *pTempContext;
791
792 SuspendContext(NULL);
793
794 pTempContext = g_pContextList;
795 while (pTempContext && pTempContext != pContext)
796 pTempContext = pTempContext->next;
797
798 ProcessContext(NULL);
799
800 return (pTempContext ? ALC_TRUE : ALC_FALSE);
801 }
802
803
804 /*
805 alcSetError
806
807 Store latest ALC Error
808 */
809 ALCvoid alcSetError(ALCdevice *device, ALenum errorCode)
810 {
811 if(IsDevice(device))
812 device->LastError = errorCode;
813 else
814 g_eLastNullDeviceError = errorCode;
815 }
816
817
818 /*
819 SuspendContext
820
821 Thread-safe entry
822 */
823 ALCvoid SuspendContext(ALCcontext *pContext)
824 {
825 (void)pContext;
826 EnterCriticalSection(&g_csMutex);
827 }
828
829
830 /*
831 ProcessContext
832
833 Thread-safe exit
834 */
835 ALCvoid ProcessContext(ALCcontext *pContext)
836 {
837 (void)pContext;
838 LeaveCriticalSection(&g_csMutex);
839 }
840
841
842 /*
843 GetContextSuspended
844
845 Returns the currently active Context, in a locked state
846 */
847 ALCcontext *GetContextSuspended(void)
848 {
849 ALCcontext *pContext = NULL;
850
851 SuspendContext(NULL);
852
853 pContext = tls_get(LocalContext);
854 if(pContext && !IsContext(pContext))
855 {
856 tls_set(LocalContext, NULL);
857 pContext = NULL;
858 }
859 if(!pContext)
860 pContext = GlobalContext;
861
862 if(pContext)
863 SuspendContext(pContext);
864
865 ProcessContext(NULL);
866
867 return pContext;
868 }
869
870
871 /*
872 InitContext
873
874 Initialize Context variables
875 */
876 static ALvoid InitContext(ALCcontext *pContext)
877 {
878 //Initialise listener
879 pContext->Listener.Gain = 1.0f;
880 pContext->Listener.MetersPerUnit = 1.0f;
881 pContext->Listener.Position[0] = 0.0f;
882 pContext->Listener.Position[1] = 0.0f;
883 pContext->Listener.Position[2] = 0.0f;
884 pContext->Listener.Velocity[0] = 0.0f;
885 pContext->Listener.Velocity[1] = 0.0f;
886 pContext->Listener.Velocity[2] = 0.0f;
887 pContext->Listener.Forward[0] = 0.0f;
888 pContext->Listener.Forward[1] = 0.0f;
889 pContext->Listener.Forward[2] = -1.0f;
890 pContext->Listener.Up[0] = 0.0f;
891 pContext->Listener.Up[1] = 1.0f;
892 pContext->Listener.Up[2] = 0.0f;
893
894 //Validate pContext
895 pContext->LastError = AL_NO_ERROR;
896 pContext->Suspended = AL_FALSE;
897 pContext->ActiveSourceCount = 0;
898 InitUIntMap(&pContext->SourceMap);
899 InitUIntMap(&pContext->EffectSlotMap);
900
901 //Set globals
902 pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
903 pContext->SourceDistanceModel = AL_FALSE;
904 pContext->DopplerFactor = 1.0f;
905 pContext->DopplerVelocity = 1.0f;
906 pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
907
908 pContext->ExtensionList = alExtList;
909 }
910
911
912 /*
913 ExitContext
914
915 Clean up Context, destroy any remaining Sources
916 */
917 static ALCvoid ExitContext(ALCcontext *pContext)
918 {
919 //Invalidate context
920 pContext->LastError = AL_NO_ERROR;
921 }
922
923 ///////////////////////////////////////////////////////
924
925
926 ///////////////////////////////////////////////////////
927 // ALC Functions calls
928
929
930 // This should probably move to another c file but for now ...
931 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
932 {
933 ALCboolean DeviceFound = ALC_FALSE;
934 ALCdevice *device = NULL;
935 ALCint i;
936
937 if(SampleSize <= 0)
938 {
939 alcSetError(NULL, ALC_INVALID_VALUE);
940 return NULL;
941 }
942
943 if(deviceName && !deviceName[0])
944 deviceName = NULL;
945
946 device = calloc(1, sizeof(ALCdevice));
947 if(!device)
948 {
949 alcSetError(NULL, ALC_OUT_OF_MEMORY);
950 return NULL;
951 }
952
953 //Validate device
954 device->Connected = ALC_TRUE;
955 device->IsCaptureDevice = AL_TRUE;
956
957 device->szDeviceName = NULL;
958
959 device->Frequency = frequency;
960 device->Format = format;
961 device->UpdateSize = SampleSize;
962 device->NumUpdates = 1;
963
964 SuspendContext(NULL);
965 for(i = 0;BackendList[i].Init;i++)
966 {
967 device->Funcs = &BackendList[i].Funcs;
968 if(ALCdevice_OpenCapture(device, deviceName))
969 {
970 device->next = g_pDeviceList;
971 g_pDeviceList = device;
972 g_ulDeviceCount++;
973
974 DeviceFound = ALC_TRUE;
975 break;
976 }
977 }
978 ProcessContext(NULL);
979
980 if(!DeviceFound)
981 {
982 alcSetError(NULL, ALC_INVALID_VALUE);
983 free(device);
984 device = NULL;
985 }
986
987 return device;
988 }
989
990 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
991 {
992 ALCdevice **list;
993
994 if(!IsDevice(pDevice) || !pDevice->IsCaptureDevice)
995 {
996 alcSetError(pDevice, ALC_INVALID_DEVICE);
997 return ALC_FALSE;
998 }
999
1000 SuspendContext(NULL);
1001
1002 list = &g_pDeviceList;
1003 while(*list != pDevice)
1004 list = &(*list)->next;
1005
1006 *list = (*list)->next;
1007 g_ulDeviceCount--;
1008
1009 ProcessContext(NULL);
1010
1011 ALCdevice_CloseCapture(pDevice);
1012
1013 free(pDevice->szDeviceName);
1014 pDevice->szDeviceName = NULL;
1015
1016 free(pDevice);
1017
1018 return ALC_TRUE;
1019 }
1020
1021 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
1022 {
1023 SuspendContext(NULL);
1024 if(!IsDevice(device) || !device->IsCaptureDevice)
1025 alcSetError(device, ALC_INVALID_DEVICE);
1026 else if(device->Connected)
1027 ALCdevice_StartCapture(device);
1028 ProcessContext(NULL);
1029 }
1030
1031 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
1032 {
1033 SuspendContext(NULL);
1034 if(!IsDevice(device) || !device->IsCaptureDevice)
1035 alcSetError(device, ALC_INVALID_DEVICE);
1036 else
1037 ALCdevice_StopCapture(device);
1038 ProcessContext(NULL);
1039 }
1040
1041 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
1042 {
1043 SuspendContext(NULL);
1044 if(!IsDevice(device) || !device->IsCaptureDevice)
1045 alcSetError(device, ALC_INVALID_DEVICE);
1046 else
1047 ALCdevice_CaptureSamples(device, buffer, samples);
1048 ProcessContext(NULL);
1049 }
1050
1051 /*
1052 alcGetError
1053
1054 Return last ALC generated error code
1055 */
1056 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
1057 {
1058 ALCenum errorCode;
1059
1060 if(IsDevice(device))
1061 {
1062 errorCode = device->LastError;
1063 device->LastError = ALC_NO_ERROR;
1064 }
1065 else
1066 {
1067 errorCode = g_eLastNullDeviceError;
1068 g_eLastNullDeviceError = ALC_NO_ERROR;
1069 }
1070 return errorCode;
1071 }
1072
1073
1074 /*
1075 alcSuspendContext
1076
1077 Not functional
1078 */
1079 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *pContext)
1080 {
1081 SuspendContext(NULL);
1082 if(IsContext(pContext))
1083 pContext->Suspended = AL_TRUE;
1084 ProcessContext(NULL);
1085 }
1086
1087
1088 /*
1089 alcProcessContext
1090
1091 Not functional
1092 */
1093 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *pContext)
1094 {
1095 SuspendContext(NULL);
1096 if(IsContext(pContext))
1097 pContext->Suspended = AL_FALSE;
1098 ProcessContext(NULL);
1099 }
1100
1101
1102 /*
1103 alcGetString
1104
1105 Returns information about the Device, and error strings
1106 */
1107 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
1108 {
1109 const ALCchar *value = NULL;
1110
1111 switch (param)
1112 {
1113 case ALC_NO_ERROR:
1114 value = alcNoError;
1115 break;
1116
1117 case ALC_INVALID_ENUM:
1118 value = alcErrInvalidEnum;
1119 break;
1120
1121 case ALC_INVALID_VALUE:
1122 value = alcErrInvalidValue;
1123 break;
1124
1125 case ALC_INVALID_DEVICE:
1126 value = alcErrInvalidDevice;
1127 break;
1128
1129 case ALC_INVALID_CONTEXT:
1130 value = alcErrInvalidContext;
1131 break;
1132
1133 case ALC_OUT_OF_MEMORY:
1134 value = alcErrOutOfMemory;
1135 break;
1136
1137 case ALC_DEVICE_SPECIFIER:
1138 if(IsDevice(pDevice))
1139 value = pDevice->szDeviceName;
1140 else
1141 {
1142 ProbeDeviceList();
1143 value = alcDeviceList;
1144 }
1145 break;
1146
1147 case ALC_ALL_DEVICES_SPECIFIER:
1148 ProbeAllDeviceList();
1149 value = alcAllDeviceList;
1150 break;
1151
1152 case ALC_CAPTURE_DEVICE_SPECIFIER:
1153 if(IsDevice(pDevice))
1154 value = pDevice->szDeviceName;
1155 else
1156 {
1157 ProbeCaptureDeviceList();
1158 value = alcCaptureDeviceList;
1159 }
1160 break;
1161
1162 /* Default devices are always first in the list */
1163 case ALC_DEFAULT_DEVICE_SPECIFIER:
1164 if(!alcDeviceList)
1165 ProbeDeviceList();
1166
1167 free(alcDefaultDeviceSpecifier);
1168 alcDefaultDeviceSpecifier = strdup(alcDeviceList ? alcDeviceList : "");
1169 if(!alcDefaultDeviceSpecifier)
1170 alcSetError(pDevice, ALC_OUT_OF_MEMORY);
1171 value = alcDefaultDeviceSpecifier;
1172 break;
1173
1174 case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
1175 if(!alcAllDeviceList)
1176 ProbeAllDeviceList();
1177
1178 free(alcDefaultAllDeviceSpecifier);
1179 alcDefaultAllDeviceSpecifier = strdup(alcAllDeviceList ?
1180 alcAllDeviceList : "");
1181 if(!alcDefaultAllDeviceSpecifier)
1182 alcSetError(pDevice, ALC_OUT_OF_MEMORY);
1183 value = alcDefaultAllDeviceSpecifier;
1184 break;
1185
1186 case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
1187 if(!alcCaptureDeviceList)
1188 ProbeCaptureDeviceList();
1189
1190 free(alcCaptureDefaultDeviceSpecifier);
1191 alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?
1192 alcCaptureDeviceList : "");
1193 if(!alcCaptureDefaultDeviceSpecifier)
1194 alcSetError(pDevice, ALC_OUT_OF_MEMORY);
1195 value = alcCaptureDefaultDeviceSpecifier;
1196 break;
1197
1198 case ALC_EXTENSIONS:
1199 if(IsDevice(pDevice))
1200 value = alcExtensionList;
1201 else
1202 value = alcNoDeviceExtList;
1203 break;
1204
1205 default:
1206 alcSetError(pDevice, ALC_INVALID_ENUM);
1207 break;
1208 }
1209
1210 return value;
1211 }
1212
1213
1214 /*
1215 alcGetIntegerv
1216
1217 Returns information about the Device and the version of Open AL
1218 */
1219 ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
1220 {
1221 if(size == 0 || data == NULL)
1222 {
1223 alcSetError(device, ALC_INVALID_VALUE);
1224 return;
1225 }
1226
1227 if(IsDevice(device) && device->IsCaptureDevice)
1228 {
1229 SuspendContext(NULL);
1230
1231 // Capture device
1232 switch (param)
1233 {
1234 case ALC_CAPTURE_SAMPLES:
1235 *data = ALCdevice_AvailableSamples(device);
1236 break;
1237
1238 case ALC_CONNECTED:
1239 *data = device->Connected;
1240 break;
1241
1242 default:
1243 alcSetError(device, ALC_INVALID_ENUM);
1244 break;
1245 }
1246
1247 ProcessContext(NULL);
1248 return;
1249 }
1250
1251 // Playback Device
1252 switch (param)
1253 {
1254 case ALC_MAJOR_VERSION:
1255 *data = alcMajorVersion;
1256 break;
1257
1258 case ALC_MINOR_VERSION:
1259 *data = alcMinorVersion;
1260 break;
1261
1262 case ALC_EFX_MAJOR_VERSION:
1263 *data = alcEFXMajorVersion;
1264 break;
1265
1266 case ALC_EFX_MINOR_VERSION:
1267 *data = alcEFXMinorVersion;
1268 break;
1269
1270 case ALC_MAX_AUXILIARY_SENDS:
1271 if(!IsDevice(device))
1272 alcSetError(device, ALC_INVALID_DEVICE);
1273 else
1274 *data = device->NumAuxSends;
1275 break;
1276
1277 case ALC_ATTRIBUTES_SIZE:
1278 if(!IsDevice(device))
1279 alcSetError(device, ALC_INVALID_DEVICE);
1280 else
1281 *data = 13;
1282 break;
1283
1284 case ALC_ALL_ATTRIBUTES:
1285 if(!IsDevice(device))
1286 alcSetError(device, ALC_INVALID_DEVICE);
1287 else if (size < 13)
1288 alcSetError(device, ALC_INVALID_VALUE);
1289 else
1290 {
1291 int i = 0;
1292
1293 SuspendContext(NULL);
1294 data[i++] = ALC_FREQUENCY;
1295 data[i++] = device->Frequency;
1296
1297 data[i++] = ALC_REFRESH;
1298 data[i++] = device->Frequency / device->UpdateSize;
1299
1300 data[i++] = ALC_SYNC;
1301 data[i++] = ALC_FALSE;
1302
1303 data[i++] = ALC_MONO_SOURCES;
1304 data[i++] = device->NumMonoSources;
1305
1306 data[i++] = ALC_STEREO_SOURCES;
1307 data[i++] = device->NumStereoSources;
1308
1309 data[i++] = ALC_MAX_AUXILIARY_SENDS;
1310 data[i++] = device->NumAuxSends;
1311
1312 data[i++] = 0;
1313 ProcessContext(NULL);
1314 }
1315 break;
1316
1317 case ALC_FREQUENCY:
1318 if(!IsDevice(device))
1319 alcSetError(device, ALC_INVALID_DEVICE);
1320 else
1321 *data = device->Frequency;
1322 break;
1323
1324 case ALC_REFRESH:
1325 if(!IsDevice(device))
1326 alcSetError(device, ALC_INVALID_DEVICE);
1327 else
1328 *data = device->Frequency / device->UpdateSize;
1329 break;
1330
1331 case ALC_SYNC:
1332 if(!IsDevice(device))
1333 alcSetError(device, ALC_INVALID_DEVICE);
1334 else
1335 *data = ALC_FALSE;
1336 break;
1337
1338 case ALC_MONO_SOURCES:
1339 if(!IsDevice(device))
1340 alcSetError(device, ALC_INVALID_DEVICE);
1341 else
1342 *data = device->NumMonoSources;
1343 break;
1344
1345 case ALC_STEREO_SOURCES:
1346 if(!IsDevice(device))
1347 alcSetError(device, ALC_INVALID_DEVICE);
1348 else
1349 *data = device->NumStereoSources;
1350 break;
1351
1352 case ALC_CONNECTED:
1353 if(!IsDevice(device))
1354 alcSetError(device, ALC_INVALID_DEVICE);
1355 else
1356 *data = device->Connected;
1357 break;
1358
1359 case ALC_GET_TIME_EXT:
1360 if(!IsDevice(device))
1361 alcSetError(device, ALC_INVALID_DEVICE);
1362 else if(size < 2)
1363 alcSetError(device, ALC_INVALID_VALUE);
1364 else
1365 {
1366 ALuint64 t = ALCdevice_GetTime(device);
1367 data[0] = t&0xffffffff;
1368 data[1] = t>>32;
1369 }
1370 break;
1371
1372 case ALC_GET_TIME_RES_EXT:
1373 if(!IsDevice(device))
1374 alcSetError(device, ALC_INVALID_DEVICE);
1375 else if(size < 2)
1376 alcSetError(device, ALC_INVALID_VALUE);
1377 else
1378 {
1379 data[0] = device->TimeRes&0xffffffff;
1380 data[1] = device->TimeRes>>32;
1381 }
1382 break;
1383
1384 default:
1385 alcSetError(device, ALC_INVALID_ENUM);
1386 break;
1387 }
1388 }
1389
1390
1391 /*
1392 alcIsExtensionPresent
1393
1394 Determines if there is support for a particular extension
1395 */
1396 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
1397 {
1398 ALCboolean bResult = ALC_FALSE;
1399 const char *ptr;
1400 size_t len;
1401
1402 if(!extName)
1403 {
1404 alcSetError(device, ALC_INVALID_VALUE);
1405 return ALC_FALSE;
1406 }
1407
1408 len = strlen(extName);
1409 ptr = (IsDevice(device) ? alcExtensionList : alcNoDeviceExtList);
1410 while(ptr && *ptr)
1411 {
1412 if(strncasecmp(ptr, extName, len) == 0 &&
1413 (ptr[len] == '\0' || isspace(ptr[len])))
1414 {
1415 bResult = ALC_TRUE;
1416 break;
1417 }
1418 if((ptr=strchr(ptr, ' ')) != NULL)
1419 {
1420 do {
1421 ++ptr;
1422 } while(isspace(*ptr));
1423 }
1424 }
1425
1426 return bResult;
1427 }
1428
1429
1430 /*
1431 alcGetProcAddress
1432
1433 Retrieves the function address for a particular extension function
1434 */
1435 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
1436 {
1437 ALsizei i = 0;
1438
1439 if(!funcName)
1440 {
1441 alcSetError(device, ALC_INVALID_VALUE);
1442 return NULL;
1443 }
1444
1445 while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName,funcName) != 0)
1446 i++;
1447 return alcFunctions[i].address;
1448 }
1449
1450
1451 /*
1452 alcGetEnumValue
1453
1454 Get the value for a particular ALC Enumerated Value
1455 */
1456 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
1457 {
1458 ALsizei i = 0;
1459
1460 if(!enumName)
1461 {
1462 alcSetError(device, ALC_INVALID_VALUE);
1463 return (ALCenum)0;
1464 }
1465
1466 while(enumeration[i].enumName && strcmp(enumeration[i].enumName,enumName) != 0)
1467 i++;
1468 return enumeration[i].value;
1469 }
1470
1471
1472 /*
1473 alcCreateContext
1474
1475 Create and attach a Context to a particular Device.
1476 */
1477 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
1478 {
1479 ALCcontext *ALContext;
1480 ALboolean running;
1481 ALuint oldRate;
1482 ALuint attrIdx;
1483 void *temp;
1484 ALuint i;
1485
1486 SuspendContext(NULL);
1487
1488 if(!IsDevice(device) || device->IsCaptureDevice || !device->Connected)
1489 {
1490 alcSetError(device, ALC_INVALID_DEVICE);
1491 ProcessContext(NULL);
1492 return NULL;
1493 }
1494
1495 running = ((device->NumContexts > 0) ? AL_TRUE : AL_FALSE);
1496 oldRate = device->Frequency;
1497
1498 // Reset Context Last Error code
1499 device->LastError = ALC_NO_ERROR;
1500
1501 // Check for attributes
1502 if(attrList && attrList[0])
1503 {
1504 ALCuint freq, numMono, numStereo, numSends;
1505
1506 // If a context is already running on the device, stop playback so the
1507 // device attributes can be updated
1508 if(running)
1509 {
1510 ProcessContext(NULL);
1511 ALCdevice_StopPlayback(device);
1512 SuspendContext(NULL);
1513 running = AL_FALSE;
1514 }
1515
1516 freq = device->Frequency;
1517 numMono = device->NumMonoSources;
1518 numStereo = device->NumStereoSources;
1519 numSends = device->NumAuxSends;
1520
1521 attrIdx = 0;
1522 while(attrList[attrIdx])
1523 {
1524 if(attrList[attrIdx] == ALC_FREQUENCY &&
1525 !ConfigValueExists(NULL, "frequency"))
1526 {
1527 freq = attrList[attrIdx + 1];
1528 if(freq < 8000)
1529 freq = 8000;
1530 }
1531
1532 if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1533 {
1534 numStereo = attrList[attrIdx + 1];
1535 if(numStereo > device->MaxNoOfSources)
1536 numStereo = device->MaxNoOfSources;
1537
1538 numMono = device->MaxNoOfSources - numStereo;
1539 }
1540
1541 if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS &&
1542 !ConfigValueExists(NULL, "sends"))
1543 {
1544 numSends = attrList[attrIdx + 1];
1545 if(numSends > MAX_SENDS)
1546 numSends = MAX_SENDS;
1547 }
1548
1549 attrIdx += 2;
1550 }
1551
1552 device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1553 device->Frequency;
1554
1555 device->Frequency = freq;
1556 device->NumMonoSources = numMono;
1557 device->NumStereoSources = numStereo;
1558 device->NumAuxSends = numSends;
1559 }
1560
1561 if(running == AL_FALSE && ALCdevice_ResetPlayback(device) == ALC_FALSE)
1562 {
1563 alcSetError(device, ALC_INVALID_DEVICE);
1564 aluHandleDisconnect(device);
1565 ProcessContext(NULL);
1566 return NULL;
1567 }
1568 aluInitPanning(device);
1569
1570 // Scale the number of samples played according to the new sample rate
1571 device->SamplesPlayed *= device->Frequency;
1572 device->SamplesPlayed += oldRate-1;
1573 device->SamplesPlayed /= oldRate;
1574
1575 for(i = 0;i < device->NumContexts;i++)
1576 {
1577 ALCcontext *context = device->Contexts[i];
1578 ALsizei pos;
1579
1580 SuspendContext(context);
1581 for(pos = 0;pos < context->EffectSlotMap.size;pos++)
1582 {
1583 ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
1584 if(!slot->EffectState)
1585 continue;
1586
1587 if(ALEffect_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
1588 {
1589 alcSetError(device, ALC_INVALID_DEVICE);
1590 aluHandleDisconnect(device);
1591 ProcessContext(context);
1592 ProcessContext(NULL);
1593 ALCdevice_StopPlayback(device);
1594 return NULL;
1595 }
1596 ALEffect_Update(slot->EffectState, context, &slot->effect);
1597 }
1598
1599 for(pos = 0;pos < context->SourceMap.size;pos++)
1600 {
1601 ALsource *source = context->SourceMap.array[pos].value;
1602 ALuint s = device->NumAuxSends;
1603 while(s < MAX_SENDS)
1604 {
1605 if(source->Send[s].Slot)
1606 source->Send[s].Slot->refcount--;
1607 source->Send[s].Slot = NULL;
1608 source->Send[s].WetFilter.type = 0;
1609 source->Send[s].WetFilter.filter = 0;
1610 s++;
1611 }
1612 source->NeedsUpdate = AL_TRUE;
1613 }
1614 ProcessContext(context);
1615 }
1616
1617 if(device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
1618 {
1619 if(!device->Bs2b)
1620 {
1621 device->Bs2b = calloc(1, sizeof(*device->Bs2b));
1622 bs2b_clear(device->Bs2b);
1623 }
1624 bs2b_set_srate(device->Bs2b, device->Frequency);
1625 bs2b_set_level(device->Bs2b, device->Bs2bLevel);
1626 }
1627 else
1628 {
1629 free(device->Bs2b);
1630 device->Bs2b = NULL;
1631 }
1632
1633 if(aluChannelsFromFormat(device->Format) <= 2)
1634 {
1635 device->HeadDampen = GetConfigValueFloat(NULL, "head_dampen", DEFAULT_HEAD_DAMPEN);
1636 device->HeadDampen = __min(device->HeadDampen, 1.0f);
1637 device->HeadDampen = __max(device->HeadDampen, 0.0f);
1638 }
1639 else
1640 device->HeadDampen = 0.0f;
1641
1642 temp = realloc(device->Contexts, (device->NumContexts+1) * sizeof(*device->Contexts));
1643 if(!temp)
1644 {
1645 alcSetError(device, ALC_OUT_OF_MEMORY);
1646 ProcessContext(NULL);
1647 if(device->NumContexts == 0)
1648 ALCdevice_StopPlayback(device);
1649 return NULL;
1650 }
1651 device->Contexts = temp;
1652
1653 ALContext = calloc(1, sizeof(ALCcontext));
1654 if(ALContext)
1655 {
1656 ALContext->MaxActiveSources = 256;
1657 ALContext->ActiveSources = malloc(sizeof(*ALContext->ActiveSources) *
1658 ALContext->MaxActiveSources);
1659 }
1660 if(!ALContext || !ALContext->ActiveSources)
1661 {
1662 free(ALContext);
1663 alcSetError(device, ALC_OUT_OF_MEMORY);
1664 ProcessContext(NULL);
1665 if(device->NumContexts == 0)
1666 ALCdevice_StopPlayback(device);
1667 return NULL;
1668 }
1669
1670 device->Contexts[device->NumContexts++] = ALContext;
1671 ALContext->Device = device;
1672
1673 InitContext(ALContext);
1674
1675 ALContext->next = g_pContextList;
1676 g_pContextList = ALContext;
1677 g_ulContextCount++;
1678
1679 ProcessContext(NULL);
1680
1681 return ALContext;
1682 }
1683
1684
1685 /*
1686 alcDestroyContext
1687
1688 Remove a Context
1689 */
1690 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
1691 {
1692 ALCdevice *Device;
1693 ALCcontext **list;
1694 ALuint i;
1695
1696 if(!IsContext(context))
1697 {
1698 alcSetError(NULL, ALC_INVALID_CONTEXT);
1699 return;
1700 }
1701
1702 Device = context->Device;
1703
1704 if(Device->NumContexts == 1)
1705 ALCdevice_StopPlayback(Device);
1706
1707 SuspendContext(NULL);
1708
1709 if(context == GlobalContext)
1710 GlobalContext = NULL;
1711
1712 for(i = 0;i < Device->NumContexts-1;i++)
1713 {
1714 if(Device->Contexts[i] == context)
1715 {
1716 Device->Contexts[i] = Device->Contexts[Device->NumContexts-1];
1717 break;
1718 }
1719 }
1720 Device->NumContexts--;
1721
1722 // Lock context
1723 SuspendContext(context);
1724
1725 if(context->SourceMap.size > 0)
1726 {
1727 #ifdef _DEBUG
1728 AL_PRINT("alcDestroyContext(): deleting %d Source(s)\n", context->SourceMap.size);
1729 #endif
1730 ReleaseALSources(context);
1731 }
1732 ResetUIntMap(&context->SourceMap);
1733
1734 if(context->EffectSlotMap.size > 0)
1735 {
1736 #ifdef _DEBUG
1737 AL_PRINT("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", context->EffectSlotMap.size);
1738 #endif
1739 ReleaseALAuxiliaryEffectSlots(context);
1740 }
1741 ResetUIntMap(&context->EffectSlotMap);
1742
1743 free(context->ActiveSources);
1744 context->ActiveSources = NULL;
1745 context->MaxActiveSources = 0;
1746 context->ActiveSourceCount = 0;
1747
1748 list = &g_pContextList;
1749 while(*list != context)
1750 list = &(*list)->next;
1751
1752 *list = (*list)->next;
1753 g_ulContextCount--;
1754
1755 // Unlock context
1756 ProcessContext(context);
1757 ProcessContext(NULL);
1758
1759 ExitContext(context);
1760
1761 // Free memory (MUST do this after ProcessContext)
1762 memset(context, 0, sizeof(ALCcontext));
1763 free(context);
1764 }
1765
1766
1767 /*
1768 alcGetCurrentContext
1769
1770 Returns the currently active Context
1771 */
1772 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(ALCvoid)
1773 {
1774 ALCcontext *pContext;
1775
1776 if((pContext=GetContextSuspended()) != NULL)
1777 ProcessContext(pContext);
1778
1779 return pContext;
1780 }
1781
1782 /*
1783 alcGetThreadContext
1784
1785 Returns the currently active thread-local Context
1786 */
1787 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
1788 {
1789 ALCcontext *pContext = NULL;
1790
1791 SuspendContext(NULL);
1792
1793 pContext = tls_get(LocalContext);
1794 if(pContext && !IsContext(pContext))
1795 {
1796 tls_set(LocalContext, NULL);
1797 pContext = NULL;
1798 }
1799
1800 ProcessContext(NULL);
1801
1802 return pContext;
1803 }
1804
1805
1806 /*
1807 alcGetContextsDevice
1808
1809 Returns the Device that a particular Context is attached to
1810 */
1811 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *pContext)
1812 {
1813 ALCdevice *pDevice = NULL;
1814
1815 SuspendContext(NULL);
1816 if(IsContext(pContext))
1817 pDevice = pContext->Device;
1818 else
1819 alcSetError(NULL, ALC_INVALID_CONTEXT);
1820 ProcessContext(NULL);
1821
1822 return pDevice;
1823 }
1824
1825
1826 /*
1827 alcMakeContextCurrent
1828
1829 Makes the given Context the active Context
1830 */
1831 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
1832 {
1833 ALboolean bReturn = AL_TRUE;
1834
1835 SuspendContext(NULL);
1836
1837 // context must be a valid Context or NULL
1838 if(context == NULL || IsContext(context))
1839 {
1840 GlobalContext = context;
1841 tls_set(LocalContext, NULL);
1842 }
1843 else
1844 {
1845 alcSetError(NULL, ALC_INVALID_CONTEXT);
1846 bReturn = AL_FALSE;
1847 }
1848
1849 ProcessContext(NULL);
1850
1851 return bReturn;
1852 }
1853
1854 /*
1855 alcSetThreadContext
1856
1857 Makes the given Context the active Context for the current thread
1858 */
1859 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
1860 {
1861 ALboolean bReturn = AL_TRUE;
1862
1863 SuspendContext(NULL);
1864
1865 // context must be a valid Context or NULL
1866 if(context == NULL || IsContext(context))
1867 tls_set(LocalContext, context);
1868 else
1869 {
1870 alcSetError(NULL, ALC_INVALID_CONTEXT);
1871 bReturn = AL_FALSE;
1872 }
1873
1874 ProcessContext(NULL);
1875
1876 return bReturn;
1877 }
1878
1879
1880 // Sets the default channel order used by most non-WaveFormatEx-based APIs
1881 void SetDefaultChannelOrder(ALCdevice *device)
1882 {
1883 switch(aluChannelsFromFormat(device->Format))
1884 {
1885 case 1: device->DevChannels[FRONT_CENTER] = 0; break;
1886
1887 case 2: device->DevChannels[FRONT_LEFT] = 0;
1888 device->DevChannels[FRONT_RIGHT] = 1; break;
1889
1890 case 4: device->DevChannels[FRONT_LEFT] = 0;
1891 device->DevChannels[FRONT_RIGHT] = 1;
1892 device->DevChannels[BACK_LEFT] = 2;
1893 device->DevChannels[BACK_RIGHT] = 3; break;
1894
1895 case 6: device->DevChannels[FRONT_LEFT] = 0;
1896 device->DevChannels[FRONT_RIGHT] = 1;
1897 device->DevChannels[BACK_LEFT] = 2;
1898 device->DevChannels[BACK_RIGHT] = 3;
1899 device->DevChannels[FRONT_CENTER] = 4;
1900 device->DevChannels[LFE] = 5; break;
1901
1902 case 7: device->DevChannels[FRONT_LEFT] = 0;
1903 device->DevChannels[FRONT_RIGHT] = 1;
1904 device->DevChannels[FRONT_CENTER] = 2;
1905 device->DevChannels[LFE] = 3;
1906 device->DevChannels[BACK_CENTER] = 4;
1907 device->DevChannels[SIDE_LEFT] = 5;
1908 device->DevChannels[SIDE_RIGHT] = 6; break;
1909
1910 case 8: device->DevChannels[FRONT_LEFT] = 0;
1911 device->DevChannels[FRONT_RIGHT] = 1;
1912 device->DevChannels[BACK_LEFT] = 2;
1913 device->DevChannels[BACK_RIGHT] = 3;
1914 device->DevChannels[FRONT_CENTER] = 4;
1915 device->DevChannels[LFE] = 5;
1916 device->DevChannels[SIDE_LEFT] = 6;
1917 device->DevChannels[SIDE_RIGHT] = 7; break;
1918 }
1919 }
1920 // Sets the default order used by WaveFormatEx
1921 void SetDefaultWFXChannelOrder(ALCdevice *device)
1922 {
1923 switch(aluChannelsFromFormat(device->Format))
1924 {
1925 case 1: device->DevChannels[FRONT_CENTER] = 0; break;
1926
1927 case 2: device->DevChannels[FRONT_LEFT] = 0;
1928 device->DevChannels[FRONT_RIGHT] = 1; break;
1929
1930 case 4: device->DevChannels[FRONT_LEFT] = 0;
1931 device->DevChannels[FRONT_RIGHT] = 1;
1932 device->DevChannels[BACK_LEFT] = 2;
1933 device->DevChannels[BACK_RIGHT] = 3; break;
1934
1935 case 6: device->DevChannels[FRONT_LEFT] = 0;
1936 device->DevChannels[FRONT_RIGHT] = 1;
1937 device->DevChannels[FRONT_CENTER] = 2;
1938 device->DevChannels[LFE] = 3;
1939 device->DevChannels[BACK_LEFT] = 4;
1940 device->DevChannels[BACK_RIGHT] = 5; break;
1941
1942 case 7: device->DevChannels[FRONT_LEFT] = 0;
1943 device->DevChannels[FRONT_RIGHT] = 1;
1944 device->DevChannels[FRONT_CENTER] = 2;
1945 device->DevChannels[LFE] = 3;
1946 device->DevChannels[BACK_CENTER] = 4;
1947 device->DevChannels[SIDE_LEFT] = 5;
1948 device->DevChannels[SIDE_RIGHT] = 6; break;
1949
1950 case 8: device->DevChannels[FRONT_LEFT] = 0;
1951 device->DevChannels[FRONT_RIGHT] = 1;
1952 device->DevChannels[FRONT_CENTER] = 2;
1953 device->DevChannels[LFE] = 3;
1954 device->DevChannels[BACK_LEFT] = 4;
1955 device->DevChannels[BACK_RIGHT] = 5;
1956 device->DevChannels[SIDE_LEFT] = 6;
1957 device->DevChannels[SIDE_RIGHT] = 7; break;
1958 }
1959 }
1960
1961 static ALenum GetFormatFromString(const char *str)
1962 {
1963 if(strcasecmp(str, "AL_FORMAT_MONO32") == 0) return AL_FORMAT_MONO_FLOAT32;
1964 if(strcasecmp(str, "AL_FORMAT_STEREO32") == 0) return AL_FORMAT_STEREO_FLOAT32;
1965 if(strcasecmp(str, "AL_FORMAT_QUAD32") == 0) return AL_FORMAT_QUAD32;
1966 if(strcasecmp(str, "AL_FORMAT_51CHN32") == 0) return AL_FORMAT_51CHN32;
1967 if(strcasecmp(str, "AL_FORMAT_61CHN32") == 0) return AL_FORMAT_61CHN32;
1968 if(strcasecmp(str, "AL_FORMAT_71CHN32") == 0) return AL_FORMAT_71CHN32;
1969
1970 if(strcasecmp(str, "AL_FORMAT_MONO16") == 0) return AL_FORMAT_MONO16;
1971 if(strcasecmp(str, "AL_FORMAT_STEREO16") == 0) return AL_FORMAT_STEREO16;
1972 if(strcasecmp(str, "AL_FORMAT_QUAD16") == 0) return AL_FORMAT_QUAD16;
1973 if(strcasecmp(str, "AL_FORMAT_51CHN16") == 0) return AL_FORMAT_51CHN16;
1974 if(strcasecmp(str, "AL_FORMAT_61CHN16") == 0) return AL_FORMAT_61CHN16;
1975 if(strcasecmp(str, "AL_FORMAT_71CHN16") == 0) return AL_FORMAT_71CHN16;
1976
1977 if(strcasecmp(str, "AL_FORMAT_MONO8") == 0) return AL_FORMAT_MONO8;
1978 if(strcasecmp(str, "AL_FORMAT_STEREO8") == 0) return AL_FORMAT_STEREO8;
1979 if(strcasecmp(str, "AL_FORMAT_QUAD8") == 0) return AL_FORMAT_QUAD8;
1980 if(strcasecmp(str, "AL_FORMAT_51CHN8") == 0) return AL_FORMAT_51CHN8;
1981 if(strcasecmp(str, "AL_FORMAT_61CHN8") == 0) return AL_FORMAT_61CHN8;
1982 if(strcasecmp(str, "AL_FORMAT_71CHN8") == 0) return AL_FORMAT_71CHN8;
1983
1984 AL_PRINT("Unknown format: \"%s\"\n", str);
1985 return AL_FORMAT_STEREO16;
1986 }
1987
1988 /*
1989 alcOpenDevice
1990
1991 Open the Device specified.
1992 */
1993 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
1994 {
1995 ALboolean bDeviceFound = AL_FALSE;
1996 const ALCchar *fmt;
1997 ALCdevice *device;
1998 ALint i;
1999
2000 if(deviceName && !deviceName[0])
2001 deviceName = NULL;
2002
2003 device = calloc(1, sizeof(ALCdevice));
2004 if(!device)
2005 {
2006 alcSetError(NULL, ALC_OUT_OF_MEMORY);
2007 return NULL;
2008 }
2009
2010 //Validate device
2011 device->Connected = ALC_TRUE;
2012 device->IsCaptureDevice = AL_FALSE;
2013 device->LastError = ALC_NO_ERROR;
2014
2015 device->Bs2b = NULL;
2016 device->szDeviceName = NULL;
2017
2018 device->Contexts = NULL;
2019 device->NumContexts = 0;
2020
2021 device->SamplesPlayed = 0;
2022
2023 device->TimeRes = 1;
2024
2025 InitUIntMap(&device->BufferMap);
2026 InitUIntMap(&device->EffectMap);
2027 InitUIntMap(&device->FilterMap);
2028 InitUIntMap(&device->DatabufferMap);
2029
2030 //Set output format
2031 device->Frequency = GetConfigValueInt(NULL, "frequency", SWMIXER_OUTPUT_RATE);
2032 if(device->Frequency < 8000)
2033 device->Frequency = 8000;
2034
2035 fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
2036 device->Format = GetFormatFromString(fmt);
2037
2038 device->NumUpdates = GetConfigValueInt(NULL, "periods", 4);
2039 if(device->NumUpdates < 2)
2040 device->NumUpdates = 4;
2041
2042 device->UpdateSize = GetConfigValueInt(NULL, "period_size", 1024);
2043 if(device->UpdateSize <= 0)
2044 device->UpdateSize = 1024;
2045
2046 device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
2047 if((ALint)device->MaxNoOfSources <= 0)
2048 device->MaxNoOfSources = 256;
2049
2050 device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);
2051 if((ALint)device->AuxiliaryEffectSlotMax <= 0)
2052 device->AuxiliaryEffectSlotMax = 4;
2053
2054 device->NumStereoSources = 1;
2055 device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
2056
2057 device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);
2058 if(device->NumAuxSends > MAX_SENDS)
2059 device->NumAuxSends = MAX_SENDS;
2060
2061 device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);
2062
2063 device->HeadDampen = 0.0f;
2064
2065 // Find a playback device to open
2066 SuspendContext(NULL);
2067 for(i = 0;BackendList[i].Init;i++)
2068 {
2069 device->Funcs = &BackendList[i].Funcs;
2070 if(ALCdevice_OpenPlayback(device, deviceName))
2071 {
2072 device->next = g_pDeviceList;
2073 g_pDeviceList = device;
2074 g_ulDeviceCount++;
2075
2076 bDeviceFound = AL_TRUE;
2077 break;
2078 }
2079 }
2080 ProcessContext(NULL);
2081
2082 if(!bDeviceFound)
2083 {
2084 // No suitable output device found
2085 alcSetError(NULL, ALC_INVALID_VALUE);
2086 free(device);
2087 device = NULL;
2088 }
2089
2090 return device;
2091 }
2092
2093
2094 /*
2095 alcCloseDevice
2096
2097 Close the specified Device
2098 */
2099 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *pDevice)
2100 {
2101 ALCdevice **list;
2102
2103 if(!IsDevice(pDevice) || pDevice->IsCaptureDevice)
2104 {
2105 alcSetError(pDevice, ALC_INVALID_DEVICE);
2106 return ALC_FALSE;
2107 }
2108
2109 SuspendContext(NULL);
2110
2111 list = &g_pDeviceList;
2112 while(*list != pDevice)
2113 list = &(*list)->next;
2114
2115 *list = (*list)->next;
2116 g_ulDeviceCount--;
2117
2118 ProcessContext(NULL);
2119
2120 if(pDevice->NumContexts > 0)
2121 {
2122 #ifdef _DEBUG
2123 AL_PRINT("alcCloseDevice(): destroying %u Context(s)\n", pDevice->NumContexts);
2124 #endif
2125 while(pDevice->NumContexts > 0)
2126 alcDestroyContext(pDevice->Contexts[0]);
2127 }
2128 ALCdevice_ClosePlayback(pDevice);
2129
2130 if(pDevice->BufferMap.size > 0)
2131 {
2132 #ifdef _DEBUG
2133 AL_PRINT("alcCloseDevice(): deleting %d Buffer(s)\n", pDevice->BufferMap.size);
2134 #endif
2135 ReleaseALBuffers(pDevice);
2136 }
2137 ResetUIntMap(&pDevice->BufferMap);
2138
2139 if(pDevice->EffectMap.size > 0)
2140 {
2141 #ifdef _DEBUG
2142 AL_PRINT("alcCloseDevice(): deleting %d Effect(s)\n", pDevice->EffectMap.size);
2143 #endif
2144 ReleaseALEffects(pDevice);
2145 }
2146 ResetUIntMap(&pDevice->EffectMap);
2147
2148 if(pDevice->FilterMap.size > 0)
2149 {
2150 #ifdef _DEBUG
2151 AL_PRINT("alcCloseDevice(): deleting %d Filter(s)\n", pDevice->FilterMap.size);
2152 #endif
2153 ReleaseALFilters(pDevice);
2154 }
2155 ResetUIntMap(&pDevice->FilterMap);
2156
2157 if(pDevice->DatabufferMap.size > 0)
2158 {
2159 #ifdef _DEBUG
2160 AL_PRINT("alcCloseDevice(): deleting %d Databuffer(s)\n", pDevice->DatabufferMap.size);
2161 #endif
2162 ReleaseALDatabuffers(pDevice);
2163 }
2164 ResetUIntMap(&pDevice->DatabufferMap);
2165
2166 free(pDevice->Bs2b);
2167 pDevice->Bs2b = NULL;
2168
2169 free(pDevice->szDeviceName);
2170 pDevice->szDeviceName = NULL;
2171
2172 free(pDevice->Contexts);
2173 pDevice->Contexts = NULL;
2174
2175 //Release device structure
2176 memset(pDevice, 0, sizeof(ALCdevice));
2177 free(pDevice);
2178
2179 return ALC_TRUE;
2180 }
2181
2182
2183 ALCvoid ReleaseALC(ALCvoid)
2184 {
2185 free(alcDeviceList); alcDeviceList = NULL;
2186 alcDeviceListSize = 0;
2187 free(alcAllDeviceList); alcAllDeviceList = NULL;
2188 alcAllDeviceListSize = 0;
2189 free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
2190 alcCaptureDeviceListSize = 0;
2191
2192 free(alcDefaultDeviceSpecifier);
2193 alcDefaultDeviceSpecifier = NULL;
2194 free(alcDefaultAllDeviceSpecifier);
2195 alcDefaultAllDeviceSpecifier = NULL;
2196 free(alcCaptureDefaultDeviceSpecifier);
2197 alcCaptureDefaultDeviceSpecifier = NULL;
2198
2199 #ifdef _DEBUG
2200 if(g_ulDeviceCount > 0)
2201 AL_PRINT("exit(): closing %u Device%s\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
2202 #endif
2203
2204 while(g_pDeviceList)
2205 {
2206 if(g_pDeviceList->IsCaptureDevice)
2207 alcCaptureCloseDevice(g_pDeviceList);
2208 else
2209 alcCloseDevice(g_pDeviceList);
2210 }
2211 }
2212
2213 ///////////////////////////////////////////////////////
Software OpenAL implementation