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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 <signal.h>
  29
  30 #include "alMain.h"
  31 #include "alSource.h"
  32 #include "alListener.h"
  33 #include "alThunk.h"
  34 #include "alSource.h"
  35 #include "alBuffer.h"
  36 #include "alAuxEffectSlot.h"
  37 #include "alError.h"
  38 #include "alMidi.h"
  39 #include "bs2b.h"
  40 #include "alu.h"
  41
  42 #include "compat.h"
  43 #include "threads.h"
  44 #include "alstring.h"
  45
  46 #include "backends/base.h"
  47 #include "midi/base.h"
  48
  49
  50 /************************************************
  51  * Backends
  52  ************************************************/
  53 struct BackendInfo {
  54     const char *name;
  55     ALCbackendFactory* (*getFactory)(void);
  56     ALCboolean (*Init)(BackendFuncs*);
  57     void (*Deinit)(void);
  58     void (*Probe)(enum DevProbe);
  59     BackendFuncs Funcs;
  60 };
  61
  62 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
  63 static struct BackendInfo BackendList[] = {
  64 #ifdef HAVE_PULSEAUDIO
  65     { "pulse", ALCpulseBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
  66 #endif
  67 #ifdef HAVE_ALSA
  68     { "alsa", ALCalsaBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
  69 #endif
  70 #ifdef HAVE_COREAUDIO
  71     { "core", NULL, alc_ca_init, alc_ca_deinit, alc_ca_probe, EmptyFuncs },
  72 #endif
  73 #ifdef HAVE_OSS
  74     { "oss", ALCossBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
  75 #endif
  76 #ifdef HAVE_SOLARIS
  77     { "solaris", NULL, alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },
  78 #endif
  79 #ifdef HAVE_SNDIO
  80     { "sndio", NULL, alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },
  81 #endif
  82 #ifdef HAVE_QSA
  83     { "qsa", NULL, alc_qsa_init, alc_qsa_deinit, alc_qsa_probe, EmptyFuncs },
  84 #endif
  85 #ifdef HAVE_MMDEVAPI
  86     { "mmdevapi", ALCmmdevBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
  87 #endif
  88 #ifdef HAVE_DSOUND
  89     { "dsound", ALCdsoundBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
  90 #endif
  91 #ifdef HAVE_WINMM
  92     { "winmm", ALCwinmmBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
  93 #endif
  94 #ifdef HAVE_PORTAUDIO
  95     { "port", NULL, alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
  96 #endif
  97 #ifdef HAVE_OPENSL
  98     { "opensl", NULL, alc_opensl_init, alc_opensl_deinit, alc_opensl_probe, EmptyFuncs },
  99 #endif
 100
 101     { "null", ALCnullBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
 102 #ifdef HAVE_WAVE
 103     { "wave", ALCwaveBackendFactory_getFactory, NULL, NULL, NULL, EmptyFuncs },
 104 #endif
 105
 106     { NULL, NULL, NULL, NULL, NULL, EmptyFuncs }
 107 };
 108 #undef EmptyFuncs
 109
 110 static struct BackendInfo PlaybackBackend;
 111 static struct BackendInfo CaptureBackend;
 112
 113
 114 /************************************************
 115  * Functions, enums, and errors
 116  ************************************************/
 117 typedef struct ALCfunction {
 118     const ALCchar *funcName;
 119     ALCvoid *address;
 120 } ALCfunction;
 121
 122 typedef struct ALCenums {
 123     const ALCchar *enumName;
 124     ALCenum value;
 125 } ALCenums;
 126
 127 #define DECL(x) { #x, (ALCvoid*)(x) }
 128 static const ALCfunction alcFunctions[] = {
 129     DECL(alcCreateContext),
 130     DECL(alcMakeContextCurrent),
 131     DECL(alcProcessContext),
 132     DECL(alcSuspendContext),
 133     DECL(alcDestroyContext),
 134     DECL(alcGetCurrentContext),
 135     DECL(alcGetContextsDevice),
 136     DECL(alcOpenDevice),
 137     DECL(alcCloseDevice),
 138     DECL(alcGetError),
 139     DECL(alcIsExtensionPresent),
 140     DECL(alcGetProcAddress),
 141     DECL(alcGetEnumValue),
 142     DECL(alcGetString),
 143     DECL(alcGetIntegerv),
 144     DECL(alcCaptureOpenDevice),
 145     DECL(alcCaptureCloseDevice),
 146     DECL(alcCaptureStart),
 147     DECL(alcCaptureStop),
 148     DECL(alcCaptureSamples),
 149
 150     DECL(alcSetThreadContext),
 151     DECL(alcGetThreadContext),
 152
 153     DECL(alcLoopbackOpenDeviceSOFT),
 154     DECL(alcIsRenderFormatSupportedSOFT),
 155     DECL(alcRenderSamplesSOFT),
 156
 157     DECL(alcDevicePauseSOFT),
 158     DECL(alcDeviceResumeSOFT),
 159
 160     DECL(alcGetInteger64vSOFT),
 161
 162     DECL(alEnable),
 163     DECL(alDisable),
 164     DECL(alIsEnabled),
 165     DECL(alGetString),
 166     DECL(alGetBooleanv),
 167     DECL(alGetIntegerv),
 168     DECL(alGetFloatv),
 169     DECL(alGetDoublev),
 170     DECL(alGetBoolean),
 171     DECL(alGetInteger),
 172     DECL(alGetFloat),
 173     DECL(alGetDouble),
 174     DECL(alGetError),
 175     DECL(alIsExtensionPresent),
 176     DECL(alGetProcAddress),
 177     DECL(alGetEnumValue),
 178     DECL(alListenerf),
 179     DECL(alListener3f),
 180     DECL(alListenerfv),
 181     DECL(alListeneri),
 182     DECL(alListener3i),
 183     DECL(alListeneriv),
 184     DECL(alGetListenerf),
 185     DECL(alGetListener3f),
 186     DECL(alGetListenerfv),
 187     DECL(alGetListeneri),
 188     DECL(alGetListener3i),
 189     DECL(alGetListeneriv),
 190     DECL(alGenSources),
 191     DECL(alDeleteSources),
 192     DECL(alIsSource),
 193     DECL(alSourcef),
 194     DECL(alSource3f),
 195     DECL(alSourcefv),
 196     DECL(alSourcei),
 197     DECL(alSource3i),
 198     DECL(alSourceiv),
 199     DECL(alGetSourcef),
 200     DECL(alGetSource3f),
 201     DECL(alGetSourcefv),
 202     DECL(alGetSourcei),
 203     DECL(alGetSource3i),
 204     DECL(alGetSourceiv),
 205     DECL(alSourcePlayv),
 206     DECL(alSourceStopv),
 207     DECL(alSourceRewindv),
 208     DECL(alSourcePausev),
 209     DECL(alSourcePlay),
 210     DECL(alSourceStop),
 211     DECL(alSourceRewind),
 212     DECL(alSourcePause),
 213     DECL(alSourceQueueBuffers),
 214     DECL(alSourceUnqueueBuffers),
 215     DECL(alGenBuffers),
 216     DECL(alDeleteBuffers),
 217     DECL(alIsBuffer),
 218     DECL(alBufferData),
 219     DECL(alBufferf),
 220     DECL(alBuffer3f),
 221     DECL(alBufferfv),
 222     DECL(alBufferi),
 223     DECL(alBuffer3i),
 224     DECL(alBufferiv),
 225     DECL(alGetBufferf),
 226     DECL(alGetBuffer3f),
 227     DECL(alGetBufferfv),
 228     DECL(alGetBufferi),
 229     DECL(alGetBuffer3i),
 230     DECL(alGetBufferiv),
 231     DECL(alDopplerFactor),
 232     DECL(alDopplerVelocity),
 233     DECL(alSpeedOfSound),
 234     DECL(alDistanceModel),
 235
 236     DECL(alGenFilters),
 237     DECL(alDeleteFilters),
 238     DECL(alIsFilter),
 239     DECL(alFilteri),
 240     DECL(alFilteriv),
 241     DECL(alFilterf),
 242     DECL(alFilterfv),
 243     DECL(alGetFilteri),
 244     DECL(alGetFilteriv),
 245     DECL(alGetFilterf),
 246     DECL(alGetFilterfv),
 247     DECL(alGenEffects),
 248     DECL(alDeleteEffects),
 249     DECL(alIsEffect),
 250     DECL(alEffecti),
 251     DECL(alEffectiv),
 252     DECL(alEffectf),
 253     DECL(alEffectfv),
 254     DECL(alGetEffecti),
 255     DECL(alGetEffectiv),
 256     DECL(alGetEffectf),
 257     DECL(alGetEffectfv),
 258     DECL(alGenAuxiliaryEffectSlots),
 259     DECL(alDeleteAuxiliaryEffectSlots),
 260     DECL(alIsAuxiliaryEffectSlot),
 261     DECL(alAuxiliaryEffectSloti),
 262     DECL(alAuxiliaryEffectSlotiv),
 263     DECL(alAuxiliaryEffectSlotf),
 264     DECL(alAuxiliaryEffectSlotfv),
 265     DECL(alGetAuxiliaryEffectSloti),
 266     DECL(alGetAuxiliaryEffectSlotiv),
 267     DECL(alGetAuxiliaryEffectSlotf),
 268     DECL(alGetAuxiliaryEffectSlotfv),
 269
 270     DECL(alBufferSubDataSOFT),
 271
 272     DECL(alBufferSamplesSOFT),
 273     DECL(alBufferSubSamplesSOFT),
 274     DECL(alGetBufferSamplesSOFT),
 275     DECL(alIsBufferFormatSupportedSOFT),
 276
 277     DECL(alDeferUpdatesSOFT),
 278     DECL(alProcessUpdatesSOFT),
 279
 280     DECL(alSourcedSOFT),
 281     DECL(alSource3dSOFT),
 282     DECL(alSourcedvSOFT),
 283     DECL(alGetSourcedSOFT),
 284     DECL(alGetSource3dSOFT),
 285     DECL(alGetSourcedvSOFT),
 286     DECL(alSourcei64SOFT),
 287     DECL(alSource3i64SOFT),
 288     DECL(alSourcei64vSOFT),
 289     DECL(alGetSourcei64SOFT),
 290     DECL(alGetSource3i64SOFT),
 291     DECL(alGetSourcei64vSOFT),
 292
 293     DECL(alGenSoundfontsSOFT),
 294     DECL(alDeleteSoundfontsSOFT),
 295     DECL(alIsSoundfontSOFT),
 296     DECL(alGetSoundfontivSOFT),
 297     DECL(alSoundfontPresetsSOFT),
 298     DECL(alGenPresetsSOFT),
 299     DECL(alDeletePresetsSOFT),
 300     DECL(alIsPresetSOFT),
 301     DECL(alPresetiSOFT),
 302     DECL(alPresetivSOFT),
 303     DECL(alGetPresetivSOFT),
 304     DECL(alPresetFontsoundsSOFT),
 305     DECL(alGenFontsoundsSOFT),
 306     DECL(alDeleteFontsoundsSOFT),
 307     DECL(alIsFontsoundSOFT),
 308     DECL(alFontsoundiSOFT),
 309     DECL(alFontsound2iSOFT),
 310     DECL(alFontsoundivSOFT),
 311     DECL(alGetFontsoundivSOFT),
 312     DECL(alFontsoundModulatoriSOFT),
 313     DECL(alGetFontsoundModulatorivSOFT),
 314     DECL(alMidiSoundfontSOFT),
 315     DECL(alMidiSoundfontvSOFT),
 316     DECL(alMidiEventSOFT),
 317     DECL(alMidiSysExSOFT),
 318     DECL(alMidiPlaySOFT),
 319     DECL(alMidiPauseSOFT),
 320     DECL(alMidiStopSOFT),
 321     DECL(alMidiResetSOFT),
 322     DECL(alMidiGainSOFT),
 323     DECL(alGetInteger64SOFT),
 324     DECL(alGetInteger64vSOFT),
 325     DECL(alLoadSoundfontSOFT),
 326
 327     { NULL, NULL }
 328 };
 329 #undef DECL
 330
 331 #define DECL(x) { #x, (x) }
 332 static const ALCenums enumeration[] = {
 333     DECL(ALC_INVALID),
 334     DECL(ALC_FALSE),
 335     DECL(ALC_TRUE),
 336
 337     DECL(ALC_MAJOR_VERSION),
 338     DECL(ALC_MINOR_VERSION),
 339     DECL(ALC_ATTRIBUTES_SIZE),
 340     DECL(ALC_ALL_ATTRIBUTES),
 341     DECL(ALC_DEFAULT_DEVICE_SPECIFIER),
 342     DECL(ALC_DEVICE_SPECIFIER),
 343     DECL(ALC_ALL_DEVICES_SPECIFIER),
 344     DECL(ALC_DEFAULT_ALL_DEVICES_SPECIFIER),
 345     DECL(ALC_EXTENSIONS),
 346     DECL(ALC_FREQUENCY),
 347     DECL(ALC_REFRESH),
 348     DECL(ALC_SYNC),
 349     DECL(ALC_MONO_SOURCES),
 350     DECL(ALC_STEREO_SOURCES),
 351     DECL(ALC_CAPTURE_DEVICE_SPECIFIER),
 352     DECL(ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER),
 353     DECL(ALC_CAPTURE_SAMPLES),
 354     DECL(ALC_CONNECTED),
 355
 356     DECL(ALC_EFX_MAJOR_VERSION),
 357     DECL(ALC_EFX_MINOR_VERSION),
 358     DECL(ALC_MAX_AUXILIARY_SENDS),
 359
 360     DECL(ALC_FORMAT_CHANNELS_SOFT),
 361     DECL(ALC_FORMAT_TYPE_SOFT),
 362
 363     DECL(ALC_MONO_SOFT),
 364     DECL(ALC_STEREO_SOFT),
 365     DECL(ALC_QUAD_SOFT),
 366     DECL(ALC_5POINT1_SOFT),
 367     DECL(ALC_6POINT1_SOFT),
 368     DECL(ALC_7POINT1_SOFT),
 369
 370     DECL(ALC_BYTE_SOFT),
 371     DECL(ALC_UNSIGNED_BYTE_SOFT),
 372     DECL(ALC_SHORT_SOFT),
 373     DECL(ALC_UNSIGNED_SHORT_SOFT),
 374     DECL(ALC_INT_SOFT),
 375     DECL(ALC_UNSIGNED_INT_SOFT),
 376     DECL(ALC_FLOAT_SOFT),
 377
 378     DECL(ALC_NO_ERROR),
 379     DECL(ALC_INVALID_DEVICE),
 380     DECL(ALC_INVALID_CONTEXT),
 381     DECL(ALC_INVALID_ENUM),
 382     DECL(ALC_INVALID_VALUE),
 383     DECL(ALC_OUT_OF_MEMORY),
 384
 385
 386     DECL(AL_INVALID),
 387     DECL(AL_NONE),
 388     DECL(AL_FALSE),
 389     DECL(AL_TRUE),
 390
 391     DECL(AL_SOURCE_RELATIVE),
 392     DECL(AL_CONE_INNER_ANGLE),
 393     DECL(AL_CONE_OUTER_ANGLE),
 394     DECL(AL_PITCH),
 395     DECL(AL_POSITION),
 396     DECL(AL_DIRECTION),
 397     DECL(AL_VELOCITY),
 398     DECL(AL_LOOPING),
 399     DECL(AL_BUFFER),
 400     DECL(AL_GAIN),
 401     DECL(AL_MIN_GAIN),
 402     DECL(AL_MAX_GAIN),
 403     DECL(AL_ORIENTATION),
 404     DECL(AL_REFERENCE_DISTANCE),
 405     DECL(AL_ROLLOFF_FACTOR),
 406     DECL(AL_CONE_OUTER_GAIN),
 407     DECL(AL_MAX_DISTANCE),
 408     DECL(AL_SEC_OFFSET),
 409     DECL(AL_SAMPLE_OFFSET),
 410     DECL(AL_SAMPLE_RW_OFFSETS_SOFT),
 411     DECL(AL_BYTE_OFFSET),
 412     DECL(AL_BYTE_RW_OFFSETS_SOFT),
 413     DECL(AL_SOURCE_TYPE),
 414     DECL(AL_STATIC),
 415     DECL(AL_STREAMING),
 416     DECL(AL_UNDETERMINED),
 417     DECL(AL_METERS_PER_UNIT),
 418     DECL(AL_DIRECT_CHANNELS_SOFT),
 419
 420     DECL(AL_DIRECT_FILTER),
 421     DECL(AL_AUXILIARY_SEND_FILTER),
 422     DECL(AL_AIR_ABSORPTION_FACTOR),
 423     DECL(AL_ROOM_ROLLOFF_FACTOR),
 424     DECL(AL_CONE_OUTER_GAINHF),
 425     DECL(AL_DIRECT_FILTER_GAINHF_AUTO),
 426     DECL(AL_AUXILIARY_SEND_FILTER_GAIN_AUTO),
 427     DECL(AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO),
 428
 429     DECL(AL_SOURCE_STATE),
 430     DECL(AL_INITIAL),
 431     DECL(AL_PLAYING),
 432     DECL(AL_PAUSED),
 433     DECL(AL_STOPPED),
 434
 435     DECL(AL_BUFFERS_QUEUED),
 436     DECL(AL_BUFFERS_PROCESSED),
 437
 438     DECL(AL_FORMAT_MONO8),
 439     DECL(AL_FORMAT_MONO16),
 440     DECL(AL_FORMAT_MONO_FLOAT32),
 441     DECL(AL_FORMAT_MONO_DOUBLE_EXT),
 442     DECL(AL_FORMAT_STEREO8),
 443     DECL(AL_FORMAT_STEREO16),
 444     DECL(AL_FORMAT_STEREO_FLOAT32),
 445     DECL(AL_FORMAT_STEREO_DOUBLE_EXT),
 446     DECL(AL_FORMAT_MONO_IMA4),
 447     DECL(AL_FORMAT_STEREO_IMA4),
 448     DECL(AL_FORMAT_MONO_MSADPCM_SOFT),
 449     DECL(AL_FORMAT_STEREO_MSADPCM_SOFT),
 450     DECL(AL_FORMAT_QUAD8_LOKI),
 451     DECL(AL_FORMAT_QUAD16_LOKI),
 452     DECL(AL_FORMAT_QUAD8),
 453     DECL(AL_FORMAT_QUAD16),
 454     DECL(AL_FORMAT_QUAD32),
 455     DECL(AL_FORMAT_51CHN8),
 456     DECL(AL_FORMAT_51CHN16),
 457     DECL(AL_FORMAT_51CHN32),
 458     DECL(AL_FORMAT_61CHN8),
 459     DECL(AL_FORMAT_61CHN16),
 460     DECL(AL_FORMAT_61CHN32),
 461     DECL(AL_FORMAT_71CHN8),
 462     DECL(AL_FORMAT_71CHN16),
 463     DECL(AL_FORMAT_71CHN32),
 464     DECL(AL_FORMAT_REAR8),
 465     DECL(AL_FORMAT_REAR16),
 466     DECL(AL_FORMAT_REAR32),
 467     DECL(AL_FORMAT_MONO_MULAW),
 468     DECL(AL_FORMAT_MONO_MULAW_EXT),
 469     DECL(AL_FORMAT_STEREO_MULAW),
 470     DECL(AL_FORMAT_STEREO_MULAW_EXT),
 471     DECL(AL_FORMAT_QUAD_MULAW),
 472     DECL(AL_FORMAT_51CHN_MULAW),
 473     DECL(AL_FORMAT_61CHN_MULAW),
 474     DECL(AL_FORMAT_71CHN_MULAW),
 475     DECL(AL_FORMAT_REAR_MULAW),
 476     DECL(AL_FORMAT_MONO_ALAW_EXT),
 477     DECL(AL_FORMAT_STEREO_ALAW_EXT),
 478
 479     DECL(AL_MONO8_SOFT),
 480     DECL(AL_MONO16_SOFT),
 481     DECL(AL_MONO32F_SOFT),
 482     DECL(AL_STEREO8_SOFT),
 483     DECL(AL_STEREO16_SOFT),
 484     DECL(AL_STEREO32F_SOFT),
 485     DECL(AL_QUAD8_SOFT),
 486     DECL(AL_QUAD16_SOFT),
 487     DECL(AL_QUAD32F_SOFT),
 488     DECL(AL_REAR8_SOFT),
 489     DECL(AL_REAR16_SOFT),
 490     DECL(AL_REAR32F_SOFT),
 491     DECL(AL_5POINT1_8_SOFT),
 492     DECL(AL_5POINT1_16_SOFT),
 493     DECL(AL_5POINT1_32F_SOFT),
 494     DECL(AL_6POINT1_8_SOFT),
 495     DECL(AL_6POINT1_16_SOFT),
 496     DECL(AL_6POINT1_32F_SOFT),
 497     DECL(AL_7POINT1_8_SOFT),
 498     DECL(AL_7POINT1_16_SOFT),
 499     DECL(AL_7POINT1_32F_SOFT),
 500     DECL(AL_FORMAT_BFORMAT2D_8),
 501     DECL(AL_FORMAT_BFORMAT2D_16),
 502     DECL(AL_FORMAT_BFORMAT2D_FLOAT32),
 503     DECL(AL_FORMAT_BFORMAT2D_MULAW),
 504     DECL(AL_FORMAT_BFORMAT3D_8),
 505     DECL(AL_FORMAT_BFORMAT3D_16),
 506     DECL(AL_FORMAT_BFORMAT3D_FLOAT32),
 507     DECL(AL_FORMAT_BFORMAT3D_MULAW),
 508
 509     DECL(AL_MONO_SOFT),
 510     DECL(AL_STEREO_SOFT),
 511     DECL(AL_QUAD_SOFT),
 512     DECL(AL_REAR_SOFT),
 513     DECL(AL_5POINT1_SOFT),
 514     DECL(AL_6POINT1_SOFT),
 515     DECL(AL_7POINT1_SOFT),
 516
 517     DECL(AL_BYTE_SOFT),
 518     DECL(AL_UNSIGNED_BYTE_SOFT),
 519     DECL(AL_SHORT_SOFT),
 520     DECL(AL_UNSIGNED_SHORT_SOFT),
 521     DECL(AL_INT_SOFT),
 522     DECL(AL_UNSIGNED_INT_SOFT),
 523     DECL(AL_FLOAT_SOFT),
 524     DECL(AL_DOUBLE_SOFT),
 525     DECL(AL_BYTE3_SOFT),
 526     DECL(AL_UNSIGNED_BYTE3_SOFT),
 527
 528     DECL(AL_FREQUENCY),
 529     DECL(AL_BITS),
 530     DECL(AL_CHANNELS),
 531     DECL(AL_SIZE),
 532     DECL(AL_INTERNAL_FORMAT_SOFT),
 533     DECL(AL_BYTE_LENGTH_SOFT),
 534     DECL(AL_SAMPLE_LENGTH_SOFT),
 535     DECL(AL_SEC_LENGTH_SOFT),
 536     DECL(AL_UNPACK_BLOCK_ALIGNMENT_SOFT),
 537     DECL(AL_PACK_BLOCK_ALIGNMENT_SOFT),
 538
 539     DECL(AL_UNUSED),
 540     DECL(AL_PENDING),
 541     DECL(AL_PROCESSED),
 542
 543     DECL(AL_NO_ERROR),
 544     DECL(AL_INVALID_NAME),
 545     DECL(AL_INVALID_ENUM),
 546     DECL(AL_INVALID_VALUE),
 547     DECL(AL_INVALID_OPERATION),
 548     DECL(AL_OUT_OF_MEMORY),
 549
 550     DECL(AL_VENDOR),
 551     DECL(AL_VERSION),
 552     DECL(AL_RENDERER),
 553     DECL(AL_EXTENSIONS),
 554
 555     DECL(AL_DOPPLER_FACTOR),
 556     DECL(AL_DOPPLER_VELOCITY),
 557     DECL(AL_DISTANCE_MODEL),
 558     DECL(AL_SPEED_OF_SOUND),
 559     DECL(AL_SOURCE_DISTANCE_MODEL),
 560     DECL(AL_DEFERRED_UPDATES_SOFT),
 561
 562     DECL(AL_INVERSE_DISTANCE),
 563     DECL(AL_INVERSE_DISTANCE_CLAMPED),
 564     DECL(AL_LINEAR_DISTANCE),
 565     DECL(AL_LINEAR_DISTANCE_CLAMPED),
 566     DECL(AL_EXPONENT_DISTANCE),
 567     DECL(AL_EXPONENT_DISTANCE_CLAMPED),
 568
 569     DECL(AL_FILTER_TYPE),
 570     DECL(AL_FILTER_NULL),
 571     DECL(AL_FILTER_LOWPASS),
 572     DECL(AL_FILTER_HIGHPASS),
 573     DECL(AL_FILTER_BANDPASS),
 574
 575     DECL(AL_LOWPASS_GAIN),
 576     DECL(AL_LOWPASS_GAINHF),
 577
 578     DECL(AL_HIGHPASS_GAIN),
 579     DECL(AL_HIGHPASS_GAINLF),
 580
 581     DECL(AL_BANDPASS_GAIN),
 582     DECL(AL_BANDPASS_GAINHF),
 583     DECL(AL_BANDPASS_GAINLF),
 584
 585     DECL(AL_EFFECT_TYPE),
 586     DECL(AL_EFFECT_NULL),
 587     DECL(AL_EFFECT_REVERB),
 588     DECL(AL_EFFECT_EAXREVERB),
 589     DECL(AL_EFFECT_CHORUS),
 590     DECL(AL_EFFECT_DISTORTION),
 591     DECL(AL_EFFECT_ECHO),
 592     DECL(AL_EFFECT_FLANGER),
 593 #if 0
 594     DECL(AL_EFFECT_FREQUENCY_SHIFTER),
 595     DECL(AL_EFFECT_VOCAL_MORPHER),
 596     DECL(AL_EFFECT_PITCH_SHIFTER),
 597 #endif
 598     DECL(AL_EFFECT_RING_MODULATOR),
 599 #if 0
 600     DECL(AL_EFFECT_AUTOWAH),
 601 #endif
 602     DECL(AL_EFFECT_COMPRESSOR),
 603     DECL(AL_EFFECT_EQUALIZER),
 604     DECL(AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT),
 605     DECL(AL_EFFECT_DEDICATED_DIALOGUE),
 606
 607     DECL(AL_EAXREVERB_DENSITY),
 608     DECL(AL_EAXREVERB_DIFFUSION),
 609     DECL(AL_EAXREVERB_GAIN),
 610     DECL(AL_EAXREVERB_GAINHF),
 611     DECL(AL_EAXREVERB_GAINLF),
 612     DECL(AL_EAXREVERB_DECAY_TIME),
 613     DECL(AL_EAXREVERB_DECAY_HFRATIO),
 614     DECL(AL_EAXREVERB_DECAY_LFRATIO),
 615     DECL(AL_EAXREVERB_REFLECTIONS_GAIN),
 616     DECL(AL_EAXREVERB_REFLECTIONS_DELAY),
 617     DECL(AL_EAXREVERB_REFLECTIONS_PAN),
 618     DECL(AL_EAXREVERB_LATE_REVERB_GAIN),
 619     DECL(AL_EAXREVERB_LATE_REVERB_DELAY),
 620     DECL(AL_EAXREVERB_LATE_REVERB_PAN),
 621     DECL(AL_EAXREVERB_ECHO_TIME),
 622     DECL(AL_EAXREVERB_ECHO_DEPTH),
 623     DECL(AL_EAXREVERB_MODULATION_TIME),
 624     DECL(AL_EAXREVERB_MODULATION_DEPTH),
 625     DECL(AL_EAXREVERB_AIR_ABSORPTION_GAINHF),
 626     DECL(AL_EAXREVERB_HFREFERENCE),
 627     DECL(AL_EAXREVERB_LFREFERENCE),
 628     DECL(AL_EAXREVERB_ROOM_ROLLOFF_FACTOR),
 629     DECL(AL_EAXREVERB_DECAY_HFLIMIT),
 630
 631     DECL(AL_REVERB_DENSITY),
 632     DECL(AL_REVERB_DIFFUSION),
 633     DECL(AL_REVERB_GAIN),
 634     DECL(AL_REVERB_GAINHF),
 635     DECL(AL_REVERB_DECAY_TIME),
 636     DECL(AL_REVERB_DECAY_HFRATIO),
 637     DECL(AL_REVERB_REFLECTIONS_GAIN),
 638     DECL(AL_REVERB_REFLECTIONS_DELAY),
 639     DECL(AL_REVERB_LATE_REVERB_GAIN),
 640     DECL(AL_REVERB_LATE_REVERB_DELAY),
 641     DECL(AL_REVERB_AIR_ABSORPTION_GAINHF),
 642     DECL(AL_REVERB_ROOM_ROLLOFF_FACTOR),
 643     DECL(AL_REVERB_DECAY_HFLIMIT),
 644
 645     DECL(AL_CHORUS_WAVEFORM),
 646     DECL(AL_CHORUS_PHASE),
 647     DECL(AL_CHORUS_RATE),
 648     DECL(AL_CHORUS_DEPTH),
 649     DECL(AL_CHORUS_FEEDBACK),
 650     DECL(AL_CHORUS_DELAY),
 651
 652     DECL(AL_DISTORTION_EDGE),
 653     DECL(AL_DISTORTION_GAIN),
 654     DECL(AL_DISTORTION_LOWPASS_CUTOFF),
 655     DECL(AL_DISTORTION_EQCENTER),
 656     DECL(AL_DISTORTION_EQBANDWIDTH),
 657
 658     DECL(AL_ECHO_DELAY),
 659     DECL(AL_ECHO_LRDELAY),
 660     DECL(AL_ECHO_DAMPING),
 661     DECL(AL_ECHO_FEEDBACK),
 662     DECL(AL_ECHO_SPREAD),
 663
 664     DECL(AL_FLANGER_WAVEFORM),
 665     DECL(AL_FLANGER_PHASE),
 666     DECL(AL_FLANGER_RATE),
 667     DECL(AL_FLANGER_DEPTH),
 668     DECL(AL_FLANGER_FEEDBACK),
 669     DECL(AL_FLANGER_DELAY),
 670
 671     DECL(AL_RING_MODULATOR_FREQUENCY),
 672     DECL(AL_RING_MODULATOR_HIGHPASS_CUTOFF),
 673     DECL(AL_RING_MODULATOR_WAVEFORM),
 674
 675 #if 0
 676     DECL(AL_AUTOWAH_ATTACK_TIME),
 677     DECL(AL_AUTOWAH_PEAK_GAIN),
 678     DECL(AL_AUTOWAH_RELEASE_TIME),
 679     DECL(AL_AUTOWAH_RESONANCE),
 680 #endif
 681
 682     DECL(AL_COMPRESSOR_ONOFF),
 683
 684     DECL(AL_EQUALIZER_LOW_GAIN),
 685     DECL(AL_EQUALIZER_LOW_CUTOFF),
 686     DECL(AL_EQUALIZER_MID1_GAIN),
 687     DECL(AL_EQUALIZER_MID1_CENTER),
 688     DECL(AL_EQUALIZER_MID1_WIDTH),
 689     DECL(AL_EQUALIZER_MID2_GAIN),
 690     DECL(AL_EQUALIZER_MID2_CENTER),
 691     DECL(AL_EQUALIZER_MID2_WIDTH),
 692     DECL(AL_EQUALIZER_HIGH_GAIN),
 693     DECL(AL_EQUALIZER_HIGH_CUTOFF),
 694
 695     DECL(AL_DEDICATED_GAIN),
 696
 697     { NULL, (ALCenum)0 }
 698 };
 699 #undef DECL
 700
 701 static const ALCchar alcNoError[] = "No Error";
 702 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
 703 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
 704 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
 705 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
 706 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
 707
 708
 709 /************************************************
 710  * Global variables
 711  ************************************************/
 712
 713 /* Enumerated device names */
 714 static const ALCchar alcDefaultName[] = "OpenAL Soft\0";
 715
 716 static al_string alcAllDevicesList;
 717 static al_string alcCaptureDeviceList;
 718
 719 /* Default is always the first in the list */
 720 static ALCchar *alcDefaultAllDevicesSpecifier;
 721 static ALCchar *alcCaptureDefaultDeviceSpecifier;
 722
 723 /* Default context extensions */
 724 static const ALchar alExtList[] =
 725     "AL_EXT_ALAW AL_EXT_BFORMAT AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE "
 726     "AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS "
 727     "AL_EXT_MULAW AL_EXT_MULAW_BFORMAT AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET "
 728     "AL_EXT_source_distance_model AL_LOKI_quadriphonic AL_SOFT_block_alignment "
 729     "AL_SOFT_buffer_samples AL_SOFT_buffer_sub_data AL_SOFT_deferred_updates "
 730     "AL_SOFT_direct_channels AL_SOFT_loop_points AL_SOFT_MSADPCM "
 731     "AL_SOFT_source_latency AL_SOFT_source_length";
 732
 733 static ATOMIC(ALCenum) LastNullDeviceError = ATOMIC_INIT_STATIC(ALC_NO_ERROR);
 734
 735 /* Thread-local current context */
 736 static altss_t LocalContext;
 737 /* Process-wide current context */
 738 static ATOMIC(ALCcontext*) GlobalContext = ATOMIC_INIT_STATIC(NULL);
 739
 740 /* Mixing thread piority level */
 741 ALint RTPrioLevel;
 742
 743 FILE *LogFile;
 744 #ifdef _DEBUG
 745 enum LogLevel LogLevel = LogWarning;
 746 #else
 747 enum LogLevel LogLevel = LogError;
 748 #endif
 749
 750 /* Flag to trap ALC device errors */
 751 static ALCboolean TrapALCError = ALC_FALSE;
 752
 753 /* One-time configuration init control */
 754 static alonce_flag alc_config_once = AL_ONCE_FLAG_INIT;
 755
 756 /* Default effect that applies to sources that don't have an effect on send 0 */
 757 static ALeffect DefaultEffect;
 758
 759 /* Flag to specify if alcSuspendContext/alcProcessContext should defer/process
 760  * updates.
 761  */
 762 static ALCboolean SuspendDefers = ALC_TRUE;
 763
 764
 765 /************************************************
 766  * ALC information
 767  ************************************************/
 768 static const ALCchar alcNoDeviceExtList[] =
 769     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
 770     "ALC_EXT_thread_local_context ALC_SOFT_loopback";
 771 static const ALCchar alcExtensionList[] =
 772     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
 773     "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
 774     "ALC_EXT_thread_local_context ALC_SOFTX_device_clock ALC_SOFTX_HRTF "
 775     "ALC_SOFT_loopback ALC_SOFTX_midi_interface ALC_SOFT_pause_device";
 776 static const ALCint alcMajorVersion = 1;
 777 static const ALCint alcMinorVersion = 1;
 778
 779 static const ALCint alcEFXMajorVersion = 1;
 780 static const ALCint alcEFXMinorVersion = 0;
 781
 782
 783 /************************************************
 784  * Device lists
 785  ************************************************/
 786 static ATOMIC(ALCdevice*) DeviceList = ATOMIC_INIT_STATIC(NULL);
 787
 788 static almtx_t ListLock;
 789 static inline void LockLists(void)
 790 {
 791     int lockret = almtx_lock(&ListLock);
 792     assert(lockret == althrd_success);
 793 }
 794 static inline void UnlockLists(void)
 795 {
 796     int unlockret = almtx_unlock(&ListLock);
 797     assert(unlockret == althrd_success);
 798 }
 799
 800 /************************************************
 801  * Library initialization
 802  ************************************************/
 803 #if defined(_WIN32)
 804 static void alc_init(void);
 805 static void alc_deinit(void);
 806 static void alc_deinit_safe(void);
 807
 808 #ifndef AL_LIBTYPE_STATIC
 809 BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD reason, LPVOID lpReserved)
 810 {
 811     switch(reason)
 812     {
 813         case DLL_PROCESS_ATTACH:
 814             /* Pin the DLL so we won't get unloaded until the process terminates */
 815             GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
 816                                (WCHAR*)hModule, &hModule);
 817             alc_init();
 818             break;
 819
 820         case DLL_THREAD_DETACH:
 821             break;
 822
 823         case DLL_PROCESS_DETACH:
 824             if(!lpReserved)
 825                 alc_deinit();
 826             else
 827                 alc_deinit_safe();
 828             break;
 829     }
 830     return TRUE;
 831 }
 832 #elif defined(_MSC_VER)
 833 #pragma section(".CRT$XCU",read)
 834 static void alc_constructor(void);
 835 static void alc_destructor(void);
 836 __declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;
 837
 838 static void alc_constructor(void)
 839 {
 840     atexit(alc_destructor);
 841     alc_init();
 842 }
 843
 844 static void alc_destructor(void)
 845 {
 846     alc_deinit();
 847 }
 848 #elif defined(HAVE_GCC_DESTRUCTOR)
 849 static void alc_init(void) __attribute__((constructor));
 850 static void alc_deinit(void) __attribute__((destructor));
 851 #else
 852 #error "No static initialization available on this platform!"
 853 #endif
 854
 855 #elif defined(HAVE_GCC_DESTRUCTOR)
 856
 857 static void alc_init(void) __attribute__((constructor));
 858 static void alc_deinit(void) __attribute__((destructor));
 859
 860 #else
 861 #error "No global initialization available on this platform!"
 862 #endif
 863
 864 static void ReleaseThreadCtx(void *ptr);
 865 static void alc_init(void)
 866 {
 867     const char *str;
 868     int ret;
 869
 870     LogFile = stderr;
 871
 872     AL_STRING_INIT(alcAllDevicesList);
 873     AL_STRING_INIT(alcCaptureDeviceList);
 874
 875     str = getenv("__ALSOFT_HALF_ANGLE_CONES");
 876     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
 877         ConeScale *= 0.5f;
 878
 879     str = getenv("__ALSOFT_REVERSE_Z");
 880     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
 881         ZScale *= -1.0f;
 882
 883     ret = altss_create(&LocalContext, ReleaseThreadCtx);
 884     assert(ret == althrd_success);
 885
 886     ret = almtx_init(&ListLock, almtx_recursive);
 887     assert(ret == althrd_success);
 888
 889     ThunkInit();
 890 }
 891
 892 static void alc_initconfig(void)
 893 {
 894     const char *devs, *str;
 895     ALuint capfilter;
 896     float valf;
 897     int i, n;
 898
 899     str = getenv("ALSOFT_LOGLEVEL");
 900     if(str)
 901     {
 902         long lvl = strtol(str, NULL, 0);
 903         if(lvl >= NoLog && lvl <= LogRef)
 904             LogLevel = lvl;
 905     }
 906
 907     str = getenv("ALSOFT_LOGFILE");
 908     if(str && str[0])
 909     {
 910         FILE *logfile = al_fopen(str, "wt");
 911         if(logfile) LogFile = logfile;
 912         else ERR("Failed to open log file '%s'\n", str);
 913     }
 914
 915     {
 916         char buf[1024] = "";
 917         int len = snprintf(buf, sizeof(buf), "%s", BackendList[0].name);
 918         for(i = 1;BackendList[i].name;i++)
 919             len += snprintf(buf+len, sizeof(buf)-len, ", %s", BackendList[i].name);
 920         TRACE("Supported backends: %s\n", buf);
 921     }
 922     ReadALConfig();
 923
 924     str = getenv("__ALSOFT_SUSPEND_CONTEXT");
 925     if(str && *str)
 926     {
 927         if(strcasecmp(str, "ignore") == 0)
 928         {
 929             SuspendDefers = ALC_FALSE;
 930             TRACE("Selected context suspend behavior, \"ignore\"\n");
 931         }
 932         else
 933             ERR("Unhandled context suspend behavior setting: \"%s\"\n", str);
 934     }
 935
 936     capfilter = 0;
 937 #if defined(HAVE_SSE4_1)
 938     capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE4_1;
 939 #elif defined(HAVE_SSE2)
 940     capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2;
 941 #elif defined(HAVE_SSE)
 942     capfilter |= CPU_CAP_SSE;
 943 #endif
 944 #ifdef HAVE_NEON
 945     capfilter |= CPU_CAP_NEON;
 946 #endif
 947     if(ConfigValueStr(NULL, "disable-cpu-exts", &str))
 948     {
 949         if(strcasecmp(str, "all") == 0)
 950             capfilter = 0;
 951         else
 952         {
 953             size_t len;
 954             const char *next = str;
 955
 956             do {
 957                 str = next;
 958                 while(isspace(str[0]))
 959                     str++;
 960                 next = strchr(str, ',');
 961
 962                 if(!str[0] || str[0] == ',')
 963                     continue;
 964
 965                 len = (next ? ((size_t)(next-str)) : strlen(str));
 966                 while(len > 0 && isspace(str[len-1]))
 967                     len--;
 968                 if(len == 3 && strncasecmp(str, "sse", len) == 0)
 969                     capfilter &= ~CPU_CAP_SSE;
 970                 else if(len == 4 && strncasecmp(str, "sse2", len) == 0)
 971                     capfilter &= ~CPU_CAP_SSE2;
 972                 else if(len == 6 && strncasecmp(str, "sse4.1", len) == 0)
 973                     capfilter &= ~CPU_CAP_SSE4_1;
 974                 else if(len == 4 && strncasecmp(str, "neon", len) == 0)
 975                     capfilter &= ~CPU_CAP_NEON;
 976                 else
 977                     WARN("Invalid CPU extension \"%s\"\n", str);
 978             } while(next++);
 979         }
 980     }
 981     FillCPUCaps(capfilter);
 982
 983 #ifdef _WIN32
 984     RTPrioLevel = 1;
 985 #else
 986     RTPrioLevel = 0;
 987 #endif
 988     ConfigValueInt(NULL, "rt-prio", &RTPrioLevel);
 989
 990     if(ConfigValueStr(NULL, "resampler", &str))
 991     {
 992         if(strcasecmp(str, "point") == 0 || strcasecmp(str, "none") == 0)
 993             DefaultResampler = PointResampler;
 994         else if(strcasecmp(str, "linear") == 0)
 995             DefaultResampler = LinearResampler;
 996         else if(strcasecmp(str, "cubic") == 0)
 997             DefaultResampler = CubicResampler;
 998         else
 999         {
1000             char *end;
1001
1002             n = strtol(str, &end, 0);
1003             if(*end == '\0' && (n == PointResampler || n == LinearResampler || n == CubicResampler))
1004                 DefaultResampler = n;
1005             else
1006                 WARN("Invalid resampler: %s\n", str);
1007         }
1008     }
1009
1010     str = getenv("ALSOFT_TRAP_ERROR");
1011     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
1012     {
1013         TrapALError  = AL_TRUE;
1014         TrapALCError = AL_TRUE;
1015     }
1016     else
1017     {
1018         str = getenv("ALSOFT_TRAP_AL_ERROR");
1019         if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
1020             TrapALError = AL_TRUE;
1021         TrapALError = GetConfigValueBool(NULL, "trap-al-error", TrapALError);
1022
1023         str = getenv("ALSOFT_TRAP_ALC_ERROR");
1024         if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
1025             TrapALCError = ALC_TRUE;
1026         TrapALCError = GetConfigValueBool(NULL, "trap-alc-error", TrapALCError);
1027     }
1028
1029     if(ConfigValueFloat("reverb", "boost", &valf))
1030         ReverbBoost *= powf(10.0f, valf / 20.0f);
1031
1032     EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);
1033
1034     if(((devs=getenv("ALSOFT_DRIVERS")) && devs[0]) ||
1035        ConfigValueStr(NULL, "drivers", &devs))
1036     {
1037         int n;
1038         size_t len;
1039         const char *next = devs;
1040         int endlist, delitem;
1041
1042         i = 0;
1043         do {
1044             devs = next;
1045             while(isspace(devs[0]))
1046                 devs++;
1047             next = strchr(devs, ',');
1048
1049             delitem = (devs[0] == '-');
1050             if(devs[0] == '-') devs++;
1051
1052             if(!devs[0] || devs[0] == ',')
1053             {
1054                 endlist = 0;
1055                 continue;
1056             }
1057             endlist = 1;
1058
1059             len = (next ? ((size_t)(next-devs)) : strlen(devs));
1060             while(len > 0 && isspace(devs[len-1]))
1061                 len--;
1062             for(n = i;BackendList[n].name;n++)
1063             {
1064                 if(len == strlen(BackendList[n].name) &&
1065                    strncmp(BackendList[n].name, devs, len) == 0)
1066                 {
1067                     if(delitem)
1068                     {
1069                         do {
1070                             BackendList[n] = BackendList[n+1];
1071                             ++n;
1072                         } while(BackendList[n].name);
1073                     }
1074                     else
1075                     {
1076                         struct BackendInfo Bkp = BackendList[n];
1077                         while(n > i)
1078                         {
1079                             BackendList[n] = BackendList[n-1];
1080                             --n;
1081                         }
1082                         BackendList[n] = Bkp;
1083
1084                         i++;
1085                     }
1086                     break;
1087                 }
1088             }
1089         } while(next++);
1090
1091         if(endlist)
1092         {
1093             BackendList[i].name = NULL;
1094             BackendList[i].getFactory = NULL;
1095             BackendList[i].Init = NULL;
1096             BackendList[i].Deinit = NULL;
1097             BackendList[i].Probe = NULL;
1098         }
1099     }
1100
1101     for(i = 0;(BackendList[i].Init || BackendList[i].getFactory) && (!PlaybackBackend.name || !CaptureBackend.name);i++)
1102     {
1103         if(BackendList[i].getFactory)
1104         {
1105             ALCbackendFactory *factory = BackendList[i].getFactory();
1106             if(!V0(factory,init)())
1107             {
1108                 WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
1109                 continue;
1110             }
1111
1112             TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
1113             if(!PlaybackBackend.name && V(factory,querySupport)(ALCbackend_Playback))
1114             {
1115                 PlaybackBackend = BackendList[i];
1116                 TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
1117             }
1118             if(!CaptureBackend.name && V(factory,querySupport)(ALCbackend_Capture))
1119             {
1120                 CaptureBackend = BackendList[i];
1121                 TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
1122             }
1123
1124             continue;
1125         }
1126
1127         if(!BackendList[i].Init(&BackendList[i].Funcs))
1128         {
1129             WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
1130             continue;
1131         }
1132
1133         TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
1134         if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
1135         {
1136             PlaybackBackend = BackendList[i];
1137             TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
1138         }
1139         if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
1140         {
1141             CaptureBackend = BackendList[i];
1142             TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
1143         }
1144     }
1145     {
1146         ALCbackendFactory *factory = ALCloopbackFactory_getFactory();
1147         V0(factory,init)();
1148     }
1149
1150     if(ConfigValueStr(NULL, "excludefx", &str))
1151     {
1152         size_t len;
1153         const char *next = str;
1154
1155         do {
1156             str = next;
1157             next = strchr(str, ',');
1158
1159             if(!str[0] || next == str)
1160                 continue;
1161
1162             len = (next ? ((size_t)(next-str)) : strlen(str));
1163             for(n = 0;EffectList[n].name;n++)
1164             {
1165                 if(len == strlen(EffectList[n].name) &&
1166                    strncmp(EffectList[n].name, str, len) == 0)
1167                     DisabledEffects[EffectList[n].type] = AL_TRUE;
1168             }
1169         } while(next++);
1170     }
1171
1172     InitEffectFactoryMap();
1173
1174     InitEffect(&DefaultEffect);
1175     str = getenv("ALSOFT_DEFAULT_REVERB");
1176     if((str && str[0]) || ConfigValueStr(NULL, "default-reverb", &str))
1177         LoadReverbPreset(str, &DefaultEffect);
1178 }
1179 #define DO_INITCONFIG() alcall_once(&alc_config_once, alc_initconfig)
1180
1181
1182 /************************************************
1183  * Library deinitialization
1184  ************************************************/
1185 static void alc_cleanup(void)
1186 {
1187     ALCdevice *dev;
1188
1189     AL_STRING_DEINIT(alcAllDevicesList);
1190     AL_STRING_DEINIT(alcCaptureDeviceList);
1191
1192     free(alcDefaultAllDevicesSpecifier);
1193     alcDefaultAllDevicesSpecifier = NULL;
1194     free(alcCaptureDefaultDeviceSpecifier);
1195     alcCaptureDefaultDeviceSpecifier = NULL;
1196
1197     if((dev=ATOMIC_EXCHANGE(ALCdevice*, &DeviceList, NULL)) != NULL)
1198     {
1199         ALCuint num = 0;
1200         do {
1201             num++;
1202         } while((dev=dev->next) != NULL);
1203         ERR("%u device%s not closed\n", num, (num>1)?"s":"");
1204     }
1205
1206     DeinitEffectFactoryMap();
1207 }
1208
1209 static void alc_deinit_safe(void)
1210 {
1211     alc_cleanup();
1212
1213     FreeHrtfs();
1214     FreeALConfig();
1215
1216     ThunkExit();
1217     almtx_destroy(&ListLock);
1218     altss_delete(LocalContext);
1219
1220     if(LogFile != stderr)
1221         fclose(LogFile);
1222     LogFile = NULL;
1223 }
1224
1225 static void alc_deinit(void)
1226 {
1227     int i;
1228
1229     alc_cleanup();
1230
1231     memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
1232     memset(&CaptureBackend, 0, sizeof(CaptureBackend));
1233
1234     for(i = 0;BackendList[i].Deinit || BackendList[i].getFactory;i++)
1235     {
1236         if(!BackendList[i].getFactory)
1237             BackendList[i].Deinit();
1238         else
1239         {
1240             ALCbackendFactory *factory = BackendList[i].getFactory();
1241             V0(factory,deinit)();
1242         }
1243     }
1244     {
1245         ALCbackendFactory *factory = ALCloopbackFactory_getFactory();
1246         V0(factory,deinit)();
1247     }
1248
1249     alc_deinit_safe();
1250 }
1251
1252
1253 /************************************************
1254  * Device enumeration
1255  ************************************************/
1256 static void ProbeDevices(al_string *list, enum DevProbe type)
1257 {
1258     DO_INITCONFIG();
1259
1260     LockLists();
1261     al_string_clear(list);
1262
1263     if(type == ALL_DEVICE_PROBE && (PlaybackBackend.Probe || PlaybackBackend.getFactory))
1264     {
1265         if(!PlaybackBackend.getFactory)
1266             PlaybackBackend.Probe(type);
1267         else
1268         {
1269             ALCbackendFactory *factory = PlaybackBackend.getFactory();
1270             V(factory,probe)(type);
1271         }
1272     }
1273     else if(type == CAPTURE_DEVICE_PROBE && (CaptureBackend.Probe || CaptureBackend.getFactory))
1274     {
1275         if(!CaptureBackend.getFactory)
1276             CaptureBackend.Probe(type);
1277         else
1278         {
1279             ALCbackendFactory *factory = CaptureBackend.getFactory();
1280             V(factory,probe)(type);
1281         }
1282     }
1283     UnlockLists();
1284 }
1285 static void ProbeAllDevicesList(void)
1286 { ProbeDevices(&alcAllDevicesList, ALL_DEVICE_PROBE); }
1287 static void ProbeCaptureDeviceList(void)
1288 { ProbeDevices(&alcCaptureDeviceList, CAPTURE_DEVICE_PROBE); }
1289
1290 static void AppendDevice(const ALCchar *name, al_string *devnames)
1291 {
1292     size_t len = strlen(name);
1293     if(len > 0)
1294         al_string_append_range(devnames, name, name+len+1);
1295 }
1296 void AppendAllDevicesList(const ALCchar *name)
1297 { AppendDevice(name, &alcAllDevicesList); }
1298 void AppendCaptureDeviceList(const ALCchar *name)
1299 { AppendDevice(name, &alcCaptureDeviceList); }
1300
1301
1302 /************************************************
1303  * Device format information
1304  ************************************************/
1305 const ALCchar *DevFmtTypeString(enum DevFmtType type)
1306 {
1307     switch(type)
1308     {
1309     case DevFmtByte: return "Signed Byte";
1310     case DevFmtUByte: return "Unsigned Byte";
1311     case DevFmtShort: return "Signed Short";
1312     case DevFmtUShort: return "Unsigned Short";
1313     case DevFmtInt: return "Signed Int";
1314     case DevFmtUInt: return "Unsigned Int";
1315     case DevFmtFloat: return "Float";
1316     }
1317     return "(unknown type)";
1318 }
1319 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
1320 {
1321     switch(chans)
1322     {
1323     case DevFmtMono: return "Mono";
1324     case DevFmtStereo: return "Stereo";
1325     case DevFmtQuad: return "Quadraphonic";
1326     case DevFmtX51: return "5.1 Surround";
1327     case DevFmtX51Rear: return "5.1 Surround (Rear)";
1328     case DevFmtX61: return "6.1 Surround";
1329     case DevFmtX71: return "7.1 Surround";
1330     }
1331     return "(unknown channels)";
1332 }
1333
1334 extern inline ALuint FrameSizeFromDevFmt(enum DevFmtChannels chans, enum DevFmtType type);
1335 ALuint BytesFromDevFmt(enum DevFmtType type)
1336 {
1337     switch(type)
1338     {
1339     case DevFmtByte: return sizeof(ALbyte);
1340     case DevFmtUByte: return sizeof(ALubyte);
1341     case DevFmtShort: return sizeof(ALshort);
1342     case DevFmtUShort: return sizeof(ALushort);
1343     case DevFmtInt: return sizeof(ALint);
1344     case DevFmtUInt: return sizeof(ALuint);
1345     case DevFmtFloat: return sizeof(ALfloat);
1346     }
1347     return 0;
1348 }
1349 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
1350 {
1351     switch(chans)
1352     {
1353     case DevFmtMono: return 1;
1354     case DevFmtStereo: return 2;
1355     case DevFmtQuad: return 4;
1356     case DevFmtX51: return 6;
1357     case DevFmtX51Rear: return 6;
1358     case DevFmtX61: return 7;
1359     case DevFmtX71: return 8;
1360     }
1361     return 0;
1362 }
1363
1364 DECL_CONST static ALboolean DecomposeDevFormat(ALenum format,
1365   enum DevFmtChannels *chans, enum DevFmtType *type)
1366 {
1367     static const struct {
1368         ALenum format;
1369         enum DevFmtChannels channels;
1370         enum DevFmtType type;
1371     } list[] = {
1372         { AL_FORMAT_MONO8,        DevFmtMono, DevFmtUByte },
1373         { AL_FORMAT_MONO16,       DevFmtMono, DevFmtShort },
1374         { AL_FORMAT_MONO_FLOAT32, DevFmtMono, DevFmtFloat },
1375
1376         { AL_FORMAT_STEREO8,        DevFmtStereo, DevFmtUByte },
1377         { AL_FORMAT_STEREO16,       DevFmtStereo, DevFmtShort },
1378         { AL_FORMAT_STEREO_FLOAT32, DevFmtStereo, DevFmtFloat },
1379
1380         { AL_FORMAT_QUAD8,  DevFmtQuad, DevFmtUByte },
1381         { AL_FORMAT_QUAD16, DevFmtQuad, DevFmtShort },
1382         { AL_FORMAT_QUAD32, DevFmtQuad, DevFmtFloat },
1383
1384         { AL_FORMAT_51CHN8,  DevFmtX51, DevFmtUByte },
1385         { AL_FORMAT_51CHN16, DevFmtX51, DevFmtShort },
1386         { AL_FORMAT_51CHN32, DevFmtX51, DevFmtFloat },
1387
1388         { AL_FORMAT_61CHN8,  DevFmtX61, DevFmtUByte },
1389         { AL_FORMAT_61CHN16, DevFmtX61, DevFmtShort },
1390         { AL_FORMAT_61CHN32, DevFmtX61, DevFmtFloat },
1391
1392         { AL_FORMAT_71CHN8,  DevFmtX71, DevFmtUByte },
1393         { AL_FORMAT_71CHN16, DevFmtX71, DevFmtShort },
1394         { AL_FORMAT_71CHN32, DevFmtX71, DevFmtFloat },
1395     };
1396     ALuint i;
1397
1398     for(i = 0;i < COUNTOF(list);i++)
1399     {
1400         if(list[i].format == format)
1401         {
1402             *chans = list[i].channels;
1403             *type  = list[i].type;
1404             return AL_TRUE;
1405         }
1406     }
1407
1408     return AL_FALSE;
1409 }
1410
1411 DECL_CONST static ALCboolean IsValidALCType(ALCenum type)
1412 {
1413     switch(type)
1414     {
1415         case ALC_BYTE_SOFT:
1416         case ALC_UNSIGNED_BYTE_SOFT:
1417         case ALC_SHORT_SOFT:
1418         case ALC_UNSIGNED_SHORT_SOFT:
1419         case ALC_INT_SOFT:
1420         case ALC_UNSIGNED_INT_SOFT:
1421         case ALC_FLOAT_SOFT:
1422             return ALC_TRUE;
1423     }
1424     return ALC_FALSE;
1425 }
1426
1427 DECL_CONST static ALCboolean IsValidALCChannels(ALCenum channels)
1428 {
1429     switch(channels)
1430     {
1431         case ALC_MONO_SOFT:
1432         case ALC_STEREO_SOFT:
1433         case ALC_QUAD_SOFT:
1434         case ALC_5POINT1_SOFT:
1435         case ALC_6POINT1_SOFT:
1436         case ALC_7POINT1_SOFT:
1437             return ALC_TRUE;
1438     }
1439     return ALC_FALSE;
1440 }
1441
1442
1443 /************************************************
1444  * Miscellaneous ALC helpers
1445  ************************************************/
1446 extern inline void LockContext(ALCcontext *context);
1447 extern inline void UnlockContext(ALCcontext *context);
1448
1449 ALint64 ALCdevice_GetLatency(ALCdevice *device)
1450 {
1451     return V0(device->Backend,getLatency)();
1452 }
1453
1454 void ALCdevice_Lock(ALCdevice *device)
1455 {
1456     V0(device->Backend,lock)();
1457 }
1458
1459 void ALCdevice_Unlock(ALCdevice *device)
1460 {
1461     V0(device->Backend,unlock)();
1462 }
1463
1464
1465 /* SetDefaultWFXChannelOrder
1466  *
1467  * Sets the default channel order used by WaveFormatEx.
1468  */
1469 void SetDefaultWFXChannelOrder(ALCdevice *device)
1470 {
1471     ALuint i;
1472
1473     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
1474         device->ChannelName[i] = InvalidChannel;
1475
1476     switch(device->FmtChans)
1477     {
1478     case DevFmtMono:
1479         device->ChannelName[0] = FrontCenter;
1480         break;
1481     case DevFmtStereo:
1482         device->ChannelName[0] = FrontLeft;
1483         device->ChannelName[1] = FrontRight;
1484         break;
1485     case DevFmtQuad:
1486         device->ChannelName[0] = FrontLeft;
1487         device->ChannelName[1] = FrontRight;
1488         device->ChannelName[2] = BackLeft;
1489         device->ChannelName[3] = BackRight;
1490         break;
1491     case DevFmtX51:
1492         device->ChannelName[0] = FrontLeft;
1493         device->ChannelName[1] = FrontRight;
1494         device->ChannelName[2] = FrontCenter;
1495         device->ChannelName[3] = LFE;
1496         device->ChannelName[4] = SideLeft;
1497         device->ChannelName[5] = SideRight;
1498         break;
1499     case DevFmtX51Rear:
1500         device->ChannelName[0] = FrontLeft;
1501         device->ChannelName[1] = FrontRight;
1502         device->ChannelName[2] = FrontCenter;
1503         device->ChannelName[3] = LFE;
1504         device->ChannelName[4] = BackLeft;
1505         device->ChannelName[5] = BackRight;
1506         break;
1507     case DevFmtX61:
1508         device->ChannelName[0] = FrontLeft;
1509         device->ChannelName[1] = FrontRight;
1510         device->ChannelName[2] = FrontCenter;
1511         device->ChannelName[3] = LFE;
1512         device->ChannelName[4] = BackCenter;
1513         device->ChannelName[5] = SideLeft;
1514         device->ChannelName[6] = SideRight;
1515         break;
1516     case DevFmtX71:
1517         device->ChannelName[0] = FrontLeft;
1518         device->ChannelName[1] = FrontRight;
1519         device->ChannelName[2] = FrontCenter;
1520         device->ChannelName[3] = LFE;
1521         device->ChannelName[4] = BackLeft;
1522         device->ChannelName[5] = BackRight;
1523         device->ChannelName[6] = SideLeft;
1524         device->ChannelName[7] = SideRight;
1525         break;
1526     }
1527 }
1528
1529 /* SetDefaultChannelOrder
1530  *
1531  * Sets the default channel order used by most non-WaveFormatEx-based APIs.
1532  */
1533 void SetDefaultChannelOrder(ALCdevice *device)
1534 {
1535     ALuint i;
1536
1537     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
1538         device->ChannelName[i] = InvalidChannel;
1539
1540     switch(device->FmtChans)
1541     {
1542     case DevFmtX51Rear:
1543         device->ChannelName[0] = FrontLeft;
1544         device->ChannelName[1] = FrontRight;
1545         device->ChannelName[2] = BackLeft;
1546         device->ChannelName[3] = BackRight;
1547         device->ChannelName[4] = FrontCenter;
1548         device->ChannelName[5] = LFE;
1549         return;
1550     case DevFmtX71:
1551         device->ChannelName[0] = FrontLeft;
1552         device->ChannelName[1] = FrontRight;
1553         device->ChannelName[2] = BackLeft;
1554         device->ChannelName[3] = BackRight;
1555         device->ChannelName[4] = FrontCenter;
1556         device->ChannelName[5] = LFE;
1557         device->ChannelName[6] = SideLeft;
1558         device->ChannelName[7] = SideRight;
1559         return;
1560
1561     /* Same as WFX order */
1562     case DevFmtMono:
1563     case DevFmtStereo:
1564     case DevFmtQuad:
1565     case DevFmtX51:
1566     case DevFmtX61:
1567         SetDefaultWFXChannelOrder(device);
1568         break;
1569     }
1570 }
1571
1572 extern inline ALint GetChannelIdxByName(const ALCdevice *device, enum Channel chan);
1573
1574
1575 /* ALCcontext_DeferUpdates
1576  *
1577  * Defers/suspends updates for the given context's listener and sources. This
1578  * does *NOT* stop mixing, but rather prevents certain property changes from
1579  * taking effect.
1580  */
1581 void ALCcontext_DeferUpdates(ALCcontext *context)
1582 {
1583     ALCdevice *device = context->Device;
1584     FPUCtl oldMode;
1585
1586     SetMixerFPUMode(&oldMode);
1587
1588     V0(device->Backend,lock)();
1589     if(!ExchangeInt(&context->DeferUpdates, AL_TRUE))
1590     {
1591         ALboolean UpdateSources;
1592         ALvoice *voice, *voice_end;
1593         ALeffectslot **slot, **slot_end;
1594         /* Make sure all pending updates are performed */
1595         UpdateSources = ATOMIC_EXCHANGE(ALenum, &context->UpdateSources, AL_FALSE);
1596
1597         voice = context->Voices;
1598         voice_end = voice + context->VoiceCount;
1599         while(voice != voice_end)
1600         {
1601             ALsource *source = voice->Source;
1602             if(!source) goto next;
1603
1604             if(source->state != AL_PLAYING && source->state != AL_PAUSED)
1605             {
1606                 voice->Source = NULL;
1607                 goto next;
1608             }
1609
1610             if(ATOMIC_EXCHANGE(ALenum, &source->NeedsUpdate, AL_FALSE) || UpdateSources)
1611                 voice->Update(voice, source, context);
1612         next:
1613             voice++;
1614         }
1615
1616         slot = VECTOR_ITER_BEGIN(context->ActiveAuxSlots);
1617         slot_end = VECTOR_ITER_END(context->ActiveAuxSlots);
1618         while(slot != slot_end)
1619         {
1620             if(ATOMIC_EXCHANGE(ALenum, &(*slot)->NeedsUpdate, AL_FALSE))
1621                 V((*slot)->EffectState,update)(context->Device, *slot);
1622             slot++;
1623         }
1624     }
1625     V0(device->Backend,unlock)();
1626
1627     RestoreFPUMode(&oldMode);
1628 }
1629
1630 /* ALCcontext_ProcessUpdates
1631  *
1632  * Resumes update processing after being deferred.
1633  */
1634 void ALCcontext_ProcessUpdates(ALCcontext *context)
1635 {
1636     ALCdevice *device = context->Device;
1637
1638     V0(device->Backend,lock)();
1639     if(ExchangeInt(&context->DeferUpdates, AL_FALSE))
1640     {
1641         ALsizei pos;
1642
1643         LockUIntMapRead(&context->SourceMap);
1644         for(pos = 0;pos < context->SourceMap.size;pos++)
1645         {
1646             ALsource *Source = context->SourceMap.array[pos].value;
1647             ALenum new_state;
1648
1649             if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&
1650                Source->Offset >= 0.0)
1651             {
1652                 ReadLock(&Source->queue_lock);
1653                 ApplyOffset(Source);
1654                 ReadUnlock(&Source->queue_lock);
1655             }
1656
1657             new_state = ExchangeInt(&Source->new_state, AL_NONE);
1658             if(new_state)
1659                 SetSourceState(Source, context, new_state);
1660         }
1661         UnlockUIntMapRead(&context->SourceMap);
1662     }
1663     V0(device->Backend,unlock)();
1664 }
1665
1666
1667 /* alcSetError
1668  *
1669  * Stores the latest ALC device error
1670  */
1671 static void alcSetError(ALCdevice *device, ALCenum errorCode)
1672 {
1673     if(TrapALCError)
1674     {
1675 #ifdef _WIN32
1676         /* DebugBreak() will cause an exception if there is no debugger */
1677         if(IsDebuggerPresent())
1678             DebugBreak();
1679 #elif defined(SIGTRAP)
1680         raise(SIGTRAP);
1681 #endif
1682     }
1683
1684     if(device)
1685         ATOMIC_STORE(&device->LastError, errorCode);
1686     else
1687         ATOMIC_STORE(&LastNullDeviceError, errorCode);
1688 }
1689
1690
1691 /* UpdateClockBase
1692  *
1693  * Updates the device's base clock time with however many samples have been
1694  * done. This is used so frequency changes on the device don't cause the time
1695  * to jump forward or back.
1696  */
1697 static inline void UpdateClockBase(ALCdevice *device)
1698 {
1699     device->ClockBase += device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency;
1700     device->SamplesDone = 0;
1701 }
1702
1703 /* UpdateDeviceParams
1704  *
1705  * Updates device parameters according to the attribute list (caller is
1706  * responsible for holding the list lock).
1707  */
1708 static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
1709 {
1710     ALCcontext *context;
1711     enum DevFmtChannels oldChans;
1712     enum DevFmtType oldType;
1713     ALCuint oldFreq;
1714     FPUCtl oldMode;
1715
1716     // Check for attributes
1717     if(device->Type == Loopback)
1718     {
1719         enum {
1720             GotFreq  = 1<<0,
1721             GotChans = 1<<1,
1722             GotType  = 1<<2,
1723             GotAll   = GotFreq|GotChans|GotType
1724         };
1725         ALCuint freq, numMono, numStereo, numSends, flags;
1726         enum DevFmtChannels schans;
1727         enum DevFmtType stype;
1728         ALCuint attrIdx = 0;
1729         ALCint gotFmt = 0;
1730
1731         if(!attrList)
1732         {
1733             WARN("Missing attributes for loopback device\n");
1734             return ALC_INVALID_VALUE;
1735         }
1736
1737         numMono = device->NumMonoSources;
1738         numStereo = device->NumStereoSources;
1739         numSends = device->NumAuxSends;
1740         schans = device->FmtChans;
1741         stype = device->FmtType;
1742         freq = device->Frequency;
1743         flags = device->Flags;
1744
1745         while(attrList[attrIdx])
1746         {
1747             if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT)
1748             {
1749                 ALCint val = attrList[attrIdx + 1];
1750                 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
1751                     return ALC_INVALID_VALUE;
1752                 schans = val;
1753                 gotFmt |= GotChans;
1754             }
1755
1756             if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT)
1757             {
1758                 ALCint val = attrList[attrIdx + 1];
1759                 if(!IsValidALCType(val) || !BytesFromDevFmt(val))
1760                     return ALC_INVALID_VALUE;
1761                 stype = val;
1762                 gotFmt |= GotType;
1763             }
1764
1765             if(attrList[attrIdx] == ALC_FREQUENCY)
1766             {
1767                 freq = attrList[attrIdx + 1];
1768                 if(freq < MIN_OUTPUT_RATE)
1769                     return ALC_INVALID_VALUE;
1770                 gotFmt |= GotFreq;
1771             }
1772
1773             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1774             {
1775                 numStereo = attrList[attrIdx + 1];
1776                 if(numStereo > device->MaxNoOfSources)
1777                     numStereo = device->MaxNoOfSources;
1778
1779                 numMono = device->MaxNoOfSources - numStereo;
1780             }
1781
1782             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1783                 numSends = attrList[attrIdx + 1];
1784
1785             if(attrList[attrIdx] == ALC_HRTF_SOFT)
1786             {
1787                 if(attrList[attrIdx + 1] != ALC_FALSE)
1788                     flags |= DEVICE_HRTF_REQUEST;
1789                 else
1790                     flags &= ~DEVICE_HRTF_REQUEST;
1791             }
1792
1793             attrIdx += 2;
1794         }
1795
1796         if(gotFmt != GotAll)
1797         {
1798             WARN("Missing format for loopback device\n");
1799             return ALC_INVALID_VALUE;
1800         }
1801
1802         ConfigValueUInt(NULL, "sends", &numSends);
1803         numSends = minu(MAX_SENDS, numSends);
1804
1805         if((device->Flags&DEVICE_RUNNING))
1806             V0(device->Backend,stop)();
1807         device->Flags = (flags & ~DEVICE_RUNNING);
1808
1809         UpdateClockBase(device);
1810
1811         device->Frequency = freq;
1812         device->FmtChans = schans;
1813         device->FmtType = stype;
1814         device->NumMonoSources = numMono;
1815         device->NumStereoSources = numStereo;
1816         device->NumAuxSends = numSends;
1817     }
1818     else if(attrList && attrList[0])
1819     {
1820         ALCuint freq, numMono, numStereo, numSends;
1821         ALCuint attrIdx = 0;
1822
1823         /* If a context is already running on the device, stop playback so the
1824          * device attributes can be updated. */
1825         if((device->Flags&DEVICE_RUNNING))
1826             V0(device->Backend,stop)();
1827         device->Flags &= ~DEVICE_RUNNING;
1828
1829         freq = device->Frequency;
1830         numMono = device->NumMonoSources;
1831         numStereo = device->NumStereoSources;
1832         numSends = device->NumAuxSends;
1833
1834         while(attrList[attrIdx])
1835         {
1836             if(attrList[attrIdx] == ALC_FREQUENCY)
1837             {
1838                 freq = attrList[attrIdx + 1];
1839                 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1840             }
1841
1842             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1843             {
1844                 numStereo = attrList[attrIdx + 1];
1845                 if(numStereo > device->MaxNoOfSources)
1846                     numStereo = device->MaxNoOfSources;
1847
1848                 numMono = device->MaxNoOfSources - numStereo;
1849             }
1850
1851             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1852                 numSends = attrList[attrIdx + 1];
1853
1854             if(attrList[attrIdx] == ALC_HRTF_SOFT)
1855             {
1856                 if(attrList[attrIdx + 1] != ALC_FALSE)
1857                     device->Flags |= DEVICE_HRTF_REQUEST;
1858                 else
1859                     device->Flags &= ~DEVICE_HRTF_REQUEST;
1860             }
1861
1862             attrIdx += 2;
1863         }
1864
1865         ConfigValueUInt(NULL, "frequency", &freq);
1866         freq = maxu(freq, MIN_OUTPUT_RATE);
1867
1868         ConfigValueUInt(NULL, "sends", &numSends);
1869         numSends = minu(MAX_SENDS, numSends);
1870
1871         UpdateClockBase(device);
1872
1873         device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1874                              device->Frequency;
1875         /* SSE and Neon do best with the update size being a multiple of 4 */
1876         if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
1877             device->UpdateSize = (device->UpdateSize+3)&~3;
1878
1879         device->Frequency = freq;
1880         device->NumMonoSources = numMono;
1881         device->NumStereoSources = numStereo;
1882         device->NumAuxSends = numSends;
1883     }
1884
1885     if((device->Flags&DEVICE_RUNNING))
1886         return ALC_NO_ERROR;
1887
1888     UpdateClockBase(device);
1889
1890     if(device->Type != Loopback)
1891     {
1892         bool usehrtf = !!(device->Flags&DEVICE_HRTF_REQUEST);
1893         if(GetConfigValueBool(NULL, "hrtf", usehrtf))
1894             device->Flags |= DEVICE_HRTF_REQUEST;
1895         else
1896             device->Flags &= ~DEVICE_HRTF_REQUEST;
1897     }
1898     if((device->Flags&DEVICE_HRTF_REQUEST))
1899     {
1900         enum DevFmtChannels chans = device->FmtChans;
1901         ALCuint freq = device->Frequency;
1902         if(FindHrtfFormat(&chans, &freq))
1903         {
1904             if(device->Type != Loopback)
1905             {
1906                 device->Frequency = freq;
1907                 device->FmtChans = chans;
1908                 device->Flags |= DEVICE_CHANNELS_REQUEST |
1909                                  DEVICE_FREQUENCY_REQUEST;
1910             }
1911             else if(device->Frequency != freq || device->FmtChans != chans)
1912             {
1913                 ERR("Requested format not HRTF compatible: %s, %uhz\n",
1914                     DevFmtChannelsString(device->FmtChans), device->Frequency);
1915                 device->Flags &= ~DEVICE_HRTF_REQUEST;
1916             }
1917         }
1918     }
1919
1920     oldFreq  = device->Frequency;
1921     oldChans = device->FmtChans;
1922     oldType  = device->FmtType;
1923
1924     TRACE("Pre-reset: %s%s, %s%s, %s%uhz, %u update size x%d\n",
1925           (device->Flags&DEVICE_CHANNELS_REQUEST)?"*":"",
1926           DevFmtChannelsString(device->FmtChans),
1927           (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST)?"*":"",
1928           DevFmtTypeString(device->FmtType),
1929           (device->Flags&DEVICE_FREQUENCY_REQUEST)?"*":"",
1930           device->Frequency,
1931           device->UpdateSize, device->NumUpdates);
1932
1933     if(V0(device->Backend,reset)() == ALC_FALSE)
1934         return ALC_INVALID_DEVICE;
1935
1936     if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
1937     {
1938         ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
1939             DevFmtChannelsString(device->FmtChans));
1940         device->Flags &= ~DEVICE_CHANNELS_REQUEST;
1941     }
1942     if(device->FmtType != oldType && (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
1943     {
1944         ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
1945             DevFmtTypeString(device->FmtType));
1946         device->Flags &= ~DEVICE_SAMPLE_TYPE_REQUEST;
1947     }
1948     if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
1949     {
1950         ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
1951         device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
1952     }
1953
1954     TRACE("Post-reset: %s, %s, %uhz, %u update size x%d\n",
1955           DevFmtChannelsString(device->FmtChans),
1956           DevFmtTypeString(device->FmtType), device->Frequency,
1957           device->UpdateSize, device->NumUpdates);
1958
1959     aluInitPanning(device);
1960
1961     V(device->Synth,update)(device);
1962
1963     device->Hrtf = NULL;
1964     if((device->Flags&DEVICE_HRTF_REQUEST))
1965     {
1966         device->Hrtf = GetHrtf(device->FmtChans, device->Frequency);
1967         if(!device->Hrtf)
1968             device->Flags &= ~DEVICE_HRTF_REQUEST;
1969     }
1970     TRACE("HRTF %s\n", device->Hrtf?"enabled":"disabled");
1971
1972     if(!device->Hrtf && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6 &&
1973        device->FmtChans == DevFmtStereo)
1974     {
1975         if(!device->Bs2b)
1976         {
1977             device->Bs2b = calloc(1, sizeof(*device->Bs2b));
1978             bs2b_clear(device->Bs2b);
1979         }
1980         bs2b_set_srate(device->Bs2b, device->Frequency);
1981         bs2b_set_level(device->Bs2b, device->Bs2bLevel);
1982         TRACE("BS2B level %d\n", device->Bs2bLevel);
1983     }
1984     else
1985     {
1986         free(device->Bs2b);
1987         device->Bs2b = NULL;
1988         TRACE("BS2B disabled\n");
1989     }
1990
1991     if(!device->Hrtf && (device->UpdateSize&3))
1992     {
1993         if((CPUCapFlags&CPU_CAP_SSE))
1994             WARN("SSE performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
1995         if((CPUCapFlags&CPU_CAP_NEON))
1996             WARN("NEON performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
1997     }
1998
1999     SetMixerFPUMode(&oldMode);
2000     V0(device->Backend,lock)();
2001     context = ATOMIC_LOAD(&device->ContextList);
2002     while(context)
2003     {
2004         ALsizei pos;
2005
2006         ATOMIC_STORE(&context->UpdateSources, AL_FALSE);
2007         LockUIntMapRead(&context->EffectSlotMap);
2008         for(pos = 0;pos < context->EffectSlotMap.size;pos++)
2009         {
2010             ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
2011
2012             if(V(slot->EffectState,deviceUpdate)(device) == AL_FALSE)
2013             {
2014                 UnlockUIntMapRead(&context->EffectSlotMap);
2015                 V0(device->Backend,unlock)();
2016                 RestoreFPUMode(&oldMode);
2017                 return ALC_INVALID_DEVICE;
2018             }
2019             ATOMIC_STORE(&slot->NeedsUpdate, AL_FALSE);
2020             V(slot->EffectState,update)(device, slot);
2021         }
2022         UnlockUIntMapRead(&context->EffectSlotMap);
2023
2024         LockUIntMapRead(&context->SourceMap);
2025         for(pos = 0;pos < context->SourceMap.size;pos++)
2026         {
2027             ALsource *source = context->SourceMap.array[pos].value;
2028             ALuint s = device->NumAuxSends;
2029             while(s < MAX_SENDS)
2030             {
2031                 if(source->Send[s].Slot)
2032                     DecrementRef(&source->Send[s].Slot->ref);
2033                 source->Send[s].Slot = NULL;
2034                 source->Send[s].Gain = 1.0f;
2035                 source->Send[s].GainHF = 1.0f;
2036                 s++;
2037             }
2038             ATOMIC_STORE(&source->NeedsUpdate, AL_TRUE);
2039         }
2040         UnlockUIntMapRead(&context->SourceMap);
2041
2042         for(pos = 0;pos < context->VoiceCount;pos++)
2043         {
2044             ALvoice *voice = &context->Voices[pos];
2045             ALsource *source = voice->Source;
2046             ALuint s = device->NumAuxSends;
2047
2048             while(s < MAX_SENDS)
2049             {
2050                 voice->Send[s].Moving = AL_FALSE;
2051                 voice->Send[s].Counter = 0;
2052                 s++;
2053             }
2054
2055             if(source)
2056             {
2057                 ATOMIC_STORE(&source->NeedsUpdate, AL_FALSE);
2058                 voice->Update(voice, source, context);
2059             }
2060         }
2061
2062         context = context->next;
2063     }
2064     if(device->DefaultSlot)
2065     {
2066         ALeffectslot *slot = device->DefaultSlot;
2067
2068         if(V(slot->EffectState,deviceUpdate)(device) == AL_FALSE)
2069         {
2070             V0(device->Backend,unlock)();
2071             RestoreFPUMode(&oldMode);
2072             return ALC_INVALID_DEVICE;
2073         }
2074         ATOMIC_STORE(&slot->NeedsUpdate, AL_FALSE);
2075         V(slot->EffectState,update)(device, slot);
2076     }
2077     V0(device->Backend,unlock)();
2078     RestoreFPUMode(&oldMode);
2079
2080     if(!(device->Flags&DEVICE_PAUSED))
2081     {
2082         if(V0(device->Backend,start)() == ALC_FALSE)
2083             return ALC_INVALID_DEVICE;
2084         device->Flags |= DEVICE_RUNNING;
2085     }
2086
2087     return ALC_NO_ERROR;
2088 }
2089
2090 /* FreeDevice
2091  *
2092  * Frees the device structure, and destroys any objects the app failed to
2093  * delete. Called once there's no more references on the device.
2094  */
2095 static ALCvoid FreeDevice(ALCdevice *device)
2096 {
2097     TRACE("%p\n", device);
2098
2099     V0(device->Backend,close)();
2100     DELETE_OBJ(device->Backend);
2101     device->Backend = NULL;
2102
2103     DELETE_OBJ(device->Synth);
2104     device->Synth = NULL;
2105
2106     if(device->DefaultSlot)
2107     {
2108         ALeffectState *state = device->DefaultSlot->EffectState;
2109         device->DefaultSlot = NULL;
2110         DELETE_OBJ(state);
2111     }
2112
2113     if(device->DefaultSfont)
2114         ALsoundfont_deleteSoundfont(device->DefaultSfont, device);
2115     device->DefaultSfont = NULL;
2116
2117     if(device->BufferMap.size > 0)
2118     {
2119         WARN("(%p) Deleting %d Buffer(s)\n", device, device->BufferMap.size);
2120         ReleaseALBuffers(device);
2121     }
2122     ResetUIntMap(&device->BufferMap);
2123
2124     if(device->EffectMap.size > 0)
2125     {
2126         WARN("(%p) Deleting %d Effect(s)\n", device, device->EffectMap.size);
2127         ReleaseALEffects(device);
2128     }
2129     ResetUIntMap(&device->EffectMap);
2130
2131     if(device->FilterMap.size > 0)
2132     {
2133         WARN("(%p) Deleting %d Filter(s)\n", device, device->FilterMap.size);
2134         ReleaseALFilters(device);
2135     }
2136     ResetUIntMap(&device->FilterMap);
2137
2138     if(device->SfontMap.size > 0)
2139     {
2140         WARN("(%p) Deleting %d Soundfont(s)\n", device, device->SfontMap.size);
2141         ReleaseALSoundfonts(device);
2142     }
2143     ResetUIntMap(&device->SfontMap);
2144
2145     if(device->PresetMap.size > 0)
2146     {
2147         WARN("(%p) Deleting %d Preset(s)\n", device, device->PresetMap.size);
2148         ReleaseALPresets(device);
2149     }
2150     ResetUIntMap(&device->PresetMap);
2151
2152     if(device->FontsoundMap.size > 0)
2153     {
2154         WARN("(%p) Deleting %d Fontsound(s)\n", device, device->FontsoundMap.size);
2155         ReleaseALFontsounds(device);
2156     }
2157     ResetUIntMap(&device->FontsoundMap);
2158
2159     free(device->Bs2b);
2160     device->Bs2b = NULL;
2161
2162     AL_STRING_DEINIT(device->DeviceName);
2163
2164     al_free(device);
2165 }
2166
2167
2168 void ALCdevice_IncRef(ALCdevice *device)
2169 {
2170     uint ref;
2171     ref = IncrementRef(&device->ref);
2172     TRACEREF("%p increasing refcount to %u\n", device, ref);
2173 }
2174
2175 void ALCdevice_DecRef(ALCdevice *device)
2176 {
2177     uint ref;
2178     ref = DecrementRef(&device->ref);
2179     TRACEREF("%p decreasing refcount to %u\n", device, ref);
2180     if(ref == 0) FreeDevice(device);
2181 }
2182
2183 /* VerifyDevice
2184  *
2185  * Checks if the device handle is valid, and increments its ref count if so.
2186  */
2187 static ALCdevice *VerifyDevice(ALCdevice *device)
2188 {
2189     ALCdevice *tmpDevice;
2190
2191     if(!device)
2192         return NULL;
2193
2194     LockLists();
2195     tmpDevice = ATOMIC_LOAD(&DeviceList);
2196     while(tmpDevice && tmpDevice != device)
2197         tmpDevice = tmpDevice->next;
2198
2199     if(tmpDevice)
2200         ALCdevice_IncRef(tmpDevice);
2201     UnlockLists();
2202     return tmpDevice;
2203 }
2204
2205
2206 /* InitContext
2207  *
2208  * Initializes context fields
2209  */
2210 static ALvoid InitContext(ALCcontext *Context)
2211 {
2212     ALint i, j;
2213
2214     //Initialise listener
2215     Context->Listener->Gain = 1.0f;
2216     Context->Listener->MetersPerUnit = 1.0f;
2217     Context->Listener->Position[0] = 0.0f;
2218     Context->Listener->Position[1] = 0.0f;
2219     Context->Listener->Position[2] = 0.0f;
2220     Context->Listener->Velocity[0] = 0.0f;
2221     Context->Listener->Velocity[1] = 0.0f;
2222     Context->Listener->Velocity[2] = 0.0f;
2223     Context->Listener->Forward[0] = 0.0f;
2224     Context->Listener->Forward[1] = 0.0f;
2225     Context->Listener->Forward[2] = -1.0f;
2226     Context->Listener->Up[0] = 0.0f;
2227     Context->Listener->Up[1] = 1.0f;
2228     Context->Listener->Up[2] = 0.0f;
2229     for(i = 0;i < 4;i++)
2230     {
2231         for(j = 0;j < 4;j++)
2232             Context->Listener->Params.Matrix[i][j] = ((i==j) ? 1.0f : 0.0f);
2233     }
2234     for(i = 0;i < 3;i++)
2235         Context->Listener->Params.Velocity[i] = 0.0f;
2236
2237     //Validate Context
2238     ATOMIC_INIT(&Context->LastError, AL_NO_ERROR);
2239     ATOMIC_INIT(&Context->UpdateSources, AL_FALSE);
2240     InitUIntMap(&Context->SourceMap, Context->Device->MaxNoOfSources);
2241     InitUIntMap(&Context->EffectSlotMap, Context->Device->AuxiliaryEffectSlotMax);
2242
2243     //Set globals
2244     Context->DistanceModel = DefaultDistanceModel;
2245     Context->SourceDistanceModel = AL_FALSE;
2246     Context->DopplerFactor = 1.0f;
2247     Context->DopplerVelocity = 1.0f;
2248     Context->SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
2249     Context->DeferUpdates = AL_FALSE;
2250
2251     Context->ExtensionList = alExtList;
2252 }
2253
2254
2255 /* FreeContext
2256  *
2257  * Cleans up the context, and destroys any remaining objects the app failed to
2258  * delete. Called once there's no more references on the context.
2259  */
2260 static void FreeContext(ALCcontext *context)
2261 {
2262     TRACE("%p\n", context);
2263
2264     if(context->SourceMap.size > 0)
2265     {
2266         WARN("(%p) Deleting %d Source(s)\n", context, context->SourceMap.size);
2267         ReleaseALSources(context);
2268     }
2269     ResetUIntMap(&context->SourceMap);
2270
2271     if(context->EffectSlotMap.size > 0)
2272     {
2273         WARN("(%p) Deleting %d AuxiliaryEffectSlot(s)\n", context, context->EffectSlotMap.size);
2274         ReleaseALAuxiliaryEffectSlots(context);
2275     }
2276     ResetUIntMap(&context->EffectSlotMap);
2277
2278     al_free(context->Voices);
2279     context->Voices = NULL;
2280     context->VoiceCount = 0;
2281     context->MaxVoices = 0;
2282
2283     VECTOR_DEINIT(context->ActiveAuxSlots);
2284
2285     ALCdevice_DecRef(context->Device);
2286     context->Device = NULL;
2287
2288     //Invalidate context
2289     memset(context, 0, sizeof(ALCcontext));
2290     al_free(context);
2291 }
2292
2293 /* ReleaseContext
2294  *
2295  * Removes the context reference from the given device and removes it from
2296  * being current on the running thread or globally.
2297  */
2298 static void ReleaseContext(ALCcontext *context, ALCdevice *device)
2299 {
2300     ALCcontext *nextctx;
2301     ALCcontext *origctx;
2302
2303     if(altss_get(LocalContext) == context)
2304     {
2305         WARN("%p released while current on thread\n", context);
2306         altss_set(LocalContext, NULL);
2307         ALCcontext_DecRef(context);
2308     }
2309
2310     origctx = context;
2311     if(ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &GlobalContext, &origctx, NULL))
2312         ALCcontext_DecRef(context);
2313
2314     ALCdevice_Lock(device);
2315     origctx = context;
2316     nextctx = context->next;
2317     if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &device->ContextList, &origctx, nextctx))
2318     {
2319         ALCcontext *list;
2320         do {
2321             list = origctx;
2322             origctx = context;
2323         } while(!COMPARE_EXCHANGE(&list->next, &origctx, nextctx));
2324     }
2325     ALCdevice_Unlock(device);
2326
2327     ALCcontext_DecRef(context);
2328 }
2329
2330 void ALCcontext_IncRef(ALCcontext *context)
2331 {
2332     uint ref;
2333     ref = IncrementRef(&context->ref);
2334     TRACEREF("%p increasing refcount to %u\n", context, ref);
2335 }
2336
2337 void ALCcontext_DecRef(ALCcontext *context)
2338 {
2339     uint ref;
2340     ref = DecrementRef(&context->ref);
2341     TRACEREF("%p decreasing refcount to %u\n", context, ref);
2342     if(ref == 0) FreeContext(context);
2343 }
2344
2345 static void ReleaseThreadCtx(void *ptr)
2346 {
2347     WARN("%p current for thread being destroyed\n", ptr);
2348     ALCcontext_DecRef(ptr);
2349 }
2350
2351 /* VerifyContext
2352  *
2353  * Checks that the given context is valid, and increments its reference count.
2354  */
2355 static ALCcontext *VerifyContext(ALCcontext *context)
2356 {
2357     ALCdevice *dev;
2358
2359     LockLists();
2360     dev = ATOMIC_LOAD(&DeviceList);
2361     while(dev)
2362     {
2363         ALCcontext *ctx = ATOMIC_LOAD(&dev->ContextList);
2364         while(ctx)
2365         {
2366             if(ctx == context)
2367             {
2368                 ALCcontext_IncRef(ctx);
2369                 UnlockLists();
2370                 return ctx;
2371             }
2372             ctx = ctx->next;
2373         }
2374         dev = dev->next;
2375     }
2376     UnlockLists();
2377
2378     return NULL;
2379 }
2380
2381
2382 /* GetContextRef
2383  *
2384  * Returns the currently active context for this thread, and adds a reference
2385  * without locking it.
2386  */
2387 ALCcontext *GetContextRef(void)
2388 {
2389     ALCcontext *context;
2390
2391     context = altss_get(LocalContext);
2392     if(context)
2393         ALCcontext_IncRef(context);
2394     else
2395     {
2396         LockLists();
2397         context = ATOMIC_LOAD(&GlobalContext);
2398         if(context)
2399             ALCcontext_IncRef(context);
2400         UnlockLists();
2401     }
2402
2403     return context;
2404 }
2405
2406
2407 /************************************************
2408  * Standard ALC functions
2409  ************************************************/
2410
2411 /* alcGetError
2412  *
2413  * Return last ALC generated error code for the given device
2414 */
2415 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
2416 {
2417     ALCenum errorCode;
2418
2419     if(VerifyDevice(device))
2420     {
2421         errorCode = ATOMIC_EXCHANGE(ALCenum, &device->LastError, ALC_NO_ERROR);
2422         ALCdevice_DecRef(device);
2423     }
2424     else
2425         errorCode = ATOMIC_EXCHANGE(ALCenum, &LastNullDeviceError, ALC_NO_ERROR);
2426
2427     return errorCode;
2428 }
2429
2430
2431 /* alcSuspendContext
2432  *
2433  * Suspends updates for the given context
2434  */
2435 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *context)
2436 {
2437     if(!SuspendDefers)
2438         return;
2439
2440     context = VerifyContext(context);
2441     if(!context)
2442         alcSetError(NULL, ALC_INVALID_CONTEXT);
2443     else
2444     {
2445         ALCcontext_DeferUpdates(context);
2446         ALCcontext_DecRef(context);
2447     }
2448 }
2449
2450 /* alcProcessContext
2451  *
2452  * Resumes processing updates for the given context
2453  */
2454 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *context)
2455 {
2456     if(!SuspendDefers)
2457         return;
2458
2459     context = VerifyContext(context);
2460     if(!context)
2461         alcSetError(NULL, ALC_INVALID_CONTEXT);
2462     else
2463     {
2464         ALCcontext_ProcessUpdates(context);
2465         ALCcontext_DecRef(context);
2466     }
2467 }
2468
2469
2470 /* alcGetString
2471  *
2472  * Returns information about the device, and error strings
2473  */
2474 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
2475 {
2476     const ALCchar *value = NULL;
2477
2478     switch(param)
2479     {
2480     case ALC_NO_ERROR:
2481         value = alcNoError;
2482         break;
2483
2484     case ALC_INVALID_ENUM:
2485         value = alcErrInvalidEnum;
2486         break;
2487
2488     case ALC_INVALID_VALUE:
2489         value = alcErrInvalidValue;
2490         break;
2491
2492     case ALC_INVALID_DEVICE:
2493         value = alcErrInvalidDevice;
2494         break;
2495
2496     case ALC_INVALID_CONTEXT:
2497         value = alcErrInvalidContext;
2498         break;
2499
2500     case ALC_OUT_OF_MEMORY:
2501         value = alcErrOutOfMemory;
2502         break;
2503
2504     case ALC_DEVICE_SPECIFIER:
2505         value = alcDefaultName;
2506         break;
2507
2508     case ALC_ALL_DEVICES_SPECIFIER:
2509         if(VerifyDevice(Device))
2510         {
2511             value = al_string_get_cstr(Device->DeviceName);
2512             ALCdevice_DecRef(Device);
2513         }
2514         else
2515         {
2516             ProbeAllDevicesList();
2517             value = al_string_get_cstr(alcAllDevicesList);
2518         }
2519         break;
2520
2521     case ALC_CAPTURE_DEVICE_SPECIFIER:
2522         if(VerifyDevice(Device))
2523         {
2524             value = al_string_get_cstr(Device->DeviceName);
2525             ALCdevice_DecRef(Device);
2526         }
2527         else
2528         {
2529             ProbeCaptureDeviceList();
2530             value = al_string_get_cstr(alcCaptureDeviceList);
2531         }
2532         break;
2533
2534     /* Default devices are always first in the list */
2535     case ALC_DEFAULT_DEVICE_SPECIFIER:
2536         value = alcDefaultName;
2537         break;
2538
2539     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
2540         if(al_string_empty(alcAllDevicesList))
2541             ProbeAllDevicesList();
2542
2543         Device = VerifyDevice(Device);
2544
2545         free(alcDefaultAllDevicesSpecifier);
2546         alcDefaultAllDevicesSpecifier = strdup(al_string_get_cstr(alcAllDevicesList));
2547         if(!alcDefaultAllDevicesSpecifier)
2548             alcSetError(Device, ALC_OUT_OF_MEMORY);
2549
2550         value = alcDefaultAllDevicesSpecifier;
2551         if(Device) ALCdevice_DecRef(Device);
2552         break;
2553
2554     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
2555         if(al_string_empty(alcCaptureDeviceList))
2556             ProbeCaptureDeviceList();
2557
2558         Device = VerifyDevice(Device);
2559
2560         free(alcCaptureDefaultDeviceSpecifier);
2561         alcCaptureDefaultDeviceSpecifier = strdup(al_string_get_cstr(alcCaptureDeviceList));
2562         if(!alcCaptureDefaultDeviceSpecifier)
2563             alcSetError(Device, ALC_OUT_OF_MEMORY);
2564
2565         value = alcCaptureDefaultDeviceSpecifier;
2566         if(Device) ALCdevice_DecRef(Device);
2567         break;
2568
2569     case ALC_EXTENSIONS:
2570         if(!VerifyDevice(Device))
2571             value = alcNoDeviceExtList;
2572         else
2573         {
2574             value = alcExtensionList;
2575             ALCdevice_DecRef(Device);
2576         }
2577         break;
2578
2579     default:
2580         Device = VerifyDevice(Device);
2581         alcSetError(Device, ALC_INVALID_ENUM);
2582         if(Device) ALCdevice_DecRef(Device);
2583         break;
2584     }
2585
2586     return value;
2587 }
2588
2589
2590 static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
2591 {
2592     ALCsizei i;
2593
2594     if(size <= 0 || values == NULL)
2595     {
2596         alcSetError(device, ALC_INVALID_VALUE);
2597         return 0;
2598     }
2599
2600     if(!device)
2601     {
2602         switch(param)
2603         {
2604             case ALC_MAJOR_VERSION:
2605                 values[0] = alcMajorVersion;
2606                 return 1;
2607             case ALC_MINOR_VERSION:
2608                 values[0] = alcMinorVersion;
2609                 return 1;
2610
2611             case ALC_ATTRIBUTES_SIZE:
2612             case ALC_ALL_ATTRIBUTES:
2613             case ALC_FREQUENCY:
2614             case ALC_REFRESH:
2615             case ALC_SYNC:
2616             case ALC_MONO_SOURCES:
2617             case ALC_STEREO_SOURCES:
2618             case ALC_CAPTURE_SAMPLES:
2619             case ALC_FORMAT_CHANNELS_SOFT:
2620             case ALC_FORMAT_TYPE_SOFT:
2621                 alcSetError(NULL, ALC_INVALID_DEVICE);
2622                 return 0;
2623
2624             default:
2625                 alcSetError(NULL, ALC_INVALID_ENUM);
2626                 return 0;
2627         }
2628         return 0;
2629     }
2630
2631     if(device->Type == Capture)
2632     {
2633         switch(param)
2634         {
2635             case ALC_CAPTURE_SAMPLES:
2636                 ALCdevice_Lock(device);
2637                 values[0] = V0(device->Backend,availableSamples)();
2638                 ALCdevice_Unlock(device);
2639                 return 1;
2640
2641             case ALC_CONNECTED:
2642                 values[0] = device->Connected;
2643                 return 1;
2644
2645             default:
2646                 alcSetError(device, ALC_INVALID_ENUM);
2647                 return 0;
2648         }
2649         return 0;
2650     }
2651
2652     /* render device */
2653     switch(param)
2654     {
2655         case ALC_MAJOR_VERSION:
2656             values[0] = alcMajorVersion;
2657             return 1;
2658
2659         case ALC_MINOR_VERSION:
2660             values[0] = alcMinorVersion;
2661             return 1;
2662
2663         case ALC_EFX_MAJOR_VERSION:
2664             values[0] = alcEFXMajorVersion;
2665             return 1;
2666
2667         case ALC_EFX_MINOR_VERSION:
2668             values[0] = alcEFXMinorVersion;
2669             return 1;
2670
2671         case ALC_ATTRIBUTES_SIZE:
2672             values[0] = 15;
2673             return 1;
2674
2675         case ALC_ALL_ATTRIBUTES:
2676             if(size < 15)
2677             {
2678                 alcSetError(device, ALC_INVALID_VALUE);
2679                 return 0;
2680             }
2681
2682             i = 0;
2683             values[i++] = ALC_FREQUENCY;
2684             values[i++] = device->Frequency;
2685
2686             if(device->Type != Loopback)
2687             {
2688                 values[i++] = ALC_REFRESH;
2689                 values[i++] = device->Frequency / device->UpdateSize;
2690
2691                 values[i++] = ALC_SYNC;
2692                 values[i++] = ALC_FALSE;
2693             }
2694             else
2695             {
2696                 values[i++] = ALC_FORMAT_CHANNELS_SOFT;
2697                 values[i++] = device->FmtChans;
2698
2699                 values[i++] = ALC_FORMAT_TYPE_SOFT;
2700                 values[i++] = device->FmtType;
2701             }
2702
2703             values[i++] = ALC_MONO_SOURCES;
2704             values[i++] = device->NumMonoSources;
2705
2706             values[i++] = ALC_STEREO_SOURCES;
2707             values[i++] = device->NumStereoSources;
2708
2709             values[i++] = ALC_MAX_AUXILIARY_SENDS;
2710             values[i++] = device->NumAuxSends;
2711
2712             values[i++] = ALC_HRTF_SOFT;
2713             values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2714
2715             values[i++] = 0;
2716             return i;
2717
2718         case ALC_FREQUENCY:
2719             values[0] = device->Frequency;
2720             return 1;
2721
2722         case ALC_REFRESH:
2723             if(device->Type == Loopback)
2724             {
2725                 alcSetError(device, ALC_INVALID_DEVICE);
2726                 return 0;
2727             }
2728             values[0] = device->Frequency / device->UpdateSize;
2729             return 1;
2730
2731         case ALC_SYNC:
2732             if(device->Type == Loopback)
2733             {
2734                 alcSetError(device, ALC_INVALID_DEVICE);
2735                 return 0;
2736             }
2737             values[0] = ALC_FALSE;
2738             return 1;
2739
2740         case ALC_FORMAT_CHANNELS_SOFT:
2741             if(device->Type != Loopback)
2742             {
2743                 alcSetError(device, ALC_INVALID_DEVICE);
2744                 return 0;
2745             }
2746             values[0] = device->FmtChans;
2747             return 1;
2748
2749         case ALC_FORMAT_TYPE_SOFT:
2750             if(device->Type != Loopback)
2751             {
2752                 alcSetError(device, ALC_INVALID_DEVICE);
2753                 return 0;
2754             }
2755             values[0] = device->FmtType;
2756             return 1;
2757
2758         case ALC_MONO_SOURCES:
2759             values[0] = device->NumMonoSources;
2760             return 1;
2761
2762         case ALC_STEREO_SOURCES:
2763             values[0] = device->NumStereoSources;
2764             return 1;
2765
2766         case ALC_MAX_AUXILIARY_SENDS:
2767             values[0] = device->NumAuxSends;
2768             return 1;
2769
2770         case ALC_CONNECTED:
2771             values[0] = device->Connected;
2772             return 1;
2773
2774         case ALC_HRTF_SOFT:
2775             values[0] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2776             return 1;
2777
2778         default:
2779             alcSetError(device, ALC_INVALID_ENUM);
2780             return 0;
2781     }
2782     return 0;
2783 }
2784
2785 /* alcGetIntegerv
2786  *
2787  * Returns information about the device and the version of OpenAL
2788  */
2789 ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
2790 {
2791     device = VerifyDevice(device);
2792     if(size <= 0 || values == NULL)
2793         alcSetError(device, ALC_INVALID_VALUE);
2794     else
2795         GetIntegerv(device, param, size, values);
2796     if(device) ALCdevice_DecRef(device);
2797 }
2798
2799 ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALCsizei size, ALCint64SOFT *values)
2800 {
2801     ALCint *ivals;
2802     ALsizei i;
2803
2804     device = VerifyDevice(device);
2805     if(size <= 0 || values == NULL)
2806         alcSetError(device, ALC_INVALID_VALUE);
2807     else if(!device || device->Type == Capture)
2808     {
2809         ivals = malloc(size * sizeof(ALCint));
2810         size = GetIntegerv(device, pname, size, ivals);
2811         for(i = 0;i < size;i++)
2812             values[i] = ivals[i];
2813         free(ivals);
2814     }
2815     else /* render device */
2816     {
2817         switch(pname)
2818         {
2819             case ALC_ATTRIBUTES_SIZE:
2820                 *values = 17;
2821                 break;
2822
2823             case ALC_ALL_ATTRIBUTES:
2824                 if(size < 17)
2825                     alcSetError(device, ALC_INVALID_VALUE);
2826                 else
2827                 {
2828                     int i = 0;
2829
2830                     V0(device->Backend,lock)();
2831                     values[i++] = ALC_FREQUENCY;
2832                     values[i++] = device->Frequency;
2833
2834                     if(device->Type != Loopback)
2835                     {
2836                         values[i++] = ALC_REFRESH;
2837                         values[i++] = device->Frequency / device->UpdateSize;
2838
2839                         values[i++] = ALC_SYNC;
2840                         values[i++] = ALC_FALSE;
2841                     }
2842                     else
2843                     {
2844                         values[i++] = ALC_FORMAT_CHANNELS_SOFT;
2845                         values[i++] = device->FmtChans;
2846
2847                         values[i++] = ALC_FORMAT_TYPE_SOFT;
2848                         values[i++] = device->FmtType;
2849                     }
2850
2851                     values[i++] = ALC_MONO_SOURCES;
2852                     values[i++] = device->NumMonoSources;
2853
2854                     values[i++] = ALC_STEREO_SOURCES;
2855                     values[i++] = device->NumStereoSources;
2856
2857                     values[i++] = ALC_MAX_AUXILIARY_SENDS;
2858                     values[i++] = device->NumAuxSends;
2859
2860                     values[i++] = ALC_HRTF_SOFT;
2861                     values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2862
2863                     values[i++] = ALC_DEVICE_CLOCK_SOFT;
2864                     values[i++] = device->ClockBase +
2865                                   (device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency);
2866
2867                     values[i++] = 0;
2868                     V0(device->Backend,unlock)();
2869                 }
2870                 break;
2871
2872             case ALC_DEVICE_CLOCK_SOFT:
2873                 V0(device->Backend,lock)();
2874                 *values = device->ClockBase +
2875                           (device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency);
2876                 V0(device->Backend,unlock)();
2877                 break;
2878
2879             default:
2880                 ivals = malloc(size * sizeof(ALCint));
2881                 size = GetIntegerv(device, pname, size, ivals);
2882                 for(i = 0;i < size;i++)
2883                     values[i] = ivals[i];
2884                 free(ivals);
2885                 break;
2886         }
2887     }
2888     if(device)
2889         ALCdevice_DecRef(device);
2890 }
2891
2892
2893 /* alcIsExtensionPresent
2894  *
2895  * Determines if there is support for a particular extension
2896  */
2897 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
2898 {
2899     ALCboolean bResult = ALC_FALSE;
2900
2901     device = VerifyDevice(device);
2902
2903     if(!extName)
2904         alcSetError(device, ALC_INVALID_VALUE);
2905     else
2906     {
2907         size_t len = strlen(extName);
2908         const char *ptr = (device ? alcExtensionList : alcNoDeviceExtList);
2909         while(ptr && *ptr)
2910         {
2911             if(strncasecmp(ptr, extName, len) == 0 &&
2912                (ptr[len] == '\0' || isspace(ptr[len])))
2913             {
2914                 bResult = ALC_TRUE;
2915                 break;
2916             }
2917             if((ptr=strchr(ptr, ' ')) != NULL)
2918             {
2919                 do {
2920                     ++ptr;
2921                 } while(isspace(*ptr));
2922             }
2923         }
2924     }
2925     if(device)
2926         ALCdevice_DecRef(device);
2927     return bResult;
2928 }
2929
2930
2931 /* alcGetProcAddress
2932  *
2933  * Retrieves the function address for a particular extension function
2934  */
2935 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
2936 {
2937     ALCvoid *ptr = NULL;
2938
2939     if(!funcName)
2940     {
2941         device = VerifyDevice(device);
2942         alcSetError(device, ALC_INVALID_VALUE);
2943         if(device) ALCdevice_DecRef(device);
2944     }
2945     else
2946     {
2947         ALsizei i = 0;
2948         while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName, funcName) != 0)
2949             i++;
2950         ptr = alcFunctions[i].address;
2951     }
2952
2953     return ptr;
2954 }
2955
2956
2957 /* alcGetEnumValue
2958  *
2959  * Get the value for a particular ALC enumeration name
2960  */
2961 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
2962 {
2963     ALCenum val = 0;
2964
2965     if(!enumName)
2966     {
2967         device = VerifyDevice(device);
2968         alcSetError(device, ALC_INVALID_VALUE);
2969         if(device) ALCdevice_DecRef(device);
2970     }
2971     else
2972     {
2973         ALsizei i = 0;
2974         while(enumeration[i].enumName && strcmp(enumeration[i].enumName, enumName) != 0)
2975             i++;
2976         val = enumeration[i].value;
2977     }
2978
2979     return val;
2980 }
2981
2982
2983 /* alcCreateContext
2984  *
2985  * Create and attach a context to the given device.
2986  */
2987 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
2988 {
2989     ALCcontext *ALContext;
2990     ALCenum err;
2991
2992     LockLists();
2993     if(!(device=VerifyDevice(device)) || device->Type == Capture || !device->Connected)
2994     {
2995         UnlockLists();
2996         alcSetError(device, ALC_INVALID_DEVICE);
2997         if(device) ALCdevice_DecRef(device);
2998         return NULL;
2999     }
3000
3001     ATOMIC_STORE(&device->LastError, ALC_NO_ERROR);
3002
3003     if((err=UpdateDeviceParams(device, attrList)) != ALC_NO_ERROR)
3004     {
3005         UnlockLists();
3006         alcSetError(device, err);
3007         if(err == ALC_INVALID_DEVICE)
3008         {
3009             ALCdevice_Lock(device);
3010             aluHandleDisconnect(device);
3011             ALCdevice_Unlock(device);
3012         }
3013         ALCdevice_DecRef(device);
3014         return NULL;
3015     }
3016
3017     ALContext = al_calloc(16, sizeof(ALCcontext)+sizeof(ALlistener));
3018     if(ALContext)
3019     {
3020         InitRef(&ALContext->ref, 1);
3021         ALContext->Listener = (ALlistener*)ALContext->_listener_mem;
3022
3023         VECTOR_INIT(ALContext->ActiveAuxSlots);
3024
3025         ALContext->VoiceCount = 0;
3026         ALContext->MaxVoices = 256;
3027         ALContext->Voices = al_calloc(16, ALContext->MaxVoices * sizeof(ALContext->Voices[0]));
3028     }
3029     if(!ALContext || !ALContext->Voices)
3030     {
3031         if(!ATOMIC_LOAD(&device->ContextList))
3032         {
3033             V0(device->Backend,stop)();
3034             device->Flags &= ~DEVICE_RUNNING;
3035         }
3036         UnlockLists();
3037
3038         if(ALContext)
3039         {
3040             al_free(ALContext->Voices);
3041             ALContext->Voices = NULL;
3042
3043             VECTOR_DEINIT(ALContext->ActiveAuxSlots);
3044
3045             al_free(ALContext);
3046             ALContext = NULL;
3047         }
3048
3049         alcSetError(device, ALC_OUT_OF_MEMORY);
3050         ALCdevice_DecRef(device);
3051         return NULL;
3052     }
3053
3054     ALContext->Device = device;
3055     ALCdevice_IncRef(device);
3056     InitContext(ALContext);
3057
3058     {
3059         ALCcontext *head = ATOMIC_LOAD(&device->ContextList);
3060         do {
3061             ALContext->next = head;
3062         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCcontext*, &device->ContextList, &head, ALContext));
3063     }
3064     UnlockLists();
3065
3066     ALCdevice_DecRef(device);
3067
3068     TRACE("Created context %p\n", ALContext);
3069     return ALContext;
3070 }
3071
3072 /* alcDestroyContext
3073  *
3074  * Remove a context from its device
3075  */
3076 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
3077 {
3078     ALCdevice *Device;
3079
3080     LockLists();
3081     /* alcGetContextsDevice sets an error for invalid contexts */
3082     Device = alcGetContextsDevice(context);
3083     if(Device)
3084     {
3085         ReleaseContext(context, Device);
3086         if(!ATOMIC_LOAD(&Device->ContextList))
3087         {
3088             V0(Device->Backend,stop)();
3089             Device->Flags &= ~DEVICE_RUNNING;
3090         }
3091     }
3092     UnlockLists();
3093 }
3094
3095
3096 /* alcGetCurrentContext
3097  *
3098  * Returns the currently active context on the calling thread
3099  */
3100 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
3101 {
3102     ALCcontext *Context = altss_get(LocalContext);
3103     if(!Context) Context = ATOMIC_LOAD(&GlobalContext);
3104     return Context;
3105 }
3106
3107 /* alcGetThreadContext
3108  *
3109  * Returns the currently active thread-local context
3110  */
3111 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
3112 {
3113     return altss_get(LocalContext);
3114 }
3115
3116
3117 /* alcMakeContextCurrent
3118  *
3119  * Makes the given context the active process-wide context, and removes the
3120  * thread-local context for the calling thread.
3121  */
3122 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
3123 {
3124     /* context must be valid or NULL */
3125     if(context && !(context=VerifyContext(context)))
3126     {
3127         alcSetError(NULL, ALC_INVALID_CONTEXT);
3128         return ALC_FALSE;
3129     }
3130     /* context's reference count is already incremented */
3131     context = ATOMIC_EXCHANGE(ALCcontext*, &GlobalContext, context);
3132     if(context) ALCcontext_DecRef(context);
3133
3134     if((context=altss_get(LocalContext)) != NULL)
3135     {
3136         altss_set(LocalContext, NULL);
3137         ALCcontext_DecRef(context);
3138     }
3139
3140     return ALC_TRUE;
3141 }
3142
3143 /* alcSetThreadContext
3144  *
3145  * Makes the given context the active context for the current thread
3146  */
3147 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
3148 {
3149     ALCcontext *old;
3150
3151     /* context must be valid or NULL */
3152     if(context && !(context=VerifyContext(context)))
3153     {
3154         alcSetError(NULL, ALC_INVALID_CONTEXT);
3155         return ALC_FALSE;
3156     }
3157     /* context's reference count is already incremented */
3158     old = altss_get(LocalContext);
3159     altss_set(LocalContext, context);
3160     if(old) ALCcontext_DecRef(old);
3161
3162     return ALC_TRUE;
3163 }
3164
3165
3166 /* alcGetContextsDevice
3167  *
3168  * Returns the device that a particular context is attached to
3169  */
3170 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
3171 {
3172     ALCdevice *Device;
3173
3174     if(!(Context=VerifyContext(Context)))
3175     {
3176         alcSetError(NULL, ALC_INVALID_CONTEXT);
3177         return NULL;
3178     }
3179     Device = Context->Device;
3180     ALCcontext_DecRef(Context);
3181
3182     return Device;
3183 }
3184
3185
3186 /* alcOpenDevice
3187  *
3188  * Opens the named device.
3189  */
3190 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
3191 {
3192     const ALCchar *fmt;
3193     ALCdevice *device;
3194     ALCenum err;
3195
3196     DO_INITCONFIG();
3197
3198     if(!PlaybackBackend.name)
3199     {
3200         alcSetError(NULL, ALC_INVALID_VALUE);
3201         return NULL;
3202     }
3203
3204     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
3205         deviceName = NULL;
3206
3207     device = al_calloc(16, sizeof(ALCdevice)+sizeof(ALeffectslot));
3208     if(!device)
3209     {
3210         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3211         return NULL;
3212     }
3213
3214     //Validate device
3215     InitRef(&device->ref, 1);
3216     device->Connected = ALC_TRUE;
3217     device->Type = Playback;
3218     ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
3219
3220     device->Flags = 0;
3221     device->Bs2b = NULL;
3222     device->Bs2bLevel = 0;
3223     AL_STRING_INIT(device->DeviceName);
3224
3225     ATOMIC_INIT(&device->ContextList, NULL);
3226
3227     device->ClockBase = 0;
3228     device->SamplesDone = 0;
3229
3230     device->MaxNoOfSources = 256;
3231     device->AuxiliaryEffectSlotMax = 4;
3232     device->NumAuxSends = MAX_SENDS;
3233
3234     InitUIntMap(&device->BufferMap, ~0);
3235     InitUIntMap(&device->EffectMap, ~0);
3236     InitUIntMap(&device->FilterMap, ~0);
3237     InitUIntMap(&device->SfontMap, ~0);
3238     InitUIntMap(&device->PresetMap, ~0);
3239     InitUIntMap(&device->FontsoundMap, ~0);
3240
3241     //Set output format
3242     device->FmtChans = DevFmtChannelsDefault;
3243     device->FmtType = DevFmtTypeDefault;
3244     device->Frequency = DEFAULT_OUTPUT_RATE;
3245     device->NumUpdates = 4;
3246     device->UpdateSize = 1024;
3247
3248     if(!PlaybackBackend.getFactory)
3249         device->Backend = create_backend_wrapper(device, &PlaybackBackend.Funcs,
3250                                                  ALCbackend_Playback);
3251     else
3252     {
3253         ALCbackendFactory *factory = PlaybackBackend.getFactory();
3254         device->Backend = V(factory,createBackend)(device, ALCbackend_Playback);
3255     }
3256     if(!device->Backend)
3257     {
3258         al_free(device);
3259         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3260         return NULL;
3261     }
3262
3263
3264     if(ConfigValueStr(NULL, "channels", &fmt))
3265     {
3266         static const struct {
3267             const char name[16];
3268             enum DevFmtChannels chans;
3269         } chanlist[] = {
3270             { "mono",       DevFmtMono   },
3271             { "stereo",     DevFmtStereo },
3272             { "quad",       DevFmtQuad   },
3273             { "surround51", DevFmtX51    },
3274             { "surround61", DevFmtX61    },
3275             { "surround71", DevFmtX71    },
3276             { "surround51rear", DevFmtX51Rear },
3277         };
3278         size_t i;
3279
3280         for(i = 0;i < COUNTOF(chanlist);i++)
3281         {
3282             if(strcasecmp(chanlist[i].name, fmt) == 0)
3283             {
3284                 device->FmtChans = chanlist[i].chans;
3285                 device->Flags |= DEVICE_CHANNELS_REQUEST;
3286                 break;
3287             }
3288         }
3289         if(i == COUNTOF(chanlist))
3290             ERR("Unsupported channels: %s\n", fmt);
3291     }
3292     if(ConfigValueStr(NULL, "sample-type", &fmt))
3293     {
3294         static const struct {
3295             const char name[16];
3296             enum DevFmtType type;
3297         } typelist[] = {
3298             { "int8",    DevFmtByte   },
3299             { "uint8",   DevFmtUByte  },
3300             { "int16",   DevFmtShort  },
3301             { "uint16",  DevFmtUShort },
3302             { "int32",   DevFmtInt    },
3303             { "uint32",  DevFmtUInt   },
3304             { "float32", DevFmtFloat  },
3305         };
3306         size_t i;
3307
3308         for(i = 0;i < COUNTOF(typelist);i++)
3309         {
3310             if(strcasecmp(typelist[i].name, fmt) == 0)
3311             {
3312                 device->FmtType = typelist[i].type;
3313                 device->Flags |= DEVICE_SAMPLE_TYPE_REQUEST;
3314                 break;
3315             }
3316         }
3317         if(i == COUNTOF(typelist))
3318             ERR("Unsupported sample-type: %s\n", fmt);
3319     }
3320
3321     if(ConfigValueUInt(NULL, "frequency", &device->Frequency))
3322     {
3323         device->Flags |= DEVICE_FREQUENCY_REQUEST;
3324         if(device->Frequency < MIN_OUTPUT_RATE)
3325             ERR("%uhz request clamped to %uhz minimum\n", device->Frequency, MIN_OUTPUT_RATE);
3326         device->Frequency = maxu(device->Frequency, MIN_OUTPUT_RATE);
3327     }
3328
3329     ConfigValueUInt(NULL, "periods", &device->NumUpdates);
3330     device->NumUpdates = clampu(device->NumUpdates, 2, 16);
3331
3332     ConfigValueUInt(NULL, "period_size", &device->UpdateSize);
3333     device->UpdateSize = clampu(device->UpdateSize, 64, 8192);
3334     if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
3335         device->UpdateSize = (device->UpdateSize+3)&~3;
3336
3337     ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
3338     if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
3339
3340     ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
3341     if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
3342
3343     ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
3344     if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
3345
3346     ConfigValueInt(NULL, "cf_level", &device->Bs2bLevel);
3347
3348     device->NumStereoSources = 1;
3349     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
3350
3351     device->Synth = SynthCreate(device);
3352     if(!device->Synth)
3353     {
3354         DELETE_OBJ(device->Backend);
3355         al_free(device);
3356         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3357         return NULL;
3358     }
3359
3360     // Find a playback device to open
3361     if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
3362     {
3363         DELETE_OBJ(device->Synth);
3364         DELETE_OBJ(device->Backend);
3365         al_free(device);
3366         alcSetError(NULL, err);
3367         return NULL;
3368     }
3369
3370     if(DefaultEffect.type != AL_EFFECT_NULL)
3371     {
3372         device->DefaultSlot = (ALeffectslot*)device->_slot_mem;
3373         if(InitEffectSlot(device->DefaultSlot) != AL_NO_ERROR)
3374         {
3375             device->DefaultSlot = NULL;
3376             ERR("Failed to initialize the default effect slot\n");
3377         }
3378         else if(InitializeEffect(device, device->DefaultSlot, &DefaultEffect) != AL_NO_ERROR)
3379         {
3380             ALeffectState *state = device->DefaultSlot->EffectState;
3381             device->DefaultSlot = NULL;
3382             DELETE_OBJ(state);
3383             ERR("Failed to initialize the default effect\n");
3384         }
3385     }
3386
3387     {
3388         ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3389         do {
3390             device->next = head;
3391         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3392     }
3393
3394     TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
3395     return device;
3396 }
3397
3398 /* alcCloseDevice
3399  *
3400  * Closes the given device.
3401  */
3402 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
3403 {
3404     ALCdevice *list, *origdev, *nextdev;
3405     ALCcontext *ctx;
3406
3407     LockLists();
3408     list = ATOMIC_LOAD(&DeviceList);
3409     do {
3410         if(list == device)
3411             break;
3412     } while((list=list->next) != NULL);
3413     if(!list || list->Type == Capture)
3414     {
3415         alcSetError(list, ALC_INVALID_DEVICE);
3416         UnlockLists();
3417         return ALC_FALSE;
3418     }
3419
3420     origdev = device;
3421     nextdev = device->next;
3422     if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &origdev, nextdev))
3423     {
3424         do {
3425             list = origdev;
3426             origdev = device;
3427         } while(!COMPARE_EXCHANGE(&list->next, &origdev, nextdev));
3428     }
3429     UnlockLists();
3430
3431     ctx = ATOMIC_LOAD(&device->ContextList);
3432     while(ctx != NULL)
3433     {
3434         ALCcontext *next = ctx->next;
3435         WARN("Releasing context %p\n", ctx);
3436         ReleaseContext(ctx, device);
3437         ctx = next;
3438     }
3439     if((device->Flags&DEVICE_RUNNING))
3440         V0(device->Backend,stop)();
3441     device->Flags &= ~DEVICE_RUNNING;
3442
3443     ALCdevice_DecRef(device);
3444
3445     return ALC_TRUE;
3446 }
3447
3448
3449 /************************************************
3450  * ALC capture functions
3451  ************************************************/
3452 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
3453 {
3454     ALCdevice *device = NULL;
3455     ALCenum err;
3456
3457     DO_INITCONFIG();
3458
3459     if(!CaptureBackend.name)
3460     {
3461         alcSetError(NULL, ALC_INVALID_VALUE);
3462         return NULL;
3463     }
3464
3465     if(samples <= 0)
3466     {
3467         alcSetError(NULL, ALC_INVALID_VALUE);
3468         return NULL;
3469     }
3470
3471     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
3472         deviceName = NULL;
3473
3474     device = al_calloc(16, sizeof(ALCdevice));
3475     if(!device)
3476     {
3477         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3478         return NULL;
3479     }
3480
3481     //Validate device
3482     InitRef(&device->ref, 1);
3483     device->Connected = ALC_TRUE;
3484     device->Type = Capture;
3485
3486     AL_STRING_INIT(device->DeviceName);
3487
3488     InitUIntMap(&device->BufferMap, ~0);
3489     InitUIntMap(&device->EffectMap, ~0);
3490     InitUIntMap(&device->FilterMap, ~0);
3491     InitUIntMap(&device->SfontMap, ~0);
3492     InitUIntMap(&device->PresetMap, ~0);
3493     InitUIntMap(&device->FontsoundMap, ~0);
3494
3495     if(!CaptureBackend.getFactory)
3496         device->Backend = create_backend_wrapper(device, &CaptureBackend.Funcs,
3497                                                  ALCbackend_Capture);
3498     else
3499     {
3500         ALCbackendFactory *factory = CaptureBackend.getFactory();
3501         device->Backend = V(factory,createBackend)(device, ALCbackend_Capture);
3502     }
3503     if(!device->Backend)
3504     {
3505         al_free(device);
3506         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3507         return NULL;
3508     }
3509
3510     device->Flags |= DEVICE_FREQUENCY_REQUEST;
3511     device->Frequency = frequency;
3512
3513     device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_SAMPLE_TYPE_REQUEST;
3514     if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
3515     {
3516         al_free(device);
3517         alcSetError(NULL, ALC_INVALID_ENUM);
3518         return NULL;
3519     }
3520
3521     device->UpdateSize = samples;
3522     device->NumUpdates = 1;
3523
3524     if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
3525     {
3526         al_free(device);
3527         alcSetError(NULL, err);
3528         return NULL;
3529     }
3530
3531     {
3532         ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3533         do {
3534             device->next = head;
3535         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3536     }
3537
3538     TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
3539     return device;
3540 }
3541
3542 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device)
3543 {
3544     ALCdevice *list, *next, *nextdev;
3545
3546     LockLists();
3547     list = ATOMIC_LOAD(&DeviceList);
3548     do {
3549         if(list == device)
3550             break;
3551     } while((list=list->next) != NULL);
3552     if(!list || list->Type != Capture)
3553     {
3554         alcSetError(list, ALC_INVALID_DEVICE);
3555         UnlockLists();
3556         return ALC_FALSE;
3557     }
3558
3559     next = device;
3560     nextdev = device->next;
3561     if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &next, nextdev))
3562     {
3563         do {
3564             list = next;
3565             next = device;
3566         } while(!COMPARE_EXCHANGE(&list->next, &next, nextdev));
3567     }
3568     UnlockLists();
3569
3570     ALCdevice_DecRef(device);
3571
3572     return ALC_TRUE;
3573 }
3574
3575 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
3576 {
3577     if(!(device=VerifyDevice(device)) || device->Type != Capture)
3578         alcSetError(device, ALC_INVALID_DEVICE);
3579     else
3580     {
3581         ALCdevice_Lock(device);
3582         if(device->Connected)
3583         {
3584             if(!(device->Flags&DEVICE_RUNNING))
3585                 V0(device->Backend,start)();
3586             device->Flags |= DEVICE_RUNNING;
3587         }
3588         ALCdevice_Unlock(device);
3589     }
3590
3591     if(device) ALCdevice_DecRef(device);
3592 }
3593
3594 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
3595 {
3596     if(!(device=VerifyDevice(device)) || device->Type != Capture)
3597         alcSetError(device, ALC_INVALID_DEVICE);
3598     else
3599     {
3600         ALCdevice_Lock(device);
3601         if((device->Flags&DEVICE_RUNNING))
3602             V0(device->Backend,stop)();
3603         device->Flags &= ~DEVICE_RUNNING;
3604         ALCdevice_Unlock(device);
3605     }
3606
3607     if(device) ALCdevice_DecRef(device);
3608 }
3609
3610 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
3611 {
3612     if(!(device=VerifyDevice(device)) || device->Type != Capture)
3613         alcSetError(device, ALC_INVALID_DEVICE);
3614     else
3615     {
3616         ALCenum err = ALC_INVALID_VALUE;
3617
3618         ALCdevice_Lock(device);
3619         if(samples >= 0 && V0(device->Backend,availableSamples)() >= (ALCuint)samples)
3620             err = V(device->Backend,captureSamples)(buffer, samples);
3621         ALCdevice_Unlock(device);
3622
3623         if(err != ALC_NO_ERROR)
3624             alcSetError(device, err);
3625     }
3626     if(device) ALCdevice_DecRef(device);
3627 }
3628
3629
3630 /************************************************
3631  * ALC loopback functions
3632  ************************************************/
3633
3634 /* alcLoopbackOpenDeviceSOFT
3635  *
3636  * Open a loopback device, for manual rendering.
3637  */
3638 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
3639 {
3640     ALCbackendFactory *factory;
3641     ALCdevice *device;
3642
3643     DO_INITCONFIG();
3644
3645     /* Make sure the device name, if specified, is us. */
3646     if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
3647     {
3648         alcSetError(NULL, ALC_INVALID_VALUE);
3649         return NULL;
3650     }
3651
3652     device = al_calloc(16, sizeof(ALCdevice));
3653     if(!device)
3654     {
3655         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3656         return NULL;
3657     }
3658
3659     //Validate device
3660     InitRef(&device->ref, 1);
3661     device->Connected = ALC_TRUE;
3662     device->Type = Loopback;
3663     ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
3664
3665     device->Flags = 0;
3666     device->Bs2b = NULL;
3667     device->Bs2bLevel = 0;
3668     AL_STRING_INIT(device->DeviceName);
3669
3670     ATOMIC_INIT(&device->ContextList, NULL);
3671
3672     device->ClockBase = 0;
3673     device->SamplesDone = 0;
3674
3675     device->MaxNoOfSources = 256;
3676     device->AuxiliaryEffectSlotMax = 4;
3677     device->NumAuxSends = MAX_SENDS;
3678
3679     InitUIntMap(&device->BufferMap, ~0);
3680     InitUIntMap(&device->EffectMap, ~0);
3681     InitUIntMap(&device->FilterMap, ~0);
3682     InitUIntMap(&device->SfontMap, ~0);
3683     InitUIntMap(&device->PresetMap, ~0);
3684     InitUIntMap(&device->FontsoundMap, ~0);
3685
3686     factory = ALCloopbackFactory_getFactory();
3687     device->Backend = V(factory,createBackend)(device, ALCbackend_Loopback);
3688     if(!device->Backend)
3689     {
3690         al_free(device);
3691         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3692         return NULL;
3693     }
3694
3695     //Set output format
3696     device->NumUpdates = 0;
3697     device->UpdateSize = 0;
3698
3699     device->Frequency = DEFAULT_OUTPUT_RATE;
3700     device->FmtChans = DevFmtChannelsDefault;
3701     device->FmtType = DevFmtTypeDefault;
3702
3703     ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
3704     if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
3705
3706     ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
3707     if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
3708
3709     ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
3710     if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
3711
3712     device->NumStereoSources = 1;
3713     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
3714
3715     device->Synth = SynthCreate(device);
3716     if(!device->Synth)
3717     {
3718         DELETE_OBJ(device->Backend);
3719         al_free(device);
3720         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3721         return NULL;
3722     }
3723
3724     // Open the "backend"
3725     V(device->Backend,open)("Loopback");
3726
3727     {
3728         ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3729         do {
3730             device->next = head;
3731         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3732     }
3733
3734     TRACE("Created device %p\n", device);
3735     return device;
3736 }
3737
3738 /* alcIsRenderFormatSupportedSOFT
3739  *
3740  * Determines if the loopback device supports the given format for rendering.
3741  */
3742 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
3743 {
3744     ALCboolean ret = ALC_FALSE;
3745
3746     if(!(device=VerifyDevice(device)) || device->Type != Loopback)
3747         alcSetError(device, ALC_INVALID_DEVICE);
3748     else if(freq <= 0)
3749         alcSetError(device, ALC_INVALID_VALUE);
3750     else
3751     {
3752         if(IsValidALCType(type) && BytesFromDevFmt(type) > 0 &&
3753            IsValidALCChannels(channels) && ChannelsFromDevFmt(channels) > 0 &&
3754            freq >= MIN_OUTPUT_RATE)
3755             ret = ALC_TRUE;
3756     }
3757     if(device) ALCdevice_DecRef(device);
3758
3759     return ret;
3760 }
3761
3762 /* alcRenderSamplesSOFT
3763  *
3764  * Renders some samples into a buffer, using the format last set by the
3765  * attributes given to alcCreateContext.
3766  */
3767 FORCE_ALIGN ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
3768 {
3769     if(!(device=VerifyDevice(device)) || device->Type != Loopback)
3770         alcSetError(device, ALC_INVALID_DEVICE);
3771     else if(samples < 0 || (samples > 0 && buffer == NULL))
3772         alcSetError(device, ALC_INVALID_VALUE);
3773     else
3774         aluMixData(device, buffer, samples);
3775     if(device) ALCdevice_DecRef(device);
3776 }
3777
3778
3779 /************************************************
3780  * ALC DSP pause/resume functions
3781  ************************************************/
3782
3783 /* alcDevicePauseSOFT
3784  *
3785  * Pause the DSP to stop audio processing.
3786  */
3787 ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device)
3788 {
3789     if(!(device=VerifyDevice(device)) || device->Type != Playback)
3790         alcSetError(device, ALC_INVALID_DEVICE);
3791     else
3792     {
3793         LockLists();
3794         if((device->Flags&DEVICE_RUNNING))
3795             V0(device->Backend,stop)();
3796         device->Flags &= ~DEVICE_RUNNING;
3797         device->Flags |= DEVICE_PAUSED;
3798         UnlockLists();
3799     }
3800     if(device) ALCdevice_DecRef(device);
3801 }
3802
3803 /* alcDeviceResumeSOFT
3804  *
3805  * Resume the DSP to restart audio processing.
3806  */
3807 ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device)
3808 {
3809     if(!(device=VerifyDevice(device)) || device->Type != Playback)
3810         alcSetError(device, ALC_INVALID_DEVICE);
3811     else
3812     {
3813         LockLists();
3814         if((device->Flags&DEVICE_PAUSED))
3815         {
3816             device->Flags &= ~DEVICE_PAUSED;
3817             if(ATOMIC_LOAD(&device->ContextList) != NULL)
3818             {
3819                 if(V0(device->Backend,start)() != ALC_FALSE)
3820                     device->Flags |= DEVICE_RUNNING;
3821                 else
3822                 {
3823                     alcSetError(device, ALC_INVALID_DEVICE);
3824                     ALCdevice_Lock(device);
3825                     aluHandleDisconnect(device);
3826                     ALCdevice_Unlock(device);
3827                 }
3828             }
3829         }
3830         UnlockLists();
3831     }
3832     if(device) ALCdevice_DecRef(device);
3833 }