Alc/ALc.c

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