Alc/ALc.c

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