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