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