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