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