Alc/ALc.c

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