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 #include "config.h"
  22
  23 #include <math.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <memory.h>
  27 #include <ctype.h>
  28 #include "alMain.h"
  29 #include "alSource.h"
  30 #include "AL/al.h"
  31 #include "AL/alc.h"
  32 #include "alThunk.h"
  33 #include "alSource.h"
  34 #include "alBuffer.h"
  35 #include "alExtension.h"
  36 #include "alAuxEffectSlot.h"
  37 #include "alDatabuffer.h"
  38 #include "bs2b.h"
  39 #include "alu.h"
  40
  41
  42 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
  43 typedef struct BackendInfo {
  44     const char *name;
  45     void (*Init)(BackendFuncs*);
  46     void (*Deinit)(void);
  47     void (*Probe)(int);
  48     BackendFuncs Funcs;
  49 } BackendInfo;
  50 static BackendInfo BackendList[] = {
  51 #ifdef HAVE_PULSEAUDIO
  52     { "pulse", alc_pulse_init, alc_pulse_deinit, alc_pulse_probe, EmptyFuncs },
  53 #endif
  54 #ifdef HAVE_ALSA
  55     { "alsa", alc_alsa_init, alc_alsa_deinit, alc_alsa_probe, EmptyFuncs },
  56 #endif
  57 #ifdef HAVE_OSS
  58     { "oss", alc_oss_init, alc_oss_deinit, alc_oss_probe, EmptyFuncs },
  59 #endif
  60 #ifdef HAVE_SOLARIS
  61     { "solaris", alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },
  62 #endif
  63 #ifdef HAVE_DSOUND
  64     { "dsound", alcDSoundInit, alcDSoundDeinit, alcDSoundProbe, EmptyFuncs },
  65 #endif
  66 #ifdef HAVE_WINMM
  67     { "winmm", alcWinMMInit, alcWinMMDeinit, alcWinMMProbe, EmptyFuncs },
  68 #endif
  69 #ifdef HAVE_PORTAUDIO
  70     { "port", alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
  71 #endif
  72
  73     { "wave", alc_wave_init, alc_wave_deinit, alc_wave_probe, EmptyFuncs },
  74
  75     { NULL, NULL, NULL, NULL, EmptyFuncs }
  76 };
  77 #undef EmptyFuncs
  78
  79 ///////////////////////////////////////////////////////
  80
  81 #define ALC_EFX_MAJOR_VERSION                              0x20001
  82 #define ALC_EFX_MINOR_VERSION                              0x20002
  83 #define ALC_MAX_AUXILIARY_SENDS                            0x20003
  84
  85 ///////////////////////////////////////////////////////
  86 // STRING and EXTENSIONS
  87
  88 typedef struct ALCfunction_struct
  89 {
  90     ALCchar        *funcName;
  91     ALvoid        *address;
  92 } ALCfunction;
  93
  94 static ALCfunction  alcFunctions[] = {
  95     { "alcCreateContext",           (ALvoid *) alcCreateContext         },
  96     { "alcMakeContextCurrent",      (ALvoid *) alcMakeContextCurrent    },
  97     { "alcProcessContext",          (ALvoid *) alcProcessContext        },
  98     { "alcSuspendContext",          (ALvoid *) alcSuspendContext        },
  99     { "alcDestroyContext",          (ALvoid *) alcDestroyContext        },
 100     { "alcGetCurrentContext",       (ALvoid *) alcGetCurrentContext     },
 101     { "alcGetContextsDevice",       (ALvoid *) alcGetContextsDevice     },
 102     { "alcOpenDevice",              (ALvoid *) alcOpenDevice            },
 103     { "alcCloseDevice",             (ALvoid *) alcCloseDevice           },
 104     { "alcGetError",                (ALvoid *) alcGetError              },
 105     { "alcIsExtensionPresent",      (ALvoid *) alcIsExtensionPresent    },
 106     { "alcGetProcAddress",          (ALvoid *) alcGetProcAddress        },
 107     { "alcGetEnumValue",            (ALvoid *) alcGetEnumValue          },
 108     { "alcGetString",               (ALvoid *) alcGetString             },
 109     { "alcGetIntegerv",             (ALvoid *) alcGetIntegerv           },
 110     { "alcCaptureOpenDevice",       (ALvoid *) alcCaptureOpenDevice     },
 111     { "alcCaptureCloseDevice",      (ALvoid *) alcCaptureCloseDevice    },
 112     { "alcCaptureStart",            (ALvoid *) alcCaptureStart          },
 113     { "alcCaptureStop",             (ALvoid *) alcCaptureStop           },
 114     { "alcCaptureSamples",          (ALvoid *) alcCaptureSamples        },
 115
 116     { "alcSetThreadContext",        (ALvoid *) alcSetThreadContext      },
 117     { "alcGetThreadContext",        (ALvoid *) alcGetThreadContext      },
 118
 119     { NULL,                         (ALvoid *) NULL                     }
 120 };
 121
 122 static ALenums enumeration[]={
 123     // Types
 124     { (ALchar *)"ALC_INVALID",                          ALC_INVALID                         },
 125     { (ALchar *)"ALC_FALSE",                            ALC_FALSE                           },
 126     { (ALchar *)"ALC_TRUE",                             ALC_TRUE                            },
 127
 128     // ALC Properties
 129     { (ALchar *)"ALC_MAJOR_VERSION",                    ALC_MAJOR_VERSION                   },
 130     { (ALchar *)"ALC_MINOR_VERSION",                    ALC_MINOR_VERSION                   },
 131     { (ALchar *)"ALC_ATTRIBUTES_SIZE",                  ALC_ATTRIBUTES_SIZE                 },
 132     { (ALchar *)"ALC_ALL_ATTRIBUTES",                   ALC_ALL_ATTRIBUTES                  },
 133     { (ALchar *)"ALC_DEFAULT_DEVICE_SPECIFIER",         ALC_DEFAULT_DEVICE_SPECIFIER        },
 134     { (ALchar *)"ALC_DEVICE_SPECIFIER",                 ALC_DEVICE_SPECIFIER                },
 135     { (ALchar *)"ALC_ALL_DEVICES_SPECIFIER",            ALC_ALL_DEVICES_SPECIFIER           },
 136     { (ALchar *)"ALC_DEFAULT_ALL_DEVICES_SPECIFIER",    ALC_DEFAULT_ALL_DEVICES_SPECIFIER   },
 137     { (ALchar *)"ALC_EXTENSIONS",                       ALC_EXTENSIONS                      },
 138     { (ALchar *)"ALC_FREQUENCY",                        ALC_FREQUENCY                       },
 139     { (ALchar *)"ALC_REFRESH",                          ALC_REFRESH                         },
 140     { (ALchar *)"ALC_SYNC",                             ALC_SYNC                            },
 141     { (ALchar *)"ALC_MONO_SOURCES",                     ALC_MONO_SOURCES                    },
 142     { (ALchar *)"ALC_STEREO_SOURCES",                   ALC_STEREO_SOURCES                  },
 143     { (ALchar *)"ALC_CAPTURE_DEVICE_SPECIFIER",         ALC_CAPTURE_DEVICE_SPECIFIER        },
 144     { (ALchar *)"ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},
 145     { (ALchar *)"ALC_CAPTURE_SAMPLES",                  ALC_CAPTURE_SAMPLES                 },
 146
 147     // EFX Properties
 148     { (ALchar *)"ALC_EFX_MAJOR_VERSION",                ALC_EFX_MAJOR_VERSION               },
 149     { (ALchar *)"ALC_EFX_MINOR_VERSION",                ALC_EFX_MINOR_VERSION               },
 150     { (ALchar *)"ALC_MAX_AUXILIARY_SENDS",              ALC_MAX_AUXILIARY_SENDS             },
 151
 152     // ALC Error Message
 153     { (ALchar *)"ALC_NO_ERROR",                         ALC_NO_ERROR                        },
 154     { (ALchar *)"ALC_INVALID_DEVICE",                   ALC_INVALID_DEVICE                  },
 155     { (ALchar *)"ALC_INVALID_CONTEXT",                  ALC_INVALID_CONTEXT                 },
 156     { (ALchar *)"ALC_INVALID_ENUM",                     ALC_INVALID_ENUM                    },
 157     { (ALchar *)"ALC_INVALID_VALUE",                    ALC_INVALID_VALUE                   },
 158     { (ALchar *)"ALC_OUT_OF_MEMORY",                    ALC_OUT_OF_MEMORY                   },
 159     { (ALchar *)NULL,                                   (ALenum)0 }
 160 };
 161 // Error strings
 162 static const ALCchar alcNoError[] = "No Error";
 163 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
 164 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
 165 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
 166 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
 167 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
 168
 169 /* Device lists. Sizes only include the first ending null character, not the
 170  * second */
 171 static ALCchar *alcDeviceList;
 172 static size_t alcDeviceListSize;
 173 static ALCchar *alcAllDeviceList;
 174 static size_t alcAllDeviceListSize;
 175 static ALCchar *alcCaptureDeviceList;
 176 static size_t alcCaptureDeviceListSize;
 177 // Default is always the first in the list
 178 static ALCchar *alcDefaultDeviceSpecifier;
 179 static ALCchar *alcDefaultAllDeviceSpecifier;
 180 static ALCchar *alcCaptureDefaultDeviceSpecifier;
 181
 182
 183 static const ALCchar alcNoDeviceExtList[] =
 184     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
 185     "ALC_EXTX_thread_local_context";
 186 static const ALCchar alcExtensionList[] =
 187     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
 188     "ALC_EXT_disconnect ALC_EXT_EFX ALC_EXTX_thread_local_context";
 189 static const ALCint alcMajorVersion = 1;
 190 static const ALCint alcMinorVersion = 1;
 191
 192 static const ALCint alcEFXMajorVersion = 1;
 193 static const ALCint alcEFXMinorVersion = 0;
 194
 195 ///////////////////////////////////////////////////////
 196
 197
 198 ///////////////////////////////////////////////////////
 199 // Global Variables
 200
 201 static ALCdevice *g_pDeviceList = NULL;
 202 static ALCuint    g_ulDeviceCount = 0;
 203
 204 static CRITICAL_SECTION g_csMutex;
 205
 206 // Context List
 207 static ALCcontext *g_pContextList = NULL;
 208 static ALCuint     g_ulContextCount = 0;
 209
 210 // Thread-local current context
 211 static tls_type LocalContext;
 212
 213 // Context Error
 214 static ALCenum g_eLastContextError = ALC_NO_ERROR;
 215
 216 // Default context extensions
 217 static const ALchar alExtList[] =
 218     "AL_EXTX_buffer_sub_data AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE "
 219     "AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS "
 220     "AL_EXT_MULAW AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET "
 221     "AL_EXTX_sample_buffer_object AL_EXT_source_distance_model "
 222     "AL_LOKI_quadriphonic";
 223
 224 // Mixing Priority Level
 225 ALint RTPrioLevel;
 226
 227 // Resampler Quality
 228 resampler_t DefaultResampler;
 229
 230 ///////////////////////////////////////////////////////
 231
 232
 233 ///////////////////////////////////////////////////////
 234 // ALC Related helper functions
 235 #ifdef _WIN32
 236 static void alc_init(void);
 237 static void alc_deinit(void);
 238
 239 BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
 240 {
 241     (void)lpReserved;
 242
 243     // Perform actions based on the reason for calling.
 244     switch(ul_reason_for_call)
 245     {
 246         case DLL_PROCESS_ATTACH:
 247             DisableThreadLibraryCalls(hModule);
 248             alc_init();
 249             break;
 250
 251         case DLL_PROCESS_DETACH:
 252             alc_deinit();
 253             break;
 254     }
 255     return TRUE;
 256 }
 257 #else
 258 #ifdef HAVE_GCC_DESTRUCTOR
 259 static void alc_init(void) __attribute__((constructor));
 260 static void alc_deinit(void) __attribute__((destructor));
 261 #endif
 262 #endif
 263
 264 static void alc_init(void)
 265 {
 266     int i;
 267     const char *devs, *str;
 268
 269     InitializeCriticalSection(&g_csMutex);
 270     ALTHUNK_INIT();
 271     ReadALConfig();
 272
 273     tls_create(&LocalContext);
 274
 275     RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 0);
 276
 277     DefaultResampler = GetConfigValueInt(NULL, "resampler", RESAMPLER_DEFAULT);
 278     if(DefaultResampler >= RESAMPLER_MAX || DefaultResampler <= RESAMPLER_MIN)
 279         DefaultResampler = RESAMPLER_DEFAULT;
 280
 281     devs = GetConfigValue(NULL, "drivers", "");
 282     if(devs[0])
 283     {
 284         int n;
 285         size_t len;
 286         const char *next = devs;
 287         int endlist;
 288
 289         i = 0;
 290         do {
 291             devs = next;
 292             next = strchr(devs, ',');
 293
 294             if(!devs[0] || devs[0] == ',')
 295             {
 296                 endlist = 0;
 297                 continue;
 298             }
 299             endlist = 1;
 300
 301             len = (next ? ((size_t)(next-devs)) : strlen(devs));
 302             for(n = i;BackendList[n].Init;n++)
 303             {
 304                 if(len == strlen(BackendList[n].name) &&
 305                    strncmp(BackendList[n].name, devs, len) == 0)
 306                 {
 307                     BackendInfo Bkp = BackendList[n];
 308                     while(n > i)
 309                     {
 310                         BackendList[n] = BackendList[n-1];
 311                         --n;
 312                     }
 313                     BackendList[n] = Bkp;
 314
 315                     i++;
 316                     break;
 317                 }
 318             }
 319         } while(next++);
 320
 321         if(endlist)
 322         {
 323             BackendList[i].name = NULL;
 324             BackendList[i].Init = NULL;
 325             BackendList[i].Deinit = NULL;
 326             BackendList[i].Probe = NULL;
 327         }
 328     }
 329
 330     for(i = 0;BackendList[i].Init;i++)
 331         BackendList[i].Init(&BackendList[i].Funcs);
 332
 333     DuplicateStereo = GetConfigValueBool(NULL, "stereodup", 0);
 334
 335     str = GetConfigValue(NULL, "excludefx", "");
 336     if(str[0])
 337     {
 338         const struct {
 339             const char *name;
 340             int type;
 341         } EffectList[] = {
 342             { "eaxreverb", EAXREVERB },
 343             { "reverb", REVERB },
 344             { "echo", ECHO },
 345             { NULL, 0 }
 346         };
 347         int n;
 348         size_t len;
 349         const char *next = str;
 350
 351         do {
 352             str = next;
 353             next = strchr(str, ',');
 354
 355             if(!str[0] || next == str)
 356                 continue;
 357
 358             len = (next ? ((size_t)(next-str)) : strlen(str));
 359             for(n = 0;EffectList[n].name;n++)
 360             {
 361                 if(len == strlen(EffectList[n].name) &&
 362                    strncmp(EffectList[n].name, str, len) == 0)
 363                     DisabledEffects[EffectList[n].type] = AL_TRUE;
 364             }
 365         } while(next++);
 366     }
 367 }
 368
 369 static void alc_deinit(void)
 370 {
 371     int i;
 372
 373     ReleaseALC();
 374
 375     for(i = 0;BackendList[i].Deinit;i++)
 376         BackendList[i].Deinit();
 377
 378     tls_delete(LocalContext);
 379
 380     FreeALConfig();
 381     ALTHUNK_EXIT();
 382     DeleteCriticalSection(&g_csMutex);
 383 }
 384
 385
 386 static void ProbeDeviceList()
 387 {
 388     ALint i;
 389
 390     free(alcDeviceList); alcDeviceList = NULL;
 391     alcDeviceListSize = 0;
 392
 393     for(i = 0;BackendList[i].Probe;i++)
 394         BackendList[i].Probe(DEVICE_PROBE);
 395 }
 396
 397 static void ProbeAllDeviceList()
 398 {
 399     ALint i;
 400
 401     free(alcAllDeviceList); alcAllDeviceList = NULL;
 402     alcAllDeviceListSize = 0;
 403
 404     for(i = 0;BackendList[i].Probe;i++)
 405         BackendList[i].Probe(ALL_DEVICE_PROBE);
 406 }
 407
 408 static void ProbeCaptureDeviceList()
 409 {
 410     ALint i;
 411
 412     free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
 413     alcCaptureDeviceListSize = 0;
 414
 415     for(i = 0;BackendList[i].Probe;i++)
 416         BackendList[i].Probe(CAPTURE_DEVICE_PROBE);
 417 }
 418
 419
 420 #define DECL_APPEND_LIST_FUNC(type)                                          \
 421 void Append##type##List(const ALCchar *name)                                 \
 422 {                                                                            \
 423     size_t len = strlen(name);                                               \
 424     void *temp;                                                              \
 425                                                                              \
 426     if(len == 0)                                                             \
 427         return;                                                              \
 428                                                                              \
 429     temp = realloc(alc##type##List, alc##type##ListSize + len + 2);          \
 430     if(!temp)                                                                \
 431     {                                                                        \
 432         AL_PRINT("Realloc failed to add %s!\n", name);                       \
 433         return;                                                              \
 434     }                                                                        \
 435     alc##type##List = temp;                                                  \
 436     sprintf(alc##type##List+alc##type##ListSize, "%s", name);                \
 437     alc##type##ListSize += len+1;                                            \
 438     alc##type##List[alc##type##ListSize] = 0;                                \
 439 }
 440
 441 DECL_APPEND_LIST_FUNC(Device)
 442 DECL_APPEND_LIST_FUNC(AllDevice)
 443 DECL_APPEND_LIST_FUNC(CaptureDevice)
 444
 445
 446 void al_print(const char *fname, unsigned int line, const char *fmt, ...)
 447 {
 448     const char *fn;
 449     char str[256];
 450     int i;
 451
 452     fn = strrchr(fname, '/');
 453     if(!fn) fn = strrchr(fname, '\\');;
 454     if(!fn) fn = fname;
 455     else fn += 1;
 456
 457     i = snprintf(str, sizeof(str), "AL lib: %s:%d: ", fn, line);
 458     if(i < (int)sizeof(str) && i > 0)
 459     {
 460         va_list ap;
 461         va_start(ap, fmt);
 462         vsnprintf(str+i, sizeof(str)-i, fmt, ap);
 463         va_end(ap);
 464     }
 465     str[sizeof(str)-1] = 0;
 466
 467     fprintf(stderr, "%s", str);
 468 }
 469
 470 void EnableRTPrio(ALint level)
 471 {
 472     ALboolean failed;
 473
 474 #ifdef _WIN32
 475     if(level > 0)
 476         failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
 477     else
 478         failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
 479 #elif defined(HAVE_PTHREAD_SETSCHEDPARAM)
 480     struct sched_param param;
 481
 482     if(level > 0)
 483     {
 484         /* Use the minimum real-time priority possible for now (on Linux this
 485          * should be 1 for SCHED_RR) */
 486         param.sched_priority = sched_get_priority_min(SCHED_RR);
 487         failed = !!pthread_setschedparam(pthread_self(), SCHED_RR, &param);
 488     }
 489     else
 490     {
 491         param.sched_priority = 0;
 492         failed = !!pthread_setschedparam(pthread_self(), SCHED_OTHER, &param);
 493     }
 494 #else
 495     /* Real-time priority not available */
 496     failed = !!level;
 497 #endif
 498     if(failed)
 499         AL_PRINT("Failed to set priority level for thread\n");
 500 }
 501
 502
 503 /*
 504     IsDevice
 505
 506     Check pDevice is a valid Device pointer
 507 */
 508 static ALCboolean IsDevice(ALCdevice *pDevice)
 509 {
 510     ALCdevice *pTempDevice;
 511
 512     SuspendContext(NULL);
 513
 514     pTempDevice = g_pDeviceList;
 515     while(pTempDevice && pTempDevice != pDevice)
 516         pTempDevice = pTempDevice->next;
 517
 518     ProcessContext(NULL);
 519
 520     return (pTempDevice ? ALC_TRUE : ALC_FALSE);
 521 }
 522
 523 /*
 524     IsContext
 525
 526     Check pContext is a valid Context pointer
 527 */
 528 static ALCboolean IsContext(ALCcontext *pContext)
 529 {
 530     ALCcontext *pTempContext;
 531
 532     SuspendContext(NULL);
 533
 534     pTempContext = g_pContextList;
 535     while (pTempContext && pTempContext != pContext)
 536         pTempContext = pTempContext->next;
 537
 538     ProcessContext(NULL);
 539
 540     return (pTempContext ? ALC_TRUE : ALC_FALSE);
 541 }
 542
 543
 544 /*
 545     alcSetError
 546
 547     Store latest ALC Error
 548 */
 549 ALCvoid alcSetError(ALCdevice *device, ALenum errorCode)
 550 {
 551     if(IsDevice(device))
 552         device->LastError = errorCode;
 553     else
 554         g_eLastContextError = errorCode;
 555 }
 556
 557
 558 /*
 559     SuspendContext
 560
 561     Thread-safe entry
 562 */
 563 ALCvoid SuspendContext(ALCcontext *pContext)
 564 {
 565     (void)pContext;
 566     EnterCriticalSection(&g_csMutex);
 567 }
 568
 569
 570 /*
 571     ProcessContext
 572
 573     Thread-safe exit
 574 */
 575 ALCvoid ProcessContext(ALCcontext *pContext)
 576 {
 577     (void)pContext;
 578     LeaveCriticalSection(&g_csMutex);
 579 }
 580
 581
 582 /*
 583     GetContextSuspended
 584
 585     Returns the currently active Context, in a locked state
 586 */
 587 ALCcontext *GetContextSuspended(void)
 588 {
 589     ALCcontext *pContext = NULL;
 590
 591     SuspendContext(NULL);
 592
 593     pContext = tls_get(LocalContext);
 594     if(pContext && !IsContext(pContext))
 595     {
 596         tls_set(LocalContext, NULL);
 597         pContext = NULL;
 598     }
 599     if(!pContext)
 600     {
 601         pContext = g_pContextList;
 602         while(pContext && !pContext->InUse)
 603             pContext = pContext->next;
 604     }
 605     if(pContext)
 606         SuspendContext(pContext);
 607
 608     ProcessContext(NULL);
 609
 610     return pContext;
 611 }
 612
 613
 614 /*
 615     InitContext
 616
 617     Initialize Context variables
 618 */
 619 static ALvoid InitContext(ALCcontext *pContext)
 620 {
 621     //Initialise listener
 622     pContext->Listener.Gain = 1.0f;
 623     pContext->Listener.MetersPerUnit = 1.0f;
 624     pContext->Listener.Position[0] = 0.0f;
 625     pContext->Listener.Position[1] = 0.0f;
 626     pContext->Listener.Position[2] = 0.0f;
 627     pContext->Listener.Velocity[0] = 0.0f;
 628     pContext->Listener.Velocity[1] = 0.0f;
 629     pContext->Listener.Velocity[2] = 0.0f;
 630     pContext->Listener.Forward[0] = 0.0f;
 631     pContext->Listener.Forward[1] = 0.0f;
 632     pContext->Listener.Forward[2] = -1.0f;
 633     pContext->Listener.Up[0] = 0.0f;
 634     pContext->Listener.Up[1] = 1.0f;
 635     pContext->Listener.Up[2] = 0.0f;
 636
 637     //Validate pContext
 638     pContext->LastError = AL_NO_ERROR;
 639     pContext->InUse = AL_FALSE;
 640     pContext->Suspended = AL_FALSE;
 641
 642     //Set globals
 643     pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
 644     pContext->SourceDistanceModel = AL_FALSE;
 645     pContext->DopplerFactor = 1.0f;
 646     pContext->DopplerVelocity = 1.0f;
 647     pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
 648
 649     pContext->ExtensionList = alExtList;
 650 }
 651
 652
 653 /*
 654     ExitContext
 655
 656     Clean up Context, destroy any remaining Sources
 657 */
 658 static ALCvoid ExitContext(ALCcontext *pContext)
 659 {
 660     //Invalidate context
 661     pContext->LastError = AL_NO_ERROR;
 662     pContext->InUse = AL_FALSE;
 663 }
 664
 665 ///////////////////////////////////////////////////////
 666
 667
 668 ///////////////////////////////////////////////////////
 669 // ALC Functions calls
 670
 671
 672 // This should probably move to another c file but for now ...
 673 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 674 {
 675     ALCboolean DeviceFound = ALC_FALSE;
 676     ALCdevice *device = NULL;
 677     ALCint i;
 678
 679     if(SampleSize <= 0)
 680     {
 681         alcSetError(NULL, ALC_INVALID_VALUE);
 682         return NULL;
 683     }
 684
 685     if(deviceName && !deviceName[0])
 686         deviceName = NULL;
 687
 688     device = calloc(1, sizeof(ALCdevice));
 689     if(!device)
 690     {
 691         alcSetError(NULL, ALC_OUT_OF_MEMORY);
 692         return NULL;
 693     }
 694
 695     //Validate device
 696     device->Connected = ALC_TRUE;
 697     device->IsCaptureDevice = AL_TRUE;
 698
 699     device->szDeviceName = NULL;
 700
 701     device->Frequency = frequency;
 702     device->Format = format;
 703     device->UpdateSize = SampleSize;
 704     device->NumUpdates = 1;
 705
 706     SuspendContext(NULL);
 707     for(i = 0;BackendList[i].Init;i++)
 708     {
 709         device->Funcs = &BackendList[i].Funcs;
 710         if(ALCdevice_OpenCapture(device, deviceName))
 711         {
 712             device->next = g_pDeviceList;
 713             g_pDeviceList = device;
 714             g_ulDeviceCount++;
 715
 716             DeviceFound = ALC_TRUE;
 717             break;
 718         }
 719     }
 720     ProcessContext(NULL);
 721
 722     if(!DeviceFound)
 723     {
 724         alcSetError(NULL, ALC_INVALID_VALUE);
 725         free(device);
 726         device = NULL;
 727     }
 728
 729     return device;
 730 }
 731
 732 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)
 733 {
 734     ALCdevice **list;
 735
 736     if(!IsDevice(pDevice) || !pDevice->IsCaptureDevice)
 737     {
 738         alcSetError(pDevice, ALC_INVALID_DEVICE);
 739         return ALC_FALSE;
 740     }
 741
 742     SuspendContext(NULL);
 743
 744     list = &g_pDeviceList;
 745     while(*list != pDevice)
 746         list = &(*list)->next;
 747
 748     *list = (*list)->next;
 749     g_ulDeviceCount--;
 750
 751     ProcessContext(NULL);
 752
 753     ALCdevice_CloseCapture(pDevice);
 754
 755     free(pDevice->szDeviceName);
 756     pDevice->szDeviceName = NULL;
 757
 758     free(pDevice);
 759
 760     return ALC_TRUE;
 761 }
 762
 763 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
 764 {
 765     if(!IsDevice(device) || !device->IsCaptureDevice)
 766     {
 767         alcSetError(device, ALC_INVALID_DEVICE);
 768         return;
 769     }
 770     SuspendContext(NULL);
 771     ALCdevice_StartCapture(device);
 772     ProcessContext(NULL);
 773 }
 774
 775 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
 776 {
 777     if(!IsDevice(device) || !device->IsCaptureDevice)
 778     {
 779         alcSetError(device, ALC_INVALID_DEVICE);
 780         return;
 781     }
 782     SuspendContext(NULL);
 783     ALCdevice_StopCapture(device);
 784     ProcessContext(NULL);
 785 }
 786
 787 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
 788 {
 789     if(!IsDevice(device) || !device->IsCaptureDevice)
 790     {
 791         alcSetError(device, ALC_INVALID_DEVICE);
 792         return;
 793     }
 794     SuspendContext(NULL);
 795     ALCdevice_CaptureSamples(device, buffer, samples);
 796     ProcessContext(NULL);
 797 }
 798
 799 /*
 800     alcGetError
 801
 802     Return last ALC generated error code
 803 */
 804 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
 805 {
 806     ALCenum errorCode = ALC_NO_ERROR;
 807
 808     if(IsDevice(device))
 809     {
 810         errorCode = device->LastError;
 811         device->LastError = ALC_NO_ERROR;
 812     }
 813     else
 814     {
 815         errorCode = g_eLastContextError;
 816         g_eLastContextError = ALC_NO_ERROR;
 817     }
 818     return errorCode;
 819 }
 820
 821
 822 /*
 823     alcSuspendContext
 824
 825     Not functional
 826 */
 827 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *pContext)
 828 {
 829     SuspendContext(NULL);
 830     if(IsContext(pContext))
 831         pContext->Suspended = AL_TRUE;
 832     ProcessContext(NULL);
 833 }
 834
 835
 836 /*
 837     alcProcessContext
 838
 839     Not functional
 840 */
 841 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *pContext)
 842 {
 843     SuspendContext(NULL);
 844     if(IsContext(pContext))
 845         pContext->Suspended = AL_FALSE;
 846     ProcessContext(NULL);
 847 }
 848
 849
 850 /*
 851     alcGetString
 852
 853     Returns information about the Device, and error strings
 854 */
 855 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)
 856 {
 857     const ALCchar *value = NULL;
 858
 859     switch (param)
 860     {
 861     case ALC_NO_ERROR:
 862         value = alcNoError;
 863         break;
 864
 865     case ALC_INVALID_ENUM:
 866         value = alcErrInvalidEnum;
 867         break;
 868
 869     case ALC_INVALID_VALUE:
 870         value = alcErrInvalidValue;
 871         break;
 872
 873     case ALC_INVALID_DEVICE:
 874         value = alcErrInvalidDevice;
 875         break;
 876
 877     case ALC_INVALID_CONTEXT:
 878         value = alcErrInvalidContext;
 879         break;
 880
 881     case ALC_OUT_OF_MEMORY:
 882         value = alcErrOutOfMemory;
 883         break;
 884
 885     case ALC_DEVICE_SPECIFIER:
 886         if(IsDevice(pDevice))
 887             value = pDevice->szDeviceName;
 888         else
 889         {
 890             ProbeDeviceList();
 891             value = alcDeviceList;
 892         }
 893         break;
 894
 895     case ALC_ALL_DEVICES_SPECIFIER:
 896         ProbeAllDeviceList();
 897         value = alcAllDeviceList;
 898         break;
 899
 900     case ALC_CAPTURE_DEVICE_SPECIFIER:
 901         if(IsDevice(pDevice))
 902             value = pDevice->szDeviceName;
 903         else
 904         {
 905             ProbeCaptureDeviceList();
 906             value = alcCaptureDeviceList;
 907         }
 908         break;
 909
 910     /* Default devices are always first in the list */
 911     case ALC_DEFAULT_DEVICE_SPECIFIER:
 912         if(!alcDeviceList)
 913             ProbeDeviceList();
 914
 915         free(alcDefaultDeviceSpecifier);
 916         alcDefaultDeviceSpecifier = strdup(alcDeviceList ? alcDeviceList : "");
 917         if(!alcDefaultDeviceSpecifier)
 918             alcSetError(pDevice, ALC_OUT_OF_MEMORY);
 919         value = alcDefaultDeviceSpecifier;
 920         break;
 921
 922     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
 923         if(!alcAllDeviceList)
 924             ProbeAllDeviceList();
 925
 926         free(alcDefaultAllDeviceSpecifier);
 927         alcDefaultAllDeviceSpecifier = strdup(alcAllDeviceList ?
 928                                               alcAllDeviceList : "");
 929         if(!alcDefaultAllDeviceSpecifier)
 930             alcSetError(pDevice, ALC_OUT_OF_MEMORY);
 931         value = alcDefaultAllDeviceSpecifier;
 932         break;
 933
 934     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
 935         if(!alcCaptureDeviceList)
 936             ProbeCaptureDeviceList();
 937
 938         free(alcCaptureDefaultDeviceSpecifier);
 939         alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?
 940                                                   alcCaptureDeviceList : "");
 941         if(!alcCaptureDefaultDeviceSpecifier)
 942             alcSetError(pDevice, ALC_OUT_OF_MEMORY);
 943         value = alcCaptureDefaultDeviceSpecifier;
 944         break;
 945
 946     case ALC_EXTENSIONS:
 947         if(IsDevice(pDevice))
 948             value = alcExtensionList;
 949         else
 950             value = alcNoDeviceExtList;
 951         break;
 952
 953     default:
 954         alcSetError(pDevice, ALC_INVALID_ENUM);
 955         break;
 956     }
 957
 958     return value;
 959 }
 960
 961
 962 /*
 963     alcGetIntegerv
 964
 965     Returns information about the Device and the version of Open AL
 966 */
 967 ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
 968 {
 969     if(size == 0 || data == NULL)
 970     {
 971         alcSetError(device, ALC_INVALID_VALUE);
 972         return;
 973     }
 974
 975     if(IsDevice(device) && device->IsCaptureDevice)
 976     {
 977         SuspendContext(NULL);
 978
 979         // Capture device
 980         switch (param)
 981         {
 982         case ALC_CAPTURE_SAMPLES:
 983             *data = ALCdevice_AvailableSamples(device);
 984             break;
 985
 986         case ALC_CONNECTED:
 987             *data = device->Connected;
 988             break;
 989
 990         default:
 991             alcSetError(device, ALC_INVALID_ENUM);
 992             break;
 993         }
 994
 995         ProcessContext(NULL);
 996         return;
 997     }
 998
 999     // Playback Device
1000     switch (param)
1001     {
1002         case ALC_MAJOR_VERSION:
1003             *data = alcMajorVersion;
1004             break;
1005
1006         case ALC_MINOR_VERSION:
1007             *data = alcMinorVersion;
1008             break;
1009
1010         case ALC_EFX_MAJOR_VERSION:
1011             *data = alcEFXMajorVersion;
1012             break;
1013
1014         case ALC_EFX_MINOR_VERSION:
1015             *data = alcEFXMinorVersion;
1016             break;
1017
1018         case ALC_MAX_AUXILIARY_SENDS:
1019             if(!IsDevice(device))
1020                 alcSetError(device, ALC_INVALID_DEVICE);
1021             else
1022                 *data = device->NumAuxSends;
1023             break;
1024
1025         case ALC_ATTRIBUTES_SIZE:
1026             if(!IsDevice(device))
1027                 alcSetError(device, ALC_INVALID_DEVICE);
1028             else
1029                 *data = 13;
1030             break;
1031
1032         case ALC_ALL_ATTRIBUTES:
1033             if(!IsDevice(device))
1034                 alcSetError(device, ALC_INVALID_DEVICE);
1035             else if (size < 13)
1036                 alcSetError(device, ALC_INVALID_VALUE);
1037             else
1038             {
1039                 int i = 0;
1040
1041                 SuspendContext(NULL);
1042                 data[i++] = ALC_FREQUENCY;
1043                 data[i++] = device->Frequency;
1044
1045                 data[i++] = ALC_REFRESH;
1046                 data[i++] = device->Frequency / device->UpdateSize;
1047
1048                 data[i++] = ALC_SYNC;
1049                 data[i++] = ALC_FALSE;
1050
1051                 data[i++] = ALC_MONO_SOURCES;
1052                 data[i++] = device->lNumMonoSources;
1053
1054                 data[i++] = ALC_STEREO_SOURCES;
1055                 data[i++] = device->lNumStereoSources;
1056
1057                 data[i++] = ALC_MAX_AUXILIARY_SENDS;
1058                 data[i++] = device->NumAuxSends;
1059
1060                 data[i++] = 0;
1061                 ProcessContext(NULL);
1062             }
1063             break;
1064
1065         case ALC_FREQUENCY:
1066             if(!IsDevice(device))
1067                 alcSetError(device, ALC_INVALID_DEVICE);
1068             else
1069                 *data = device->Frequency;
1070             break;
1071
1072         case ALC_REFRESH:
1073             if(!IsDevice(device))
1074                 alcSetError(device, ALC_INVALID_DEVICE);
1075             else
1076                 *data = device->Frequency / device->UpdateSize;
1077             break;
1078
1079         case ALC_SYNC:
1080             if(!IsDevice(device))
1081                 alcSetError(device, ALC_INVALID_DEVICE);
1082             else
1083                 *data = ALC_FALSE;
1084             break;
1085
1086         case ALC_MONO_SOURCES:
1087             if(!IsDevice(device))
1088                 alcSetError(device, ALC_INVALID_DEVICE);
1089             else
1090                 *data = device->lNumMonoSources;
1091             break;
1092
1093         case ALC_STEREO_SOURCES:
1094             if(!IsDevice(device))
1095                 alcSetError(device, ALC_INVALID_DEVICE);
1096             else
1097                 *data = device->lNumStereoSources;
1098             break;
1099
1100         case ALC_CONNECTED:
1101             if(!IsDevice(device))
1102                 alcSetError(device, ALC_INVALID_DEVICE);
1103             else
1104                 *data = device->Connected;
1105             break;
1106
1107         default:
1108             alcSetError(device, ALC_INVALID_ENUM);
1109             break;
1110     }
1111 }
1112
1113
1114 /*
1115     alcIsExtensionPresent
1116
1117     Determines if there is support for a particular extension
1118 */
1119 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
1120 {
1121     ALCboolean bResult = ALC_FALSE;
1122     const char *ptr;
1123     size_t len;
1124
1125     if(!extName)
1126     {
1127         alcSetError(device, ALC_INVALID_VALUE);
1128         return ALC_FALSE;
1129     }
1130
1131     len = strlen(extName);
1132     ptr = (IsDevice(device) ? alcExtensionList : alcNoDeviceExtList);
1133     while(ptr && *ptr)
1134     {
1135         if(strncasecmp(ptr, extName, len) == 0 &&
1136            (ptr[len] == '\0' || isspace(ptr[len])))
1137         {
1138             bResult = ALC_TRUE;
1139             break;
1140         }
1141         if((ptr=strchr(ptr, ' ')) != NULL)
1142         {
1143             do {
1144                 ++ptr;
1145             } while(isspace(*ptr));
1146         }
1147     }
1148
1149     return bResult;
1150 }
1151
1152
1153 /*
1154     alcGetProcAddress
1155
1156     Retrieves the function address for a particular extension function
1157 */
1158 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
1159 {
1160     ALsizei i = 0;
1161
1162     if(!funcName)
1163     {
1164         alcSetError(device, ALC_INVALID_VALUE);
1165         return NULL;
1166     }
1167
1168     while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName,funcName) != 0)
1169         i++;
1170     return alcFunctions[i].address;
1171 }
1172
1173
1174 /*
1175     alcGetEnumValue
1176
1177     Get the value for a particular ALC Enumerated Value
1178 */
1179 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
1180 {
1181     ALsizei i = 0;
1182     ALCenum val;
1183
1184     while(enumeration[i].enumName && strcmp(enumeration[i].enumName,enumName) == 0)
1185         i++;
1186     val = enumeration[i].value;
1187
1188     if(!enumeration[i].enumName)
1189         alcSetError(device, ALC_INVALID_VALUE);
1190
1191     return val;
1192 }
1193
1194
1195 /*
1196     alcCreateContext
1197
1198     Create and attach a Context to a particular Device.
1199 */
1200 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
1201 {
1202     ALuint attrIdx, reqStereoSources;
1203     ALCcontext *ALContext;
1204     void *temp;
1205     ALuint i;
1206
1207     SuspendContext(NULL);
1208
1209     if(!IsDevice(device) || device->IsCaptureDevice || !device->Connected)
1210     {
1211         alcSetError(device, ALC_INVALID_DEVICE);
1212         ProcessContext(NULL);
1213         return NULL;
1214     }
1215
1216     // Reset Context Last Error code
1217     device->LastError = ALC_NO_ERROR;
1218
1219     // If a context is already running on the device, stop playback so the
1220     // device attributes can be updated
1221     if(device->NumContexts > 0)
1222     {
1223         ProcessContext(NULL);
1224         ALCdevice_StopPlayback(device);
1225         SuspendContext(NULL);
1226     }
1227
1228     // Check for attributes
1229     if(attrList)
1230     {
1231         ALCint level = device->Bs2bLevel;
1232         ALCuint freq = device->Frequency;
1233         ALCint numMono = device->lNumMonoSources;
1234         ALCint numStereo = device->lNumStereoSources;
1235         ALCuint numSends = device->NumAuxSends;
1236
1237         attrIdx = 0;
1238         while(attrList[attrIdx])
1239         {
1240             if(attrList[attrIdx] == ALC_FREQUENCY &&
1241                !ConfigValueExists(NULL, "frequency"))
1242             {
1243                 freq = attrList[attrIdx + 1];
1244                 if(freq < 8000)
1245                     freq = 8000;
1246             }
1247
1248             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1249             {
1250                 reqStereoSources = attrList[attrIdx + 1];
1251                 if(reqStereoSources > device->MaxNoOfSources)
1252                     reqStereoSources = device->MaxNoOfSources;
1253
1254                 numStereo = reqStereoSources;
1255                 numMono = device->MaxNoOfSources - numStereo;
1256             }
1257
1258             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS &&
1259                !ConfigValueExists(NULL, "sends"))
1260             {
1261                 numSends = attrList[attrIdx + 1];
1262                 if(numSends > MAX_SENDS)
1263                     numSends = MAX_SENDS;
1264             }
1265
1266             attrIdx += 2;
1267         }
1268
1269         device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1270                              device->Frequency;
1271
1272         device->Bs2bLevel = level;
1273         device->Frequency = freq;
1274         device->lNumMonoSources = numMono;
1275         device->lNumStereoSources = numStereo;
1276         device->NumAuxSends = numSends;
1277     }
1278
1279     if(ALCdevice_ResetPlayback(device) == ALC_FALSE)
1280     {
1281         alcSetError(device, ALC_INVALID_DEVICE);
1282         aluHandleDisconnect(device);
1283         ProcessContext(NULL);
1284         return NULL;
1285     }
1286
1287     for(i = 0;i < device->NumContexts;i++)
1288     {
1289         ALCcontext *context = device->Contexts[i];
1290         ALeffectslot *slot;
1291         ALsource *source;
1292
1293         SuspendContext(context);
1294         for(slot = context->EffectSlotList;slot != NULL;slot = slot->next)
1295         {
1296             if(!slot->EffectState)
1297                 continue;
1298
1299             if(ALEffect_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
1300             {
1301                 alcSetError(device, ALC_INVALID_DEVICE);
1302                 aluHandleDisconnect(device);
1303                 ProcessContext(context);
1304                 ProcessContext(NULL);
1305                 ALCdevice_StopPlayback(device);
1306                 return NULL;
1307             }
1308             ALEffect_Update(slot->EffectState, context, &slot->effect);
1309         }
1310
1311         for(source = context->SourceList;source != NULL;source = source->next)
1312         {
1313             ALuint s = device->NumAuxSends;
1314             while(s < MAX_SENDS)
1315             {
1316                 if(source->Send[s].Slot)
1317                     source->Send[s].Slot->refcount--;
1318                 source->Send[s].Slot = NULL;
1319                 source->Send[s].WetFilter.type = 0;
1320                 source->Send[s].WetFilter.filter = 0;
1321                 s++;
1322             }
1323             source->NeedsUpdate = AL_TRUE;
1324         }
1325         aluInitPanning(context);
1326         ProcessContext(context);
1327     }
1328
1329     if(device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
1330     {
1331         if(!device->Bs2b)
1332         {
1333             device->Bs2b = calloc(1, sizeof(*device->Bs2b));
1334             bs2b_clear(device->Bs2b);
1335         }
1336         bs2b_set_srate(device->Bs2b, device->Frequency);
1337         bs2b_set_level(device->Bs2b, device->Bs2bLevel);
1338     }
1339     else
1340     {
1341         free(device->Bs2b);
1342         device->Bs2b = NULL;
1343     }
1344
1345     temp = realloc(device->Contexts, (device->NumContexts+1) * sizeof(*device->Contexts));
1346     if(!temp)
1347     {
1348         alcSetError(device, ALC_OUT_OF_MEMORY);
1349         ProcessContext(NULL);
1350         return NULL;
1351     }
1352     device->Contexts = temp;
1353
1354     ALContext = calloc(1, sizeof(ALCcontext));
1355     if(!ALContext)
1356     {
1357         alcSetError(device, ALC_OUT_OF_MEMORY);
1358         ProcessContext(NULL);
1359         return NULL;
1360     }
1361
1362     device->Contexts[device->NumContexts++] = ALContext;
1363     ALContext->Device = device;
1364
1365     InitContext(ALContext);
1366     aluInitPanning(ALContext);
1367
1368     ALContext->next = g_pContextList;
1369     g_pContextList = ALContext;
1370     g_ulContextCount++;
1371
1372     ProcessContext(NULL);
1373
1374     return ALContext;
1375 }
1376
1377
1378 /*
1379     alcDestroyContext
1380
1381     Remove a Context
1382 */
1383 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
1384 {
1385     ALCdevice *Device;
1386     ALCcontext **list;
1387     ALuint i;
1388
1389     if(!IsContext(context))
1390     {
1391         alcSetError(NULL, ALC_INVALID_CONTEXT);
1392         return;
1393     }
1394
1395     Device = context->Device;
1396
1397     if(Device->NumContexts == 1)
1398         ALCdevice_StopPlayback(Device);
1399
1400     SuspendContext(NULL);
1401
1402     for(i = 0;i < Device->NumContexts-1;i++)
1403     {
1404         if(Device->Contexts[i] == context)
1405         {
1406             Device->Contexts[i] = Device->Contexts[Device->NumContexts-1];
1407             break;
1408         }
1409     }
1410     Device->NumContexts--;
1411
1412     // Lock context
1413     SuspendContext(context);
1414
1415     if(context->SourceCount > 0)
1416     {
1417 #ifdef _DEBUG
1418         AL_PRINT("alcDestroyContext(): deleting %d Source(s)\n", context->SourceCount);
1419 #endif
1420         ReleaseALSources(context);
1421     }
1422     if(context->EffectSlotCount > 0)
1423     {
1424 #ifdef _DEBUG
1425         AL_PRINT("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", context->EffectSlotCount);
1426 #endif
1427         ReleaseALAuxiliaryEffectSlots(context);
1428     }
1429
1430     list = &g_pContextList;
1431     while(*list != context)
1432         list = &(*list)->next;
1433
1434     *list = (*list)->next;
1435     g_ulContextCount--;
1436
1437     // Unlock context
1438     ProcessContext(context);
1439     ProcessContext(NULL);
1440
1441     ExitContext(context);
1442
1443     // Free memory (MUST do this after ProcessContext)
1444     memset(context, 0, sizeof(ALCcontext));
1445     free(context);
1446 }
1447
1448
1449 /*
1450     alcGetCurrentContext
1451
1452     Returns the currently active Context
1453 */
1454 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(ALCvoid)
1455 {
1456     ALCcontext *pContext;
1457
1458     if((pContext=GetContextSuspended()) != NULL)
1459         ProcessContext(pContext);
1460
1461     return pContext;
1462 }
1463
1464 /*
1465     alcGetThreadContext
1466
1467     Returns the currently active thread-local Context
1468 */
1469 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
1470 {
1471     ALCcontext *pContext = NULL;
1472
1473     SuspendContext(NULL);
1474
1475     pContext = tls_get(LocalContext);
1476     if(pContext && !IsContext(pContext))
1477     {
1478         tls_set(LocalContext, NULL);
1479         pContext = NULL;
1480     }
1481
1482     ProcessContext(NULL);
1483
1484     return pContext;
1485 }
1486
1487
1488 /*
1489     alcGetContextsDevice
1490
1491     Returns the Device that a particular Context is attached to
1492 */
1493 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *pContext)
1494 {
1495     ALCdevice *pDevice = NULL;
1496
1497     SuspendContext(NULL);
1498     if(IsContext(pContext))
1499         pDevice = pContext->Device;
1500     else
1501         alcSetError(NULL, ALC_INVALID_CONTEXT);
1502     ProcessContext(NULL);
1503
1504     return pDevice;
1505 }
1506
1507
1508 /*
1509     alcMakeContextCurrent
1510
1511     Makes the given Context the active Context
1512 */
1513 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
1514 {
1515     ALCcontext *ALContext;
1516     ALboolean bReturn = AL_TRUE;
1517
1518     SuspendContext(NULL);
1519
1520     // context must be a valid Context or NULL
1521     if(context == NULL || IsContext(context))
1522     {
1523         ALContext = g_pContextList;
1524         while(ALContext && !ALContext->InUse)
1525             ALContext = ALContext->next;
1526
1527         if(ALContext != NULL)
1528         {
1529             SuspendContext(ALContext);
1530             ALContext->InUse=AL_FALSE;
1531             ProcessContext(ALContext);
1532         }
1533
1534         if((ALContext=context) != NULL && ALContext->Device)
1535         {
1536             SuspendContext(ALContext);
1537             ALContext->InUse=AL_TRUE;
1538             ProcessContext(ALContext);
1539         }
1540
1541         tls_set(LocalContext, NULL);
1542     }
1543     else
1544     {
1545         alcSetError(NULL, ALC_INVALID_CONTEXT);
1546         bReturn = AL_FALSE;
1547     }
1548
1549     ProcessContext(NULL);
1550
1551     return bReturn;
1552 }
1553
1554 /*
1555     alcSetThreadContext
1556
1557     Makes the given Context the active Context for the current thread
1558 */
1559 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
1560 {
1561     ALboolean bReturn = AL_TRUE;
1562
1563     SuspendContext(NULL);
1564
1565     // context must be a valid Context or NULL
1566     if(context == NULL || IsContext(context))
1567         tls_set(LocalContext, context);
1568     else
1569     {
1570         alcSetError(NULL, ALC_INVALID_CONTEXT);
1571         bReturn = AL_FALSE;
1572     }
1573
1574     ProcessContext(NULL);
1575
1576     return bReturn;
1577 }
1578
1579
1580 // Sets the default channel order used by most non-WaveFormatEx-based APIs
1581 void SetDefaultChannelOrder(ALCdevice *device)
1582 {
1583     switch(aluChannelsFromFormat(device->Format))
1584     {
1585     case 1: device->DevChannels[0] = FRONT_CENTER; break;
1586
1587     case 2: device->DevChannels[0] = FRONT_LEFT;
1588             device->DevChannels[1] = FRONT_RIGHT; break;
1589
1590     case 4: device->DevChannels[0] = FRONT_LEFT;
1591             device->DevChannels[1] = FRONT_RIGHT;
1592             device->DevChannels[2] = BACK_LEFT;
1593             device->DevChannels[3] = BACK_RIGHT; break;
1594
1595     case 6: device->DevChannels[0] = FRONT_LEFT;
1596             device->DevChannels[1] = FRONT_RIGHT;
1597             device->DevChannels[2] = BACK_LEFT;
1598             device->DevChannels[3] = BACK_RIGHT;
1599             device->DevChannels[4] = FRONT_CENTER;
1600             device->DevChannels[5] = LFE; break;
1601
1602     case 7: device->DevChannels[0] = FRONT_LEFT;
1603             device->DevChannels[1] = FRONT_RIGHT;
1604             device->DevChannels[2] = FRONT_CENTER;
1605             device->DevChannels[3] = LFE;
1606             device->DevChannels[4] = BACK_CENTER;
1607             device->DevChannels[5] = SIDE_LEFT;
1608             device->DevChannels[6] = SIDE_RIGHT; break;
1609
1610     case 8: device->DevChannels[0] = FRONT_LEFT;
1611             device->DevChannels[1] = FRONT_RIGHT;
1612             device->DevChannels[2] = BACK_LEFT;
1613             device->DevChannels[3] = BACK_RIGHT;
1614             device->DevChannels[4] = FRONT_CENTER;
1615             device->DevChannels[5] = LFE;
1616             device->DevChannels[6] = SIDE_LEFT;
1617             device->DevChannels[7] = SIDE_RIGHT; break;
1618     }
1619 }
1620 // Sets the default order used by WaveFormatEx
1621 void SetDefaultWFXChannelOrder(ALCdevice *device)
1622 {
1623     switch(aluChannelsFromFormat(device->Format))
1624     {
1625     case 1: device->DevChannels[0] = FRONT_CENTER; break;
1626
1627     case 2: device->DevChannels[0] = FRONT_LEFT;
1628             device->DevChannels[1] = FRONT_RIGHT; break;
1629
1630     case 4: device->DevChannels[0] = FRONT_LEFT;
1631             device->DevChannels[1] = FRONT_RIGHT;
1632             device->DevChannels[2] = BACK_LEFT;
1633             device->DevChannels[3] = BACK_RIGHT; break;
1634
1635     case 6: device->DevChannels[0] = FRONT_LEFT;
1636             device->DevChannels[1] = FRONT_RIGHT;
1637             device->DevChannels[2] = FRONT_CENTER;
1638             device->DevChannels[3] = LFE;
1639             device->DevChannels[4] = BACK_LEFT;
1640             device->DevChannels[5] = BACK_RIGHT; break;
1641
1642     case 7: device->DevChannels[0] = FRONT_LEFT;
1643             device->DevChannels[1] = FRONT_RIGHT;
1644             device->DevChannels[2] = FRONT_CENTER;
1645             device->DevChannels[3] = LFE;
1646             device->DevChannels[4] = BACK_CENTER;
1647             device->DevChannels[5] = SIDE_LEFT;
1648             device->DevChannels[6] = SIDE_RIGHT; break;
1649
1650     case 8: device->DevChannels[0] = FRONT_LEFT;
1651             device->DevChannels[1] = FRONT_RIGHT;
1652             device->DevChannels[2] = FRONT_CENTER;
1653             device->DevChannels[3] = LFE;
1654             device->DevChannels[4] = BACK_LEFT;
1655             device->DevChannels[5] = BACK_RIGHT;
1656             device->DevChannels[6] = SIDE_LEFT;
1657             device->DevChannels[7] = SIDE_RIGHT; break;
1658     }
1659 }
1660
1661 static ALenum GetFormatFromString(const char *str)
1662 {
1663     if(strcasecmp(str, "AL_FORMAT_MONO32") == 0)    return AL_FORMAT_MONO_FLOAT32;
1664     if(strcasecmp(str, "AL_FORMAT_STEREO32") == 0)  return AL_FORMAT_STEREO_FLOAT32;
1665     if(strcasecmp(str, "AL_FORMAT_QUAD32") == 0)    return AL_FORMAT_QUAD32;
1666     if(strcasecmp(str, "AL_FORMAT_51CHN32") == 0)   return AL_FORMAT_51CHN32;
1667     if(strcasecmp(str, "AL_FORMAT_61CHN32") == 0)   return AL_FORMAT_61CHN32;
1668     if(strcasecmp(str, "AL_FORMAT_71CHN32") == 0)   return AL_FORMAT_71CHN32;
1669
1670     if(strcasecmp(str, "AL_FORMAT_MONO16") == 0)    return AL_FORMAT_MONO16;
1671     if(strcasecmp(str, "AL_FORMAT_STEREO16") == 0)  return AL_FORMAT_STEREO16;
1672     if(strcasecmp(str, "AL_FORMAT_QUAD16") == 0)    return AL_FORMAT_QUAD16;
1673     if(strcasecmp(str, "AL_FORMAT_51CHN16") == 0)   return AL_FORMAT_51CHN16;
1674     if(strcasecmp(str, "AL_FORMAT_61CHN16") == 0)   return AL_FORMAT_61CHN16;
1675     if(strcasecmp(str, "AL_FORMAT_71CHN16") == 0)   return AL_FORMAT_71CHN16;
1676
1677     if(strcasecmp(str, "AL_FORMAT_MONO8") == 0)    return AL_FORMAT_MONO8;
1678     if(strcasecmp(str, "AL_FORMAT_STEREO8") == 0)  return AL_FORMAT_STEREO8;
1679     if(strcasecmp(str, "AL_FORMAT_QUAD8") == 0)    return AL_FORMAT_QUAD8;
1680     if(strcasecmp(str, "AL_FORMAT_51CHN8") == 0)   return AL_FORMAT_51CHN8;
1681     if(strcasecmp(str, "AL_FORMAT_61CHN8") == 0)   return AL_FORMAT_61CHN8;
1682     if(strcasecmp(str, "AL_FORMAT_71CHN8") == 0)   return AL_FORMAT_71CHN8;
1683
1684     AL_PRINT("Unknown format: \"%s\"\n", str);
1685     return AL_FORMAT_STEREO16;
1686 }
1687
1688 /*
1689     alcOpenDevice
1690
1691     Open the Device specified.
1692 */
1693 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
1694 {
1695     ALboolean bDeviceFound = AL_FALSE;
1696     const ALCchar *fmt;
1697     ALCdevice *device;
1698     ALint i;
1699
1700     if(deviceName && !deviceName[0])
1701         deviceName = NULL;
1702
1703     device = calloc(1, sizeof(ALCdevice));
1704     if(!device)
1705     {
1706         alcSetError(NULL, ALC_OUT_OF_MEMORY);
1707         return NULL;
1708     }
1709
1710     //Validate device
1711     device->Connected = ALC_TRUE;
1712     device->IsCaptureDevice = AL_FALSE;
1713     device->LastError = ALC_NO_ERROR;
1714
1715     device->Bs2b = NULL;
1716     device->szDeviceName = NULL;
1717
1718     device->Contexts = NULL;
1719     device->NumContexts = 0;
1720
1721     //Set output format
1722     device->Frequency = GetConfigValueInt(NULL, "frequency", SWMIXER_OUTPUT_RATE);
1723     if(device->Frequency < 8000)
1724         device->Frequency = 8000;
1725
1726     fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");
1727     device->Format = GetFormatFromString(fmt);
1728
1729     device->NumUpdates = GetConfigValueInt(NULL, "periods", 4);
1730     if(device->NumUpdates < 2)
1731         device->NumUpdates = 4;
1732
1733     i = GetConfigValueInt(NULL, "refresh", 4096);
1734     if(i <= 0) i = 4096;
1735
1736     device->UpdateSize = GetConfigValueInt(NULL, "period_size", i/device->NumUpdates);
1737     if(device->UpdateSize <= 0)
1738         device->UpdateSize = i/device->NumUpdates;
1739
1740     device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
1741     if((ALint)device->MaxNoOfSources <= 0)
1742         device->MaxNoOfSources = 256;
1743
1744     device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);
1745     if((ALint)device->AuxiliaryEffectSlotMax <= 0)
1746         device->AuxiliaryEffectSlotMax = 4;
1747
1748     device->lNumStereoSources = 1;
1749     device->lNumMonoSources = device->MaxNoOfSources - device->lNumStereoSources;
1750
1751     device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);
1752     if(device->NumAuxSends > MAX_SENDS)
1753         device->NumAuxSends = MAX_SENDS;
1754
1755     device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);
1756
1757     if(aluChannelsFromFormat(device->Format) <= 2)
1758     {
1759         device->HeadDampen = GetConfigValueFloat(NULL, "head_dampen", DEFAULT_HEAD_DAMPEN);
1760         device->HeadDampen = __min(device->HeadDampen, 1.0f);
1761         device->HeadDampen = __max(device->HeadDampen, 0.0f);
1762     }
1763     else
1764         device->HeadDampen = 0.0f;
1765
1766     // Find a playback device to open
1767     SuspendContext(NULL);
1768     for(i = 0;BackendList[i].Init;i++)
1769     {
1770         device->Funcs = &BackendList[i].Funcs;
1771         if(ALCdevice_OpenPlayback(device, deviceName))
1772         {
1773             device->next = g_pDeviceList;
1774             g_pDeviceList = device;
1775             g_ulDeviceCount++;
1776
1777             bDeviceFound = AL_TRUE;
1778             break;
1779         }
1780     }
1781     ProcessContext(NULL);
1782
1783     if(!bDeviceFound)
1784     {
1785         // No suitable output device found
1786         alcSetError(NULL, ALC_INVALID_VALUE);
1787         free(device);
1788         device = NULL;
1789     }
1790
1791     return device;
1792 }
1793
1794
1795 /*
1796     alcCloseDevice
1797
1798     Close the specified Device
1799 */
1800 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *pDevice)
1801 {
1802     ALCdevice **list;
1803
1804     if(!IsDevice(pDevice) || pDevice->IsCaptureDevice)
1805     {
1806         alcSetError(pDevice, ALC_INVALID_DEVICE);
1807         return ALC_FALSE;
1808     }
1809
1810     SuspendContext(NULL);
1811
1812     list = &g_pDeviceList;
1813     while(*list != pDevice)
1814         list = &(*list)->next;
1815
1816     *list = (*list)->next;
1817     g_ulDeviceCount--;
1818
1819     ProcessContext(NULL);
1820
1821     if(pDevice->NumContexts > 0)
1822     {
1823 #ifdef _DEBUG
1824         AL_PRINT("alcCloseDevice(): destroying %u Context(s)\n", pDevice->NumContexts);
1825 #endif
1826         while(pDevice->NumContexts > 0)
1827             alcDestroyContext(pDevice->Contexts[0]);
1828     }
1829     ALCdevice_ClosePlayback(pDevice);
1830
1831     if(pDevice->BufferCount > 0)
1832     {
1833 #ifdef _DEBUG
1834         AL_PRINT("alcCloseDevice(): deleting %d Buffer(s)\n", pDevice->BufferCount);
1835 #endif
1836         ReleaseALBuffers(pDevice);
1837     }
1838     if(pDevice->EffectCount > 0)
1839     {
1840 #ifdef _DEBUG
1841         AL_PRINT("alcCloseDevice(): deleting %d Effect(s)\n", pDevice->EffectCount);
1842 #endif
1843         ReleaseALEffects(pDevice);
1844     }
1845     if(pDevice->FilterCount > 0)
1846     {
1847 #ifdef _DEBUG
1848         AL_PRINT("alcCloseDevice(): deleting %d Filter(s)\n", pDevice->FilterCount);
1849 #endif
1850         ReleaseALFilters(pDevice);
1851     }
1852     if(pDevice->DatabufferCount > 0)
1853     {
1854 #ifdef _DEBUG
1855         AL_PRINT("alcCloseDevice(): deleting %d Databuffer(s)\n", pDevice->DatabufferCount);
1856 #endif
1857         ReleaseALDatabuffers(pDevice);
1858     }
1859
1860     free(pDevice->Bs2b);
1861     pDevice->Bs2b = NULL;
1862
1863     free(pDevice->szDeviceName);
1864     pDevice->szDeviceName = NULL;
1865
1866     free(pDevice->Contexts);
1867     pDevice->Contexts = NULL;
1868
1869     //Release device structure
1870     memset(pDevice, 0, sizeof(ALCdevice));
1871     free(pDevice);
1872
1873     return ALC_TRUE;
1874 }
1875
1876
1877 ALCvoid ReleaseALC(ALCvoid)
1878 {
1879     free(alcDeviceList); alcDeviceList = NULL;
1880     alcDeviceListSize = 0;
1881     free(alcAllDeviceList); alcAllDeviceList = NULL;
1882     alcAllDeviceListSize = 0;
1883     free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
1884     alcCaptureDeviceListSize = 0;
1885
1886     free(alcDefaultDeviceSpecifier);
1887     alcDefaultDeviceSpecifier = NULL;
1888     free(alcDefaultAllDeviceSpecifier);
1889     alcDefaultAllDeviceSpecifier = NULL;
1890     free(alcCaptureDefaultDeviceSpecifier);
1891     alcCaptureDefaultDeviceSpecifier = NULL;
1892
1893 #ifdef _DEBUG
1894     if(g_ulDeviceCount > 0)
1895         AL_PRINT("exit(): closing %u Device%s\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
1896 #endif
1897
1898     while(g_pDeviceList)
1899     {
1900         if(g_pDeviceList->IsCaptureDevice)
1901             alcCaptureCloseDevice(g_pDeviceList);
1902         else
1903             alcCloseDevice(g_pDeviceList);
1904     }
1905 }
1906
1907 ///////////////////////////////////////////////////////