Convert the router to C++

1 files changed, 0 insertions, 956 deletions

diff --git a/router/alc.c b/router/alc.c
deleted file mode 100644
index 946c7d4c..00000000
--- a/router/alc.c
+++ /dev/null
@@ -1,956 +0,0 @@
-
-#include "config.h"
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "AL/alc.h"
-#include "router.h"
-#include "almalloc.h"
-
-
-#define COUNTOF(x)  (sizeof(x)/sizeof(x[0]))
-
-#define DECL(x) { #x, (ALCvoid*)(x) }
-static const struct {
-    const ALCchar *funcName;
-    ALCvoid *address;
-} alcFunctions[] = {
-    DECL(alcCreateContext),
-    DECL(alcMakeContextCurrent),
-    DECL(alcProcessContext),
-    DECL(alcSuspendContext),
-    DECL(alcDestroyContext),
-    DECL(alcGetCurrentContext),
-    DECL(alcGetContextsDevice),
-    DECL(alcOpenDevice),
-    DECL(alcCloseDevice),
-    DECL(alcGetError),
-    DECL(alcIsExtensionPresent),
-    DECL(alcGetProcAddress),
-    DECL(alcGetEnumValue),
-    DECL(alcGetString),
-    DECL(alcGetIntegerv),
-    DECL(alcCaptureOpenDevice),
-    DECL(alcCaptureCloseDevice),
-    DECL(alcCaptureStart),
-    DECL(alcCaptureStop),
-    DECL(alcCaptureSamples),
-
-    DECL(alcSetThreadContext),
-    DECL(alcGetThreadContext),
-
-    DECL(alEnable),
-    DECL(alDisable),
-    DECL(alIsEnabled),
-    DECL(alGetString),
-    DECL(alGetBooleanv),
-    DECL(alGetIntegerv),
-    DECL(alGetFloatv),
-    DECL(alGetDoublev),
-    DECL(alGetBoolean),
-    DECL(alGetInteger),
-    DECL(alGetFloat),
-    DECL(alGetDouble),
-    DECL(alGetError),
-    DECL(alIsExtensionPresent),
-    DECL(alGetProcAddress),
-    DECL(alGetEnumValue),
-    DECL(alListenerf),
-    DECL(alListener3f),
-    DECL(alListenerfv),
-    DECL(alListeneri),
-    DECL(alListener3i),
-    DECL(alListeneriv),
-    DECL(alGetListenerf),
-    DECL(alGetListener3f),
-    DECL(alGetListenerfv),
-    DECL(alGetListeneri),
-    DECL(alGetListener3i),
-    DECL(alGetListeneriv),
-    DECL(alGenSources),
-    DECL(alDeleteSources),
-    DECL(alIsSource),
-    DECL(alSourcef),
-    DECL(alSource3f),
-    DECL(alSourcefv),
-    DECL(alSourcei),
-    DECL(alSource3i),
-    DECL(alSourceiv),
-    DECL(alGetSourcef),
-    DECL(alGetSource3f),
-    DECL(alGetSourcefv),
-    DECL(alGetSourcei),
-    DECL(alGetSource3i),
-    DECL(alGetSourceiv),
-    DECL(alSourcePlayv),
-    DECL(alSourceStopv),
-    DECL(alSourceRewindv),
-    DECL(alSourcePausev),
-    DECL(alSourcePlay),
-    DECL(alSourceStop),
-    DECL(alSourceRewind),
-    DECL(alSourcePause),
-    DECL(alSourceQueueBuffers),
-    DECL(alSourceUnqueueBuffers),
-    DECL(alGenBuffers),
-    DECL(alDeleteBuffers),
-    DECL(alIsBuffer),
-    DECL(alBufferData),
-    DECL(alBufferf),
-    DECL(alBuffer3f),
-    DECL(alBufferfv),
-    DECL(alBufferi),
-    DECL(alBuffer3i),
-    DECL(alBufferiv),
-    DECL(alGetBufferf),
-    DECL(alGetBuffer3f),
-    DECL(alGetBufferfv),
-    DECL(alGetBufferi),
-    DECL(alGetBuffer3i),
-    DECL(alGetBufferiv),
-    DECL(alDopplerFactor),
-    DECL(alDopplerVelocity),
-    DECL(alSpeedOfSound),
-    DECL(alDistanceModel),
-};
-#undef DECL
-
-#define DECL(x) { #x, (x) }
-static const struct {
-    const ALCchar *enumName;
-    ALCenum value;
-} alcEnumerations[] = {
-    DECL(ALC_INVALID),
-    DECL(ALC_FALSE),
-    DECL(ALC_TRUE),
-
-    DECL(ALC_MAJOR_VERSION),
-    DECL(ALC_MINOR_VERSION),
-    DECL(ALC_ATTRIBUTES_SIZE),
-    DECL(ALC_ALL_ATTRIBUTES),
-    DECL(ALC_DEFAULT_DEVICE_SPECIFIER),
-    DECL(ALC_DEVICE_SPECIFIER),
-    DECL(ALC_ALL_DEVICES_SPECIFIER),
-    DECL(ALC_DEFAULT_ALL_DEVICES_SPECIFIER),
-    DECL(ALC_EXTENSIONS),
-    DECL(ALC_FREQUENCY),
-    DECL(ALC_REFRESH),
-    DECL(ALC_SYNC),
-    DECL(ALC_MONO_SOURCES),
-    DECL(ALC_STEREO_SOURCES),
-    DECL(ALC_CAPTURE_DEVICE_SPECIFIER),
-    DECL(ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER),
-    DECL(ALC_CAPTURE_SAMPLES),
-
-    DECL(ALC_NO_ERROR),
-    DECL(ALC_INVALID_DEVICE),
-    DECL(ALC_INVALID_CONTEXT),
-    DECL(ALC_INVALID_ENUM),
-    DECL(ALC_INVALID_VALUE),
-    DECL(ALC_OUT_OF_MEMORY),
-
-    DECL(AL_INVALID),
-    DECL(AL_NONE),
-    DECL(AL_FALSE),
-    DECL(AL_TRUE),
-
-    DECL(AL_SOURCE_RELATIVE),
-    DECL(AL_CONE_INNER_ANGLE),
-    DECL(AL_CONE_OUTER_ANGLE),
-    DECL(AL_PITCH),
-    DECL(AL_POSITION),
-    DECL(AL_DIRECTION),
-    DECL(AL_VELOCITY),
-    DECL(AL_LOOPING),
-    DECL(AL_BUFFER),
-    DECL(AL_GAIN),
-    DECL(AL_MIN_GAIN),
-    DECL(AL_MAX_GAIN),
-    DECL(AL_ORIENTATION),
-    DECL(AL_REFERENCE_DISTANCE),
-    DECL(AL_ROLLOFF_FACTOR),
-    DECL(AL_CONE_OUTER_GAIN),
-    DECL(AL_MAX_DISTANCE),
-    DECL(AL_SEC_OFFSET),
-    DECL(AL_SAMPLE_OFFSET),
-    DECL(AL_BYTE_OFFSET),
-    DECL(AL_SOURCE_TYPE),
-    DECL(AL_STATIC),
-    DECL(AL_STREAMING),
-    DECL(AL_UNDETERMINED),
-
-    DECL(AL_SOURCE_STATE),
-    DECL(AL_INITIAL),
-    DECL(AL_PLAYING),
-    DECL(AL_PAUSED),
-    DECL(AL_STOPPED),
-
-    DECL(AL_BUFFERS_QUEUED),
-    DECL(AL_BUFFERS_PROCESSED),
-
-    DECL(AL_FORMAT_MONO8),
-    DECL(AL_FORMAT_MONO16),
-    DECL(AL_FORMAT_STEREO8),
-    DECL(AL_FORMAT_STEREO16),
-
-    DECL(AL_FREQUENCY),
-    DECL(AL_BITS),
-    DECL(AL_CHANNELS),
-    DECL(AL_SIZE),
-
-    DECL(AL_UNUSED),
-    DECL(AL_PENDING),
-    DECL(AL_PROCESSED),
-
-    DECL(AL_NO_ERROR),
-    DECL(AL_INVALID_NAME),
-    DECL(AL_INVALID_ENUM),
-    DECL(AL_INVALID_VALUE),
-    DECL(AL_INVALID_OPERATION),
-    DECL(AL_OUT_OF_MEMORY),
-
-    DECL(AL_VENDOR),
-    DECL(AL_VERSION),
-    DECL(AL_RENDERER),
-    DECL(AL_EXTENSIONS),
-
-    DECL(AL_DOPPLER_FACTOR),
-    DECL(AL_DOPPLER_VELOCITY),
-    DECL(AL_DISTANCE_MODEL),
-    DECL(AL_SPEED_OF_SOUND),
-
-    DECL(AL_INVERSE_DISTANCE),
-    DECL(AL_INVERSE_DISTANCE_CLAMPED),
-    DECL(AL_LINEAR_DISTANCE),
-    DECL(AL_LINEAR_DISTANCE_CLAMPED),
-    DECL(AL_EXPONENT_DISTANCE),
-    DECL(AL_EXPONENT_DISTANCE_CLAMPED),
-};
-#undef DECL
-
-static const ALCchar alcNoError[] = "No Error";
-static const ALCchar alcErrInvalidDevice[] = "Invalid Device";
-static const ALCchar alcErrInvalidContext[] = "Invalid Context";
-static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";
-static const ALCchar alcErrInvalidValue[] = "Invalid Value";
-static const ALCchar alcErrOutOfMemory[] = "Out of Memory";
-static const ALCchar alcExtensionList[] =
-    "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "
-    "ALC_EXT_thread_local_context";
-
-static const ALCint alcMajorVersion = 1;
-static const ALCint alcMinorVersion = 1;
-
-
-static almtx_t EnumerationLock;
-static almtx_t ContextSwitchLock;
-
-static ATOMIC(ALCenum) LastError = ATOMIC_INIT_STATIC(ALC_NO_ERROR);
-static PtrIntMap DeviceIfaceMap = PTRINTMAP_STATIC_INITIALIZE;
-static PtrIntMap ContextIfaceMap = PTRINTMAP_STATIC_INITIALIZE;
-
-
-typedef struct EnumeratedList {
-    ALCchar *Names;
-    ALCchar *NamesEnd;
-    ALCint *Indicies;
-    ALCsizei IndexSize;
-} EnumeratedList;
-static EnumeratedList DevicesList = { NULL, NULL, NULL, 0 };
-static EnumeratedList AllDevicesList = { NULL, NULL, NULL, 0 };
-static EnumeratedList CaptureDevicesList = { NULL, NULL, NULL, 0 };
-
-static void ClearDeviceList(EnumeratedList *list)
-{
-    al_free(list->Names);
-    list->Names = NULL;
-    list->NamesEnd = NULL;
-
-    al_free(list->Indicies);
-    list->Indicies = NULL;
-    list->IndexSize = 0;
-}
-
-static void AppendDeviceList(EnumeratedList *list, const ALCchar *names, ALint idx)
-{
-    const ALCchar *name_end = names;
-    ALCsizei count = 0;
-    ALCchar *new_list;
-    ALCint *new_indicies;
-    size_t len;
-    ALCsizei i;
-
-    if(!name_end)
-        return;
-    while(*name_end)
-    {
-        TRACE("Enumerated \"%s\", driver %d\n", name_end, idx);
-        count++;
-        name_end += strlen(name_end)+1;
-    }
-    if(names == name_end)
-        return;
-
-    len = (list->NamesEnd - list->Names) + (name_end - names);
-    new_list = al_calloc(DEF_ALIGN, len + 1);
-    memcpy(new_list,  list->Names, list->NamesEnd - list->Names);
-    memcpy(new_list + (list->NamesEnd - list->Names), names, name_end - names);
-    al_free(list->Names);
-    list->Names = new_list;
-    list->NamesEnd = list->Names + len;
-
-    new_indicies = al_calloc(16, sizeof(ALCint)*(list->IndexSize + count));
-    for(i = 0;i < list->IndexSize;i++)
-        new_indicies[i] = list->Indicies[i];
-    for(i = 0;i < count;i++)
-        new_indicies[list->IndexSize+i] = idx;
-    al_free(list->Indicies);
-    list->Indicies = new_indicies;
-    list->IndexSize += count;
-}
-
-static ALint GetDriverIndexForName(const EnumeratedList *list, const ALCchar *name)
-{
-    const ALCchar *devnames = list->Names;
-    const ALCint *index = list->Indicies;
-
-    while(devnames && *devnames)
-    {
-        if(strcmp(name, devnames) == 0)
-            return *index;
-        devnames += strlen(devnames)+1;
-        index++;
-    }
-    return -1;
-}
-
-void InitALC(void)
-{
-    almtx_init(&EnumerationLock, almtx_recursive);
-    almtx_init(&ContextSwitchLock, almtx_plain);
-}
-
-void ReleaseALC(void)
-{
-    ClearDeviceList(&DevicesList);
-    ClearDeviceList(&AllDevicesList);
-    ClearDeviceList(&CaptureDevicesList);
-
-    ResetPtrIntMap(&ContextIfaceMap);
-    ResetPtrIntMap(&DeviceIfaceMap);
-
-    almtx_destroy(&ContextSwitchLock);
-    almtx_destroy(&EnumerationLock);
-}
-
-
-ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename)
-{
-    ALCdevice *device = NULL;
-    ALint idx;
-
-    /* Prior to the enumeration extension, apps would hardcode these names as a
-     * quality hint for the wrapper driver. Ignore them since there's no sane
-     * way to map them.
-     */
-    if(devicename && (devicename[0] == '\0' ||
-                      strcmp(devicename, "DirectSound3D") == 0 ||
-                      strcmp(devicename, "DirectSound") == 0 ||
-                      strcmp(devicename, "MMSYSTEM") == 0))
-        devicename = NULL;
-    if(devicename)
-    {
-        almtx_lock(&EnumerationLock);
-        if(!DevicesList.Names)
-            (void)alcGetString(NULL, ALC_DEVICE_SPECIFIER);
-        idx = GetDriverIndexForName(&DevicesList, devicename);
-        if(idx < 0)
-        {
-            if(!AllDevicesList.Names)
-                (void)alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
-            idx = GetDriverIndexForName(&AllDevicesList, devicename);
-        }
-        almtx_unlock(&EnumerationLock);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_VALUE);
-            TRACE("Failed to find driver for name \"%s\"\n", devicename);
-            return NULL;
-        }
-        TRACE("Found driver %d for name \"%s\"\n", idx, devicename);
-        device = DriverList[idx].alcOpenDevice(devicename);
-    }
-    else
-    {
-        int i;
-        for(i = 0;i < DriverListSize;i++)
-        {
-            if(DriverList[i].ALCVer >= MAKE_ALC_VER(1, 1) ||
-               DriverList[i].alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT"))
-            {
-                idx = i;
-                TRACE("Using default device from driver %d\n", idx);
-                device = DriverList[idx].alcOpenDevice(NULL);
-                break;
-            }
-        }
-    }
-
-    if(device)
-    {
-        if(InsertPtrIntMapEntry(&DeviceIfaceMap, device, idx) != ALC_NO_ERROR)
-        {
-            DriverList[idx].alcCloseDevice(device);
-            device = NULL;
-        }
-    }
-
-    return device;
-}
-
-ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device)
-{
-    ALint idx;
-
-    if(!device || (idx=LookupPtrIntMapKey(&DeviceIfaceMap, device)) < 0)
-    {
-        ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-        return ALC_FALSE;
-    }
-    if(!DriverList[idx].alcCloseDevice(device))
-        return ALC_FALSE;
-    RemovePtrIntMapKey(&DeviceIfaceMap, device);
-    return ALC_TRUE;
-}
-
-
-ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrlist)
-{
-    ALCcontext *context;
-    ALint idx;
-
-    if(!device || (idx=LookupPtrIntMapKey(&DeviceIfaceMap, device)) < 0)
-    {
-        ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-        return ALC_FALSE;
-    }
-    context = DriverList[idx].alcCreateContext(device, attrlist);
-    if(context)
-    {
-        if(InsertPtrIntMapEntry(&ContextIfaceMap, context, idx) != ALC_NO_ERROR)
-        {
-            DriverList[idx].alcDestroyContext(context);
-            context = NULL;
-        }
-    }
-
-    return context;
-}
-
-ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)
-{
-    ALint idx = -1;
-
-    almtx_lock(&ContextSwitchLock);
-    if(context)
-    {
-        idx = LookupPtrIntMapKey(&ContextIfaceMap, context);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_CONTEXT);
-            almtx_unlock(&ContextSwitchLock);
-            return ALC_FALSE;
-        }
-        if(!DriverList[idx].alcMakeContextCurrent(context))
-        {
-            almtx_unlock(&ContextSwitchLock);
-            return ALC_FALSE;
-        }
-    }
-
-    /* Unset the context from the old driver if it's different from the new
-     * current one.
-     */
-    if(idx < 0)
-    {
-        DriverIface *oldiface = altss_get(ThreadCtxDriver);
-        if(oldiface) oldiface->alcSetThreadContext(NULL);
-        oldiface = ATOMIC_EXCHANGE_PTR_SEQ(&CurrentCtxDriver, NULL);
-        if(oldiface) oldiface->alcMakeContextCurrent(NULL);
-    }
-    else
-    {
-        DriverIface *oldiface = altss_get(ThreadCtxDriver);
-        if(oldiface && oldiface != &DriverList[idx])
-            oldiface->alcSetThreadContext(NULL);
-        oldiface = ATOMIC_EXCHANGE_PTR_SEQ(&CurrentCtxDriver, &DriverList[idx]);
-        if(oldiface && oldiface != &DriverList[idx])
-            oldiface->alcMakeContextCurrent(NULL);
-    }
-    almtx_unlock(&ContextSwitchLock);
-    altss_set(ThreadCtxDriver, NULL);
-
-    return ALC_TRUE;
-}
-
-ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context)
-{
-    if(context)
-    {
-        ALint idx = LookupPtrIntMapKey(&ContextIfaceMap, context);
-        if(idx >= 0)
-            return DriverList[idx].alcProcessContext(context);
-    }
-    ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_CONTEXT);
-}
-
-ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context)
-{
-    if(context)
-    {
-        ALint idx = LookupPtrIntMapKey(&ContextIfaceMap, context);
-        if(idx >= 0)
-            return DriverList[idx].alcSuspendContext(context);
-    }
-    ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_CONTEXT);
-}
-
-ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context)
-{
-    ALint idx;
-
-    if(!context || (idx=LookupPtrIntMapKey(&ContextIfaceMap, context)) < 0)
-    {
-        ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_CONTEXT);
-        return;
-    }
-
-    DriverList[idx].alcDestroyContext(context);
-    RemovePtrIntMapKey(&ContextIfaceMap, context);
-}
-
-ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void)
-{
-    DriverIface *iface = altss_get(ThreadCtxDriver);
-    if(!iface) iface = ATOMIC_LOAD_SEQ(&CurrentCtxDriver);
-    return iface ? iface->alcGetCurrentContext() : NULL;
-}
-
-ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *context)
-{
-    if(context)
-    {
-        ALint idx = LookupPtrIntMapKey(&ContextIfaceMap, context);
-        if(idx >= 0)
-            return DriverList[idx].alcGetContextsDevice(context);
-    }
-    ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_CONTEXT);
-    return NULL;
-}
-
-
-ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)
-{
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx < 0) return ALC_INVALID_DEVICE;
-        return DriverList[idx].alcGetError(device);
-    }
-    return ATOMIC_EXCHANGE_SEQ(&LastError, ALC_NO_ERROR);
-}
-
-ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname)
-{
-    const char *ptr;
-    size_t len;
-
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-            return ALC_FALSE;
-        }
-        return DriverList[idx].alcIsExtensionPresent(device, extname);
-    }
-
-    len = strlen(extname);
-    ptr = alcExtensionList;
-    while(ptr && *ptr)
-    {
-        if(strncasecmp(ptr, extname, len) == 0 && (ptr[len] == '\0' || isspace(ptr[len])))
-            return ALC_TRUE;
-        if((ptr=strchr(ptr, ' ')) != NULL)
-        {
-            do {
-                ++ptr;
-            } while(isspace(*ptr));
-        }
-    }
-    return ALC_FALSE;
-}
-
-ALC_API void* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname)
-{
-    size_t i;
-
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-            return NULL;
-        }
-        return DriverList[idx].alcGetProcAddress(device, funcname);
-    }
-
-    for(i = 0;i < COUNTOF(alcFunctions);i++)
-    {
-        if(strcmp(funcname, alcFunctions[i].funcName) == 0)
-            return alcFunctions[i].address;
-    }
-    return NULL;
-}
-
-ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname)
-{
-    size_t i;
-
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-            return 0;
-        }
-        return DriverList[idx].alcGetEnumValue(device, enumname);
-    }
-
-    for(i = 0;i < COUNTOF(alcEnumerations);i++)
-    {
-        if(strcmp(enumname, alcEnumerations[i].enumName) == 0)
-            return alcEnumerations[i].value;
-    }
-    return 0;
-}
-
-ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param)
-{
-    ALsizei i = 0;
-
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-            return NULL;
-        }
-        return DriverList[idx].alcGetString(device, param);
-    }
-
-    switch(param)
-    {
-    case ALC_NO_ERROR:
-        return alcNoError;
-    case ALC_INVALID_ENUM:
-        return alcErrInvalidEnum;
-    case ALC_INVALID_VALUE:
-        return alcErrInvalidValue;
-    case ALC_INVALID_DEVICE:
-        return alcErrInvalidDevice;
-    case ALC_INVALID_CONTEXT:
-        return alcErrInvalidContext;
-    case ALC_OUT_OF_MEMORY:
-        return alcErrOutOfMemory;
-    case ALC_EXTENSIONS:
-        return alcExtensionList;
-
-    case ALC_DEVICE_SPECIFIER:
-        almtx_lock(&EnumerationLock);
-        ClearDeviceList(&DevicesList);
-        for(i = 0;i < DriverListSize;i++)
-        {
-            /* Only enumerate names from drivers that support it. */
-            if(DriverList[i].ALCVer >= MAKE_ALC_VER(1, 1) ||
-               DriverList[i].alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT"))
-                AppendDeviceList(&DevicesList,
-                    DriverList[i].alcGetString(NULL, ALC_DEVICE_SPECIFIER), i
-                );
-        }
-        almtx_unlock(&EnumerationLock);
-        return DevicesList.Names;
-
-    case ALC_ALL_DEVICES_SPECIFIER:
-        almtx_lock(&EnumerationLock);
-        ClearDeviceList(&AllDevicesList);
-        for(i = 0;i < DriverListSize;i++)
-        {
-            /* If the driver doesn't support ALC_ENUMERATE_ALL_EXT, substitute
-             * standard enumeration.
-             */
-            if(DriverList[i].alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT"))
-                AppendDeviceList(&AllDevicesList,
-                    DriverList[i].alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER), i
-                );
-            else if(DriverList[i].ALCVer >= MAKE_ALC_VER(1, 1) ||
-                    DriverList[i].alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT"))
-                AppendDeviceList(&AllDevicesList,
-                    DriverList[i].alcGetString(NULL, ALC_DEVICE_SPECIFIER), i
-                );
-        }
-        almtx_unlock(&EnumerationLock);
-        return AllDevicesList.Names;
-
-    case ALC_CAPTURE_DEVICE_SPECIFIER:
-        almtx_lock(&EnumerationLock);
-        ClearDeviceList(&CaptureDevicesList);
-        for(i = 0;i < DriverListSize;i++)
-        {
-            if(DriverList[i].ALCVer >= MAKE_ALC_VER(1, 1) ||
-               DriverList[i].alcIsExtensionPresent(NULL, "ALC_EXT_CAPTURE"))
-                AppendDeviceList(&CaptureDevicesList,
-                    DriverList[i].alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER), i
-                );
-        }
-        almtx_unlock(&EnumerationLock);
-        return CaptureDevicesList.Names;
-
-    case ALC_DEFAULT_DEVICE_SPECIFIER:
-        for(i = 0;i < DriverListSize;i++)
-        {
-            if(DriverList[i].ALCVer >= MAKE_ALC_VER(1, 1) ||
-               DriverList[i].alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT"))
-                return DriverList[i].alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
-        }
-        return "";
-
-    case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:
-        for(i = 0;i < DriverListSize;i++)
-        {
-            if(DriverList[i].alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT"))
-                return DriverList[i].alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
-        }
-        return "";
-
-    case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:
-        for(i = 0;i < DriverListSize;i++)
-        {
-            if(DriverList[i].ALCVer >= MAKE_ALC_VER(1, 1) ||
-               DriverList[i].alcIsExtensionPresent(NULL, "ALC_EXT_CAPTURE"))
-                return DriverList[i].alcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
-        }
-        return "";
-
-    default:
-        ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_ENUM);
-        break;
-    }
-    return NULL;
-}
-
-ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values)
-{
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-            return;
-        }
-        return DriverList[idx].alcGetIntegerv(device, param, size, values);
-    }
-
-    if(size <= 0 || values == NULL)
-    {
-        ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_VALUE);
-        return;
-    }
-
-    switch(param)
-    {
-        case ALC_MAJOR_VERSION:
-            if(size >= 1)
-            {
-                values[0] = alcMajorVersion;
-                return;
-            }
-            /*fall-through*/
-        case ALC_MINOR_VERSION:
-            if(size >= 1)
-            {
-                values[0] = alcMinorVersion;
-                return;
-            }
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_VALUE);
-            return;
-
-        case ALC_ATTRIBUTES_SIZE:
-        case ALC_ALL_ATTRIBUTES:
-        case ALC_FREQUENCY:
-        case ALC_REFRESH:
-        case ALC_SYNC:
-        case ALC_MONO_SOURCES:
-        case ALC_STEREO_SOURCES:
-        case ALC_CAPTURE_SAMPLES:
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-            return;
-
-        default:
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_ENUM);
-            return;
-    }
-}
-
-
-ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize)
-{
-    ALCdevice *device = NULL;
-    ALint idx;
-
-    if(devicename && devicename[0] == '\0')
-        devicename = NULL;
-    if(devicename)
-    {
-        almtx_lock(&EnumerationLock);
-        if(!CaptureDevicesList.Names)
-            (void)alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
-        idx = GetDriverIndexForName(&CaptureDevicesList, devicename);
-        almtx_unlock(&EnumerationLock);
-        if(idx < 0)
-        {
-            ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_VALUE);
-            TRACE("Failed to find driver for name \"%s\"\n", devicename);
-            return NULL;
-        }
-        TRACE("Found driver %d for name \"%s\"\n", idx, devicename);
-        device = DriverList[idx].alcCaptureOpenDevice(
-            devicename, frequency, format, buffersize
-        );
-    }
-    else
-    {
-        int i;
-        for(i = 0;i < DriverListSize;i++)
-        {
-            if(DriverList[i].ALCVer >= MAKE_ALC_VER(1, 1) ||
-               DriverList[i].alcIsExtensionPresent(NULL, "ALC_EXT_CAPTURE"))
-            {
-                idx = i;
-                TRACE("Using default capture device from driver %d\n", idx);
-                device = DriverList[idx].alcCaptureOpenDevice(
-                    NULL, frequency, format, buffersize
-                );
-                break;
-            }
-        }
-    }
-
-    if(device)
-    {
-        if(InsertPtrIntMapEntry(&DeviceIfaceMap, device, idx) != ALC_NO_ERROR)
-        {
-            DriverList[idx].alcCaptureCloseDevice(device);
-            device = NULL;
-        }
-    }
-
-    return device;
-}
-
-ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device)
-{
-    ALint idx;
-
-    if(!device || (idx=LookupPtrIntMapKey(&DeviceIfaceMap, device)) < 0)
-    {
-        ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-        return ALC_FALSE;
-    }
-    if(!DriverList[idx].alcCaptureCloseDevice(device))
-        return ALC_FALSE;
-    RemovePtrIntMapKey(&DeviceIfaceMap, device);
-    return ALC_TRUE;
-}
-
-ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)
-{
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx >= 0)
-            return DriverList[idx].alcCaptureStart(device);
-    }
-    ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-}
-
-ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)
-{
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx >= 0)
-            return DriverList[idx].alcCaptureStop(device);
-    }
-    ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-}
-
-ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)
-{
-    if(device)
-    {
-        ALint idx = LookupPtrIntMapKey(&DeviceIfaceMap, device);
-        if(idx >= 0)
-            return DriverList[idx].alcCaptureSamples(device, buffer, samples);
-    }
-    ATOMIC_STORE_SEQ(&LastError, ALC_INVALID_DEVICE);
-}
-
-
-ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)
-{
-    ALCenum err = ALC_INVALID_CONTEXT;
-    ALint idx;
-
-    if(!context)
-    {
-        DriverIface *oldiface = altss_get(ThreadCtxDriver);
-        if(oldiface && !oldiface->alcSetThreadContext(NULL))
-            return ALC_FALSE;
-        altss_set(ThreadCtxDriver, NULL);
-        return ALC_TRUE;
-    }
-
-    idx = LookupPtrIntMapKey(&ContextIfaceMap, context);
-    if(idx >= 0)
-    {
-        if(DriverList[idx].alcSetThreadContext(context))
-        {
-            DriverIface *oldiface = altss_get(ThreadCtxDriver);
-            if(oldiface != &DriverList[idx])
-            {
-                altss_set(ThreadCtxDriver, &DriverList[idx]);
-                if(oldiface) oldiface->alcSetThreadContext(NULL);
-            }
-            return ALC_TRUE;
-        }
-        err = DriverList[idx].alcGetError(NULL);
-    }
-    ATOMIC_STORE_SEQ(&LastError, err);
-    return ALC_FALSE;
-}
-
-ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)
-{
-    DriverIface *iface = altss_get(ThreadCtxDriver);
-    if(iface) return iface->alcGetThreadContext();
-    return NULL;
-}