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