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