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