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 "AL/al.h"
  33 #include "AL/alc.h"
  34 #include "alThunk.h"
  35 #include "alSource.h"
  36 #include "alBuffer.h"
  37 #include "alAuxEffectSlot.h"
  38 #include "alError.h"
  39 #include "bs2b.h"
  40 #include "alu.h"
  41
  42
  43 /************************************************
  44  * Backends
  45  ************************************************/
  46 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
  47 static struct BackendInfo BackendList[] = {
  48 #ifdef HAVE_PULSEAUDIO
  49     { "pulse", alc_pulse_init, alc_pulse_deinit, alc_pulse_probe, EmptyFuncs },
  50 #endif
  51 #ifdef HAVE_ALSA
  52     { "alsa", alc_alsa_init, alc_alsa_deinit, alc_alsa_probe, EmptyFuncs },
  53 #endif
  54 #ifdef HAVE_COREAUDIO
  55     { "core", alc_ca_init, alc_ca_deinit, alc_ca_probe, EmptyFuncs },
  56 #endif
  57 #ifdef HAVE_OSS
  58     { "oss", alc_oss_init, alc_oss_deinit, alc_oss_probe, EmptyFuncs },
  59 #endif
  60 #ifdef HAVE_SOLARIS
  61     { "solaris", alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },
  62 #endif
  63 #ifdef HAVE_SNDIO
  64     { "sndio", alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },
  65 #endif
  66 #ifdef HAVE_MMDEVAPI
  67     { "mmdevapi", alcMMDevApiInit, alcMMDevApiDeinit, alcMMDevApiProbe, EmptyFuncs },
  68 #endif
  69 #ifdef HAVE_DSOUND
  70     { "dsound", alcDSoundInit, alcDSoundDeinit, alcDSoundProbe, EmptyFuncs },
  71 #endif
  72 #ifdef HAVE_WINMM
  73     { "winmm", alcWinMMInit, alcWinMMDeinit, alcWinMMProbe, EmptyFuncs },
  74 #endif
  75 #ifdef HAVE_PORTAUDIO
  76     { "port", alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
  77 #endif
  78 #ifdef HAVE_OPENSL
  79     { "opensl", alc_opensl_init, alc_opensl_deinit, alc_opensl_probe, EmptyFuncs },
  80 #endif
  81
  82     { "null", alc_null_init, alc_null_deinit, alc_null_probe, EmptyFuncs },
  83 #ifdef HAVE_WAVE
  84     { "wave", alc_wave_init, alc_wave_deinit, alc_wave_probe, EmptyFuncs },
  85 #endif
  86
  87     { NULL, NULL, NULL, NULL, EmptyFuncs }
  88 };
  89 static struct BackendInfo BackendLoopback = {
  90     "loopback", alc_loopback_init, alc_loopback_deinit, alc_loopback_probe, EmptyFuncs
  91 };
  92 #undef EmptyFuncs
  93
  94 static struct BackendInfo PlaybackBackend;
  95 static struct BackendInfo CaptureBackend;
  96
  97 /************************************************
  98  * Functions, enums, and errors
  99  ************************************************/
 100 typedef struct ALCfunction {
 101     const ALCchar *funcName;
 102     ALCvoid *address;
 103 } ALCfunction;
 104
 105 typedef struct ALCenums {
 106     const ALCchar *enumName;
 107     ALCenum value;
 108 } ALCenums;
 109
 110 #define DECL(x) { #x, (ALCvoid*)(x) }
 111 static const ALCfunction alcFunctions[] = {
 112     DECL(alcCreateContext),
 113     DECL(alcMakeContextCurrent),
 114     DECL(alcProcessContext),
 115     DECL(alcSuspendContext),
 116     DECL(alcDestroyContext),
 117     DECL(alcGetCurrentContext),
 118     DECL(alcGetContextsDevice),
 119     DECL(alcOpenDevice),
 120     DECL(alcCloseDevice),
 121     DECL(alcGetError),
 122     DECL(alcIsExtensionPresent),
 123     DECL(alcGetProcAddress),
 124     DECL(alcGetEnumValue),
 125     DECL(alcGetString),
 126     DECL(alcGetIntegerv),
 127     DECL(alcCaptureOpenDevice),
 128     DECL(alcCaptureCloseDevice),
 129     DECL(alcCaptureStart),
 130     DECL(alcCaptureStop),
 131     DECL(alcCaptureSamples),
 132
 133     DECL(alcSetThreadContext),
 134     DECL(alcGetThreadContext),
 135
 136     DECL(alcLoopbackOpenDeviceSOFT),
 137     DECL(alcIsRenderFormatSupportedSOFT),
 138     DECL(alcRenderSamplesSOFT),
 139
 140     DECL(alEnable),
 141     DECL(alDisable),
 142     DECL(alIsEnabled),
 143     DECL(alGetString),
 144     DECL(alGetBooleanv),
 145     DECL(alGetIntegerv),
 146     DECL(alGetFloatv),
 147     DECL(alGetDoublev),
 148     DECL(alGetBoolean),
 149     DECL(alGetInteger),
 150     DECL(alGetFloat),
 151     DECL(alGetDouble),
 152     DECL(alGetError),
 153     DECL(alIsExtensionPresent),
 154     DECL(alGetProcAddress),
 155     DECL(alGetEnumValue),
 156     DECL(alListenerf),
 157     DECL(alListener3f),
 158     DECL(alListenerfv),
 159     DECL(alListeneri),
 160     DECL(alListener3i),
 161     DECL(alListeneriv),
 162     DECL(alGetListenerf),
 163     DECL(alGetListener3f),
 164     DECL(alGetListenerfv),
 165     DECL(alGetListeneri),
 166     DECL(alGetListener3i),
 167     DECL(alGetListeneriv),
 168     DECL(alGenSources),
 169     DECL(alDeleteSources),
 170     DECL(alIsSource),
 171     DECL(alSourcef),
 172     DECL(alSource3f),
 173     DECL(alSourcefv),
 174     DECL(alSourcei),
 175     DECL(alSource3i),
 176     DECL(alSourceiv),
 177     DECL(alGetSourcef),
 178     DECL(alGetSource3f),
 179     DECL(alGetSourcefv),
 180     DECL(alGetSourcei),
 181     DECL(alGetSource3i),
 182     DECL(alGetSourceiv),
 183     DECL(alSourcePlayv),
 184     DECL(alSourceStopv),
 185     DECL(alSourceRewindv),
 186     DECL(alSourcePausev),
 187     DECL(alSourcePlay),
 188     DECL(alSourceStop),
 189     DECL(alSourceRewind),
 190     DECL(alSourcePause),
 191     DECL(alSourceQueueBuffers),
 192     DECL(alSourceUnqueueBuffers),
 193     DECL(alGenBuffers),
 194     DECL(alDeleteBuffers),
 195     DECL(alIsBuffer),
 196     DECL(alBufferData),
 197     DECL(alBufferf),
 198     DECL(alBuffer3f),
 199     DECL(alBufferfv),
 200     DECL(alBufferi),
 201     DECL(alBuffer3i),
 202     DECL(alBufferiv),
 203     DECL(alGetBufferf),
 204     DECL(alGetBuffer3f),
 205     DECL(alGetBufferfv),
 206     DECL(alGetBufferi),
 207     DECL(alGetBuffer3i),
 208     DECL(alGetBufferiv),
 209     DECL(alDopplerFactor),
 210     DECL(alDopplerVelocity),
 211     DECL(alSpeedOfSound),
 212     DECL(alDistanceModel),
 213
 214     DECL(alGenFilters),
 215     DECL(alDeleteFilters),
 216     DECL(alIsFilter),
 217     DECL(alFilteri),
 218     DECL(alFilteriv),
 219     DECL(alFilterf),
 220     DECL(alFilterfv),
 221     DECL(alGetFilteri),
 222     DECL(alGetFilteriv),
 223     DECL(alGetFilterf),
 224     DECL(alGetFilterfv),
 225     DECL(alGenEffects),
 226     DECL(alDeleteEffects),
 227     DECL(alIsEffect),
 228     DECL(alEffecti),
 229     DECL(alEffectiv),
 230     DECL(alEffectf),
 231     DECL(alEffectfv),
 232     DECL(alGetEffecti),
 233     DECL(alGetEffectiv),
 234     DECL(alGetEffectf),
 235     DECL(alGetEffectfv),
 236     DECL(alGenAuxiliaryEffectSlots),
 237     DECL(alDeleteAuxiliaryEffectSlots),
 238     DECL(alIsAuxiliaryEffectSlot),
 239     DECL(alAuxiliaryEffectSloti),
 240     DECL(alAuxiliaryEffectSlotiv),
 241     DECL(alAuxiliaryEffectSlotf),
 242     DECL(alAuxiliaryEffectSlotfv),
 243     DECL(alGetAuxiliaryEffectSloti),
 244     DECL(alGetAuxiliaryEffectSlotiv),
 245     DECL(alGetAuxiliaryEffectSlotf),
 246     DECL(alGetAuxiliaryEffectSlotfv),
 247
 248     DECL(alBufferSubDataSOFT),
 249
 250     DECL(alBufferSamplesSOFT),
 251     DECL(alBufferSubSamplesSOFT),
 252     DECL(alGetBufferSamplesSOFT),
 253     DECL(alIsBufferFormatSupportedSOFT),
 254
 255     DECL(alDeferUpdatesSOFT),
 256     DECL(alProcessUpdatesSOFT),
 257
 258     { NULL, NULL }
 259 };
 260 #undef DECL
 261
 262 #define DECL(x) { #x, (x) }
 263 static const ALCenums enumeration[] = {
 264     DECL(ALC_INVALID),
 265     DECL(ALC_FALSE),
 266     DECL(ALC_TRUE),
 267
 268     DECL(ALC_MAJOR_VERSION),
 269     DECL(ALC_MINOR_VERSION),
 270     DECL(ALC_ATTRIBUTES_SIZE),
 271     DECL(ALC_ALL_ATTRIBUTES),
 272     DECL(ALC_DEFAULT_DEVICE_SPECIFIER),
 273     DECL(ALC_DEVICE_SPECIFIER),
 274     DECL(ALC_ALL_DEVICES_SPECIFIER),
 275     DECL(ALC_DEFAULT_ALL_DEVICES_SPECIFIER),
 276     DECL(ALC_EXTENSIONS),
 277     DECL(ALC_FREQUENCY),
 278     DECL(ALC_REFRESH),
 279     DECL(ALC_SYNC),
 280     DECL(ALC_MONO_SOURCES),
 281     DECL(ALC_STEREO_SOURCES),
 282     DECL(ALC_CAPTURE_DEVICE_SPECIFIER),
 283     DECL(ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER),
 284     DECL(ALC_CAPTURE_SAMPLES),
 285     DECL(ALC_CONNECTED),
 286
 287     DECL(ALC_EFX_MAJOR_VERSION),
 288     DECL(ALC_EFX_MINOR_VERSION),
 289     DECL(ALC_MAX_AUXILIARY_SENDS),
 290
 291     DECL(ALC_FORMAT_CHANNELS_SOFT),
 292     DECL(ALC_FORMAT_TYPE_SOFT),
 293
 294     DECL(ALC_MONO_SOFT),
 295     DECL(ALC_STEREO_SOFT),
 296     DECL(ALC_QUAD_SOFT),
 297     DECL(ALC_5POINT1_SOFT),
 298     DECL(ALC_6POINT1_SOFT),
 299     DECL(ALC_7POINT1_SOFT),
 300
 301     DECL(ALC_BYTE_SOFT),
 302     DECL(ALC_UNSIGNED_BYTE_SOFT),
 303     DECL(ALC_SHORT_SOFT),
 304     DECL(ALC_UNSIGNED_SHORT_SOFT),
 305     DECL(ALC_INT_SOFT),
 306     DECL(ALC_UNSIGNED_INT_SOFT),
 307     DECL(ALC_FLOAT_SOFT),
 308
 309     DECL(ALC_NO_ERROR),
 310     DECL(ALC_INVALID_DEVICE),
 311     DECL(ALC_INVALID_CONTEXT),
 312     DECL(ALC_INVALID_ENUM),
 313     DECL(ALC_INVALID_VALUE),
 314     DECL(ALC_OUT_OF_MEMORY),
 315
 316
 317     DECL(AL_INVALID),
 318     DECL(AL_NONE),
 319     DECL(AL_FALSE),
 320     DECL(AL_TRUE),
 321
 322     DECL(AL_SOURCE_RELATIVE),
 323     DECL(AL_CONE_INNER_ANGLE),
 324     DECL(AL_CONE_OUTER_ANGLE),
 325     DECL(AL_PITCH),
 326     DECL(AL_POSITION),
 327     DECL(AL_DIRECTION),
 328     DECL(AL_VELOCITY),
 329     DECL(AL_LOOPING),
 330     DECL(AL_BUFFER),
 331     DECL(AL_GAIN),
 332     DECL(AL_MIN_GAIN),
 333     DECL(AL_MAX_GAIN),
 334     DECL(AL_ORIENTATION),
 335     DECL(AL_REFERENCE_DISTANCE),
 336     DECL(AL_ROLLOFF_FACTOR),
 337     DECL(AL_CONE_OUTER_GAIN),
 338     DECL(AL_MAX_DISTANCE),
 339     DECL(AL_SEC_OFFSET),
 340     DECL(AL_SAMPLE_OFFSET),
 341     DECL(AL_SAMPLE_RW_OFFSETS_SOFT),
 342     DECL(AL_BYTE_OFFSET),
 343     DECL(AL_BYTE_RW_OFFSETS_SOFT),
 344     DECL(AL_SOURCE_TYPE),
 345     DECL(AL_STATIC),
 346     DECL(AL_STREAMING),
 347     DECL(AL_UNDETERMINED),
 348     DECL(AL_METERS_PER_UNIT),
 349     DECL(AL_DIRECT_CHANNELS_SOFT),
 350
 351     DECL(AL_DIRECT_FILTER),
 352     DECL(AL_AUXILIARY_SEND_FILTER),
 353     DECL(AL_AIR_ABSORPTION_FACTOR),
 354     DECL(AL_ROOM_ROLLOFF_FACTOR),
 355     DECL(AL_CONE_OUTER_GAINHF),
 356     DECL(AL_DIRECT_FILTER_GAINHF_AUTO),
 357     DECL(AL_AUXILIARY_SEND_FILTER_GAIN_AUTO),
 358     DECL(AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO),
 359
 360     DECL(AL_SOURCE_STATE),
 361     DECL(AL_INITIAL),
 362     DECL(AL_PLAYING),
 363     DECL(AL_PAUSED),
 364     DECL(AL_STOPPED),
 365
 366     DECL(AL_BUFFERS_QUEUED),
 367     DECL(AL_BUFFERS_PROCESSED),
 368
 369     DECL(AL_FORMAT_MONO8),
 370     DECL(AL_FORMAT_MONO16),
 371     DECL(AL_FORMAT_MONO_FLOAT32),
 372     DECL(AL_FORMAT_MONO_DOUBLE_EXT),
 373     DECL(AL_FORMAT_STEREO8),
 374     DECL(AL_FORMAT_STEREO16),
 375     DECL(AL_FORMAT_STEREO_FLOAT32),
 376     DECL(AL_FORMAT_STEREO_DOUBLE_EXT),
 377     DECL(AL_FORMAT_MONO_IMA4),
 378     DECL(AL_FORMAT_STEREO_IMA4),
 379     DECL(AL_FORMAT_QUAD8_LOKI),
 380     DECL(AL_FORMAT_QUAD16_LOKI),
 381     DECL(AL_FORMAT_QUAD8),
 382     DECL(AL_FORMAT_QUAD16),
 383     DECL(AL_FORMAT_QUAD32),
 384     DECL(AL_FORMAT_51CHN8),
 385     DECL(AL_FORMAT_51CHN16),
 386     DECL(AL_FORMAT_51CHN32),
 387     DECL(AL_FORMAT_61CHN8),
 388     DECL(AL_FORMAT_61CHN16),
 389     DECL(AL_FORMAT_61CHN32),
 390     DECL(AL_FORMAT_71CHN8),
 391     DECL(AL_FORMAT_71CHN16),
 392     DECL(AL_FORMAT_71CHN32),
 393     DECL(AL_FORMAT_REAR8),
 394     DECL(AL_FORMAT_REAR16),
 395     DECL(AL_FORMAT_REAR32),
 396     DECL(AL_FORMAT_MONO_MULAW),
 397     DECL(AL_FORMAT_MONO_MULAW_EXT),
 398     DECL(AL_FORMAT_STEREO_MULAW),
 399     DECL(AL_FORMAT_STEREO_MULAW_EXT),
 400     DECL(AL_FORMAT_QUAD_MULAW),
 401     DECL(AL_FORMAT_51CHN_MULAW),
 402     DECL(AL_FORMAT_61CHN_MULAW),
 403     DECL(AL_FORMAT_71CHN_MULAW),
 404     DECL(AL_FORMAT_REAR_MULAW),
 405     DECL(AL_FORMAT_MONO_ALAW_EXT),
 406     DECL(AL_FORMAT_STEREO_ALAW_EXT),
 407
 408     DECL(AL_MONO8_SOFT),
 409     DECL(AL_MONO16_SOFT),
 410     DECL(AL_MONO32F_SOFT),
 411     DECL(AL_STEREO8_SOFT),
 412     DECL(AL_STEREO16_SOFT),
 413     DECL(AL_STEREO32F_SOFT),
 414     DECL(AL_QUAD8_SOFT),
 415     DECL(AL_QUAD16_SOFT),
 416     DECL(AL_QUAD32F_SOFT),
 417     DECL(AL_REAR8_SOFT),
 418     DECL(AL_REAR16_SOFT),
 419     DECL(AL_REAR32F_SOFT),
 420     DECL(AL_5POINT1_8_SOFT),
 421     DECL(AL_5POINT1_16_SOFT),
 422     DECL(AL_5POINT1_32F_SOFT),
 423     DECL(AL_6POINT1_8_SOFT),
 424     DECL(AL_6POINT1_16_SOFT),
 425     DECL(AL_6POINT1_32F_SOFT),
 426     DECL(AL_7POINT1_8_SOFT),
 427     DECL(AL_7POINT1_16_SOFT),
 428     DECL(AL_7POINT1_32F_SOFT),
 429
 430     DECL(AL_MONO_SOFT),
 431     DECL(AL_STEREO_SOFT),
 432     DECL(AL_QUAD_SOFT),
 433     DECL(AL_REAR_SOFT),
 434     DECL(AL_5POINT1_SOFT),
 435     DECL(AL_6POINT1_SOFT),
 436     DECL(AL_7POINT1_SOFT),
 437
 438     DECL(AL_BYTE_SOFT),
 439     DECL(AL_UNSIGNED_BYTE_SOFT),
 440     DECL(AL_SHORT_SOFT),
 441     DECL(AL_UNSIGNED_SHORT_SOFT),
 442     DECL(AL_INT_SOFT),
 443     DECL(AL_UNSIGNED_INT_SOFT),
 444     DECL(AL_FLOAT_SOFT),
 445     DECL(AL_DOUBLE_SOFT),
 446     DECL(AL_BYTE3_SOFT),
 447     DECL(AL_UNSIGNED_BYTE3_SOFT),
 448
 449     DECL(AL_FREQUENCY),
 450     DECL(AL_BITS),
 451     DECL(AL_CHANNELS),
 452     DECL(AL_SIZE),
 453     DECL(AL_INTERNAL_FORMAT_SOFT),
 454     DECL(AL_BYTE_LENGTH_SOFT),
 455     DECL(AL_SAMPLE_LENGTH_SOFT),
 456     DECL(AL_SEC_LENGTH_SOFT),
 457
 458     DECL(AL_UNUSED),
 459     DECL(AL_PENDING),
 460     DECL(AL_PROCESSED),
 461
 462     DECL(AL_NO_ERROR),
 463     DECL(AL_INVALID_NAME),
 464     DECL(AL_INVALID_ENUM),
 465     DECL(AL_INVALID_VALUE),
 466     DECL(AL_INVALID_OPERATION),
 467     DECL(AL_OUT_OF_MEMORY),
 468
 469     DECL(AL_VENDOR),
 470     DECL(AL_VERSION),
 471     DECL(AL_RENDERER),
 472     DECL(AL_EXTENSIONS),
 473
 474     DECL(AL_DOPPLER_FACTOR),
 475     DECL(AL_DOPPLER_VELOCITY),
 476     DECL(AL_DISTANCE_MODEL),
 477     DECL(AL_SPEED_OF_SOUND),
 478     DECL(AL_SOURCE_DISTANCE_MODEL),
 479     DECL(AL_DEFERRED_UPDATES_SOFT),
 480
 481     DECL(AL_INVERSE_DISTANCE),
 482     DECL(AL_INVERSE_DISTANCE_CLAMPED),
 483     DECL(AL_LINEAR_DISTANCE),
 484     DECL(AL_LINEAR_DISTANCE_CLAMPED),
 485     DECL(AL_EXPONENT_DISTANCE),
 486     DECL(AL_EXPONENT_DISTANCE_CLAMPED),
 487
 488     DECL(AL_FILTER_TYPE),
 489     DECL(AL_FILTER_NULL),
 490     DECL(AL_FILTER_LOWPASS),
 491 #if 0
 492     DECL(AL_FILTER_HIGHPASS),
 493     DECL(AL_FILTER_BANDPASS),
 494 #endif
 495
 496     DECL(AL_LOWPASS_GAIN),
 497     DECL(AL_LOWPASS_GAINHF),
 498
 499     DECL(AL_EFFECT_TYPE),
 500     DECL(AL_EFFECT_NULL),
 501     DECL(AL_EFFECT_REVERB),
 502     DECL(AL_EFFECT_EAXREVERB),
 503 #if 0
 504     DECL(AL_EFFECT_CHORUS),
 505     DECL(AL_EFFECT_DISTORTION),
 506 #endif
 507     DECL(AL_EFFECT_ECHO),
 508 #if 0
 509     DECL(AL_EFFECT_FLANGER),
 510     DECL(AL_EFFECT_FREQUENCY_SHIFTER),
 511     DECL(AL_EFFECT_VOCAL_MORPHER),
 512     DECL(AL_EFFECT_PITCH_SHIFTER),
 513 #endif
 514     DECL(AL_EFFECT_RING_MODULATOR),
 515 #if 0
 516     DECL(AL_EFFECT_AUTOWAH),
 517     DECL(AL_EFFECT_COMPRESSOR),
 518     DECL(AL_EFFECT_EQUALIZER),
 519 #endif
 520     DECL(AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT),
 521     DECL(AL_EFFECT_DEDICATED_DIALOGUE),
 522
 523     DECL(AL_EAXREVERB_DENSITY),
 524     DECL(AL_EAXREVERB_DIFFUSION),
 525     DECL(AL_EAXREVERB_GAIN),
 526     DECL(AL_EAXREVERB_GAINHF),
 527     DECL(AL_EAXREVERB_GAINLF),
 528     DECL(AL_EAXREVERB_DECAY_TIME),
 529     DECL(AL_EAXREVERB_DECAY_HFRATIO),
 530     DECL(AL_EAXREVERB_DECAY_LFRATIO),
 531     DECL(AL_EAXREVERB_REFLECTIONS_GAIN),
 532     DECL(AL_EAXREVERB_REFLECTIONS_DELAY),
 533     DECL(AL_EAXREVERB_REFLECTIONS_PAN),
 534     DECL(AL_EAXREVERB_LATE_REVERB_GAIN),
 535     DECL(AL_EAXREVERB_LATE_REVERB_DELAY),
 536     DECL(AL_EAXREVERB_LATE_REVERB_PAN),
 537     DECL(AL_EAXREVERB_ECHO_TIME),
 538     DECL(AL_EAXREVERB_ECHO_DEPTH),
 539     DECL(AL_EAXREVERB_MODULATION_TIME),
 540     DECL(AL_EAXREVERB_MODULATION_DEPTH),
 541     DECL(AL_EAXREVERB_AIR_ABSORPTION_GAINHF),
 542     DECL(AL_EAXREVERB_HFREFERENCE),
 543     DECL(AL_EAXREVERB_LFREFERENCE),
 544     DECL(AL_EAXREVERB_ROOM_ROLLOFF_FACTOR),
 545     DECL(AL_EAXREVERB_DECAY_HFLIMIT),
 546
 547     DECL(AL_REVERB_DENSITY),
 548     DECL(AL_REVERB_DIFFUSION),
 549     DECL(AL_REVERB_GAIN),
 550     DECL(AL_REVERB_GAINHF),
 551     DECL(AL_REVERB_DECAY_TIME),
 552     DECL(AL_REVERB_DECAY_HFRATIO),
 553     DECL(AL_REVERB_REFLECTIONS_GAIN),
 554     DECL(AL_REVERB_REFLECTIONS_DELAY),
 555     DECL(AL_REVERB_LATE_REVERB_GAIN),
 556     DECL(AL_REVERB_LATE_REVERB_DELAY),
 557     DECL(AL_REVERB_AIR_ABSORPTION_GAINHF),
 558     DECL(AL_REVERB_ROOM_ROLLOFF_FACTOR),
 559     DECL(AL_REVERB_DECAY_HFLIMIT),
 560
 561     DECL(AL_ECHO_DELAY),
 562     DECL(AL_ECHO_LRDELAY),
 563     DECL(AL_ECHO_DAMPING),
 564     DECL(AL_ECHO_FEEDBACK),
 565     DECL(AL_ECHO_SPREAD),
 566
 567     DECL(AL_RING_MODULATOR_FREQUENCY),
 568     DECL(AL_RING_MODULATOR_HIGHPASS_CUTOFF),
 569     DECL(AL_RING_MODULATOR_WAVEFORM),
 570
 571     DECL(AL_DEDICATED_GAIN),
 572
 573     { NULL, (ALCenum)0 }
 574 };
 575 #undef DECL
 576
 577 static const ALCchar alcNoError[] = "No Error";
 578 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
 579 static const ALCchar alcErrInvalidContext[] = "Invalid Context";
 580 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
 581 static const ALCchar alcErrInvalidValue[] = "Invalid Value";
 582 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
 583
 584
 585 /************************************************
 586  * Global variables
 587  ************************************************/
 588
 589 /* Enumerated device names */
 590 static const ALCchar alcDefaultName[] = "OpenAL Soft\0";
 591 static ALCchar *alcAllDevicesList;
 592 static ALCchar *alcCaptureDeviceList;
 593 /* Sizes only include the first ending null character, not the second */
 594 static size_t alcAllDevicesListSize;
 595 static size_t alcCaptureDeviceListSize;
 596
 597 /* Default is always the first in the list */
 598 static ALCchar *alcDefaultAllDevicesSpecifier;
 599 static ALCchar *alcCaptureDefaultDeviceSpecifier;
 600
 601 /* Default context extensions */
 602 static const ALchar alExtList[] =
 603     "AL_EXT_ALAW AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 "
 604     "AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_MULAW "
 605     "AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET AL_EXT_source_distance_model "
 606     "AL_LOKI_quadriphonic AL_SOFT_buffer_samples AL_SOFT_buffer_sub_data "
 607     "AL_SOFTX_deferred_updates AL_SOFT_direct_channels AL_SOFT_loop_points";
 608
 609 static volatile ALCenum LastNullDeviceError = ALC_NO_ERROR;
 610
 611 /* Thread-local current context */
 612 static pthread_key_t LocalContext;
 613 /* Process-wide current context */
 614 static ALCcontext *volatile GlobalContext = NULL;
 615
 616 /* Mixing thread piority level */
 617 ALint RTPrioLevel;
 618
 619 FILE *LogFile;
 620 #ifdef _DEBUG
 621 enum LogLevel LogLevel = LogWarning;
 622 #else
 623 enum LogLevel LogLevel = LogError;
 624 #endif
 625
 626 /* Flag to trap ALC device errors */
 627 static ALCboolean TrapALCError = ALC_FALSE;
 628
 629 /* One-time configuration init control */
 630 static pthread_once_t alc_config_once = PTHREAD_ONCE_INIT;
 631
 632 /* Default effect that applies to sources that don't have an effect on send 0 */
 633 static ALeffect DefaultEffect;
 634
 635
 636 /************************************************
 637  * ALC information
 638  ************************************************/
 639 static const ALCchar alcNoDeviceExtList[] =
 640     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
 641     "ALC_EXT_thread_local_context ALC_SOFT_loopback";
 642 static const ALCchar alcExtensionList[] =
 643     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
 644     "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "
 645     "ALC_EXT_thread_local_context ALC_SOFT_loopback";
 646 static const ALCint alcMajorVersion = 1;
 647 static const ALCint alcMinorVersion = 1;
 648
 649 static const ALCint alcEFXMajorVersion = 1;
 650 static const ALCint alcEFXMinorVersion = 0;
 651
 652
 653 /************************************************
 654  * Device lists
 655  ************************************************/
 656 static ALCdevice *volatile DeviceList = NULL;
 657
 658 static CRITICAL_SECTION ListLock;
 659
 660 static void LockLists(void)
 661 {
 662     EnterCriticalSection(&ListLock);
 663 }
 664 static void UnlockLists(void)
 665 {
 666     LeaveCriticalSection(&ListLock);
 667 }
 668
 669 /************************************************
 670  * Library initialization
 671  ************************************************/
 672 #if defined(_WIN32)
 673 static void alc_init(void);
 674 static void alc_deinit(void);
 675 static void alc_deinit_safe(void);
 676
 677 UIntMap TlsDestructor;
 678
 679 #ifndef AL_LIBTYPE_STATIC
 680 BOOL APIENTRY DllMain(HINSTANCE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
 681 {
 682     ALsizei i;
 683
 684     // Perform actions based on the reason for calling.
 685     switch(ul_reason_for_call)
 686     {
 687         case DLL_PROCESS_ATTACH:
 688             /* Pin the DLL so we won't get unloaded until the process terminates */
 689             GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_PIN | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
 690                                (WCHAR*)hModule, &hModule);
 691             InitUIntMap(&TlsDestructor, ~0);
 692             alc_init();
 693             break;
 694
 695         case DLL_THREAD_DETACH:
 696             LockUIntMapRead(&TlsDestructor);
 697             for(i = 0;i < TlsDestructor.size;i++)
 698             {
 699                 void *ptr = pthread_getspecific(TlsDestructor.array[i].key);
 700                 void (*callback)(void*) = (void(*)(void*))TlsDestructor.array[i].value;
 701                 if(ptr && callback)
 702                     callback(ptr);
 703             }
 704             UnlockUIntMapRead(&TlsDestructor);
 705             break;
 706
 707         case DLL_PROCESS_DETACH:
 708             if(!lpReserved)
 709                 alc_deinit();
 710             else
 711                 alc_deinit_safe();
 712             ResetUIntMap(&TlsDestructor);
 713             break;
 714     }
 715     return TRUE;
 716 }
 717 #elif defined(_MSC_VER)
 718 #pragma section(".CRT$XCU",read)
 719 static void alc_constructor(void);
 720 static void alc_destructor(void);
 721 __declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;
 722
 723 static void alc_constructor(void)
 724 {
 725     atexit(alc_destructor);
 726     alc_init();
 727 }
 728
 729 static void alc_destructor(void)
 730 {
 731     alc_deinit();
 732 }
 733 #elif defined(HAVE_GCC_DESTRUCTOR)
 734 static void alc_init(void) __attribute__((constructor));
 735 static void alc_deinit(void) __attribute__((destructor));
 736 #else
 737 #error "No static initialization available on this platform!"
 738 #endif
 739
 740 #elif defined(HAVE_GCC_DESTRUCTOR)
 741
 742 static void alc_init(void) __attribute__((constructor));
 743 static void alc_deinit(void) __attribute__((destructor));
 744
 745 #else
 746 #error "No global initialization available on this platform!"
 747 #endif
 748
 749 static void ReleaseThreadCtx(void *ptr);
 750 static void alc_init(void)
 751 {
 752     const char *str;
 753
 754     LogFile = stderr;
 755
 756     str = getenv("__ALSOFT_HALF_ANGLE_CONES");
 757     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
 758         ConeScale = 1.0f;
 759
 760     str = getenv("__ALSOFT_REVERSE_Z");
 761     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
 762         ZScale = -1.0f;
 763
 764     pthread_key_create(&LocalContext, ReleaseThreadCtx);
 765     InitializeCriticalSection(&ListLock);
 766     ThunkInit();
 767 }
 768
 769 static void alc_initconfig(void)
 770 {
 771     const char *devs, *str;
 772     float valf;
 773     int i, n;
 774
 775     str = getenv("ALSOFT_LOGLEVEL");
 776     if(str)
 777     {
 778         long lvl = strtol(str, NULL, 0);
 779         if(lvl >= NoLog && lvl <= LogRef)
 780             LogLevel = lvl;
 781     }
 782
 783     str = getenv("ALSOFT_LOGFILE");
 784     if(str && str[0])
 785     {
 786         FILE *logfile = fopen(str, "wat");
 787         if(logfile) LogFile = logfile;
 788         else ERR("Failed to open log file '%s'\n", str);
 789     }
 790
 791     ReadALConfig();
 792
 793     InitHrtf();
 794
 795 #ifdef _WIN32
 796     RTPrioLevel = 1;
 797 #else
 798     RTPrioLevel = 0;
 799 #endif
 800     ConfigValueInt(NULL, "rt-prio", &RTPrioLevel);
 801
 802     if(ConfigValueStr(NULL, "resampler", &str))
 803     {
 804         if(strcasecmp(str, "point") == 0 || strcasecmp(str, "none") == 0)
 805             DefaultResampler = PointResampler;
 806         else if(strcasecmp(str, "linear") == 0)
 807             DefaultResampler = LinearResampler;
 808         else if(strcasecmp(str, "cubic") == 0)
 809             DefaultResampler = CubicResampler;
 810         else
 811         {
 812             char *end;
 813
 814             n = strtol(str, &end, 0);
 815             if(*end == '\0' && (n == PointResampler || n == LinearResampler || n == CubicResampler))
 816                 DefaultResampler = n;
 817             else
 818                 WARN("Invalid resampler: %s\n", str);
 819         }
 820     }
 821
 822     str = getenv("ALSOFT_TRAP_ERROR");
 823     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
 824     {
 825         TrapALError  = AL_TRUE;
 826         TrapALCError = AL_TRUE;
 827     }
 828     else
 829     {
 830         str = getenv("ALSOFT_TRAP_AL_ERROR");
 831         if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
 832             TrapALError = AL_TRUE;
 833         TrapALError = GetConfigValueBool(NULL, "trap-al-error", TrapALError);
 834
 835         str = getenv("ALSOFT_TRAP_ALC_ERROR");
 836         if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))
 837             TrapALCError = ALC_TRUE;
 838         TrapALCError = GetConfigValueBool(NULL, "trap-alc-error", TrapALCError);
 839     }
 840
 841     if(ConfigValueFloat("reverb", "boost", &valf))
 842         ReverbBoost *= powf(10.0f, valf / 20.0f);
 843
 844     EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);
 845
 846     if(((devs=getenv("ALSOFT_DRIVERS")) && devs[0]) ||
 847        ConfigValueStr(NULL, "drivers", &devs))
 848     {
 849         int n;
 850         size_t len;
 851         const char *next = devs;
 852         int endlist, delitem;
 853
 854         i = 0;
 855         do {
 856             devs = next;
 857             next = strchr(devs, ',');
 858
 859             delitem = (devs[0] == '-');
 860             if(devs[0] == '-') devs++;
 861
 862             if(!devs[0] || devs[0] == ',')
 863             {
 864                 endlist = 0;
 865                 continue;
 866             }
 867             endlist = 1;
 868
 869             len = (next ? ((size_t)(next-devs)) : strlen(devs));
 870             for(n = i;BackendList[n].Init;n++)
 871             {
 872                 if(len == strlen(BackendList[n].name) &&
 873                    strncmp(BackendList[n].name, devs, len) == 0)
 874                 {
 875                     if(delitem)
 876                     {
 877                         do {
 878                             BackendList[n] = BackendList[n+1];
 879                             ++n;
 880                         } while(BackendList[n].Init);
 881                     }
 882                     else
 883                     {
 884                         struct BackendInfo Bkp = BackendList[n];
 885                         while(n > i)
 886                         {
 887                             BackendList[n] = BackendList[n-1];
 888                             --n;
 889                         }
 890                         BackendList[n] = Bkp;
 891
 892                         i++;
 893                     }
 894                     break;
 895                 }
 896             }
 897         } while(next++);
 898
 899         if(endlist)
 900         {
 901             BackendList[i].name = NULL;
 902             BackendList[i].Init = NULL;
 903             BackendList[i].Deinit = NULL;
 904             BackendList[i].Probe = NULL;
 905         }
 906     }
 907
 908     for(i = 0;BackendList[i].Init && (!PlaybackBackend.name || !CaptureBackend.name);i++)
 909     {
 910         if(!BackendList[i].Init(&BackendList[i].Funcs))
 911         {
 912             WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);
 913             continue;
 914         }
 915
 916         TRACE("Initialized backend \"%s\"\n", BackendList[i].name);
 917         if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)
 918         {
 919             PlaybackBackend = BackendList[i];
 920             TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);
 921         }
 922         if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)
 923         {
 924             CaptureBackend = BackendList[i];
 925             TRACE("Added \"%s\" for capture\n", CaptureBackend.name);
 926         }
 927     }
 928     BackendLoopback.Init(&BackendLoopback.Funcs);
 929
 930     if(ConfigValueStr(NULL, "excludefx", &str))
 931     {
 932         size_t len;
 933         const char *next = str;
 934
 935         do {
 936             str = next;
 937             next = strchr(str, ',');
 938
 939             if(!str[0] || next == str)
 940                 continue;
 941
 942             len = (next ? ((size_t)(next-str)) : strlen(str));
 943             for(n = 0;EffectList[n].name;n++)
 944             {
 945                 if(len == strlen(EffectList[n].name) &&
 946                    strncmp(EffectList[n].name, str, len) == 0)
 947                     DisabledEffects[EffectList[n].type] = AL_TRUE;
 948             }
 949         } while(next++);
 950     }
 951
 952     InitEffect(&DefaultEffect);
 953     str = getenv("ALSOFT_DEFAULT_REVERB");
 954     if((str && str[0]) || ConfigValueStr(NULL, "default-reverb", &str))
 955         LoadReverbPreset(str, &DefaultEffect);
 956 }
 957 #define DO_INITCONFIG() pthread_once(&alc_config_once, alc_initconfig)
 958
 959
 960 /************************************************
 961  * Library deinitialization
 962  ************************************************/
 963 static void alc_cleanup(void)
 964 {
 965     ALCdevice *dev;
 966
 967     free(alcAllDevicesList); alcAllDevicesList = NULL;
 968     alcAllDevicesListSize = 0;
 969     free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;
 970     alcCaptureDeviceListSize = 0;
 971
 972     free(alcDefaultAllDevicesSpecifier);
 973     alcDefaultAllDevicesSpecifier = NULL;
 974     free(alcCaptureDefaultDeviceSpecifier);
 975     alcCaptureDefaultDeviceSpecifier = NULL;
 976
 977     if((dev=ExchangePtr((XchgPtr*)&DeviceList, NULL)) != NULL)
 978     {
 979         ALCuint num = 0;
 980         do {
 981             num++;
 982         } while((dev=dev->next) != NULL);
 983         ERR("%u device%s not closed\n", num, (num>1)?"s":"");
 984     }
 985 }
 986
 987 static void alc_deinit_safe(void)
 988 {
 989     alc_cleanup();
 990
 991     FreeHrtf();
 992     FreeALConfig();
 993
 994     ThunkExit();
 995     DeleteCriticalSection(&ListLock);
 996     pthread_key_delete(LocalContext);
 997
 998     if(LogFile != stderr)
 999         fclose(LogFile);
1000     LogFile = NULL;
1001 }
1002
1003 static void alc_deinit(void)
1004 {
1005     int i;
1006
1007     alc_cleanup();
1008
1009     memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));
1010     memset(&CaptureBackend, 0, sizeof(CaptureBackend));
1011
1012     for(i = 0;BackendList[i].Deinit;i++)
1013         BackendList[i].Deinit();
1014     BackendLoopback.Deinit();
1015
1016     alc_deinit_safe();
1017 }
1018
1019
1020 /************************************************
1021  * Device enumeration
1022  ************************************************/
1023 static void ProbeList(ALCchar **list, size_t *listsize, enum DevProbe type)
1024 {
1025     DO_INITCONFIG();
1026
1027     LockLists();
1028     free(*list);
1029     *list = NULL;
1030     *listsize = 0;
1031
1032     if(type == ALL_DEVICE_PROBE && PlaybackBackend.Probe)
1033         PlaybackBackend.Probe(type);
1034     else if(type == CAPTURE_DEVICE_PROBE && CaptureBackend.Probe)
1035         CaptureBackend.Probe(type);
1036     UnlockLists();
1037 }
1038
1039 static void ProbeAllDevicesList(void)
1040 { ProbeList(&alcAllDevicesList, &alcAllDevicesListSize, ALL_DEVICE_PROBE); }
1041 static void ProbeCaptureDeviceList(void)
1042 { ProbeList(&alcCaptureDeviceList, &alcCaptureDeviceListSize, CAPTURE_DEVICE_PROBE); }
1043
1044
1045 static void AppendList(const ALCchar *name, ALCchar **List, size_t *ListSize)
1046 {
1047     size_t len = strlen(name);
1048     void *temp;
1049
1050     if(len == 0)
1051         return;
1052
1053     temp = realloc(*List, (*ListSize) + len + 2);
1054     if(!temp)
1055     {
1056         ERR("Realloc failed to add %s!\n", name);
1057         return;
1058     }
1059     *List = temp;
1060
1061     memcpy((*List)+(*ListSize), name, len+1);
1062     *ListSize += len+1;
1063     (*List)[*ListSize] = 0;
1064 }
1065
1066 #define DECL_APPEND_LIST_FUNC(type)                                          \
1067 void Append##type##List(const ALCchar *name)                                 \
1068 { AppendList(name, &alc##type##List, &alc##type##ListSize); }
1069
1070 DECL_APPEND_LIST_FUNC(AllDevices)
1071 DECL_APPEND_LIST_FUNC(CaptureDevice)
1072
1073 #undef DECL_APPEND_LIST_FUNC
1074
1075
1076 /************************************************
1077  * Device format information
1078  ************************************************/
1079 const ALCchar *DevFmtTypeString(enum DevFmtType type)
1080 {
1081     switch(type)
1082     {
1083     case DevFmtByte: return "Signed Byte";
1084     case DevFmtUByte: return "Unsigned Byte";
1085     case DevFmtShort: return "Signed Short";
1086     case DevFmtUShort: return "Unsigned Short";
1087     case DevFmtInt: return "Signed Int";
1088     case DevFmtUInt: return "Unsigned Int";
1089     case DevFmtFloat: return "Float";
1090     }
1091     return "(unknown type)";
1092 }
1093 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)
1094 {
1095     switch(chans)
1096     {
1097     case DevFmtMono: return "Mono";
1098     case DevFmtStereo: return "Stereo";
1099     case DevFmtQuad: return "Quadraphonic";
1100     case DevFmtX51: return "5.1 Surround";
1101     case DevFmtX51Side: return "5.1 Side";
1102     case DevFmtX61: return "6.1 Surround";
1103     case DevFmtX71: return "7.1 Surround";
1104     }
1105     return "(unknown channels)";
1106 }
1107
1108 ALuint BytesFromDevFmt(enum DevFmtType type)
1109 {
1110     switch(type)
1111     {
1112     case DevFmtByte: return sizeof(ALbyte);
1113     case DevFmtUByte: return sizeof(ALubyte);
1114     case DevFmtShort: return sizeof(ALshort);
1115     case DevFmtUShort: return sizeof(ALushort);
1116     case DevFmtInt: return sizeof(ALint);
1117     case DevFmtUInt: return sizeof(ALuint);
1118     case DevFmtFloat: return sizeof(ALfloat);
1119     }
1120     return 0;
1121 }
1122 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)
1123 {
1124     switch(chans)
1125     {
1126     case DevFmtMono: return 1;
1127     case DevFmtStereo: return 2;
1128     case DevFmtQuad: return 4;
1129     case DevFmtX51: return 6;
1130     case DevFmtX51Side: return 6;
1131     case DevFmtX61: return 7;
1132     case DevFmtX71: return 8;
1133     }
1134     return 0;
1135 }
1136
1137 static ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,
1138                                     enum DevFmtType *type)
1139 {
1140     static const struct {
1141         ALenum format;
1142         enum DevFmtChannels channels;
1143         enum DevFmtType type;
1144     } list[] = {
1145         { AL_FORMAT_MONO8,        DevFmtMono, DevFmtUByte },
1146         { AL_FORMAT_MONO16,       DevFmtMono, DevFmtShort },
1147         { AL_FORMAT_MONO_FLOAT32, DevFmtMono, DevFmtFloat },
1148
1149         { AL_FORMAT_STEREO8,        DevFmtStereo, DevFmtUByte },
1150         { AL_FORMAT_STEREO16,       DevFmtStereo, DevFmtShort },
1151         { AL_FORMAT_STEREO_FLOAT32, DevFmtStereo, DevFmtFloat },
1152
1153         { AL_FORMAT_QUAD8,  DevFmtQuad, DevFmtUByte },
1154         { AL_FORMAT_QUAD16, DevFmtQuad, DevFmtShort },
1155         { AL_FORMAT_QUAD32, DevFmtQuad, DevFmtFloat },
1156
1157         { AL_FORMAT_51CHN8,  DevFmtX51, DevFmtUByte },
1158         { AL_FORMAT_51CHN16, DevFmtX51, DevFmtShort },
1159         { AL_FORMAT_51CHN32, DevFmtX51, DevFmtFloat },
1160
1161         { AL_FORMAT_61CHN8,  DevFmtX61, DevFmtUByte },
1162         { AL_FORMAT_61CHN16, DevFmtX61, DevFmtShort },
1163         { AL_FORMAT_61CHN32, DevFmtX61, DevFmtFloat },
1164
1165         { AL_FORMAT_71CHN8,  DevFmtX71, DevFmtUByte },
1166         { AL_FORMAT_71CHN16, DevFmtX71, DevFmtShort },
1167         { AL_FORMAT_71CHN32, DevFmtX71, DevFmtFloat },
1168     };
1169     ALuint i;
1170
1171     for(i = 0;i < COUNTOF(list);i++)
1172     {
1173         if(list[i].format == format)
1174         {
1175             *chans = list[i].channels;
1176             *type  = list[i].type;
1177             return AL_TRUE;
1178         }
1179     }
1180
1181     return AL_FALSE;
1182 }
1183
1184 static ALCboolean IsValidALCType(ALCenum type)
1185 {
1186     switch(type)
1187     {
1188         case ALC_BYTE_SOFT:
1189         case ALC_UNSIGNED_BYTE_SOFT:
1190         case ALC_SHORT_SOFT:
1191         case ALC_UNSIGNED_SHORT_SOFT:
1192         case ALC_INT_SOFT:
1193         case ALC_UNSIGNED_INT_SOFT:
1194         case ALC_FLOAT_SOFT:
1195             return ALC_TRUE;
1196     }
1197     return ALC_FALSE;
1198 }
1199
1200 static ALCboolean IsValidALCChannels(ALCenum channels)
1201 {
1202     switch(channels)
1203     {
1204         case ALC_MONO_SOFT:
1205         case ALC_STEREO_SOFT:
1206         case ALC_QUAD_SOFT:
1207         case ALC_5POINT1_SOFT:
1208         case ALC_6POINT1_SOFT:
1209         case ALC_7POINT1_SOFT:
1210             return ALC_TRUE;
1211     }
1212     return ALC_FALSE;
1213 }
1214
1215
1216 /************************************************
1217  * Miscellaneous ALC helpers
1218  ************************************************/
1219
1220 /* SetDefaultWFXChannelOrder
1221  *
1222  * Sets the default channel order used by WaveFormatEx.
1223  */
1224 void SetDefaultWFXChannelOrder(ALCdevice *device)
1225 {
1226     switch(device->FmtChans)
1227     {
1228     case DevFmtMono: device->DevChannels[0] = FrontCenter; break;
1229
1230     case DevFmtStereo: device->DevChannels[0] = FrontLeft;
1231                        device->DevChannels[1] = FrontRight; break;
1232
1233     case DevFmtQuad: device->DevChannels[0] = FrontLeft;
1234                      device->DevChannels[1] = FrontRight;
1235                      device->DevChannels[2] = BackLeft;
1236                      device->DevChannels[3] = BackRight; break;
1237
1238     case DevFmtX51: device->DevChannels[0] = FrontLeft;
1239                     device->DevChannels[1] = FrontRight;
1240                     device->DevChannels[2] = FrontCenter;
1241                     device->DevChannels[3] = LFE;
1242                     device->DevChannels[4] = BackLeft;
1243                     device->DevChannels[5] = BackRight; break;
1244
1245     case DevFmtX51Side: device->DevChannels[0] = FrontLeft;
1246                         device->DevChannels[1] = FrontRight;
1247                         device->DevChannels[2] = FrontCenter;
1248                         device->DevChannels[3] = LFE;
1249                         device->DevChannels[4] = SideLeft;
1250                         device->DevChannels[5] = SideRight; break;
1251
1252     case DevFmtX61: device->DevChannels[0] = FrontLeft;
1253                     device->DevChannels[1] = FrontRight;
1254                     device->DevChannels[2] = FrontCenter;
1255                     device->DevChannels[3] = LFE;
1256                     device->DevChannels[4] = BackCenter;
1257                     device->DevChannels[5] = SideLeft;
1258                     device->DevChannels[6] = SideRight; break;
1259
1260     case DevFmtX71: device->DevChannels[0] = FrontLeft;
1261                     device->DevChannels[1] = FrontRight;
1262                     device->DevChannels[2] = FrontCenter;
1263                     device->DevChannels[3] = LFE;
1264                     device->DevChannels[4] = BackLeft;
1265                     device->DevChannels[5] = BackRight;
1266                     device->DevChannels[6] = SideLeft;
1267                     device->DevChannels[7] = SideRight; break;
1268     }
1269 }
1270
1271 /* SetDefaultChannelOrder
1272  *
1273  * Sets the default channel order used by most non-WaveFormatEx-based APIs.
1274  */
1275 void SetDefaultChannelOrder(ALCdevice *device)
1276 {
1277     switch(device->FmtChans)
1278     {
1279     case DevFmtX51: device->DevChannels[0] = FrontLeft;
1280                     device->DevChannels[1] = FrontRight;
1281                     device->DevChannels[2] = BackLeft;
1282                     device->DevChannels[3] = BackRight;
1283                     device->DevChannels[4] = FrontCenter;
1284                     device->DevChannels[5] = LFE;
1285                     return;
1286
1287     case DevFmtX71: device->DevChannels[0] = FrontLeft;
1288                     device->DevChannels[1] = FrontRight;
1289                     device->DevChannels[2] = BackLeft;
1290                     device->DevChannels[3] = BackRight;
1291                     device->DevChannels[4] = FrontCenter;
1292                     device->DevChannels[5] = LFE;
1293                     device->DevChannels[6] = SideLeft;
1294                     device->DevChannels[7] = SideRight;
1295                     return;
1296
1297     /* Same as WFX order */
1298     case DevFmtMono:
1299     case DevFmtStereo:
1300     case DevFmtQuad:
1301     case DevFmtX51Side:
1302     case DevFmtX61:
1303         break;
1304     }
1305     SetDefaultWFXChannelOrder(device);
1306 }
1307
1308
1309 /* alcSetError
1310  *
1311  * Stores the latest ALC device error
1312  */
1313 static void alcSetError(ALCdevice *device, ALCenum errorCode)
1314 {
1315     if(TrapALCError)
1316     {
1317 #ifdef _WIN32
1318         /* DebugBreak() will cause an exception if there is no debugger */
1319         if(IsDebuggerPresent())
1320             DebugBreak();
1321 #elif defined(SIGTRAP)
1322         raise(SIGTRAP);
1323 #endif
1324     }
1325
1326     if(device)
1327         device->LastError = errorCode;
1328     else
1329         LastNullDeviceError = errorCode;
1330 }
1331
1332
1333 /* UpdateDeviceParams
1334  *
1335  * Updates device parameters according to the attribute list (caller is
1336  * responsible for holding the list lock).
1337  */
1338 static ALCenum UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)
1339 {
1340     ALCcontext *context;
1341     enum DevFmtChannels oldChans;
1342     enum DevFmtType oldType;
1343     ALCuint oldFreq;
1344     int oldMode;
1345     ALuint i;
1346
1347     // Check for attributes
1348     if(device->Type == Loopback)
1349     {
1350         enum {
1351             GotFreq  = 1<<0,
1352             GotChans = 1<<1,
1353             GotType  = 1<<2,
1354             GotAll   = GotFreq|GotChans|GotType
1355         };
1356         ALCuint freq, numMono, numStereo, numSends;
1357         enum DevFmtChannels schans;
1358         enum DevFmtType stype;
1359         ALCuint attrIdx = 0;
1360         ALCint gotFmt = 0;
1361
1362         if(!attrList)
1363         {
1364             WARN("Missing attributes for loopback device\n");
1365             return ALC_INVALID_VALUE;
1366         }
1367
1368         numMono = device->NumMonoSources;
1369         numStereo = device->NumStereoSources;
1370         numSends = device->NumAuxSends;
1371         schans = device->FmtChans;
1372         stype = device->FmtType;
1373         freq = device->Frequency;
1374
1375         while(attrList[attrIdx])
1376         {
1377             if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT)
1378             {
1379                 ALCint val = attrList[attrIdx + 1];
1380                 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))
1381                     return ALC_INVALID_VALUE;
1382                 schans = val;
1383                 gotFmt |= GotChans;
1384             }
1385
1386             if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT)
1387             {
1388                 ALCint val = attrList[attrIdx + 1];
1389                 if(!IsValidALCType(val) || !BytesFromDevFmt(val))
1390                     return ALC_INVALID_VALUE;
1391                 stype = val;
1392                 gotFmt |= GotType;
1393             }
1394
1395             if(attrList[attrIdx] == ALC_FREQUENCY)
1396             {
1397                 freq = attrList[attrIdx + 1];
1398                 if(freq < MIN_OUTPUT_RATE)
1399                     return ALC_INVALID_VALUE;
1400                 gotFmt |= GotFreq;
1401             }
1402
1403             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1404             {
1405                 numStereo = attrList[attrIdx + 1];
1406                 if(numStereo > device->MaxNoOfSources)
1407                     numStereo = device->MaxNoOfSources;
1408
1409                 numMono = device->MaxNoOfSources - numStereo;
1410             }
1411
1412             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1413                 numSends = attrList[attrIdx + 1];
1414
1415             attrIdx += 2;
1416         }
1417
1418         if(gotFmt != GotAll)
1419         {
1420             WARN("Missing format for loopback device\n");
1421             return ALC_INVALID_VALUE;
1422         }
1423
1424         ConfigValueUInt(NULL, "sends", &numSends);
1425         numSends = minu(MAX_SENDS, numSends);
1426
1427         if((device->Flags&DEVICE_RUNNING))
1428             ALCdevice_StopPlayback(device);
1429         device->Flags &= ~DEVICE_RUNNING;
1430
1431         device->Frequency = freq;
1432         device->FmtChans = schans;
1433         device->FmtType = stype;
1434         device->NumMonoSources = numMono;
1435         device->NumStereoSources = numStereo;
1436         device->NumAuxSends = numSends;
1437     }
1438     else if(attrList && attrList[0])
1439     {
1440         ALCuint freq, numMono, numStereo, numSends;
1441         ALCuint attrIdx = 0;
1442
1443         /* If a context is already running on the device, stop playback so the
1444          * device attributes can be updated. */
1445         if((device->Flags&DEVICE_RUNNING))
1446             ALCdevice_StopPlayback(device);
1447         device->Flags &= ~DEVICE_RUNNING;
1448
1449         freq = device->Frequency;
1450         numMono = device->NumMonoSources;
1451         numStereo = device->NumStereoSources;
1452         numSends = device->NumAuxSends;
1453
1454         while(attrList[attrIdx])
1455         {
1456             if(attrList[attrIdx] == ALC_FREQUENCY)
1457             {
1458                 freq = attrList[attrIdx + 1];
1459                 device->Flags |= DEVICE_FREQUENCY_REQUEST;
1460             }
1461
1462             if(attrList[attrIdx] == ALC_STEREO_SOURCES)
1463             {
1464                 numStereo = attrList[attrIdx + 1];
1465                 if(numStereo > device->MaxNoOfSources)
1466                     numStereo = device->MaxNoOfSources;
1467
1468                 numMono = device->MaxNoOfSources - numStereo;
1469             }
1470
1471             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS)
1472                 numSends = attrList[attrIdx + 1];
1473
1474             attrIdx += 2;
1475         }
1476
1477         ConfigValueUInt(NULL, "frequency", &freq);
1478         freq = maxu(freq, MIN_OUTPUT_RATE);
1479
1480         ConfigValueUInt(NULL, "sends", &numSends);
1481         numSends = minu(MAX_SENDS, numSends);
1482
1483         device->UpdateSize = (ALuint64)device->UpdateSize * freq /
1484                              device->Frequency;
1485
1486         device->Frequency = freq;
1487         device->NumMonoSources = numMono;
1488         device->NumStereoSources = numStereo;
1489         device->NumAuxSends = numSends;
1490     }
1491
1492     if((device->Flags&DEVICE_RUNNING))
1493         return ALC_NO_ERROR;
1494
1495     oldFreq  = device->Frequency;
1496     oldChans = device->FmtChans;
1497     oldType  = device->FmtType;
1498
1499     TRACE("Format pre-setup: %s%s, %s%s, %uhz%s, %u update size x%d\n",
1500           DevFmtChannelsString(device->FmtChans),
1501           (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",
1502           DevFmtTypeString(device->FmtType),
1503           (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST)?" (requested)":"",
1504           device->Frequency,
1505           (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",
1506           device->UpdateSize, device->NumUpdates);
1507
1508     if(ALCdevice_ResetPlayback(device) == ALC_FALSE)
1509         return ALC_INVALID_DEVICE;
1510
1511     if(device->FmtChans != oldChans && (device->Flags&DEVICE_CHANNELS_REQUEST))
1512     {
1513         ERR("Failed to set %s, got %s instead\n", DevFmtChannelsString(oldChans),
1514             DevFmtChannelsString(device->FmtChans));
1515         device->Flags &= ~DEVICE_CHANNELS_REQUEST;
1516     }
1517     if(device->FmtType != oldType && (device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
1518     {
1519         ERR("Failed to set %s, got %s instead\n", DevFmtTypeString(oldType),
1520             DevFmtTypeString(device->FmtType));
1521         device->Flags &= ~DEVICE_SAMPLE_TYPE_REQUEST;
1522     }
1523     if(device->Frequency != oldFreq && (device->Flags&DEVICE_FREQUENCY_REQUEST))
1524     {
1525         ERR("Failed to set %uhz, got %uhz instead\n", oldFreq, device->Frequency);
1526         device->Flags &= ~DEVICE_FREQUENCY_REQUEST;
1527     }
1528
1529     TRACE("Format post-setup: %s, %s, %uhz, %u update size x%d\n",
1530           DevFmtChannelsString(device->FmtChans),
1531           DevFmtTypeString(device->FmtType), device->Frequency,
1532           device->UpdateSize, device->NumUpdates);
1533
1534     aluInitPanning(device);
1535
1536     for(i = 0;i < MaxChannels;i++)
1537     {
1538         device->ClickRemoval[i] = 0.0f;
1539         device->PendingClicks[i] = 0.0f;
1540     }
1541
1542     device->Hrtf = NULL;
1543     if(device->Type != Loopback && GetConfigValueBool(NULL, "hrtf", AL_FALSE))
1544         device->Hrtf = GetHrtf(device);
1545     TRACE("HRTF %s\n", device->Hrtf?"enabled":"disabled");
1546
1547     if(!device->Hrtf && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)
1548     {
1549         if(!device->Bs2b)
1550         {
1551             device->Bs2b = calloc(1, sizeof(*device->Bs2b));
1552             bs2b_clear(device->Bs2b);
1553         }
1554         bs2b_set_srate(device->Bs2b, device->Frequency);
1555         bs2b_set_level(device->Bs2b, device->Bs2bLevel);
1556         TRACE("BS2B level %d\n", device->Bs2bLevel);
1557     }
1558     else
1559     {
1560         free(device->Bs2b);
1561         device->Bs2b = NULL;
1562         TRACE("BS2B disabled\n");
1563     }
1564
1565     oldMode = SetMixerFPUMode();
1566     LockDevice(device);
1567     context = device->ContextList;
1568     while(context)
1569     {
1570         ALsizei pos;
1571
1572         context->UpdateSources = AL_FALSE;
1573         LockUIntMapRead(&context->EffectSlotMap);
1574         for(pos = 0;pos < context->EffectSlotMap.size;pos++)
1575         {
1576             ALeffectslot *slot = context->EffectSlotMap.array[pos].value;
1577
1578             if(ALeffectState_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
1579             {
1580                 UnlockUIntMapRead(&context->EffectSlotMap);
1581                 UnlockDevice(device);
1582                 RestoreFPUMode(oldMode);
1583                 return ALC_INVALID_DEVICE;
1584             }
1585             slot->NeedsUpdate = AL_FALSE;
1586             ALeffectState_Update(slot->EffectState, device, slot);
1587         }
1588         UnlockUIntMapRead(&context->EffectSlotMap);
1589
1590         LockUIntMapRead(&context->SourceMap);
1591         for(pos = 0;pos < context->SourceMap.size;pos++)
1592         {
1593             ALsource *source = context->SourceMap.array[pos].value;
1594             ALuint s = device->NumAuxSends;
1595             while(s < MAX_SENDS)
1596             {
1597                 if(source->Send[s].Slot)
1598                     DecrementRef(&source->Send[s].Slot->ref);
1599                 source->Send[s].Slot = NULL;
1600                 source->Send[s].Gain = 1.0f;
1601                 source->Send[s].GainHF = 1.0f;
1602                 s++;
1603             }
1604             source->NeedsUpdate = AL_FALSE;
1605             ALsource_Update(source, context);
1606         }
1607         UnlockUIntMapRead(&context->SourceMap);
1608
1609         context = context->next;
1610     }
1611     if(device->DefaultSlot)
1612     {
1613         ALeffectslot *slot = device->DefaultSlot;
1614
1615         if(ALeffectState_DeviceUpdate(slot->EffectState, device) == AL_FALSE)
1616         {
1617             UnlockDevice(device);
1618             RestoreFPUMode(oldMode);
1619             return ALC_INVALID_DEVICE;
1620         }
1621         slot->NeedsUpdate = AL_FALSE;
1622         ALeffectState_Update(slot->EffectState, device, slot);
1623     }
1624     UnlockDevice(device);
1625     RestoreFPUMode(oldMode);
1626
1627     if(ALCdevice_StartPlayback(device) == ALC_FALSE)
1628         return ALC_INVALID_DEVICE;
1629     device->Flags |= DEVICE_RUNNING;
1630
1631     return ALC_NO_ERROR;
1632 }
1633
1634 /* FreeDevice
1635  *
1636  * Frees the device structure, and destroys any objects the app failed to
1637  * delete. Called once there's no more references on the device.
1638  */
1639 static ALCvoid FreeDevice(ALCdevice *device)
1640 {
1641     TRACE("%p\n", device);
1642
1643     if(device->DefaultSlot)
1644     {
1645         ALeffectState_Destroy(device->DefaultSlot->EffectState);
1646         device->DefaultSlot->EffectState = NULL;
1647     }
1648
1649     if(device->BufferMap.size > 0)
1650     {
1651         WARN("(%p) Deleting %d Buffer(s)\n", device, device->BufferMap.size);
1652         ReleaseALBuffers(device);
1653     }
1654     ResetUIntMap(&device->BufferMap);
1655
1656     if(device->EffectMap.size > 0)
1657     {
1658         WARN("(%p) Deleting %d Effect(s)\n", device, device->EffectMap.size);
1659         ReleaseALEffects(device);
1660     }
1661     ResetUIntMap(&device->EffectMap);
1662
1663     if(device->FilterMap.size > 0)
1664     {
1665         WARN("(%p) Deleting %d Filter(s)\n", device, device->FilterMap.size);
1666         ReleaseALFilters(device);
1667     }
1668     ResetUIntMap(&device->FilterMap);
1669
1670     free(device->Bs2b);
1671     device->Bs2b = NULL;
1672
1673     free(device->DeviceName);
1674     device->DeviceName = NULL;
1675
1676     DeleteCriticalSection(&device->Mutex);
1677
1678     free(device);
1679 }
1680
1681
1682 void ALCdevice_IncRef(ALCdevice *device)
1683 {
1684     RefCount ref;
1685     ref = IncrementRef(&device->ref);
1686     TRACEREF("%p increasing refcount to %u\n", device, ref);
1687 }
1688
1689 void ALCdevice_DecRef(ALCdevice *device)
1690 {
1691     RefCount ref;
1692     ref = DecrementRef(&device->ref);
1693     TRACEREF("%p decreasing refcount to %u\n", device, ref);
1694     if(ref == 0) FreeDevice(device);
1695 }
1696
1697 /* VerifyDevice
1698  *
1699  * Checks if the device handle is valid, and increments its ref count if so.
1700  */
1701 static ALCdevice *VerifyDevice(ALCdevice *device)
1702 {
1703     ALCdevice *tmpDevice;
1704
1705     if(!device)
1706         return NULL;
1707
1708     LockLists();
1709     tmpDevice = DeviceList;
1710     while(tmpDevice && tmpDevice != device)
1711         tmpDevice = tmpDevice->next;
1712
1713     if(tmpDevice)
1714         ALCdevice_IncRef(tmpDevice);
1715     UnlockLists();
1716     return tmpDevice;
1717 }
1718
1719
1720 /* InitContext
1721  *
1722  * Initializes context fields
1723  */
1724 static ALvoid InitContext(ALCcontext *Context)
1725 {
1726     ALint i, j;
1727
1728     //Initialise listener
1729     Context->Listener.Gain = 1.0f;
1730     Context->Listener.MetersPerUnit = 1.0f;
1731     Context->Listener.Position[0] = 0.0f;
1732     Context->Listener.Position[1] = 0.0f;
1733     Context->Listener.Position[2] = 0.0f;
1734     Context->Listener.Velocity[0] = 0.0f;
1735     Context->Listener.Velocity[1] = 0.0f;
1736     Context->Listener.Velocity[2] = 0.0f;
1737     Context->Listener.Forward[0] = 0.0f;
1738     Context->Listener.Forward[1] = 0.0f;
1739     Context->Listener.Forward[2] = -1.0f;
1740     Context->Listener.Up[0] = 0.0f;
1741     Context->Listener.Up[1] = 1.0f;
1742     Context->Listener.Up[2] = 0.0f;
1743     for(i = 0;i < 4;i++)
1744     {
1745         for(j = 0;j < 4;j++)
1746             Context->Listener.Matrix[i][j] = ((i==j) ? 1.0f : 0.0f);
1747     }
1748
1749     //Validate Context
1750     Context->LastError = AL_NO_ERROR;
1751     Context->UpdateSources = AL_FALSE;
1752     Context->ActiveSourceCount = 0;
1753     InitUIntMap(&Context->SourceMap, Context->Device->MaxNoOfSources);
1754     InitUIntMap(&Context->EffectSlotMap, Context->Device->AuxiliaryEffectSlotMax);
1755
1756     //Set globals
1757     Context->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;
1758     Context->SourceDistanceModel = AL_FALSE;
1759     Context->DopplerFactor = 1.0f;
1760     Context->DopplerVelocity = 1.0f;
1761     Context->SpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;
1762     Context->DeferUpdates = AL_FALSE;
1763
1764     Context->ExtensionList = alExtList;
1765 }
1766
1767
1768 /* FreeContext
1769  *
1770  * Cleans up the context, and destroys any remaining objects the app failed to
1771  * delete. Called once there's no more references on the context.
1772  */
1773 static ALCvoid FreeContext(ALCcontext *context)
1774 {
1775     TRACE("%p\n", context);
1776
1777     if(context->SourceMap.size > 0)
1778     {
1779         ERR("(%p) Deleting %d Source(s)\n", context, context->SourceMap.size);
1780         ReleaseALSources(context);
1781     }
1782     ResetUIntMap(&context->SourceMap);
1783
1784     if(context->EffectSlotMap.size > 0)
1785     {
1786         ERR("(%p) Deleting %d AuxiliaryEffectSlot(s)\n", context, context->EffectSlotMap.size);
1787         ReleaseALAuxiliaryEffectSlots(context);
1788     }
1789     ResetUIntMap(&context->EffectSlotMap);
1790
1791     context->ActiveSourceCount = 0;
1792     free(context->ActiveSources);
1793     context->ActiveSources = NULL;
1794     context->MaxActiveSources = 0;
1795
1796     context->ActiveEffectSlotCount = 0;
1797     free(context->ActiveEffectSlots);
1798     context->ActiveEffectSlots = NULL;
1799     context->MaxActiveEffectSlots = 0;
1800
1801     ALCdevice_DecRef(context->Device);
1802     context->Device = NULL;
1803
1804     //Invalidate context
1805     memset(context, 0, sizeof(ALCcontext));
1806     free(context);
1807 }
1808
1809 /* ReleaseContext
1810  *
1811  * Removes the context reference from the given device and removes it from
1812  * being current on the running thread or globally.
1813  */
1814 static void ReleaseContext(ALCcontext *context, ALCdevice *device)
1815 {
1816     ALCcontext *volatile*tmp_ctx;
1817
1818     if(pthread_getspecific(LocalContext) == context)
1819     {
1820         WARN("%p released while current on thread\n", context);
1821         pthread_setspecific(LocalContext, NULL);
1822         ALCcontext_DecRef(context);
1823     }
1824
1825     if(CompExchangePtr((XchgPtr*)&GlobalContext, context, NULL))
1826         ALCcontext_DecRef(context);
1827
1828     LockDevice(device);
1829     tmp_ctx = &device->ContextList;
1830     while(*tmp_ctx)
1831     {
1832         if(CompExchangePtr((XchgPtr*)tmp_ctx, context, context->next))
1833             break;
1834         tmp_ctx = &(*tmp_ctx)->next;
1835     }
1836     UnlockDevice(device);
1837
1838     ALCcontext_DecRef(context);
1839 }
1840
1841 void ALCcontext_IncRef(ALCcontext *context)
1842 {
1843     RefCount ref;
1844     ref = IncrementRef(&context->ref);
1845     TRACEREF("%p increasing refcount to %u\n", context, ref);
1846 }
1847
1848 void ALCcontext_DecRef(ALCcontext *context)
1849 {
1850     RefCount ref;
1851     ref = DecrementRef(&context->ref);
1852     TRACEREF("%p decreasing refcount to %u\n", context, ref);
1853     if(ref == 0) FreeContext(context);
1854 }
1855
1856 static void ReleaseThreadCtx(void *ptr)
1857 {
1858     WARN("%p current for thread being destroyed\n", ptr);
1859     ALCcontext_DecRef(ptr);
1860 }
1861
1862 /* VerifyContext
1863  *
1864  * Checks that the given context is valid, and increments its reference count.
1865  */
1866 static ALCcontext *VerifyContext(ALCcontext *context)
1867 {
1868     ALCdevice *dev;
1869
1870     LockLists();
1871     dev = DeviceList;
1872     while(dev)
1873     {
1874         ALCcontext *tmp_ctx = dev->ContextList;
1875         while(tmp_ctx)
1876         {
1877             if(tmp_ctx == context)
1878             {
1879                 ALCcontext_IncRef(tmp_ctx);
1880                 UnlockLists();
1881                 return tmp_ctx;
1882             }
1883             tmp_ctx = tmp_ctx->next;
1884         }
1885         dev = dev->next;
1886     }
1887     UnlockLists();
1888
1889     return NULL;
1890 }
1891
1892
1893 /* GetContextRef
1894  *
1895  * Returns the currently active context for this thread, and adds a reference
1896  * without locking it.
1897  */
1898 ALCcontext *GetContextRef(void)
1899 {
1900     ALCcontext *context;
1901
1902     context = pthread_getspecific(LocalContext);
1903     if(context)
1904         ALCcontext_IncRef(context);
1905     else
1906     {
1907         LockLists();
1908         context = GlobalContext;
1909         if(context)
1910             ALCcontext_IncRef(context);
1911         UnlockLists();
1912     }
1913
1914     return context;
1915 }
1916
1917
1918 /************************************************
1919  * Standard ALC functions
1920  ************************************************/
1921
1922 /* alcGetError
1923  *
1924  * Return last ALC generated error code for the given device
1925 */
1926 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
1927 {
1928     ALCenum errorCode;
1929
1930     if(VerifyDevice(device))
1931     {
1932         errorCode = ExchangeInt(&device->LastError, ALC_NO_ERROR);
1933         ALCdevice_DecRef(device);
1934     }
1935     else
1936         errorCode = ExchangeInt(&LastNullDeviceError, ALC_NO_ERROR);
1937
1938     return errorCode;
1939 }
1940
1941
1942 /* alcSuspendContext
1943  *
1944  * Not functional
1945  */
1946 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *Context)
1947 {
1948     (void)Context;
1949 }
1950
1951 /* alcProcessContext
1952  *
1953  * Not functional
1954  */
1955 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *Context)
1956 {
1957     (void)Context;
1958 }
1959
1960
1961 /* alcGetString
1962  *
1963  * Returns information about the device, and error strings
1964  */
1965 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *Device, ALCenum param)
1966 {
1967     const ALCchar *value = NULL;
1968
1969     switch(param)
1970     {
1971     case ALC_NO_ERROR:
1972         value = alcNoError;
1973         break;
1974
1975     case ALC_INVALID_ENUM:
1976         value = alcErrInvalidEnum;
1977         break;
1978
1979     case ALC_INVALID_VALUE:
1980         value = alcErrInvalidValue;
1981         break;
1982
1983     case ALC_INVALID_DEVICE:
1984         value = alcErrInvalidDevice;
1985         break;
1986
1987     case ALC_INVALID_CONTEXT:
1988         value = alcErrInvalidContext;
1989         break;
1990
1991     case ALC_OUT_OF_MEMORY:
1992         value = alcErrOutOfMemory;
1993         break;
1994
1995     case ALC_DEVICE_SPECIFIER:
1996         value = alcDefaultName;
1997         break;
1998
1999     case ALC_ALL_DEVICES_SPECIFIER:
2000         if(VerifyDevice(Device))
2001         {
2002             value = Device->DeviceName;
2003             ALCdevice_DecRef(Device);
2004         }
2005         else
2006         {
2007             ProbeAllDevicesList();
2008             value = alcAllDevicesList;
2009         }
2010         break;
2011
2012     case ALC_CAPTURE_DEVICE_SPECIFIER:
2013         if(VerifyDevice(Device))
2014         {
2015             value = Device->DeviceName;
2016             ALCdevice_DecRef(Device);
2017         }
2018         else
2019         {
2020             ProbeCaptureDeviceList();
2021             value = alcCaptureDeviceList;
2022         }
2023         break;
2024
2025     /* Default devices are always first in the list */
2026     case ALC_DEFAULT_DEVICE_SPECIFIER:
2027         value = alcDefaultName;
2028         break;
2029
2030     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
2031         if(!alcAllDevicesList)
2032             ProbeAllDevicesList();
2033
2034         Device = VerifyDevice(Device);
2035
2036         free(alcDefaultAllDevicesSpecifier);
2037         alcDefaultAllDevicesSpecifier = strdup(alcAllDevicesList ?
2038                                                alcAllDevicesList : "");
2039         if(!alcDefaultAllDevicesSpecifier)
2040             alcSetError(Device, ALC_OUT_OF_MEMORY);
2041
2042         value = alcDefaultAllDevicesSpecifier;
2043         if(Device) ALCdevice_DecRef(Device);
2044         break;
2045
2046     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
2047         if(!alcCaptureDeviceList)
2048             ProbeCaptureDeviceList();
2049
2050         Device = VerifyDevice(Device);
2051
2052         free(alcCaptureDefaultDeviceSpecifier);
2053         alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?
2054                                                   alcCaptureDeviceList : "");
2055         if(!alcCaptureDefaultDeviceSpecifier)
2056             alcSetError(Device, ALC_OUT_OF_MEMORY);
2057
2058         value = alcCaptureDefaultDeviceSpecifier;
2059         if(Device) ALCdevice_DecRef(Device);
2060         break;
2061
2062     case ALC_EXTENSIONS:
2063         if(!VerifyDevice(Device))
2064             value = alcNoDeviceExtList;
2065         else
2066         {
2067             value = alcExtensionList;
2068             ALCdevice_DecRef(Device);
2069         }
2070         break;
2071
2072     default:
2073         Device = VerifyDevice(Device);
2074         alcSetError(Device, ALC_INVALID_ENUM);
2075         if(Device) ALCdevice_DecRef(Device);
2076         break;
2077     }
2078
2079     return value;
2080 }
2081
2082
2083 /* alcGetIntegerv
2084  *
2085  * Returns information about the device and the version of OpenAL
2086  */
2087 ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)
2088 {
2089     device = VerifyDevice(device);
2090
2091     if(size == 0 || data == NULL)
2092     {
2093         alcSetError(device, ALC_INVALID_VALUE);
2094         if(device) ALCdevice_DecRef(device);
2095         return;
2096     }
2097
2098     if(!device)
2099     {
2100         switch(param)
2101         {
2102             case ALC_MAJOR_VERSION:
2103                 *data = alcMajorVersion;
2104                 break;
2105             case ALC_MINOR_VERSION:
2106                 *data = alcMinorVersion;
2107                 break;
2108
2109             case ALC_ATTRIBUTES_SIZE:
2110             case ALC_ALL_ATTRIBUTES:
2111             case ALC_FREQUENCY:
2112             case ALC_REFRESH:
2113             case ALC_SYNC:
2114             case ALC_MONO_SOURCES:
2115             case ALC_STEREO_SOURCES:
2116             case ALC_CAPTURE_SAMPLES:
2117             case ALC_FORMAT_CHANNELS_SOFT:
2118             case ALC_FORMAT_TYPE_SOFT:
2119                 alcSetError(NULL, ALC_INVALID_DEVICE);
2120                 break;
2121
2122             default:
2123                 alcSetError(NULL, ALC_INVALID_ENUM);
2124                 break;
2125         }
2126     }
2127     else if(device->Type == Capture)
2128     {
2129         switch(param)
2130         {
2131             case ALC_CAPTURE_SAMPLES:
2132                 LockLists();
2133                 /* Re-validate the device since it may have been closed */
2134                 ALCdevice_DecRef(device);
2135                 if((device=VerifyDevice(device)) != NULL)
2136                     *data = ALCdevice_AvailableSamples(device);
2137                 else
2138                     alcSetError(NULL, ALC_INVALID_DEVICE);
2139                 UnlockLists();
2140                 break;
2141
2142             case ALC_CONNECTED:
2143                 *data = device->Connected;
2144                 break;
2145
2146             default:
2147                 alcSetError(device, ALC_INVALID_ENUM);
2148                 break;
2149         }
2150     }
2151     else /* render device */
2152     {
2153         switch(param)
2154         {
2155             case ALC_MAJOR_VERSION:
2156                 *data = alcMajorVersion;
2157                 break;
2158
2159             case ALC_MINOR_VERSION:
2160                 *data = alcMinorVersion;
2161                 break;
2162
2163             case ALC_EFX_MAJOR_VERSION:
2164                 *data = alcEFXMajorVersion;
2165                 break;
2166
2167             case ALC_EFX_MINOR_VERSION:
2168                 *data = alcEFXMinorVersion;
2169                 break;
2170
2171             case ALC_ATTRIBUTES_SIZE:
2172                 *data = 13;
2173                 break;
2174
2175             case ALC_ALL_ATTRIBUTES:
2176                 if(size < 13)
2177                     alcSetError(device, ALC_INVALID_VALUE);
2178                 else
2179                 {
2180                     int i = 0;
2181
2182                     data[i++] = ALC_FREQUENCY;
2183                     data[i++] = device->Frequency;
2184
2185                     if(device->Type != Loopback)
2186                     {
2187                         data[i++] = ALC_REFRESH;
2188                         data[i++] = device->Frequency / device->UpdateSize;
2189
2190                         data[i++] = ALC_SYNC;
2191                         data[i++] = ALC_FALSE;
2192                     }
2193                     else
2194                     {
2195                         data[i++] = ALC_FORMAT_CHANNELS_SOFT;
2196                         data[i++] = device->FmtChans;
2197
2198                         data[i++] = ALC_FORMAT_TYPE_SOFT;
2199                         data[i++] = device->FmtType;
2200                     }
2201
2202                     data[i++] = ALC_MONO_SOURCES;
2203                     data[i++] = device->NumMonoSources;
2204
2205                     data[i++] = ALC_STEREO_SOURCES;
2206                     data[i++] = device->NumStereoSources;
2207
2208                     data[i++] = ALC_MAX_AUXILIARY_SENDS;
2209                     data[i++] = device->NumAuxSends;
2210
2211                     data[i++] = 0;
2212                 }
2213                 break;
2214
2215             case ALC_FREQUENCY:
2216                 *data = device->Frequency;
2217                 break;
2218
2219             case ALC_REFRESH:
2220                 if(device->Type == Loopback)
2221                     alcSetError(device, ALC_INVALID_DEVICE);
2222                 else
2223                     *data = device->Frequency / device->UpdateSize;
2224                 break;
2225
2226             case ALC_SYNC:
2227                 if(device->Type == Loopback)
2228                     alcSetError(device, ALC_INVALID_DEVICE);
2229                 else
2230                     *data = ALC_FALSE;
2231                 break;
2232
2233             case ALC_FORMAT_CHANNELS_SOFT:
2234                 if(device->Type != Loopback)
2235                     alcSetError(device, ALC_INVALID_DEVICE);
2236                 else
2237                     *data = device->FmtChans;
2238                 break;
2239
2240             case ALC_FORMAT_TYPE_SOFT:
2241                 if(device->Type != Loopback)
2242                     alcSetError(device, ALC_INVALID_DEVICE);
2243                 else
2244                     *data = device->FmtType;
2245                 break;
2246
2247             case ALC_MONO_SOURCES:
2248                 *data = device->NumMonoSources;
2249                 break;
2250
2251             case ALC_STEREO_SOURCES:
2252                 *data = device->NumStereoSources;
2253                 break;
2254
2255             case ALC_MAX_AUXILIARY_SENDS:
2256                 *data = device->NumAuxSends;
2257                 break;
2258
2259             case ALC_CONNECTED:
2260                 *data = device->Connected;
2261                 break;
2262
2263             default:
2264                 alcSetError(device, ALC_INVALID_ENUM);
2265                 break;
2266         }
2267     }
2268     if(device)
2269         ALCdevice_DecRef(device);
2270 }
2271
2272
2273 /* alcIsExtensionPresent
2274  *
2275  * Determines if there is support for a particular extension
2276  */
2277 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)
2278 {
2279     ALCboolean bResult = ALC_FALSE;
2280
2281     device = VerifyDevice(device);
2282
2283     if(!extName)
2284         alcSetError(device, ALC_INVALID_VALUE);
2285     else
2286     {
2287         size_t len = strlen(extName);
2288         const char *ptr = (device ? alcExtensionList : alcNoDeviceExtList);
2289         while(ptr && *ptr)
2290         {
2291             if(strncasecmp(ptr, extName, len) == 0 &&
2292                (ptr[len] == '\0' || isspace(ptr[len])))
2293             {
2294                 bResult = ALC_TRUE;
2295                 break;
2296             }
2297             if((ptr=strchr(ptr, ' ')) != NULL)
2298             {
2299                 do {
2300                     ++ptr;
2301                 } while(isspace(*ptr));
2302             }
2303         }
2304     }
2305     if(device)
2306         ALCdevice_DecRef(device);
2307     return bResult;
2308 }
2309
2310
2311 /* alcGetProcAddress
2312  *
2313  * Retrieves the function address for a particular extension function
2314  */
2315 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)
2316 {
2317     ALCvoid *ptr = NULL;
2318
2319     if(!funcName)
2320     {
2321         device = VerifyDevice(device);
2322         alcSetError(device, ALC_INVALID_VALUE);
2323         if(device) ALCdevice_DecRef(device);
2324     }
2325     else
2326     {
2327         ALsizei i = 0;
2328         while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName, funcName) != 0)
2329             i++;
2330         ptr = alcFunctions[i].address;
2331     }
2332
2333     return ptr;
2334 }
2335
2336
2337 /* alcGetEnumValue
2338  *
2339  * Get the value for a particular ALC enumeration name
2340  */
2341 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)
2342 {
2343     ALCenum val = 0;
2344
2345     if(!enumName)
2346     {
2347         device = VerifyDevice(device);
2348         alcSetError(device, ALC_INVALID_VALUE);
2349         if(device) ALCdevice_DecRef(device);
2350     }
2351     else
2352     {
2353         ALsizei i = 0;
2354         while(enumeration[i].enumName && strcmp(enumeration[i].enumName, enumName) != 0)
2355             i++;
2356         val = enumeration[i].value;
2357     }
2358
2359     return val;
2360 }
2361
2362
2363 /* alcCreateContext
2364  *
2365  * Create and attach a context to the given device.
2366  */
2367 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)
2368 {
2369     ALCcontext *ALContext;
2370     ALCenum err;
2371
2372     LockLists();
2373     if(!(device=VerifyDevice(device)) || device->Type == Capture || !device->Connected)
2374     {
2375         UnlockLists();
2376         alcSetError(device, ALC_INVALID_DEVICE);
2377         if(device) ALCdevice_DecRef(device);
2378         return NULL;
2379     }
2380
2381     device->LastError = ALC_NO_ERROR;
2382
2383     if((err=UpdateDeviceParams(device, attrList)) != ALC_NO_ERROR)
2384     {
2385         UnlockLists();
2386         alcSetError(device, err);
2387         if(err == ALC_INVALID_DEVICE)
2388             aluHandleDisconnect(device);
2389         ALCdevice_DecRef(device);
2390         return NULL;
2391     }
2392
2393     ALContext = calloc(1, sizeof(ALCcontext));
2394     if(ALContext)
2395     {
2396         ALContext->ref = 1;
2397
2398         ALContext->MaxActiveSources = 256;
2399         ALContext->ActiveSources = malloc(sizeof(ALContext->ActiveSources[0]) *
2400                                           ALContext->MaxActiveSources);
2401     }
2402     if(!ALContext || !ALContext->ActiveSources)
2403     {
2404         if(!device->ContextList)
2405         {
2406             ALCdevice_StopPlayback(device);
2407             device->Flags &= ~DEVICE_RUNNING;
2408         }
2409         UnlockLists();
2410
2411         free(ALContext);
2412         ALContext = NULL;
2413
2414         alcSetError(device, ALC_OUT_OF_MEMORY);
2415         ALCdevice_DecRef(device);
2416         return NULL;
2417     }
2418
2419     ALContext->Device = device;
2420     ALCdevice_IncRef(device);
2421     InitContext(ALContext);
2422
2423     do {
2424         ALContext->next = device->ContextList;
2425     } while(!CompExchangePtr((XchgPtr*)&device->ContextList, ALContext->next, ALContext));
2426     UnlockLists();
2427
2428     ALCdevice_DecRef(device);
2429
2430     TRACE("Created context %p\n", ALContext);
2431     return ALContext;
2432 }
2433
2434 /* alcDestroyContext
2435  *
2436  * Remove a context from its device
2437  */
2438 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)
2439 {
2440     ALCdevice *Device;
2441
2442     LockLists();
2443     /* alcGetContextsDevice sets an error for invalid contexts */
2444     Device = alcGetContextsDevice(context);
2445     if(Device)
2446     {
2447         ReleaseContext(context, Device);
2448         if(!Device->ContextList)
2449         {
2450             ALCdevice_StopPlayback(Device);
2451             Device->Flags &= ~DEVICE_RUNNING;
2452         }
2453     }
2454     UnlockLists();
2455 }
2456
2457
2458 /* alcGetCurrentContext
2459  *
2460  * Returns the currently active context on the calling thread
2461  */
2462 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
2463 {
2464     ALCcontext *Context;
2465
2466     Context = pthread_getspecific(LocalContext);
2467     if(!Context) Context = GlobalContext;
2468
2469     return Context;
2470 }
2471
2472 /* alcGetThreadContext
2473  *
2474  * Returns the currently active thread-local context
2475  */
2476 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
2477 {
2478     ALCcontext *Context;
2479     Context = pthread_getspecific(LocalContext);
2480     return Context;
2481 }
2482
2483
2484 /* alcMakeContextCurrent
2485  *
2486  * Makes the given context the active process-wide context, and removes the
2487  * thread-local context for the calling thread.
2488  */
2489 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
2490 {
2491     /* context must be valid or NULL */
2492     if(context && !(context=VerifyContext(context)))
2493     {
2494         alcSetError(NULL, ALC_INVALID_CONTEXT);
2495         return ALC_FALSE;
2496     }
2497     /* context's reference count is already incremented */
2498     context = ExchangePtr((XchgPtr*)&GlobalContext, context);
2499     if(context) ALCcontext_DecRef(context);
2500
2501     if((context=pthread_getspecific(LocalContext)) != NULL)
2502     {
2503         pthread_setspecific(LocalContext, NULL);
2504         ALCcontext_DecRef(context);
2505     }
2506
2507     return ALC_TRUE;
2508 }
2509
2510 /* alcSetThreadContext
2511  *
2512  * Makes the given context the active context for the current thread
2513  */
2514 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
2515 {
2516     ALCcontext *old;
2517
2518     /* context must be valid or NULL */
2519     if(context && !(context=VerifyContext(context)))
2520     {
2521         alcSetError(NULL, ALC_INVALID_CONTEXT);
2522         return ALC_FALSE;
2523     }
2524     /* context's reference count is already incremented */
2525     old = pthread_getspecific(LocalContext);
2526     pthread_setspecific(LocalContext, context);
2527     if(old) ALCcontext_DecRef(old);
2528
2529     return ALC_TRUE;
2530 }
2531
2532
2533 /* alcGetContextsDevice
2534  *
2535  * Returns the device that a particular context is attached to
2536  */
2537 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *Context)
2538 {
2539     ALCdevice *Device;
2540
2541     if(!(Context=VerifyContext(Context)))
2542     {
2543         alcSetError(NULL, ALC_INVALID_CONTEXT);
2544         return NULL;
2545     }
2546     Device = Context->Device;
2547     ALCcontext_DecRef(Context);
2548
2549     return Device;
2550 }
2551
2552
2553 /* alcOpenDevice
2554  *
2555  * Opens the named device.
2556  */
2557 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)
2558 {
2559     const ALCchar *fmt;
2560     ALCdevice *device;
2561     ALCenum err;
2562
2563     DO_INITCONFIG();
2564
2565     if(!PlaybackBackend.name)
2566     {
2567         alcSetError(NULL, ALC_INVALID_VALUE);
2568         return NULL;
2569     }
2570
2571     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
2572         deviceName = NULL;
2573
2574     device = calloc(1, sizeof(ALCdevice)+sizeof(ALeffectslot));
2575     if(!device)
2576     {
2577         alcSetError(NULL, ALC_OUT_OF_MEMORY);
2578         return NULL;
2579     }
2580
2581     //Validate device
2582     device->Funcs = &PlaybackBackend.Funcs;
2583     device->ref = 1;
2584     device->Connected = ALC_TRUE;
2585     device->Type = Playback;
2586     InitializeCriticalSection(&device->Mutex);
2587     device->LastError = ALC_NO_ERROR;
2588
2589     device->Flags = 0;
2590     device->Bs2b = NULL;
2591     device->Bs2bLevel = 0;
2592     device->DeviceName = NULL;
2593
2594     device->ContextList = NULL;
2595
2596     device->MaxNoOfSources = 256;
2597     device->AuxiliaryEffectSlotMax = 4;
2598     device->NumAuxSends = MAX_SENDS;
2599
2600     InitUIntMap(&device->BufferMap, ~0);
2601     InitUIntMap(&device->EffectMap, ~0);
2602     InitUIntMap(&device->FilterMap, ~0);
2603
2604     //Set output format
2605     device->FmtChans = DevFmtChannelsDefault;
2606     device->FmtType = DevFmtTypeDefault;
2607     device->Frequency = DEFAULT_OUTPUT_RATE;
2608     device->NumUpdates = 4;
2609     device->UpdateSize = 1024;
2610
2611     if(ConfigValueStr(NULL, "channels", &fmt))
2612     {
2613         static const struct {
2614             const char name[16];
2615             enum DevFmtChannels chans;
2616         } chanlist[] = {
2617             { "mono",       DevFmtMono   },
2618             { "stereo",     DevFmtStereo },
2619             { "quad",       DevFmtQuad   },
2620             { "surround51", DevFmtX51    },
2621             { "surround61", DevFmtX61    },
2622             { "surround71", DevFmtX71    },
2623         };
2624         size_t i;
2625
2626         for(i = 0;i < COUNTOF(chanlist);i++)
2627         {
2628             if(strcasecmp(chanlist[i].name, fmt) == 0)
2629             {
2630                 device->FmtChans = chanlist[i].chans;
2631                 device->Flags |= DEVICE_CHANNELS_REQUEST;
2632                 break;
2633             }
2634         }
2635         if(i == COUNTOF(chanlist))
2636             ERR("Unsupported channels: %s\n", fmt);
2637     }
2638     if(ConfigValueStr(NULL, "sample-type", &fmt))
2639     {
2640         static const struct {
2641             const char name[16];
2642             enum DevFmtType type;
2643         } typelist[] = {
2644             { "int8",    DevFmtByte   },
2645             { "uint8",   DevFmtUByte  },
2646             { "int16",   DevFmtShort  },
2647             { "uint16",  DevFmtUShort },
2648             { "int32",   DevFmtInt    },
2649             { "uint32",  DevFmtUInt   },
2650             { "float32", DevFmtFloat  },
2651         };
2652         size_t i;
2653
2654         for(i = 0;i < COUNTOF(typelist);i++)
2655         {
2656             if(strcasecmp(typelist[i].name, fmt) == 0)
2657             {
2658                 device->FmtType = typelist[i].type;
2659                 device->Flags |= DEVICE_SAMPLE_TYPE_REQUEST;
2660                 break;
2661             }
2662         }
2663         if(i == COUNTOF(typelist))
2664             ERR("Unsupported sample-type: %s\n", fmt);
2665     }
2666 #define DEVICE_FORMAT_REQUEST (DEVICE_CHANNELS_REQUEST|DEVICE_SAMPLE_TYPE_REQUEST)
2667     if((device->Flags&DEVICE_FORMAT_REQUEST) != DEVICE_FORMAT_REQUEST &&
2668        ConfigValueStr(NULL, "format", &fmt))
2669     {
2670         static const struct {
2671             const char name[32];
2672             enum DevFmtChannels channels;
2673             enum DevFmtType type;
2674         } formats[] = {
2675             { "AL_FORMAT_MONO32",   DevFmtMono,   DevFmtFloat },
2676             { "AL_FORMAT_STEREO32", DevFmtStereo, DevFmtFloat },
2677             { "AL_FORMAT_QUAD32",   DevFmtQuad,   DevFmtFloat },
2678             { "AL_FORMAT_51CHN32",  DevFmtX51,    DevFmtFloat },
2679             { "AL_FORMAT_61CHN32",  DevFmtX61,    DevFmtFloat },
2680             { "AL_FORMAT_71CHN32",  DevFmtX71,    DevFmtFloat },
2681
2682             { "AL_FORMAT_MONO16",   DevFmtMono,   DevFmtShort },
2683             { "AL_FORMAT_STEREO16", DevFmtStereo, DevFmtShort },
2684             { "AL_FORMAT_QUAD16",   DevFmtQuad,   DevFmtShort },
2685             { "AL_FORMAT_51CHN16",  DevFmtX51,    DevFmtShort },
2686             { "AL_FORMAT_61CHN16",  DevFmtX61,    DevFmtShort },
2687             { "AL_FORMAT_71CHN16",  DevFmtX71,    DevFmtShort },
2688
2689             { "AL_FORMAT_MONO8",   DevFmtMono,   DevFmtByte },
2690             { "AL_FORMAT_STEREO8", DevFmtStereo, DevFmtByte },
2691             { "AL_FORMAT_QUAD8",   DevFmtQuad,   DevFmtByte },
2692             { "AL_FORMAT_51CHN8",  DevFmtX51,    DevFmtByte },
2693             { "AL_FORMAT_61CHN8",  DevFmtX61,    DevFmtByte },
2694             { "AL_FORMAT_71CHN8",  DevFmtX71,    DevFmtByte }
2695         };
2696         size_t i;
2697
2698         ERR("Option 'format' is deprecated, please use 'channels' and 'sample-type'\n");
2699         for(i = 0;i < COUNTOF(formats);i++)
2700         {
2701             if(strcasecmp(fmt, formats[i].name) == 0)
2702             {
2703                 if(!(device->Flags&DEVICE_CHANNELS_REQUEST))
2704                     device->FmtChans = formats[i].channels;
2705                 if(!(device->Flags&DEVICE_SAMPLE_TYPE_REQUEST))
2706                     device->FmtType = formats[i].type;
2707                 device->Flags |= DEVICE_FORMAT_REQUEST;
2708                 break;
2709             }
2710         }
2711         if(i == COUNTOF(formats))
2712             ERR("Unsupported format: %s\n", fmt);
2713     }
2714 #undef DEVICE_FORMAT_REQUEST
2715
2716     if(ConfigValueUInt(NULL, "frequency", &device->Frequency))
2717     {
2718         device->Flags |= DEVICE_FREQUENCY_REQUEST;
2719         if(device->Frequency < MIN_OUTPUT_RATE)
2720             ERR("%uhz request clamped to %uhz minimum\n", device->Frequency, MIN_OUTPUT_RATE);
2721         device->Frequency = maxu(device->Frequency, MIN_OUTPUT_RATE);
2722     }
2723
2724     ConfigValueUInt(NULL, "periods", &device->NumUpdates);
2725     device->NumUpdates = clampu(device->NumUpdates, 2, 16);
2726
2727     ConfigValueUInt(NULL, "period_size", &device->UpdateSize);
2728     device->UpdateSize = clampu(device->UpdateSize, 64, 8192);
2729
2730     ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
2731     if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
2732
2733     ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
2734     if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
2735
2736     ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
2737     if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
2738
2739     ConfigValueInt(NULL, "cf_level", &device->Bs2bLevel);
2740
2741     device->NumStereoSources = 1;
2742     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
2743
2744     // Find a playback device to open
2745     LockLists();
2746     if((err=ALCdevice_OpenPlayback(device, deviceName)) != ALC_NO_ERROR)
2747     {
2748         UnlockLists();
2749         DeleteCriticalSection(&device->Mutex);
2750         free(device);
2751         alcSetError(NULL, err);
2752         return NULL;
2753     }
2754     UnlockLists();
2755
2756     if(DefaultEffect.type != AL_EFFECT_NULL)
2757     {
2758         device->DefaultSlot = (ALeffectslot*)(device+1);
2759         if(InitEffectSlot(device->DefaultSlot) != AL_NO_ERROR)
2760         {
2761             device->DefaultSlot = NULL;
2762             ERR("Failed to initialize the default effect slot\n");
2763         }
2764         else if(InitializeEffect(device, device->DefaultSlot, &DefaultEffect) != AL_NO_ERROR)
2765         {
2766             ALeffectState_Destroy(device->DefaultSlot->EffectState);
2767             device->DefaultSlot = NULL;
2768             ERR("Failed to initialize the default effect\n");
2769         }
2770     }
2771
2772     do {
2773         device->next = DeviceList;
2774     } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
2775
2776     TRACE("Created device %p, \"%s\"\n", device, device->DeviceName);
2777     return device;
2778 }
2779
2780 /* alcCloseDevice
2781  *
2782  * Closes the given device.
2783  */
2784 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *Device)
2785 {
2786     ALCdevice *volatile*list;
2787     ALCcontext *ctx;
2788
2789     LockLists();
2790     list = &DeviceList;
2791     while(*list && *list != Device)
2792         list = &(*list)->next;
2793
2794     if(!*list || (*list)->Type == Capture)
2795     {
2796         alcSetError(*list, ALC_INVALID_DEVICE);
2797         UnlockLists();
2798         return ALC_FALSE;
2799     }
2800
2801     *list = (*list)->next;
2802     UnlockLists();
2803
2804     while((ctx=Device->ContextList) != NULL)
2805     {
2806         WARN("Releasing context %p\n", ctx);
2807         ReleaseContext(ctx, Device);
2808     }
2809     if((Device->Flags&DEVICE_RUNNING))
2810         ALCdevice_StopPlayback(Device);
2811     Device->Flags &= ~DEVICE_RUNNING;
2812
2813     ALCdevice_ClosePlayback(Device);
2814
2815     ALCdevice_DecRef(Device);
2816
2817     return ALC_TRUE;
2818 }
2819
2820
2821 /************************************************
2822  * ALC capture functions
2823  ************************************************/
2824 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei samples)
2825 {
2826     ALCdevice *device = NULL;
2827     ALCenum err;
2828
2829     DO_INITCONFIG();
2830
2831     if(!CaptureBackend.name)
2832     {
2833         alcSetError(NULL, ALC_INVALID_VALUE);
2834         return NULL;
2835     }
2836
2837     if(samples <= 0)
2838     {
2839         alcSetError(NULL, ALC_INVALID_VALUE);
2840         return NULL;
2841     }
2842
2843     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, alcDefaultName) == 0 || strcasecmp(deviceName, "openal-soft") == 0))
2844         deviceName = NULL;
2845
2846     device = calloc(1, sizeof(ALCdevice));
2847     if(!device)
2848     {
2849         alcSetError(NULL, ALC_OUT_OF_MEMORY);
2850         return NULL;
2851     }
2852
2853     //Validate device
2854     device->Funcs = &CaptureBackend.Funcs;
2855     device->ref = 1;
2856     device->Connected = ALC_TRUE;
2857     device->Type = Capture;
2858     InitializeCriticalSection(&device->Mutex);
2859
2860     InitUIntMap(&device->BufferMap, ~0);
2861     InitUIntMap(&device->EffectMap, ~0);
2862     InitUIntMap(&device->FilterMap, ~0);
2863
2864     device->DeviceName = NULL;
2865
2866     device->Flags |= DEVICE_FREQUENCY_REQUEST;
2867     device->Frequency = frequency;
2868
2869     device->Flags |= DEVICE_CHANNELS_REQUEST | DEVICE_SAMPLE_TYPE_REQUEST;
2870     if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)
2871     {
2872         DeleteCriticalSection(&device->Mutex);
2873         free(device);
2874         alcSetError(NULL, ALC_INVALID_ENUM);
2875         return NULL;
2876     }
2877
2878     device->UpdateSize = samples;
2879     device->NumUpdates = 1;
2880
2881     LockLists();
2882     if((err=ALCdevice_OpenCapture(device, deviceName)) != ALC_NO_ERROR)
2883     {
2884         UnlockLists();
2885         DeleteCriticalSection(&device->Mutex);
2886         free(device);
2887         alcSetError(NULL, err);
2888         return NULL;
2889     }
2890     UnlockLists();
2891
2892     do {
2893         device->next = DeviceList;
2894     } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
2895
2896     TRACE("Created device %p\n", device);
2897     return device;
2898 }
2899
2900 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *Device)
2901 {
2902     ALCdevice *volatile*list;
2903
2904     LockLists();
2905     list = &DeviceList;
2906     while(*list && *list != Device)
2907         list = &(*list)->next;
2908
2909     if(!*list || (*list)->Type != Capture)
2910     {
2911         alcSetError(*list, ALC_INVALID_DEVICE);
2912         UnlockLists();
2913         return ALC_FALSE;
2914     }
2915
2916     *list = (*list)->next;
2917     UnlockLists();
2918
2919     ALCdevice_CloseCapture(Device);
2920
2921     ALCdevice_DecRef(Device);
2922
2923     return ALC_TRUE;
2924 }
2925
2926 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
2927 {
2928     LockLists();
2929     if(!(device=VerifyDevice(device)) || device->Type != Capture)
2930     {
2931         UnlockLists();
2932         alcSetError(device, ALC_INVALID_DEVICE);
2933         if(device) ALCdevice_DecRef(device);
2934         return;
2935     }
2936     if(device->Connected)
2937     {
2938         if(!(device->Flags&DEVICE_RUNNING))
2939             ALCdevice_StartCapture(device);
2940         device->Flags |= DEVICE_RUNNING;
2941     }
2942     UnlockLists();
2943
2944     ALCdevice_DecRef(device);
2945 }
2946
2947 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
2948 {
2949     LockLists();
2950     if(!(device=VerifyDevice(device)) || device->Type != Capture)
2951     {
2952         UnlockLists();
2953         alcSetError(device, ALC_INVALID_DEVICE);
2954         if(device) ALCdevice_DecRef(device);
2955         return;
2956     }
2957     if((device->Flags&DEVICE_RUNNING))
2958         ALCdevice_StopCapture(device);
2959     device->Flags &= ~DEVICE_RUNNING;
2960     UnlockLists();
2961
2962     ALCdevice_DecRef(device);
2963 }
2964
2965 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
2966 {
2967     ALCenum err = ALC_INVALID_DEVICE;
2968     LockLists();
2969     if((device=VerifyDevice(device)) != NULL && device->Type == Capture)
2970     {
2971         err = ALC_INVALID_VALUE;
2972         if(samples >= 0 && ALCdevice_AvailableSamples(device) >= (ALCuint)samples)
2973             err = ALCdevice_CaptureSamples(device, buffer, samples);
2974     }
2975     UnlockLists();
2976     if(err != ALC_NO_ERROR)
2977         alcSetError(device, err);
2978     if(device) ALCdevice_DecRef(device);
2979 }
2980
2981
2982 /************************************************
2983  * ALC loopback functions
2984  ************************************************/
2985
2986 /* alcLoopbackOpenDeviceSOFT
2987  *
2988  * Open a loopback device, for manual rendering.
2989  */
2990 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName)
2991 {
2992     ALCdevice *device;
2993
2994     DO_INITCONFIG();
2995
2996     /* Make sure the device name, if specified, is us. */
2997     if(deviceName && strcmp(deviceName, alcDefaultName) != 0)
2998     {
2999         alcSetError(NULL, ALC_INVALID_VALUE);
3000         return NULL;
3001     }
3002
3003     device = calloc(1, sizeof(ALCdevice));
3004     if(!device)
3005     {
3006         alcSetError(NULL, ALC_OUT_OF_MEMORY);
3007         return NULL;
3008     }
3009
3010     //Validate device
3011     device->Funcs = &BackendLoopback.Funcs;
3012     device->ref = 1;
3013     device->Connected = ALC_TRUE;
3014     device->Type = Loopback;
3015     InitializeCriticalSection(&device->Mutex);
3016     device->LastError = ALC_NO_ERROR;
3017
3018     device->Flags = 0;
3019     device->Bs2b = NULL;
3020     device->Bs2bLevel = 0;
3021     device->DeviceName = NULL;
3022
3023     device->ContextList = NULL;
3024
3025     device->MaxNoOfSources = 256;
3026     device->AuxiliaryEffectSlotMax = 4;
3027     device->NumAuxSends = MAX_SENDS;
3028
3029     InitUIntMap(&device->BufferMap, ~0);
3030     InitUIntMap(&device->EffectMap, ~0);
3031     InitUIntMap(&device->FilterMap, ~0);
3032
3033     //Set output format
3034     device->NumUpdates = 0;
3035     device->UpdateSize = 0;
3036
3037     device->Frequency = DEFAULT_OUTPUT_RATE;
3038     device->FmtChans = DevFmtChannelsDefault;
3039     device->FmtType = DevFmtTypeDefault;
3040
3041     ConfigValueUInt(NULL, "sources", &device->MaxNoOfSources);
3042     if(device->MaxNoOfSources == 0) device->MaxNoOfSources = 256;
3043
3044     ConfigValueUInt(NULL, "slots", &device->AuxiliaryEffectSlotMax);
3045     if(device->AuxiliaryEffectSlotMax == 0) device->AuxiliaryEffectSlotMax = 4;
3046
3047     ConfigValueUInt(NULL, "sends", &device->NumAuxSends);
3048     if(device->NumAuxSends > MAX_SENDS) device->NumAuxSends = MAX_SENDS;
3049
3050     device->NumStereoSources = 1;
3051     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;
3052
3053     // Open the "backend"
3054     ALCdevice_OpenPlayback(device, "Loopback");
3055     do {
3056         device->next = DeviceList;
3057     } while(!CompExchangePtr((XchgPtr*)&DeviceList, device->next, device));
3058
3059     TRACE("Created device %p\n", device);
3060     return device;
3061 }
3062
3063 /* alcIsRenderFormatSupportedSOFT
3064  *
3065  * Determines if the loopback device supports the given format for rendering.
3066  */
3067 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)
3068 {
3069     ALCboolean ret = ALC_FALSE;
3070
3071     if(!(device=VerifyDevice(device)) || device->Type != Loopback)
3072         alcSetError(device, ALC_INVALID_DEVICE);
3073     else if(freq <= 0)
3074         alcSetError(device, ALC_INVALID_VALUE);
3075     else
3076     {
3077         if(IsValidALCType(type) && BytesFromDevFmt(type) > 0 &&
3078            IsValidALCChannels(channels) && ChannelsFromDevFmt(channels) > 0 &&
3079            freq >= MIN_OUTPUT_RATE)
3080             ret = ALC_TRUE;
3081     }
3082     if(device) ALCdevice_DecRef(device);
3083
3084     return ret;
3085 }
3086
3087 /* alcRenderSamplesSOFT
3088  *
3089  * Renders some samples into a buffer, using the format last set by the
3090  * attributes given to alcCreateContext.
3091  */
3092 ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
3093 {
3094     if(!(device=VerifyDevice(device)) || device->Type != Loopback)
3095         alcSetError(device, ALC_INVALID_DEVICE);
3096     else if(samples < 0 || (samples > 0 && buffer == NULL))
3097         alcSetError(device, ALC_INVALID_VALUE);
3098     else
3099         aluMixData(device, buffer, samples);
3100     if(device) ALCdevice_DecRef(device);
3101 }