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 szDebug[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(&g_mutex);
 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(&g_mutex);
 307 }
 308
 309
 310 /*
 311     ProcessContext
 312
 313     Thread-safe exit
 314 */
 315 ALCvoid ProcessContext(ALCcontext *pContext)
 316 {
 317     (void)pContext;
 318     LeaveCriticalSection(&g_mutex);
 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_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     pDevice = malloc(sizeof(ALCdevice));
 413     if (pDevice)
 414     {
 415         if (SampleSize > 0)
 416         {
 417             //Initialise device structure
 418             memset(pDevice, 0, sizeof(ALCdevice));
 419
 420             //Validate device
 421             pDevice->InUse = AL_TRUE;
 422             pDevice->IsCaptureDevice = AL_TRUE;
 423
 424             pDevice->Frequency = frequency;
 425             pDevice->Format = format;
 426             pDevice->Channels = aluChannelsFromFormat(format);
 427             pDevice->FrameSize = aluBytesFromFormat(format) *
 428                                  pDevice->Channels;
 429
 430             for(i = 0;BackendList[i].Init;i++)
 431             {
 432                 pDevice->Funcs = &BackendList[i].Funcs;
 433                 if(ALCdevice_OpenCapture(pDevice, deviceName, frequency, format, SampleSize))
 434                 {
 435                     DeviceFound = ALC_TRUE;
 436                     break;
 437                 }
 438             }
 439         }
 440         else
 441             SetALCError(ALC_INVALID_VALUE);
 442
 443         if(!DeviceFound)
 444         {
 445             free(pDevice);
 446             pDevice = NULL;
 447         }
 448     }
 449     else
 450         SetALCError(ALC_OUT_OF_MEMORY);
 451
 452     return pDevice;
 453 }
 454
 455 ALCAPI ALCboolean ALCAPIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
 456 {
 457     ALCboolean bReturn = ALC_FALSE;
 458
 459     if ((pDevice)&&(pDevice->IsCaptureDevice))
 460     {
 461         ALCdevice_CloseCapture(pDevice);
 462         free(pDevice);
 463
 464         bReturn = ALC_TRUE;
 465     }
 466     else
 467         SetALCError(ALC_INVALID_DEVICE);
 468
 469     return bReturn;
 470 }
 471
 472 ALCAPI void ALCAPIENTRY alcCaptureStart(ALCdevice *pDevice)
 473 {
 474     if ((pDevice)&&(pDevice->IsCaptureDevice))
 475         ALCdevice_StartCapture(pDevice);
 476     else
 477         SetALCError(ALC_INVALID_DEVICE);
 478 }
 479
 480 ALCAPI void ALCAPIENTRY alcCaptureStop(ALCdevice *pDevice)
 481 {
 482     if ((pDevice)&&(pDevice->IsCaptureDevice))
 483         ALCdevice_StopCapture(pDevice);
 484     else
 485         SetALCError(ALC_INVALID_DEVICE);
 486 }
 487
 488 ALCAPI void ALCAPIENTRY alcCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCsizei lSamples)
 489 {
 490     if ((pDevice) && (pDevice->IsCaptureDevice))
 491         ALCdevice_CaptureSamples(pDevice, pBuffer, lSamples);
 492     else
 493         SetALCError(ALC_INVALID_DEVICE);
 494 }
 495
 496 /*
 497     alcGetError
 498
 499     Return last ALC generated error code
 500 */
 501 ALCAPI ALCenum ALCAPIENTRY alcGetError(ALCdevice *device)
 502 {
 503     ALCenum errorCode;
 504
 505     (void)device;
 506
 507     errorCode = g_eLastContextError;
 508     g_eLastContextError = ALC_NO_ERROR;
 509     return errorCode;
 510 }
 511
 512
 513 /*
 514     alcSuspendContext
 515
 516     Not functional
 517 */
 518 ALCAPI ALCvoid ALCAPIENTRY alcSuspendContext(ALCcontext *pContext)
 519 {
 520     // Not a lot happens here !
 521     (void)pContext;
 522 }
 523
 524
 525 /*
 526     alcProcessContext
 527
 528     Not functional
 529 */
 530 ALCAPI ALCvoid ALCAPIENTRY alcProcessContext(ALCcontext *pContext)
 531 {
 532     // Not a lot happens here !
 533     (void)pContext;
 534 }
 535
 536
 537 /*
 538     alcGetString
 539
 540     Returns information about the Device, and error strings
 541 */
 542 ALCAPI const ALCchar* ALCAPIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
 543 {
 544     const ALCchar *value = NULL;
 545
 546     InitAL();
 547
 548     switch (param)
 549     {
 550     case ALC_NO_ERROR:
 551         value = alcNoError;
 552         break;
 553
 554     case ALC_INVALID_ENUM:
 555         value = alcErrInvalidEnum;
 556         break;
 557
 558     case ALC_INVALID_VALUE:
 559         value = alcErrInvalidValue;
 560         break;
 561
 562     case ALC_INVALID_DEVICE:
 563         value = alcErrInvalidDevice;
 564         break;
 565
 566     case ALC_INVALID_CONTEXT:
 567         value = alcErrInvalidContext;
 568         break;
 569
 570     case ALC_OUT_OF_MEMORY:
 571         value = alcErrOutOfMemory;
 572         break;
 573
 574     case ALC_DEFAULT_DEVICE_SPECIFIER:
 575         value = alcDefaultDeviceSpecifier;
 576         break;
 577
 578     case ALC_DEVICE_SPECIFIER:
 579         if (pDevice)
 580             value = pDevice->szDeviceName;
 581         else
 582             value = alcDeviceList;
 583         break;
 584
 585     case ALC_ALL_DEVICES_SPECIFIER:
 586         value = alcAllDeviceList;
 587         break;
 588
 589     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
 590         value = alcDefaultAllDeviceSpecifier;
 591         break;
 592
 593     case ALC_CAPTURE_DEVICE_SPECIFIER:
 594         if (pDevice)
 595             value = pDevice->szDeviceName;
 596         else
 597             value = alcCaptureDeviceList;
 598         break;
 599
 600     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
 601         value = alcCaptureDefaultDeviceSpecifier;
 602         break;
 603
 604     case ALC_EXTENSIONS:
 605         value = alcExtensionList;
 606         break;
 607
 608     default:
 609         SetALCError(ALC_INVALID_ENUM);
 610         break;
 611     }
 612
 613     return value;
 614 }
 615
 616
 617 /*
 618     alcGetIntegerv
 619
 620     Returns information about the Device and the version of Open AL
 621 */
 622 ALCAPI ALCvoid ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
 623 {
 624     InitAL();
 625
 626     if ((device)&&(device->IsCaptureDevice))
 627     {
 628         SuspendContext(NULL);
 629
 630         // Capture device
 631         switch (param)
 632         {
 633         case ALC_CAPTURE_SAMPLES:
 634             if ((size) && (data))
 635                 *data = ALCdevice_AvailableSamples(device);
 636             else
 637                 SetALCError(ALC_INVALID_VALUE);
 638             break;
 639
 640         default:
 641             SetALCError(ALC_INVALID_ENUM);
 642             break;
 643         }
 644
 645         ProcessContext(NULL);
 646     }
 647     else
 648     {
 649         if(data)
 650         {
 651             // Playback Device
 652             switch (param)
 653             {
 654                 case ALC_MAJOR_VERSION:
 655                     if(!size)
 656                         SetALCError(ALC_INVALID_VALUE);
 657                     else
 658                         *data = alcMajorVersion;
 659                     break;
 660
 661                 case ALC_MINOR_VERSION:
 662                     if(!size)
 663                         SetALCError(ALC_INVALID_VALUE);
 664                     else
 665                         *data = alcMinorVersion;
 666                     break;
 667
 668                 case ALC_ATTRIBUTES_SIZE:
 669                     if(!device)
 670                         SetALCError(ALC_INVALID_DEVICE);
 671                     else if(!size)
 672                         SetALCError(ALC_INVALID_VALUE);
 673                     else
 674                         *data = 11;
 675                     break;
 676
 677                 case ALC_ALL_ATTRIBUTES:
 678                     if(!device)
 679                         SetALCError(ALC_INVALID_DEVICE);
 680                     else if (size < 7)
 681                         SetALCError(ALC_INVALID_VALUE);
 682                     else
 683                     {
 684                         int i = 0;
 685
 686                         data[i++] = ALC_FREQUENCY;
 687                         data[i++] = device->Frequency;
 688
 689                         data[i++] = ALC_REFRESH;
 690                         data[i++] = device->UpdateFreq;
 691
 692                         data[i++] = ALC_SYNC;
 693                         data[i++] = ALC_FALSE;
 694
 695                         SuspendContext(NULL);
 696                         if(device->Context && size >= 11)
 697                         {
 698                             data[i++] = ALC_MONO_SOURCES;
 699                             data[i++] = device->Context->lNumMonoSources;
 700
 701                             data[i++] = ALC_STEREO_SOURCES;
 702                             data[i++] = device->Context->lNumStereoSources;
 703                         }
 704                         ProcessContext(NULL);
 705
 706                         data[i++] = 0;
 707                     }
 708                     break;
 709
 710                 case ALC_FREQUENCY:
 711                     if(!device)
 712                         SetALCError(ALC_INVALID_DEVICE);
 713                     else if(!size)
 714                         SetALCError(ALC_INVALID_VALUE);
 715                     else
 716                         *data = device->Frequency;
 717                     break;
 718
 719                 case ALC_REFRESH:
 720                     if(!device)
 721                         SetALCError(ALC_INVALID_DEVICE);
 722                     else if(!size)
 723                         SetALCError(ALC_INVALID_VALUE);
 724                     else
 725                         *data = device->UpdateFreq;
 726                     break;
 727
 728                 case ALC_SYNC:
 729                     if(!device)
 730                         SetALCError(ALC_INVALID_DEVICE);
 731                     else if(!size)
 732                         SetALCError(ALC_INVALID_VALUE);
 733                     else
 734                         *data = ALC_FALSE;
 735                     break;
 736
 737                 default:
 738                     SetALCError(ALC_INVALID_ENUM);
 739                     break;
 740             }
 741         }
 742         else if(size)
 743             SetALCError(ALC_INVALID_VALUE);
 744     }
 745
 746     return;
 747 }
 748
 749
 750 /*
 751     alcIsExtensionPresent
 752
 753     Determines if there is support for a particular extension
 754 */
 755 ALCAPI ALCboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
 756 {
 757     ALCboolean bResult = ALC_FALSE;
 758     ALsizei i = 0;
 759
 760     (void)device;
 761
 762     if (extName)
 763     {
 764         while(alcExtensions[i].extName &&
 765               strcasecmp(alcExtensions[i].extName,extName) != 0)
 766             i++;
 767
 768         if (alcExtensions[i].extName)
 769             bResult = ALC_TRUE;
 770     }
 771     else
 772         SetALCError(ALC_INVALID_VALUE);
 773
 774     return bResult;
 775 }
 776
 777
 778 /*
 779     alcGetProcAddress
 780
 781     Retrieves the function address for a particular extension function
 782 */
 783 ALCAPI ALCvoid *  ALCAPIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
 784 {
 785     ALCvoid *pFunction = NULL;
 786     ALsizei i = 0;
 787
 788     (void)device;
 789
 790     if (funcName)
 791     {
 792         while(alcFunctions[i].funcName &&
 793               strcmp(alcFunctions[i].funcName,funcName) != 0)
 794             i++;
 795         pFunction = alcFunctions[i].address;
 796     }
 797     else
 798         SetALCError(ALC_INVALID_VALUE);
 799
 800     return pFunction;
 801 }
 802
 803
 804 /*
 805     alcGetEnumValue
 806
 807     Get the value for a particular ALC Enumerated Value
 808 */
 809 ALCAPI ALCenum ALCAPIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
 810 {
 811     ALsizei i = 0;
 812     ALCenum val;
 813
 814     (void)device;
 815
 816     while ((enumeration[i].enumName)&&(strcmp(enumeration[i].enumName,enumName)))
 817         i++;
 818     val = enumeration[i].value;
 819
 820     if(!enumeration[i].enumName)
 821         SetALCError(ALC_INVALID_VALUE);
 822
 823     return val;
 824 }
 825
 826
 827 /*
 828     alcCreateContext
 829
 830     Create and attach a Context to a particular Device.
 831 */
 832 ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
 833 {
 834     ALCcontext *ALContext = NULL;
 835     ALuint      ulAttributeIndex, ulRequestedStereoSources;
 836
 837     if ((device)&&(!device->IsCaptureDevice))
 838     {
 839         // Reset Context Last Error code
 840         g_eLastContextError = ALC_NO_ERROR;
 841
 842         // Current implementation only allows one Context per Device
 843         if(!device->Context)
 844         {
 845             ALContext = calloc(1, sizeof(ALCcontext));
 846             if(!ALContext)
 847             {
 848                 SetALCError(ALC_OUT_OF_MEMORY);
 849                 return NULL;
 850             }
 851
 852             ALContext->Device = device;
 853             InitContext(ALContext);
 854
 855             device->Context = ALContext;
 856
 857             SuspendContext(NULL);
 858
 859             ALContext->next = g_pContextList;
 860             g_pContextList = ALContext;
 861             g_ulContextCount++;
 862
 863             ProcessContext(NULL);
 864
 865             // Check for Voice Count attributes
 866             if (attrList)
 867             {
 868                 ulAttributeIndex = 0;
 869                 while ((ulAttributeIndex < 10) && (attrList[ulAttributeIndex]))
 870                 {
 871                     if (attrList[ulAttributeIndex] == ALC_STEREO_SOURCES)
 872                     {
 873                         ulRequestedStereoSources = attrList[ulAttributeIndex + 1];
 874
 875                         if (ulRequestedStereoSources > ALContext->Device->MaxNoOfSources)
 876                             ulRequestedStereoSources = ALContext->Device->MaxNoOfSources;
 877
 878                         ALContext->lNumStereoSources = ulRequestedStereoSources;
 879                         ALContext->lNumMonoSources = ALContext->Device->MaxNoOfSources - ALContext->lNumStereoSources;
 880                         break;
 881                     }
 882
 883                     ulAttributeIndex += 2;
 884                 }
 885             }
 886         }
 887         else
 888         {
 889             SetALCError(ALC_INVALID_VALUE);
 890             ALContext = NULL;
 891         }
 892     }
 893     else
 894         SetALCError(ALC_INVALID_DEVICE);
 895
 896     return ALContext;
 897 }
 898
 899
 900 /*
 901     alcDestroyContext
 902
 903     Remove a Context
 904 */
 905 ALCAPI ALCvoid ALCAPIENTRY alcDestroyContext(ALCcontext *context)
 906 {
 907     ALCcontext **list;
 908
 909     // Lock context list
 910     SuspendContext(NULL);
 911
 912     if (IsContext(context))
 913     {
 914         // Lock context
 915         SuspendContext(context);
 916
 917         context->Device->Context = NULL;
 918
 919         list = &g_pContextList;
 920         while(*list != context)
 921             list = &(*list)->next;
 922
 923         *list = (*list)->next;
 924         g_ulContextCount--;
 925
 926         // Unlock context
 927         ProcessContext(context);
 928
 929         ExitContext(context);
 930
 931         // Free memory (MUST do this after ProcessContext)
 932         memset(context, 0, sizeof(ALCcontext));
 933         free(context);
 934     }
 935     else
 936         SetALCError(ALC_INVALID_CONTEXT);
 937
 938     ProcessContext(NULL);
 939 }
 940
 941
 942 /*
 943     alcGetCurrentContext
 944
 945     Returns the currently active Context
 946 */
 947 ALCAPI ALCcontext * ALCAPIENTRY alcGetCurrentContext(ALCvoid)
 948 {
 949     ALCcontext *pContext = NULL;
 950
 951     SuspendContext(NULL);
 952
 953     pContext = g_pContextList;
 954     while ((pContext) && (!pContext->InUse))
 955         pContext = pContext->next;
 956
 957     ProcessContext(NULL);
 958
 959     return pContext;
 960 }
 961
 962
 963 /*
 964     alcGetContextsDevice
 965
 966     Returns the Device that a particular Context is attached to
 967 */
 968 ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext *pContext)
 969 {
 970     ALCdevice *pDevice = NULL;
 971
 972     SuspendContext(NULL);
 973     if (IsContext(pContext))
 974         pDevice = pContext->Device;
 975     else
 976         SetALCError(ALC_INVALID_CONTEXT);
 977     ProcessContext(NULL);
 978
 979     return pDevice;
 980 }
 981
 982
 983 /*
 984     alcMakeContextCurrent
 985
 986     Makes the given Context the active Context
 987 */
 988 ALCAPI ALCboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext *context)
 989 {
 990     ALCcontext *ALContext;
 991     ALboolean bReturn = AL_TRUE;
 992
 993     SuspendContext(NULL);
 994
 995     // context must be a valid Context or NULL
 996     if ((IsContext(context)) || (context == NULL))
 997     {
 998         if ((ALContext=alcGetCurrentContext()))
 999         {
1000             SuspendContext(ALContext);
1001             ALContext->InUse=AL_FALSE;
1002             ProcessContext(ALContext);
1003         }
1004
1005         if ((ALContext=context) && (ALContext->Device))
1006         {
1007             SuspendContext(ALContext);
1008             ALContext->InUse=AL_TRUE;
1009             ProcessContext(ALContext);
1010         }
1011     }
1012     else
1013     {
1014         SetALCError(ALC_INVALID_CONTEXT);
1015         bReturn = AL_FALSE;
1016     }
1017
1018     ProcessContext(NULL);
1019
1020     return bReturn;
1021 }
1022
1023
1024 /*
1025     alcOpenDevice
1026
1027     Open the Device specified.
1028 */
1029 ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(const ALCchar *deviceName)
1030 {
1031     ALboolean bDeviceFound = AL_FALSE;
1032     ALCdevice *device;
1033     ALint i;
1034
1035     InitAL();
1036
1037     device = malloc(sizeof(ALCdevice));
1038     if (device)
1039     {
1040         const char *fmt;
1041
1042         //Initialise device structure
1043         memset(device, 0, sizeof(ALCdevice));
1044
1045         //Validate device
1046         device->InUse = AL_TRUE;
1047         device->IsCaptureDevice = AL_FALSE;
1048
1049         //Set output format
1050         device->Frequency = GetConfigValueInt(NULL, "frequency", SWMIXER_OUTPUT_RATE);
1051         if((ALint)device->Frequency <= 0)
1052             device->Frequency = SWMIXER_OUTPUT_RATE;
1053
1054         fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
1055         if(fmt[0])
1056             device->Format = alGetEnumValue(fmt);
1057
1058         device->Channels = aluChannelsFromFormat(device->Format);
1059         if(!device->Channels)
1060         {
1061             device->Format = AL_FORMAT_STEREO16;
1062             device->Channels = 2;
1063             device->FrameSize = 4;
1064         }
1065         else
1066             device->FrameSize = aluBytesFromFormat(device->Format) *
1067                                 device->Channels;
1068
1069         device->UpdateFreq = GetConfigValueInt(NULL, "refresh", 0);
1070         if((ALint)device->UpdateFreq <= 0)
1071             device->UpdateFreq = 8192 * device->Frequency / 22050;
1072
1073         // Find a playback device to open
1074         for(i = 0;BackendList[i].Init;i++)
1075         {
1076             device->Funcs = &BackendList[i].Funcs;
1077             if(ALCdevice_OpenPlayback(device, deviceName))
1078             {
1079                 bDeviceFound = AL_TRUE;
1080                 break;
1081             }
1082         }
1083
1084         if (!bDeviceFound)
1085         {
1086             // No suitable output device found
1087             free(device);
1088             device = NULL;
1089         }
1090     }
1091
1092     return device;
1093 }
1094
1095
1096 /*
1097     alcCloseDevice
1098
1099     Close the specified Device
1100 */
1101 ALCAPI ALCboolean ALCAPIENTRY alcCloseDevice(ALCdevice *pDevice)
1102 {
1103     ALCboolean bReturn = ALC_FALSE;
1104
1105     if ((pDevice)&&(!pDevice->IsCaptureDevice))
1106     {
1107         ALCdevice_ClosePlayback(pDevice);
1108
1109         //Release device structure
1110         memset(pDevice, 0, sizeof(ALCdevice));
1111         free(pDevice);
1112
1113         bReturn = ALC_TRUE;
1114     }
1115     else
1116         SetALCError(ALC_INVALID_DEVICE);
1117
1118     return bReturn;
1119 }
1120 ///////////////////////////////////////////////////////