?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add a PortAudio backend
[openal-soft.git] / Alc / ALc.c
blob13b2fa310eafa0bcfeac69259056847e44bc4d37
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 #define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
22
23 #include "config.h"
24
25 #include <math.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <memory.h>
29 #include <ctype.h>
30 #include "alMain.h"
31 #include "alSource.h"
32 #include "AL/al.h"
33 #include "AL/alc.h"
34 #include "alThunk.h"
35 #include "alSource.h"
36 #include "alBuffer.h"
37 #include "alExtension.h"
38 #include "alAuxEffectSlot.h"
39 #include "bs2b.h"
40 #include "alu.h"
41
42 ///////////////////////////////////////////////////////
43 // DEBUG INFORMATION
44
45 char _alDebug[256];
46
47 ///////////////////////////////////////////////////////
48
49
50 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
51 static struct {
52 const char *name;
53 void (*Init)(BackendFuncs*);
54 BackendFuncs Funcs;
55 } BackendList[] = {
56 #ifdef HAVE_ALSA
57 { "alsa", alc_alsa_init, EmptyFuncs },
58 #endif
59 #ifdef HAVE_OSS
60 { "oss", alc_oss_init, EmptyFuncs },
61 #endif
62 #ifdef HAVE_SOLARIS
63 { "solaris", alc_solaris_init, EmptyFuncs },
64 #endif
65 #ifdef HAVE_DSOUND
66 { "dsound", alcDSoundInit, EmptyFuncs },
67 #endif
68 #ifdef HAVE_WINMM
69 { "winmm", alcWinMMInit, EmptyFuncs },
70 #endif
71 #ifdef HAVE_PORTAUDIO
72 { "port", alc_pa_init, EmptyFuncs },
73 #endif
74 #ifdef HAVE_SDL
75 { "sdl", alc_sdl_init, EmptyFuncs },
76 #endif
77
78 { "wave", alc_wave_init, EmptyFuncs },
79
80 { NULL, NULL, EmptyFuncs }
81 };
82 #undef EmptyFuncs
83
84 ///////////////////////////////////////////////////////
85
86 #define ALC_EFX_MAJOR_VERSION 0x20001
87 #define ALC_EFX_MINOR_VERSION 0x20002
88 #define ALC_MAX_AUXILIARY_SENDS 0x20003
89
90 ///////////////////////////////////////////////////////
91 // STRING and EXTENSIONS
92
93 typedef struct ALCfunction_struct
94 {
95 ALCchar *funcName;
96 ALvoid *address;
97 } ALCfunction;
98
99 static ALCfunction alcFunctions[] = {
100 { "alcCreateContext", (ALvoid *) alcCreateContext },
101 { "alcMakeContextCurrent", (ALvoid *) alcMakeContextCurrent },
102 { "alcProcessContext", (ALvoid *) alcProcessContext },
103 { "alcSuspendContext", (ALvoid *) alcSuspendContext },
104 { "alcDestroyContext", (ALvoid *) alcDestroyContext },
105 { "alcGetCurrentContext", (ALvoid *) alcGetCurrentContext },
106 { "alcGetContextsDevice", (ALvoid *) alcGetContextsDevice },
107 { "alcOpenDevice", (ALvoid *) alcOpenDevice },
108 { "alcCloseDevice", (ALvoid *) alcCloseDevice },
109 { "alcGetError", (ALvoid *) alcGetError },
110 { "alcIsExtensionPresent", (ALvoid *) alcIsExtensionPresent },
111 { "alcGetProcAddress", (ALvoid *) alcGetProcAddress },
112 { "alcGetEnumValue", (ALvoid *) alcGetEnumValue },
113 { "alcGetString", (ALvoid *) alcGetString },
114 { "alcGetIntegerv", (ALvoid *) alcGetIntegerv },
115 { "alcCaptureOpenDevice", (ALvoid *) alcCaptureOpenDevice },
116 { "alcCaptureCloseDevice", (ALvoid *) alcCaptureCloseDevice },
117 { "alcCaptureStart", (ALvoid *) alcCaptureStart },
118 { "alcCaptureStop", (ALvoid *) alcCaptureStop },
119 { "alcCaptureSamples", (ALvoid *) alcCaptureSamples },
120 { NULL, (ALvoid *) NULL }
121 };
122
123 static ALenums enumeration[]={
124 // Types
125 { (ALchar *)"ALC_INVALID", ALC_INVALID },
126 { (ALchar *)"ALC_FALSE", ALC_FALSE },
127 { (ALchar *)"ALC_TRUE", ALC_TRUE },
128
129 // ALC Properties
130 { (ALchar *)"ALC_MAJOR_VERSION", ALC_MAJOR_VERSION },
131 { (ALchar *)"ALC_MINOR_VERSION", ALC_MINOR_VERSION },
132 { (ALchar *)"ALC_ATTRIBUTES_SIZE", ALC_ATTRIBUTES_SIZE },
133 { (ALchar *)"ALC_ALL_ATTRIBUTES", ALC_ALL_ATTRIBUTES },
134 { (ALchar *)"ALC_DEFAULT_DEVICE_SPECIFIER", ALC_DEFAULT_DEVICE_SPECIFIER },
135 { (ALchar *)"ALC_DEVICE_SPECIFIER", ALC_DEVICE_SPECIFIER },
136 { (ALchar *)"ALC_ALL_DEVICES_SPECIFIER", ALC_ALL_DEVICES_SPECIFIER },
137 { (ALchar *)"ALC_DEFAULT_ALL_DEVICES_SPECIFIER", ALC_DEFAULT_ALL_DEVICES_SPECIFIER },
138 { (ALchar *)"ALC_EXTENSIONS", ALC_EXTENSIONS },
139 { (ALchar *)"ALC_FREQUENCY", ALC_FREQUENCY },
140 { (ALchar *)"ALC_REFRESH", ALC_REFRESH },
141 { (ALchar *)"ALC_SYNC", ALC_SYNC },
142 { (ALchar *)"ALC_MONO_SOURCES", ALC_MONO_SOURCES },
143 { (ALchar *)"ALC_STEREO_SOURCES", ALC_STEREO_SOURCES },
144 { (ALchar *)"ALC_CAPTURE_DEVICE_SPECIFIER", ALC_CAPTURE_DEVICE_SPECIFIER },
145 { (ALchar *)"ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
146 { (ALchar *)"ALC_CAPTURE_SAMPLES", ALC_CAPTURE_SAMPLES },
147
148 // EFX Properties
149 { (ALchar *)"ALC_EFX_MAJOR_VERSION", ALC_EFX_MAJOR_VERSION },
150 { (ALchar *)"ALC_EFX_MINOR_VERSION", ALC_EFX_MINOR_VERSION },
151 { (ALchar *)"ALC_MAX_AUXILIARY_SENDS", ALC_MAX_AUXILIARY_SENDS },
152
153 // ALC Error Message
154 { (ALchar *)"ALC_NO_ERROR", ALC_NO_ERROR },
155 { (ALchar *)"ALC_INVALID_DEVICE", ALC_INVALID_DEVICE },
156 { (ALchar *)"ALC_INVALID_CONTEXT", ALC_INVALID_CONTEXT },
157 { (ALchar *)"ALC_INVALID_ENUM", ALC_INVALID_ENUM },
158 { (ALchar *)"ALC_INVALID_VALUE", ALC_INVALID_VALUE },
159 { (ALchar *)"ALC_OUT_OF_MEMORY", ALC_OUT_OF_MEMORY },
160 { (ALchar *)NULL, (ALenum)0 }
161 };
162 // Error strings
163 static const ALCchar alcNoError[] = "No Error";
164 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
165 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
166 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
167 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
168 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
169
170 // Context strings
171 static ALCchar alcDeviceList[2048];
172 static ALCchar alcAllDeviceList[2048];
173 static ALCchar alcCaptureDeviceList[2048];
174 // Default is always the first in the list
175 static ALCchar *alcDefaultDeviceSpecifier = alcDeviceList;
176 static ALCchar *alcDefaultAllDeviceSpecifier = alcAllDeviceList;
177 static ALCchar *alcCaptureDefaultDeviceSpecifier = alcCaptureDeviceList;
178
179
180 static ALCchar alcExtensionList[] = "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE ALC_EXT_EFX";
181 static ALCint alcMajorVersion = 1;
182 static ALCint alcMinorVersion = 1;
183
184 static ALCint alcEFXMajorVersion = 1;
185 static ALCint alcEFXMinorVersion = 0;
186
187 ///////////////////////////////////////////////////////
188
189
190 ///////////////////////////////////////////////////////
191 // Global Variables
192
193 static ALCdevice *g_pDeviceList = NULL;
194 static ALCuint g_ulDeviceCount = 0;
195
196 static CRITICAL_SECTION g_csMutex;
197
198 // Context List
199 static ALCcontext *g_pContextList = NULL;
200 static ALCuint g_ulContextCount = 0;
201
202 // Context Error
203 static ALCenum g_eLastContextError = ALC_NO_ERROR;
204
205 static ALboolean init_done = AL_FALSE;
206
207 ///////////////////////////////////////////////////////
208
209
210 ///////////////////////////////////////////////////////
211 // ALC Related helper functions
212 #ifdef _WIN32
213 BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
214 {
215 (void)lpReserved;
216
217 // Perform actions based on the reason for calling.
218 switch(ul_reason_for_call)
219 {
220 case DLL_PROCESS_ATTACH:
221 DisableThreadLibraryCalls(hModule);
222 break;
223
224 case DLL_PROCESS_DETACH:
225 if(!init_done)
226 break;
227 ReleaseALC();
228 ReleaseALBuffers();
229 ReleaseALEffects();
230 ReleaseALFilters();
231 FreeALConfig();
232 ALTHUNK_EXIT();
233 DeleteCriticalSection(&g_csMutex);
234 break;
235 }
236 return TRUE;
237 }
238 #else
239 #ifdef HAVE_GCC_DESTRUCTOR
240 static void my_deinit() __attribute__((destructor));
241 static void my_deinit()
242 {
243 static ALenum once = AL_FALSE;
244 if(once || !init_done) return;
245 once = AL_TRUE;
246
247 ReleaseALC();
248 ReleaseALBuffers();
249 ReleaseALEffects();
250 ReleaseALFilters();
251 FreeALConfig();
252 ALTHUNK_EXIT();
253 DeleteCriticalSection(&g_csMutex);
254 }
255 #endif
256 #endif
257
258 static void InitAL(void)
259 {
260 if(!init_done)
261 {
262 int i;
263 const char *devs, *str;
264
265 init_done = AL_TRUE;
266
267 InitializeCriticalSection(&g_csMutex);
268 ALTHUNK_INIT();
269 ReadALConfig();
270
271 devs = GetConfigValue(NULL, "drivers", "");
272 if(devs[0])
273 {
274 int n;
275 size_t len;
276 const char *next = devs;
277
278 i = 0;
279
280 do {
281 devs = next;
282 next = strchr(devs, ',');
283
284 if(!devs[0] || devs[0] == ',')
285 continue;
286
287 len = (next ? ((size_t)(next-devs)) : strlen(devs));
288 for(n = i;BackendList[n].Init;n++)
289 {
290 if(len == strlen(BackendList[n].name) &&
291 strncmp(BackendList[n].name, devs, len) == 0)
292 {
293 const char *name = BackendList[i].name;
294 void (*Init)(BackendFuncs*) = BackendList[i].Init;
295
296 BackendList[i].name = BackendList[n].name;
297 BackendList[i].Init = BackendList[n].Init;
298
299 BackendList[n].name = name;
300 BackendList[n].Init = Init;
301
302 i++;
303 }
304 }
305 } while(next++);
306
307 BackendList[i].name = NULL;
308 BackendList[i].Init = NULL;
309 }
310
311 for(i = 0;BackendList[i].Init;i++)
312 BackendList[i].Init(&BackendList[i].Funcs);
313
314 str = GetConfigValue(NULL, "stereodup", "false");
315 DuplicateStereo = (strcasecmp(str, "true") == 0 ||
316 strcasecmp(str, "yes") == 0 ||
317 strcasecmp(str, "on") == 0 ||
318 atoi(str) != 0);
319
320 str = GetConfigValue(NULL, "excludefx", "");
321 if(str[0])
322 {
323 const struct {
324 const char *name;
325 int type;
326 } EffectList[] = {
327 { "reverb", REVERB },
328 { NULL, 0 }
329 };
330 int n;
331 size_t len;
332 const char *next = str;
333
334 do {
335 str = next;
336 next = strchr(str, ',');
337
338 if(!str[0] || next == str)
339 continue;
340
341 len = (next ? ((size_t)(next-str)) : strlen(str));
342 for(n = 0;EffectList[n].name;n++)
343 {
344 if(len == strlen(EffectList[n].name) &&
345 strncmp(EffectList[n].name, str, len) == 0)
346 DisabledEffects[EffectList[n].type] = AL_TRUE;
347 }
348 } while(next++);
349 }
350 }
351 }
352
353 ALCchar *AppendDeviceList(char *name)
354 {
355 static size_t pos;
356 ALCchar *ret = alcDeviceList+pos;
357 if(pos >= sizeof(alcDeviceList))
358 {
359 AL_PRINT("Not enough room to add %s!\n", name);
360 return alcDeviceList + sizeof(alcDeviceList) - 1;
361 }
362 pos += snprintf(alcDeviceList+pos, sizeof(alcDeviceList)-pos-1, "%s", name) + 1;
363 return ret;
364 }
365
366 ALCchar *AppendAllDeviceList(char *name)
367 {
368 static size_t pos;
369 ALCchar *ret = alcAllDeviceList+pos;
370 if(pos >= sizeof(alcAllDeviceList))
371 {
372 AL_PRINT("Not enough room to add %s!\n", name);
373 return alcAllDeviceList + sizeof(alcAllDeviceList) - 1;
374 }
375 pos += snprintf(alcAllDeviceList+pos, sizeof(alcAllDeviceList)-pos-1, "%s", name) + 1;
376 return ret;
377 }
378
379 ALCchar *AppendCaptureDeviceList(char *name)
380 {
381 static size_t pos;
382 ALCchar *ret = alcCaptureDeviceList+pos;
383 if(pos >= sizeof(alcCaptureDeviceList))
384 {
385 AL_PRINT("Not enough room to add %s!\n", name);
386 return alcCaptureDeviceList + sizeof(alcCaptureDeviceList) - 1;
387 }
388 pos += snprintf(alcCaptureDeviceList+pos, sizeof(alcCaptureDeviceList)-pos-1, "%s", name) + 1;
389 return ret;
390 }
391
392 /*
393 IsContext
394
395 Check pContext is a valid Context pointer
396 */
397 static ALCboolean IsContext(ALCcontext *pContext)
398 {
399 ALCcontext *pTempContext;
400
401 pTempContext = g_pContextList;
402 while (pTempContext && pTempContext != pContext)
403 pTempContext = pTempContext->next;
404
405 return (pTempContext ? ALC_TRUE : ALC_FALSE);
406 }
407
408
409 /*
410 SetALCError
411
412 Store latest ALC Error
413 */
414 ALCvoid SetALCError(ALenum errorCode)
415 {
416 g_eLastContextError = errorCode;
417 }
418
419
420 /*
421 SuspendContext
422
423 Thread-safe entry
424 */
425 ALCvoid SuspendContext(ALCcontext *pContext)
426 {
427 (void)pContext;
428 EnterCriticalSection(&g_csMutex);
429 }
430
431
432 /*
433 ProcessContext
434
435 Thread-safe exit
436 */
437 ALCvoid ProcessContext(ALCcontext *pContext)
438 {
439 (void)pContext;
440 LeaveCriticalSection(&g_csMutex);
441 }
442
443
444 /*
445 InitContext
446
447 Initialize Context variables
448 */
449 static ALvoid InitContext(ALCcontext *pContext)
450 {
451 int level;
452
453 //Initialise listener
454 pContext->Listener.Gain = 1.0f;
455 pContext->Listener.MetersPerUnit = 1.0f;
456 pContext->Listener.Position[0] = 0.0f;
457 pContext->Listener.Position[1] = 0.0f;
458 pContext->Listener.Position[2] = 0.0f;
459 pContext->Listener.Velocity[0] = 0.0f;
460 pContext->Listener.Velocity[1] = 0.0f;
461 pContext->Listener.Velocity[2] = 0.0f;
462 pContext->Listener.Forward[0] = 0.0f;
463 pContext->Listener.Forward[1] = 0.0f;
464 pContext->Listener.Forward[2] = -1.0f;
465 pContext->Listener.Up[0] = 0.0f;
466 pContext->Listener.Up[1] = 1.0f;
467 pContext->Listener.Up[2] = 0.0f;
468
469 //Validate pContext
470 pContext->LastError = AL_NO_ERROR;
471 pContext->InUse = AL_FALSE;
472
473 //Set output format
474 pContext->Frequency = pContext->Device->Frequency;
475
476 //Set globals
477 pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
478 pContext->DopplerFactor = 1.0f;
479 pContext->DopplerVelocity = 1.0f;
480 pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
481
482 pContext->lNumStereoSources = 1;
483 pContext->lNumMonoSources = pContext->Device->MaxNoOfSources - pContext->lNumStereoSources;
484
485 pContext->ExtensionList = "AL_EXTX_buffer_sub_data AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_OFFSET AL_EXTX_source_distance_model AL_LOKI_quadriphonic";
486
487 level = GetConfigValueInt(NULL, "cf_level", 0);
488 if(level > 0 && level <= 6)
489 {
490 pContext->bs2b = calloc(1, sizeof(*pContext->bs2b));
491 bs2b_set_srate(pContext->bs2b, pContext->Frequency);
492 bs2b_set_level(pContext->bs2b, level);
493 }
494
495 aluInitPanning(pContext);
496 }
497
498
499 /*
500 ExitContext
501
502 Clean up Context, destroy any remaining Sources
503 */
504 static ALCvoid ExitContext(ALCcontext *pContext)
505 {
506 //Invalidate context
507 pContext->LastError = AL_NO_ERROR;
508 pContext->InUse = AL_FALSE;
509
510 free(pContext->bs2b);
511 pContext->bs2b = NULL;
512 }
513
514 ///////////////////////////////////////////////////////
515
516
517 ///////////////////////////////////////////////////////
518 // ALC Functions calls
519
520
521 // This should probably move to another c file but for now ...
522 ALCAPI ALCdevice* ALCAPIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
523 {
524 ALCboolean DeviceFound = ALC_FALSE;
525 ALCdevice *pDevice = NULL;
526 ALCint i;
527
528 InitAL();
529
530 if(SampleSize <= 0)
531 {
532 SetALCError(ALC_INVALID_VALUE);
533 return NULL;
534 }
535
536 if(deviceName && !deviceName[0])
537 deviceName = NULL;
538
539 pDevice = malloc(sizeof(ALCdevice));
540 if (pDevice)
541 {
542 //Initialise device structure
543 memset(pDevice, 0, sizeof(ALCdevice));
544
545 //Validate device
546 pDevice->IsCaptureDevice = AL_TRUE;
547
548 pDevice->Frequency = frequency;
549 pDevice->Format = format;
550
551 for(i = 0;BackendList[i].Init;i++)
552 {
553 pDevice->Funcs = &BackendList[i].Funcs;
554 if(ALCdevice_OpenCapture(pDevice, deviceName, frequency, format, SampleSize))
555 {
556 SuspendContext(NULL);
557 pDevice->next = g_pDeviceList;
558 g_pDeviceList = pDevice;
559 g_ulDeviceCount++;
560 ProcessContext(NULL);
561
562 DeviceFound = ALC_TRUE;
563 break;
564 }
565 }
566
567 if(!DeviceFound)
568 {
569 SetALCError(ALC_INVALID_VALUE);
570 free(pDevice);
571 pDevice = NULL;
572 }
573 }
574 else
575 SetALCError(ALC_OUT_OF_MEMORY);
576
577 return pDevice;
578 }
579
580 ALCAPI ALCboolean ALCAPIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
581 {
582 ALCboolean bReturn = ALC_FALSE;
583 ALCdevice **list;
584
585 if ((pDevice)&&(pDevice->IsCaptureDevice))
586 {
587 SuspendContext(NULL);
588
589 list = &g_pDeviceList;
590 while(*list != pDevice)
591 list = &(*list)->next;
592
593 *list = (*list)->next;
594 g_ulDeviceCount--;
595
596 ProcessContext(NULL);
597
598 ALCdevice_CloseCapture(pDevice);
599 free(pDevice);
600
601 bReturn = ALC_TRUE;
602 }
603 else
604 SetALCError(ALC_INVALID_DEVICE);
605
606 return bReturn;
607 }
608
609 ALCAPI void ALCAPIENTRY alcCaptureStart(ALCdevice *pDevice)
610 {
611 if ((pDevice)&&(pDevice->IsCaptureDevice))
612 ALCdevice_StartCapture(pDevice);
613 else
614 SetALCError(ALC_INVALID_DEVICE);
615 }
616
617 ALCAPI void ALCAPIENTRY alcCaptureStop(ALCdevice *pDevice)
618 {
619 if ((pDevice)&&(pDevice->IsCaptureDevice))
620 ALCdevice_StopCapture(pDevice);
621 else
622 SetALCError(ALC_INVALID_DEVICE);
623 }
624
625 ALCAPI void ALCAPIENTRY alcCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCsizei lSamples)
626 {
627 if ((pDevice) && (pDevice->IsCaptureDevice))
628 ALCdevice_CaptureSamples(pDevice, pBuffer, lSamples);
629 else
630 SetALCError(ALC_INVALID_DEVICE);
631 }
632
633 /*
634 alcGetError
635
636 Return last ALC generated error code
637 */
638 ALCAPI ALCenum ALCAPIENTRY alcGetError(ALCdevice *device)
639 {
640 ALCenum errorCode;
641
642 (void)device;
643
644 errorCode = g_eLastContextError;
645 g_eLastContextError = ALC_NO_ERROR;
646 return errorCode;
647 }
648
649
650 /*
651 alcSuspendContext
652
653 Not functional
654 */
655 ALCAPI ALCvoid ALCAPIENTRY alcSuspendContext(ALCcontext *pContext)
656 {
657 // Not a lot happens here !
658 (void)pContext;
659 }
660
661
662 /*
663 alcProcessContext
664
665 Not functional
666 */
667 ALCAPI ALCvoid ALCAPIENTRY alcProcessContext(ALCcontext *pContext)
668 {
669 // Not a lot happens here !
670 (void)pContext;
671 }
672
673
674 /*
675 alcGetString
676
677 Returns information about the Device, and error strings
678 */
679 ALCAPI const ALCchar* ALCAPIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
680 {
681 const ALCchar *value = NULL;
682
683 InitAL();
684
685 switch (param)
686 {
687 case ALC_NO_ERROR:
688 value = alcNoError;
689 break;
690
691 case ALC_INVALID_ENUM:
692 value = alcErrInvalidEnum;
693 break;
694
695 case ALC_INVALID_VALUE:
696 value = alcErrInvalidValue;
697 break;
698
699 case ALC_INVALID_DEVICE:
700 value = alcErrInvalidDevice;
701 break;
702
703 case ALC_INVALID_CONTEXT:
704 value = alcErrInvalidContext;
705 break;
706
707 case ALC_OUT_OF_MEMORY:
708 value = alcErrOutOfMemory;
709 break;
710
711 case ALC_DEFAULT_DEVICE_SPECIFIER:
712 value = alcDefaultDeviceSpecifier;
713 break;
714
715 case ALC_DEVICE_SPECIFIER:
716 if (pDevice)
717 value = pDevice->szDeviceName;
718 else
719 value = alcDeviceList;
720 break;
721
722 case ALC_ALL_DEVICES_SPECIFIER:
723 value = alcAllDeviceList;
724 break;
725
726 case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
727 value = alcDefaultAllDeviceSpecifier;
728 break;
729
730 case ALC_CAPTURE_DEVICE_SPECIFIER:
731 if (pDevice)
732 value = pDevice->szDeviceName;
733 else
734 value = alcCaptureDeviceList;
735 break;
736
737 case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
738 value = alcCaptureDefaultDeviceSpecifier;
739 break;
740
741 case ALC_EXTENSIONS:
742 value = alcExtensionList;
743 break;
744
745 default:
746 SetALCError(ALC_INVALID_ENUM);
747 break;
748 }
749
750 return value;
751 }
752
753
754 /*
755 alcGetIntegerv
756
757 Returns information about the Device and the version of Open AL
758 */
759 ALCAPI ALCvoid ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
760 {
761 InitAL();
762
763 if ((device)&&(device->IsCaptureDevice))
764 {
765 SuspendContext(NULL);
766
767 // Capture device
768 switch (param)
769 {
770 case ALC_CAPTURE_SAMPLES:
771 if ((size) && (data))
772 *data = ALCdevice_AvailableSamples(device);
773 else
774 SetALCError(ALC_INVALID_VALUE);
775 break;
776
777 default:
778 SetALCError(ALC_INVALID_ENUM);
779 break;
780 }
781
782 ProcessContext(NULL);
783 }
784 else
785 {
786 if(data)
787 {
788 // Playback Device
789 switch (param)
790 {
791 case ALC_MAJOR_VERSION:
792 if(!size)
793 SetALCError(ALC_INVALID_VALUE);
794 else
795 *data = alcMajorVersion;
796 break;
797
798 case ALC_MINOR_VERSION:
799 if(!size)
800 SetALCError(ALC_INVALID_VALUE);
801 else
802 *data = alcMinorVersion;
803 break;
804
805 case ALC_EFX_MAJOR_VERSION:
806 if(!size)
807 SetALCError(ALC_INVALID_VALUE);
808 else
809 *data = alcEFXMajorVersion;
810 break;
811
812 case ALC_EFX_MINOR_VERSION:
813 if(!size)
814 SetALCError(ALC_INVALID_VALUE);
815 else
816 *data = alcEFXMinorVersion;
817 break;
818
819 case ALC_MAX_AUXILIARY_SENDS:
820 if(!size)
821 SetALCError(ALC_INVALID_VALUE);
822 else
823 *data = MAX_SENDS;
824 break;
825
826 case ALC_ATTRIBUTES_SIZE:
827 if(!device)
828 SetALCError(ALC_INVALID_DEVICE);
829 else if(!size)
830 SetALCError(ALC_INVALID_VALUE);
831 else
832 *data = 12;
833 break;
834
835 case ALC_ALL_ATTRIBUTES:
836 if(!device)
837 SetALCError(ALC_INVALID_DEVICE);
838 else if (size < 7)
839 SetALCError(ALC_INVALID_VALUE);
840 else
841 {
842 int i = 0;
843
844 data[i++] = ALC_FREQUENCY;
845 data[i++] = device->Frequency;
846
847 data[i++] = ALC_REFRESH;
848 data[i++] = device->Frequency / device->UpdateSize;
849
850 data[i++] = ALC_SYNC;
851 data[i++] = ALC_FALSE;
852
853 SuspendContext(NULL);
854 if(device->Context && size >= 12)
855 {
856 data[i++] = ALC_MONO_SOURCES;
857 data[i++] = device->Context->lNumMonoSources;
858
859 data[i++] = ALC_STEREO_SOURCES;
860 data[i++] = device->Context->lNumStereoSources;
861
862 data[i++] = ALC_MAX_AUXILIARY_SENDS;
863 data[i++] = MAX_SENDS;
864 }
865 ProcessContext(NULL);
866
867 data[i++] = 0;
868 }
869 break;
870
871 case ALC_FREQUENCY:
872 if(!device)
873 SetALCError(ALC_INVALID_DEVICE);
874 else if(!size)
875 SetALCError(ALC_INVALID_VALUE);
876 else
877 *data = device->Frequency;
878 break;
879
880 case ALC_REFRESH:
881 if(!device)
882 SetALCError(ALC_INVALID_DEVICE);
883 else if(!size)
884 SetALCError(ALC_INVALID_VALUE);
885 else
886 *data = device->Frequency / device->UpdateSize;
887 break;
888
889 case ALC_SYNC:
890 if(!device)
891 SetALCError(ALC_INVALID_DEVICE);
892 else if(!size)
893 SetALCError(ALC_INVALID_VALUE);
894 else
895 *data = ALC_FALSE;
896 break;
897
898 case ALC_MONO_SOURCES:
899 if(!device || !device->Context)
900 SetALCError(ALC_INVALID_DEVICE);
901 else if (size != 1)
902 SetALCError(ALC_INVALID_VALUE);
903 else
904 *data = device->Context->lNumMonoSources;
905 break;
906
907 case ALC_STEREO_SOURCES:
908 if(!device || !device->Context)
909 SetALCError(ALC_INVALID_DEVICE);
910 else if (size != 1)
911 SetALCError(ALC_INVALID_VALUE);
912 else
913 *data = device->Context->lNumStereoSources;
914 break;
915
916 default:
917 SetALCError(ALC_INVALID_ENUM);
918 break;
919 }
920 }
921 else if(size)
922 SetALCError(ALC_INVALID_VALUE);
923 }
924
925 return;
926 }
927
928
929 /*
930 alcIsExtensionPresent
931
932 Determines if there is support for a particular extension
933 */
934 ALCAPI ALCboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
935 {
936 ALCboolean bResult = ALC_FALSE;
937
938 (void)device;
939
940 if (extName)
941 {
942 const char *ptr;
943 size_t len;
944
945 len = strlen(extName);
946 ptr = alcExtensionList;
947 while(ptr && *ptr)
948 {
949 if(strncasecmp(ptr, extName, len) == 0 &&
950 (ptr[len] == '\0' || isspace(ptr[len])))
951 {
952 bResult = ALC_TRUE;
953 break;
954 }
955 if((ptr=strchr(ptr, ' ')) != NULL)
956 {
957 do {
958 ++ptr;
959 } while(isspace(*ptr));
960 }
961 }
962 }
963 else
964 SetALCError(ALC_INVALID_VALUE);
965
966 return bResult;
967 }
968
969
970 /*
971 alcGetProcAddress
972
973 Retrieves the function address for a particular extension function
974 */
975 ALCAPI ALCvoid * ALCAPIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
976 {
977 ALCvoid *pFunction = NULL;
978 ALsizei i = 0;
979
980 (void)device;
981
982 if (funcName)
983 {
984 while(alcFunctions[i].funcName &&
985 strcmp(alcFunctions[i].funcName,funcName) != 0)
986 i++;
987 pFunction = alcFunctions[i].address;
988 }
989 else
990 SetALCError(ALC_INVALID_VALUE);
991
992 return pFunction;
993 }
994
995
996 /*
997 alcGetEnumValue
998
999 Get the value for a particular ALC Enumerated Value
1000 */
1001 ALCAPI ALCenum ALCAPIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
1002 {
1003 ALsizei i = 0;
1004 ALCenum val;
1005
1006 (void)device;
1007
1008 while ((enumeration[i].enumName)&&(strcmp(enumeration[i].enumName,enumName)))
1009 i++;
1010 val = enumeration[i].value;
1011
1012 if(!enumeration[i].enumName)
1013 SetALCError(ALC_INVALID_VALUE);
1014
1015 return val;
1016 }
1017
1018
1019 /*
1020 alcCreateContext
1021
1022 Create and attach a Context to a particular Device.
1023 */
1024 ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
1025 {
1026 ALCcontext *ALContext = NULL;
1027 ALuint ulAttributeIndex, ulRequestedStereoSources;
1028
1029 if ((device)&&(!device->IsCaptureDevice))
1030 {
1031 // Reset Context Last Error code
1032 g_eLastContextError = ALC_NO_ERROR;
1033
1034 // Current implementation only allows one Context per Device
1035 if(!device->Context)
1036 {
1037 ALContext = calloc(1, sizeof(ALCcontext));
1038 if(!ALContext)
1039 {
1040 SetALCError(ALC_OUT_OF_MEMORY);
1041 return NULL;
1042 }
1043
1044 ALContext->Device = device;
1045 InitContext(ALContext);
1046
1047 device->Context = ALContext;
1048
1049 SuspendContext(NULL);
1050
1051 ALContext->next = g_pContextList;
1052 g_pContextList = ALContext;
1053 g_ulContextCount++;
1054
1055 ProcessContext(NULL);
1056
1057 // Check for Voice Count attributes
1058 if (attrList)
1059 {
1060 ulAttributeIndex = 0;
1061 while ((ulAttributeIndex < 10) && (attrList[ulAttributeIndex]))
1062 {
1063 if (attrList[ulAttributeIndex] == ALC_STEREO_SOURCES)
1064 {
1065 ulRequestedStereoSources = attrList[ulAttributeIndex + 1];
1066
1067 if (ulRequestedStereoSources > ALContext->Device->MaxNoOfSources)
1068 ulRequestedStereoSources = ALContext->Device->MaxNoOfSources;
1069
1070 ALContext->lNumStereoSources = ulRequestedStereoSources;
1071 ALContext->lNumMonoSources = ALContext->Device->MaxNoOfSources - ALContext->lNumStereoSources;
1072 break;
1073 }
1074
1075 ulAttributeIndex += 2;
1076 }
1077 }
1078 }
1079 else
1080 {
1081 SetALCError(ALC_INVALID_VALUE);
1082 ALContext = NULL;
1083 }
1084 }
1085 else
1086 SetALCError(ALC_INVALID_DEVICE);
1087
1088 return ALContext;
1089 }
1090
1091
1092 /*
1093 alcDestroyContext
1094
1095 Remove a Context
1096 */
1097 ALCAPI ALCvoid ALCAPIENTRY alcDestroyContext(ALCcontext *context)
1098 {
1099 ALCcontext **list;
1100
1101 InitAL();
1102
1103 // Lock context list
1104 SuspendContext(NULL);
1105
1106 if (IsContext(context))
1107 {
1108 // Lock context
1109 SuspendContext(context);
1110
1111 ReleaseALSources(context);
1112 ReleaseALAuxiliaryEffectSlots(context);
1113
1114 context->Device->Context = NULL;
1115
1116 list = &g_pContextList;
1117 while(*list != context)
1118 list = &(*list)->next;
1119
1120 *list = (*list)->next;
1121 g_ulContextCount--;
1122
1123 // Unlock context
1124 ProcessContext(context);
1125
1126 ExitContext(context);
1127
1128 // Free memory (MUST do this after ProcessContext)
1129 memset(context, 0, sizeof(ALCcontext));
1130 free(context);
1131 }
1132 else
1133 SetALCError(ALC_INVALID_CONTEXT);
1134
1135 ProcessContext(NULL);
1136 }
1137
1138
1139 /*
1140 alcGetCurrentContext
1141
1142 Returns the currently active Context
1143 */
1144 ALCAPI ALCcontext * ALCAPIENTRY alcGetCurrentContext(ALCvoid)
1145 {
1146 ALCcontext *pContext = NULL;
1147
1148 InitAL();
1149
1150 SuspendContext(NULL);
1151
1152 pContext = g_pContextList;
1153 while ((pContext) && (!pContext->InUse))
1154 pContext = pContext->next;
1155
1156 ProcessContext(NULL);
1157
1158 return pContext;
1159 }
1160
1161
1162 /*
1163 alcGetContextsDevice
1164
1165 Returns the Device that a particular Context is attached to
1166 */
1167 ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext *pContext)
1168 {
1169 ALCdevice *pDevice = NULL;
1170
1171 InitAL();
1172
1173 SuspendContext(NULL);
1174 if (IsContext(pContext))
1175 pDevice = pContext->Device;
1176 else
1177 SetALCError(ALC_INVALID_CONTEXT);
1178 ProcessContext(NULL);
1179
1180 return pDevice;
1181 }
1182
1183
1184 /*
1185 alcMakeContextCurrent
1186
1187 Makes the given Context the active Context
1188 */
1189 ALCAPI ALCboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext *context)
1190 {
1191 ALCcontext *ALContext;
1192 ALboolean bReturn = AL_TRUE;
1193
1194 InitAL();
1195
1196 SuspendContext(NULL);
1197
1198 // context must be a valid Context or NULL
1199 if ((IsContext(context)) || (context == NULL))
1200 {
1201 if ((ALContext=alcGetCurrentContext()))
1202 {
1203 SuspendContext(ALContext);
1204 ALContext->InUse=AL_FALSE;
1205 ProcessContext(ALContext);
1206 }
1207
1208 if ((ALContext=context) && (ALContext->Device))
1209 {
1210 SuspendContext(ALContext);
1211 ALContext->InUse=AL_TRUE;
1212 ProcessContext(ALContext);
1213 }
1214 }
1215 else
1216 {
1217 SetALCError(ALC_INVALID_CONTEXT);
1218 bReturn = AL_FALSE;
1219 }
1220
1221 ProcessContext(NULL);
1222
1223 return bReturn;
1224 }
1225
1226
1227 /*
1228 alcOpenDevice
1229
1230 Open the Device specified.
1231 */
1232 ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(const ALCchar *deviceName)
1233 {
1234 ALboolean bDeviceFound = AL_FALSE;
1235 ALCdevice *device;
1236 ALint i;
1237
1238 InitAL();
1239
1240 if(deviceName && !deviceName[0])
1241 deviceName = NULL;
1242
1243 device = malloc(sizeof(ALCdevice));
1244 if (device)
1245 {
1246 const char *fmt;
1247
1248 //Initialise device structure
1249 memset(device, 0, sizeof(ALCdevice));
1250
1251 //Validate device
1252 device->IsCaptureDevice = AL_FALSE;
1253
1254 //Set output format
1255 device->Frequency = GetConfigValueInt(NULL, "frequency", SWMIXER_OUTPUT_RATE);
1256 if((ALint)device->Frequency <= 0)
1257 device->Frequency = SWMIXER_OUTPUT_RATE;
1258
1259 fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
1260 if(fmt[0])
1261 device->Format = alGetEnumValue(fmt);
1262
1263 if(!aluChannelsFromFormat(device->Format))
1264 device->Format = AL_FORMAT_STEREO16;
1265
1266 device->UpdateSize = GetConfigValueInt(NULL, "refresh", 4096);
1267 if((ALint)device->UpdateSize <= 0)
1268 device->UpdateSize = 4096;
1269
1270 device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
1271 if((ALint)device->MaxNoOfSources <= 0)
1272 device->MaxNoOfSources = 256;
1273
1274 // Find a playback device to open
1275 SuspendContext(NULL);
1276 for(i = 0;BackendList[i].Init;i++)
1277 {
1278 device->Funcs = &BackendList[i].Funcs;
1279 if(ALCdevice_OpenPlayback(device, deviceName))
1280 {
1281 device->next = g_pDeviceList;
1282 g_pDeviceList = device;
1283 g_ulDeviceCount++;
1284
1285 bDeviceFound = AL_TRUE;
1286 break;
1287 }
1288 }
1289 ProcessContext(NULL);
1290
1291 if (!bDeviceFound)
1292 {
1293 // No suitable output device found
1294 SetALCError(ALC_INVALID_VALUE);
1295 free(device);
1296 device = NULL;
1297 }
1298 }
1299 else
1300 SetALCError(ALC_OUT_OF_MEMORY);
1301
1302 return device;
1303 }
1304
1305
1306 /*
1307 alcCloseDevice
1308
1309 Close the specified Device
1310 */
1311 ALCAPI ALCboolean ALCAPIENTRY alcCloseDevice(ALCdevice *pDevice)
1312 {
1313 ALCboolean bReturn = ALC_FALSE;
1314 ALCdevice **list;
1315
1316 if ((pDevice)&&(!pDevice->IsCaptureDevice))
1317 {
1318 SuspendContext(NULL);
1319
1320 list = &g_pDeviceList;
1321 while(*list != pDevice)
1322 list = &(*list)->next;
1323
1324 *list = (*list)->next;
1325 g_ulDeviceCount--;
1326
1327 ProcessContext(NULL);
1328
1329 if(pDevice->Context)
1330 {
1331 #ifdef _DEBUG
1332 AL_PRINT("alcCloseDevice(): destroying 1 Context\n");
1333 #endif
1334 alcDestroyContext(pDevice->Context);
1335 }
1336 ALCdevice_ClosePlayback(pDevice);
1337
1338 //Release device structure
1339 memset(pDevice, 0, sizeof(ALCdevice));
1340 free(pDevice);
1341
1342 bReturn = ALC_TRUE;
1343 }
1344 else
1345 SetALCError(ALC_INVALID_DEVICE);
1346
1347 return bReturn;
1348 }
1349
1350
1351 ALCvoid ReleaseALC(ALCvoid)
1352 {
1353 #ifdef _DEBUG
1354 if(g_ulDeviceCount > 0)
1355 AL_PRINT("exit(): closing %u Device%s\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
1356 #endif
1357
1358 while(g_pDeviceList)
1359 {
1360 if(g_pDeviceList->IsCaptureDevice)
1361 alcCaptureCloseDevice(g_pDeviceList);
1362 else
1363 alcCloseDevice(g_pDeviceList);
1364 }
1365 }
1366
1367 ///////////////////////////////////////////////////////
Software OpenAL implementation