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