Alc/ALc.c

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