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