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 #define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
  22
  23 #include "config.h"
  24
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <memory.h>
  29 #include "alMain.h"
  30 #include "alSource.h"
  31 #include "AL/al.h"
  32 #include "AL/alc.h"
  33 #include "alThunk.h"
  34 #include "alSource.h"
  35 #include "alExtension.h"
  36 #include "alAuxEffectSlot.h"
  37 #include "bs2b.h"
  38
  39 ///////////////////////////////////////////////////////
  40 // DEBUG INFORMATION
  41
  42 char _alDebug[256];
  43
  44 ///////////////////////////////////////////////////////
  45
  46
  47 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
  48 struct {
  49     const char *name;
  50     void (*Init)(BackendFuncs*);
  51     BackendFuncs Funcs;
  52 } BackendList[] = {
  53 #ifdef HAVE_ALSA
  54     { "alsa", alc_alsa_init, EmptyFuncs },
  55 #endif
  56 #ifdef HAVE_OSS
  57     { "oss", alc_oss_init, EmptyFuncs },
  58 #endif
  59 #ifdef HAVE_DSOUND
  60     { "dsound", alcDSoundInit, EmptyFuncs },
  61 #endif
  62 #ifdef HAVE_WINMM
  63     { "winmm", alcWinMMInit, EmptyFuncs },
  64 #endif
  65
  66     { "wave", alc_wave_init, EmptyFuncs },
  67
  68     { NULL, NULL, EmptyFuncs }
  69 };
  70 #undef EmptyFuncs
  71
  72 ///////////////////////////////////////////////////////
  73
  74 #define ALC_EFX_MAJOR_VERSION                              0x20001
  75 #define ALC_EFX_MINOR_VERSION                              0x20002
  76 #define ALC_MAX_AUXILIARY_SENDS                            0x20003
  77
  78 ///////////////////////////////////////////////////////
  79 // STRING and EXTENSIONS
  80
  81 typedef struct ALCextension_struct
  82 {
  83     ALCchar        *extName;
  84     ALvoid        *address;
  85 } ALCextension;
  86
  87 typedef struct ALCfunction_struct
  88 {
  89     ALCchar        *funcName;
  90     ALvoid        *address;
  91 } ALCfunction;
  92
  93 static ALCextension alcExtensions[] = {
  94     { "ALC_ENUMERATE_ALL_EXT", (ALvoid *) NULL },
  95     { "ALC_ENUMERATION_EXT",   (ALvoid *) NULL },
  96     { "ALC_EXT_CAPTURE",       (ALvoid *) NULL },
  97     { "ALC_EXT_EFX",           (ALvoid *) NULL },
  98     { NULL,                    (ALvoid *) NULL }
  99 };
 100
 101 static ALCfunction  alcFunctions[] = {
 102     { "alcCreateContext",           (ALvoid *) alcCreateContext         },
 103     { "alcMakeContextCurrent",      (ALvoid *) alcMakeContextCurrent    },
 104     { "alcProcessContext",          (ALvoid *) alcProcessContext        },
 105     { "alcSuspendContext",          (ALvoid *) alcSuspendContext        },
 106     { "alcDestroyContext",          (ALvoid *) alcDestroyContext        },
 107     { "alcGetCurrentContext",       (ALvoid *) alcGetCurrentContext     },
 108     { "alcGetContextsDevice",       (ALvoid *) alcGetContextsDevice     },
 109     { "alcOpenDevice",              (ALvoid *) alcOpenDevice            },
 110     { "alcCloseDevice",             (ALvoid *) alcCloseDevice           },
 111     { "alcGetError",                (ALvoid *) alcGetError              },
 112     { "alcIsExtensionPresent",      (ALvoid *) alcIsExtensionPresent    },
 113     { "alcGetProcAddress",          (ALvoid *) alcGetProcAddress        },
 114     { "alcGetEnumValue",            (ALvoid *) alcGetEnumValue          },
 115     { "alcGetString",               (ALvoid *) alcGetString             },
 116     { "alcGetIntegerv",             (ALvoid *) alcGetIntegerv           },
 117     { "alcCaptureOpenDevice",       (ALvoid *) alcCaptureOpenDevice     },
 118     { "alcCaptureCloseDevice",      (ALvoid *) alcCaptureCloseDevice    },
 119     { "alcCaptureStart",            (ALvoid *) alcCaptureStart          },
 120     { "alcCaptureStop",             (ALvoid *) alcCaptureStop           },
 121     { "alcCaptureSamples",          (ALvoid *) alcCaptureSamples        },
 122     { NULL,                         (ALvoid *) NULL                     }
 123 };
 124
 125 static ALenums enumeration[]={
 126     // Types
 127     { (ALchar *)"ALC_INVALID",                          ALC_INVALID                         },
 128     { (ALchar *)"ALC_FALSE",                            ALC_FALSE                           },
 129     { (ALchar *)"ALC_TRUE",                             ALC_TRUE                            },
 130
 131     // ALC Properties
 132     { (ALchar *)"ALC_MAJOR_VERSION",                    ALC_MAJOR_VERSION                   },
 133     { (ALchar *)"ALC_MINOR_VERSION",                    ALC_MINOR_VERSION                   },
 134     { (ALchar *)"ALC_ATTRIBUTES_SIZE",                  ALC_ATTRIBUTES_SIZE                 },
 135     { (ALchar *)"ALC_ALL_ATTRIBUTES",                   ALC_ALL_ATTRIBUTES                  },
 136     { (ALchar *)"ALC_DEFAULT_DEVICE_SPECIFIER",         ALC_DEFAULT_DEVICE_SPECIFIER        },
 137     { (ALchar *)"ALC_DEVICE_SPECIFIER",                 ALC_DEVICE_SPECIFIER                },
 138     { (ALchar *)"ALC_ALL_DEVICES_SPECIFIER",            ALC_ALL_DEVICES_SPECIFIER           },
 139     { (ALchar *)"ALC_DEFAULT_ALL_DEVICES_SPECIFIER",    ALC_DEFAULT_ALL_DEVICES_SPECIFIER   },
 140     { (ALchar *)"ALC_EXTENSIONS",                       ALC_EXTENSIONS                      },
 141     { (ALchar *)"ALC_FREQUENCY",                        ALC_FREQUENCY                       },
 142     { (ALchar *)"ALC_REFRESH",                          ALC_REFRESH                         },
 143     { (ALchar *)"ALC_SYNC",                             ALC_SYNC                            },
 144     { (ALchar *)"ALC_MONO_SOURCES",                     ALC_MONO_SOURCES                    },
 145     { (ALchar *)"ALC_STEREO_SOURCES",                   ALC_STEREO_SOURCES                  },
 146     { (ALchar *)"ALC_CAPTURE_DEVICE_SPECIFIER",         ALC_CAPTURE_DEVICE_SPECIFIER        },
 147     { (ALchar *)"ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
 148     { (ALchar *)"ALC_CAPTURE_SAMPLES",                  ALC_CAPTURE_SAMPLES                 },
 149
 150     // EFX Properties
 151     { (ALchar *)"ALC_EFX_MAJOR_VERSION",                ALC_EFX_MAJOR_VERSION               },
 152     { (ALchar *)"ALC_EFX_MINOR_VERSION",                ALC_EFX_MINOR_VERSION               },
 153     { (ALchar *)"ALC_MAX_AUXILIARY_SENDS",              ALC_MAX_AUXILIARY_SENDS             },
 154
 155     // ALC Error Message
 156     { (ALchar *)"ALC_NO_ERROR",                         ALC_NO_ERROR                        },
 157     { (ALchar *)"ALC_INVALID_DEVICE",                   ALC_INVALID_DEVICE                  },
 158     { (ALchar *)"ALC_INVALID_CONTEXT",                  ALC_INVALID_CONTEXT                 },
 159     { (ALchar *)"ALC_INVALID_ENUM",                     ALC_INVALID_ENUM                    },
 160     { (ALchar *)"ALC_INVALID_VALUE",                    ALC_INVALID_VALUE                   },
 161     { (ALchar *)"ALC_OUT_OF_MEMORY",                    ALC_OUT_OF_MEMORY                   },
 162     { (ALchar *)NULL,                                   (ALenum)0 }
 163 };
 164 // Error strings
 165 static const ALCchar alcNoError[] = "No Error";
 166 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
 167 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
 168 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
 169 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
 170 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
 171
 172 // Context strings
 173 static ALCchar alcDeviceList[2048];
 174 static ALCchar alcAllDeviceList[2048];
 175 static ALCchar alcCaptureDeviceList[2048];
 176 // Default is always the first in the list
 177 static ALCchar *alcDefaultDeviceSpecifier = alcDeviceList;
 178 static ALCchar *alcDefaultAllDeviceSpecifier = alcAllDeviceList;
 179 static ALCchar *alcCaptureDefaultDeviceSpecifier = alcCaptureDeviceList;
 180
 181
 182 static ALCchar alcExtensionList[] = "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE ALC_EXT_EFX";
 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 // Context List
 199 static ALCcontext *g_pContextList = NULL;
 200 static ALCuint     g_ulContextCount = 0;
 201
 202 // Context Error
 203 static ALCenum g_eLastContextError = ALC_NO_ERROR;
 204
 205 ///////////////////////////////////////////////////////
 206
 207
 208 ///////////////////////////////////////////////////////
 209 // ALC Related helper functions
 210
 211 static void InitAL(void)
 212 {
 213     static int done = 0;
 214     if(!done)
 215     {
 216         int i;
 217         const char *devs;
 218
 219         InitializeCriticalSection(&_alMutex);
 220         ALTHUNK_INIT();
 221         ReadALConfig();
 222
 223         devs = GetConfigValue(NULL, "drivers", "");
 224         if(devs[0])
 225         {
 226             int n;
 227             size_t len;
 228             const char *next = devs;
 229
 230             i = 0;
 231
 232             do {
 233                 devs = next;
 234                 next = strchr(devs, ',');
 235
 236                 if(!devs[0] || devs[0] == ',')
 237                     continue;
 238
 239                 len = (next ? ((size_t)(next-devs)) : strlen(devs));
 240                 for(n = i;BackendList[n].Init;n++)
 241                 {
 242                     if(len == strlen(BackendList[n].name) &&
 243                        strncmp(BackendList[n].name, devs, len) == 0)
 244                     {
 245                         const char *name = BackendList[i].name;
 246                         void (*Init)(BackendFuncs*) = BackendList[i].Init;
 247
 248                         BackendList[i].name = BackendList[n].name;
 249                         BackendList[i].Init = BackendList[n].Init;
 250
 251                         BackendList[n].name = name;
 252                         BackendList[n].Init = Init;
 253
 254                         i++;
 255                     }
 256                 }
 257             } while(next++);
 258
 259             BackendList[i].name = NULL;
 260             BackendList[i].Init = NULL;
 261         }
 262
 263         for(i = 0;BackendList[i].Init;i++)
 264             BackendList[i].Init(&BackendList[i].Funcs);
 265         done = 1;
 266     }
 267 }
 268
 269 ALCchar *AppendDeviceList(char *name)
 270 {
 271     static int pos;
 272     ALCchar *ret = alcDeviceList+pos;
 273     pos += snprintf(alcDeviceList+pos, sizeof(alcDeviceList)-pos, "%s", name) + 1;
 274     return ret;
 275 }
 276
 277 ALCchar *AppendAllDeviceList(char *name)
 278 {
 279     static int pos;
 280     ALCchar *ret = alcAllDeviceList+pos;
 281     pos += snprintf(alcAllDeviceList+pos, sizeof(alcAllDeviceList)-pos, "%s", name) + 1;
 282     return ret;
 283 }
 284
 285 ALCchar *AppendCaptureDeviceList(char *name)
 286 {
 287     static int pos;
 288     ALCchar *ret = alcCaptureDeviceList+pos;
 289     pos += snprintf(alcCaptureDeviceList+pos, sizeof(alcCaptureDeviceList)-pos, "%s", name) + 1;
 290     return ret;
 291 }
 292
 293 /*
 294     IsContext
 295
 296     Check pContext is a valid Context pointer
 297 */
 298 static ALCboolean IsContext(ALCcontext *pContext)
 299 {
 300     ALCcontext *pTempContext;
 301
 302     pTempContext = g_pContextList;
 303     while (pTempContext && pTempContext != pContext)
 304         pTempContext = pTempContext->next;
 305
 306     return (pTempContext ? ALC_TRUE : ALC_FALSE);
 307 }
 308
 309
 310 /*
 311     SetALCError
 312
 313     Store latest ALC Error
 314 */
 315 ALCvoid SetALCError(ALenum errorCode)
 316 {
 317     g_eLastContextError = errorCode;
 318 }
 319
 320
 321 /*
 322     SuspendContext
 323
 324     Thread-safe entry
 325 */
 326 ALCvoid SuspendContext(ALCcontext *pContext)
 327 {
 328     (void)pContext;
 329     EnterCriticalSection(&_alMutex);
 330 }
 331
 332
 333 /*
 334     ProcessContext
 335
 336     Thread-safe exit
 337 */
 338 ALCvoid ProcessContext(ALCcontext *pContext)
 339 {
 340     (void)pContext;
 341     LeaveCriticalSection(&_alMutex);
 342 }
 343
 344
 345 /*
 346     InitContext
 347
 348     Initialize Context variables
 349 */
 350 static ALvoid InitContext(ALCcontext *pContext)
 351 {
 352     int level;
 353
 354     //Initialise listener
 355     pContext->Listener.Gain = 1.0f;
 356     pContext->Listener.MetersPerUnit = 1.0f;
 357     pContext->Listener.Position[0] = 0.0f;
 358     pContext->Listener.Position[1] = 0.0f;
 359     pContext->Listener.Position[2] = 0.0f;
 360     pContext->Listener.Velocity[0] = 0.0f;
 361     pContext->Listener.Velocity[1] = 0.0f;
 362     pContext->Listener.Velocity[2] = 0.0f;
 363     pContext->Listener.Forward[0] = 0.0f;
 364     pContext->Listener.Forward[1] = 0.0f;
 365     pContext->Listener.Forward[2] = -1.0f;
 366     pContext->Listener.Up[0] = 0.0f;
 367     pContext->Listener.Up[1] = 1.0f;
 368     pContext->Listener.Up[2] = 0.0f;
 369
 370     //Validate pContext
 371     pContext->LastError = AL_NO_ERROR;
 372     pContext->InUse = AL_FALSE;
 373
 374     //Set output format
 375     pContext->Frequency = pContext->Device->Frequency;
 376
 377     //Set globals
 378     pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
 379     pContext->DopplerFactor = 1.0f;
 380     pContext->DopplerVelocity = 1.0f;
 381     pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
 382
 383     pContext->lNumStereoSources = 1;
 384     pContext->lNumMonoSources = pContext->Device->MaxNoOfSources - pContext->lNumStereoSources;
 385
 386     strcpy(pContext->ExtensionList, "AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_OFFSET AL_LOKI_quadriphonic");
 387
 388     level = GetConfigValueInt(NULL, "cf_level", 0);
 389     if(level > 0 && level <= 6)
 390     {
 391         pContext->bs2b = calloc(1, sizeof(*pContext->bs2b));
 392         bs2b_set_srate(pContext->bs2b, pContext->Frequency);
 393         bs2b_set_level(pContext->bs2b, level);
 394     }
 395 }
 396
 397
 398 /*
 399     ExitContext
 400
 401     Clean up Context, destroy any remaining Sources
 402 */
 403 static ALCvoid ExitContext(ALCcontext *pContext)
 404 {
 405     //Invalidate context
 406     pContext->LastError = AL_NO_ERROR;
 407     pContext->InUse = AL_FALSE;
 408
 409     free(pContext->bs2b);
 410     pContext->bs2b = NULL;
 411 }
 412
 413 ///////////////////////////////////////////////////////
 414
 415
 416 ///////////////////////////////////////////////////////
 417 // ALC Functions calls
 418
 419
 420 // This should probably move to another c file but for now ...
 421 ALCAPI ALCdevice* ALCAPIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 422 {
 423     ALCboolean DeviceFound = ALC_FALSE;
 424     ALCdevice *pDevice = NULL;
 425     ALCint i;
 426
 427     InitAL();
 428
 429     if(deviceName && !deviceName[0])
 430         deviceName = NULL;
 431
 432     pDevice = malloc(sizeof(ALCdevice));
 433     if (pDevice)
 434     {
 435         if (SampleSize > 0)
 436         {
 437             //Initialise device structure
 438             memset(pDevice, 0, sizeof(ALCdevice));
 439
 440             //Validate device
 441             pDevice->InUse = AL_TRUE;
 442             pDevice->IsCaptureDevice = AL_TRUE;
 443
 444             pDevice->Frequency = frequency;
 445             pDevice->Format = format;
 446             pDevice->Channels = aluChannelsFromFormat(format);
 447             pDevice->FrameSize = aluBytesFromFormat(format) *
 448                                  pDevice->Channels;
 449
 450             for(i = 0;BackendList[i].Init;i++)
 451             {
 452                 pDevice->Funcs = &BackendList[i].Funcs;
 453                 if(ALCdevice_OpenCapture(pDevice, deviceName, frequency, format, SampleSize))
 454                 {
 455                     SuspendContext(NULL);
 456                     pDevice->next = g_pDeviceList;
 457                     g_pDeviceList = pDevice;
 458                     g_ulDeviceCount++;
 459                     ProcessContext(NULL);
 460
 461                     DeviceFound = ALC_TRUE;
 462                     break;
 463                 }
 464             }
 465         }
 466         else
 467             SetALCError(ALC_INVALID_VALUE);
 468
 469         if(!DeviceFound)
 470         {
 471             free(pDevice);
 472             pDevice = NULL;
 473         }
 474     }
 475     else
 476         SetALCError(ALC_OUT_OF_MEMORY);
 477
 478     return pDevice;
 479 }
 480
 481 ALCAPI ALCboolean ALCAPIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
 482 {
 483     ALCboolean bReturn = ALC_FALSE;
 484     ALCdevice **list;
 485
 486     if ((pDevice)&&(pDevice->IsCaptureDevice))
 487     {
 488         SuspendContext(NULL);
 489
 490         list = &g_pDeviceList;
 491         while(*list != pDevice)
 492             list = &(*list)->next;
 493
 494         *list = (*list)->next;
 495         g_ulDeviceCount--;
 496
 497         ProcessContext(NULL);
 498
 499         ALCdevice_CloseCapture(pDevice);
 500         free(pDevice);
 501
 502         bReturn = ALC_TRUE;
 503     }
 504     else
 505         SetALCError(ALC_INVALID_DEVICE);
 506
 507     return bReturn;
 508 }
 509
 510 ALCAPI void ALCAPIENTRY alcCaptureStart(ALCdevice *pDevice)
 511 {
 512     if ((pDevice)&&(pDevice->IsCaptureDevice))
 513         ALCdevice_StartCapture(pDevice);
 514     else
 515         SetALCError(ALC_INVALID_DEVICE);
 516 }
 517
 518 ALCAPI void ALCAPIENTRY alcCaptureStop(ALCdevice *pDevice)
 519 {
 520     if ((pDevice)&&(pDevice->IsCaptureDevice))
 521         ALCdevice_StopCapture(pDevice);
 522     else
 523         SetALCError(ALC_INVALID_DEVICE);
 524 }
 525
 526 ALCAPI void ALCAPIENTRY alcCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCsizei lSamples)
 527 {
 528     if ((pDevice) && (pDevice->IsCaptureDevice))
 529         ALCdevice_CaptureSamples(pDevice, pBuffer, lSamples);
 530     else
 531         SetALCError(ALC_INVALID_DEVICE);
 532 }
 533
 534 /*
 535     alcGetError
 536
 537     Return last ALC generated error code
 538 */
 539 ALCAPI ALCenum ALCAPIENTRY alcGetError(ALCdevice *device)
 540 {
 541     ALCenum errorCode;
 542
 543     (void)device;
 544
 545     errorCode = g_eLastContextError;
 546     g_eLastContextError = ALC_NO_ERROR;
 547     return errorCode;
 548 }
 549
 550
 551 /*
 552     alcSuspendContext
 553
 554     Not functional
 555 */
 556 ALCAPI ALCvoid ALCAPIENTRY alcSuspendContext(ALCcontext *pContext)
 557 {
 558     // Not a lot happens here !
 559     (void)pContext;
 560 }
 561
 562
 563 /*
 564     alcProcessContext
 565
 566     Not functional
 567 */
 568 ALCAPI ALCvoid ALCAPIENTRY alcProcessContext(ALCcontext *pContext)
 569 {
 570     // Not a lot happens here !
 571     (void)pContext;
 572 }
 573
 574
 575 /*
 576     alcGetString
 577
 578     Returns information about the Device, and error strings
 579 */
 580 ALCAPI const ALCchar* ALCAPIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
 581 {
 582     const ALCchar *value = NULL;
 583
 584     InitAL();
 585
 586     switch (param)
 587     {
 588     case ALC_NO_ERROR:
 589         value = alcNoError;
 590         break;
 591
 592     case ALC_INVALID_ENUM:
 593         value = alcErrInvalidEnum;
 594         break;
 595
 596     case ALC_INVALID_VALUE:
 597         value = alcErrInvalidValue;
 598         break;
 599
 600     case ALC_INVALID_DEVICE:
 601         value = alcErrInvalidDevice;
 602         break;
 603
 604     case ALC_INVALID_CONTEXT:
 605         value = alcErrInvalidContext;
 606         break;
 607
 608     case ALC_OUT_OF_MEMORY:
 609         value = alcErrOutOfMemory;
 610         break;
 611
 612     case ALC_DEFAULT_DEVICE_SPECIFIER:
 613         value = alcDefaultDeviceSpecifier;
 614         break;
 615
 616     case ALC_DEVICE_SPECIFIER:
 617         if (pDevice)
 618             value = pDevice->szDeviceName;
 619         else
 620             value = alcDeviceList;
 621         break;
 622
 623     case ALC_ALL_DEVICES_SPECIFIER:
 624         value = alcAllDeviceList;
 625         break;
 626
 627     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
 628         value = alcDefaultAllDeviceSpecifier;
 629         break;
 630
 631     case ALC_CAPTURE_DEVICE_SPECIFIER:
 632         if (pDevice)
 633             value = pDevice->szDeviceName;
 634         else
 635             value = alcCaptureDeviceList;
 636         break;
 637
 638     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
 639         value = alcCaptureDefaultDeviceSpecifier;
 640         break;
 641
 642     case ALC_EXTENSIONS:
 643         value = alcExtensionList;
 644         break;
 645
 646     default:
 647         SetALCError(ALC_INVALID_ENUM);
 648         break;
 649     }
 650
 651     return value;
 652 }
 653
 654
 655 /*
 656     alcGetIntegerv
 657
 658     Returns information about the Device and the version of Open AL
 659 */
 660 ALCAPI ALCvoid ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
 661 {
 662     InitAL();
 663
 664     if ((device)&&(device->IsCaptureDevice))
 665     {
 666         SuspendContext(NULL);
 667
 668         // Capture device
 669         switch (param)
 670         {
 671         case ALC_CAPTURE_SAMPLES:
 672             if ((size) && (data))
 673                 *data = ALCdevice_AvailableSamples(device);
 674             else
 675                 SetALCError(ALC_INVALID_VALUE);
 676             break;
 677
 678         default:
 679             SetALCError(ALC_INVALID_ENUM);
 680             break;
 681         }
 682
 683         ProcessContext(NULL);
 684     }
 685     else
 686     {
 687         if(data)
 688         {
 689             // Playback Device
 690             switch (param)
 691             {
 692                 case ALC_MAJOR_VERSION:
 693                     if(!size)
 694                         SetALCError(ALC_INVALID_VALUE);
 695                     else
 696                         *data = alcMajorVersion;
 697                     break;
 698
 699                 case ALC_MINOR_VERSION:
 700                     if(!size)
 701                         SetALCError(ALC_INVALID_VALUE);
 702                     else
 703                         *data = alcMinorVersion;
 704                     break;
 705
 706                 case ALC_EFX_MAJOR_VERSION:
 707                     if(!size)
 708                         SetALCError(ALC_INVALID_VALUE);
 709                     else
 710                         *data = alcEFXMajorVersion;
 711                     break;
 712
 713                 case ALC_EFX_MINOR_VERSION:
 714                     if(!size)
 715                         SetALCError(ALC_INVALID_VALUE);
 716                     else
 717                         *data = alcEFXMinorVersion;
 718                     break;
 719
 720                 case ALC_MAX_AUXILIARY_SENDS:
 721                     if(!size)
 722                         SetALCError(ALC_INVALID_VALUE);
 723                     else
 724                         *data = MAX_SENDS;
 725                     break;
 726
 727                 case ALC_ATTRIBUTES_SIZE:
 728                     if(!device)
 729                         SetALCError(ALC_INVALID_DEVICE);
 730                     else if(!size)
 731                         SetALCError(ALC_INVALID_VALUE);
 732                     else
 733                         *data = 12;
 734                     break;
 735
 736                 case ALC_ALL_ATTRIBUTES:
 737                     if(!device)
 738                         SetALCError(ALC_INVALID_DEVICE);
 739                     else if (size < 7)
 740                         SetALCError(ALC_INVALID_VALUE);
 741                     else
 742                     {
 743                         int i = 0;
 744
 745                         data[i++] = ALC_FREQUENCY;
 746                         data[i++] = device->Frequency;
 747
 748                         data[i++] = ALC_REFRESH;
 749                         data[i++] = device->Frequency / device->UpdateFreq;
 750
 751                         data[i++] = ALC_SYNC;
 752                         data[i++] = ALC_FALSE;
 753
 754                         SuspendContext(NULL);
 755                         if(device->Context && size >= 12)
 756                         {
 757                             data[i++] = ALC_MONO_SOURCES;
 758                             data[i++] = device->Context->lNumMonoSources;
 759
 760                             data[i++] = ALC_STEREO_SOURCES;
 761                             data[i++] = device->Context->lNumStereoSources;
 762
 763                             data[i++] = ALC_MAX_AUXILIARY_SENDS;
 764                             data[i++] = MAX_SENDS;
 765                         }
 766                         ProcessContext(NULL);
 767
 768                         data[i++] = 0;
 769                     }
 770                     break;
 771
 772                 case ALC_FREQUENCY:
 773                     if(!device)
 774                         SetALCError(ALC_INVALID_DEVICE);
 775                     else if(!size)
 776                         SetALCError(ALC_INVALID_VALUE);
 777                     else
 778                         *data = device->Frequency;
 779                     break;
 780
 781                 case ALC_REFRESH:
 782                     if(!device)
 783                         SetALCError(ALC_INVALID_DEVICE);
 784                     else if(!size)
 785                         SetALCError(ALC_INVALID_VALUE);
 786                     else
 787                         *data = device->Frequency / device->UpdateFreq;
 788                     break;
 789
 790                 case ALC_SYNC:
 791                     if(!device)
 792                         SetALCError(ALC_INVALID_DEVICE);
 793                     else if(!size)
 794                         SetALCError(ALC_INVALID_VALUE);
 795                     else
 796                         *data = ALC_FALSE;
 797                     break;
 798
 799                 case ALC_MONO_SOURCES:
 800                     if(!device || !device->Context)
 801                         SetALCError(ALC_INVALID_DEVICE);
 802                     else if (size != 1)
 803                         SetALCError(ALC_INVALID_VALUE);
 804                     else
 805                         *data = device->Context->lNumMonoSources;
 806                     break;
 807
 808                 case ALC_STEREO_SOURCES:
 809                     if(!device || !device->Context)
 810                         SetALCError(ALC_INVALID_DEVICE);
 811                     else if (size != 1)
 812                         SetALCError(ALC_INVALID_VALUE);
 813                     else
 814                         *data = device->Context->lNumStereoSources;
 815                     break;
 816
 817                 default:
 818                     SetALCError(ALC_INVALID_ENUM);
 819                     break;
 820             }
 821         }
 822         else if(size)
 823             SetALCError(ALC_INVALID_VALUE);
 824     }
 825
 826     return;
 827 }
 828
 829
 830 /*
 831     alcIsExtensionPresent
 832
 833     Determines if there is support for a particular extension
 834 */
 835 ALCAPI ALCboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
 836 {
 837     ALCboolean bResult = ALC_FALSE;
 838     ALsizei i = 0;
 839
 840     (void)device;
 841
 842     if (extName)
 843     {
 844         while(alcExtensions[i].extName &&
 845               strcasecmp(alcExtensions[i].extName,extName) != 0)
 846             i++;
 847
 848         if (alcExtensions[i].extName)
 849             bResult = ALC_TRUE;
 850     }
 851     else
 852         SetALCError(ALC_INVALID_VALUE);
 853
 854     return bResult;
 855 }
 856
 857
 858 /*
 859     alcGetProcAddress
 860
 861     Retrieves the function address for a particular extension function
 862 */
 863 ALCAPI ALCvoid *  ALCAPIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
 864 {
 865     ALCvoid *pFunction = NULL;
 866     ALsizei i = 0;
 867
 868     (void)device;
 869
 870     if (funcName)
 871     {
 872         while(alcFunctions[i].funcName &&
 873               strcmp(alcFunctions[i].funcName,funcName) != 0)
 874             i++;
 875         pFunction = alcFunctions[i].address;
 876     }
 877     else
 878         SetALCError(ALC_INVALID_VALUE);
 879
 880     return pFunction;
 881 }
 882
 883
 884 /*
 885     alcGetEnumValue
 886
 887     Get the value for a particular ALC Enumerated Value
 888 */
 889 ALCAPI ALCenum ALCAPIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
 890 {
 891     ALsizei i = 0;
 892     ALCenum val;
 893
 894     (void)device;
 895
 896     while ((enumeration[i].enumName)&&(strcmp(enumeration[i].enumName,enumName)))
 897         i++;
 898     val = enumeration[i].value;
 899
 900     if(!enumeration[i].enumName)
 901         SetALCError(ALC_INVALID_VALUE);
 902
 903     return val;
 904 }
 905
 906
 907 /*
 908     alcCreateContext
 909
 910     Create and attach a Context to a particular Device.
 911 */
 912 ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
 913 {
 914     ALCcontext *ALContext = NULL;
 915     ALuint      ulAttributeIndex, ulRequestedStereoSources;
 916
 917     if ((device)&&(!device->IsCaptureDevice))
 918     {
 919         // Reset Context Last Error code
 920         g_eLastContextError = ALC_NO_ERROR;
 921
 922         // Current implementation only allows one Context per Device
 923         if(!device->Context)
 924         {
 925             ALContext = calloc(1, sizeof(ALCcontext));
 926             if(!ALContext)
 927             {
 928                 SetALCError(ALC_OUT_OF_MEMORY);
 929                 return NULL;
 930             }
 931
 932             ALContext->Device = device;
 933             InitContext(ALContext);
 934
 935             device->Context = ALContext;
 936
 937             SuspendContext(NULL);
 938
 939             ALContext->next = g_pContextList;
 940             g_pContextList = ALContext;
 941             g_ulContextCount++;
 942
 943             ProcessContext(NULL);
 944
 945             // Check for Voice Count attributes
 946             if (attrList)
 947             {
 948                 ulAttributeIndex = 0;
 949                 while ((ulAttributeIndex < 10) && (attrList[ulAttributeIndex]))
 950                 {
 951                     if (attrList[ulAttributeIndex] == ALC_STEREO_SOURCES)
 952                     {
 953                         ulRequestedStereoSources = attrList[ulAttributeIndex + 1];
 954
 955                         if (ulRequestedStereoSources > ALContext->Device->MaxNoOfSources)
 956                             ulRequestedStereoSources = ALContext->Device->MaxNoOfSources;
 957
 958                         ALContext->lNumStereoSources = ulRequestedStereoSources;
 959                         ALContext->lNumMonoSources = ALContext->Device->MaxNoOfSources - ALContext->lNumStereoSources;
 960                         break;
 961                     }
 962
 963                     ulAttributeIndex += 2;
 964                 }
 965             }
 966         }
 967         else
 968         {
 969             SetALCError(ALC_INVALID_VALUE);
 970             ALContext = NULL;
 971         }
 972     }
 973     else
 974         SetALCError(ALC_INVALID_DEVICE);
 975
 976     return ALContext;
 977 }
 978
 979
 980 /*
 981     alcDestroyContext
 982
 983     Remove a Context
 984 */
 985 ALCAPI ALCvoid ALCAPIENTRY alcDestroyContext(ALCcontext *context)
 986 {
 987     ALCcontext **list;
 988
 989     // Lock context list
 990     SuspendContext(NULL);
 991
 992     if (IsContext(context))
 993     {
 994         // Lock context
 995         SuspendContext(context);
 996
 997         ReleaseALSources(context);
 998         ReleaseALAuxiliaryEffectSlots(context);
 999
1000         context->Device->Context = NULL;
1001
1002         list = &g_pContextList;
1003         while(*list != context)
1004             list = &(*list)->next;
1005
1006         *list = (*list)->next;
1007         g_ulContextCount--;
1008
1009         // Unlock context
1010         ProcessContext(context);
1011
1012         ExitContext(context);
1013
1014         // Free memory (MUST do this after ProcessContext)
1015         memset(context, 0, sizeof(ALCcontext));
1016         free(context);
1017     }
1018     else
1019         SetALCError(ALC_INVALID_CONTEXT);
1020
1021     ProcessContext(NULL);
1022 }
1023
1024
1025 /*
1026     alcGetCurrentContext
1027
1028     Returns the currently active Context
1029 */
1030 ALCAPI ALCcontext * ALCAPIENTRY alcGetCurrentContext(ALCvoid)
1031 {
1032     ALCcontext *pContext = NULL;
1033
1034     SuspendContext(NULL);
1035
1036     pContext = g_pContextList;
1037     while ((pContext) && (!pContext->InUse))
1038         pContext = pContext->next;
1039
1040     ProcessContext(NULL);
1041
1042     return pContext;
1043 }
1044
1045
1046 /*
1047     alcGetContextsDevice
1048
1049     Returns the Device that a particular Context is attached to
1050 */
1051 ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext *pContext)
1052 {
1053     ALCdevice *pDevice = NULL;
1054
1055     SuspendContext(NULL);
1056     if (IsContext(pContext))
1057         pDevice = pContext->Device;
1058     else
1059         SetALCError(ALC_INVALID_CONTEXT);
1060     ProcessContext(NULL);
1061
1062     return pDevice;
1063 }
1064
1065
1066 /*
1067     alcMakeContextCurrent
1068
1069     Makes the given Context the active Context
1070 */
1071 ALCAPI ALCboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext *context)
1072 {
1073     ALCcontext *ALContext;
1074     ALboolean bReturn = AL_TRUE;
1075
1076     SuspendContext(NULL);
1077
1078     // context must be a valid Context or NULL
1079     if ((IsContext(context)) || (context == NULL))
1080     {
1081         if ((ALContext=alcGetCurrentContext()))
1082         {
1083             SuspendContext(ALContext);
1084             ALContext->InUse=AL_FALSE;
1085             ProcessContext(ALContext);
1086         }
1087
1088         if ((ALContext=context) && (ALContext->Device))
1089         {
1090             SuspendContext(ALContext);
1091             ALContext->InUse=AL_TRUE;
1092             ProcessContext(ALContext);
1093         }
1094     }
1095     else
1096     {
1097         SetALCError(ALC_INVALID_CONTEXT);
1098         bReturn = AL_FALSE;
1099     }
1100
1101     ProcessContext(NULL);
1102
1103     return bReturn;
1104 }
1105
1106
1107 /*
1108     alcOpenDevice
1109
1110     Open the Device specified.
1111 */
1112 ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(const ALCchar *deviceName)
1113 {
1114     ALboolean bDeviceFound = AL_FALSE;
1115     ALCdevice *device;
1116     ALint i;
1117
1118     InitAL();
1119
1120     if(deviceName && !deviceName[0])
1121         deviceName = NULL;
1122
1123     device = malloc(sizeof(ALCdevice));
1124     if (device)
1125     {
1126         const char *fmt;
1127
1128         //Initialise device structure
1129         memset(device, 0, sizeof(ALCdevice));
1130
1131         //Validate device
1132         device->InUse = AL_TRUE;
1133         device->IsCaptureDevice = AL_FALSE;
1134
1135         //Set output format
1136         device->Frequency = GetConfigValueInt(NULL, "frequency", SWMIXER_OUTPUT_RATE);
1137         if((ALint)device->Frequency <= 0)
1138             device->Frequency = SWMIXER_OUTPUT_RATE;
1139
1140         fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
1141         if(fmt[0])
1142             device->Format = alGetEnumValue(fmt);
1143
1144         device->Channels = aluChannelsFromFormat(device->Format);
1145         if(!device->Channels)
1146         {
1147             device->Format = AL_FORMAT_STEREO16;
1148             device->Channels = 2;
1149             device->FrameSize = 4;
1150         }
1151         else
1152             device->FrameSize = aluBytesFromFormat(device->Format) *
1153                                 device->Channels;
1154
1155         device->UpdateFreq = GetConfigValueInt(NULL, "refresh", 8192);
1156         if((ALint)device->UpdateFreq <= 0)
1157             device->UpdateFreq = 8192;
1158
1159         device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
1160         if((ALint)device->MaxNoOfSources <= 0)
1161             device->MaxNoOfSources = 256;
1162
1163         // Find a playback device to open
1164         for(i = 0;BackendList[i].Init;i++)
1165         {
1166             device->Funcs = &BackendList[i].Funcs;
1167             if(ALCdevice_OpenPlayback(device, deviceName))
1168             {
1169                 SuspendContext(NULL);
1170                 device->next = g_pDeviceList;
1171                 g_pDeviceList = device;
1172                 g_ulDeviceCount++;
1173                 ProcessContext(NULL);
1174
1175                 bDeviceFound = AL_TRUE;
1176                 break;
1177             }
1178         }
1179
1180         if (!bDeviceFound)
1181         {
1182             // No suitable output device found
1183             free(device);
1184             device = NULL;
1185         }
1186     }
1187
1188     return device;
1189 }
1190
1191
1192 /*
1193     alcCloseDevice
1194
1195     Close the specified Device
1196 */
1197 ALCAPI ALCboolean ALCAPIENTRY alcCloseDevice(ALCdevice *pDevice)
1198 {
1199     ALCboolean bReturn = ALC_FALSE;
1200     ALCdevice **list;
1201
1202     if ((pDevice)&&(!pDevice->IsCaptureDevice))
1203     {
1204         SuspendContext(NULL);
1205
1206         list = &g_pDeviceList;
1207         while(*list != pDevice)
1208             list = &(*list)->next;
1209
1210         *list = (*list)->next;
1211         g_ulDeviceCount--;
1212
1213         ProcessContext(NULL);
1214
1215         if(pDevice->Context)
1216             alcDestroyContext(pDevice->Context);
1217         ALCdevice_ClosePlayback(pDevice);
1218
1219         //Release device structure
1220         memset(pDevice, 0, sizeof(ALCdevice));
1221         free(pDevice);
1222
1223         bReturn = ALC_TRUE;
1224     }
1225     else
1226         SetALCError(ALC_INVALID_DEVICE);
1227
1228     return bReturn;
1229 }
1230
1231
1232 ALCvoid ReleaseALC(ALCvoid)
1233 {
1234     ALCdevice *Dev;
1235
1236 #ifdef _DEBUG
1237     if(g_ulContextCount > 0)
1238         AL_PRINT("exit() %u device(s) and %u context(s) NOT deleted\n", g_ulDeviceCount, g_ulContextCount);
1239 #endif
1240
1241     while(g_pDeviceList)
1242     {
1243         Dev = g_pDeviceList;
1244         g_pDeviceList = g_pDeviceList->next;
1245         if(Dev->IsCaptureDevice)
1246             alcCaptureCloseDevice(Dev);
1247         else
1248             alcCloseDevice(Dev);
1249     }
1250 }
1251
1252 ///////////////////////////////////////////////////////