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