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     size_t size;
1716
1717     // Check for attributes
1718     if(device->Type == Loopback)
1719     {
1720         enum {
1721             GotFreq  = 1<<0,
1722             GotChans = 1<<1,
1723             GotType  = 1<<2,
1724             GotAll   = GotFreq|GotChans|GotType
1725         };
1726         ALCuint freq, numMono, numStereo, numSends, flags;
1727         enum DevFmtChannels schans;
1728         enum DevFmtType stype;
1729         ALCuint attrIdx = 0;
1730         ALCint gotFmt = 0;
1731
1732         if(!attrList)
1733         {
1734             WARN("Missing attributes for loopback device\n");
1735             return ALC_INVALID_VALUE;
1736         }
1737
1738         numMono = device->NumMonoSources;
1739         numStereo = device->NumStereoSources;
1740         numSends = device->NumAuxSends;
1741         schans = device->FmtChans;
1742         stype = device->FmtType;
1743         freq = device->Frequency;
1744         flags = device->Flags;
1745
1746         while(attrList[attrIdx])
1747         {
1748             if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT)
1749             {
1750                 ALCint val = attrList[attrIdx + 1];
1751                 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
1752                     return ALC_INVALID_VALUE;
1753                 schans = val;
1754                 gotFmt |= GotChans;
1755             }
1756
1757             if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT)
1758             {
1759                 ALCint val = attrList[attrIdx + 1];
1760                 if(!IsValidALCType(val) || !BytesFromDevFmt(val))
1761                     return ALC_INVALID_VALUE;
1762                 stype = val;
1763                 gotFmt |= GotType;
1764             }
1765
1766             if(attrList[attrIdx] == ALC_FREQUENCY)
1767             {
1768                 freq = attrList[attrIdx + 1];
1769                 if(freq < MIN_OUTPUT_RATE)
1770                     return ALC_INVALID_VALUE;
1771                 gotFmt |= GotFreq;
1772             }
1773
1774             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1775             {
1776                 numStereo = attrList[attrIdx + 1];
1777                 if(numStereo > device->MaxNoOfSources)
1778                     numStereo = device->MaxNoOfSources;
1779
1780                 numMono = device->MaxNoOfSources - numStereo;
1781             }
1782
1783             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1784                 numSends = attrList[attrIdx + 1];
1785
1786             if(attrList[attrIdx] == ALC_HRTF_SOFT)
1787             {
1788                 if(attrList[attrIdx + 1] != ALC_FALSE)
1789                     flags |= DEVICE_HRTF_REQUEST;
1790                 else
1791                     flags &= ~DEVICE_HRTF_REQUEST;
1792             }
1793
1794             attrIdx += 2;
1795         }
1796
1797         if(gotFmt != GotAll)
1798         {
1799             WARN("Missing format for loopback device\n");
1800             return ALC_INVALID_VALUE;
1801         }
1802
1803         ConfigValueUInt(NULL, "sends", &numSends);
1804         numSends = minu(MAX_SENDS, numSends);
1805
1806         if((device->Flags&DEVICE_RUNNING))
1807             V0(device->Backend,stop)();
1808         device->Flags = (flags & ~DEVICE_RUNNING);
1809
1810         UpdateClockBase(device);
1811
1812         device->Frequency = freq;
1813         device->FmtChans = schans;
1814         device->FmtType = stype;
1815         device->NumMonoSources = numMono;
1816         device->NumStereoSources = numStereo;
1817         device->NumAuxSends = numSends;
1818     }
1819     else if(attrList && attrList[0])
1820     {
1821         ALCuint freq, numMono, numStereo, numSends;
1822         ALCuint attrIdx = 0;
1823
1824         /* If a context is already running on the device, stop playback so the
1825          * device attributes can be updated. */
1826         if((device->Flags&DEVICE_RUNNING))
1827             V0(device->Backend,stop)();
1828         device->Flags &= ~DEVICE_RUNNING;
1829
1830         freq = device->Frequency;
1831         numMono = device->NumMonoSources;
1832         numStereo = device->NumStereoSources;
1833         numSends = device->NumAuxSends;
1834
1835         while(attrList[attrIdx])
1836         {
1837             if(attrList[attrIdx] == ALC_FREQUENCY)
1838             {
1839                 freq = attrList[attrIdx + 1];
1840                 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1841             }
1842
1843             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1844             {
1845                 numStereo = attrList[attrIdx + 1];
1846                 if(numStereo > device->MaxNoOfSources)
1847                     numStereo = device->MaxNoOfSources;
1848
1849                 numMono = device->MaxNoOfSources - numStereo;
1850             }
1851
1852             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1853                 numSends = attrList[attrIdx + 1];
1854
1855             if(attrList[attrIdx] == ALC_HRTF_SOFT)
1856             {
1857                 if(attrList[attrIdx + 1] != ALC_FALSE)
1858                     device->Flags |= DEVICE_HRTF_REQUEST;
1859                 else
1860                     device->Flags &= ~DEVICE_HRTF_REQUEST;
1861             }
1862
1863             attrIdx += 2;
1864         }
1865
1866         ConfigValueUInt(NULL, "frequency", &freq);
1867         freq = maxu(freq, MIN_OUTPUT_RATE);
1868
1869         ConfigValueUInt(NULL, "sends", &numSends);
1870         numSends = minu(MAX_SENDS, numSends);
1871
1872         UpdateClockBase(device);
1873
1874         device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1875                              device->Frequency;
1876         /* SSE and Neon do best with the update size being a multiple of 4 */
1877         if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
1878             device->UpdateSize = (device->UpdateSize+3)&~3;
1879
1880         device->Frequency = freq;
1881         device->NumMonoSources = numMono;
1882         device->NumStereoSources = numStereo;
1883         device->NumAuxSends = numSends;
1884     }
1885
1886     if((device->Flags&DEVICE_RUNNING))
1887         return ALC_NO_ERROR;
1888
1889     al_free(device->DryBuffer);
1890     device->DryBuffer = NULL;
1891
1892     UpdateClockBase(device);
1893
1894     if(device->Type != Loopback)
1895     {
1896         bool usehrtf = !!(device->Flags&DEVICE_HRTF_REQUEST);
1897         if(GetConfigValueBool(NULL, "hrtf", usehrtf))
1898             device->Flags |= DEVICE_HRTF_REQUEST;
1899         else
1900             device->Flags &= ~DEVICE_HRTF_REQUEST;
1901     }
1902     if((device->Flags&DEVICE_HRTF_REQUEST))
1903     {
1904         enum DevFmtChannels chans = device->FmtChans;
1905         ALCuint freq = device->Frequency;
1906         if(FindHrtfFormat(&chans, &freq))
1907         {
1908             if(device->Type != Loopback)
1909             {
1910                 device->Frequency = freq;
1911                 device->FmtChans = chans;
1912                 device->Flags |= DEVICE_CHANNELS_REQUEST |
1913                                  DEVICE_FREQUENCY_REQUEST;
1914             }
1915             else if(device->Frequency != freq || device->FmtChans != chans)
1916             {
1917                 ERR("Requested format not HRTF compatible: %s, %uhz\n",
1918                     DevFmtChannelsString(device->FmtChans), device->Frequency);
1919                 device->Flags &= ~DEVICE_HRTF_REQUEST;
1920             }
1921         }
1922     }
1923
1924     oldFreq  = device->Frequency;
1925     oldChans = device->FmtChans;
1926     oldType  = device->FmtType;
1927
1928     TRACE("Pre-reset: %s%s, %s%s, %s%uhz, %u update size x%d\n",
1929         (device->Flags&DEVICE_CHANNELS_REQUEST)?"*":"", DevFmtChannelsString(device->FmtChans),
1930         (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST)?"*":"", DevFmtTypeString(device->FmtType),
1931         (device->Flags&DEVICE_FREQUENCY_REQUEST)?"*":"", device->Frequency,
1932         device->UpdateSize, device->NumUpdates
1933     );
1934
1935     if(V0(device->Backend,reset)() == ALC_FALSE)
1936         return ALC_INVALID_DEVICE;
1937
1938     if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
1939     {
1940         ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
1941             DevFmtChannelsString(device->FmtChans));
1942         device->Flags &= ~DEVICE_CHANNELS_REQUEST;
1943     }
1944     if(device->FmtType != oldType && (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
1945     {
1946         ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
1947             DevFmtTypeString(device->FmtType));
1948         device->Flags &= ~DEVICE_SAMPLE_TYPE_REQUEST;
1949     }
1950     if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
1951     {
1952         ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
1953         device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
1954     }
1955
1956     TRACE("Post-reset: %s, %s, %uhz, %u update size x%d\n",
1957         DevFmtChannelsString(device->FmtChans), DevFmtTypeString(device->FmtType),
1958         device->Frequency, device->UpdateSize, device->NumUpdates
1959     );
1960
1961     if((device->UpdateSize&3) != 0)
1962     {
1963         if((CPUCapFlags&CPU_CAP_SSE))
1964             WARN("SSE performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
1965         if((CPUCapFlags&CPU_CAP_NEON))
1966             WARN("NEON performs best with multiple of 4 update sizes (%u)\n", device->UpdateSize);
1967     }
1968
1969     device->Hrtf = NULL;
1970     if((device->Flags&DEVICE_HRTF_REQUEST))
1971     {
1972         device->Hrtf = GetHrtf(device->FmtChans, device->Frequency);
1973         if(!device->Hrtf)
1974             device->Flags &= ~DEVICE_HRTF_REQUEST;
1975     }
1976     TRACE("HRTF %s\n", device->Hrtf?"enabled":"disabled");
1977
1978     if(!device->Hrtf && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6 &&
1979        device->FmtChans == DevFmtStereo)
1980     {
1981         if(!device->Bs2b)
1982         {
1983             device->Bs2b = calloc(1, sizeof(*device->Bs2b));
1984             bs2b_clear(device->Bs2b);
1985         }
1986         bs2b_set_srate(device->Bs2b, device->Frequency);
1987         bs2b_set_level(device->Bs2b, device->Bs2bLevel);
1988         TRACE("BS2B level %d\n", device->Bs2bLevel);
1989     }
1990     else
1991     {
1992         free(device->Bs2b);
1993         device->Bs2b = NULL;
1994         TRACE("BS2B disabled\n");
1995     }
1996
1997     aluInitPanning(device);
1998
1999     /* With HRTF enabled, the channels are virtual and get positioned around
2000      * the virtual listener. Two extra channels are allocated for the actual
2001      * HRTF-filtered output.
2002      */
2003     size = sizeof(device->DryBuffer[0]) * (device->NumChannels + (device->Hrtf ? 2 : 0));
2004     device->DryBuffer = al_calloc(16, size);
2005     if(!device->DryBuffer)
2006     {
2007         ERR("Failed to allocate "SZFMT" bytes for mix buffer\n", size);
2008         return ALC_INVALID_DEVICE;
2009     }
2010
2011     V(device->Synth,update)(device);
2012
2013     SetMixerFPUMode(&oldMode);
2014     V0(device->Backend,lock)();
2015     context = ATOMIC_LOAD(&device->ContextList);
2016     while(context)
2017     {
2018         ALsizei pos;
2019
2020         ATOMIC_STORE(&context->UpdateSources, AL_FALSE);
2021         LockUIntMapRead(&context->EffectSlotMap);
2022         for(pos = 0;pos < context->EffectSlotMap.size;pos++)
2023         {
2024             ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
2025
2026             if(V(slot->EffectState,deviceUpdate)(device) == AL_FALSE)
2027             {
2028                 UnlockUIntMapRead(&context->EffectSlotMap);
2029                 V0(device->Backend,unlock)();
2030                 RestoreFPUMode(&oldMode);
2031                 return ALC_INVALID_DEVICE;
2032             }
2033             ATOMIC_STORE(&slot->NeedsUpdate, AL_FALSE);
2034             V(slot->EffectState,update)(device, slot);
2035         }
2036         UnlockUIntMapRead(&context->EffectSlotMap);
2037
2038         LockUIntMapRead(&context->SourceMap);
2039         for(pos = 0;pos < context->SourceMap.size;pos++)
2040         {
2041             ALsource *source = context->SourceMap.array[pos].value;
2042             ALuint s = device->NumAuxSends;
2043             while(s < MAX_SENDS)
2044             {
2045                 if(source->Send[s].Slot)
2046                     DecrementRef(&source->Send[s].Slot->ref);
2047                 source->Send[s].Slot = NULL;
2048                 source->Send[s].Gain = 1.0f;
2049                 source->Send[s].GainHF = 1.0f;
2050                 s++;
2051             }
2052             ATOMIC_STORE(&source->NeedsUpdate, AL_TRUE);
2053         }
2054         UnlockUIntMapRead(&context->SourceMap);
2055
2056         for(pos = 0;pos < context->VoiceCount;pos++)
2057         {
2058             ALvoice *voice = &context->Voices[pos];
2059             ALsource *source = voice->Source;
2060             ALuint s = device->NumAuxSends;
2061
2062             while(s < MAX_SENDS)
2063             {
2064                 voice->Send[s].Moving = AL_FALSE;
2065                 voice->Send[s].Counter = 0;
2066                 s++;
2067             }
2068
2069             if(source)
2070             {
2071                 ATOMIC_STORE(&source->NeedsUpdate, AL_FALSE);
2072                 voice->Update(voice, source, context);
2073             }
2074         }
2075
2076         context = context->next;
2077     }
2078     if(device->DefaultSlot)
2079     {
2080         ALeffectslot *slot = device->DefaultSlot;
2081
2082         if(V(slot->EffectState,deviceUpdate)(device) == AL_FALSE)
2083         {
2084             V0(device->Backend,unlock)();
2085             RestoreFPUMode(&oldMode);
2086             return ALC_INVALID_DEVICE;
2087         }
2088         ATOMIC_STORE(&slot->NeedsUpdate, AL_FALSE);
2089         V(slot->EffectState,update)(device, slot);
2090     }
2091     V0(device->Backend,unlock)();
2092     RestoreFPUMode(&oldMode);
2093
2094     if(!(device->Flags&DEVICE_PAUSED))
2095     {
2096         if(V0(device->Backend,start)() == ALC_FALSE)
2097             return ALC_INVALID_DEVICE;
2098         device->Flags |= DEVICE_RUNNING;
2099     }
2100
2101     return ALC_NO_ERROR;
2102 }
2103
2104 /* FreeDevice
2105  *
2106  * Frees the device structure, and destroys any objects the app failed to
2107  * delete. Called once there's no more references on the device.
2108  */
2109 static ALCvoid FreeDevice(ALCdevice *device)
2110 {
2111     TRACE("%p\n", device);
2112
2113     V0(device->Backend,close)();
2114     DELETE_OBJ(device->Backend);
2115     device->Backend = NULL;
2116
2117     DELETE_OBJ(device->Synth);
2118     device->Synth = NULL;
2119
2120     if(device->DefaultSlot)
2121     {
2122         ALeffectState *state = device->DefaultSlot->EffectState;
2123         device->DefaultSlot = NULL;
2124         DELETE_OBJ(state);
2125     }
2126
2127     if(device->DefaultSfont)
2128         ALsoundfont_deleteSoundfont(device->DefaultSfont, device);
2129     device->DefaultSfont = NULL;
2130
2131     if(device->BufferMap.size > 0)
2132     {
2133         WARN("(%p) Deleting %d Buffer(s)\n", device, device->BufferMap.size);
2134         ReleaseALBuffers(device);
2135     }
2136     ResetUIntMap(&device->BufferMap);
2137
2138     if(device->EffectMap.size > 0)
2139     {
2140         WARN("(%p) Deleting %d Effect(s)\n", device, device->EffectMap.size);
2141         ReleaseALEffects(device);
2142     }
2143     ResetUIntMap(&device->EffectMap);
2144
2145     if(device->FilterMap.size > 0)
2146     {
2147         WARN("(%p) Deleting %d Filter(s)\n", device, device->FilterMap.size);
2148         ReleaseALFilters(device);
2149     }
2150     ResetUIntMap(&device->FilterMap);
2151
2152     if(device->SfontMap.size > 0)
2153     {
2154         WARN("(%p) Deleting %d Soundfont(s)\n", device, device->SfontMap.size);
2155         ReleaseALSoundfonts(device);
2156     }
2157     ResetUIntMap(&device->SfontMap);
2158
2159     if(device->PresetMap.size > 0)
2160     {
2161         WARN("(%p) Deleting %d Preset(s)\n", device, device->PresetMap.size);
2162         ReleaseALPresets(device);
2163     }
2164     ResetUIntMap(&device->PresetMap);
2165
2166     if(device->FontsoundMap.size > 0)
2167     {
2168         WARN("(%p) Deleting %d Fontsound(s)\n", device, device->FontsoundMap.size);
2169         ReleaseALFontsounds(device);
2170     }
2171     ResetUIntMap(&device->FontsoundMap);
2172
2173     free(device->Bs2b);
2174     device->Bs2b = NULL;
2175
2176     AL_STRING_DEINIT(device->DeviceName);
2177
2178     al_free(device->DryBuffer);
2179     device->DryBuffer = NULL;
2180
2181     al_free(device);
2182 }
2183
2184
2185 void ALCdevice_IncRef(ALCdevice *device)
2186 {
2187     uint ref;
2188     ref = IncrementRef(&device->ref);
2189     TRACEREF("%p increasing refcount to %u\n", device, ref);
2190 }
2191
2192 void ALCdevice_DecRef(ALCdevice *device)
2193 {
2194     uint ref;
2195     ref = DecrementRef(&device->ref);
2196     TRACEREF("%p decreasing refcount to %u\n", device, ref);
2197     if(ref == 0) FreeDevice(device);
2198 }
2199
2200 /* VerifyDevice
2201  *
2202  * Checks if the device handle is valid, and increments its ref count if so.
2203  */
2204 static ALCdevice *VerifyDevice(ALCdevice *device)
2205 {
2206     ALCdevice *tmpDevice;
2207
2208     if(!device)
2209         return NULL;
2210
2211     LockLists();
2212     tmpDevice = ATOMIC_LOAD(&DeviceList);
2213     while(tmpDevice && tmpDevice != device)
2214         tmpDevice = tmpDevice->next;
2215
2216     if(tmpDevice)
2217         ALCdevice_IncRef(tmpDevice);
2218     UnlockLists();
2219     return tmpDevice;
2220 }
2221
2222
2223 /* InitContext
2224  *
2225  * Initializes context fields
2226  */
2227 static ALvoid InitContext(ALCcontext *Context)
2228 {
2229     ALint i, j;
2230
2231     //Initialise listener
2232     Context->Listener->Gain = 1.0f;
2233     Context->Listener->MetersPerUnit = 1.0f;
2234     Context->Listener->Position[0] = 0.0f;
2235     Context->Listener->Position[1] = 0.0f;
2236     Context->Listener->Position[2] = 0.0f;
2237     Context->Listener->Velocity[0] = 0.0f;
2238     Context->Listener->Velocity[1] = 0.0f;
2239     Context->Listener->Velocity[2] = 0.0f;
2240     Context->Listener->Forward[0] = 0.0f;
2241     Context->Listener->Forward[1] = 0.0f;
2242     Context->Listener->Forward[2] = -1.0f;
2243     Context->Listener->Up[0] = 0.0f;
2244     Context->Listener->Up[1] = 1.0f;
2245     Context->Listener->Up[2] = 0.0f;
2246     for(i = 0;i < 4;i++)
2247     {
2248         for(j = 0;j < 4;j++)
2249             Context->Listener->Params.Matrix[i][j] = ((i==j) ? 1.0f : 0.0f);
2250     }
2251     for(i = 0;i < 3;i++)
2252         Context->Listener->Params.Velocity[i] = 0.0f;
2253
2254     //Validate Context
2255     ATOMIC_INIT(&Context->LastError, AL_NO_ERROR);
2256     ATOMIC_INIT(&Context->UpdateSources, AL_FALSE);
2257     InitUIntMap(&Context->SourceMap, Context->Device->MaxNoOfSources);
2258     InitUIntMap(&Context->EffectSlotMap, Context->Device->AuxiliaryEffectSlotMax);
2259
2260     //Set globals
2261     Context->DistanceModel = DefaultDistanceModel;
2262     Context->SourceDistanceModel = AL_FALSE;
2263     Context->DopplerFactor = 1.0f;
2264     Context->DopplerVelocity = 1.0f;
2265     Context->SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
2266     Context->DeferUpdates = AL_FALSE;
2267
2268     Context->ExtensionList = alExtList;
2269 }
2270
2271
2272 /* FreeContext
2273  *
2274  * Cleans up the context, and destroys any remaining objects the app failed to
2275  * delete. Called once there's no more references on the context.
2276  */
2277 static void FreeContext(ALCcontext *context)
2278 {
2279     TRACE("%p\n", context);
2280
2281     if(context->SourceMap.size > 0)
2282     {
2283         WARN("(%p) Deleting %d Source(s)\n", context, context->SourceMap.size);
2284         ReleaseALSources(context);
2285     }
2286     ResetUIntMap(&context->SourceMap);
2287
2288     if(context->EffectSlotMap.size > 0)
2289     {
2290         WARN("(%p) Deleting %d AuxiliaryEffectSlot(s)\n", context, context->EffectSlotMap.size);
2291         ReleaseALAuxiliaryEffectSlots(context);
2292     }
2293     ResetUIntMap(&context->EffectSlotMap);
2294
2295     al_free(context->Voices);
2296     context->Voices = NULL;
2297     context->VoiceCount = 0;
2298     context->MaxVoices = 0;
2299
2300     VECTOR_DEINIT(context->ActiveAuxSlots);
2301
2302     ALCdevice_DecRef(context->Device);
2303     context->Device = NULL;
2304
2305     //Invalidate context
2306     memset(context, 0, sizeof(ALCcontext));
2307     al_free(context);
2308 }
2309
2310 /* ReleaseContext
2311  *
2312  * Removes the context reference from the given device and removes it from
2313  * being current on the running thread or globally.
2314  */
2315 static void ReleaseContext(ALCcontext *context, ALCdevice *device)
2316 {
2317     ALCcontext *nextctx;
2318     ALCcontext *origctx;
2319
2320     if(altss_get(LocalContext) == context)
2321     {
2322         WARN("%p released while current on thread\n", context);
2323         altss_set(LocalContext, NULL);
2324         ALCcontext_DecRef(context);
2325     }
2326
2327     origctx = context;
2328     if(ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &GlobalContext, &origctx, NULL))
2329         ALCcontext_DecRef(context);
2330
2331     ALCdevice_Lock(device);
2332     origctx = context;
2333     nextctx = context->next;
2334     if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCcontext*, &device->ContextList, &origctx, nextctx))
2335     {
2336         ALCcontext *list;
2337         do {
2338             list = origctx;
2339             origctx = context;
2340         } while(!COMPARE_EXCHANGE(&list->next, &origctx, nextctx));
2341     }
2342     ALCdevice_Unlock(device);
2343
2344     ALCcontext_DecRef(context);
2345 }
2346
2347 void ALCcontext_IncRef(ALCcontext *context)
2348 {
2349     uint ref;
2350     ref = IncrementRef(&context->ref);
2351     TRACEREF("%p increasing refcount to %u\n", context, ref);
2352 }
2353
2354 void ALCcontext_DecRef(ALCcontext *context)
2355 {
2356     uint ref;
2357     ref = DecrementRef(&context->ref);
2358     TRACEREF("%p decreasing refcount to %u\n", context, ref);
2359     if(ref == 0) FreeContext(context);
2360 }
2361
2362 static void ReleaseThreadCtx(void *ptr)
2363 {
2364     WARN("%p current for thread being destroyed\n", ptr);
2365     ALCcontext_DecRef(ptr);
2366 }
2367
2368 /* VerifyContext
2369  *
2370  * Checks that the given context is valid, and increments its reference count.
2371  */
2372 static ALCcontext *VerifyContext(ALCcontext *context)
2373 {
2374     ALCdevice *dev;
2375
2376     LockLists();
2377     dev = ATOMIC_LOAD(&DeviceList);
2378     while(dev)
2379     {
2380         ALCcontext *ctx = ATOMIC_LOAD(&dev->ContextList);
2381         while(ctx)
2382         {
2383             if(ctx == context)
2384             {
2385                 ALCcontext_IncRef(ctx);
2386                 UnlockLists();
2387                 return ctx;
2388             }
2389             ctx = ctx->next;
2390         }
2391         dev = dev->next;
2392     }
2393     UnlockLists();
2394
2395     return NULL;
2396 }
2397
2398
2399 /* GetContextRef
2400  *
2401  * Returns the currently active context for this thread, and adds a reference
2402  * without locking it.
2403  */
2404 ALCcontext *GetContextRef(void)
2405 {
2406     ALCcontext *context;
2407
2408     context = altss_get(LocalContext);
2409     if(context)
2410         ALCcontext_IncRef(context);
2411     else
2412     {
2413         LockLists();
2414         context = ATOMIC_LOAD(&GlobalContext);
2415         if(context)
2416             ALCcontext_IncRef(context);
2417         UnlockLists();
2418     }
2419
2420     return context;
2421 }
2422
2423
2424 /************************************************
2425  * Standard ALC functions
2426  ************************************************/
2427
2428 /* alcGetError
2429  *
2430  * Return last ALC generated error code for the given device
2431 */
2432 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
2433 {
2434     ALCenum errorCode;
2435
2436     if(VerifyDevice(device))
2437     {
2438         errorCode = ATOMIC_EXCHANGE(ALCenum, &device->LastError, ALC_NO_ERROR);
2439         ALCdevice_DecRef(device);
2440     }
2441     else
2442         errorCode = ATOMIC_EXCHANGE(ALCenum, &LastNullDeviceError, ALC_NO_ERROR);
2443
2444     return errorCode;
2445 }
2446
2447
2448 /* alcSuspendContext
2449  *
2450  * Suspends updates for the given context
2451  */
2452 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *context)
2453 {
2454     if(!SuspendDefers)
2455         return;
2456
2457     context = VerifyContext(context);
2458     if(!context)
2459         alcSetError(NULL, ALC_INVALID_CONTEXT);
2460     else
2461     {
2462         ALCcontext_DeferUpdates(context);
2463         ALCcontext_DecRef(context);
2464     }
2465 }
2466
2467 /* alcProcessContext
2468  *
2469  * Resumes processing updates for the given context
2470  */
2471 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *context)
2472 {
2473     if(!SuspendDefers)
2474         return;
2475
2476     context = VerifyContext(context);
2477     if(!context)
2478         alcSetError(NULL, ALC_INVALID_CONTEXT);
2479     else
2480     {
2481         ALCcontext_ProcessUpdates(context);
2482         ALCcontext_DecRef(context);
2483     }
2484 }
2485
2486
2487 /* alcGetString
2488  *
2489  * Returns information about the device, and error strings
2490  */
2491 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
2492 {
2493     const ALCchar *value = NULL;
2494
2495     switch(param)
2496     {
2497     case ALC_NO_ERROR:
2498         value = alcNoError;
2499         break;
2500
2501     case ALC_INVALID_ENUM:
2502         value = alcErrInvalidEnum;
2503         break;
2504
2505     case ALC_INVALID_VALUE:
2506         value = alcErrInvalidValue;
2507         break;
2508
2509     case ALC_INVALID_DEVICE:
2510         value = alcErrInvalidDevice;
2511         break;
2512
2513     case ALC_INVALID_CONTEXT:
2514         value = alcErrInvalidContext;
2515         break;
2516
2517     case ALC_OUT_OF_MEMORY:
2518         value = alcErrOutOfMemory;
2519         break;
2520
2521     case ALC_DEVICE_SPECIFIER:
2522         value = alcDefaultName;
2523         break;
2524
2525     case ALC_ALL_DEVICES_SPECIFIER:
2526         if(VerifyDevice(Device))
2527         {
2528             value = al_string_get_cstr(Device->DeviceName);
2529             ALCdevice_DecRef(Device);
2530         }
2531         else
2532         {
2533             ProbeAllDevicesList();
2534             value = al_string_get_cstr(alcAllDevicesList);
2535         }
2536         break;
2537
2538     case ALC_CAPTURE_DEVICE_SPECIFIER:
2539         if(VerifyDevice(Device))
2540         {
2541             value = al_string_get_cstr(Device->DeviceName);
2542             ALCdevice_DecRef(Device);
2543         }
2544         else
2545         {
2546             ProbeCaptureDeviceList();
2547             value = al_string_get_cstr(alcCaptureDeviceList);
2548         }
2549         break;
2550
2551     /* Default devices are always first in the list */
2552     case ALC_DEFAULT_DEVICE_SPECIFIER:
2553         value = alcDefaultName;
2554         break;
2555
2556     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
2557         if(al_string_empty(alcAllDevicesList))
2558             ProbeAllDevicesList();
2559
2560         Device = VerifyDevice(Device);
2561
2562         free(alcDefaultAllDevicesSpecifier);
2563         alcDefaultAllDevicesSpecifier = strdup(al_string_get_cstr(alcAllDevicesList));
2564         if(!alcDefaultAllDevicesSpecifier)
2565             alcSetError(Device, ALC_OUT_OF_MEMORY);
2566
2567         value = alcDefaultAllDevicesSpecifier;
2568         if(Device) ALCdevice_DecRef(Device);
2569         break;
2570
2571     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
2572         if(al_string_empty(alcCaptureDeviceList))
2573             ProbeCaptureDeviceList();
2574
2575         Device = VerifyDevice(Device);
2576
2577         free(alcCaptureDefaultDeviceSpecifier);
2578         alcCaptureDefaultDeviceSpecifier = strdup(al_string_get_cstr(alcCaptureDeviceList));
2579         if(!alcCaptureDefaultDeviceSpecifier)
2580             alcSetError(Device, ALC_OUT_OF_MEMORY);
2581
2582         value = alcCaptureDefaultDeviceSpecifier;
2583         if(Device) ALCdevice_DecRef(Device);
2584         break;
2585
2586     case ALC_EXTENSIONS:
2587         if(!VerifyDevice(Device))
2588             value = alcNoDeviceExtList;
2589         else
2590         {
2591             value = alcExtensionList;
2592             ALCdevice_DecRef(Device);
2593         }
2594         break;
2595
2596     default:
2597         Device = VerifyDevice(Device);
2598         alcSetError(Device, ALC_INVALID_ENUM);
2599         if(Device) ALCdevice_DecRef(Device);
2600         break;
2601     }
2602
2603     return value;
2604 }
2605
2606
2607 static ALCsizei GetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
2608 {
2609     ALCsizei i;
2610
2611     if(size <= 0 || values == NULL)
2612     {
2613         alcSetError(device, ALC_INVALID_VALUE);
2614         return 0;
2615     }
2616
2617     if(!device)
2618     {
2619         switch(param)
2620         {
2621             case ALC_MAJOR_VERSION:
2622                 values[0] = alcMajorVersion;
2623                 return 1;
2624             case ALC_MINOR_VERSION:
2625                 values[0] = alcMinorVersion;
2626                 return 1;
2627
2628             case ALC_ATTRIBUTES_SIZE:
2629             case ALC_ALL_ATTRIBUTES:
2630             case ALC_FREQUENCY:
2631             case ALC_REFRESH:
2632             case ALC_SYNC:
2633             case ALC_MONO_SOURCES:
2634             case ALC_STEREO_SOURCES:
2635             case ALC_CAPTURE_SAMPLES:
2636             case ALC_FORMAT_CHANNELS_SOFT:
2637             case ALC_FORMAT_TYPE_SOFT:
2638                 alcSetError(NULL, ALC_INVALID_DEVICE);
2639                 return 0;
2640
2641             default:
2642                 alcSetError(NULL, ALC_INVALID_ENUM);
2643                 return 0;
2644         }
2645         return 0;
2646     }
2647
2648     if(device->Type == Capture)
2649     {
2650         switch(param)
2651         {
2652             case ALC_CAPTURE_SAMPLES:
2653                 ALCdevice_Lock(device);
2654                 values[0] = V0(device->Backend,availableSamples)();
2655                 ALCdevice_Unlock(device);
2656                 return 1;
2657
2658             case ALC_CONNECTED:
2659                 values[0] = device->Connected;
2660                 return 1;
2661
2662             default:
2663                 alcSetError(device, ALC_INVALID_ENUM);
2664                 return 0;
2665         }
2666         return 0;
2667     }
2668
2669     /* render device */
2670     switch(param)
2671     {
2672         case ALC_MAJOR_VERSION:
2673             values[0] = alcMajorVersion;
2674             return 1;
2675
2676         case ALC_MINOR_VERSION:
2677             values[0] = alcMinorVersion;
2678             return 1;
2679
2680         case ALC_EFX_MAJOR_VERSION:
2681             values[0] = alcEFXMajorVersion;
2682             return 1;
2683
2684         case ALC_EFX_MINOR_VERSION:
2685             values[0] = alcEFXMinorVersion;
2686             return 1;
2687
2688         case ALC_ATTRIBUTES_SIZE:
2689             values[0] = 15;
2690             return 1;
2691
2692         case ALC_ALL_ATTRIBUTES:
2693             if(size < 15)
2694             {
2695                 alcSetError(device, ALC_INVALID_VALUE);
2696                 return 0;
2697             }
2698
2699             i = 0;
2700             values[i++] = ALC_FREQUENCY;
2701             values[i++] = device->Frequency;
2702
2703             if(device->Type != Loopback)
2704             {
2705                 values[i++] = ALC_REFRESH;
2706                 values[i++] = device->Frequency / device->UpdateSize;
2707
2708                 values[i++] = ALC_SYNC;
2709                 values[i++] = ALC_FALSE;
2710             }
2711             else
2712             {
2713                 values[i++] = ALC_FORMAT_CHANNELS_SOFT;
2714                 values[i++] = device->FmtChans;
2715
2716                 values[i++] = ALC_FORMAT_TYPE_SOFT;
2717                 values[i++] = device->FmtType;
2718             }
2719
2720             values[i++] = ALC_MONO_SOURCES;
2721             values[i++] = device->NumMonoSources;
2722
2723             values[i++] = ALC_STEREO_SOURCES;
2724             values[i++] = device->NumStereoSources;
2725
2726             values[i++] = ALC_MAX_AUXILIARY_SENDS;
2727             values[i++] = device->NumAuxSends;
2728
2729             values[i++] = ALC_HRTF_SOFT;
2730             values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2731
2732             values[i++] = 0;
2733             return i;
2734
2735         case ALC_FREQUENCY:
2736             values[0] = device->Frequency;
2737             return 1;
2738
2739         case ALC_REFRESH:
2740             if(device->Type == Loopback)
2741             {
2742                 alcSetError(device, ALC_INVALID_DEVICE);
2743                 return 0;
2744             }
2745             values[0] = device->Frequency / device->UpdateSize;
2746             return 1;
2747
2748         case ALC_SYNC:
2749             if(device->Type == Loopback)
2750             {
2751                 alcSetError(device, ALC_INVALID_DEVICE);
2752                 return 0;
2753             }
2754             values[0] = ALC_FALSE;
2755             return 1;
2756
2757         case ALC_FORMAT_CHANNELS_SOFT:
2758             if(device->Type != Loopback)
2759             {
2760                 alcSetError(device, ALC_INVALID_DEVICE);
2761                 return 0;
2762             }
2763             values[0] = device->FmtChans;
2764             return 1;
2765
2766         case ALC_FORMAT_TYPE_SOFT:
2767             if(device->Type != Loopback)
2768             {
2769                 alcSetError(device, ALC_INVALID_DEVICE);
2770                 return 0;
2771             }
2772             values[0] = device->FmtType;
2773             return 1;
2774
2775         case ALC_MONO_SOURCES:
2776             values[0] = device->NumMonoSources;
2777             return 1;
2778
2779         case ALC_STEREO_SOURCES:
2780             values[0] = device->NumStereoSources;
2781             return 1;
2782
2783         case ALC_MAX_AUXILIARY_SENDS:
2784             values[0] = device->NumAuxSends;
2785             return 1;
2786
2787         case ALC_CONNECTED:
2788             values[0] = device->Connected;
2789             return 1;
2790
2791         case ALC_HRTF_SOFT:
2792             values[0] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2793             return 1;
2794
2795         default:
2796             alcSetError(device, ALC_INVALID_ENUM);
2797             return 0;
2798     }
2799     return 0;
2800 }
2801
2802 /* alcGetIntegerv
2803  *
2804  * Returns information about the device and the version of OpenAL
2805  */
2806 ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
2807 {
2808     device = VerifyDevice(device);
2809     if(size <= 0 || values == NULL)
2810         alcSetError(device, ALC_INVALID_VALUE);
2811     else
2812         GetIntegerv(device, param, size, values);
2813     if(device) ALCdevice_DecRef(device);
2814 }
2815
2816 ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALCsizei size, ALCint64SOFT *values)
2817 {
2818     ALCint *ivals;
2819     ALsizei i;
2820
2821     device = VerifyDevice(device);
2822     if(size <= 0 || values == NULL)
2823         alcSetError(device, ALC_INVALID_VALUE);
2824     else if(!device || device->Type == Capture)
2825     {
2826         ivals = malloc(size * sizeof(ALCint));
2827         size = GetIntegerv(device, pname, size, ivals);
2828         for(i = 0;i < size;i++)
2829             values[i] = ivals[i];
2830         free(ivals);
2831     }
2832     else /* render device */
2833     {
2834         switch(pname)
2835         {
2836             case ALC_ATTRIBUTES_SIZE:
2837                 *values = 17;
2838                 break;
2839
2840             case ALC_ALL_ATTRIBUTES:
2841                 if(size < 17)
2842                     alcSetError(device, ALC_INVALID_VALUE);
2843                 else
2844                 {
2845                     int i = 0;
2846
2847                     V0(device->Backend,lock)();
2848                     values[i++] = ALC_FREQUENCY;
2849                     values[i++] = device->Frequency;
2850
2851                     if(device->Type != Loopback)
2852                     {
2853                         values[i++] = ALC_REFRESH;
2854                         values[i++] = device->Frequency / device->UpdateSize;
2855
2856                         values[i++] = ALC_SYNC;
2857                         values[i++] = ALC_FALSE;
2858                     }
2859                     else
2860                     {
2861                         values[i++] = ALC_FORMAT_CHANNELS_SOFT;
2862                         values[i++] = device->FmtChans;
2863
2864                         values[i++] = ALC_FORMAT_TYPE_SOFT;
2865                         values[i++] = device->FmtType;
2866                     }
2867
2868                     values[i++] = ALC_MONO_SOURCES;
2869                     values[i++] = device->NumMonoSources;
2870
2871                     values[i++] = ALC_STEREO_SOURCES;
2872                     values[i++] = device->NumStereoSources;
2873
2874                     values[i++] = ALC_MAX_AUXILIARY_SENDS;
2875                     values[i++] = device->NumAuxSends;
2876
2877                     values[i++] = ALC_HRTF_SOFT;
2878                     values[i++] = (device->Hrtf ? ALC_TRUE : ALC_FALSE);
2879
2880                     values[i++] = ALC_DEVICE_CLOCK_SOFT;
2881                     values[i++] = device->ClockBase +
2882                                   (device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency);
2883
2884                     values[i++] = 0;
2885                     V0(device->Backend,unlock)();
2886                 }
2887                 break;
2888
2889             case ALC_DEVICE_CLOCK_SOFT:
2890                 V0(device->Backend,lock)();
2891                 *values = device->ClockBase +
2892                           (device->SamplesDone * DEVICE_CLOCK_RES / device->Frequency);
2893                 V0(device->Backend,unlock)();
2894                 break;
2895
2896             default:
2897                 ivals = malloc(size * sizeof(ALCint));
2898                 size = GetIntegerv(device, pname, size, ivals);
2899                 for(i = 0;i < size;i++)
2900                     values[i] = ivals[i];
2901                 free(ivals);
2902                 break;
2903         }
2904     }
2905     if(device)
2906         ALCdevice_DecRef(device);
2907 }
2908
2909
2910 /* alcIsExtensionPresent
2911  *
2912  * Determines if there is support for a particular extension
2913  */
2914 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
2915 {
2916     ALCboolean bResult = ALC_FALSE;
2917
2918     device = VerifyDevice(device);
2919
2920     if(!extName)
2921         alcSetError(device, ALC_INVALID_VALUE);
2922     else
2923     {
2924         size_t len = strlen(extName);
2925         const char *ptr = (device ? alcExtensionList : alcNoDeviceExtList);
2926         while(ptr && *ptr)
2927         {
2928             if(strncasecmp(ptr, extName, len) == 0 &&
2929                (ptr[len] == '\0' || isspace(ptr[len])))
2930             {
2931                 bResult = ALC_TRUE;
2932                 break;
2933             }
2934             if((ptr=strchr(ptr, ' ')) != NULL)
2935             {
2936                 do {
2937                     ++ptr;
2938                 } while(isspace(*ptr));
2939             }
2940         }
2941     }
2942     if(device)
2943         ALCdevice_DecRef(device);
2944     return bResult;
2945 }
2946
2947
2948 /* alcGetProcAddress
2949  *
2950  * Retrieves the function address for a particular extension function
2951  */
2952 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
2953 {
2954     ALCvoid *ptr = NULL;
2955
2956     if(!funcName)
2957     {
2958         device = VerifyDevice(device);
2959         alcSetError(device, ALC_INVALID_VALUE);
2960         if(device) ALCdevice_DecRef(device);
2961     }
2962     else
2963     {
2964         ALsizei i = 0;
2965         while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName, funcName) != 0)
2966             i++;
2967         ptr = alcFunctions[i].address;
2968     }
2969
2970     return ptr;
2971 }
2972
2973
2974 /* alcGetEnumValue
2975  *
2976  * Get the value for a particular ALC enumeration name
2977  */
2978 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
2979 {
2980     ALCenum val = 0;
2981
2982     if(!enumName)
2983     {
2984         device = VerifyDevice(device);
2985         alcSetError(device, ALC_INVALID_VALUE);
2986         if(device) ALCdevice_DecRef(device);
2987     }
2988     else
2989     {
2990         ALsizei i = 0;
2991         while(enumeration[i].enumName && strcmp(enumeration[i].enumName, enumName) != 0)
2992             i++;
2993         val = enumeration[i].value;
2994     }
2995
2996     return val;
2997 }
2998
2999
3000 /* alcCreateContext
3001  *
3002  * Create and attach a context to the given device.
3003  */
3004 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
3005 {
3006     ALCcontext *ALContext;
3007     ALCenum err;
3008
3009     LockLists();
3010     if(!(device=VerifyDevice(device)) || device->Type == Capture || !device->Connected)
3011     {
3012         UnlockLists();
3013         alcSetError(device, ALC_INVALID_DEVICE);
3014         if(device) ALCdevice_DecRef(device);
3015         return NULL;
3016     }
3017
3018     ATOMIC_STORE(&device->LastError, ALC_NO_ERROR);
3019
3020     if((err=UpdateDeviceParams(device, attrList)) != ALC_NO_ERROR)
3021     {
3022         UnlockLists();
3023         alcSetError(device, err);
3024         if(err == ALC_INVALID_DEVICE)
3025         {
3026             ALCdevice_Lock(device);
3027             aluHandleDisconnect(device);
3028             ALCdevice_Unlock(device);
3029         }
3030         ALCdevice_DecRef(device);
3031         return NULL;
3032     }
3033
3034     ALContext = al_calloc(16, sizeof(ALCcontext)+sizeof(ALlistener));
3035     if(ALContext)
3036     {
3037         InitRef(&ALContext->ref, 1);
3038         ALContext->Listener = (ALlistener*)ALContext->_listener_mem;
3039
3040         VECTOR_INIT(ALContext->ActiveAuxSlots);
3041
3042         ALContext->VoiceCount = 0;
3043         ALContext->MaxVoices = 256;
3044         ALContext->Voices = al_calloc(16, ALContext->MaxVoices * sizeof(ALContext->Voices[0]));
3045     }
3046     if(!ALContext || !ALContext->Voices)
3047     {
3048         if(!ATOMIC_LOAD(&device->ContextList))
3049         {
3050             V0(device->Backend,stop)();
3051             device->Flags &= ~DEVICE_RUNNING;
3052         }
3053         UnlockLists();
3054
3055         if(ALContext)
3056         {
3057             al_free(ALContext->Voices);
3058             ALContext->Voices = NULL;
3059
3060             VECTOR_DEINIT(ALContext->ActiveAuxSlots);
3061
3062             al_free(ALContext);
3063             ALContext = NULL;
3064         }
3065
3066         alcSetError(device, ALC_OUT_OF_MEMORY);
3067         ALCdevice_DecRef(device);
3068         return NULL;
3069     }
3070
3071     ALContext->Device = device;
3072     ALCdevice_IncRef(device);
3073     InitContext(ALContext);
3074
3075     {
3076         ALCcontext *head = ATOMIC_LOAD(&device->ContextList);
3077         do {
3078             ALContext->next = head;
3079         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCcontext*, &device->ContextList, &head, ALContext));
3080     }
3081     UnlockLists();
3082
3083     ALCdevice_DecRef(device);
3084
3085     TRACE("Created context %p\n", ALContext);
3086     return ALContext;
3087 }
3088
3089 /* alcDestroyContext
3090  *
3091  * Remove a context from its device
3092  */
3093 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
3094 {
3095     ALCdevice *Device;
3096
3097     LockLists();
3098     /* alcGetContextsDevice sets an error for invalid contexts */
3099     Device = alcGetContextsDevice(context);
3100     if(Device)
3101     {
3102         ReleaseContext(context, Device);
3103         if(!ATOMIC_LOAD(&Device->ContextList))
3104         {
3105             V0(Device->Backend,stop)();
3106             Device->Flags &= ~DEVICE_RUNNING;
3107         }
3108     }
3109     UnlockLists();
3110 }
3111
3112
3113 /* alcGetCurrentContext
3114  *
3115  * Returns the currently active context on the calling thread
3116  */
3117 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
3118 {
3119     ALCcontext *Context = altss_get(LocalContext);
3120     if(!Context) Context = ATOMIC_LOAD(&GlobalContext);
3121     return Context;
3122 }
3123
3124 /* alcGetThreadContext
3125  *
3126  * Returns the currently active thread-local context
3127  */
3128 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
3129 {
3130     return altss_get(LocalContext);
3131 }
3132
3133
3134 /* alcMakeContextCurrent
3135  *
3136  * Makes the given context the active process-wide context, and removes the
3137  * thread-local context for the calling thread.
3138  */
3139 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
3140 {
3141     /* context must be valid or NULL */
3142     if(context && !(context=VerifyContext(context)))
3143     {
3144         alcSetError(NULL, ALC_INVALID_CONTEXT);
3145         return ALC_FALSE;
3146     }
3147     /* context's reference count is already incremented */
3148     context = ATOMIC_EXCHANGE(ALCcontext*, &GlobalContext, context);
3149     if(context) ALCcontext_DecRef(context);
3150
3151     if((context=altss_get(LocalContext)) != NULL)
3152     {
3153         altss_set(LocalContext, NULL);
3154         ALCcontext_DecRef(context);
3155     }
3156
3157     return ALC_TRUE;
3158 }
3159
3160 /* alcSetThreadContext
3161  *
3162  * Makes the given context the active context for the current thread
3163  */
3164 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
3165 {
3166     ALCcontext *old;
3167
3168     /* context must be valid or NULL */
3169     if(context && !(context=VerifyContext(context)))
3170     {
3171         alcSetError(NULL, ALC_INVALID_CONTEXT);
3172         return ALC_FALSE;
3173     }
3174     /* context's reference count is already incremented */
3175     old = altss_get(LocalContext);
3176     altss_set(LocalContext, context);
3177     if(old) ALCcontext_DecRef(old);
3178
3179     return ALC_TRUE;
3180 }
3181
3182
3183 /* alcGetContextsDevice
3184  *
3185  * Returns the device that a particular context is attached to
3186  */
3187 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
3188 {
3189     ALCdevice *Device;
3190
3191     if(!(Context=VerifyContext(Context)))
3192     {
3193         alcSetError(NULL, ALC_INVALID_CONTEXT);
3194         return NULL;
3195     }
3196     Device = Context->Device;
3197     ALCcontext_DecRef(Context);
3198
3199     return Device;
3200 }
3201
3202
3203 /* alcOpenDevice
3204  *
3205  * Opens the named device.
3206  */
3207 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
3208 {
3209     const ALCchar *fmt;
3210     ALCdevice *device;
3211     ALCenum err;
3212
3213     DO_INITCONFIG();
3214
3215     if(!PlaybackBackend.name)
3216     {
3217         alcSetError(NULL, ALC_INVALID_VALUE);
3218         return NULL;
3219     }
3220
3221     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
3222         deviceName = NULL;
3223
3224     device = al_calloc(16, sizeof(ALCdevice)+sizeof(ALeffectslot));
3225     if(!device)
3226     {
3227         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3228         return NULL;
3229     }
3230
3231     //Validate device
3232     InitRef(&device->ref, 1);
3233     device->Connected = ALC_TRUE;
3234     device->Type = Playback;
3235     ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
3236
3237     device->Flags = 0;
3238     device->Bs2b = NULL;
3239     device->Bs2bLevel = 0;
3240     AL_STRING_INIT(device->DeviceName);
3241     device->DryBuffer = NULL;
3242
3243     ATOMIC_INIT(&device->ContextList, NULL);
3244
3245     device->ClockBase = 0;
3246     device->SamplesDone = 0;
3247
3248     device->MaxNoOfSources = 256;
3249     device->AuxiliaryEffectSlotMax = 4;
3250     device->NumAuxSends = MAX_SENDS;
3251
3252     InitUIntMap(&device->BufferMap, ~0);
3253     InitUIntMap(&device->EffectMap, ~0);
3254     InitUIntMap(&device->FilterMap, ~0);
3255     InitUIntMap(&device->SfontMap, ~0);
3256     InitUIntMap(&device->PresetMap, ~0);
3257     InitUIntMap(&device->FontsoundMap, ~0);
3258
3259     //Set output format
3260     device->FmtChans = DevFmtChannelsDefault;
3261     device->FmtType = DevFmtTypeDefault;
3262     device->Frequency = DEFAULT_OUTPUT_RATE;
3263     device->NumUpdates = 4;
3264     device->UpdateSize = 1024;
3265
3266     if(!PlaybackBackend.getFactory)
3267         device->Backend = create_backend_wrapper(device, &PlaybackBackend.Funcs,
3268                                                  ALCbackend_Playback);
3269     else
3270     {
3271         ALCbackendFactory *factory = PlaybackBackend.getFactory();
3272         device->Backend = V(factory,createBackend)(device, ALCbackend_Playback);
3273     }
3274     if(!device->Backend)
3275     {
3276         al_free(device);
3277         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3278         return NULL;
3279     }
3280
3281
3282     if(ConfigValueStr(NULL, "channels", &fmt))
3283     {
3284         static const struct {
3285             const char name[16];
3286             enum DevFmtChannels chans;
3287         } chanlist[] = {
3288             { "mono",       DevFmtMono   },
3289             { "stereo",     DevFmtStereo },
3290             { "quad",       DevFmtQuad   },
3291             { "surround51", DevFmtX51    },
3292             { "surround61", DevFmtX61    },
3293             { "surround71", DevFmtX71    },
3294             { "surround51rear", DevFmtX51Rear },
3295         };
3296         size_t i;
3297
3298         for(i = 0;i < COUNTOF(chanlist);i++)
3299         {
3300             if(strcasecmp(chanlist[i].name, fmt) == 0)
3301             {
3302                 device->FmtChans = chanlist[i].chans;
3303                 device->Flags |= DEVICE_CHANNELS_REQUEST;
3304                 break;
3305             }
3306         }
3307         if(i == COUNTOF(chanlist))
3308             ERR("Unsupported channels: %s\n", fmt);
3309     }
3310     if(ConfigValueStr(NULL, "sample-type", &fmt))
3311     {
3312         static const struct {
3313             const char name[16];
3314             enum DevFmtType type;
3315         } typelist[] = {
3316             { "int8",    DevFmtByte   },
3317             { "uint8",   DevFmtUByte  },
3318             { "int16",   DevFmtShort  },
3319             { "uint16",  DevFmtUShort },
3320             { "int32",   DevFmtInt    },
3321             { "uint32",  DevFmtUInt   },
3322             { "float32", DevFmtFloat  },
3323         };
3324         size_t i;
3325
3326         for(i = 0;i < COUNTOF(typelist);i++)
3327         {
3328             if(strcasecmp(typelist[i].name, fmt) == 0)
3329             {
3330                 device->FmtType = typelist[i].type;
3331                 device->Flags |= DEVICE_SAMPLE_TYPE_REQUEST;
3332                 break;
3333             }
3334         }
3335         if(i == COUNTOF(typelist))
3336             ERR("Unsupported sample-type: %s\n", fmt);
3337     }
3338
3339     if(ConfigValueUInt(NULL, "frequency", &device->Frequency))
3340     {
3341         device->Flags |= DEVICE_FREQUENCY_REQUEST;
3342         if(device->Frequency < MIN_OUTPUT_RATE)
3343             ERR("%uhz request clamped to %uhz minimum\n", device->Frequency, MIN_OUTPUT_RATE);
3344         device->Frequency = maxu(device->Frequency, MIN_OUTPUT_RATE);
3345     }
3346
3347     ConfigValueUInt(NULL, "periods", &device->NumUpdates);
3348     device->NumUpdates = clampu(device->NumUpdates, 2, 16);
3349
3350     ConfigValueUInt(NULL, "period_size", &device->UpdateSize);
3351     device->UpdateSize = clampu(device->UpdateSize, 64, 8192);
3352     if((CPUCapFlags&(CPU_CAP_SSE|CPU_CAP_NEON)) != 0)
3353         device->UpdateSize = (device->UpdateSize+3)&~3;
3354
3355     ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
3356     if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
3357
3358     ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
3359     if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
3360
3361     ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
3362     if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
3363
3364     ConfigValueInt(NULL, "cf_level", &device->Bs2bLevel);
3365
3366     device->NumStereoSources = 1;
3367     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
3368
3369     device->Synth = SynthCreate(device);
3370     if(!device->Synth)
3371     {
3372         DELETE_OBJ(device->Backend);
3373         al_free(device);
3374         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3375         return NULL;
3376     }
3377
3378     // Find a playback device to open
3379     if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
3380     {
3381         DELETE_OBJ(device->Synth);
3382         DELETE_OBJ(device->Backend);
3383         al_free(device);
3384         alcSetError(NULL, err);
3385         return NULL;
3386     }
3387
3388     if(DefaultEffect.type != AL_EFFECT_NULL)
3389     {
3390         device->DefaultSlot = (ALeffectslot*)device->_slot_mem;
3391         if(InitEffectSlot(device->DefaultSlot) != AL_NO_ERROR)
3392         {
3393             device->DefaultSlot = NULL;
3394             ERR("Failed to initialize the default effect slot\n");
3395         }
3396         else if(InitializeEffect(device, device->DefaultSlot, &DefaultEffect) != AL_NO_ERROR)
3397         {
3398             ALeffectState *state = device->DefaultSlot->EffectState;
3399             device->DefaultSlot = NULL;
3400             DELETE_OBJ(state);
3401             ERR("Failed to initialize the default effect\n");
3402         }
3403     }
3404
3405     {
3406         ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3407         do {
3408             device->next = head;
3409         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3410     }
3411
3412     TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
3413     return device;
3414 }
3415
3416 /* alcCloseDevice
3417  *
3418  * Closes the given device.
3419  */
3420 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
3421 {
3422     ALCdevice *list, *origdev, *nextdev;
3423     ALCcontext *ctx;
3424
3425     LockLists();
3426     list = ATOMIC_LOAD(&DeviceList);
3427     do {
3428         if(list == device)
3429             break;
3430     } while((list=list->next) != NULL);
3431     if(!list || list->Type == Capture)
3432     {
3433         alcSetError(list, ALC_INVALID_DEVICE);
3434         UnlockLists();
3435         return ALC_FALSE;
3436     }
3437
3438     origdev = device;
3439     nextdev = device->next;
3440     if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &origdev, nextdev))
3441     {
3442         do {
3443             list = origdev;
3444             origdev = device;
3445         } while(!COMPARE_EXCHANGE(&list->next, &origdev, nextdev));
3446     }
3447     UnlockLists();
3448
3449     ctx = ATOMIC_LOAD(&device->ContextList);
3450     while(ctx != NULL)
3451     {
3452         ALCcontext *next = ctx->next;
3453         WARN("Releasing context %p\n", ctx);
3454         ReleaseContext(ctx, device);
3455         ctx = next;
3456     }
3457     if((device->Flags&DEVICE_RUNNING))
3458         V0(device->Backend,stop)();
3459     device->Flags &= ~DEVICE_RUNNING;
3460
3461     ALCdevice_DecRef(device);
3462
3463     return ALC_TRUE;
3464 }
3465
3466
3467 /************************************************
3468  * ALC capture functions
3469  ************************************************/
3470 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
3471 {
3472     ALCdevice *device = NULL;
3473     ALCenum err;
3474
3475     DO_INITCONFIG();
3476
3477     if(!CaptureBackend.name)
3478     {
3479         alcSetError(NULL, ALC_INVALID_VALUE);
3480         return NULL;
3481     }
3482
3483     if(samples <= 0)
3484     {
3485         alcSetError(NULL, ALC_INVALID_VALUE);
3486         return NULL;
3487     }
3488
3489     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
3490         deviceName = NULL;
3491
3492     device = al_calloc(16, sizeof(ALCdevice));
3493     if(!device)
3494     {
3495         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3496         return NULL;
3497     }
3498
3499     //Validate device
3500     InitRef(&device->ref, 1);
3501     device->Connected = ALC_TRUE;
3502     device->Type = Capture;
3503
3504     AL_STRING_INIT(device->DeviceName);
3505     device->DryBuffer = NULL;
3506
3507     InitUIntMap(&device->BufferMap, ~0);
3508     InitUIntMap(&device->EffectMap, ~0);
3509     InitUIntMap(&device->FilterMap, ~0);
3510     InitUIntMap(&device->SfontMap, ~0);
3511     InitUIntMap(&device->PresetMap, ~0);
3512     InitUIntMap(&device->FontsoundMap, ~0);
3513
3514     if(!CaptureBackend.getFactory)
3515         device->Backend = create_backend_wrapper(device, &CaptureBackend.Funcs,
3516                                                  ALCbackend_Capture);
3517     else
3518     {
3519         ALCbackendFactory *factory = CaptureBackend.getFactory();
3520         device->Backend = V(factory,createBackend)(device, ALCbackend_Capture);
3521     }
3522     if(!device->Backend)
3523     {
3524         al_free(device);
3525         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3526         return NULL;
3527     }
3528
3529     device->Flags |= DEVICE_FREQUENCY_REQUEST;
3530     device->Frequency = frequency;
3531
3532     device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_SAMPLE_TYPE_REQUEST;
3533     if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
3534     {
3535         al_free(device);
3536         alcSetError(NULL, ALC_INVALID_ENUM);
3537         return NULL;
3538     }
3539
3540     device->UpdateSize = samples;
3541     device->NumUpdates = 1;
3542
3543     if((err=V(device->Backend,open)(deviceName)) != ALC_NO_ERROR)
3544     {
3545         al_free(device);
3546         alcSetError(NULL, err);
3547         return NULL;
3548     }
3549
3550     {
3551         ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3552         do {
3553             device->next = head;
3554         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3555     }
3556
3557     TRACE("Created device %p, \"%s\"\n", device, al_string_get_cstr(device->DeviceName));
3558     return device;
3559 }
3560
3561 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device)
3562 {
3563     ALCdevice *list, *next, *nextdev;
3564
3565     LockLists();
3566     list = ATOMIC_LOAD(&DeviceList);
3567     do {
3568         if(list == device)
3569             break;
3570     } while((list=list->next) != NULL);
3571     if(!list || list->Type != Capture)
3572     {
3573         alcSetError(list, ALC_INVALID_DEVICE);
3574         UnlockLists();
3575         return ALC_FALSE;
3576     }
3577
3578     next = device;
3579     nextdev = device->next;
3580     if(!ATOMIC_COMPARE_EXCHANGE_STRONG(ALCdevice*, &DeviceList, &next, nextdev))
3581     {
3582         do {
3583             list = next;
3584             next = device;
3585         } while(!COMPARE_EXCHANGE(&list->next, &next, nextdev));
3586     }
3587     UnlockLists();
3588
3589     ALCdevice_DecRef(device);
3590
3591     return ALC_TRUE;
3592 }
3593
3594 ALC_API void ALC_APIENTRY alcCaptureStart(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->Connected)
3602         {
3603             if(!(device->Flags&DEVICE_RUNNING))
3604                 V0(device->Backend,start)();
3605             device->Flags |= DEVICE_RUNNING;
3606         }
3607         ALCdevice_Unlock(device);
3608     }
3609
3610     if(device) ALCdevice_DecRef(device);
3611 }
3612
3613 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
3614 {
3615     if(!(device=VerifyDevice(device)) || device->Type != Capture)
3616         alcSetError(device, ALC_INVALID_DEVICE);
3617     else
3618     {
3619         ALCdevice_Lock(device);
3620         if((device->Flags&DEVICE_RUNNING))
3621             V0(device->Backend,stop)();
3622         device->Flags &= ~DEVICE_RUNNING;
3623         ALCdevice_Unlock(device);
3624     }
3625
3626     if(device) ALCdevice_DecRef(device);
3627 }
3628
3629 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
3630 {
3631     if(!(device=VerifyDevice(device)) || device->Type != Capture)
3632         alcSetError(device, ALC_INVALID_DEVICE);
3633     else
3634     {
3635         ALCenum err = ALC_INVALID_VALUE;
3636
3637         ALCdevice_Lock(device);
3638         if(samples >= 0 && V0(device->Backend,availableSamples)() >= (ALCuint)samples)
3639             err = V(device->Backend,captureSamples)(buffer, samples);
3640         ALCdevice_Unlock(device);
3641
3642         if(err != ALC_NO_ERROR)
3643             alcSetError(device, err);
3644     }
3645     if(device) ALCdevice_DecRef(device);
3646 }
3647
3648
3649 /************************************************
3650  * ALC loopback functions
3651  ************************************************/
3652
3653 /* alcLoopbackOpenDeviceSOFT
3654  *
3655  * Open a loopback device, for manual rendering.
3656  */
3657 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
3658 {
3659     ALCbackendFactory *factory;
3660     ALCdevice *device;
3661
3662     DO_INITCONFIG();
3663
3664     /* Make sure the device name, if specified, is us. */
3665     if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
3666     {
3667         alcSetError(NULL, ALC_INVALID_VALUE);
3668         return NULL;
3669     }
3670
3671     device = al_calloc(16, sizeof(ALCdevice));
3672     if(!device)
3673     {
3674         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3675         return NULL;
3676     }
3677
3678     //Validate device
3679     InitRef(&device->ref, 1);
3680     device->Connected = ALC_TRUE;
3681     device->Type = Loopback;
3682     ATOMIC_INIT(&device->LastError, ALC_NO_ERROR);
3683
3684     device->Flags = 0;
3685     device->Bs2b = NULL;
3686     device->Bs2bLevel = 0;
3687     AL_STRING_INIT(device->DeviceName);
3688     device->DryBuffer = NULL;
3689
3690     ATOMIC_INIT(&device->ContextList, NULL);
3691
3692     device->ClockBase = 0;
3693     device->SamplesDone = 0;
3694
3695     device->MaxNoOfSources = 256;
3696     device->AuxiliaryEffectSlotMax = 4;
3697     device->NumAuxSends = MAX_SENDS;
3698
3699     InitUIntMap(&device->BufferMap, ~0);
3700     InitUIntMap(&device->EffectMap, ~0);
3701     InitUIntMap(&device->FilterMap, ~0);
3702     InitUIntMap(&device->SfontMap, ~0);
3703     InitUIntMap(&device->PresetMap, ~0);
3704     InitUIntMap(&device->FontsoundMap, ~0);
3705
3706     factory = ALCloopbackFactory_getFactory();
3707     device->Backend = V(factory,createBackend)(device, ALCbackend_Loopback);
3708     if(!device->Backend)
3709     {
3710         al_free(device);
3711         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3712         return NULL;
3713     }
3714
3715     //Set output format
3716     device->NumUpdates = 0;
3717     device->UpdateSize = 0;
3718
3719     device->Frequency = DEFAULT_OUTPUT_RATE;
3720     device->FmtChans = DevFmtChannelsDefault;
3721     device->FmtType = DevFmtTypeDefault;
3722
3723     ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
3724     if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
3725
3726     ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
3727     if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
3728
3729     ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
3730     if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
3731
3732     device->NumStereoSources = 1;
3733     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
3734
3735     device->Synth = SynthCreate(device);
3736     if(!device->Synth)
3737     {
3738         DELETE_OBJ(device->Backend);
3739         al_free(device);
3740         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3741         return NULL;
3742     }
3743
3744     // Open the "backend"
3745     V(device->Backend,open)("Loopback");
3746
3747     {
3748         ALCdevice *head = ATOMIC_LOAD(&DeviceList);
3749         do {
3750             device->next = head;
3751         } while(!ATOMIC_COMPARE_EXCHANGE_WEAK(ALCdevice*, &DeviceList, &head, device));
3752     }
3753
3754     TRACE("Created device %p\n", device);
3755     return device;
3756 }
3757
3758 /* alcIsRenderFormatSupportedSOFT
3759  *
3760  * Determines if the loopback device supports the given format for rendering.
3761  */
3762 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
3763 {
3764     ALCboolean ret = ALC_FALSE;
3765
3766     if(!(device=VerifyDevice(device)) || device->Type != Loopback)
3767         alcSetError(device, ALC_INVALID_DEVICE);
3768     else if(freq <= 0)
3769         alcSetError(device, ALC_INVALID_VALUE);
3770     else
3771     {
3772         if(IsValidALCType(type) && BytesFromDevFmt(type) > 0 &&
3773            IsValidALCChannels(channels) && ChannelsFromDevFmt(channels) > 0 &&
3774            freq >= MIN_OUTPUT_RATE)
3775             ret = ALC_TRUE;
3776     }
3777     if(device) ALCdevice_DecRef(device);
3778
3779     return ret;
3780 }
3781
3782 /* alcRenderSamplesSOFT
3783  *
3784  * Renders some samples into a buffer, using the format last set by the
3785  * attributes given to alcCreateContext.
3786  */
3787 FORCE_ALIGN ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
3788 {
3789     if(!(device=VerifyDevice(device)) || device->Type != Loopback)
3790         alcSetError(device, ALC_INVALID_DEVICE);
3791     else if(samples < 0 || (samples > 0 && buffer == NULL))
3792         alcSetError(device, ALC_INVALID_VALUE);
3793     else
3794         aluMixData(device, buffer, samples);
3795     if(device) ALCdevice_DecRef(device);
3796 }
3797
3798
3799 /************************************************
3800  * ALC DSP pause/resume functions
3801  ************************************************/
3802
3803 /* alcDevicePauseSOFT
3804  *
3805  * Pause the DSP to stop audio processing.
3806  */
3807 ALC_API void ALC_APIENTRY alcDevicePauseSOFT(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_RUNNING))
3815             V0(device->Backend,stop)();
3816         device->Flags &= ~DEVICE_RUNNING;
3817         device->Flags |= DEVICE_PAUSED;
3818         UnlockLists();
3819     }
3820     if(device) ALCdevice_DecRef(device);
3821 }
3822
3823 /* alcDeviceResumeSOFT
3824  *
3825  * Resume the DSP to restart audio processing.
3826  */
3827 ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device)
3828 {
3829     if(!(device=VerifyDevice(device)) || device->Type != Playback)
3830         alcSetError(device, ALC_INVALID_DEVICE);
3831     else
3832     {
3833         LockLists();
3834         if((device->Flags&DEVICE_PAUSED))
3835         {
3836             device->Flags &= ~DEVICE_PAUSED;
3837             if(ATOMIC_LOAD(&device->ContextList) != NULL)
3838             {
3839                 if(V0(device->Backend,start)() != ALC_FALSE)
3840                     device->Flags |= DEVICE_RUNNING;
3841                 else
3842                 {
3843                     alcSetError(device, ALC_INVALID_DEVICE);
3844                     ALCdevice_Lock(device);
3845                     aluHandleDisconnect(device);
3846                     ALCdevice_Unlock(device);
3847                 }
3848             }
3849         }
3850         UnlockLists();
3851     }
3852     if(device) ALCdevice_DecRef(device);
3853 }