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