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