Release 1.16.0

ALC_SOFT_pause_device is finished
Assume SSE is available if building with support and no run-time checking
2014-08-14 17:30:11 -07:00 · 2014-08-12 08:45:11 -07:00 · 2014-08-11 14:45:28 -07:00 · 2014-08-11 14:19:15 -07:00 · 2014-08-11 13:38:43 -07:00 · 2014-08-11 09:13:08 -07:00
156 changed files with 58418 additions and 10304 deletions
@@ -1 +1,7 @@
-CMakeConf
+build
+winbuild
+win64build
+include/SLES
+include/sndio.h
+include/sys
+openal-soft.kdev4
@@ -18,12 +18,27 @@
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

+#ifdef _WIN32
+#ifdef __MINGW32__
+#define _WIN32_IE 0x501
+#else
+#define _WIN32_IE 0x400
+#endif
+#endif
+
+#include "config.h"
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
+#ifdef _WIN32_IE
+#include <shlobj.h>
+#endif

 #include "alMain.h"
+#include "compat.h"
+

 typedef struct ConfigEntry {
    char *key;
@@ -31,255 +46,470 @@ typedef struct ConfigEntry {
 } ConfigEntry;

 typedef struct ConfigBlock {
-    char *name;
    ConfigEntry *entries;
-    size_t entryCount;
+    unsigned int entryCount;
 } ConfigBlock;
+static ConfigBlock cfgBlock;

-static ConfigBlock *cfgBlocks;
-static size_t cfgCount;

-static char buffer[1024];
+static char *lstrip(char *line)
+{
+    while(isspace(line[0]))
+        line++;
+    return line;
+}
+
+static char *rstrip(char *line)
+{
+    size_t len = strlen(line);
+    while(len > 0 && isspace(line[len-1]))
+        len--;
+    line[len] = 0;
+    return line;
+}
+
+static int readline(FILE *f, char **output, size_t *maxlen)
+{
+    size_t len = 0;
+    int c;
+
+    while((c=fgetc(f)) != EOF && (c == '\r' || c == '\n'))
+        ;
+    if(c == EOF)
+        return 0;
+
+    do {
+        if(len+1 >= *maxlen)
+        {
+            void *temp = NULL;
+            size_t newmax;
+
+            newmax = (*maxlen ? (*maxlen)<<1 : 32);
+            if(newmax > *maxlen)
+                temp = realloc(*output, newmax);
+            if(!temp)
+            {
+                ERR("Failed to realloc "SZFMT" bytes from "SZFMT"!\n", newmax, *maxlen);
+                return 0;
+            }
+
+            *output = temp;
+            *maxlen = newmax;
+        }
+        (*output)[len++] = c;
+        (*output)[len] = '\0';
+    } while((c=fgetc(f)) != EOF && c != '\r' && c != '\n');
+
+    return 1;
+}
+
+
+static char *expdup(const char *str)
+{
+    char *output = NULL;
+    size_t maxlen = 0;
+    size_t len = 0;
+
+    while(*str != '\0')
+    {
+        const char *addstr;
+        size_t addstrlen;
+        size_t i;
+
+        if(str[0] != '$')
+        {
+            const char *next = strchr(str, '$');
+            addstr = str;
+            addstrlen = next ? (size_t)(next-str) : strlen(str);
+
+            str += addstrlen;
+        }
+        else
+        {
+            str++;
+            if(*str == '$')
+            {
+                const char *next = strchr(str+1, '$');
+                addstr = str;
+                addstrlen = next ? (size_t)(next-str) : strlen(str);
+
+                str += addstrlen;
+            }
+            else
+            {
+                char envname[1024];
+                size_t k = 0;
+
+                while((isalnum(*str) || *str == '_') && k < sizeof(envname)-1)
+                    envname[k++] = *(str++);
+                envname[k++] = '\0';
+
+                if((addstr=getenv(envname)) == NULL)
+                    continue;
+                addstrlen = strlen(addstr);
+            }
+        }
+        if(addstrlen == 0)
+            continue;
+
+        if(addstrlen >= maxlen-len)
+        {
+            void *temp = NULL;
+            size_t newmax;
+
+            newmax = len+addstrlen+1;
+            if(newmax > maxlen)
+                temp = realloc(output, newmax);
+            if(!temp)
+            {
+                ERR("Failed to realloc "SZFMT" bytes from "SZFMT"!\n", newmax, maxlen);
+                return output;
+            }
+
+            output = temp;
+            maxlen = newmax;
+        }
+
+        for(i = 0;i < addstrlen;i++)
+            output[len++] = addstr[i];
+        output[len] = '\0';
+    }
+
+    return output ? output : calloc(1, 1);
+}
+

 static void LoadConfigFromFile(FILE *f)
 {
-    ConfigBlock *curBlock = cfgBlocks;
+    char curSection[128] = "";
+    char *buffer = NULL;
+    size_t maxlen = 0;
    ConfigEntry *ent;

-    while(fgets(buffer, sizeof(buffer), f))
+    while(readline(f, &buffer, &maxlen))
    {
-        size_t i = 0;
+        char *line, *comment;
+        char key[256] = "";
+        char value[256] = "";

-        while(isspace(buffer[i]))
-            i++;
-        if(!buffer[i] || buffer[i] == '#')
+        comment = strchr(buffer, '#');
+        if(comment) *(comment++) = 0;
+
+        line = rstrip(lstrip(buffer));
+        if(!line[0])
            continue;

-        memmove(buffer, buffer+i, strlen(buffer+i)+1);
-
-        if(buffer[0] == '[')
+        if(line[0] == '[')
        {
-            ConfigBlock *nextBlock;
+            char *section = line+1;
+            char *endsection;

-            i = 1;
-            while(buffer[i] && buffer[i] != ']')
-                i++;
-
-            if(!buffer[i])
+            endsection = strchr(section, ']');
+            if(!endsection || section == endsection || endsection[1] != 0)
            {
-                 AL_PRINT("config parse error: bad line \"%s\"\n", buffer);
+                 ERR("config parse error: bad line \"%s\"\n", line);
                 continue;
            }
-            buffer[i] = 0;
+            *endsection = 0;

-            do {
-                i++;
-                if(buffer[i] && !isspace(buffer[i]))
-                {
-                    if(buffer[i] != '#')
-                        AL_PRINT("config warning: extra data after block: \"%s\"\n", buffer+i);
-                    break;
-                }
-            } while(buffer[i]);
-
-            nextBlock = NULL;
-            for(i = 0;i < cfgCount;i++)
+            if(strcasecmp(section, "general") == 0)
+                curSection[0] = 0;
+            else
            {
-                if(strcasecmp(cfgBlocks[i].name, buffer+1) == 0)
-                {
-                    nextBlock = cfgBlocks+i;
-//                    AL_PRINT("found block '%s'\n", nextBlock->name);
-                    break;
-                }
+                strncpy(curSection, section, sizeof(curSection)-1);
+                curSection[sizeof(curSection)-1] = 0;
            }

-            if(!nextBlock)
-            {
-                nextBlock = realloc(cfgBlocks, (cfgCount+1)*sizeof(ConfigBlock));
-                if(!nextBlock)
-                {
-                     AL_PRINT("config parse error: error reallocating config blocks\n");
-                     continue;
-                }
-                cfgBlocks = nextBlock;
-                nextBlock = cfgBlocks+cfgCount;
-                cfgCount++;
-
-                nextBlock->name = strdup(buffer+1);
-                nextBlock->entries = NULL;
-                nextBlock->entryCount = 0;
-
-//                AL_PRINT("found new block '%s'\n", nextBlock->name);
-            }
-            curBlock = nextBlock;
            continue;
        }

-        /* Look for the option name */
-        i = 0;
-        while(buffer[i] && buffer[i] != '#' && buffer[i] != '=' &&
-              !isspace(buffer[i]))
-            i++;
-
-        if(!buffer[i] || buffer[i] == '#' || i == 0)
+        if(sscanf(line, "%255[^=] = \"%255[^\"]\"", key, value) == 2 ||
+           sscanf(line, "%255[^=] = '%255[^\']'", key, value) == 2 ||
+           sscanf(line, "%255[^=] = %255[^\n]", key, value) == 2)
        {
-            AL_PRINT("config parse error: malformed option line: \"%s\"\n", buffer);
+            /* sscanf doesn't handle '' or "" as empty values, so clip it
+             * manually. */
+            if(strcmp(value, "\"\"") == 0 || strcmp(value, "''") == 0)
+                value[0] = 0;
+        }
+        else if(sscanf(line, "%255[^=] %255[=]", key, value) == 2)
+        {
+            /* Special case for 'key =' */
+            value[0] = 0;
+        }
+        else
+        {
+            ERR("config parse error: malformed option line: \"%s\"\n\n", line);
            continue;
        }
+        rstrip(key);

-        /* Seperate the option */
-        if(buffer[i] != '=')
+        if(curSection[0] != 0)
        {
-            buffer[i++] = 0;
-
-            while(isspace(buffer[i]))
-                i++;
-            if(buffer[i] != '=')
-            {
-                AL_PRINT("config parse error: option without a value: \"%s\"\n", buffer);
-                continue;
-            }
+            size_t len = strlen(curSection);
+            memmove(&key[len+1], key, sizeof(key)-1-len);
+            key[len] = '/';
+            memcpy(key, curSection, len);
        }
-        /* Find the start of the value */
-        buffer[i++] = 0;
-        while(isspace(buffer[i]))
-            i++;

        /* Check if we already have this option set */
-        ent = curBlock->entries;
-        while((size_t)(ent-curBlock->entries) < curBlock->entryCount)
+        ent = cfgBlock.entries;
+        while((unsigned int)(ent-cfgBlock.entries) < cfgBlock.entryCount)
        {
-            if(strcasecmp(ent->key, buffer) == 0)
+            if(strcasecmp(ent->key, key) == 0)
                break;
            ent++;
        }

-        if((size_t)(ent-curBlock->entries) >= curBlock->entryCount)
+        if((unsigned int)(ent-cfgBlock.entries) >= cfgBlock.entryCount)
        {
            /* Allocate a new option entry */
-            ent = realloc(curBlock->entries, (curBlock->entryCount+1)*sizeof(ConfigEntry));
+            ent = realloc(cfgBlock.entries, (cfgBlock.entryCount+1)*sizeof(ConfigEntry));
            if(!ent)
            {
-                 AL_PRINT("config parse error: error reallocating config entries\n");
+                 ERR("config parse error: error reallocating config entries\n");
                 continue;
            }
-            curBlock->entries = ent;
-            ent = curBlock->entries + curBlock->entryCount;
-            curBlock->entryCount++;
+            cfgBlock.entries = ent;
+            ent = cfgBlock.entries + cfgBlock.entryCount;
+            cfgBlock.entryCount++;

-            ent->key = strdup(buffer);
+            ent->key = strdup(key);
            ent->value = NULL;
        }

-        /* Look for the end of the line (Null term, new-line, or #-symbol) and
-           eat up the trailing whitespace */
-        memmove(buffer, buffer+i, strlen(buffer+i)+1);
-
-        i = 0;
-        while(buffer[i] && buffer[i] != '#' && buffer[i] != '\n')
-            i++;
-        do {
-            i--;
-        } while(isspace(buffer[i]));
-        buffer[++i] = 0;
-
        free(ent->value);
-        ent->value = strdup(buffer);
+        ent->value = expdup(value);

-//        AL_PRINT("found '%s' = '%s'\n", ent->key, ent->value);
+        TRACE("found '%s' = '%s'\n", ent->key, ent->value);
    }
+
+    free(buffer);
 }

+#ifdef _WIN32
 void ReadALConfig(void)
 {
+    WCHAR buffer[PATH_MAX];
+    const WCHAR *str;
    FILE *f;

-    cfgBlocks = calloc(1, sizeof(ConfigBlock));
-    cfgBlocks->name = strdup("general");
-    cfgCount = 1;
+    if(SHGetSpecialFolderPathW(NULL, buffer, CSIDL_APPDATA, FALSE) != FALSE)
+    {
+        size_t p = lstrlenW(buffer);
+        _snwprintf(buffer+p, PATH_MAX-p, L"\\alsoft.ini");

-#ifdef _WIN32
-#else
-    f = fopen("/etc/openal/config", "r");
-    if(f)
-    {
-        LoadConfigFromFile(f);
-        fclose(f);
-    }
-    if(getenv("HOME") && *(getenv("HOME")))
-    {
-        snprintf(buffer, sizeof(buffer), "%s/.openalrc", getenv("HOME"));
-        f = fopen(buffer, "r");
+        TRACE("Loading config %ls...\n", buffer);
+        f = _wfopen(buffer, L"rt");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
+
+    if((str=_wgetenv(L"ALSOFT_CONF")) != NULL && *str)
+    {
+        TRACE("Loading config %ls...\n", str);
+        f = _wfopen(str, L"rt");
        if(f)
        {
            LoadConfigFromFile(f);
            fclose(f);
        }
    }
-#endif
 }
+#else
+void ReadALConfig(void)
+{
+    char buffer[PATH_MAX];
+    const char *str;
+    FILE *f;
+
+    str = "/etc/openal/alsoft.conf";
+
+    TRACE("Loading config %s...\n", str);
+    f = al_fopen(str, "r");
+    if(f)
+    {
+        LoadConfigFromFile(f);
+        fclose(f);
+    }
+
+    if(!(str=getenv("XDG_CONFIG_DIRS")) || str[0] == 0)
+        str = "/etc/xdg";
+    strncpy(buffer, str, sizeof(buffer)-1);
+    buffer[sizeof(buffer)-1] = 0;
+    /* Go through the list in reverse, since "the order of base directories
+     * denotes their importance; the first directory listed is the most
+     * important". Ergo, we need to load the settings from the later dirs
+     * first so that the settings in the earlier dirs override them.
+     */
+    while(1)
+    {
+        char *next = strrchr(buffer, ':');
+        if(next) *(next++) = 0;
+        else next = buffer;
+
+        if(next[0] != '/')
+            WARN("Ignoring XDG config dir: %s\n", next);
+        else
+        {
+            size_t len = strlen(next);
+            strncpy(next+len, "/alsoft.conf", buffer+sizeof(buffer)-next-len);
+            buffer[sizeof(buffer)-1] = 0;
+
+            TRACE("Loading config %s...\n", next);
+            f = al_fopen(next, "r");
+            if(f)
+            {
+                LoadConfigFromFile(f);
+                fclose(f);
+            }
+        }
+        if(next == buffer)
+            break;
+    }
+
+    if((str=getenv("HOME")) != NULL && *str)
+    {
+        snprintf(buffer, sizeof(buffer), "%s/.alsoftrc", str);
+
+        TRACE("Loading config %s...\n", buffer);
+        f = al_fopen(buffer, "r");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
+
+    if((str=getenv("XDG_CONFIG_HOME")) != NULL && str[0] != 0)
+        snprintf(buffer, sizeof(buffer), "%s/%s", str, "alsoft.conf");
+    else
+    {
+        buffer[0] = 0;
+        if((str=getenv("HOME")) != NULL && str[0] != 0)
+            snprintf(buffer, sizeof(buffer), "%s/.config/%s", str, "alsoft.conf");
+    }
+    if(buffer[0] != 0)
+    {
+        TRACE("Loading config %s...\n", buffer);
+        f = al_fopen(buffer, "r");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
+
+    if((str=getenv("ALSOFT_CONF")) != NULL && *str)
+    {
+        TRACE("Loading config %s...\n", str);
+        f = al_fopen(str, "r");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
+}
+#endif

 void FreeALConfig(void)
 {
-    size_t i;
+    unsigned int i;

-    for(i = 0;i < cfgCount;i++)
+    for(i = 0;i < cfgBlock.entryCount;i++)
    {
-        size_t j;
-        for(j = 0;j < cfgBlocks[i].entryCount;j++)
-        {
-           free(cfgBlocks[i].entries[j].key);
-           free(cfgBlocks[i].entries[j].value);
-        }
-        free(cfgBlocks[i].entries);
-        free(cfgBlocks[i].name);
+        free(cfgBlock.entries[i].key);
+        free(cfgBlock.entries[i].value);
    }
-    free(cfgBlocks);
-    cfgBlocks = NULL;
-    cfgCount = 0;
+    free(cfgBlock.entries);
 }

 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def)
 {
-    size_t i, j;
+    unsigned int i;
+    char key[256];

-    if(keyName)
+    if(!keyName)
+        return def;
+
+    if(blockName && strcasecmp(blockName, "general") != 0)
+        snprintf(key, sizeof(key), "%s/%s", blockName, keyName);
+    else
    {
-        if(!blockName)
-            blockName = "general";
+        strncpy(key, keyName, sizeof(key)-1);
+        key[sizeof(key)-1] = 0;
+    }

-        for(i = 0;i < cfgCount;i++)
+    for(i = 0;i < cfgBlock.entryCount;i++)
+    {
+        if(strcasecmp(cfgBlock.entries[i].key, key) == 0)
        {
-            if(strcasecmp(cfgBlocks[i].name, blockName) != 0)
-                continue;
-
-            for(j = 0;j < cfgBlocks[i].entryCount;j++)
-            {
-                if(strcasecmp(cfgBlocks[i].entries[j].key, keyName) == 0)
-                    return cfgBlocks[i].entries[j].value;
-            }
+            TRACE("Found %s = \"%s\"\n", key, cfgBlock.entries[i].value);
+            if(cfgBlock.entries[i].value[0])
+                return cfgBlock.entries[i].value;
+            return def;
        }
    }

+    TRACE("Key %s not found\n", key);
    return def;
 }

-int GetConfigValueInt(const char *blockName, const char *keyName, int def)
+int ConfigValueExists(const char *blockName, const char *keyName)
 {
    const char *val = GetConfigValue(blockName, keyName, "");
-
-    if(!val[0]) return def;
-    return strtol(val, NULL, 0);
+    return !!val[0];
 }

-float GetConfigValueFloat(const char *blockName, const char *keyName, float def)
+int ConfigValueStr(const char *blockName, const char *keyName, const char **ret)
 {
    const char *val = GetConfigValue(blockName, keyName, "");
+    if(!val[0]) return 0;
+
+    *ret = val;
+    return 1;
+}
+
+int ConfigValueInt(const char *blockName, const char *keyName, int *ret)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+    if(!val[0]) return 0;
+
+    *ret = strtol(val, NULL, 0);
+    return 1;
+}
+
+int ConfigValueUInt(const char *blockName, const char *keyName, unsigned int *ret)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+    if(!val[0]) return 0;
+
+    *ret = strtoul(val, NULL, 0);
+    return 1;
+}
+
+int ConfigValueFloat(const char *blockName, const char *keyName, float *ret)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+    if(!val[0]) return 0;

-    if(!val[0]) return def;
 #ifdef HAVE_STRTOF
-    return strtof(val, NULL);
+    *ret = strtof(val, NULL);
 #else
-    return (float)strtod(val, NULL);
+    *ret = (float)strtod(val, NULL);
 #endif
+    return 1;
+}
+
+int GetConfigValueBool(const char *blockName, const char *keyName, int def)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+
+    if(!val[0]) return !!def;
+    return (strcasecmp(val, "true") == 0 || strcasecmp(val, "yes") == 0 ||
+            strcasecmp(val, "on") == 0 || atoi(val) != 0);
 }
@@ -18,12 +18,14 @@
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

+#include "config.h"
+
 #include <string.h>
 #include <stdlib.h>

-#include "config.h"
-
 #include "alMain.h"
+#include "threads.h"
+#include "compat.h"


 struct RingBuffer {
@@ -34,26 +36,23 @@ struct RingBuffer {
    ALint read_pos;
    ALint write_pos;

-    CRITICAL_SECTION cs;
+    almtx_t mtx;
 };


 RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length)
 {
-    RingBuffer *ring = calloc(1, sizeof(*ring));
+    RingBuffer *ring = calloc(1, sizeof(*ring) + ((length+1) * frame_size));
    if(ring)
    {
+        ring->mem = (ALubyte*)(ring+1);
+
        ring->frame_size = frame_size;
        ring->length = length+1;
-        ring->write_pos = 1;
-        ring->mem = malloc((length+1)*frame_size);
-        if(!ring->mem)
-        {
-            free(ring);
-            ring = NULL;
-        }
+        ring->read_pos = 0;
+        ring->write_pos = 0;

-        InitializeCriticalSection(&ring->cs);
+        almtx_init(&ring->mtx, almtx_plain);
    }
    return ring;
 }
@@ -62,46 +61,59 @@ void DestroyRingBuffer(RingBuffer *ring)
 {
    if(ring)
    {
-        DeleteCriticalSection(&ring->cs);
-        free(ring->mem);
+        almtx_destroy(&ring->mtx);
        free(ring);
    }
 }

 ALsizei RingBufferSize(RingBuffer *ring)
 {
-    return (ring->write_pos-ring->read_pos-1+ring->length) % ring->length;
+    ALsizei s;
+
+    almtx_lock(&ring->mtx);
+    s = (ring->write_pos-ring->read_pos+ring->length) % ring->length;
+    almtx_unlock(&ring->mtx);
+
+    return s;
 }

 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len)
 {
-    int remain = ring->length - ring->write_pos;
+    int remain;

-    EnterCriticalSection(&ring->cs);
+    almtx_lock(&ring->mtx);

-    if((ring->read_pos-ring->write_pos+ring->length)%ring->length < len)
-        ring->read_pos = (ring->write_pos+len) % ring->length;
+    remain = (ring->read_pos-ring->write_pos-1+ring->length) % ring->length;
+    if(remain < len) len = remain;

-    if(remain < len)
+    if(len > 0)
    {
-        memcpy(ring->mem+(ring->write_pos*ring->frame_size), data, remain*ring->frame_size);
-        memcpy(ring->mem, data+(remain*ring->frame_size), (len-remain)*ring->frame_size);
+        remain = ring->length - ring->write_pos;
+        if(remain < len)
+        {
+            memcpy(ring->mem+(ring->write_pos*ring->frame_size), data,
+                   remain*ring->frame_size);
+            memcpy(ring->mem, data+(remain*ring->frame_size),
+                   (len-remain)*ring->frame_size);
+        }
+        else
+            memcpy(ring->mem+(ring->write_pos*ring->frame_size), data,
+                   len*ring->frame_size);
+
+        ring->write_pos += len;
+        ring->write_pos %= ring->length;
    }
-    else
-        memcpy(ring->mem+(ring->write_pos*ring->frame_size), data, len*ring->frame_size);

-    ring->write_pos += len;
-    ring->write_pos %= ring->length;
-
-    LeaveCriticalSection(&ring->cs);
+    almtx_unlock(&ring->mtx);
 }

 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len)
 {
-    int remain = ring->length - ring->read_pos;
+    int remain;

-    EnterCriticalSection(&ring->cs);
+    almtx_lock(&ring->mtx);

+    remain = ring->length - ring->read_pos;
    if(remain < len)
    {
        memcpy(data, ring->mem+(ring->read_pos*ring->frame_size), remain*ring->frame_size);
@@ -113,6 +125,5 @@ void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len)
    ring->read_pos += len;
    ring->read_pos %= ring->length;

-    LeaveCriticalSection(&ring->cs);
+    almtx_unlock(&ring->mtx);
 }
-
@@ -1,125 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#include <stdlib.h>
-
-#include "alMain.h"
-#include "alThunk.h"
-
-
-#ifdef _WIN32
-
-#include <windows.h>
-
-typedef struct {
-    ALuint (*func)(ALvoid*);
-    ALvoid *ptr;
-    HANDLE thread;
-} ThreadInfo;
-
-static DWORD CALLBACK StarterFunc(void *ptr)
-{
-    ThreadInfo *inf = (ThreadInfo*)ptr;
-    ALint ret;
-
-    ret = inf->func(inf->ptr);
-    ExitThread((DWORD)ret);
-
-    return (DWORD)ret;
-}
-
-ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr)
-{
-    ThreadInfo *inf = malloc(sizeof(ThreadInfo));
-    if(!inf) return 0;
-
-    inf->func = func;
-    inf->ptr = ptr;
-
-    inf->thread = CreateThread(NULL, 0, StarterFunc, inf, 0, NULL);
-    if(!inf->thread)
-    {
-        free(inf);
-        return NULL;
-    }
-
-    return inf;
-}
-
-ALuint StopThread(ALvoid *thread)
-{
-    ThreadInfo *inf = thread;
-    DWORD ret = 0;
-
-    WaitForSingleObject(inf->thread, INFINITE);
-    GetExitCodeThread(inf->thread, &ret);
-
-    free(inf);
-
-    return (ALuint)ret;
-}
-
-#else
-
-#include <pthread.h>
-
-typedef struct {
-    ALuint (*func)(ALvoid*);
-    ALvoid *ptr;
-    pthread_t thread;
-} ThreadInfo;
-
-static void *StarterFunc(void *ptr)
-{
-    ThreadInfo *inf = (ThreadInfo*)ptr;
-    ALint ret;
-
-    ret = inf->func(inf->ptr);
-    return (void*)ret;
-}
-
-ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr)
-{
-    ThreadInfo *inf = malloc(sizeof(ThreadInfo));
-    if(!inf) return 0;
-
-    inf->func = func;
-    inf->ptr = ptr;
-    if(pthread_create(&inf->thread, NULL, StarterFunc, inf) != 0)
-    {
-        free(inf);
-        return NULL;
-    }
-
-    return inf;
-}
-
-ALuint StopThread(ALvoid *thread)
-{
-    ThreadInfo *inf = thread;
-    void *ret;
-
-    pthread_join(inf->thread, &ret);
-    free(inf);
-
-    return (ALuint)ret;
-}
-
-#endif
@@ -1,912 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#include "config.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <memory.h>
-#ifdef HAVE_DLFCN_H
-#include <dlfcn.h>
-#endif
-#include "alMain.h"
-#include "AL/al.h"
-#include "AL/alc.h"
-
-#include <alsa/asoundlib.h>
-
-
-typedef struct {
-    snd_pcm_t *pcmHandle;
-    snd_pcm_format_t format;
-
-    ALvoid *buffer;
-    ALsizei size;
-
-    int killNow;
-    ALvoid *thread;
-} alsa_data;
-
-typedef struct {
-    ALCchar *name;
-    int card, dev;
-} DevMap;
-
-static void *alsa_handle;
-#define MAKE_FUNC(f) static typeof(f) * p##f
-MAKE_FUNC(snd_strerror);
-MAKE_FUNC(snd_pcm_open);
-MAKE_FUNC(snd_pcm_close);
-MAKE_FUNC(snd_pcm_nonblock);
-MAKE_FUNC(snd_pcm_frames_to_bytes);
-MAKE_FUNC(snd_pcm_hw_params_malloc);
-MAKE_FUNC(snd_pcm_hw_params_free);
-MAKE_FUNC(snd_pcm_hw_params_any);
-MAKE_FUNC(snd_pcm_hw_params_set_access);
-MAKE_FUNC(snd_pcm_hw_params_set_format);
-MAKE_FUNC(snd_pcm_hw_params_set_channels);
-MAKE_FUNC(snd_pcm_hw_params_set_periods_near);
-MAKE_FUNC(snd_pcm_hw_params_set_rate_near);
-MAKE_FUNC(snd_pcm_hw_params_set_rate);
-MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near);
-MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min);
-MAKE_FUNC(snd_pcm_hw_params_get_access);
-MAKE_FUNC(snd_pcm_hw_params);
-MAKE_FUNC(snd_pcm_prepare);
-MAKE_FUNC(snd_pcm_start);
-MAKE_FUNC(snd_pcm_resume);
-MAKE_FUNC(snd_pcm_state);
-MAKE_FUNC(snd_pcm_avail_update);
-MAKE_FUNC(snd_pcm_areas_silence);
-MAKE_FUNC(snd_pcm_mmap_begin);
-MAKE_FUNC(snd_pcm_mmap_commit);
-MAKE_FUNC(snd_pcm_writei);
-MAKE_FUNC(snd_pcm_drain);
-MAKE_FUNC(snd_pcm_info_malloc);
-MAKE_FUNC(snd_pcm_info_free);
-MAKE_FUNC(snd_pcm_info_set_device);
-MAKE_FUNC(snd_pcm_info_set_subdevice);
-MAKE_FUNC(snd_pcm_info_set_stream);
-MAKE_FUNC(snd_pcm_info_get_name);
-MAKE_FUNC(snd_ctl_pcm_next_device);
-MAKE_FUNC(snd_ctl_pcm_info);
-MAKE_FUNC(snd_ctl_open);
-MAKE_FUNC(snd_ctl_close);
-MAKE_FUNC(snd_ctl_card_info_malloc);
-MAKE_FUNC(snd_ctl_card_info_free);
-MAKE_FUNC(snd_ctl_card_info);
-MAKE_FUNC(snd_ctl_card_info_get_name);
-MAKE_FUNC(snd_card_next);
-#undef MAKE_FUNC
-
-#define MAX_DEVICES 16
-#define MAX_ALL_DEVICES 32
-
-static DevMap allDevNameMap[MAX_ALL_DEVICES];
-static ALCchar *alsaDeviceList[MAX_DEVICES];
-static ALCchar *alsaCaptureDeviceList[MAX_DEVICES];
-
-static int xrun_recovery(snd_pcm_t *handle, int err)
-{
-    if (err == -EPIPE)
-    {    /* under-run */
-        err = psnd_pcm_prepare(handle);
-        if(err >= 0)
-            err = psnd_pcm_start(handle);
-        if (err < 0)
-            AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
-    }
-    else if (err == -ESTRPIPE)
-    {
-        while ((err = psnd_pcm_resume(handle)) == -EAGAIN)
-            usleep(1);       /* wait until the suspend flag is released */
-        if (err < 0)
-        {
-            err = psnd_pcm_prepare(handle);
-            if(err >= 0)
-                err = psnd_pcm_start(handle);
-            if (err < 0)
-                AL_PRINT("prepare failed: %s\n", psnd_strerror(err));
-        }
-    }
-    return err;
-}
-
-
-static ALuint ALSAProc(ALvoid *ptr)
-{
-    ALCdevice *pDevice = (ALCdevice*)ptr;
-    alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    const snd_pcm_channel_area_t *areas = NULL;
-    snd_pcm_sframes_t avail, commitres;
-    snd_pcm_uframes_t offset, frames;
-    char *WritePtr;
-    int WriteCnt;
-    int err;
-
-    while(!data->killNow)
-    {
-        snd_pcm_state_t state = psnd_pcm_state(data->pcmHandle);
-        if(state == SND_PCM_STATE_XRUN)
-        {
-            err = xrun_recovery(data->pcmHandle, -EPIPE);
-            if (err < 0)
-            {
-                AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
-                break;
-            }
-        }
-        else if (state == SND_PCM_STATE_SUSPENDED)
-        {
-            err = xrun_recovery(data->pcmHandle, -ESTRPIPE);
-            if (err < 0)
-            {
-                AL_PRINT("SUSPEND recovery failed: %s\n", psnd_strerror(err));
-                break;
-            }
-        }
-
-        avail = psnd_pcm_avail_update(data->pcmHandle);
-        if(avail < 0)
-        {
-            err = xrun_recovery(data->pcmHandle, avail);
-            if (err < 0)
-            {
-                AL_PRINT("available update failed: %s\n", psnd_strerror(err));
-                break;
-            }
-        }
-
-        // make sure there's frames to process
-        if(avail == 0)
-        {
-            usleep(1000);
-            continue;
-        }
-
-        // it is possible that contiguous areas are smaller, thus we use a loop
-        while (avail > 0)
-        {
-            frames = avail;
-
-            err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
-            if (err < 0)
-            {
-                err = xrun_recovery(data->pcmHandle, err);
-                if (err < 0)
-                    AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
-                break;
-            }
-
-            SuspendContext(NULL);
-            WritePtr = (char*)areas->addr + (offset * areas->step / 8);
-            WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
-            aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
-            ProcessContext(NULL);
-
-            commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
-            if (commitres < 0 || (commitres-frames) != 0)
-            {
-                AL_PRINT("mmap commit error: %s\n",
-                         psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
-                break;
-            }
-
-            avail -= frames;
-        }
-    }
-
-    return 0;
-}
-
-static ALuint ALSANoMMapProc(ALvoid *ptr)
-{
-    ALCdevice *pDevice = (ALCdevice*)ptr;
-    alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    snd_pcm_sframes_t avail;
-    char *WritePtr;
-
-    while(!data->killNow)
-    {
-        SuspendContext(NULL);
-        aluMixData(pDevice->Context, data->buffer, data->size, pDevice->Format);
-        ProcessContext(NULL);
-
-        WritePtr = data->buffer;
-        avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
-        while(avail > 0)
-        {
-            int ret = psnd_pcm_writei(data->pcmHandle, WritePtr, avail);
-            switch (ret)
-            {
-            case -EAGAIN:
-                continue;
-            case -ESTRPIPE:
-                do {
-                    ret = psnd_pcm_resume(data->pcmHandle);
-                } while(ret == -EAGAIN);
-                break;
-            case -EPIPE:
-                break;
-            default:
-                if (ret >= 0)
-                {
-                    WritePtr += psnd_pcm_frames_to_bytes(data->pcmHandle, ret);
-                    avail -= ret;
-                }
-                break;
-            }
-            if (ret < 0)
-            {
-                ret = psnd_pcm_prepare(data->pcmHandle);
-                if(ret < 0)
-                    break;
-            }
-        }
-    }
-
-    return 0;
-}
-
-static void fill_silence(snd_pcm_t *pcmHandle, snd_pcm_format_t alsaFormat, int channels)
-{
-    const snd_pcm_channel_area_t *areas = NULL;
-    snd_pcm_sframes_t avail, commitres;
-    snd_pcm_uframes_t offset, frames;
-    int err;
-
-    avail = psnd_pcm_avail_update(pcmHandle);
-    if(avail < 0)
-    {
-        err = xrun_recovery(pcmHandle, avail);
-        if (err < 0)
-        {
-            AL_PRINT("available update failed: %s\n", psnd_strerror(err));
-            return;
-        }
-    }
-
-    // it is possible that contiguous areas are smaller, thus we use a loop
-    while (avail > 0)
-    {
-        frames = avail;
-
-        err = psnd_pcm_mmap_begin(pcmHandle, &areas, &offset, &frames);
-        if (err < 0)
-        {
-            err = xrun_recovery(pcmHandle, err);
-            if (err < 0)
-            {
-                AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
-                break;
-            }
-            continue;
-        }
-
-        psnd_pcm_areas_silence(areas, offset, channels, frames, alsaFormat);
-
-        commitres = psnd_pcm_mmap_commit(pcmHandle, offset, frames);
-        if (commitres < 0 || (commitres-frames) != 0)
-        {
-            AL_PRINT("mmap commit error: %s\n",
-                     psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
-            break;
-        }
-
-        avail -= frames;
-    }
-}
-
-static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
-{
-    snd_pcm_uframes_t bufferSizeInFrames;
-    snd_pcm_hw_params_t *p = NULL;
-    snd_pcm_access_t access;
-    unsigned int periods;
-    alsa_data *data;
-    char driver[64];
-    char *err;
-    int i;
-
-    strncpy(driver, GetConfigValue("alsa", "device", "default"), sizeof(driver)-1);
-    driver[sizeof(driver)-1] = 0;
-    if(deviceName)
-    {
-        size_t idx;
-
-        for(idx = 0;idx < MAX_ALL_DEVICES;idx++)
-        {
-            if(allDevNameMap[idx].name &&
-               strcmp(deviceName, allDevNameMap[idx].name) == 0)
-            {
-                device->szDeviceName = allDevNameMap[idx].name;
-                if(idx > 0)
-                    sprintf(driver, "hw:%d,%d", allDevNameMap[idx].card, allDevNameMap[idx].dev);
-                goto open_alsa;
-            }
-        }
-        for(idx = 0;idx < MAX_DEVICES;idx++)
-        {
-            if(alsaDeviceList[idx] &&
-               strcmp(deviceName, alsaDeviceList[idx]) == 0)
-            {
-                device->szDeviceName = alsaDeviceList[idx];
-                if(idx > 0)
-                    sprintf(driver, "hw:%zd,0", idx-1);
-                goto open_alsa;
-            }
-        }
-        return ALC_FALSE;
-    }
-    else
-        device->szDeviceName = alsaDeviceList[0];
-
-open_alsa:
-    data = (alsa_data*)calloc(1, sizeof(alsa_data));
-
-    i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
-    if(i < 0)
-    {
-        usleep(200000);
-        i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
-    }
-    if(i >= 0)
-    {
-        i = psnd_pcm_nonblock(data->pcmHandle, 0);
-        if(i < 0)
-            psnd_pcm_close(data->pcmHandle);
-    }
-    if(i < 0)
-    {
-        free(data);
-        AL_PRINT("Could not open playback device '%s': %s\n", driver, psnd_strerror(i));
-        return ALC_FALSE;
-    }
-
-    switch(aluBytesFromFormat(device->Format))
-    {
-        case 1:
-            data->format = SND_PCM_FORMAT_U8;
-            break;
-        case 2:
-            data->format = SND_PCM_FORMAT_S16;
-            break;
-        default:
-            data->format = SND_PCM_FORMAT_UNKNOWN;
-            AL_PRINT("Unknown format?! %x\n", device->Format);
-    }
-
-    periods = GetConfigValueInt("alsa", "periods", 4);
-    if((int)periods <= 0)
-        periods = 4;
-    bufferSizeInFrames = device->UpdateFreq / periods;
-
-    psnd_pcm_hw_params_malloc(&p);
-#define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
-    /* start with the largest configuration space possible */
-    if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
-         /* set interleaved access */
-         (ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access") ||
-          ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED), "set access")) &&
-         /* set format (implicitly sets sample bits) */
-         ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format), "set format") &&
-         /* set channels (implicitly sets frame bits) */
-         ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, device->Channels), "set channels") &&
-         /* set periods (implicitly constrains period/buffer parameters) */
-         ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near") &&
-         /* set rate (implicitly constrains period/buffer parameters) */
-         ok(psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &device->Frequency, NULL), "set rate near") &&
-         /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
-         ok(psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size near") &&
-         /* install and prepare hardware configuration */
-         ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
-    {
-        AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
-        psnd_pcm_hw_params_free(p);
-        psnd_pcm_close(data->pcmHandle);
-        free(data);
-        return ALC_FALSE;
-    }
-#undef ok
-
-    if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
-    {
-        AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
-        psnd_pcm_hw_params_free(p);
-        psnd_pcm_close(data->pcmHandle);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    psnd_pcm_hw_params_free(p);
-
-    device->MaxNoOfSources = 256;
-    device->UpdateFreq = bufferSizeInFrames;
-
-    data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, device->UpdateFreq);
-    if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
-    {
-        data->buffer = malloc(data->size);
-        if(!data->buffer)
-        {
-            AL_PRINT("buffer malloc failed\n");
-            psnd_pcm_close(data->pcmHandle);
-            free(data);
-            return ALC_FALSE;
-        }
-    }
-    else
-    {
-        i = psnd_pcm_prepare(data->pcmHandle);
-        if(i < 0)
-        {
-            AL_PRINT("prepare error: %s\n", psnd_strerror(i));
-            psnd_pcm_close(data->pcmHandle);
-            free(data->buffer);
-            free(data);
-            return ALC_FALSE;
-        }
-
-        fill_silence(data->pcmHandle, data->format, device->Channels);
-
-        i = psnd_pcm_start(data->pcmHandle);
-        if(i < 0)
-        {
-            AL_PRINT("start error: %s\n", psnd_strerror(i));
-            psnd_pcm_close(data->pcmHandle);
-            free(data->buffer);
-            free(data);
-            return ALC_FALSE;
-        }
-    }
-
-    device->ExtraData = data;
-    if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
-        data->thread = StartThread(ALSANoMMapProc, device);
-    else
-        data->thread = StartThread(ALSAProc, device);
-    if(data->thread == NULL)
-    {
-        psnd_pcm_close(data->pcmHandle);
-        device->ExtraData = NULL;
-        free(data->buffer);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    return ALC_TRUE;
-}
-
-static void alsa_close_playback(ALCdevice *device)
-{
-    alsa_data *data = (alsa_data*)device->ExtraData;
-    data->killNow = 1;
-    StopThread(data->thread);
-    psnd_pcm_close(data->pcmHandle);
-
-    free(data->buffer);
-    free(data);
-    device->ExtraData = NULL;
-}
-
-
-static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
-{
-    snd_pcm_format_t alsaFormat;
-    snd_pcm_hw_params_t *p;
-    unsigned int periods = 4;
-    snd_pcm_uframes_t bufferSizeInFrames;
-    alsa_data *data;
-    char driver[64];
-    char *err;
-    int i;
-
-    strncpy(driver, GetConfigValue("alsa", "capture", "default"), sizeof(driver)-1);
-    driver[sizeof(driver)-1] = 0;
-    if(deviceName)
-    {
-        size_t idx;
-
-        for(idx = 0;idx < MAX_DEVICES;idx++)
-        {
-            if(alsaCaptureDeviceList[idx] &&
-               strcmp(deviceName, alsaCaptureDeviceList[idx]) == 0)
-            {
-                pDevice->szDeviceName = alsaCaptureDeviceList[idx];
-                if(idx > 0)
-                    sprintf(driver, "hw:%zd,0", idx-1);
-                goto open_alsa;
-            }
-        }
-        return ALC_FALSE;
-    }
-    else
-        pDevice->szDeviceName = alsaCaptureDeviceList[0];
-
-open_alsa:
-    data = (alsa_data*)calloc(1, sizeof(alsa_data));
-
-    i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
-    if(i < 0)
-    {
-        usleep(200000);
-        i = psnd_pcm_open(&data->pcmHandle, driver, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
-    }
-    if(i >= 0)
-    {
-        i = psnd_pcm_nonblock(data->pcmHandle, 0);
-        if(i < 0)
-            psnd_pcm_close(data->pcmHandle);
-    }
-    if(i < 0)
-    {
-        free(data);
-        AL_PRINT("Could not open capture device '%s': %s\n", driver, psnd_strerror(i));
-        return ALC_FALSE;
-    }
-
-    switch(aluBytesFromFormat(format))
-    {
-        case 1:
-            alsaFormat = SND_PCM_FORMAT_U8;
-            break;
-        case 2:
-            alsaFormat = SND_PCM_FORMAT_S16;
-            break;
-        default:
-            alsaFormat = SND_PCM_FORMAT_UNKNOWN;
-            AL_PRINT("Unknown format?! %x\n", format);
-    }
-
-    bufferSizeInFrames = SampleSize / periods;
-
-    psnd_pcm_hw_params_malloc(&p);
-#define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
-    /* start with the largest configuration space possible */
-    if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
-         /* set interleaved access */
-         ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access") &&
-         /* set format (implicitly sets sample bits) */
-         ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, alsaFormat), "set format") &&
-         /* set channels (implicitly sets frame bits) */
-         ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, pDevice->Channels), "set channels") &&
-         /* set periods (implicitly constrains period/buffer parameters) */
-         ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near") &&
-         /* set rate (implicitly constrains period/buffer parameters) */
-         ok(psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0), "set rate") &&
-         /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
-         ok(psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size min") &&
-         /* install and prepare hardware configuration */
-         ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
-    {
-        AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
-        psnd_pcm_hw_params_free(p);
-        psnd_pcm_close(data->pcmHandle);
-        free(data);
-        return ALC_FALSE;
-    }
-#undef ok
-    psnd_pcm_hw_params_free(p);
-
-    i = psnd_pcm_prepare(data->pcmHandle);
-    if(i < 0)
-    {
-        AL_PRINT("prepare error: %s\n", psnd_strerror(i));
-        psnd_pcm_close(data->pcmHandle);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    pDevice->ExtraData = data;
-    return ALC_TRUE;
-}
-
-static void alsa_close_capture(ALCdevice *pDevice)
-{
-    alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    psnd_pcm_close(data->pcmHandle);
-
-    free(data);
-    pDevice->ExtraData = NULL;
-}
-
-static void alsa_start_capture(ALCdevice *pDevice)
-{
-    alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    psnd_pcm_start(data->pcmHandle);
-}
-
-static void alsa_stop_capture(ALCdevice *pDevice)
-{
-    alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    psnd_pcm_drain(data->pcmHandle);
-}
-
-static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
-{
-    alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    const snd_pcm_channel_area_t *areas = NULL;
-    snd_pcm_sframes_t frames, commitres;
-    snd_pcm_uframes_t size, offset;
-    int err;
-
-    frames = psnd_pcm_avail_update(data->pcmHandle);
-    if(frames < 0)
-    {
-        err = xrun_recovery(data->pcmHandle, frames);
-        if (err < 0)
-            AL_PRINT("available update failed: %s\n", psnd_strerror(err));
-        else
-            frames = psnd_pcm_avail_update(data->pcmHandle);
-    }
-    if (frames < (snd_pcm_sframes_t)lSamples)
-    {
-        SetALCError(ALC_INVALID_VALUE);
-        return;
-    }
-
-    // it is possible that contiguous areas are smaller, thus we use a loop
-    while (lSamples > 0)
-    {
-        char *Pointer;
-        int Count;
-
-        size = lSamples;
-        err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &size);
-        if (err < 0)
-        {
-            err = xrun_recovery(data->pcmHandle, err);
-            if (err < 0)
-            {
-                AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
-                break;
-            }
-            continue;
-        }
-
-        Pointer = (char*)areas->addr + (offset * areas->step / 8);
-        Count = size * pDevice->FrameSize;
-
-        memcpy(pBuffer, Pointer, Count);
-        pBuffer = (char*)pBuffer + Count;
-
-        commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, size);
-        if (commitres < 0 || (commitres-size) != 0)
-        {
-           AL_PRINT("mmap commit error: %s\n",
-                    psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
-           break;
-        }
-
-        lSamples -= size;
-    }
-}
-
-static ALCuint alsa_available_samples(ALCdevice *pDevice)
-{
-    alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    snd_pcm_sframes_t frames = psnd_pcm_avail_update(data->pcmHandle);
-    if(frames < 0)
-    {
-        int err = xrun_recovery(data->pcmHandle, frames);
-        if (err < 0)
-            AL_PRINT("available update failed: %s\n", psnd_strerror(err));
-        else
-            frames = psnd_pcm_avail_update(data->pcmHandle);
-        if(frames < 0) /* ew.. */
-            SetALCError(ALC_INVALID_DEVICE);
-    }
-    return max(frames, 0);
-}
-
-
-BackendFuncs alsa_funcs = {
-    alsa_open_playback,
-    alsa_close_playback,
-    alsa_open_capture,
-    alsa_close_capture,
-    alsa_start_capture,
-    alsa_stop_capture,
-    alsa_capture_samples,
-    alsa_available_samples
-};
-
-void alc_alsa_init(BackendFuncs *func_list)
-{
-    snd_ctl_t *handle;
-    int card, err, dev, idx = 1;
-    snd_ctl_card_info_t *info;
-    snd_pcm_info_t *pcminfo;
-    snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
-    char name[128];
-    char *str;
-
-    *func_list = alsa_funcs;
-
-#ifdef HAVE_DLFCN_H
-    alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
-    if(!alsa_handle)
-        return;
-    dlerror();
-
-#define LOAD_FUNC(f) do { \
-    p##f = (typeof(f)*)dlsym(alsa_handle, #f); \
-    if((str=dlerror()) != NULL) \
-    { \
-        dlclose(alsa_handle); \
-        alsa_handle = NULL; \
-        AL_PRINT("Could not load %s from libasound.so.2: %s\n", #f, str); \
-        return; \
-    } \
-} while(0)
-#else
-    str = NULL;
-    alsa_handle = NULL;
-#define LOAD_FUNC(f) p##f = f
-#endif
-
-LOAD_FUNC(snd_strerror);
-LOAD_FUNC(snd_pcm_open);
-LOAD_FUNC(snd_pcm_close);
-LOAD_FUNC(snd_pcm_nonblock);
-LOAD_FUNC(snd_pcm_frames_to_bytes);
-LOAD_FUNC(snd_pcm_hw_params_malloc);
-LOAD_FUNC(snd_pcm_hw_params_free);
-LOAD_FUNC(snd_pcm_hw_params_any);
-LOAD_FUNC(snd_pcm_hw_params_set_access);
-LOAD_FUNC(snd_pcm_hw_params_set_format);
-LOAD_FUNC(snd_pcm_hw_params_set_channels);
-LOAD_FUNC(snd_pcm_hw_params_set_periods_near);
-LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
-LOAD_FUNC(snd_pcm_hw_params_set_rate);
-LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
-LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
-LOAD_FUNC(snd_pcm_hw_params_get_access);
-LOAD_FUNC(snd_pcm_hw_params);
-LOAD_FUNC(snd_pcm_prepare);
-LOAD_FUNC(snd_pcm_start);
-LOAD_FUNC(snd_pcm_resume);
-LOAD_FUNC(snd_pcm_state);
-LOAD_FUNC(snd_pcm_avail_update);
-LOAD_FUNC(snd_pcm_areas_silence);
-LOAD_FUNC(snd_pcm_mmap_begin);
-LOAD_FUNC(snd_pcm_mmap_commit);
-LOAD_FUNC(snd_pcm_writei);
-LOAD_FUNC(snd_pcm_drain);
-
-LOAD_FUNC(snd_pcm_info_malloc);
-LOAD_FUNC(snd_pcm_info_free);
-LOAD_FUNC(snd_pcm_info_set_device);
-LOAD_FUNC(snd_pcm_info_set_subdevice);
-LOAD_FUNC(snd_pcm_info_set_stream);
-LOAD_FUNC(snd_pcm_info_get_name);
-LOAD_FUNC(snd_ctl_pcm_next_device);
-LOAD_FUNC(snd_ctl_pcm_info);
-LOAD_FUNC(snd_ctl_open);
-LOAD_FUNC(snd_ctl_close);
-LOAD_FUNC(snd_ctl_card_info_malloc);
-LOAD_FUNC(snd_ctl_card_info_free);
-LOAD_FUNC(snd_ctl_card_info);
-LOAD_FUNC(snd_ctl_card_info_get_name);
-LOAD_FUNC(snd_card_next);
-
-#undef LOAD_FUNC
-
-    psnd_ctl_card_info_malloc(&info);
-    psnd_pcm_info_malloc(&pcminfo);
-
-    card = -1;
-    if(psnd_card_next(&card) < 0 || card < 0)
-        AL_PRINT("no playback cards found...\n");
-    else
-    {
-        alsaDeviceList[0] = AppendDeviceList("ALSA Software on default");
-        allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
-    }
-
-    while (card >= 0) {
-        sprintf(name, "hw:%d", card);
-        if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
-            AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
-            goto next_card;
-        }
-        if ((err = psnd_ctl_card_info(handle, info)) < 0) {
-            AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
-            psnd_ctl_close(handle);
-            goto next_card;
-        }
-        if(card < MAX_DEVICES-1) {
-            snprintf(name, sizeof(name), "ALSA Software on %s",
-                     psnd_ctl_card_info_get_name(info));
-            alsaDeviceList[card+1] = AppendDeviceList(name);
-        }
-
-        dev = -1;
-        while (idx < MAX_ALL_DEVICES) {
-            const char *cname, *dname;
-
-            if (psnd_ctl_pcm_next_device(handle, &dev)<0)
-                AL_PRINT("snd_ctl_pcm_next_device failed\n");
-            if (dev < 0)
-                break;
-            psnd_pcm_info_set_device(pcminfo, dev);
-            psnd_pcm_info_set_subdevice(pcminfo, 0);
-            psnd_pcm_info_set_stream(pcminfo, stream);
-            if ((err = psnd_ctl_pcm_info(handle, pcminfo)) < 0) {
-                if (err != -ENOENT)
-                    AL_PRINT("control digital audio info (%i): %s\n", card, psnd_strerror(err));
-                continue;
-            }
-
-            cname = psnd_ctl_card_info_get_name(info);
-            dname = psnd_pcm_info_get_name(pcminfo);
-            snprintf(name, sizeof(name), "ALSA Software on %s [%s]",
-                     cname, dname);
-            allDevNameMap[idx].name = AppendAllDeviceList(name);
-            allDevNameMap[idx].card = card;
-            allDevNameMap[idx].dev = dev;
-            idx++;
-        }
-        psnd_ctl_close(handle);
-next_card:
-        if(psnd_card_next(&card) < 0) {
-            AL_PRINT("snd_card_next failed\n");
-            break;
-        }
-    }
-
-
-    stream = SND_PCM_STREAM_CAPTURE;
-
-    card = -1;
-    if(psnd_card_next(&card) < 0 || card < 0) {
-        AL_PRINT("no capture cards found...\n");
-        psnd_pcm_info_free(pcminfo);
-        psnd_ctl_card_info_free(info);
-        return;
-    }
-
-    alsaCaptureDeviceList[0] = AppendCaptureDeviceList("ALSA Capture on default");
-
-    while (card >= 0) {
-        sprintf(name, "hw:%d", card);
-        handle = NULL;
-        if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
-            AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
-        }
-        if (err >= 0 && (err = psnd_ctl_card_info(handle, info)) < 0) {
-            AL_PRINT("control hardware info (%i): %s\n", card, psnd_strerror(err));
-            psnd_ctl_close(handle);
-        }
-        else if (err >= 0 && card < MAX_DEVICES-1)
-        {
-            snprintf(name, sizeof(name), "ALSA Capture on %s",
-                     psnd_ctl_card_info_get_name(info));
-            alsaCaptureDeviceList[card+1] = AppendCaptureDeviceList(name);
-        }
-        if(handle) psnd_ctl_close(handle);
-        if(psnd_card_next(&card) < 0) {
-            AL_PRINT("snd_card_next failed\n");
-            break;
-        }
-    }
-    psnd_pcm_info_free(pcminfo);
-    psnd_ctl_card_info_free(info);
-}
@@ -0,0 +1,45 @@
+#ifndef ALSTRING_H
+#define ALSTRING_H
+
+#include <string.h>
+
+#include "vector.h"
+
+
+typedef char al_string_char_type;
+TYPEDEF_VECTOR(al_string_char_type, al_string)
+
+inline void al_string_deinit(al_string *str)
+{ VECTOR_DEINIT(*str); }
+#define AL_STRING_INIT(_x)       do { (_x) = (al_string)NULL; } while(0)
+#define AL_STRING_INIT_STATIC()  ((al_string)NULL)
+#define AL_STRING_DEINIT(_x)     al_string_deinit(&(_x))
+
+inline ALsizei al_string_length(const_al_string str)
+{ return VECTOR_SIZE(str); }
+
+inline ALboolean al_string_empty(const_al_string str)
+{ return al_string_length(str) == 0; }
+
+inline const al_string_char_type *al_string_get_cstr(const_al_string str)
+{ return str ? &VECTOR_FRONT(str) : ""; }
+
+void al_string_clear(al_string *str);
+
+int al_string_cmp(const_al_string str1, const_al_string str2);
+int al_string_cmp_cstr(const_al_string str1, const al_string_char_type *str2);
+
+void al_string_copy(al_string *str, const_al_string from);
+void al_string_copy_cstr(al_string *str, const al_string_char_type *from);
+
+void al_string_append_char(al_string *str, const al_string_char_type c);
+void al_string_append_cstr(al_string *str, const al_string_char_type *from);
+void al_string_append_range(al_string *str, const al_string_char_type *from, const al_string_char_type *to);
+
+#ifdef _WIN32
+#include <wchar.h>
+/* Windows-only methods to deal with WideChar strings. */
+void al_string_copy_wcstr(al_string *str, const wchar_t *from);
+#endif
+
+#endif /* ALSTRING_H */
@@ -0,0 +1,232 @@
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "alMain.h"
+
+#include "backends/base.h"
+
+
+/* Base ALCbackend method implementations. */
+void ALCbackend_Construct(ALCbackend *self, ALCdevice *device)
+{
+    int ret;
+    self->mDevice = device;
+    ret = almtx_init(&self->mMutex, almtx_recursive);
+    assert(ret == althrd_success);
+}
+
+void ALCbackend_Destruct(ALCbackend *self)
+{
+    almtx_destroy(&self->mMutex);
+}
+
+ALCboolean ALCbackend_reset(ALCbackend* UNUSED(self))
+{
+    return ALC_FALSE;
+}
+
+ALCenum ALCbackend_captureSamples(ALCbackend* UNUSED(self), void* UNUSED(buffer), ALCuint UNUSED(samples))
+{
+    return ALC_INVALID_DEVICE;
+}
+
+ALCuint ALCbackend_availableSamples(ALCbackend* UNUSED(self))
+{
+    return 0;
+}
+
+ALint64 ALCbackend_getLatency(ALCbackend* UNUSED(self))
+{
+    return 0;
+}
+
+void ALCbackend_lock(ALCbackend *self)
+{
+    int ret = almtx_lock(&self->mMutex);
+    assert(ret == althrd_success);
+}
+
+void ALCbackend_unlock(ALCbackend *self)
+{
+    int ret = almtx_unlock(&self->mMutex);
+    assert(ret == althrd_success);
+}
+
+
+/* Base ALCbackendFactory method implementations. */
+void ALCbackendFactory_deinit(ALCbackendFactory* UNUSED(self))
+{
+}
+
+
+/* Wrappers to use an old-style backend with the new interface. */
+typedef struct PlaybackWrapper {
+    DERIVE_FROM_TYPE(ALCbackend);
+
+    const BackendFuncs *Funcs;
+} PlaybackWrapper;
+
+static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device, const BackendFuncs *funcs);
+static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, Destruct)
+static ALCenum PlaybackWrapper_open(PlaybackWrapper *self, const ALCchar *name);
+static void PlaybackWrapper_close(PlaybackWrapper *self);
+static ALCboolean PlaybackWrapper_reset(PlaybackWrapper *self);
+static ALCboolean PlaybackWrapper_start(PlaybackWrapper *self);
+static void PlaybackWrapper_stop(PlaybackWrapper *self);
+static DECLARE_FORWARD2(PlaybackWrapper, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
+static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, ALCuint, availableSamples)
+static ALint64 PlaybackWrapper_getLatency(PlaybackWrapper *self);
+static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, lock)
+static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, unlock)
+DECLARE_DEFAULT_ALLOCATORS(PlaybackWrapper)
+DEFINE_ALCBACKEND_VTABLE(PlaybackWrapper);
+
+static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device, const BackendFuncs *funcs)
+{
+    ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
+    SET_VTABLE2(PlaybackWrapper, ALCbackend, self);
+
+    self->Funcs = funcs;
+}
+
+static ALCenum PlaybackWrapper_open(PlaybackWrapper *self, const ALCchar *name)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->OpenPlayback(device, name);
+}
+
+static void PlaybackWrapper_close(PlaybackWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    self->Funcs->ClosePlayback(device);
+}
+
+static ALCboolean PlaybackWrapper_reset(PlaybackWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->ResetPlayback(device);
+}
+
+static ALCboolean PlaybackWrapper_start(PlaybackWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->StartPlayback(device);
+}
+
+static void PlaybackWrapper_stop(PlaybackWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    self->Funcs->StopPlayback(device);
+}
+
+static ALint64 PlaybackWrapper_getLatency(PlaybackWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->GetLatency(device);
+}
+
+
+typedef struct CaptureWrapper {
+    DERIVE_FROM_TYPE(ALCbackend);
+
+    const BackendFuncs *Funcs;
+} CaptureWrapper;
+
+static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs);
+static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, Destruct)
+static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name);
+static void CaptureWrapper_close(CaptureWrapper *self);
+static DECLARE_FORWARD(CaptureWrapper, ALCbackend, ALCboolean, reset)
+static ALCboolean CaptureWrapper_start(CaptureWrapper *self);
+static void CaptureWrapper_stop(CaptureWrapper *self);
+static ALCenum CaptureWrapper_captureSamples(CaptureWrapper *self, void *buffer, ALCuint samples);
+static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self);
+static ALint64 CaptureWrapper_getLatency(CaptureWrapper *self);
+static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, lock)
+static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, unlock)
+DECLARE_DEFAULT_ALLOCATORS(CaptureWrapper)
+DEFINE_ALCBACKEND_VTABLE(CaptureWrapper);
+
+
+static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs)
+{
+    ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
+    SET_VTABLE2(CaptureWrapper, ALCbackend, self);
+
+    self->Funcs = funcs;
+}
+
+static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->OpenCapture(device, name);
+}
+
+static void CaptureWrapper_close(CaptureWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    self->Funcs->CloseCapture(device);
+}
+
+static ALCboolean CaptureWrapper_start(CaptureWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    self->Funcs->StartCapture(device);
+    return ALC_TRUE;
+}
+
+static void CaptureWrapper_stop(CaptureWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    self->Funcs->StopCapture(device);
+}
+
+static ALCenum CaptureWrapper_captureSamples(CaptureWrapper *self, void *buffer, ALCuint samples)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->CaptureSamples(device, buffer, samples);
+}
+
+static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->AvailableSamples(device);
+}
+
+static ALint64 CaptureWrapper_getLatency(CaptureWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return self->Funcs->GetLatency(device);
+}
+
+
+ALCbackend *create_backend_wrapper(ALCdevice *device, const BackendFuncs *funcs, ALCbackend_Type type)
+{
+    if(type == ALCbackend_Playback)
+    {
+        PlaybackWrapper *backend;
+
+        backend = PlaybackWrapper_New(sizeof(*backend));
+        if(!backend) return NULL;
+
+        PlaybackWrapper_Construct(backend, device, funcs);
+
+        return STATIC_CAST(ALCbackend, backend);
+    }
+
+    if(type == ALCbackend_Capture)
+    {
+        CaptureWrapper *backend;
+
+        backend = CaptureWrapper_New(sizeof(*backend));
+        if(!backend) return NULL;
+
+        CaptureWrapper_Construct(backend, device, funcs);
+
+        return STATIC_CAST(ALCbackend, backend);
+    }
+
+    return NULL;
+}
@@ -0,0 +1,133 @@
+#ifndef AL_BACKENDS_BASE_H
+#define AL_BACKENDS_BASE_H
+
+#include "alMain.h"
+#include "threads.h"
+
+
+struct ALCbackendVtable;
+
+typedef struct ALCbackend {
+    const struct ALCbackendVtable *vtbl;
+
+    ALCdevice *mDevice;
+
+    almtx_t mMutex;
+} ALCbackend;
+
+void ALCbackend_Construct(ALCbackend *self, ALCdevice *device);
+void ALCbackend_Destruct(ALCbackend *self);
+ALCboolean ALCbackend_reset(ALCbackend *self);
+ALCenum ALCbackend_captureSamples(ALCbackend *self, void *buffer, ALCuint samples);
+ALCuint ALCbackend_availableSamples(ALCbackend *self);
+ALint64 ALCbackend_getLatency(ALCbackend *self);
+void ALCbackend_lock(ALCbackend *self);
+void ALCbackend_unlock(ALCbackend *self);
+
+struct ALCbackendVtable {
+    void (*const Destruct)(ALCbackend*);
+
+    ALCenum (*const open)(ALCbackend*, const ALCchar*);
+    void (*const close)(ALCbackend*);
+
+    ALCboolean (*const reset)(ALCbackend*);
+    ALCboolean (*const start)(ALCbackend*);
+    void (*const stop)(ALCbackend*);
+
+    ALCenum (*const captureSamples)(ALCbackend*, void*, ALCuint);
+    ALCuint (*const availableSamples)(ALCbackend*);
+
+    ALint64 (*const getLatency)(ALCbackend*);
+
+    void (*const lock)(ALCbackend*);
+    void (*const unlock)(ALCbackend*);
+
+    void (*const Delete)(void*);
+};
+
+#define DEFINE_ALCBACKEND_VTABLE(T)                                           \
+DECLARE_THUNK(T, ALCbackend, void, Destruct)                                  \
+DECLARE_THUNK1(T, ALCbackend, ALCenum, open, const ALCchar*)                  \
+DECLARE_THUNK(T, ALCbackend, void, close)                                     \
+DECLARE_THUNK(T, ALCbackend, ALCboolean, reset)                               \
+DECLARE_THUNK(T, ALCbackend, ALCboolean, start)                               \
+DECLARE_THUNK(T, ALCbackend, void, stop)                                      \
+DECLARE_THUNK2(T, ALCbackend, ALCenum, captureSamples, void*, ALCuint)        \
+DECLARE_THUNK(T, ALCbackend, ALCuint, availableSamples)                       \
+DECLARE_THUNK(T, ALCbackend, ALint64, getLatency)                             \
+DECLARE_THUNK(T, ALCbackend, void, lock)                                      \
+DECLARE_THUNK(T, ALCbackend, void, unlock)                                    \
+static void T##_ALCbackend_Delete(void *ptr)                                  \
+{ T##_Delete(STATIC_UPCAST(T, ALCbackend, (ALCbackend*)ptr)); }               \
+                                                                              \
+static const struct ALCbackendVtable T##_ALCbackend_vtable = {                \
+    T##_ALCbackend_Destruct,                                                  \
+                                                                              \
+    T##_ALCbackend_open,                                                      \
+    T##_ALCbackend_close,                                                     \
+    T##_ALCbackend_reset,                                                     \
+    T##_ALCbackend_start,                                                     \
+    T##_ALCbackend_stop,                                                      \
+    T##_ALCbackend_captureSamples,                                            \
+    T##_ALCbackend_availableSamples,                                          \
+    T##_ALCbackend_getLatency,                                                \
+    T##_ALCbackend_lock,                                                      \
+    T##_ALCbackend_unlock,                                                    \
+                                                                              \
+    T##_ALCbackend_Delete,                                                    \
+}
+
+
+typedef enum ALCbackend_Type {
+    ALCbackend_Playback,
+    ALCbackend_Capture,
+    ALCbackend_Loopback
+} ALCbackend_Type;
+
+
+struct ALCbackendFactoryVtable;
+
+typedef struct ALCbackendFactory {
+    const struct ALCbackendFactoryVtable *vtbl;
+} ALCbackendFactory;
+
+void ALCbackendFactory_deinit(ALCbackendFactory *self);
+
+struct ALCbackendFactoryVtable {
+    ALCboolean (*const init)(ALCbackendFactory *self);
+    void (*const deinit)(ALCbackendFactory *self);
+
+    ALCboolean (*const querySupport)(ALCbackendFactory *self, ALCbackend_Type type);
+
+    void (*const probe)(ALCbackendFactory *self, enum DevProbe type);
+
+    ALCbackend* (*const createBackend)(ALCbackendFactory *self, ALCdevice *device, ALCbackend_Type type);
+};
+
+#define DEFINE_ALCBACKENDFACTORY_VTABLE(T)                                    \
+DECLARE_THUNK(T, ALCbackendFactory, ALCboolean, init)                         \
+DECLARE_THUNK(T, ALCbackendFactory, void, deinit)                             \
+DECLARE_THUNK1(T, ALCbackendFactory, ALCboolean, querySupport, ALCbackend_Type) \
+DECLARE_THUNK1(T, ALCbackendFactory, void, probe, enum DevProbe)              \
+DECLARE_THUNK2(T, ALCbackendFactory, ALCbackend*, createBackend, ALCdevice*, ALCbackend_Type) \
+                                                                              \
+static const struct ALCbackendFactoryVtable T##_ALCbackendFactory_vtable = {  \
+    T##_ALCbackendFactory_init,                                               \
+    T##_ALCbackendFactory_deinit,                                             \
+    T##_ALCbackendFactory_querySupport,                                       \
+    T##_ALCbackendFactory_probe,                                              \
+    T##_ALCbackendFactory_createBackend,                                      \
+}
+
+
+ALCbackendFactory *ALCpulseBackendFactory_getFactory(void);
+ALCbackendFactory *ALCalsaBackendFactory_getFactory(void);
+ALCbackendFactory *ALCossBackendFactory_getFactory(void);
+ALCbackendFactory *ALCmmdevBackendFactory_getFactory(void);
+ALCbackendFactory *ALCdsoundBackendFactory_getFactory(void);
+ALCbackendFactory *ALCnullBackendFactory_getFactory(void);
+ALCbackendFactory *ALCloopbackFactory_getFactory(void);
+
+ALCbackend *create_backend_wrapper(ALCdevice *device, const BackendFuncs *funcs, ALCbackend_Type type);
+
+#endif /* AL_BACKENDS_BASE_H */
@@ -0,0 +1,707 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <alloca.h>
+
+#include "alMain.h"
+#include "alu.h"
+
+#include <CoreServices/CoreServices.h>
+#include <unistd.h>
+#include <AudioUnit/AudioUnit.h>
+#include <AudioToolbox/AudioToolbox.h>
+
+
+typedef struct {
+    AudioUnit audioUnit;
+
+    ALuint frameSize;
+    ALdouble sampleRateRatio;              // Ratio of hardware sample rate / requested sample rate
+    AudioStreamBasicDescription format;    // This is the OpenAL format as a CoreAudio ASBD
+
+    AudioConverterRef audioConverter;      // Sample rate converter if needed
+    AudioBufferList *bufferList;           // Buffer for data coming from the input device
+    ALCvoid *resampleBuffer;               // Buffer for returned RingBuffer data when resampling
+
+    RingBuffer *ring;
+} ca_data;
+
+static const ALCchar ca_device[] = "CoreAudio Default";
+
+
+static void destroy_buffer_list(AudioBufferList* list)
+{
+    if(list)
+    {
+        UInt32 i;
+        for(i = 0;i < list->mNumberBuffers;i++)
+            free(list->mBuffers[i].mData);
+        free(list);
+    }
+}
+
+static AudioBufferList* allocate_buffer_list(UInt32 channelCount, UInt32 byteSize)
+{
+    AudioBufferList *list;
+
+    list = calloc(1, sizeof(AudioBufferList) + sizeof(AudioBuffer));
+    if(list)
+    {
+        list->mNumberBuffers = 1;
+
+        list->mBuffers[0].mNumberChannels = channelCount;
+        list->mBuffers[0].mDataByteSize = byteSize;
+        list->mBuffers[0].mData = malloc(byteSize);
+        if(list->mBuffers[0].mData == NULL)
+        {
+            free(list);
+            list = NULL;
+        }
+    }
+    return list;
+}
+
+static OSStatus ca_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp,
+                            UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
+{
+    ALCdevice *device = (ALCdevice*)inRefCon;
+    ca_data *data = (ca_data*)device->ExtraData;
+
+    aluMixData(device, ioData->mBuffers[0].mData,
+               ioData->mBuffers[0].mDataByteSize / data->frameSize);
+
+    return noErr;
+}
+
+static OSStatus ca_capture_conversion_callback(AudioConverterRef inAudioConverter, UInt32 *ioNumberDataPackets,
+        AudioBufferList *ioData, AudioStreamPacketDescription **outDataPacketDescription, void* inUserData)
+{
+    ALCdevice *device = (ALCdevice*)inUserData;
+    ca_data *data = (ca_data*)device->ExtraData;
+
+    // Read from the ring buffer and store temporarily in a large buffer
+    ReadRingBuffer(data->ring, data->resampleBuffer, (ALsizei)(*ioNumberDataPackets));
+
+    // Set the input data
+    ioData->mNumberBuffers = 1;
+    ioData->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
+    ioData->mBuffers[0].mData = data->resampleBuffer;
+    ioData->mBuffers[0].mDataByteSize = (*ioNumberDataPackets) * data->format.mBytesPerFrame;
+
+    return noErr;
+}
+
+static OSStatus ca_capture_callback(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags,
+                                    const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber,
+                                    UInt32 inNumberFrames, AudioBufferList *ioData)
+{
+    ALCdevice *device = (ALCdevice*)inRefCon;
+    ca_data *data = (ca_data*)device->ExtraData;
+    AudioUnitRenderActionFlags flags = 0;
+    OSStatus err;
+
+    // fill the bufferList with data from the input device
+    err = AudioUnitRender(data->audioUnit, &flags, inTimeStamp, 1, inNumberFrames, data->bufferList);
+    if(err != noErr)
+    {
+        ERR("AudioUnitRender error: %d\n", err);
+        return err;
+    }
+
+    WriteRingBuffer(data->ring, data->bufferList->mBuffers[0].mData, inNumberFrames);
+
+    return noErr;
+}
+
+static ALCenum ca_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    ComponentDescription desc;
+    Component comp;
+    ca_data *data;
+    OSStatus err;
+
+    if(!deviceName)
+        deviceName = ca_device;
+    else if(strcmp(deviceName, ca_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    /* open the default output unit */
+    desc.componentType = kAudioUnitType_Output;
+    desc.componentSubType = kAudioUnitSubType_DefaultOutput;
+    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+    desc.componentFlags = 0;
+    desc.componentFlagsMask = 0;
+
+    comp = FindNextComponent(NULL, &desc);
+    if(comp == NULL)
+    {
+        ERR("FindNextComponent failed\n");
+        return ALC_INVALID_VALUE;
+    }
+
+    data = calloc(1, sizeof(*data));
+
+    err = OpenAComponent(comp, &data->audioUnit);
+    if(err != noErr)
+    {
+        ERR("OpenAComponent failed\n");
+        free(data);
+        return ALC_INVALID_VALUE;
+    }
+
+    /* init and start the default audio unit... */
+    err = AudioUnitInitialize(data->audioUnit);
+    if(err != noErr)
+    {
+        ERR("AudioUnitInitialize failed\n");
+        CloseComponent(data->audioUnit);
+        free(data);
+        return ALC_INVALID_VALUE;
+    }
+
+    al_string_copy_cstr(&device->DeviceName, deviceName);
+    device->ExtraData = data;
+    return ALC_NO_ERROR;
+}
+
+static void ca_close_playback(ALCdevice *device)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+
+    AudioUnitUninitialize(data->audioUnit);
+    CloseComponent(data->audioUnit);
+
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean ca_reset_playback(ALCdevice *device)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+    AudioStreamBasicDescription streamFormat;
+    AURenderCallbackStruct input;
+    OSStatus err;
+    UInt32 size;
+
+    err = AudioUnitUninitialize(data->audioUnit);
+    if(err != noErr)
+        ERR("-- AudioUnitUninitialize failed.\n");
+
+    /* retrieve default output unit's properties (output side) */
+    size = sizeof(AudioStreamBasicDescription);
+    err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, &streamFormat, &size);
+    if(err != noErr || size != sizeof(AudioStreamBasicDescription))
+    {
+        ERR("AudioUnitGetProperty failed\n");
+        return ALC_FALSE;
+    }
+
+#if 0
+    TRACE("Output streamFormat of default output unit -\n");
+    TRACE("  streamFormat.mFramesPerPacket = %d\n", streamFormat.mFramesPerPacket);
+    TRACE("  streamFormat.mChannelsPerFrame = %d\n", streamFormat.mChannelsPerFrame);
+    TRACE("  streamFormat.mBitsPerChannel = %d\n", streamFormat.mBitsPerChannel);
+    TRACE("  streamFormat.mBytesPerPacket = %d\n", streamFormat.mBytesPerPacket);
+    TRACE("  streamFormat.mBytesPerFrame = %d\n", streamFormat.mBytesPerFrame);
+    TRACE("  streamFormat.mSampleRate = %5.0f\n", streamFormat.mSampleRate);
+#endif
+
+    /* set default output unit's input side to match output side */
+    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, size);
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        return ALC_FALSE;
+    }
+
+    if(device->Frequency != streamFormat.mSampleRate)
+    {
+        device->UpdateSize = (ALuint)((ALuint64)device->UpdateSize *
+                                      streamFormat.mSampleRate /
+                                      device->Frequency);
+        device->Frequency = streamFormat.mSampleRate;
+    }
+
+    /* FIXME: How to tell what channels are what in the output device, and how
+     * to specify what we're giving?  eg, 6.0 vs 5.1 */
+    switch(streamFormat.mChannelsPerFrame)
+    {
+        case 1:
+            device->FmtChans = DevFmtMono;
+            break;
+        case 2:
+            device->FmtChans = DevFmtStereo;
+            break;
+        case 4:
+            device->FmtChans = DevFmtQuad;
+            break;
+        case 6:
+            device->FmtChans = DevFmtX51;
+            break;
+        case 7:
+            device->FmtChans = DevFmtX61;
+            break;
+        case 8:
+            device->FmtChans = DevFmtX71;
+            break;
+        default:
+            ERR("Unhandled channel count (%d), using Stereo\n", streamFormat.mChannelsPerFrame);
+            device->FmtChans = DevFmtStereo;
+            streamFormat.mChannelsPerFrame = 2;
+            break;
+    }
+    SetDefaultWFXChannelOrder(device);
+
+    /* use channel count and sample rate from the default output unit's current
+     * parameters, but reset everything else */
+    streamFormat.mFramesPerPacket = 1;
+    streamFormat.mFormatFlags = 0;
+    switch(device->FmtType)
+    {
+        case DevFmtUByte:
+            device->FmtType = DevFmtByte;
+            /* fall-through */
+        case DevFmtByte:
+            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
+            streamFormat.mBitsPerChannel = 8;
+            break;
+        case DevFmtUShort:
+            device->FmtType = DevFmtShort;
+            /* fall-through */
+        case DevFmtShort:
+            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
+            streamFormat.mBitsPerChannel = 16;
+            break;
+        case DevFmtUInt:
+            device->FmtType = DevFmtInt;
+            /* fall-through */
+        case DevFmtInt:
+            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
+            streamFormat.mBitsPerChannel = 32;
+            break;
+        case DevFmtFloat:
+            streamFormat.mFormatFlags = kLinearPCMFormatFlagIsFloat;
+            streamFormat.mBitsPerChannel = 32;
+            break;
+    }
+    streamFormat.mBytesPerFrame = streamFormat.mChannelsPerFrame *
+                                  streamFormat.mBitsPerChannel / 8;
+    streamFormat.mBytesPerPacket = streamFormat.mBytesPerFrame;
+    streamFormat.mFormatID = kAudioFormatLinearPCM;
+    streamFormat.mFormatFlags |= kAudioFormatFlagsNativeEndian |
+                                 kLinearPCMFormatFlagIsPacked;
+
+    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamFormat, sizeof(AudioStreamBasicDescription));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        return ALC_FALSE;
+    }
+
+    /* setup callback */
+    data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    input.inputProc = ca_callback;
+    input.inputProcRefCon = device;
+
+    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, sizeof(AURenderCallbackStruct));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        return ALC_FALSE;
+    }
+
+    /* init the default audio unit... */
+    err = AudioUnitInitialize(data->audioUnit);
+    if(err != noErr)
+    {
+        ERR("AudioUnitInitialize failed\n");
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static ALCboolean ca_start_playback(ALCdevice *device)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+    OSStatus err;
+
+    err = AudioOutputUnitStart(data->audioUnit);
+    if(err != noErr)
+    {
+        ERR("AudioOutputUnitStart failed\n");
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void ca_stop_playback(ALCdevice *device)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+    OSStatus err;
+
+    err = AudioOutputUnitStop(data->audioUnit);
+    if(err != noErr)
+        ERR("AudioOutputUnitStop failed\n");
+}
+
+static ALCenum ca_open_capture(ALCdevice *device, const ALCchar *deviceName)
+{
+    AudioStreamBasicDescription requestedFormat;  // The application requested format
+    AudioStreamBasicDescription hardwareFormat;   // The hardware format
+    AudioStreamBasicDescription outputFormat;     // The AudioUnit output format
+    AURenderCallbackStruct input;
+    ComponentDescription desc;
+    AudioDeviceID inputDevice;
+    UInt32 outputFrameCount;
+    UInt32 propertySize;
+    UInt32 enableIO;
+    Component comp;
+    ca_data *data;
+    OSStatus err;
+
+    desc.componentType = kAudioUnitType_Output;
+    desc.componentSubType = kAudioUnitSubType_HALOutput;
+    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+    desc.componentFlags = 0;
+    desc.componentFlagsMask = 0;
+
+    // Search for component with given description
+    comp = FindNextComponent(NULL, &desc);
+    if(comp == NULL)
+    {
+        ERR("FindNextComponent failed\n");
+        return ALC_INVALID_VALUE;
+    }
+
+    data = calloc(1, sizeof(*data));
+    device->ExtraData = data;
+
+    // Open the component
+    err = OpenAComponent(comp, &data->audioUnit);
+    if(err != noErr)
+    {
+        ERR("OpenAComponent failed\n");
+        goto error;
+    }
+
+    // Turn off AudioUnit output
+    enableIO = 0;
+    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(ALuint));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        goto error;
+    }
+
+    // Turn on AudioUnit input
+    enableIO = 1;
+    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(ALuint));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        goto error;
+    }
+
+    // Get the default input device
+    propertySize = sizeof(AudioDeviceID);
+    err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &inputDevice);
+    if(err != noErr)
+    {
+        ERR("AudioHardwareGetProperty failed\n");
+        goto error;
+    }
+
+    if(inputDevice == kAudioDeviceUnknown)
+    {
+        ERR("No input device found\n");
+        goto error;
+    }
+
+    // Track the input device
+    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &inputDevice, sizeof(AudioDeviceID));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        goto error;
+    }
+
+    // set capture callback
+    input.inputProc = ca_capture_callback;
+    input.inputProcRefCon = device;
+
+    err = AudioUnitSetProperty(data->audioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &input, sizeof(AURenderCallbackStruct));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        goto error;
+    }
+
+    // Initialize the device
+    err = AudioUnitInitialize(data->audioUnit);
+    if(err != noErr)
+    {
+        ERR("AudioUnitInitialize failed\n");
+        goto error;
+    }
+
+    // Get the hardware format
+    propertySize = sizeof(AudioStreamBasicDescription);
+    err = AudioUnitGetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &hardwareFormat, &propertySize);
+    if(err != noErr || propertySize != sizeof(AudioStreamBasicDescription))
+    {
+        ERR("AudioUnitGetProperty failed\n");
+        goto error;
+    }
+
+    // Set up the requested format description
+    switch(device->FmtType)
+    {
+        case DevFmtUByte:
+            requestedFormat.mBitsPerChannel = 8;
+            requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
+            break;
+        case DevFmtShort:
+            requestedFormat.mBitsPerChannel = 16;
+            requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+            break;
+        case DevFmtInt:
+            requestedFormat.mBitsPerChannel = 32;
+            requestedFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
+            break;
+        case DevFmtFloat:
+            requestedFormat.mBitsPerChannel = 32;
+            requestedFormat.mFormatFlags = kAudioFormatFlagIsPacked;
+            break;
+        case DevFmtByte:
+        case DevFmtUShort:
+        case DevFmtUInt:
+            ERR("%s samples not supported\n", DevFmtTypeString(device->FmtType));
+            goto error;
+    }
+
+    switch(device->FmtChans)
+    {
+        case DevFmtMono:
+            requestedFormat.mChannelsPerFrame = 1;
+            break;
+        case DevFmtStereo:
+            requestedFormat.mChannelsPerFrame = 2;
+            break;
+
+        case DevFmtQuad:
+        case DevFmtX51:
+        case DevFmtX51Side:
+        case DevFmtX61:
+        case DevFmtX71:
+            ERR("%s not supported\n", DevFmtChannelsString(device->FmtChans));
+            goto error;
+    }
+
+    requestedFormat.mBytesPerFrame = requestedFormat.mChannelsPerFrame * requestedFormat.mBitsPerChannel / 8;
+    requestedFormat.mBytesPerPacket = requestedFormat.mBytesPerFrame;
+    requestedFormat.mSampleRate = device->Frequency;
+    requestedFormat.mFormatID = kAudioFormatLinearPCM;
+    requestedFormat.mReserved = 0;
+    requestedFormat.mFramesPerPacket = 1;
+
+    // save requested format description for later use
+    data->format = requestedFormat;
+    data->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    // Use intermediate format for sample rate conversion (outputFormat)
+    // Set sample rate to the same as hardware for resampling later
+    outputFormat = requestedFormat;
+    outputFormat.mSampleRate = hardwareFormat.mSampleRate;
+
+    // Determine sample rate ratio for resampling
+    data->sampleRateRatio = outputFormat.mSampleRate / device->Frequency;
+
+    // The output format should be the requested format, but using the hardware sample rate
+    // This is because the AudioUnit will automatically scale other properties, except for sample rate
+    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, (void *)&outputFormat, sizeof(outputFormat));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed\n");
+        goto error;
+    }
+
+    // Set the AudioUnit output format frame count
+    outputFrameCount = device->UpdateSize * data->sampleRateRatio;
+    err = AudioUnitSetProperty(data->audioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Output, 0, &outputFrameCount, sizeof(outputFrameCount));
+    if(err != noErr)
+    {
+        ERR("AudioUnitSetProperty failed: %d\n", err);
+        goto error;
+    }
+
+    // Set up sample converter
+    err = AudioConverterNew(&outputFormat, &requestedFormat, &data->audioConverter);
+    if(err != noErr)
+    {
+        ERR("AudioConverterNew failed: %d\n", err);
+        goto error;
+    }
+
+    // Create a buffer for use in the resample callback
+    data->resampleBuffer = malloc(device->UpdateSize * data->frameSize * data->sampleRateRatio);
+
+    // Allocate buffer for the AudioUnit output
+    data->bufferList = allocate_buffer_list(outputFormat.mChannelsPerFrame, device->UpdateSize * data->frameSize * data->sampleRateRatio);
+    if(data->bufferList == NULL)
+        goto error;
+
+    data->ring = CreateRingBuffer(data->frameSize, (device->UpdateSize * data->sampleRateRatio) * device->NumUpdates);
+    if(data->ring == NULL)
+        goto error;
+
+    al_string_copy_cstr(&device->DeviceName, deviceName);
+
+    return ALC_NO_ERROR;
+
+error:
+    DestroyRingBuffer(data->ring);
+    free(data->resampleBuffer);
+    destroy_buffer_list(data->bufferList);
+
+    if(data->audioConverter)
+        AudioConverterDispose(data->audioConverter);
+    if(data->audioUnit)
+        CloseComponent(data->audioUnit);
+
+    free(data);
+    device->ExtraData = NULL;
+
+    return ALC_INVALID_VALUE;
+}
+
+static void ca_close_capture(ALCdevice *device)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+
+    DestroyRingBuffer(data->ring);
+    free(data->resampleBuffer);
+    destroy_buffer_list(data->bufferList);
+
+    AudioConverterDispose(data->audioConverter);
+    CloseComponent(data->audioUnit);
+
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static void ca_start_capture(ALCdevice *device)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+    OSStatus err = AudioOutputUnitStart(data->audioUnit);
+    if(err != noErr)
+        ERR("AudioOutputUnitStart failed\n");
+}
+
+static void ca_stop_capture(ALCdevice *device)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+    OSStatus err = AudioOutputUnitStop(data->audioUnit);
+    if(err != noErr)
+        ERR("AudioOutputUnitStop failed\n");
+}
+
+static ALCenum ca_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
+{
+    ca_data *data = (ca_data*)device->ExtraData;
+    AudioBufferList *list;
+    UInt32 frameCount;
+    OSStatus err;
+
+    // If no samples are requested, just return
+    if(samples == 0)
+        return ALC_NO_ERROR;
+
+    // Allocate a temporary AudioBufferList to use as the return resamples data
+    list = alloca(sizeof(AudioBufferList) + sizeof(AudioBuffer));
+
+    // Point the resampling buffer to the capture buffer
+    list->mNumberBuffers = 1;
+    list->mBuffers[0].mNumberChannels = data->format.mChannelsPerFrame;
+    list->mBuffers[0].mDataByteSize = samples * data->frameSize;
+    list->mBuffers[0].mData = buffer;
+
+    // Resample into another AudioBufferList
+    frameCount = samples;
+    err = AudioConverterFillComplexBuffer(data->audioConverter, ca_capture_conversion_callback,
+                                          device, &frameCount, list, NULL);
+    if(err != noErr)
+    {
+        ERR("AudioConverterFillComplexBuffer error: %d\n", err);
+        return ALC_INVALID_VALUE;
+    }
+    return ALC_NO_ERROR;
+}
+
+static ALCuint ca_available_samples(ALCdevice *device)
+{
+    ca_data *data = device->ExtraData;
+    return RingBufferSize(data->ring) / data->sampleRateRatio;
+}
+
+
+static const BackendFuncs ca_funcs = {
+    ca_open_playback,
+    ca_close_playback,
+    ca_reset_playback,
+    ca_start_playback,
+    ca_stop_playback,
+    ca_open_capture,
+    ca_close_capture,
+    ca_start_capture,
+    ca_stop_capture,
+    ca_capture_samples,
+    ca_available_samples,
+    ALCdevice_GetLatencyDefault
+};
+
+ALCboolean alc_ca_init(BackendFuncs *func_list)
+{
+    *func_list = ca_funcs;
+    return ALC_TRUE;
+}
+
+void alc_ca_deinit(void)
+{
+}
+
+void alc_ca_probe(enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+            AppendAllDevicesList(ca_device);
+            break;
+        case CAPTURE_DEVICE_PROBE:
+            AppendCaptureDeviceList(ca_device);
+            break;
+    }
+}
@@ -0,0 +1,138 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2011 by Chris Robinson
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alu.h"
+
+#include "backends/base.h"
+
+
+typedef struct ALCloopback {
+    DERIVE_FROM_TYPE(ALCbackend);
+} ALCloopback;
+
+static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device);
+static DECLARE_FORWARD(ALCloopback, ALCbackend, void, Destruct)
+static ALCenum ALCloopback_open(ALCloopback *self, const ALCchar *name);
+static void ALCloopback_close(ALCloopback *self);
+static ALCboolean ALCloopback_reset(ALCloopback *self);
+static ALCboolean ALCloopback_start(ALCloopback *self);
+static void ALCloopback_stop(ALCloopback *self);
+static DECLARE_FORWARD2(ALCloopback, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
+static DECLARE_FORWARD(ALCloopback, ALCbackend, ALCuint, availableSamples)
+static DECLARE_FORWARD(ALCloopback, ALCbackend, ALint64, getLatency)
+static DECLARE_FORWARD(ALCloopback, ALCbackend, void, lock)
+static DECLARE_FORWARD(ALCloopback, ALCbackend, void, unlock)
+DECLARE_DEFAULT_ALLOCATORS(ALCloopback)
+DEFINE_ALCBACKEND_VTABLE(ALCloopback);
+
+
+static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device)
+{
+    ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
+    SET_VTABLE2(ALCloopback, ALCbackend, self);
+}
+
+
+static ALCenum ALCloopback_open(ALCloopback *self, const ALCchar *name)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+
+    al_string_copy_cstr(&device->DeviceName, name);
+    return ALC_NO_ERROR;
+}
+
+static void ALCloopback_close(ALCloopback* UNUSED(self))
+{
+}
+
+static ALCboolean ALCloopback_reset(ALCloopback *self)
+{
+    SetDefaultWFXChannelOrder(STATIC_CAST(ALCbackend, self)->mDevice);
+    return ALC_TRUE;
+}
+
+static ALCboolean ALCloopback_start(ALCloopback* UNUSED(self))
+{
+    return ALC_TRUE;
+}
+
+static void ALCloopback_stop(ALCloopback* UNUSED(self))
+{
+}
+
+
+typedef struct ALCloopbackFactory {
+    DERIVE_FROM_TYPE(ALCbackendFactory);
+} ALCloopbackFactory;
+#define ALCNULLBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCloopbackFactory, ALCbackendFactory) } }
+
+ALCbackendFactory *ALCloopbackFactory_getFactory(void);
+static ALCboolean ALCloopbackFactory_init(ALCloopbackFactory *self);
+static DECLARE_FORWARD(ALCloopbackFactory, ALCbackendFactory, void, deinit)
+static ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory *self, ALCbackend_Type type);
+static void ALCloopbackFactory_probe(ALCloopbackFactory *self, enum DevProbe type);
+static ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory *self, ALCdevice *device, ALCbackend_Type type);
+DEFINE_ALCBACKENDFACTORY_VTABLE(ALCloopbackFactory);
+
+
+ALCbackendFactory *ALCloopbackFactory_getFactory(void)
+{
+    static ALCloopbackFactory factory = ALCNULLBACKENDFACTORY_INITIALIZER;
+    return STATIC_CAST(ALCbackendFactory, &factory);
+}
+
+static ALCboolean ALCloopbackFactory_init(ALCloopbackFactory* UNUSED(self))
+{
+    return ALC_TRUE;
+}
+
+static ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory* UNUSED(self), ALCbackend_Type type)
+{
+    if(type == ALCbackend_Loopback)
+        return ALC_TRUE;
+    return ALC_FALSE;
+}
+
+static void ALCloopbackFactory_probe(ALCloopbackFactory* UNUSED(self), enum DevProbe UNUSED(type))
+{
+}
+
+static ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
+{
+    if(type == ALCbackend_Loopback)
+    {
+        ALCloopback *backend;
+
+        backend = ALCloopback_New(sizeof(*backend));
+        if(!backend) return NULL;
+        memset(backend, 0, sizeof(*backend));
+
+        ALCloopback_Construct(backend, device);
+
+        return STATIC_CAST(ALCbackend, backend);
+    }
+
+    return NULL;
+}
@@ -0,0 +1,228 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2010 by Chris Robinson
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+
+#include "alMain.h"
+#include "alu.h"
+#include "threads.h"
+#include "compat.h"
+
+#include "backends/base.h"
+
+
+typedef struct ALCnullBackend {
+    DERIVE_FROM_TYPE(ALCbackend);
+
+    volatile int killNow;
+    althrd_t thread;
+} ALCnullBackend;
+
+static int ALCnullBackend_mixerProc(void *ptr);
+
+static void ALCnullBackend_Construct(ALCnullBackend *self, ALCdevice *device);
+static DECLARE_FORWARD(ALCnullBackend, ALCbackend, void, Destruct)
+static ALCenum ALCnullBackend_open(ALCnullBackend *self, const ALCchar *name);
+static void ALCnullBackend_close(ALCnullBackend *self);
+static ALCboolean ALCnullBackend_reset(ALCnullBackend *self);
+static ALCboolean ALCnullBackend_start(ALCnullBackend *self);
+static void ALCnullBackend_stop(ALCnullBackend *self);
+static DECLARE_FORWARD2(ALCnullBackend, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
+static DECLARE_FORWARD(ALCnullBackend, ALCbackend, ALCuint, availableSamples)
+static DECLARE_FORWARD(ALCnullBackend, ALCbackend, ALint64, getLatency)
+static DECLARE_FORWARD(ALCnullBackend, ALCbackend, void, lock)
+static DECLARE_FORWARD(ALCnullBackend, ALCbackend, void, unlock)
+DECLARE_DEFAULT_ALLOCATORS(ALCnullBackend)
+
+DEFINE_ALCBACKEND_VTABLE(ALCnullBackend);
+
+
+static const ALCchar nullDevice[] = "No Output";
+
+
+static void ALCnullBackend_Construct(ALCnullBackend *self, ALCdevice *device)
+{
+    ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
+    SET_VTABLE2(ALCnullBackend, ALCbackend, self);
+}
+
+
+static int ALCnullBackend_mixerProc(void *ptr)
+{
+    ALCnullBackend *self = (ALCnullBackend*)ptr;
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    struct timespec now, start;
+    ALuint64 avail, done;
+    const long restTime = (long)((ALuint64)device->UpdateSize * 1000000000 /
+                                 device->Frequency / 2);
+
+    SetRTPriority();
+    althrd_setname(althrd_current(), MIXER_THREAD_NAME);
+
+    done = 0;
+    if(altimespec_get(&start, AL_TIME_UTC) != AL_TIME_UTC)
+    {
+        ERR("Failed to get starting time\n");
+        return 1;
+    }
+    while(!self->killNow && device->Connected)
+    {
+        if(altimespec_get(&now, AL_TIME_UTC) != AL_TIME_UTC)
+        {
+            ERR("Failed to get current time\n");
+            return 1;
+        }
+
+        avail  = (now.tv_sec - start.tv_sec) * device->Frequency;
+        avail += (ALint64)(now.tv_nsec - start.tv_nsec) * device->Frequency / 1000000000;
+        if(avail < done)
+        {
+            /* Oops, time skipped backwards. Reset the number of samples done
+             * with one update available since we (likely) just came back from
+             * sleeping. */
+            done = avail - device->UpdateSize;
+        }
+
+        if(avail-done < device->UpdateSize)
+            al_nssleep(0, restTime);
+        else while(avail-done >= device->UpdateSize)
+        {
+            aluMixData(device, NULL, device->UpdateSize);
+            done += device->UpdateSize;
+        }
+    }
+
+    return 0;
+}
+
+
+static ALCenum ALCnullBackend_open(ALCnullBackend *self, const ALCchar *name)
+{
+    ALCdevice *device;
+
+    if(!name)
+        name = nullDevice;
+    else if(strcmp(name, nullDevice) != 0)
+        return ALC_INVALID_VALUE;
+
+    device = STATIC_CAST(ALCbackend, self)->mDevice;
+    al_string_copy_cstr(&device->DeviceName, name);
+
+    return ALC_NO_ERROR;
+}
+
+static void ALCnullBackend_close(ALCnullBackend* UNUSED(self))
+{
+}
+
+static ALCboolean ALCnullBackend_reset(ALCnullBackend *self)
+{
+    SetDefaultWFXChannelOrder(STATIC_CAST(ALCbackend, self)->mDevice);
+    return ALC_TRUE;
+}
+
+static ALCboolean ALCnullBackend_start(ALCnullBackend *self)
+{
+    self->killNow = 0;
+    if(althrd_create(&self->thread, ALCnullBackend_mixerProc, self) != althrd_success)
+        return ALC_FALSE;
+    return ALC_TRUE;
+}
+
+static void ALCnullBackend_stop(ALCnullBackend *self)
+{
+    int res;
+
+    if(self->killNow)
+        return;
+
+    self->killNow = 1;
+    althrd_join(self->thread, &res);
+}
+
+
+typedef struct ALCnullBackendFactory {
+    DERIVE_FROM_TYPE(ALCbackendFactory);
+} ALCnullBackendFactory;
+#define ALCNULLBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCnullBackendFactory, ALCbackendFactory) } }
+
+ALCbackendFactory *ALCnullBackendFactory_getFactory(void);
+
+static ALCboolean ALCnullBackendFactory_init(ALCnullBackendFactory *self);
+static DECLARE_FORWARD(ALCnullBackendFactory, ALCbackendFactory, void, deinit)
+static ALCboolean ALCnullBackendFactory_querySupport(ALCnullBackendFactory *self, ALCbackend_Type type);
+static void ALCnullBackendFactory_probe(ALCnullBackendFactory *self, enum DevProbe type);
+static ALCbackend* ALCnullBackendFactory_createBackend(ALCnullBackendFactory *self, ALCdevice *device, ALCbackend_Type type);
+DEFINE_ALCBACKENDFACTORY_VTABLE(ALCnullBackendFactory);
+
+
+ALCbackendFactory *ALCnullBackendFactory_getFactory(void)
+{
+    static ALCnullBackendFactory factory = ALCNULLBACKENDFACTORY_INITIALIZER;
+    return STATIC_CAST(ALCbackendFactory, &factory);
+}
+
+
+static ALCboolean ALCnullBackendFactory_init(ALCnullBackendFactory* UNUSED(self))
+{
+    return ALC_TRUE;
+}
+
+static ALCboolean ALCnullBackendFactory_querySupport(ALCnullBackendFactory* UNUSED(self), ALCbackend_Type type)
+{
+    if(type == ALCbackend_Playback)
+        return ALC_TRUE;
+    return ALC_FALSE;
+}
+
+static void ALCnullBackendFactory_probe(ALCnullBackendFactory* UNUSED(self), enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+            AppendAllDevicesList(nullDevice);
+            break;
+        case CAPTURE_DEVICE_PROBE:
+            break;
+    }
+}
+
+static ALCbackend* ALCnullBackendFactory_createBackend(ALCnullBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
+{
+    if(type == ALCbackend_Playback)
+    {
+        ALCnullBackend *backend;
+
+        backend = ALCnullBackend_New(sizeof(*backend));
+        if(!backend) return NULL;
+        memset(backend, 0, sizeof(*backend));
+
+        ALCnullBackend_Construct(backend, device);
+
+        return STATIC_CAST(ALCbackend, backend);
+    }
+
+    return NULL;
+}
@@ -0,0 +1,424 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This is an OpenAL backend for Android using the native audio APIs based on
+ * OpenSL ES 1.0.1. It is based on source code for the native-audio sample app
+ * bundled with NDK.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alu.h"
+
+
+#include <SLES/OpenSLES.h>
+#include <SLES/OpenSLES_Android.h>
+
+/* Helper macros */
+#define VCALL(obj, func)  ((*(obj))->func((obj), EXTRACT_VCALL_ARGS
+#define VCALL0(obj, func)  ((*(obj))->func((obj) EXTRACT_VCALL_ARGS
+
+
+typedef struct {
+    /* engine interfaces */
+    SLObjectItf engineObject;
+    SLEngineItf engine;
+
+    /* output mix interfaces */
+    SLObjectItf outputMix;
+
+    /* buffer queue player interfaces */
+    SLObjectItf bufferQueueObject;
+
+    void *buffer;
+    ALuint bufferSize;
+    ALuint curBuffer;
+
+    ALuint frameSize;
+} osl_data;
+
+
+static const ALCchar opensl_device[] = "OpenSL";
+
+
+static SLuint32 GetChannelMask(enum DevFmtChannels chans)
+{
+    switch(chans)
+    {
+        case DevFmtMono: return SL_SPEAKER_FRONT_CENTER;
+        case DevFmtStereo: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT;
+        case DevFmtQuad: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
+                                SL_SPEAKER_BACK_LEFT|SL_SPEAKER_BACK_RIGHT;
+        case DevFmtX51: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
+                               SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
+                               SL_SPEAKER_BACK_LEFT|SL_SPEAKER_BACK_RIGHT;
+        case DevFmtX61: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
+                               SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
+                               SL_SPEAKER_BACK_CENTER|
+                               SL_SPEAKER_SIDE_LEFT|SL_SPEAKER_SIDE_RIGHT;
+        case DevFmtX71: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
+                               SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
+                               SL_SPEAKER_BACK_LEFT|SL_SPEAKER_BACK_RIGHT|
+                               SL_SPEAKER_SIDE_LEFT|SL_SPEAKER_SIDE_RIGHT;
+        case DevFmtX51Side: return SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT|
+                                   SL_SPEAKER_FRONT_CENTER|SL_SPEAKER_LOW_FREQUENCY|
+                                   SL_SPEAKER_SIDE_LEFT|SL_SPEAKER_SIDE_RIGHT;
+    }
+    return 0;
+}
+
+static const char *res_str(SLresult result)
+{
+    switch(result)
+    {
+        case SL_RESULT_SUCCESS: return "Success";
+        case SL_RESULT_PRECONDITIONS_VIOLATED: return "Preconditions violated";
+        case SL_RESULT_PARAMETER_INVALID: return "Parameter invalid";
+        case SL_RESULT_MEMORY_FAILURE: return "Memory failure";
+        case SL_RESULT_RESOURCE_ERROR: return "Resource error";
+        case SL_RESULT_RESOURCE_LOST: return "Resource lost";
+        case SL_RESULT_IO_ERROR: return "I/O error";
+        case SL_RESULT_BUFFER_INSUFFICIENT: return "Buffer insufficient";
+        case SL_RESULT_CONTENT_CORRUPTED: return "Content corrupted";
+        case SL_RESULT_CONTENT_UNSUPPORTED: return "Content unsupported";
+        case SL_RESULT_CONTENT_NOT_FOUND: return "Content not found";
+        case SL_RESULT_PERMISSION_DENIED: return "Permission denied";
+        case SL_RESULT_FEATURE_UNSUPPORTED: return "Feature unsupported";
+        case SL_RESULT_INTERNAL_ERROR: return "Internal error";
+        case SL_RESULT_UNKNOWN_ERROR: return "Unknown error";
+        case SL_RESULT_OPERATION_ABORTED: return "Operation aborted";
+        case SL_RESULT_CONTROL_LOST: return "Control lost";
+#ifdef SL_RESULT_READONLY
+        case SL_RESULT_READONLY: return "ReadOnly";
+#endif
+#ifdef SL_RESULT_ENGINEOPTION_UNSUPPORTED
+        case SL_RESULT_ENGINEOPTION_UNSUPPORTED: return "Engine option unsupported";
+#endif
+#ifdef SL_RESULT_SOURCE_SINK_INCOMPATIBLE
+        case SL_RESULT_SOURCE_SINK_INCOMPATIBLE: return "Source/Sink incompatible";
+#endif
+    }
+    return "Unknown error code";
+}
+
+#define PRINTERR(x, s) do {                                                      \
+    if((x) != SL_RESULT_SUCCESS)                                                 \
+        ERR("%s: %s\n", (s), res_str((x)));                                      \
+} while(0)
+
+/* this callback handler is called every time a buffer finishes playing */
+static void opensl_callback(SLAndroidSimpleBufferQueueItf bq, void *context)
+{
+    ALCdevice *Device = context;
+    osl_data *data = Device->ExtraData;
+    ALvoid *buf;
+    SLresult result;
+
+    buf = (ALbyte*)data->buffer + data->curBuffer*data->bufferSize;
+    aluMixData(Device, buf, data->bufferSize/data->frameSize);
+
+    result = VCALL(bq,Enqueue)(buf, data->bufferSize);
+    PRINTERR(result, "bq->Enqueue");
+
+    data->curBuffer = (data->curBuffer+1) % Device->NumUpdates;
+}
+
+
+static ALCenum opensl_open_playback(ALCdevice *Device, const ALCchar *deviceName)
+{
+    osl_data *data = NULL;
+    SLresult result;
+
+    if(!deviceName)
+        deviceName = opensl_device;
+    else if(strcmp(deviceName, opensl_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    data = calloc(1, sizeof(*data));
+    if(!data)
+        return ALC_OUT_OF_MEMORY;
+
+    // create engine
+    result = slCreateEngine(&data->engineObject, 0, NULL, 0, NULL, NULL);
+    PRINTERR(result, "slCreateEngine");
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(data->engineObject,Realize)(SL_BOOLEAN_FALSE);
+        PRINTERR(result, "engine->Realize");
+    }
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(data->engineObject,GetInterface)(SL_IID_ENGINE, &data->engine);
+        PRINTERR(result, "engine->GetInterface");
+    }
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(data->engine,CreateOutputMix)(&data->outputMix, 0, NULL, NULL);
+        PRINTERR(result, "engine->CreateOutputMix");
+    }
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(data->outputMix,Realize)(SL_BOOLEAN_FALSE);
+        PRINTERR(result, "outputMix->Realize");
+    }
+
+    if(SL_RESULT_SUCCESS != result)
+    {
+        if(data->outputMix != NULL)
+            VCALL0(data->outputMix,Destroy)();
+        data->outputMix = NULL;
+
+        if(data->engineObject != NULL)
+            VCALL0(data->engineObject,Destroy)();
+        data->engineObject = NULL;
+        data->engine = NULL;
+
+        free(data);
+        return ALC_INVALID_VALUE;
+    }
+
+    al_string_copy_cstr(&Device->DeviceName, deviceName);
+    Device->ExtraData = data;
+
+    return ALC_NO_ERROR;
+}
+
+
+static void opensl_close_playback(ALCdevice *Device)
+{
+    osl_data *data = Device->ExtraData;
+
+    if(data->bufferQueueObject != NULL)
+        VCALL0(data->bufferQueueObject,Destroy)();
+    data->bufferQueueObject = NULL;
+
+    VCALL0(data->outputMix,Destroy)();
+    data->outputMix = NULL;
+
+    VCALL0(data->engineObject,Destroy)();
+    data->engineObject = NULL;
+    data->engine = NULL;
+
+    free(data);
+    Device->ExtraData = NULL;
+}
+
+static ALCboolean opensl_reset_playback(ALCdevice *Device)
+{
+    osl_data *data = Device->ExtraData;
+    SLDataLocator_AndroidSimpleBufferQueue loc_bufq;
+    SLDataLocator_OutputMix loc_outmix;
+    SLDataFormat_PCM format_pcm;
+    SLDataSource audioSrc;
+    SLDataSink audioSnk;
+    SLInterfaceID id;
+    SLboolean req;
+    SLresult result;
+
+
+    Device->UpdateSize = (ALuint64)Device->UpdateSize * 44100 / Device->Frequency;
+    Device->UpdateSize = Device->UpdateSize * Device->NumUpdates / 2;
+    Device->NumUpdates = 2;
+
+    Device->Frequency = 44100;
+    Device->FmtChans = DevFmtStereo;
+    Device->FmtType = DevFmtShort;
+
+    SetDefaultWFXChannelOrder(Device);
+
+
+    id  = SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+    req = SL_BOOLEAN_TRUE;
+
+    loc_bufq.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
+    loc_bufq.numBuffers = Device->NumUpdates;
+
+    format_pcm.formatType = SL_DATAFORMAT_PCM;
+    format_pcm.numChannels = ChannelsFromDevFmt(Device->FmtChans);
+    format_pcm.samplesPerSec = Device->Frequency * 1000;
+    format_pcm.bitsPerSample = BytesFromDevFmt(Device->FmtType) * 8;
+    format_pcm.containerSize = format_pcm.bitsPerSample;
+    format_pcm.channelMask = GetChannelMask(Device->FmtChans);
+    format_pcm.endianness = IS_LITTLE_ENDIAN ? SL_BYTEORDER_LITTLEENDIAN :
+                                               SL_BYTEORDER_BIGENDIAN;
+
+    audioSrc.pLocator = &loc_bufq;
+    audioSrc.pFormat = &format_pcm;
+
+    loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
+    loc_outmix.outputMix = data->outputMix;
+    audioSnk.pLocator = &loc_outmix;
+    audioSnk.pFormat = NULL;
+
+
+    if(data->bufferQueueObject != NULL)
+        VCALL0(data->bufferQueueObject,Destroy)();
+    data->bufferQueueObject = NULL;
+
+    result = VCALL(data->engine,CreateAudioPlayer)(&data->bufferQueueObject, &audioSrc, &audioSnk, 1, &id, &req);
+    PRINTERR(result, "engine->CreateAudioPlayer");
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(data->bufferQueueObject,Realize)(SL_BOOLEAN_FALSE);
+        PRINTERR(result, "bufferQueue->Realize");
+    }
+
+    if(SL_RESULT_SUCCESS != result)
+    {
+        if(data->bufferQueueObject != NULL)
+            VCALL0(data->bufferQueueObject,Destroy)();
+        data->bufferQueueObject = NULL;
+
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static ALCboolean opensl_start_playback(ALCdevice *Device)
+{
+    osl_data *data = Device->ExtraData;
+    SLAndroidSimpleBufferQueueItf bufferQueue;
+    SLPlayItf player;
+    SLresult result;
+    ALuint i;
+
+    result = VCALL(data->bufferQueueObject,GetInterface)(SL_IID_BUFFERQUEUE, &bufferQueue);
+    PRINTERR(result, "bufferQueue->GetInterface");
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(bufferQueue,RegisterCallback)(opensl_callback, Device);
+        PRINTERR(result, "bufferQueue->RegisterCallback");
+    }
+    if(SL_RESULT_SUCCESS == result)
+    {
+        data->frameSize = FrameSizeFromDevFmt(Device->FmtChans, Device->FmtType);
+        data->bufferSize = Device->UpdateSize * data->frameSize;
+        data->buffer = calloc(Device->NumUpdates, data->bufferSize);
+        if(!data->buffer)
+        {
+            result = SL_RESULT_MEMORY_FAILURE;
+            PRINTERR(result, "calloc");
+        }
+    }
+    /* enqueue the first buffer to kick off the callbacks */
+    for(i = 0;i < Device->NumUpdates;i++)
+    {
+        if(SL_RESULT_SUCCESS == result)
+        {
+            ALvoid *buf = (ALbyte*)data->buffer + i*data->bufferSize;
+            result = VCALL(bufferQueue,Enqueue)(buf, data->bufferSize);
+            PRINTERR(result, "bufferQueue->Enqueue");
+        }
+    }
+    data->curBuffer = 0;
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(data->bufferQueueObject,GetInterface)(SL_IID_PLAY, &player);
+        PRINTERR(result, "bufferQueue->GetInterface");
+    }
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(player,SetPlayState)(SL_PLAYSTATE_PLAYING);
+        PRINTERR(result, "player->SetPlayState");
+    }
+
+    if(SL_RESULT_SUCCESS != result)
+    {
+        if(data->bufferQueueObject != NULL)
+            VCALL0(data->bufferQueueObject,Destroy)();
+        data->bufferQueueObject = NULL;
+
+        free(data->buffer);
+        data->buffer = NULL;
+        data->bufferSize = 0;
+
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+
+static void opensl_stop_playback(ALCdevice *Device)
+{
+    osl_data *data = Device->ExtraData;
+    SLPlayItf player;
+    SLAndroidSimpleBufferQueueItf bufferQueue;
+    SLresult result;
+
+    result = VCALL(data->bufferQueueObject,GetInterface)(SL_IID_PLAY, &player);
+    PRINTERR(result, "bufferQueue->GetInterface");
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL(player,SetPlayState)(SL_PLAYSTATE_STOPPED);
+        PRINTERR(result, "player->SetPlayState");
+    }
+
+    result = VCALL(data->bufferQueueObject,GetInterface)(SL_IID_BUFFERQUEUE, &bufferQueue);
+    PRINTERR(result, "bufferQueue->GetInterface");
+    if(SL_RESULT_SUCCESS == result)
+    {
+        result = VCALL0(bufferQueue,Clear)();
+        PRINTERR(result, "bufferQueue->Clear");
+    }
+
+    free(data->buffer);
+    data->buffer = NULL;
+    data->bufferSize = 0;
+}
+
+
+static const BackendFuncs opensl_funcs = {
+    opensl_open_playback,
+    opensl_close_playback,
+    opensl_reset_playback,
+    opensl_start_playback,
+    opensl_stop_playback,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ALCdevice_GetLatencyDefault
+};
+
+
+ALCboolean alc_opensl_init(BackendFuncs *func_list)
+{
+    *func_list = opensl_funcs;
+    return ALC_TRUE;
+}
+
+void alc_opensl_deinit(void)
+{
+}
+
+void alc_opensl_probe(enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+            AppendAllDevicesList(opensl_device);
+            break;
+        case CAPTURE_DEVICE_PROBE:
+            break;
+    }
+}
@@ -0,0 +1,632 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <unistd.h>
+#include <errno.h>
+#include <math.h>
+
+#include "alMain.h"
+#include "alu.h"
+#include "threads.h"
+#include "compat.h"
+
+#include "backends/base.h"
+
+#include <sys/soundcard.h>
+
+/*
+ * The OSS documentation talks about SOUND_MIXER_READ, but the header
+ * only contains MIXER_READ. Play safe. Same for WRITE.
+ */
+#ifndef SOUND_MIXER_READ
+#define SOUND_MIXER_READ MIXER_READ
+#endif
+#ifndef SOUND_MIXER_WRITE
+#define SOUND_MIXER_WRITE MIXER_WRITE
+#endif
+
+
+static const ALCchar oss_device[] = "OSS Default";
+
+static const char *oss_driver = "/dev/dsp";
+static const char *oss_capture = "/dev/dsp";
+
+static int log2i(ALCuint x)
+{
+    int y = 0;
+    while (x > 1)
+    {
+        x >>= 1;
+        y++;
+    }
+    return y;
+}
+
+
+typedef struct ALCplaybackOSS {
+    DERIVE_FROM_TYPE(ALCbackend);
+
+    int fd;
+
+    ALubyte *mix_data;
+    int data_size;
+
+    volatile int killNow;
+    althrd_t thread;
+} ALCplaybackOSS;
+
+static int ALCplaybackOSS_mixerProc(void *ptr);
+
+static void ALCplaybackOSS_Construct(ALCplaybackOSS *self, ALCdevice *device);
+static DECLARE_FORWARD(ALCplaybackOSS, ALCbackend, void, Destruct)
+static ALCenum ALCplaybackOSS_open(ALCplaybackOSS *self, const ALCchar *name);
+static void ALCplaybackOSS_close(ALCplaybackOSS *self);
+static ALCboolean ALCplaybackOSS_reset(ALCplaybackOSS *self);
+static ALCboolean ALCplaybackOSS_start(ALCplaybackOSS *self);
+static void ALCplaybackOSS_stop(ALCplaybackOSS *self);
+static DECLARE_FORWARD2(ALCplaybackOSS, ALCbackend, ALCenum, captureSamples, ALCvoid*, ALCuint)
+static DECLARE_FORWARD(ALCplaybackOSS, ALCbackend, ALCuint, availableSamples)
+static DECLARE_FORWARD(ALCplaybackOSS, ALCbackend, ALint64, getLatency)
+static DECLARE_FORWARD(ALCplaybackOSS, ALCbackend, void, lock)
+static DECLARE_FORWARD(ALCplaybackOSS, ALCbackend, void, unlock)
+DECLARE_DEFAULT_ALLOCATORS(ALCplaybackOSS)
+DEFINE_ALCBACKEND_VTABLE(ALCplaybackOSS);
+
+
+static int ALCplaybackOSS_mixerProc(void *ptr)
+{
+    ALCplaybackOSS *self = (ALCplaybackOSS*)ptr;
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    ALint frameSize;
+    ssize_t wrote;
+
+    SetRTPriority();
+    althrd_setname(althrd_current(), MIXER_THREAD_NAME);
+
+    frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    while(!self->killNow && device->Connected)
+    {
+        ALint len = self->data_size;
+        ALubyte *WritePtr = self->mix_data;
+
+        aluMixData(device, WritePtr, len/frameSize);
+        while(len > 0 && !self->killNow)
+        {
+            wrote = write(self->fd, WritePtr, len);
+            if(wrote < 0)
+            {
+                if(errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
+                {
+                    ERR("write failed: %s\n", strerror(errno));
+                    ALCplaybackOSS_lock(self);
+                    aluHandleDisconnect(device);
+                    ALCplaybackOSS_unlock(self);
+                    break;
+                }
+
+                al_nssleep(0, 1000000);
+                continue;
+            }
+
+            len -= wrote;
+            WritePtr += wrote;
+        }
+    }
+
+    return 0;
+}
+
+
+static void ALCplaybackOSS_Construct(ALCplaybackOSS *self, ALCdevice *device)
+{
+    ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
+    SET_VTABLE2(ALCplaybackOSS, ALCbackend, self);
+}
+
+static ALCenum ALCplaybackOSS_open(ALCplaybackOSS *self, const ALCchar *name)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+
+    if(!name)
+        name = oss_device;
+    else if(strcmp(name, oss_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    self->killNow = 0;
+
+    self->fd = open(oss_driver, O_WRONLY);
+    if(self->fd == -1)
+    {
+        ERR("Could not open %s: %s\n", oss_driver, strerror(errno));
+        return ALC_INVALID_VALUE;
+    }
+
+    al_string_copy_cstr(&device->DeviceName, name);
+
+    return ALC_NO_ERROR;
+}
+
+static void ALCplaybackOSS_close(ALCplaybackOSS *self)
+{
+    close(self->fd);
+    self->fd = -1;
+}
+
+static ALCboolean ALCplaybackOSS_reset(ALCplaybackOSS *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    int numFragmentsLogSize;
+    int log2FragmentSize;
+    unsigned int periods;
+    audio_buf_info info;
+    ALuint frameSize;
+    int numChannels;
+    int ossFormat;
+    int ossSpeed;
+    char *err;
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            ossFormat = AFMT_S8;
+            break;
+        case DevFmtUByte:
+            ossFormat = AFMT_U8;
+            break;
+        case DevFmtUShort:
+        case DevFmtInt:
+        case DevFmtUInt:
+        case DevFmtFloat:
+            device->FmtType = DevFmtShort;
+            /* fall-through */
+        case DevFmtShort:
+            ossFormat = AFMT_S16_NE;
+            break;
+    }
+
+    periods = device->NumUpdates;
+    numChannels = ChannelsFromDevFmt(device->FmtChans);
+    frameSize = numChannels * BytesFromDevFmt(device->FmtType);
+
+    ossSpeed = device->Frequency;
+    log2FragmentSize = log2i(device->UpdateSize * frameSize);
+
+    /* according to the OSS spec, 16 bytes are the minimum */
+    if (log2FragmentSize < 4)
+        log2FragmentSize = 4;
+    /* Subtract one period since the temp mixing buffer counts as one. Still
+     * need at least two on the card, though. */
+    if(periods > 2) periods--;
+    numFragmentsLogSize = (periods << 16) | log2FragmentSize;
+
+#define CHECKERR(func) if((func) < 0) {                                       \
+    err = #func;                                                              \
+    goto err;                                                                 \
+}
+    /* Don't fail if SETFRAGMENT fails. We can handle just about anything
+     * that's reported back via GETOSPACE */
+    ioctl(self->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize);
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_SETFMT, &ossFormat));
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_CHANNELS, &numChannels));
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_SPEED, &ossSpeed));
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_GETOSPACE, &info));
+    if(0)
+    {
+    err:
+        ERR("%s failed: %s\n", err, strerror(errno));
+        return ALC_FALSE;
+    }
+#undef CHECKERR
+
+    if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
+    {
+        ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device->FmtChans), numChannels);
+        return ALC_FALSE;
+    }
+
+    if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
+         (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
+         (ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
+    {
+        ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device->FmtType), ossFormat);
+        return ALC_FALSE;
+    }
+
+    device->Frequency = ossSpeed;
+    device->UpdateSize = info.fragsize / frameSize;
+    device->NumUpdates = info.fragments + 1;
+
+    SetDefaultChannelOrder(device);
+
+    return ALC_TRUE;
+}
+
+static ALCboolean ALCplaybackOSS_start(ALCplaybackOSS *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+
+    self->data_size = device->UpdateSize * FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    self->mix_data = calloc(1, self->data_size);
+
+    self->killNow = 0;
+    if(althrd_create(&self->thread, ALCplaybackOSS_mixerProc, self) != althrd_success)
+    {
+        free(self->mix_data);
+        self->mix_data = NULL;
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void ALCplaybackOSS_stop(ALCplaybackOSS *self)
+{
+    int res;
+
+    if(self->killNow)
+        return;
+
+    self->killNow = 1;
+    althrd_join(self->thread, &res);
+
+    if(ioctl(self->fd, SNDCTL_DSP_RESET) != 0)
+        ERR("Error resetting device: %s\n", strerror(errno));
+
+    free(self->mix_data);
+    self->mix_data = NULL;
+}
+
+
+typedef struct ALCcaptureOSS {
+    DERIVE_FROM_TYPE(ALCbackend);
+
+    int fd;
+
+    ALubyte *read_data;
+    int data_size;
+
+    RingBuffer *ring;
+    int doCapture;
+
+    volatile int killNow;
+    althrd_t thread;
+} ALCcaptureOSS;
+
+static int ALCcaptureOSS_recordProc(void *ptr);
+
+static void ALCcaptureOSS_Construct(ALCcaptureOSS *self, ALCdevice *device);
+static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, void, Destruct)
+static ALCenum ALCcaptureOSS_open(ALCcaptureOSS *self, const ALCchar *name);
+static void ALCcaptureOSS_close(ALCcaptureOSS *self);
+static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, ALCboolean, reset)
+static ALCboolean ALCcaptureOSS_start(ALCcaptureOSS *self);
+static void ALCcaptureOSS_stop(ALCcaptureOSS *self);
+static ALCenum ALCcaptureOSS_captureSamples(ALCcaptureOSS *self, ALCvoid *buffer, ALCuint samples);
+static ALCuint ALCcaptureOSS_availableSamples(ALCcaptureOSS *self);
+static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, ALint64, getLatency)
+static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, void, lock)
+static DECLARE_FORWARD(ALCcaptureOSS, ALCbackend, void, unlock)
+DECLARE_DEFAULT_ALLOCATORS(ALCcaptureOSS)
+DEFINE_ALCBACKEND_VTABLE(ALCcaptureOSS);
+
+
+static int ALCcaptureOSS_recordProc(void *ptr)
+{
+    ALCcaptureOSS *self = (ALCcaptureOSS*)ptr;
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    int frameSize;
+    int amt;
+
+    SetRTPriority();
+    althrd_setname(althrd_current(), "alsoft-record");
+
+    frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    while(!self->killNow)
+    {
+        amt = read(self->fd, self->read_data, self->data_size);
+        if(amt < 0)
+        {
+            ERR("read failed: %s\n", strerror(errno));
+            ALCcaptureOSS_lock(self);
+            aluHandleDisconnect(device);
+            ALCcaptureOSS_unlock(self);
+            break;
+        }
+        if(amt == 0)
+        {
+            al_nssleep(0, 1000000);
+            continue;
+        }
+        if(self->doCapture)
+            WriteRingBuffer(self->ring, self->read_data, amt/frameSize);
+    }
+
+    return 0;
+}
+
+
+static void ALCcaptureOSS_Construct(ALCcaptureOSS *self, ALCdevice *device)
+{
+    ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
+    SET_VTABLE2(ALCcaptureOSS, ALCbackend, self);
+}
+
+static ALCenum ALCcaptureOSS_open(ALCcaptureOSS *self, const ALCchar *name)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    int numFragmentsLogSize;
+    int log2FragmentSize;
+    unsigned int periods;
+    audio_buf_info info;
+    ALuint frameSize;
+    int numChannels;
+    int ossFormat;
+    int ossSpeed;
+    char *err;
+
+    if(!name)
+        name = oss_device;
+    else if(strcmp(name, oss_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    self->fd = open(oss_capture, O_RDONLY);
+    if(self->fd == -1)
+    {
+        ERR("Could not open %s: %s\n", oss_capture, strerror(errno));
+        return ALC_INVALID_VALUE;
+    }
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            ossFormat = AFMT_S8;
+            break;
+        case DevFmtUByte:
+            ossFormat = AFMT_U8;
+            break;
+        case DevFmtShort:
+            ossFormat = AFMT_S16_NE;
+            break;
+        case DevFmtUShort:
+        case DevFmtInt:
+        case DevFmtUInt:
+        case DevFmtFloat:
+            ERR("%s capture samples not supported\n", DevFmtTypeString(device->FmtType));
+            return ALC_INVALID_VALUE;
+    }
+
+    periods = 4;
+    numChannels = ChannelsFromDevFmt(device->FmtChans);
+    frameSize = numChannels * BytesFromDevFmt(device->FmtType);
+    ossSpeed = device->Frequency;
+    log2FragmentSize = log2i(device->UpdateSize * device->NumUpdates *
+                             frameSize / periods);
+
+    /* according to the OSS spec, 16 bytes are the minimum */
+    if (log2FragmentSize < 4)
+        log2FragmentSize = 4;
+    numFragmentsLogSize = (periods << 16) | log2FragmentSize;
+
+#define CHECKERR(func) if((func) < 0) {                                       \
+    err = #func;                                                              \
+    goto err;                                                                 \
+}
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize));
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_SETFMT, &ossFormat));
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_CHANNELS, &numChannels));
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_SPEED, &ossSpeed));
+    CHECKERR(ioctl(self->fd, SNDCTL_DSP_GETISPACE, &info));
+    if(0)
+    {
+    err:
+        ERR("%s failed: %s\n", err, strerror(errno));
+        close(self->fd);
+        self->fd = -1;
+        return ALC_INVALID_VALUE;
+    }
+#undef CHECKERR
+
+    if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
+    {
+        ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device->FmtChans), numChannels);
+        close(self->fd);
+        self->fd = -1;
+        return ALC_INVALID_VALUE;
+    }
+
+    if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
+         (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
+         (ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
+    {
+        ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device->FmtType), ossFormat);
+        close(self->fd);
+        self->fd = -1;
+        return ALC_INVALID_VALUE;
+    }
+
+    self->ring = CreateRingBuffer(frameSize, device->UpdateSize * device->NumUpdates);
+    if(!self->ring)
+    {
+        ERR("Ring buffer create failed\n");
+        close(self->fd);
+        self->fd = -1;
+        return ALC_OUT_OF_MEMORY;
+    }
+
+    self->data_size = info.fragsize;
+    self->read_data = calloc(1, self->data_size);
+
+    self->killNow = 0;
+    if(althrd_create(&self->thread, ALCcaptureOSS_recordProc, self) != althrd_success)
+    {
+        device->ExtraData = NULL;
+        close(self->fd);
+        self->fd = -1;
+        return ALC_OUT_OF_MEMORY;
+    }
+
+    al_string_copy_cstr(&device->DeviceName, name);
+
+    return ALC_NO_ERROR;
+}
+
+static void ALCcaptureOSS_close(ALCcaptureOSS *self)
+{
+    int res;
+
+    self->killNow = 1;
+    althrd_join(self->thread, &res);
+
+    close(self->fd);
+    self->fd = -1;
+
+    DestroyRingBuffer(self->ring);
+    self->ring = NULL;
+
+    free(self->read_data);
+    self->read_data = NULL;
+}
+
+static ALCboolean ALCcaptureOSS_start(ALCcaptureOSS *self)
+{
+    self->doCapture = 1;
+    return ALC_TRUE;
+}
+
+static void ALCcaptureOSS_stop(ALCcaptureOSS *self)
+{
+    self->doCapture = 0;
+}
+
+static ALCenum ALCcaptureOSS_captureSamples(ALCcaptureOSS *self, ALCvoid *buffer, ALCuint samples)
+{
+    ReadRingBuffer(self->ring, buffer, samples);
+    return ALC_NO_ERROR;
+}
+
+static ALCuint ALCcaptureOSS_availableSamples(ALCcaptureOSS *self)
+{
+    return RingBufferSize(self->ring);
+}
+
+
+typedef struct ALCossBackendFactory {
+    DERIVE_FROM_TYPE(ALCbackendFactory);
+} ALCossBackendFactory;
+#define ALCOSSBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCossBackendFactory, ALCbackendFactory) } }
+
+ALCbackendFactory *ALCossBackendFactory_getFactory(void);
+
+static ALCboolean ALCossBackendFactory_init(ALCossBackendFactory *self);
+static DECLARE_FORWARD(ALCossBackendFactory, ALCbackendFactory, void, deinit)
+static ALCboolean ALCossBackendFactory_querySupport(ALCossBackendFactory *self, ALCbackend_Type type);
+static void ALCossBackendFactory_probe(ALCossBackendFactory *self, enum DevProbe type);
+static ALCbackend* ALCossBackendFactory_createBackend(ALCossBackendFactory *self, ALCdevice *device, ALCbackend_Type type);
+DEFINE_ALCBACKENDFACTORY_VTABLE(ALCossBackendFactory);
+
+
+ALCbackendFactory *ALCossBackendFactory_getFactory(void)
+{
+    static ALCossBackendFactory factory = ALCOSSBACKENDFACTORY_INITIALIZER;
+    return STATIC_CAST(ALCbackendFactory, &factory);
+}
+
+
+ALCboolean ALCossBackendFactory_init(ALCossBackendFactory* UNUSED(self))
+{
+    ConfigValueStr("oss", "device", &oss_driver);
+    ConfigValueStr("oss", "capture", &oss_capture);
+
+    return ALC_TRUE;
+}
+
+ALCboolean ALCossBackendFactory_querySupport(ALCossBackendFactory* UNUSED(self), ALCbackend_Type type)
+{
+    if(type == ALCbackend_Playback || type == ALCbackend_Capture)
+        return ALC_TRUE;
+    return ALC_FALSE;
+}
+
+void ALCossBackendFactory_probe(ALCossBackendFactory* UNUSED(self), enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+        {
+#ifdef HAVE_STAT
+            struct stat buf;
+            if(stat(oss_driver, &buf) == 0)
+#endif
+                AppendAllDevicesList(oss_device);
+        }
+        break;
+
+        case CAPTURE_DEVICE_PROBE:
+        {
+#ifdef HAVE_STAT
+            struct stat buf;
+            if(stat(oss_capture, &buf) == 0)
+#endif
+                AppendCaptureDeviceList(oss_device);
+        }
+        break;
+    }
+}
+
+ALCbackend* ALCossBackendFactory_createBackend(ALCossBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
+{
+    if(type == ALCbackend_Playback)
+    {
+        ALCplaybackOSS *backend;
+
+        backend = ALCplaybackOSS_New(sizeof(*backend));
+        if(!backend) return NULL;
+        memset(backend, 0, sizeof(*backend));
+
+        ALCplaybackOSS_Construct(backend, device);
+
+        return STATIC_CAST(ALCbackend, backend);
+    }
+    if(type == ALCbackend_Capture)
+    {
+        ALCcaptureOSS *backend;
+
+        backend = ALCcaptureOSS_New(sizeof(*backend));
+        if(!backend) return NULL;
+        memset(backend, 0, sizeof(*backend));
+
+        ALCcaptureOSS_Construct(backend, device);
+
+        return STATIC_CAST(ALCbackend, backend);
+    }
+
+    return NULL;
+}
@@ -0,0 +1,469 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "alMain.h"
+#include "alu.h"
+#include "compat.h"
+
+#include <portaudio.h>
+
+
+static const ALCchar pa_device[] = "PortAudio Default";
+
+
+#ifdef HAVE_DYNLOAD
+static void *pa_handle;
+#define MAKE_FUNC(x) static __typeof(x) * p##x
+MAKE_FUNC(Pa_Initialize);
+MAKE_FUNC(Pa_Terminate);
+MAKE_FUNC(Pa_GetErrorText);
+MAKE_FUNC(Pa_StartStream);
+MAKE_FUNC(Pa_StopStream);
+MAKE_FUNC(Pa_OpenStream);
+MAKE_FUNC(Pa_CloseStream);
+MAKE_FUNC(Pa_GetDefaultOutputDevice);
+MAKE_FUNC(Pa_GetDefaultInputDevice);
+MAKE_FUNC(Pa_GetStreamInfo);
+#undef MAKE_FUNC
+
+#define Pa_Initialize                  pPa_Initialize
+#define Pa_Terminate                   pPa_Terminate
+#define Pa_GetErrorText                pPa_GetErrorText
+#define Pa_StartStream                 pPa_StartStream
+#define Pa_StopStream                  pPa_StopStream
+#define Pa_OpenStream                  pPa_OpenStream
+#define Pa_CloseStream                 pPa_CloseStream
+#define Pa_GetDefaultOutputDevice      pPa_GetDefaultOutputDevice
+#define Pa_GetDefaultInputDevice       pPa_GetDefaultInputDevice
+#define Pa_GetStreamInfo               pPa_GetStreamInfo
+#endif
+
+static ALCboolean pa_load(void)
+{
+    PaError err;
+
+#ifdef HAVE_DYNLOAD
+    if(!pa_handle)
+    {
+#ifdef _WIN32
+# define PALIB "portaudio.dll"
+#elif defined(__APPLE__) && defined(__MACH__)
+# define PALIB "libportaudio.2.dylib"
+#elif defined(__OpenBSD__)
+# define PALIB "libportaudio.so"
+#else
+# define PALIB "libportaudio.so.2"
+#endif
+
+        pa_handle = LoadLib(PALIB);
+        if(!pa_handle)
+            return ALC_FALSE;
+
+#define LOAD_FUNC(f) do {                                                     \
+    p##f = GetSymbol(pa_handle, #f);                                          \
+    if(p##f == NULL)                                                          \
+    {                                                                         \
+        CloseLib(pa_handle);                                                  \
+        pa_handle = NULL;                                                     \
+        return ALC_FALSE;                                                     \
+    }                                                                         \
+} while(0)
+        LOAD_FUNC(Pa_Initialize);
+        LOAD_FUNC(Pa_Terminate);
+        LOAD_FUNC(Pa_GetErrorText);
+        LOAD_FUNC(Pa_StartStream);
+        LOAD_FUNC(Pa_StopStream);
+        LOAD_FUNC(Pa_OpenStream);
+        LOAD_FUNC(Pa_CloseStream);
+        LOAD_FUNC(Pa_GetDefaultOutputDevice);
+        LOAD_FUNC(Pa_GetDefaultInputDevice);
+        LOAD_FUNC(Pa_GetStreamInfo);
+#undef LOAD_FUNC
+
+        if((err=Pa_Initialize()) != paNoError)
+        {
+            ERR("Pa_Initialize() returned an error: %s\n", Pa_GetErrorText(err));
+            CloseLib(pa_handle);
+            pa_handle = NULL;
+            return ALC_FALSE;
+        }
+    }
+#else
+    if((err=Pa_Initialize()) != paNoError)
+    {
+        ERR("Pa_Initialize() returned an error: %s\n", Pa_GetErrorText(err));
+        return ALC_FALSE;
+    }
+#endif
+    return ALC_TRUE;
+}
+
+
+typedef struct {
+    PaStream *stream;
+    PaStreamParameters params;
+    ALuint update_size;
+
+    RingBuffer *ring;
+} pa_data;
+
+
+static int pa_callback(const void *UNUSED(inputBuffer), void *outputBuffer,
+                       unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *UNUSED(timeInfo),
+                       const PaStreamCallbackFlags UNUSED(statusFlags), void *userData)
+{
+    ALCdevice *device = (ALCdevice*)userData;
+
+    aluMixData(device, outputBuffer, framesPerBuffer);
+    return 0;
+}
+
+static int pa_capture_cb(const void *inputBuffer, void *UNUSED(outputBuffer),
+                         unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *UNUSED(timeInfo),
+                         const PaStreamCallbackFlags UNUSED(statusFlags), void *userData)
+{
+    ALCdevice *device = (ALCdevice*)userData;
+    pa_data *data = (pa_data*)device->ExtraData;
+
+    WriteRingBuffer(data->ring, inputBuffer, framesPerBuffer);
+    return 0;
+}
+
+
+static ALCenum pa_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    pa_data *data;
+    PaError err;
+
+    if(!deviceName)
+        deviceName = pa_device;
+    else if(strcmp(deviceName, pa_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    data = (pa_data*)calloc(1, sizeof(pa_data));
+    data->update_size = device->UpdateSize;
+
+    data->params.device = -1;
+    if(!ConfigValueInt("port", "device", &data->params.device) ||
+       data->params.device < 0)
+        data->params.device = Pa_GetDefaultOutputDevice();
+    data->params.suggestedLatency = (device->UpdateSize*device->NumUpdates) /
+                                    (float)device->Frequency;
+    data->params.hostApiSpecificStreamInfo = NULL;
+
+    data->params.channelCount = ((device->FmtChans == DevFmtMono) ? 1 : 2);
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            data->params.sampleFormat = paInt8;
+            break;
+        case DevFmtUByte:
+            data->params.sampleFormat = paUInt8;
+            break;
+        case DevFmtUShort:
+            /* fall-through */
+        case DevFmtShort:
+            data->params.sampleFormat = paInt16;
+            break;
+        case DevFmtUInt:
+            /* fall-through */
+        case DevFmtInt:
+            data->params.sampleFormat = paInt32;
+            break;
+        case DevFmtFloat:
+            data->params.sampleFormat = paFloat32;
+            break;
+    }
+
+retry_open:
+    err = Pa_OpenStream(&data->stream, NULL, &data->params, device->Frequency,
+                        device->UpdateSize, paNoFlag, pa_callback, device);
+    if(err != paNoError)
+    {
+        if(data->params.sampleFormat == paFloat32)
+        {
+            data->params.sampleFormat = paInt16;
+            goto retry_open;
+        }
+        ERR("Pa_OpenStream() returned an error: %s\n", Pa_GetErrorText(err));
+        free(data);
+        return ALC_INVALID_VALUE;
+    }
+
+    device->ExtraData = data;
+    al_string_copy_cstr(&device->DeviceName, deviceName);
+
+    return ALC_NO_ERROR;
+}
+
+static void pa_close_playback(ALCdevice *device)
+{
+    pa_data *data = (pa_data*)device->ExtraData;
+    PaError err;
+
+    err = Pa_CloseStream(data->stream);
+    if(err != paNoError)
+        ERR("Error closing stream: %s\n", Pa_GetErrorText(err));
+
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean pa_reset_playback(ALCdevice *device)
+{
+    pa_data *data = (pa_data*)device->ExtraData;
+    const PaStreamInfo *streamInfo;
+
+    streamInfo = Pa_GetStreamInfo(data->stream);
+    device->Frequency = streamInfo->sampleRate;
+    device->UpdateSize = data->update_size;
+
+    if(data->params.sampleFormat == paInt8)
+        device->FmtType = DevFmtByte;
+    else if(data->params.sampleFormat == paUInt8)
+        device->FmtType = DevFmtUByte;
+    else if(data->params.sampleFormat == paInt16)
+        device->FmtType = DevFmtShort;
+    else if(data->params.sampleFormat == paInt32)
+        device->FmtType = DevFmtInt;
+    else if(data->params.sampleFormat == paFloat32)
+        device->FmtType = DevFmtFloat;
+    else
+    {
+        ERR("Unexpected sample format: 0x%lx\n", data->params.sampleFormat);
+        return ALC_FALSE;
+    }
+
+    if(data->params.channelCount == 2)
+        device->FmtChans = DevFmtStereo;
+    else if(data->params.channelCount == 1)
+        device->FmtChans = DevFmtMono;
+    else
+    {
+        ERR("Unexpected channel count: %u\n", data->params.channelCount);
+        return ALC_FALSE;
+    }
+    SetDefaultChannelOrder(device);
+
+    return ALC_TRUE;
+}
+
+static ALCboolean pa_start_playback(ALCdevice *device)
+{
+    pa_data *data = (pa_data*)device->ExtraData;
+    PaError err;
+
+    err = Pa_StartStream(data->stream);
+    if(err != paNoError)
+    {
+        ERR("Pa_StartStream() returned an error: %s\n", Pa_GetErrorText(err));
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void pa_stop_playback(ALCdevice *device)
+{
+    pa_data *data = (pa_data*)device->ExtraData;
+    PaError err;
+
+    err = Pa_StopStream(data->stream);
+    if(err != paNoError)
+        ERR("Error stopping stream: %s\n", Pa_GetErrorText(err));
+}
+
+
+static ALCenum pa_open_capture(ALCdevice *device, const ALCchar *deviceName)
+{
+    ALuint frame_size;
+    pa_data *data;
+    PaError err;
+
+    if(!deviceName)
+        deviceName = pa_device;
+    else if(strcmp(deviceName, pa_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    data = (pa_data*)calloc(1, sizeof(pa_data));
+    if(data == NULL)
+        return ALC_OUT_OF_MEMORY;
+
+    frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    data->ring = CreateRingBuffer(frame_size, device->UpdateSize*device->NumUpdates);
+    if(data->ring == NULL)
+        goto error;
+
+    data->params.device = -1;
+    if(!ConfigValueInt("port", "capture", &data->params.device) ||
+       data->params.device < 0)
+        data->params.device = Pa_GetDefaultInputDevice();
+    data->params.suggestedLatency = 0.0f;
+    data->params.hostApiSpecificStreamInfo = NULL;
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            data->params.sampleFormat = paInt8;
+            break;
+        case DevFmtUByte:
+            data->params.sampleFormat = paUInt8;
+            break;
+        case DevFmtShort:
+            data->params.sampleFormat = paInt16;
+            break;
+        case DevFmtInt:
+            data->params.sampleFormat = paInt32;
+            break;
+        case DevFmtFloat:
+            data->params.sampleFormat = paFloat32;
+            break;
+        case DevFmtUInt:
+        case DevFmtUShort:
+            ERR("%s samples not supported\n", DevFmtTypeString(device->FmtType));
+            goto error;
+    }
+    data->params.channelCount = ChannelsFromDevFmt(device->FmtChans);
+
+    err = Pa_OpenStream(&data->stream, &data->params, NULL, device->Frequency,
+                        paFramesPerBufferUnspecified, paNoFlag, pa_capture_cb, device);
+    if(err != paNoError)
+    {
+        ERR("Pa_OpenStream() returned an error: %s\n", Pa_GetErrorText(err));
+        goto error;
+    }
+
+    al_string_copy_cstr(&device->DeviceName, deviceName);
+
+    device->ExtraData = data;
+    return ALC_NO_ERROR;
+
+error:
+    DestroyRingBuffer(data->ring);
+    free(data);
+    return ALC_INVALID_VALUE;
+}
+
+static void pa_close_capture(ALCdevice *device)
+{
+    pa_data *data = (pa_data*)device->ExtraData;
+    PaError err;
+
+    err = Pa_CloseStream(data->stream);
+    if(err != paNoError)
+        ERR("Error closing stream: %s\n", Pa_GetErrorText(err));
+
+    DestroyRingBuffer(data->ring);
+    data->ring = NULL;
+
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static void pa_start_capture(ALCdevice *device)
+{
+    pa_data *data = device->ExtraData;
+    PaError err;
+
+    err = Pa_StartStream(data->stream);
+    if(err != paNoError)
+        ERR("Error starting stream: %s\n", Pa_GetErrorText(err));
+}
+
+static void pa_stop_capture(ALCdevice *device)
+{
+    pa_data *data = (pa_data*)device->ExtraData;
+    PaError err;
+
+    err = Pa_StopStream(data->stream);
+    if(err != paNoError)
+        ERR("Error stopping stream: %s\n", Pa_GetErrorText(err));
+}
+
+static ALCenum pa_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples)
+{
+    pa_data *data = device->ExtraData;
+    ReadRingBuffer(data->ring, buffer, samples);
+    return ALC_NO_ERROR;
+}
+
+static ALCuint pa_available_samples(ALCdevice *device)
+{
+    pa_data *data = device->ExtraData;
+    return RingBufferSize(data->ring);
+}
+
+
+static const BackendFuncs pa_funcs = {
+    pa_open_playback,
+    pa_close_playback,
+    pa_reset_playback,
+    pa_start_playback,
+    pa_stop_playback,
+    pa_open_capture,
+    pa_close_capture,
+    pa_start_capture,
+    pa_stop_capture,
+    pa_capture_samples,
+    pa_available_samples,
+    ALCdevice_GetLatencyDefault
+};
+
+ALCboolean alc_pa_init(BackendFuncs *func_list)
+{
+    if(!pa_load())
+        return ALC_FALSE;
+    *func_list = pa_funcs;
+    return ALC_TRUE;
+}
+
+void alc_pa_deinit(void)
+{
+#ifdef HAVE_DYNLOAD
+    if(pa_handle)
+    {
+        Pa_Terminate();
+        CloseLib(pa_handle);
+        pa_handle = NULL;
+    }
+#else
+    Pa_Terminate();
+#endif
+}
+
+void alc_pa_probe(enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+            AppendAllDevicesList(pa_device);
+            break;
+        case CAPTURE_DEVICE_PROBE:
+            AppendCaptureDeviceList(pa_device);
+            break;
+    }
+}
@@ -0,0 +1,295 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "alMain.h"
+#include "alu.h"
+#include "threads.h"
+
+#include <sndio.h>
+
+
+static const ALCchar sndio_device[] = "SndIO Default";
+
+
+static ALCboolean sndio_load(void)
+{
+    return ALC_TRUE;
+}
+
+
+typedef struct {
+    struct sio_hdl *sndHandle;
+
+    ALvoid *mix_data;
+    ALsizei data_size;
+
+    volatile int killNow;
+    althrd_t thread;
+} sndio_data;
+
+
+static int sndio_proc(void *ptr)
+{
+    ALCdevice *device = ptr;
+    sndio_data *data = device->ExtraData;
+    ALsizei frameSize;
+    size_t wrote;
+
+    SetRTPriority();
+    althrd_setname(althrd_current(), MIXER_THREAD_NAME);
+
+    frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    while(!data->killNow && device->Connected)
+    {
+        ALsizei len = data->data_size;
+        ALubyte *WritePtr = data->mix_data;
+
+        aluMixData(device, WritePtr, len/frameSize);
+        while(len > 0 && !data->killNow)
+        {
+            wrote = sio_write(data->sndHandle, WritePtr, len);
+            if(wrote == 0)
+            {
+                ERR("sio_write failed\n");
+                ALCdevice_Lock(device);
+                aluHandleDisconnect(device);
+                ALCdevice_Unlock(device);
+                break;
+            }
+
+            len -= wrote;
+            WritePtr += wrote;
+        }
+    }
+
+    return 0;
+}
+
+
+
+static ALCenum sndio_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    sndio_data *data;
+
+    if(!deviceName)
+        deviceName = sndio_device;
+    else if(strcmp(deviceName, sndio_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    data = calloc(1, sizeof(*data));
+    data->killNow = 0;
+
+    data->sndHandle = sio_open(NULL, SIO_PLAY, 0);
+    if(data->sndHandle == NULL)
+    {
+        free(data);
+        ERR("Could not open device\n");
+        return ALC_INVALID_VALUE;
+    }
+
+    al_string_copy_cstr(&device->DeviceName, deviceName);
+    device->ExtraData = data;
+
+    return ALC_NO_ERROR;
+}
+
+static void sndio_close_playback(ALCdevice *device)
+{
+    sndio_data *data = device->ExtraData;
+
+    sio_close(data->sndHandle);
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean sndio_reset_playback(ALCdevice *device)
+{
+    sndio_data *data = device->ExtraData;
+    struct sio_par par;
+
+    sio_initpar(&par);
+
+    par.rate = device->Frequency;
+    par.pchan = ((device->FmtChans != DevFmtMono) ? 2 : 1);
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            par.bits = 8;
+            par.sig = 1;
+            break;
+        case DevFmtUByte:
+            par.bits = 8;
+            par.sig = 0;
+            break;
+        case DevFmtFloat:
+        case DevFmtShort:
+            par.bits = 16;
+            par.sig = 1;
+            break;
+        case DevFmtUShort:
+            par.bits = 16;
+            par.sig = 0;
+            break;
+        case DevFmtInt:
+            par.bits = 32;
+            par.sig = 1;
+            break;
+        case DevFmtUInt:
+            par.bits = 32;
+            par.sig = 0;
+            break;
+    }
+    par.le = SIO_LE_NATIVE;
+
+    par.round = device->UpdateSize;
+    par.appbufsz = device->UpdateSize * (device->NumUpdates-1);
+    if(!par.appbufsz) par.appbufsz = device->UpdateSize;
+
+    if(!sio_setpar(data->sndHandle, &par) || !sio_getpar(data->sndHandle, &par))
+    {
+        ERR("Failed to set device parameters\n");
+        return ALC_FALSE;
+    }
+
+    if(par.bits != par.bps*8)
+    {
+        ERR("Padded samples not supported (%u of %u bits)\n", par.bits, par.bps*8);
+        return ALC_FALSE;
+    }
+
+    device->Frequency = par.rate;
+    device->FmtChans = ((par.pchan==1) ? DevFmtMono : DevFmtStereo);
+
+    if(par.bits == 8 && par.sig == 1)
+        device->FmtType = DevFmtByte;
+    else if(par.bits == 8 && par.sig == 0)
+        device->FmtType = DevFmtUByte;
+    else if(par.bits == 16 && par.sig == 1)
+        device->FmtType = DevFmtShort;
+    else if(par.bits == 16 && par.sig == 0)
+        device->FmtType = DevFmtUShort;
+    else if(par.bits == 32 && par.sig == 1)
+        device->FmtType = DevFmtInt;
+    else if(par.bits == 32 && par.sig == 0)
+        device->FmtType = DevFmtUInt;
+    else
+    {
+        ERR("Unhandled sample format: %s %u-bit\n", (par.sig?"signed":"unsigned"), par.bits);
+        return ALC_FALSE;
+    }
+
+    device->UpdateSize = par.round;
+    device->NumUpdates = (par.bufsz/par.round) + 1;
+
+    SetDefaultChannelOrder(device);
+
+    return ALC_TRUE;
+}
+
+static ALCboolean sndio_start_playback(ALCdevice *device)
+{
+    sndio_data *data = device->ExtraData;
+
+    if(!sio_start(data->sndHandle))
+    {
+        ERR("Error starting playback\n");
+        return ALC_FALSE;
+    }
+
+    data->data_size = device->UpdateSize * FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    data->mix_data = calloc(1, data->data_size);
+
+    data->killNow = 0;
+    if(althrd_create(&data->thread, sndio_proc, device) != althrd_success)
+    {
+        sio_stop(data->sndHandle);
+        free(data->mix_data);
+        data->mix_data = NULL;
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void sndio_stop_playback(ALCdevice *device)
+{
+    sndio_data *data = device->ExtraData;
+    int res;
+
+    if(data->killNow)
+        return;
+
+    data->killNow = 1;
+    althrd_join(data->thread, &res);
+
+    if(!sio_stop(data->sndHandle))
+        ERR("Error stopping device\n");
+
+    free(data->mix_data);
+    data->mix_data = NULL;
+}
+
+
+static const BackendFuncs sndio_funcs = {
+    sndio_open_playback,
+    sndio_close_playback,
+    sndio_reset_playback,
+    sndio_start_playback,
+    sndio_stop_playback,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ALCdevice_GetLatencyDefault
+};
+
+ALCboolean alc_sndio_init(BackendFuncs *func_list)
+{
+    if(!sndio_load())
+        return ALC_FALSE;
+    *func_list = sndio_funcs;
+    return ALC_TRUE;
+}
+
+void alc_sndio_deinit(void)
+{
+}
+
+void alc_sndio_probe(enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+            AppendAllDevicesList(sndio_device);
+            break;
+        case CAPTURE_DEVICE_PROBE:
+            break;
+    }
+}
@@ -0,0 +1,288 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <unistd.h>
+#include <errno.h>
+#include <math.h>
+
+#include "alMain.h"
+#include "alu.h"
+#include "threads.h"
+#include "compat.h"
+
+#include <sys/audioio.h>
+
+
+static const ALCchar solaris_device[] = "Solaris Default";
+
+static const char *solaris_driver = "/dev/audio";
+
+typedef struct {
+    int fd;
+
+    ALubyte *mix_data;
+    int data_size;
+
+    volatile int killNow;
+    althrd_t thread;
+} solaris_data;
+
+
+static int SolarisProc(void *ptr)
+{
+    ALCdevice *Device = (ALCdevice*)ptr;
+    solaris_data *data = (solaris_data*)Device->ExtraData;
+    ALint frameSize;
+    int wrote;
+
+    SetRTPriority();
+    althrd_setname(althrd_current(), MIXER_THREAD_NAME);
+
+    frameSize = FrameSizeFromDevFmt(Device->FmtChans, Device->FmtType);
+
+    while(!data->killNow && Device->Connected)
+    {
+        ALint len = data->data_size;
+        ALubyte *WritePtr = data->mix_data;
+
+        aluMixData(Device, WritePtr, len/frameSize);
+        while(len > 0 && !data->killNow)
+        {
+            wrote = write(data->fd, WritePtr, len);
+            if(wrote < 0)
+            {
+                if(errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
+                {
+                    ERR("write failed: %s\n", strerror(errno));
+                    ALCdevice_Lock(Device);
+                    aluHandleDisconnect(Device);
+                    ALCdevice_Unlock(Device);
+                    break;
+                }
+
+                al_nssleep(0, 1000000);
+                continue;
+            }
+
+            len -= wrote;
+            WritePtr += wrote;
+        }
+    }
+
+    return 0;
+}
+
+
+static ALCenum solaris_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    solaris_data *data;
+
+    if(!deviceName)
+        deviceName = solaris_device;
+    else if(strcmp(deviceName, solaris_device) != 0)
+        return ALC_INVALID_VALUE;
+
+    data = (solaris_data*)calloc(1, sizeof(solaris_data));
+    data->killNow = 0;
+
+    data->fd = open(solaris_driver, O_WRONLY);
+    if(data->fd == -1)
+    {
+        free(data);
+        ERR("Could not open %s: %s\n", solaris_driver, strerror(errno));
+        return ALC_INVALID_VALUE;
+    }
+
+    al_string_copy_cstr(&device->DeviceName, deviceName);
+    device->ExtraData = data;
+    return ALC_NO_ERROR;
+}
+
+static void solaris_close_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+
+    close(data->fd);
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean solaris_reset_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+    audio_info_t info;
+    ALuint frameSize;
+    int numChannels;
+
+    AUDIO_INITINFO(&info);
+
+    info.play.sample_rate = device->Frequency;
+
+    if(device->FmtChans != DevFmtMono)
+        device->FmtChans = DevFmtStereo;
+    numChannels = ChannelsFromDevFmt(device->FmtChans);
+    info.play.channels = numChannels;
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            info.play.precision = 8;
+            info.play.encoding = AUDIO_ENCODING_LINEAR;
+            break;
+        case DevFmtUByte:
+            info.play.precision = 8;
+            info.play.encoding = AUDIO_ENCODING_LINEAR8;
+            break;
+        case DevFmtUShort:
+        case DevFmtInt:
+        case DevFmtUInt:
+        case DevFmtFloat:
+            device->FmtType = DevFmtShort;
+            /* fall-through */
+        case DevFmtShort:
+            info.play.precision = 16;
+            info.play.encoding = AUDIO_ENCODING_LINEAR;
+            break;
+    }
+
+    frameSize = numChannels * BytesFromDevFmt(device->FmtType);
+    info.play.buffer_size = device->UpdateSize*device->NumUpdates * frameSize;
+
+    if(ioctl(data->fd, AUDIO_SETINFO, &info) < 0)
+    {
+        ERR("ioctl failed: %s\n", strerror(errno));
+        return ALC_FALSE;
+    }
+
+    if(ChannelsFromDevFmt(device->FmtChans) != info.play.channels)
+    {
+        ERR("Could not set %d channels, got %d instead\n", ChannelsFromDevFmt(device->FmtChans), info.play.channels);
+        return ALC_FALSE;
+    }
+
+    if(!((info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR8 && device->FmtType == DevFmtUByte) ||
+         (info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR && device->FmtType == DevFmtByte) ||
+         (info.play.precision == 16 && info.play.encoding == AUDIO_ENCODING_LINEAR && device->FmtType == DevFmtShort) ||
+         (info.play.precision == 32 && info.play.encoding == AUDIO_ENCODING_LINEAR && device->FmtType == DevFmtInt)))
+    {
+        ERR("Could not set %s samples, got %d (0x%x)\n", DevFmtTypeString(device->FmtType),
+            info.play.precision, info.play.encoding);
+        return ALC_FALSE;
+    }
+
+    device->Frequency = info.play.sample_rate;
+    device->UpdateSize = (info.play.buffer_size/device->NumUpdates) + 1;
+
+    SetDefaultChannelOrder(device);
+
+    return ALC_TRUE;
+}
+
+static ALCboolean solaris_start_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+
+    data->data_size = device->UpdateSize * FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    data->mix_data = calloc(1, data->data_size);
+
+    data->killNow = 0;
+    if(althrd_create(&data->thread, SolarisProc, device) != althrd_success)
+    {
+        free(data->mix_data);
+        data->mix_data = NULL;
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void solaris_stop_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+    int res;
+
+    if(data->killNow)
+        return;
+
+    data->killNow = 1;
+    althrd_join(data->thread, &res);
+
+    if(ioctl(data->fd, AUDIO_DRAIN) < 0)
+        ERR("Error draining device: %s\n", strerror(errno));
+
+    free(data->mix_data);
+    data->mix_data = NULL;
+}
+
+
+static const BackendFuncs solaris_funcs = {
+    solaris_open_playback,
+    solaris_close_playback,
+    solaris_reset_playback,
+    solaris_start_playback,
+    solaris_stop_playback,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ALCdevice_GetLatencyDefault
+};
+
+ALCboolean alc_solaris_init(BackendFuncs *func_list)
+{
+    ConfigValueStr("solaris", "device", &solaris_driver);
+
+    *func_list = solaris_funcs;
+    return ALC_TRUE;
+}
+
+void alc_solaris_deinit(void)
+{
+}
+
+void alc_solaris_probe(enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+        {
+#ifdef HAVE_STAT
+            struct stat buf;
+            if(stat(solaris_driver, &buf) == 0)
+#endif
+                AppendAllDevicesList(solaris_device);
+        }
+        break;
+
+        case CAPTURE_DEVICE_PROBE:
+            break;
+    }
+}
@@ -0,0 +1,377 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <errno.h>
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+
+#include "alMain.h"
+#include "alu.h"
+#include "threads.h"
+#include "compat.h"
+
+
+typedef struct {
+    FILE *f;
+    long DataStart;
+
+    ALvoid *buffer;
+    ALuint size;
+
+    volatile int killNow;
+    althrd_t thread;
+} wave_data;
+
+
+static const ALCchar waveDevice[] = "Wave File Writer";
+
+static const ALubyte SUBTYPE_PCM[] = {
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa,
+    0x00, 0x38, 0x9b, 0x71
+};
+static const ALubyte SUBTYPE_FLOAT[] = {
+    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa,
+    0x00, 0x38, 0x9b, 0x71
+};
+
+static const ALuint channel_masks[] = {
+    0, /* invalid */
+    0x4, /* Mono */
+    0x1 | 0x2, /* Stereo */
+    0, /* 3 channel */
+    0x1 | 0x2 | 0x10 | 0x20, /* Quad */
+    0, /* 5 channel */
+    0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20, /* 5.1 */
+    0x1 | 0x2 | 0x4 | 0x8 | 0x100 | 0x200 | 0x400, /* 6.1 */
+    0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20 | 0x200 | 0x400, /* 7.1 */
+};
+
+
+static void fwrite16le(ALushort val, FILE *f)
+{
+    fputc(val&0xff, f);
+    fputc((val>>8)&0xff, f);
+}
+
+static void fwrite32le(ALuint val, FILE *f)
+{
+    fputc(val&0xff, f);
+    fputc((val>>8)&0xff, f);
+    fputc((val>>16)&0xff, f);
+    fputc((val>>24)&0xff, f);
+}
+
+
+static int WaveProc(void *ptr)
+{
+    ALCdevice *device = (ALCdevice*)ptr;
+    wave_data *data = (wave_data*)device->ExtraData;
+    struct timespec now, start;
+    ALint64 avail, done;
+    ALuint frameSize;
+    size_t fs;
+    const long restTime = (long)((ALuint64)device->UpdateSize * 1000000000 /
+                                 device->Frequency / 2);
+
+    althrd_setname(althrd_current(), MIXER_THREAD_NAME);
+
+    frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    done = 0;
+    if(altimespec_get(&start, AL_TIME_UTC) != AL_TIME_UTC)
+    {
+        ERR("Failed to get starting time\n");
+        return 1;
+    }
+    while(!data->killNow && device->Connected)
+    {
+        if(altimespec_get(&now, AL_TIME_UTC) != AL_TIME_UTC)
+        {
+            ERR("Failed to get current time\n");
+            return 1;
+        }
+
+        avail  = (now.tv_sec - start.tv_sec) * device->Frequency;
+        avail += (ALint64)(now.tv_nsec - start.tv_nsec) * device->Frequency / 1000000000;
+        if(avail < done)
+        {
+            /* Oops, time skipped backwards. Reset the number of samples done
+             * with one update available since we (likely) just came back from
+             * sleeping. */
+            done = avail - device->UpdateSize;
+        }
+
+        if(avail-done < device->UpdateSize)
+            al_nssleep(0, restTime);
+        else while(avail-done >= device->UpdateSize)
+        {
+            aluMixData(device, data->buffer, device->UpdateSize);
+            done += device->UpdateSize;
+
+            if(!IS_LITTLE_ENDIAN)
+            {
+                ALuint bytesize = BytesFromDevFmt(device->FmtType);
+                ALubyte *bytes = data->buffer;
+                ALuint i;
+
+                if(bytesize == 1)
+                {
+                    for(i = 0;i < data->size;i++)
+                        fputc(bytes[i], data->f);
+                }
+                else if(bytesize == 2)
+                {
+                    for(i = 0;i < data->size;i++)
+                        fputc(bytes[i^1], data->f);
+                }
+                else if(bytesize == 4)
+                {
+                    for(i = 0;i < data->size;i++)
+                        fputc(bytes[i^3], data->f);
+                }
+            }
+            else
+            {
+                fs = fwrite(data->buffer, frameSize, device->UpdateSize,
+                            data->f);
+                (void)fs;
+            }
+            if(ferror(data->f))
+            {
+                ERR("Error writing to file\n");
+                ALCdevice_Lock(device);
+                aluHandleDisconnect(device);
+                ALCdevice_Unlock(device);
+                break;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static ALCenum wave_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    wave_data *data;
+    const char *fname;
+
+    fname = GetConfigValue("wave", "file", "");
+    if(!fname[0])
+        return ALC_INVALID_VALUE;
+
+    if(!deviceName)
+        deviceName = waveDevice;
+    else if(strcmp(deviceName, waveDevice) != 0)
+        return ALC_INVALID_VALUE;
+
+    data = (wave_data*)calloc(1, sizeof(wave_data));
+
+    data->f = al_fopen(fname, "wb");
+    if(!data->f)
+    {
+        free(data);
+        ERR("Could not open file '%s': %s\n", fname, strerror(errno));
+        return ALC_INVALID_VALUE;
+    }
+
+    al_string_copy_cstr(&device->DeviceName, deviceName);
+    device->ExtraData = data;
+    return ALC_NO_ERROR;
+}
+
+static void wave_close_playback(ALCdevice *device)
+{
+    wave_data *data = (wave_data*)device->ExtraData;
+
+    fclose(data->f);
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean wave_reset_playback(ALCdevice *device)
+{
+    wave_data *data = (wave_data*)device->ExtraData;
+    ALuint channels=0, bits=0;
+    size_t val;
+
+    fseek(data->f, 0, SEEK_SET);
+    clearerr(data->f);
+
+    switch(device->FmtType)
+    {
+        case DevFmtByte:
+            device->FmtType = DevFmtUByte;
+            break;
+        case DevFmtUShort:
+            device->FmtType = DevFmtShort;
+            break;
+        case DevFmtUInt:
+            device->FmtType = DevFmtInt;
+            break;
+        case DevFmtUByte:
+        case DevFmtShort:
+        case DevFmtInt:
+        case DevFmtFloat:
+            break;
+    }
+    bits = BytesFromDevFmt(device->FmtType) * 8;
+    channels = ChannelsFromDevFmt(device->FmtChans);
+
+    fprintf(data->f, "RIFF");
+    fwrite32le(0xFFFFFFFF, data->f); // 'RIFF' header len; filled in at close
+
+    fprintf(data->f, "WAVE");
+
+    fprintf(data->f, "fmt ");
+    fwrite32le(40, data->f); // 'fmt ' header len; 40 bytes for EXTENSIBLE
+
+    // 16-bit val, format type id (extensible: 0xFFFE)
+    fwrite16le(0xFFFE, data->f);
+    // 16-bit val, channel count
+    fwrite16le(channels, data->f);
+    // 32-bit val, frequency
+    fwrite32le(device->Frequency, data->f);
+    // 32-bit val, bytes per second
+    fwrite32le(device->Frequency * channels * bits / 8, data->f);
+    // 16-bit val, frame size
+    fwrite16le(channels * bits / 8, data->f);
+    // 16-bit val, bits per sample
+    fwrite16le(bits, data->f);
+    // 16-bit val, extra byte count
+    fwrite16le(22, data->f);
+    // 16-bit val, valid bits per sample
+    fwrite16le(bits, data->f);
+    // 32-bit val, channel mask
+    fwrite32le(channel_masks[channels], data->f);
+    // 16 byte GUID, sub-type format
+    val = fwrite(((bits==32) ? SUBTYPE_FLOAT : SUBTYPE_PCM), 1, 16, data->f);
+    (void)val;
+
+    fprintf(data->f, "data");
+    fwrite32le(0xFFFFFFFF, data->f); // 'data' header len; filled in at close
+
+    if(ferror(data->f))
+    {
+        ERR("Error writing header: %s\n", strerror(errno));
+        return ALC_FALSE;
+    }
+    data->DataStart = ftell(data->f);
+
+    SetDefaultWFXChannelOrder(device);
+
+    return ALC_TRUE;
+}
+
+static ALCboolean wave_start_playback(ALCdevice *device)
+{
+    wave_data *data = (wave_data*)device->ExtraData;
+
+    data->size = device->UpdateSize * FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+    data->buffer = malloc(data->size);
+    if(!data->buffer)
+    {
+        ERR("Buffer malloc failed\n");
+        return ALC_FALSE;
+    }
+
+    data->killNow = 0;
+    if(althrd_create(&data->thread, WaveProc, device) != althrd_success)
+    {
+        free(data->buffer);
+        data->buffer = NULL;
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void wave_stop_playback(ALCdevice *device)
+{
+    wave_data *data = (wave_data*)device->ExtraData;
+    ALuint dataLen;
+    long size;
+    int res;
+
+    if(data->killNow)
+        return;
+
+    data->killNow = 1;
+    althrd_join(data->thread, &res);
+
+    free(data->buffer);
+    data->buffer = NULL;
+
+    size = ftell(data->f);
+    if(size > 0)
+    {
+        dataLen = size - data->DataStart;
+        if(fseek(data->f, data->DataStart-4, SEEK_SET) == 0)
+            fwrite32le(dataLen, data->f); // 'data' header len
+        if(fseek(data->f, 4, SEEK_SET) == 0)
+            fwrite32le(size-8, data->f); // 'WAVE' header len
+    }
+}
+
+
+static const BackendFuncs wave_funcs = {
+    wave_open_playback,
+    wave_close_playback,
+    wave_reset_playback,
+    wave_start_playback,
+    wave_stop_playback,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ALCdevice_GetLatencyDefault
+};
+
+ALCboolean alc_wave_init(BackendFuncs *func_list)
+{
+    *func_list = wave_funcs;
+    return ALC_TRUE;
+}
+
+void alc_wave_deinit(void)
+{
+}
+
+void alc_wave_probe(enum DevProbe type)
+{
+    if(!ConfigValueExists("wave", "file"))
+        return;
+
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+            AppendAllDevicesList(waveDevice);
+            break;
+        case CAPTURE_DEVICE_PROBE:
+            break;
+    }
+}
@@ -0,0 +1,716 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+
+#include <windows.h>
+#include <mmsystem.h>
+
+#include "alMain.h"
+#include "alu.h"
+#include "threads.h"
+
+#ifndef WAVE_FORMAT_IEEE_FLOAT
+#define WAVE_FORMAT_IEEE_FLOAT  0x0003
+#endif
+
+
+typedef struct {
+    // MMSYSTEM Device
+    volatile ALboolean killNow;
+    althrd_t thread;
+
+    RefCount WaveBuffersCommitted;
+    WAVEHDR WaveBuffer[4];
+
+    union {
+        HWAVEIN  In;
+        HWAVEOUT Out;
+    } WaveHandle;
+
+    WAVEFORMATEX Format;
+
+    RingBuffer *Ring;
+} WinMMData;
+
+
+TYPEDEF_VECTOR(al_string, vector_al_string)
+static vector_al_string PlaybackDevices;
+static vector_al_string CaptureDevices;
+
+static void clear_devlist(vector_al_string *list)
+{
+    VECTOR_FOR_EACH(al_string, *list, al_string_deinit);
+    VECTOR_RESIZE(*list, 0);
+}
+
+
+static void ProbePlaybackDevices(void)
+{
+    al_string *iter, *end;
+    ALuint numdevs;
+    ALuint i;
+
+    clear_devlist(&PlaybackDevices);
+
+    numdevs = waveOutGetNumDevs();
+    VECTOR_RESERVE(PlaybackDevices, numdevs);
+    for(i = 0;i < numdevs;i++)
+    {
+        WAVEOUTCAPSW WaveCaps;
+        al_string dname;
+
+        AL_STRING_INIT(dname);
+        if(waveOutGetDevCapsW(i, &WaveCaps, sizeof(WaveCaps)) == MMSYSERR_NOERROR)
+        {
+            ALuint count = 0;
+            do {
+                al_string_copy_wcstr(&dname, WaveCaps.szPname);
+                if(count != 0)
+                {
+                    char str[64];
+                    snprintf(str, sizeof(str), " #%d", count+1);
+                    al_string_append_cstr(&dname, str);
+                }
+                count++;
+
+                iter = VECTOR_ITER_BEGIN(PlaybackDevices);
+                end = VECTOR_ITER_END(PlaybackDevices);
+                for(;iter != end;iter++)
+                {
+                    if(al_string_cmp(*iter, dname) == 0)
+                        break;
+                }
+            } while(iter != end);
+
+            TRACE("Got device \"%s\", ID %u\n", al_string_get_cstr(dname), i);
+        }
+        VECTOR_PUSH_BACK(PlaybackDevices, dname);
+    }
+}
+
+static void ProbeCaptureDevices(void)
+{
+    al_string *iter, *end;
+    ALuint numdevs;
+    ALuint i;
+
+    clear_devlist(&CaptureDevices);
+
+    numdevs = waveInGetNumDevs();
+    VECTOR_RESERVE(CaptureDevices, numdevs);
+    for(i = 0;i < numdevs;i++)
+    {
+        WAVEINCAPSW WaveCaps;
+        al_string dname;
+
+        AL_STRING_INIT(dname);
+        if(waveInGetDevCapsW(i, &WaveCaps, sizeof(WaveCaps)) == MMSYSERR_NOERROR)
+        {
+            ALuint count = 0;
+            do {
+                al_string_copy_wcstr(&dname, WaveCaps.szPname);
+                if(count != 0)
+                {
+                    char str[64];
+                    snprintf(str, sizeof(str), " #%d", count+1);
+                    al_string_append_cstr(&dname, str);
+                }
+                count++;
+
+                iter = VECTOR_ITER_BEGIN(CaptureDevices);
+                end = VECTOR_ITER_END(CaptureDevices);
+                for(;iter != end;iter++)
+                {
+                    if(al_string_cmp(*iter, dname) == 0)
+                        break;
+                }
+            } while(iter != end);
+
+            TRACE("Got device \"%s\", ID %u\n", al_string_get_cstr(dname), i);
+        }
+        VECTOR_PUSH_BACK(CaptureDevices, dname);
+    }
+}
+
+
+/*
+    WaveOutProc
+
+    Posts a message to 'PlaybackThreadProc' everytime a WaveOut Buffer is completed and
+    returns to the application (for more data)
+*/
+static void CALLBACK WaveOutProc(HWAVEOUT UNUSED(device), UINT msg, DWORD_PTR instance, DWORD_PTR param1, DWORD_PTR UNUSED(param2))
+{
+    ALCdevice *Device = (ALCdevice*)instance;
+    WinMMData *data = Device->ExtraData;
+
+    if(msg != WOM_DONE)
+        return;
+
+    DecrementRef(&data->WaveBuffersCommitted);
+    PostThreadMessage(data->thread, msg, 0, param1);
+}
+
+FORCE_ALIGN static int PlaybackThreadProc(void *arg)
+{
+    ALCdevice *Device = (ALCdevice*)arg;
+    WinMMData *data = Device->ExtraData;
+    WAVEHDR *WaveHdr;
+    MSG msg;
+
+    SetRTPriority();
+    althrd_setname(althrd_current(), MIXER_THREAD_NAME);
+
+    while(GetMessage(&msg, NULL, 0, 0))
+    {
+        if(msg.message != WOM_DONE)
+            continue;
+
+        if(data->killNow)
+        {
+            if(ReadRef(&data->WaveBuffersCommitted) == 0)
+                break;
+            continue;
+        }
+
+        WaveHdr = ((WAVEHDR*)msg.lParam);
+        aluMixData(Device, WaveHdr->lpData, WaveHdr->dwBufferLength /
+                                            data->Format.nBlockAlign);
+
+        // Send buffer back to play more data
+        waveOutWrite(data->WaveHandle.Out, WaveHdr, sizeof(WAVEHDR));
+        IncrementRef(&data->WaveBuffersCommitted);
+    }
+
+    return 0;
+}
+
+/*
+    WaveInProc
+
+    Posts a message to 'CaptureThreadProc' everytime a WaveIn Buffer is completed and
+    returns to the application (with more data)
+*/
+static void CALLBACK WaveInProc(HWAVEIN UNUSED(device), UINT msg, DWORD_PTR instance, DWORD_PTR param1, DWORD_PTR UNUSED(param2))
+{
+    ALCdevice *Device = (ALCdevice*)instance;
+    WinMMData *data = Device->ExtraData;
+
+    if(msg != WIM_DATA)
+        return;
+
+    DecrementRef(&data->WaveBuffersCommitted);
+    PostThreadMessage(data->thread, msg, 0, param1);
+}
+
+static int CaptureThreadProc(void *arg)
+{
+    ALCdevice *Device = (ALCdevice*)arg;
+    WinMMData *data = Device->ExtraData;
+    WAVEHDR *WaveHdr;
+    MSG msg;
+
+    althrd_setname(althrd_current(), "alsoft-record");
+
+    while(GetMessage(&msg, NULL, 0, 0))
+    {
+        if(msg.message != WIM_DATA)
+            continue;
+        /* Don't wait for other buffers to finish before quitting. We're
+         * closing so we don't need them. */
+        if(data->killNow)
+            break;
+
+        WaveHdr = ((WAVEHDR*)msg.lParam);
+        WriteRingBuffer(data->Ring, (ALubyte*)WaveHdr->lpData,
+                        WaveHdr->dwBytesRecorded/data->Format.nBlockAlign);
+
+        // Send buffer back to capture more data
+        waveInAddBuffer(data->WaveHandle.In, WaveHdr, sizeof(WAVEHDR));
+        IncrementRef(&data->WaveBuffersCommitted);
+    }
+
+    return 0;
+}
+
+
+static ALCenum WinMMOpenPlayback(ALCdevice *Device, const ALCchar *deviceName)
+{
+    WinMMData *data = NULL;
+    const al_string *iter, *end;
+    UINT DeviceID;
+    MMRESULT res;
+
+    if(VECTOR_SIZE(PlaybackDevices) == 0)
+        ProbePlaybackDevices();
+
+    // Find the Device ID matching the deviceName if valid
+    iter = VECTOR_ITER_BEGIN(PlaybackDevices);
+    end = VECTOR_ITER_END(PlaybackDevices);
+    for(;iter != end;iter++)
+    {
+        if(!al_string_empty(*iter) &&
+           (!deviceName || al_string_cmp_cstr(*iter, deviceName) == 0))
+        {
+            DeviceID = (UINT)(iter - VECTOR_ITER_BEGIN(PlaybackDevices));
+            break;
+        }
+    }
+    if(iter == end)
+        return ALC_INVALID_VALUE;
+
+    data = calloc(1, sizeof(*data));
+    if(!data)
+        return ALC_OUT_OF_MEMORY;
+    Device->ExtraData = data;
+
+retry_open:
+    memset(&data->Format, 0, sizeof(WAVEFORMATEX));
+    if(Device->FmtType == DevFmtFloat)
+    {
+        data->Format.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
+        data->Format.wBitsPerSample = 32;
+    }
+    else
+    {
+        data->Format.wFormatTag = WAVE_FORMAT_PCM;
+        if(Device->FmtType == DevFmtUByte || Device->FmtType == DevFmtByte)
+            data->Format.wBitsPerSample = 8;
+        else
+            data->Format.wBitsPerSample = 16;
+    }
+    data->Format.nChannels = ((Device->FmtChans == DevFmtMono) ? 1 : 2);
+    data->Format.nBlockAlign = data->Format.wBitsPerSample *
+                               data->Format.nChannels / 8;
+    data->Format.nSamplesPerSec = Device->Frequency;
+    data->Format.nAvgBytesPerSec = data->Format.nSamplesPerSec *
+                                   data->Format.nBlockAlign;
+    data->Format.cbSize = 0;
+
+    if((res=waveOutOpen(&data->WaveHandle.Out, DeviceID, &data->Format, (DWORD_PTR)&WaveOutProc, (DWORD_PTR)Device, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
+    {
+        if(Device->FmtType == DevFmtFloat)
+        {
+            Device->FmtType = DevFmtShort;
+            goto retry_open;
+        }
+        ERR("waveOutOpen failed: %u\n", res);
+        goto failure;
+    }
+
+    al_string_copy(&Device->DeviceName, VECTOR_ELEM(PlaybackDevices, DeviceID));
+    return ALC_NO_ERROR;
+
+failure:
+    if(data->WaveHandle.Out)
+        waveOutClose(data->WaveHandle.Out);
+
+    free(data);
+    Device->ExtraData = NULL;
+    return ALC_INVALID_VALUE;
+}
+
+static void WinMMClosePlayback(ALCdevice *device)
+{
+    WinMMData *data = (WinMMData*)device->ExtraData;
+
+    // Close the Wave device
+    waveOutClose(data->WaveHandle.Out);
+    data->WaveHandle.Out = 0;
+
+    free(data);
+    device->ExtraData = NULL;
+}
+
+static ALCboolean WinMMResetPlayback(ALCdevice *device)
+{
+    WinMMData *data = (WinMMData*)device->ExtraData;
+
+    device->UpdateSize = (ALuint)((ALuint64)device->UpdateSize *
+                                  data->Format.nSamplesPerSec /
+                                  device->Frequency);
+    device->UpdateSize = (device->UpdateSize*device->NumUpdates + 3) / 4;
+    device->NumUpdates = 4;
+    device->Frequency = data->Format.nSamplesPerSec;
+
+    if(data->Format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
+    {
+        if(data->Format.wBitsPerSample == 32)
+            device->FmtType = DevFmtFloat;
+        else
+        {
+            ERR("Unhandled IEEE float sample depth: %d\n", data->Format.wBitsPerSample);
+            return ALC_FALSE;
+        }
+    }
+    else if(data->Format.wFormatTag == WAVE_FORMAT_PCM)
+    {
+        if(data->Format.wBitsPerSample == 16)
+            device->FmtType = DevFmtShort;
+        else if(data->Format.wBitsPerSample == 8)
+            device->FmtType = DevFmtUByte;
+        else
+        {
+            ERR("Unhandled PCM sample depth: %d\n", data->Format.wBitsPerSample);
+            return ALC_FALSE;
+        }
+    }
+    else
+    {
+        ERR("Unhandled format tag: 0x%04x\n", data->Format.wFormatTag);
+        return ALC_FALSE;
+    }
+
+    if(data->Format.nChannels == 2)
+        device->FmtChans = DevFmtStereo;
+    else if(data->Format.nChannels == 1)
+        device->FmtChans = DevFmtMono;
+    else
+    {
+        ERR("Unhandled channel count: %d\n", data->Format.nChannels);
+        return ALC_FALSE;
+    }
+    SetDefaultWFXChannelOrder(device);
+
+    return ALC_TRUE;
+}
+
+static ALCboolean WinMMStartPlayback(ALCdevice *device)
+{
+    WinMMData *data = (WinMMData*)device->ExtraData;
+    ALbyte *BufferData;
+    ALint BufferSize;
+    ALuint i;
+
+    data->killNow = AL_FALSE;
+    if(althrd_create(&data->thread, PlaybackThreadProc, device) != althrd_success)
+        return ALC_FALSE;
+
+    InitRef(&data->WaveBuffersCommitted, 0);
+
+    // Create 4 Buffers
+    BufferSize  = device->UpdateSize*device->NumUpdates / 4;
+    BufferSize *= FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
+
+    BufferData = calloc(4, BufferSize);
+    for(i = 0;i < 4;i++)
+    {
+        memset(&data->WaveBuffer[i], 0, sizeof(WAVEHDR));
+        data->WaveBuffer[i].dwBufferLength = BufferSize;
+        data->WaveBuffer[i].lpData = ((i==0) ? (CHAR*)BufferData :
+                                      (data->WaveBuffer[i-1].lpData +
+                                       data->WaveBuffer[i-1].dwBufferLength));
+        waveOutPrepareHeader(data->WaveHandle.Out, &data->WaveBuffer[i], sizeof(WAVEHDR));
+        waveOutWrite(data->WaveHandle.Out, &data->WaveBuffer[i], sizeof(WAVEHDR));
+        IncrementRef(&data->WaveBuffersCommitted);
+    }
+
+    return ALC_TRUE;
+}
+
+static void WinMMStopPlayback(ALCdevice *device)
+{
+    WinMMData *data = (WinMMData*)device->ExtraData;
+    void *buffer = NULL;
+    int i;
+
+    if(data->killNow)
+        return;
+
+    // Set flag to stop processing headers
+    data->killNow = AL_TRUE;
+    althrd_join(data->thread, &i);
+
+    // Release the wave buffers
+    for(i = 0;i < 4;i++)
+    {
+        waveOutUnprepareHeader(data->WaveHandle.Out, &data->WaveBuffer[i], sizeof(WAVEHDR));
+        if(i == 0) buffer = data->WaveBuffer[i].lpData;
+        data->WaveBuffer[i].lpData = NULL;
+    }
+    free(buffer);
+}
+
+
+static ALCenum WinMMOpenCapture(ALCdevice *Device, const ALCchar *deviceName)
+{
+    const al_string *iter, *end;
+    ALbyte *BufferData = NULL;
+    DWORD CapturedDataSize;
+    WinMMData *data = NULL;
+    ALint BufferSize;
+    UINT DeviceID;
+    MMRESULT res;
+    ALuint i;
+
+    if(VECTOR_SIZE(CaptureDevices) == 0)
+        ProbeCaptureDevices();
+
+    // Find the Device ID matching the deviceName if valid
+    iter = VECTOR_ITER_BEGIN(CaptureDevices);
+    end = VECTOR_ITER_END(CaptureDevices);
+    for(;iter != end;iter++)
+    {
+        if(!al_string_empty(*iter) &&
+           (!deviceName || al_string_cmp_cstr(*iter, deviceName) == 0))
+        {
+            DeviceID = (UINT)(iter - VECTOR_ITER_BEGIN(CaptureDevices));
+            break;
+        }
+    }
+    if(iter == end)
+        return ALC_INVALID_VALUE;
+
+    switch(Device->FmtChans)
+    {
+        case DevFmtMono:
+        case DevFmtStereo:
+            break;
+
+        case DevFmtQuad:
+        case DevFmtX51:
+        case DevFmtX51Side:
+        case DevFmtX61:
+        case DevFmtX71:
+            return ALC_INVALID_ENUM;
+    }
+
+    switch(Device->FmtType)
+    {
+        case DevFmtUByte:
+        case DevFmtShort:
+        case DevFmtInt:
+        case DevFmtFloat:
+            break;
+
+        case DevFmtByte:
+        case DevFmtUShort:
+        case DevFmtUInt:
+            return ALC_INVALID_ENUM;
+    }
+
+    data = calloc(1, sizeof(*data));
+    if(!data)
+        return ALC_OUT_OF_MEMORY;
+    Device->ExtraData = data;
+
+    memset(&data->Format, 0, sizeof(WAVEFORMATEX));
+    data->Format.wFormatTag = ((Device->FmtType == DevFmtFloat) ?
+                               WAVE_FORMAT_IEEE_FLOAT : WAVE_FORMAT_PCM);
+    data->Format.nChannels = ChannelsFromDevFmt(Device->FmtChans);
+    data->Format.wBitsPerSample = BytesFromDevFmt(Device->FmtType) * 8;
+    data->Format.nBlockAlign = data->Format.wBitsPerSample *
+                               data->Format.nChannels / 8;
+    data->Format.nSamplesPerSec = Device->Frequency;
+    data->Format.nAvgBytesPerSec = data->Format.nSamplesPerSec *
+                                   data->Format.nBlockAlign;
+    data->Format.cbSize = 0;
+
+    if((res=waveInOpen(&data->WaveHandle.In, DeviceID, &data->Format, (DWORD_PTR)&WaveInProc, (DWORD_PTR)Device, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
+    {
+        ERR("waveInOpen failed: %u\n", res);
+        goto failure;
+    }
+
+    // Allocate circular memory buffer for the captured audio
+    CapturedDataSize = Device->UpdateSize*Device->NumUpdates;
+
+    // Make sure circular buffer is at least 100ms in size
+    if(CapturedDataSize < (data->Format.nSamplesPerSec / 10))
+        CapturedDataSize = data->Format.nSamplesPerSec / 10;
+
+    data->Ring = CreateRingBuffer(data->Format.nBlockAlign, CapturedDataSize);
+    if(!data->Ring)
+        goto failure;
+
+    InitRef(&data->WaveBuffersCommitted, 0);
+
+    // Create 4 Buffers of 50ms each
+    BufferSize = data->Format.nAvgBytesPerSec / 20;
+    BufferSize -= (BufferSize % data->Format.nBlockAlign);
+
+    BufferData = calloc(4, BufferSize);
+    if(!BufferData)
+        goto failure;
+
+    for(i = 0;i < 4;i++)
+    {
+        memset(&data->WaveBuffer[i], 0, sizeof(WAVEHDR));
+        data->WaveBuffer[i].dwBufferLength = BufferSize;
+        data->WaveBuffer[i].lpData = ((i==0) ? (CHAR*)BufferData :
+                                      (data->WaveBuffer[i-1].lpData +
+                                       data->WaveBuffer[i-1].dwBufferLength));
+        data->WaveBuffer[i].dwFlags = 0;
+        data->WaveBuffer[i].dwLoops = 0;
+        waveInPrepareHeader(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
+        waveInAddBuffer(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
+        IncrementRef(&data->WaveBuffersCommitted);
+    }
+
+    if(althrd_create(&data->thread, CaptureThreadProc, Device) != althrd_success)
+        goto failure;
+
+    al_string_copy(&Device->DeviceName, VECTOR_ELEM(CaptureDevices, DeviceID));
+    return ALC_NO_ERROR;
+
+failure:
+    if(BufferData)
+    {
+        for(i = 0;i < 4;i++)
+            waveInUnprepareHeader(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
+        free(BufferData);
+    }
+
+    if(data->Ring)
+        DestroyRingBuffer(data->Ring);
+
+    if(data->WaveHandle.In)
+        waveInClose(data->WaveHandle.In);
+
+    free(data);
+    Device->ExtraData = NULL;
+    return ALC_INVALID_VALUE;
+}
+
+static void WinMMCloseCapture(ALCdevice *Device)
+{
+    WinMMData *data = (WinMMData*)Device->ExtraData;
+    void *buffer = NULL;
+    int i;
+
+    /* Tell the processing thread to quit and wait for it to do so. */
+    data->killNow = AL_TRUE;
+    PostThreadMessage(data->thread, WM_QUIT, 0, 0);
+
+    althrd_join(data->thread, &i);
+
+    /* Make sure capture is stopped and all pending buffers are flushed. */
+    waveInReset(data->WaveHandle.In);
+
+    // Release the wave buffers
+    for(i = 0;i < 4;i++)
+    {
+        waveInUnprepareHeader(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
+        if(i == 0) buffer = data->WaveBuffer[i].lpData;
+        data->WaveBuffer[i].lpData = NULL;
+    }
+    free(buffer);
+
+    DestroyRingBuffer(data->Ring);
+    data->Ring = NULL;
+
+    // Close the Wave device
+    waveInClose(data->WaveHandle.In);
+    data->WaveHandle.In = 0;
+
+    free(data);
+    Device->ExtraData = NULL;
+}
+
+static void WinMMStartCapture(ALCdevice *Device)
+{
+    WinMMData *data = (WinMMData*)Device->ExtraData;
+    waveInStart(data->WaveHandle.In);
+}
+
+static void WinMMStopCapture(ALCdevice *Device)
+{
+    WinMMData *data = (WinMMData*)Device->ExtraData;
+    waveInStop(data->WaveHandle.In);
+}
+
+static ALCenum WinMMCaptureSamples(ALCdevice *Device, ALCvoid *Buffer, ALCuint Samples)
+{
+    WinMMData *data = (WinMMData*)Device->ExtraData;
+    ReadRingBuffer(data->Ring, Buffer, Samples);
+    return ALC_NO_ERROR;
+}
+
+static ALCuint WinMMAvailableSamples(ALCdevice *Device)
+{
+    WinMMData *data = (WinMMData*)Device->ExtraData;
+    return RingBufferSize(data->Ring);
+}
+
+
+static inline void AppendAllDevicesList2(const al_string *name)
+{
+    if(!al_string_empty(*name))
+        AppendAllDevicesList(al_string_get_cstr(*name));
+}
+static inline void AppendCaptureDeviceList2(const al_string *name)
+{
+    if(!al_string_empty(*name))
+        AppendCaptureDeviceList(al_string_get_cstr(*name));
+}
+
+static const BackendFuncs WinMMFuncs = {
+    WinMMOpenPlayback,
+    WinMMClosePlayback,
+    WinMMResetPlayback,
+    WinMMStartPlayback,
+    WinMMStopPlayback,
+    WinMMOpenCapture,
+    WinMMCloseCapture,
+    WinMMStartCapture,
+    WinMMStopCapture,
+    WinMMCaptureSamples,
+    WinMMAvailableSamples,
+    ALCdevice_GetLatencyDefault
+};
+
+ALCboolean alcWinMMInit(BackendFuncs *FuncList)
+{
+    VECTOR_INIT(PlaybackDevices);
+    VECTOR_INIT(CaptureDevices);
+
+    *FuncList = WinMMFuncs;
+    return ALC_TRUE;
+}
+
+void alcWinMMDeinit()
+{
+    clear_devlist(&PlaybackDevices);
+    VECTOR_DEINIT(PlaybackDevices);
+
+    clear_devlist(&CaptureDevices);
+    VECTOR_DEINIT(CaptureDevices);
+}
+
+void alcWinMMProbe(enum DevProbe type)
+{
+    switch(type)
+    {
+        case ALL_DEVICE_PROBE:
+            ProbePlaybackDevices();
+            VECTOR_FOR_EACH(const al_string, PlaybackDevices, AppendAllDevicesList2);
+            break;
+
+        case CAPTURE_DEVICE_PROBE:
+            ProbeCaptureDevices();
+            VECTOR_FOR_EACH(const al_string, CaptureDevices, AppendCaptureDeviceList2);
+            break;
+    }
+}
@@ -1,201 +1,143 @@
-/*-
- * Copyright (c) 2005 Boris Mikhaylov
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <math.h>
-
-#include "bs2b.h"
-
-#ifndef M_PI
-#define M_PI  3.14159265358979323846
-#endif
-
-/* Single pole IIR filter.
- * O[n] = a0*I[n] + a1*I[n-1] + b1*O[n-1]
- */
-
-/* Lowpass filter */
-#define lo_filter(in, out_1) (bs2b->a0_lo*(in) + bs2b->b1_lo*(out_1))
-
-/* Highboost filter */
-#define hi_filter(in, in_1, out_1) (bs2b->a0_hi*(in) + bs2b->a1_hi*(in_1) + bs2b->b1_hi*(out_1))
-
-/* Set up all data. */
-static void init(struct bs2b *bs2b)
-{
-    double Fc_lo, Fc_hi;
-    double G_lo,  G_hi;
-    double x;
-
-    if ((bs2b->srate > 192000) || (bs2b->srate < 2000))
-        bs2b->srate = BS2B_DEFAULT_SRATE;
-
-    switch(bs2b->level)
-    {
-    case BS2B_LOW_CLEVEL: /* Low crossfeed level */
-        Fc_lo = 360.0;
-        Fc_hi = 501.0;
-        G_lo  = 0.398107170553497;
-        G_hi  = 0.205671765275719;
-        break;
-
-    case BS2B_MIDDLE_CLEVEL: /* Middle crossfeed level */
-        Fc_lo = 500.0;
-        Fc_hi = 711.0;
-        G_lo  = 0.459726988530872;
-        G_hi  = 0.228208484414988;
-        break;
-
-    case BS2B_HIGH_CLEVEL: /* High crossfeed level (virtual speakers are closer to itself) */
-        Fc_lo = 700.0;
-        Fc_hi = 1021.0;
-        G_lo  = 0.530884444230988;
-        G_hi  = 0.250105790667544;
-        break;
-
-    case BS2B_LOW_ECLEVEL: /* Low easy crossfeed level */
-        Fc_lo = 360.0;
-        Fc_hi = 494.0;
-        G_lo  = 0.316227766016838;
-        G_hi  = 0.168236228897329;
-        break;
-
-    case BS2B_MIDDLE_ECLEVEL: /* Middle easy crossfeed level */
-        Fc_lo = 500.0;
-        Fc_hi = 689.0;
-        G_lo  = 0.354813389233575;
-        G_hi  = 0.187169483835901;
-        break;
-
-    default: /* High easy crossfeed level */
-        bs2b->level = BS2B_HIGH_ECLEVEL;
-
-        Fc_lo = 700.0;
-        Fc_hi = 975.0;
-        G_lo  = 0.398107170553497;
-        G_hi  = 0.205671765275719;
-        break;
-    } /* switch */
-
-    /* $fc = $Fc / $s;
-     * $d  = 1 / 2 / pi / $fc;
-     * $x  = exp(-1 / $d);
-     */
-
-    x           = exp(-2.0 * M_PI * Fc_lo / bs2b->srate);
-    bs2b->b1_lo = x;
-    bs2b->a0_lo = G_lo * (1.0 - x);
-
-    x           = exp(-2.0 * M_PI * Fc_hi / bs2b->srate);
-    bs2b->b1_hi = x;
-    bs2b->a0_hi = 1.0 - G_hi * (1.0 - x);
-    bs2b->a1_hi = -x;
-
-    bs2b->gain  = 1.0 / (1.0 - G_hi + G_lo);
-
-    bs2b_clear(bs2b);
-} /* init */
-
-/* Exported functions.
- * See descriptions in "bs2b.h"
- */
-
-void bs2b_set_level(struct bs2b *bs2b, int level)
-{
-    if(level == bs2b->level)
-        return;
-    bs2b->level = level;
-    init(bs2b);
-} /* bs2b_set_level */
-
-int bs2b_get_level(struct bs2b *bs2b)
-{
-    return bs2b->level;
-} /* bs2b_get_level */
-
-void bs2b_set_srate(struct bs2b *bs2b, int srate)
-{
-    if (srate == bs2b->srate)
-        return;
-    bs2b->srate = srate;
-    init(bs2b);
-} /* bs2b_set_srate */
-
-int bs2b_get_srate(struct bs2b *bs2b)
-{
-    return bs2b->srate;
-} /* bs2b_get_srate */
-
-void bs2b_clear(struct bs2b *bs2b)
-{
-    int loopv = sizeof(bs2b->last_sample);
-
-    while (loopv)
-    {
-        ((char *)&bs2b->last_sample)[--loopv] = 0;
-    }
-} /* bs2b_clear */
-
-int bs2b_is_clear(struct bs2b *bs2b)
-{
-    int loopv = sizeof(bs2b->last_sample);
-
-    while (loopv)
-    {
-        if (((char *)&bs2b->last_sample)[--loopv] != 0)
-            return 0;
-    }
-    return 1;
-} /* bs2b_is_clear */
-
-void bs2b_cross_feed(struct bs2b *bs2b, float *sample)
-{
-    /* Lowpass filter */
-    bs2b->last_sample.lo[0] = lo_filter(sample[0], bs2b->last_sample.lo[0]);
-    bs2b->last_sample.lo[1] = lo_filter(sample[1], bs2b->last_sample.lo[1]);
-
-    /* Highboost filter */
-    bs2b->last_sample.hi[0] = hi_filter(sample[0], bs2b->last_sample.asis[0], bs2b->last_sample.hi[0]);
-    bs2b->last_sample.hi[1] = hi_filter(sample[1], bs2b->last_sample.asis[1], bs2b->last_sample.hi[1]);
-    bs2b->last_sample.asis[0] = sample[0];
-    bs2b->last_sample.asis[1] = sample[1];
-
-    /* Crossfeed */
-    sample[0] = bs2b->last_sample.hi[0] + bs2b->last_sample.lo[1];
-    sample[1] = bs2b->last_sample.hi[1] + bs2b->last_sample.lo[0];
-
-    /* Bass boost cause allpass attenuation */
-    sample[0] *= bs2b->gain;
-    sample[1] *= bs2b->gain;
-
-    /* Clipping of overloaded samples */
-#if 0
-    if (sample[0] > 1.0)
-        sample[0] = 1.0;
-    if (sample[0] < -1.0)
-        sample[0] = -1.0;
-    if (sample[1] > 1.0)
-        sample[1] = 1.0;
-    if (sample[1] < -1.0)
-        sample[1] = -1.0;
-#endif
-} /* bs2b_cross_feed */
+/*-
+ * Copyright (c) 2005 Boris Mikhaylov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <string.h>
+
+#include "bs2b.h"
+#include "alu.h"
+
+#ifndef M_PI
+#define M_PI  3.14159265358979323846
+#endif
+
+/* Set up all data. */
+static void init(struct bs2b *bs2b)
+{
+    float Fc_lo, Fc_hi;
+    float G_lo,  G_hi;
+    float x, g;
+
+    bs2b->srate = clampi(bs2b->srate, 2000, 192000);
+
+    switch(bs2b->level)
+    {
+    case BS2B_LOW_CLEVEL: /* Low crossfeed level */
+        Fc_lo = 360.0f;
+        Fc_hi = 501.0f;
+        G_lo  = 0.398107170553497f;
+        G_hi  = 0.205671765275719f;
+        break;
+
+    case BS2B_MIDDLE_CLEVEL: /* Middle crossfeed level */
+        Fc_lo = 500.0f;
+        Fc_hi = 711.0f;
+        G_lo  = 0.459726988530872f;
+        G_hi  = 0.228208484414988f;
+        break;
+
+    case BS2B_HIGH_CLEVEL: /* High crossfeed level (virtual speakers are closer to itself) */
+        Fc_lo = 700.0f;
+        Fc_hi = 1021.0f;
+        G_lo  = 0.530884444230988f;
+        G_hi  = 0.250105790667544f;
+        break;
+
+    case BS2B_LOW_ECLEVEL: /* Low easy crossfeed level */
+        Fc_lo = 360.0f;
+        Fc_hi = 494.0f;
+        G_lo  = 0.316227766016838f;
+        G_hi  = 0.168236228897329f;
+        break;
+
+    case BS2B_MIDDLE_ECLEVEL: /* Middle easy crossfeed level */
+        Fc_lo = 500.0f;
+        Fc_hi = 689.0f;
+        G_lo  = 0.354813389233575f;
+        G_hi  = 0.187169483835901f;
+        break;
+
+    default: /* High easy crossfeed level */
+        bs2b->level = BS2B_HIGH_ECLEVEL;
+
+        Fc_lo = 700.0f;
+        Fc_hi = 975.0f;
+        G_lo  = 0.398107170553497f;
+        G_hi  = 0.205671765275719f;
+        break;
+    } /* switch */
+
+    g = 1.0f / (1.0f - G_hi + G_lo);
+
+    /* $fc = $Fc / $s;
+     * $d  = 1 / 2 / pi / $fc;
+     * $x  = exp(-1 / $d);
+     */
+    x           = expf(-2.0f * F_PI * Fc_lo / bs2b->srate);
+    bs2b->b1_lo = x;
+    bs2b->a0_lo = G_lo * (1.0f - x) * g;
+
+    x           = expf(-2.0f * F_PI * Fc_hi / bs2b->srate);
+    bs2b->b1_hi = x;
+    bs2b->a0_hi = (1.0f - G_hi * (1.0f - x)) * g;
+    bs2b->a1_hi = -x * g;
+} /* init */
+
+/* Exported functions.
+ * See descriptions in "bs2b.h"
+ */
+
+void bs2b_set_level(struct bs2b *bs2b, int level)
+{
+    if(level == bs2b->level)
+        return;
+    bs2b->level = level;
+    init(bs2b);
+} /* bs2b_set_level */
+
+int bs2b_get_level(struct bs2b *bs2b)
+{
+    return bs2b->level;
+} /* bs2b_get_level */
+
+void bs2b_set_srate(struct bs2b *bs2b, int srate)
+{
+    if (srate == bs2b->srate)
+        return;
+    bs2b->srate = srate;
+    init(bs2b);
+} /* bs2b_set_srate */
+
+int bs2b_get_srate(struct bs2b *bs2b)
+{
+    return bs2b->srate;
+} /* bs2b_get_srate */
+
+void bs2b_clear(struct bs2b *bs2b)
+{
+    memset(&bs2b->last_sample, 0, sizeof(bs2b->last_sample));
+} /* bs2b_clear */
+
+extern inline void bs2b_cross_feed(struct bs2b *bs2b, float *restrict samples);
@@ -0,0 +1,32 @@
+#ifndef AL_COMPAT_H
+#define AL_COMPAT_H
+
+#ifdef _WIN32
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+WCHAR *strdupW(const WCHAR *str);
+
+/* Opens a file with standard I/O. The filename is expected to be UTF-8. */
+FILE *al_fopen(const char *fname, const char *mode);
+
+#define HAVE_DYNLOAD 1
+
+#else
+
+#define al_fopen fopen
+
+#if defined(HAVE_DLFCN_H) && !defined(IN_IDE_PARSER)
+#define HAVE_DYNLOAD 1
+#endif
+
+#endif
+
+#ifdef HAVE_DYNLOAD
+void *LoadLib(const char *name);
+void CloseLib(void *handle);
+void *GetSymbol(void *handle, const char *name);
+#endif
+
+#endif /* AL_COMPAT_H */
@@ -1,285 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <memory.h>
-
-#include <windows.h>
-#include <mmsystem.h>
-#include <dsound.h>
-
-#include "alMain.h"
-#include "AL/al.h"
-#include "AL/alc.h"
-
-
-typedef struct {
-    // DirectSound Playback Device
-    LPDIRECTSOUND          lpDS;
-    LPDIRECTSOUNDBUFFER    DSpbuffer;
-    LPDIRECTSOUNDBUFFER    DSsbuffer;
-    MMRESULT               ulDSTimerID;
-    DWORD                  OldWriteCursor;
-} DSoundData;
-
-
-static ALCchar *DeviceList[16];
-
-static void CALLBACK DirectSoundProc(UINT uID,UINT uReserved,DWORD_PTR dwUser,DWORD_PTR dwReserved1,DWORD_PTR dwReserved2)
-{
-    ALCdevice *pDevice = (ALCdevice *)dwUser;
-    DSoundData *pData = pDevice->ExtraData;
-    DWORD PlayCursor,WriteCursor;
-    BYTE *WritePtr1,*WritePtr2;
-    DWORD WriteCnt1,WriteCnt2;
-    WAVEFORMATEX OutputType;
-    DWORD BytesPlayed;
-    DWORD BufSize;
-    HRESULT DSRes;
-
-    (void)uID;
-    (void)uReserved;
-    (void)dwReserved1;
-    (void)dwReserved2;
-
-    BufSize = pDevice->UpdateFreq * 2 * pDevice->FrameSize;
-
-    // Get current play and write cursors
-    IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer,&PlayCursor,&WriteCursor);
-    if (!pData->OldWriteCursor) pData->OldWriteCursor=WriteCursor-PlayCursor;
-
-    // Get the output format and figure the number of bytes played (block aligned)
-    IDirectSoundBuffer_GetFormat(pData->DSsbuffer,&OutputType,sizeof(WAVEFORMATEX),NULL);
-    BytesPlayed=((((WriteCursor<pData->OldWriteCursor)?(BufSize+WriteCursor-pData->OldWriteCursor):(WriteCursor-pData->OldWriteCursor))/OutputType.nBlockAlign)*OutputType.nBlockAlign);
-
-    // Lock output buffer started at 40msec in front of the old write cursor (15msec in front of the actual write cursor)
-    DSRes=IDirectSoundBuffer_Lock(pData->DSsbuffer,(pData->OldWriteCursor+(OutputType.nSamplesPerSec/25)*OutputType.nBlockAlign)%BufSize,BytesPlayed,(LPVOID*)&WritePtr1,&WriteCnt1,(LPVOID*)&WritePtr2,&WriteCnt2,0);
-
-    // If the buffer is lost, restore it, play and lock
-    if (DSRes==DSERR_BUFFERLOST)
-    {
-        IDirectSoundBuffer_Restore(pData->DSsbuffer);
-        IDirectSoundBuffer_Play(pData->DSsbuffer,0,0,DSBPLAY_LOOPING);
-        DSRes=IDirectSoundBuffer_Lock(pData->DSsbuffer,(pData->OldWriteCursor+(OutputType.nSamplesPerSec/25)*OutputType.nBlockAlign)%BufSize,BytesPlayed,(LPVOID*)&WritePtr1,&WriteCnt1,(LPVOID*)&WritePtr2,&WriteCnt2,0);
-    }
-
-    // Successfully locked the output buffer
-    if (DSRes==DS_OK)
-    {
-        // If we have an active context, mix data directly into output buffer otherwise fill with silence
-        SuspendContext(NULL);
-        if (WritePtr1)
-            aluMixData(pDevice->Context, WritePtr1, WriteCnt1, pDevice->Format);
-        if (WritePtr2)
-            aluMixData(pDevice->Context, WritePtr2, WriteCnt2, pDevice->Format);
-        ProcessContext(NULL);
-
-        // Unlock output buffer only when successfully locked
-        IDirectSoundBuffer_Unlock(pData->DSsbuffer,WritePtr1,WriteCnt1,WritePtr2,WriteCnt2);
-    }
-
-    // Update old write cursor location
-    pData->OldWriteCursor=((pData->OldWriteCursor+BytesPlayed)%BufSize);
-}
-
-
-static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
-{
-    DSBUFFERDESC DSBDescription;
-    DSoundData *pData = NULL;
-    WAVEFORMATEX OutputType;
-    HRESULT hr;
-
-    if(deviceName)
-    {
-        int i;
-        for(i = 0;DeviceList[i];i++)
-        {
-            if(strcmp(deviceName, DeviceList[i]) == 0)
-            {
-                device->szDeviceName = DeviceList[i];
-                break;
-            }
-        }
-        if(!DeviceList[i])
-            return ALC_FALSE;
-    }
-    else
-        device->szDeviceName = DeviceList[0];
-
-    //Platform specific
-    memset(&OutputType, 0, sizeof(WAVEFORMATEX));
-    OutputType.wFormatTag = WAVE_FORMAT_PCM;
-    OutputType.nChannels = device->Channels;
-    OutputType.wBitsPerSample = aluBytesFromFormat(device->Format) * 8;
-    OutputType.nBlockAlign = OutputType.nChannels*OutputType.wBitsPerSample/8;
-    OutputType.nSamplesPerSec = device->Frequency;
-    OutputType.nAvgBytesPerSec = OutputType.nSamplesPerSec*OutputType.nBlockAlign;
-    OutputType.cbSize = 0;
-
-    //Initialise requested device
-
-    pData = calloc(1, sizeof(DSoundData));
-    if(!pData)
-    {
-        SetALCError(ALC_OUT_OF_MEMORY);
-        return ALC_FALSE;
-    }
-
-    //Init COM
-    CoInitialize(NULL);
-
-    //DirectSound Init code
-    hr = CoCreateInstance(&CLSID_DirectSound, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectSound, (LPVOID*)&pData->lpDS);
-    if(SUCCEEDED(hr))
-        hr = IDirectSound_Initialize(pData->lpDS, NULL);
-    if(SUCCEEDED(hr))
-        hr = IDirectSound_SetCooperativeLevel(pData->lpDS, GetForegroundWindow(), DSSCL_PRIORITY);
-
-    if(SUCCEEDED(hr))
-    {
-        memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
-        DSBDescription.dwSize=sizeof(DSBUFFERDESC);
-        DSBDescription.dwFlags=DSBCAPS_PRIMARYBUFFER;
-        hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSpbuffer, NULL);
-    }
-    if(SUCCEEDED(hr))
-        hr = IDirectSoundBuffer_SetFormat(pData->DSpbuffer,&OutputType);
-
-    if(SUCCEEDED(hr))
-    {
-        memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
-        DSBDescription.dwSize=sizeof(DSBUFFERDESC);
-        DSBDescription.dwFlags=DSBCAPS_GLOBALFOCUS|DSBCAPS_GETCURRENTPOSITION2;
-        DSBDescription.dwBufferBytes=device->UpdateFreq * 2 * device->FrameSize;
-        DSBDescription.lpwfxFormat=&OutputType;
-        hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSsbuffer, NULL);
-    }
-
-    if(SUCCEEDED(hr))
-        hr = IDirectSoundBuffer_Play(pData->DSsbuffer, 0, 0, DSBPLAY_LOOPING);
-
-    if(FAILED(hr))
-    {
-        if (pData->DSsbuffer)
-            IDirectSoundBuffer_Release(pData->DSsbuffer);
-        if (pData->DSpbuffer)
-            IDirectSoundBuffer_Release(pData->DSpbuffer);
-        if (pData->lpDS)
-            IDirectSound_Release(pData->lpDS);
-
-        free(pData);
-        return ALC_FALSE;
-    }
-
-    pData->ulDSTimerID = timeSetEvent(25, 0, (LPTIMECALLBACK)DirectSoundProc, (DWORD)device, (UINT)TIME_CALLBACK_FUNCTION|TIME_PERIODIC);
-    device->MaxNoOfSources = 256;
-
-    device->ExtraData = pData;
-    return ALC_TRUE;
-}
-
-static void DSoundClosePlayback(ALCdevice *device)
-{
-    DSoundData *pData = device->ExtraData;
-
-    // Stop and release the DS timer
-    if (pData->ulDSTimerID)
-        timeKillEvent(pData->ulDSTimerID);
-
-    // Wait ... just in case any timer events happen
-    Sleep(100);
-
-    SuspendContext(NULL);
-
-    if (pData->DSsbuffer)
-        IDirectSoundBuffer_Release(pData->DSsbuffer);
-    if (pData->DSpbuffer)
-        IDirectSoundBuffer_Release(pData->DSpbuffer);
-    IDirectSound_Release(pData->lpDS);
-
-    //Deinit COM
-    CoUninitialize();
-
-    ProcessContext(NULL);
-
-    free(pData);
-    device->ExtraData = NULL;
-}
-
-
-static ALCboolean DSoundOpenCapture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
-{
-    (void)pDevice;
-    (void)deviceName;
-    (void)frequency;
-    (void)format;
-    (void)SampleSize;
-    return ALC_FALSE;
-}
-
-static void DSoundCloseCapture(ALCdevice *pDevice)
-{
-    (void)pDevice;
-}
-
-static void DSoundStartCapture(ALCdevice *pDevice)
-{
-    (void)pDevice;
-}
-
-static void DSoundStopCapture(ALCdevice *pDevice)
-{
-    (void)pDevice;
-}
-
-static void DSoundCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
-{
-    (void)pDevice;
-    (void)pBuffer;
-    (void)lSamples;
-}
-
-static ALCuint DSoundAvailableSamples(ALCdevice *pDevice)
-{
-    (void)pDevice;
-    return 0;
-}
-
-
-BackendFuncs DSoundFuncs = {
-    DSoundOpenPlayback,
-    DSoundClosePlayback,
-    DSoundOpenCapture,
-    DSoundCloseCapture,
-    DSoundStartCapture,
-    DSoundStopCapture,
-    DSoundCaptureSamples,
-    DSoundAvailableSamples
-};
-
-void alcDSoundInit(BackendFuncs *FuncList)
-{
-    *FuncList = DSoundFuncs;
-
-    DeviceList[0] = AppendDeviceList("DirectSound Software");
-    AppendAllDeviceList(DeviceList[0]);
-}
@@ -0,0 +1,272 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Anis A. Hireche, Nasca Octavian Paul
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include <stdlib.h>
+
+#include "config.h"
+#include "alu.h"
+#include "alFilter.h"
+#include "alError.h"
+#include "alMain.h"
+#include "alAuxEffectSlot.h"
+
+
+/* Auto-wah is simply a low-pass filter with a cutoff frequency that shifts up
+ * or down depending on the input signal, and a resonant peak at the cutoff.
+ *
+ * Currently, we assume a cutoff frequency range of 500hz (no amplitude) to
+ * 3khz (peak gain). Peak gain is assumed to be in normalized scale.
+ */
+
+typedef struct ALautowahState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    /* Effect gains for each channel */
+    ALfloat Gain[MaxChannels];
+
+    /* Effect parameters */
+    ALfloat AttackRate;
+    ALfloat ReleaseRate;
+    ALfloat Resonance;
+    ALfloat PeakGain;
+    ALfloat GainCtrl;
+    ALfloat Frequency;
+
+    /* Samples processing */
+    ALfilterState LowPass;
+} ALautowahState;
+
+static ALvoid ALautowahState_Destruct(ALautowahState *UNUSED(state))
+{
+}
+
+static ALboolean ALautowahState_deviceUpdate(ALautowahState *state, ALCdevice *device)
+{
+    state->Frequency = (ALfloat)device->Frequency;
+    return AL_TRUE;
+}
+
+static ALvoid ALautowahState_update(ALautowahState *state, ALCdevice *device, const ALeffectslot *slot)
+{
+    ALfloat attackTime, releaseTime;
+    ALfloat gain;
+
+    attackTime = slot->EffectProps.Autowah.AttackTime * state->Frequency;
+    releaseTime = slot->EffectProps.Autowah.ReleaseTime * state->Frequency;
+
+    state->AttackRate = powf(1.0f/GAIN_SILENCE_THRESHOLD, 1.0f/attackTime);
+    state->ReleaseRate = powf(GAIN_SILENCE_THRESHOLD/1.0f, 1.0f/releaseTime);
+    state->PeakGain = slot->EffectProps.Autowah.PeakGain;
+    state->Resonance = slot->EffectProps.Autowah.Resonance;
+
+    gain = sqrtf(1.0f / device->NumChan) * slot->Gain;
+    SetGains(device, gain, state->Gain);
+}
+
+static ALvoid ALautowahState_process(ALautowahState *state, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[BUFFERSIZE])
+{
+    ALuint it, kt;
+    ALuint base;
+
+    for(base = 0;base < SamplesToDo;)
+    {
+        ALfloat temps[64];
+        ALuint td = minu(SamplesToDo-base, 64);
+        ALfloat gain = state->GainCtrl;
+
+        for(it = 0;it < td;it++)
+        {
+            ALfloat smp = SamplesIn[it+base];
+            ALfloat alpha, w0;
+            ALfloat amplitude;
+            ALfloat cutoff;
+
+            /* Similar to compressor, we get the current amplitude of the
+             * incoming signal, and attack or release to reach it. */
+            amplitude = fabsf(smp);
+            if(amplitude > gain)
+                gain = minf(gain*state->AttackRate, amplitude);
+            else if(amplitude < gain)
+                gain = maxf(gain*state->ReleaseRate, amplitude);
+            gain = maxf(gain, GAIN_SILENCE_THRESHOLD);
+
+            /* FIXME: What range does the filter cover? */
+            cutoff = lerp(20.0f, 20000.0f, minf(gain/state->PeakGain, 1.0f));
+
+            /* The code below is like calling ALfilterState_setParams with
+             * ALfilterType_LowPass. However, instead of passing a bandwidth,
+             * we use the resonance property for Q. This also inlines the call.
+             */
+            w0 = F_2PI * cutoff / state->Frequency;
+
+            /* FIXME: Resonance controls the resonant peak, or Q. How? Not sure
+             * that Q = resonance*0.1. */
+            alpha = sinf(w0) / (2.0f * state->Resonance*0.1f);
+            state->LowPass.b[0] = (1.0f - cosf(w0)) / 2.0f;
+            state->LowPass.b[1] =  1.0f - cosf(w0);
+            state->LowPass.b[2] = (1.0f - cosf(w0)) / 2.0f;
+            state->LowPass.a[0] =  1.0f + alpha;
+            state->LowPass.a[1] = -2.0f * cosf(w0);
+            state->LowPass.a[2] =  1.0f - alpha;
+
+            state->LowPass.b[2] /= state->LowPass.a[0];
+            state->LowPass.b[1] /= state->LowPass.a[0];
+            state->LowPass.b[0] /= state->LowPass.a[0];
+            state->LowPass.a[2] /= state->LowPass.a[0];
+            state->LowPass.a[1] /= state->LowPass.a[0];
+            state->LowPass.a[0] /= state->LowPass.a[0];
+
+            temps[it] = ALfilterState_processSingle(&state->LowPass, smp);
+        }
+        state->GainCtrl = gain;
+
+        for(kt = 0;kt < MaxChannels;kt++)
+        {
+            ALfloat gain = state->Gain[kt];
+            if(!(gain > GAIN_SILENCE_THRESHOLD))
+                continue;
+
+            for(it = 0;it < td;it++)
+                SamplesOut[kt][base+it] += gain * temps[it];
+        }
+
+        base += td;
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALautowahState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALautowahState);
+
+
+typedef struct ALautowahStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALautowahStateFactory;
+
+static ALeffectState *ALautowahStateFactory_create(ALautowahStateFactory *UNUSED(factory))
+{
+    ALautowahState *state;
+
+    state = ALautowahState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALautowahState, ALeffectState, state);
+
+    state->AttackRate = 1.0f;
+    state->ReleaseRate = 1.0f;
+    state->Resonance = 2.0f;
+    state->PeakGain = 1.0f;
+    state->GainCtrl = 1.0f;
+
+    ALfilterState_clear(&state->LowPass);
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALautowahStateFactory);
+
+ALeffectStateFactory *ALautowahStateFactory_getFactory(void)
+{
+    static ALautowahStateFactory AutowahFactory = { { GET_VTABLE2(ALautowahStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &AutowahFactory);
+}
+
+
+void ALautowah_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALautowah_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALautowah_setParami(effect, context, param, vals[0]);
+}
+void ALautowah_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_AUTOWAH_ATTACK_TIME:
+            if(!(val >= AL_AUTOWAH_MIN_ATTACK_TIME && val <= AL_AUTOWAH_MAX_ATTACK_TIME))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Autowah.AttackTime = val;
+            break;
+
+        case AL_AUTOWAH_RELEASE_TIME:
+            if(!(val >= AL_AUTOWAH_MIN_RELEASE_TIME && val <= AL_AUTOWAH_MAX_RELEASE_TIME))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Autowah.ReleaseTime = val;
+            break;
+
+        case AL_AUTOWAH_RESONANCE:
+            if(!(val >= AL_AUTOWAH_MIN_RESONANCE && val <= AL_AUTOWAH_MAX_RESONANCE))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Autowah.Resonance = val;
+            break;
+
+        case AL_AUTOWAH_PEAK_GAIN:
+            if(!(val >= AL_AUTOWAH_MIN_PEAK_GAIN && val <= AL_AUTOWAH_MAX_PEAK_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Autowah.PeakGain = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALautowah_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALautowah_setParamf(effect, context, param, vals[0]);
+}
+
+void ALautowah_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALautowah_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALautowah_getParami(effect, context, param, vals);
+}
+void ALautowah_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_AUTOWAH_ATTACK_TIME:
+            *val = props->Autowah.AttackTime;
+            break;
+
+        case AL_AUTOWAH_RELEASE_TIME:
+            *val = props->Autowah.ReleaseTime;
+            break;
+
+        case AL_AUTOWAH_RESONANCE:
+            *val = props->Autowah.Resonance;
+            break;
+
+        case AL_AUTOWAH_PEAK_GAIN:
+            *val = props->Autowah.PeakGain;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALautowah_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALautowah_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALautowah);
@@ -0,0 +1,397 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Mike Gorchak
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+enum ChorusWaveForm {
+    CWF_Triangle = AL_CHORUS_WAVEFORM_TRIANGLE,
+    CWF_Sinusoid = AL_CHORUS_WAVEFORM_SINUSOID
+};
+
+typedef struct ALchorusState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    ALfloat *SampleBuffer[2];
+    ALuint BufferLength;
+    ALuint offset;
+    ALuint lfo_range;
+    ALfloat lfo_scale;
+    ALint lfo_disp;
+
+    /* Gains for left and right sides */
+    ALfloat Gain[2][MaxChannels];
+
+    /* effect parameters */
+    enum ChorusWaveForm waveform;
+    ALint delay;
+    ALfloat depth;
+    ALfloat feedback;
+} ALchorusState;
+
+static ALvoid ALchorusState_Destruct(ALchorusState *state)
+{
+    free(state->SampleBuffer[0]);
+    state->SampleBuffer[0] = NULL;
+    state->SampleBuffer[1] = NULL;
+}
+
+static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device)
+{
+    ALuint maxlen;
+    ALuint it;
+
+    maxlen = fastf2u(AL_CHORUS_MAX_DELAY * 3.0f * Device->Frequency) + 1;
+    maxlen = NextPowerOf2(maxlen);
+
+    if(maxlen != state->BufferLength)
+    {
+        void *temp;
+
+        temp = realloc(state->SampleBuffer[0], maxlen * sizeof(ALfloat) * 2);
+        if(!temp) return AL_FALSE;
+        state->SampleBuffer[0] = temp;
+        state->SampleBuffer[1] = state->SampleBuffer[0] + maxlen;
+
+        state->BufferLength = maxlen;
+    }
+
+    for(it = 0;it < state->BufferLength;it++)
+    {
+        state->SampleBuffer[0][it] = 0.0f;
+        state->SampleBuffer[1][it] = 0.0f;
+    }
+
+    return AL_TRUE;
+}
+
+static ALvoid ALchorusState_update(ALchorusState *state, ALCdevice *Device, const ALeffectslot *Slot)
+{
+    ALfloat frequency = (ALfloat)Device->Frequency;
+    ALfloat rate;
+    ALint phase;
+
+    switch(Slot->EffectProps.Chorus.Waveform)
+    {
+        case AL_CHORUS_WAVEFORM_TRIANGLE:
+            state->waveform = CWF_Triangle;
+            break;
+        case AL_CHORUS_WAVEFORM_SINUSOID:
+            state->waveform = CWF_Sinusoid;
+            break;
+    }
+    state->depth = Slot->EffectProps.Chorus.Depth;
+    state->feedback = Slot->EffectProps.Chorus.Feedback;
+    state->delay = fastf2i(Slot->EffectProps.Chorus.Delay * frequency);
+
+    /* Gains for left and right sides */
+    ComputeAngleGains(Device, atan2f(-1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[0]);
+    ComputeAngleGains(Device, atan2f(+1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[1]);
+
+    phase = Slot->EffectProps.Chorus.Phase;
+    rate = Slot->EffectProps.Chorus.Rate;
+    if(!(rate > 0.0f))
+    {
+        state->lfo_scale = 0.0f;
+        state->lfo_range = 1;
+        state->lfo_disp = 0;
+    }
+    else
+    {
+        /* Calculate LFO coefficient */
+        state->lfo_range = fastf2u(frequency/rate + 0.5f);
+        switch(state->waveform)
+        {
+            case CWF_Triangle:
+                state->lfo_scale = 4.0f / state->lfo_range;
+                break;
+            case CWF_Sinusoid:
+                state->lfo_scale = F_2PI / state->lfo_range;
+                break;
+        }
+
+        /* Calculate lfo phase displacement */
+        state->lfo_disp = fastf2i(state->lfo_range * (phase/360.0f));
+    }
+}
+
+static inline void Triangle(ALint *delay_left, ALint *delay_right, ALuint offset, const ALchorusState *state)
+{
+    ALfloat lfo_value;
+
+    lfo_value = 2.0f - fabsf(2.0f - state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_left = fastf2i(lfo_value) + state->delay;
+
+    offset += state->lfo_disp;
+    lfo_value = 2.0f - fabsf(2.0f - state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_right = fastf2i(lfo_value) + state->delay;
+}
+
+static inline void Sinusoid(ALint *delay_left, ALint *delay_right, ALuint offset, const ALchorusState *state)
+{
+    ALfloat lfo_value;
+
+    lfo_value = 1.0f + sinf(state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_left = fastf2i(lfo_value) + state->delay;
+
+    offset += state->lfo_disp;
+    lfo_value = 1.0f + sinf(state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_right = fastf2i(lfo_value) + state->delay;
+}
+
+#define DECL_TEMPLATE(Func)                                                   \
+static void Process##Func(ALchorusState *state, const ALuint SamplesToDo,     \
+  const ALfloat *restrict SamplesIn, ALfloat (*restrict out)[2])              \
+{                                                                             \
+    const ALuint bufmask = state->BufferLength-1;                             \
+    ALfloat *restrict leftbuf = state->SampleBuffer[0];                       \
+    ALfloat *restrict rightbuf = state->SampleBuffer[1];                      \
+    ALuint offset = state->offset;                                            \
+    const ALfloat feedback = state->feedback;                                 \
+    ALuint it;                                                                \
+                                                                              \
+    for(it = 0;it < SamplesToDo;it++)                                         \
+    {                                                                         \
+        ALint delay_left, delay_right;                                        \
+        Func(&delay_left, &delay_right, offset, state);                       \
+                                                                              \
+        out[it][0] = leftbuf[(offset-delay_left)&bufmask];                    \
+        leftbuf[offset&bufmask] = (out[it][0]+SamplesIn[it]) * feedback;      \
+                                                                              \
+        out[it][1] = rightbuf[(offset-delay_right)&bufmask];                  \
+        rightbuf[offset&bufmask] = (out[it][1]+SamplesIn[it]) * feedback;     \
+                                                                              \
+        offset++;                                                             \
+    }                                                                         \
+    state->offset = offset;                                                   \
+}
+
+DECL_TEMPLATE(Triangle)
+DECL_TEMPLATE(Sinusoid)
+
+#undef DECL_TEMPLATE
+
+static ALvoid ALchorusState_process(ALchorusState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+{
+    ALuint it, kt;
+    ALuint base;
+
+    for(base = 0;base < SamplesToDo;)
+    {
+        ALfloat temps[64][2];
+        ALuint td = minu(SamplesToDo-base, 64);
+
+        switch(state->waveform)
+        {
+            case CWF_Triangle:
+                ProcessTriangle(state, td, SamplesIn+base, temps);
+                break;
+            case CWF_Sinusoid:
+                ProcessSinusoid(state, td, SamplesIn+base, temps);
+                break;
+        }
+
+        for(kt = 0;kt < MaxChannels;kt++)
+        {
+            ALfloat gain = state->Gain[0][kt];
+            if(gain > GAIN_SILENCE_THRESHOLD)
+            {
+                for(it = 0;it < td;it++)
+                    SamplesOut[kt][it+base] += temps[it][0] * gain;
+            }
+
+            gain = state->Gain[1][kt];
+            if(gain > GAIN_SILENCE_THRESHOLD)
+            {
+                for(it = 0;it < td;it++)
+                    SamplesOut[kt][it+base] += temps[it][1] * gain;
+            }
+        }
+
+        base += td;
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALchorusState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState);
+
+
+typedef struct ALchorusStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALchorusStateFactory;
+
+static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(factory))
+{
+    ALchorusState *state;
+
+    state = ALchorusState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALchorusState, ALeffectState, state);
+
+    state->BufferLength = 0;
+    state->SampleBuffer[0] = NULL;
+    state->SampleBuffer[1] = NULL;
+    state->offset = 0;
+    state->lfo_range = 1;
+    state->waveform = CWF_Triangle;
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALchorusStateFactory);
+
+
+ALeffectStateFactory *ALchorusStateFactory_getFactory(void)
+{
+    static ALchorusStateFactory ChorusFactory = { { GET_VTABLE2(ALchorusStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &ChorusFactory);
+}
+
+
+void ALchorus_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_CHORUS_WAVEFORM:
+            if(!(val >= AL_CHORUS_MIN_WAVEFORM && val <= AL_CHORUS_MAX_WAVEFORM))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Chorus.Waveform = val;
+            break;
+
+        case AL_CHORUS_PHASE:
+            if(!(val >= AL_CHORUS_MIN_PHASE && val <= AL_CHORUS_MAX_PHASE))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Chorus.Phase = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALchorus_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALchorus_setParami(effect, context, param, vals[0]);
+}
+void ALchorus_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_CHORUS_RATE:
+            if(!(val >= AL_CHORUS_MIN_RATE && val <= AL_CHORUS_MAX_RATE))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Chorus.Rate = val;
+            break;
+
+        case AL_CHORUS_DEPTH:
+            if(!(val >= AL_CHORUS_MIN_DEPTH && val <= AL_CHORUS_MAX_DEPTH))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Chorus.Depth = val;
+            break;
+
+        case AL_CHORUS_FEEDBACK:
+            if(!(val >= AL_CHORUS_MIN_FEEDBACK && val <= AL_CHORUS_MAX_FEEDBACK))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Chorus.Feedback = val;
+            break;
+
+        case AL_CHORUS_DELAY:
+            if(!(val >= AL_CHORUS_MIN_DELAY && val <= AL_CHORUS_MAX_DELAY))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Chorus.Delay = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALchorus_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALchorus_setParamf(effect, context, param, vals[0]);
+}
+
+void ALchorus_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_CHORUS_WAVEFORM:
+            *val = props->Chorus.Waveform;
+            break;
+
+        case AL_CHORUS_PHASE:
+            *val = props->Chorus.Phase;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALchorus_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALchorus_getParami(effect, context, param, vals);
+}
+void ALchorus_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_CHORUS_RATE:
+            *val = props->Chorus.Rate;
+            break;
+
+        case AL_CHORUS_DEPTH:
+            *val = props->Chorus.Depth;
+            break;
+
+        case AL_CHORUS_FEEDBACK:
+            *val = props->Chorus.Feedback;
+            break;
+
+        case AL_CHORUS_DELAY:
+            *val = props->Chorus.Delay;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALchorus_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALchorus_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALchorus);
@@ -0,0 +1,220 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Anis A. Hireche
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include <stdlib.h>
+
+#include "config.h"
+#include "alError.h"
+#include "alMain.h"
+#include "alAuxEffectSlot.h"
+#include "alu.h"
+
+
+typedef struct ALcompressorState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    /* Effect gains for each channel */
+    ALfloat Gain[MaxChannels];
+
+    /* Effect parameters */
+    ALboolean Enabled;
+    ALfloat AttackRate;
+    ALfloat ReleaseRate;
+    ALfloat GainCtrl;
+} ALcompressorState;
+
+static ALvoid ALcompressorState_Destruct(ALcompressorState *UNUSED(state))
+{
+}
+
+static ALboolean ALcompressorState_deviceUpdate(ALcompressorState *state, ALCdevice *device)
+{
+    const ALfloat attackTime = device->Frequency * 0.2f; /* 200ms Attack */
+    const ALfloat releaseTime = device->Frequency * 0.4f; /* 400ms Release */
+
+    state->AttackRate = 1.0f / attackTime;
+    state->ReleaseRate = 1.0f / releaseTime;
+
+    return AL_TRUE;
+}
+
+static ALvoid ALcompressorState_update(ALcompressorState *state, ALCdevice *Device, const ALeffectslot *Slot)
+{
+    ALfloat gain;
+
+    state->Enabled = Slot->EffectProps.Compressor.OnOff;
+
+    gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain;
+    SetGains(Device, gain, state->Gain);
+}
+
+static ALvoid ALcompressorState_process(ALcompressorState *state, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[BUFFERSIZE])
+{
+    ALuint it, kt;
+    ALuint base;
+
+    for(base = 0;base < SamplesToDo;)
+    {
+        ALfloat temps[64];
+        ALuint td = minu(SamplesToDo-base, 64);
+
+        if(state->Enabled)
+        {
+            ALfloat output, smp, amplitude;
+            ALfloat gain = state->GainCtrl;
+
+            for(it = 0;it < td;it++)
+            {
+                smp = SamplesIn[it+base];
+
+                amplitude = fabsf(smp);
+                if(amplitude > gain)
+                    gain = minf(gain+state->AttackRate, amplitude);
+                else if(amplitude < gain)
+                    gain = maxf(gain-state->ReleaseRate, amplitude);
+                output = 1.0f / clampf(gain, 0.5f, 2.0f);
+
+                temps[it] = smp * output;
+            }
+
+            state->GainCtrl = gain;
+        }
+        else
+        {
+            ALfloat output, smp, amplitude;
+            ALfloat gain = state->GainCtrl;
+
+            for(it = 0;it < td;it++)
+            {
+                smp = SamplesIn[it+base];
+
+                amplitude = 1.0f;
+                if(amplitude > gain)
+                    gain = minf(gain+state->AttackRate, amplitude);
+                else if(amplitude < gain)
+                    gain = maxf(gain-state->ReleaseRate, amplitude);
+                output = 1.0f / clampf(gain, 0.5f, 2.0f);
+
+                temps[it] = smp * output;
+            }
+
+            state->GainCtrl = gain;
+        }
+
+
+        for(kt = 0;kt < MaxChannels;kt++)
+        {
+            ALfloat gain = state->Gain[kt];
+            if(!(gain > GAIN_SILENCE_THRESHOLD))
+                continue;
+
+            for(it = 0;it < td;it++)
+                SamplesOut[kt][base+it] += gain * temps[it];
+        }
+
+        base += td;
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALcompressorState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALcompressorState);
+
+
+typedef struct ALcompressorStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALcompressorStateFactory;
+
+static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *UNUSED(factory))
+{
+    ALcompressorState *state;
+
+    state = ALcompressorState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALcompressorState, ALeffectState, state);
+
+    state->Enabled = AL_TRUE;
+    state->AttackRate = 0.0f;
+    state->ReleaseRate = 0.0f;
+    state->GainCtrl = 1.0f;
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALcompressorStateFactory);
+
+ALeffectStateFactory *ALcompressorStateFactory_getFactory(void)
+{
+    static ALcompressorStateFactory CompressorFactory = { { GET_VTABLE2(ALcompressorStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &CompressorFactory);
+}
+
+
+void ALcompressor_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_COMPRESSOR_ONOFF:
+            if(!(val >= AL_COMPRESSOR_MIN_ONOFF && val <= AL_COMPRESSOR_MAX_ONOFF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Compressor.OnOff = val;
+            break;
+
+    default:
+        SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALcompressor_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALcompressor_setParami(effect, context, param, vals[0]);
+}
+void ALcompressor_setParamf(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALcompressor_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALcompressor_setParamf(effect, context, param, vals[0]);
+}
+
+void ALcompressor_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+{ 
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_COMPRESSOR_ONOFF:
+            *val = props->Compressor.OnOff;
+            break;
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALcompressor_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALcompressor_getParami(effect, context, param, vals);
+}
+void ALcompressor_getParamf(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALcompressor_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALcompressor_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALcompressor);
@@ -0,0 +1,164 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2011 by Chris Robinson.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+typedef struct ALdedicatedState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    ALfloat gains[MaxChannels];
+} ALdedicatedState;
+
+
+static ALvoid ALdedicatedState_Destruct(ALdedicatedState *UNUSED(state))
+{
+}
+
+static ALboolean ALdedicatedState_deviceUpdate(ALdedicatedState *UNUSED(state), ALCdevice *UNUSED(device))
+{
+    return AL_TRUE;
+}
+
+static ALvoid ALdedicatedState_update(ALdedicatedState *state, ALCdevice *device, const ALeffectslot *Slot)
+{
+    ALfloat Gain;
+    ALsizei s;
+
+    Gain = Slot->Gain * Slot->EffectProps.Dedicated.Gain;
+    if(Slot->EffectType == AL_EFFECT_DEDICATED_DIALOGUE)
+        ComputeAngleGains(device, atan2f(0.0f, 1.0f), 0.0f, Gain, state->gains);
+    else if(Slot->EffectType == AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT)
+    {
+        for(s = 0;s < MaxChannels;s++)
+            state->gains[s] = 0.0f;
+        state->gains[LFE] = Gain;
+    }
+}
+
+static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+{
+    const ALfloat *gains = state->gains;
+    ALuint i, c;
+
+    for(c = 0;c < MaxChannels;c++)
+    {
+        if(!(gains[c] > GAIN_SILENCE_THRESHOLD))
+            continue;
+
+        for(i = 0;i < SamplesToDo;i++)
+            SamplesOut[c][i] = SamplesIn[i] * gains[c];
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALdedicatedState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALdedicatedState);
+
+
+typedef struct ALdedicatedStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALdedicatedStateFactory;
+
+ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(factory))
+{
+    ALdedicatedState *state;
+    ALsizei s;
+
+    state = ALdedicatedState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALdedicatedState, ALeffectState, state);
+
+    for(s = 0;s < MaxChannels;s++)
+        state->gains[s] = 0.0f;
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdedicatedStateFactory);
+
+
+ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void)
+{
+    static ALdedicatedStateFactory DedicatedFactory = { { GET_VTABLE2(ALdedicatedStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &DedicatedFactory);
+}
+
+
+void ALdedicated_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALdedicated_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALdedicated_setParami(effect, context, param, vals[0]);
+}
+void ALdedicated_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_DEDICATED_GAIN:
+            if(!(val >= 0.0f && isfinite(val)))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Dedicated.Gain = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALdedicated_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALdedicated_setParamf(effect, context, param, vals[0]);
+}
+
+void ALdedicated_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALdedicated_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALdedicated_getParami(effect, context, param, vals);
+}
+void ALdedicated_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_DEDICATED_GAIN:
+            *val = props->Dedicated.Gain;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALdedicated_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALdedicated_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALdedicated);
@@ -0,0 +1,297 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Mike Gorchak
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+typedef struct ALdistortionState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    /* Effect gains for each channel */
+    ALfloat Gain[MaxChannels];
+
+    /* Effect parameters */
+    ALfilterState lowpass;
+    ALfilterState bandpass;
+    ALfloat attenuation;
+    ALfloat edge_coeff;
+} ALdistortionState;
+
+static ALvoid ALdistortionState_Destruct(ALdistortionState *UNUSED(state))
+{
+}
+
+static ALboolean ALdistortionState_deviceUpdate(ALdistortionState *UNUSED(state), ALCdevice *UNUSED(device))
+{
+    return AL_TRUE;
+}
+
+static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot)
+{
+    ALfloat frequency = (ALfloat)Device->Frequency;
+    ALfloat bandwidth;
+    ALfloat cutoff;
+    ALfloat edge;
+    ALfloat gain;
+
+    /* Store distorted signal attenuation settings */
+    state->attenuation = Slot->EffectProps.Distortion.Gain;
+
+    /* Store waveshaper edge settings */
+    edge = sinf(Slot->EffectProps.Distortion.Edge * (F_PI_2));
+    edge = minf(edge, 0.99f);
+    state->edge_coeff = 2.0f * edge / (1.0f-edge);
+
+    /* Lowpass filter */
+    cutoff = Slot->EffectProps.Distortion.LowpassCutoff;
+    /* Bandwidth value is constant in octaves */
+    bandwidth = (cutoff / 2.0f) / (cutoff * 0.67f);
+    ALfilterState_setParams(&state->lowpass, ALfilterType_LowPass, 1.0f,
+                            cutoff / (frequency*4.0f), bandwidth);
+
+    /* Bandpass filter */
+    cutoff = Slot->EffectProps.Distortion.EQCenter;
+    /* Convert bandwidth in Hz to octaves */
+    bandwidth = Slot->EffectProps.Distortion.EQBandwidth / (cutoff * 0.67f);
+    ALfilterState_setParams(&state->bandpass, ALfilterType_BandPass, 1.0f,
+                            cutoff / (frequency*4.0f), bandwidth);
+
+    gain = sqrtf(1.0f / Device->NumChan) * Slot->Gain;
+    SetGains(Device, gain, state->Gain);
+}
+
+static ALvoid ALdistortionState_process(ALdistortionState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+{
+    const ALfloat fc = state->edge_coeff;
+    float oversample_buffer[64][4];
+    ALuint base;
+    ALuint it;
+    ALuint ot;
+    ALuint kt;
+
+    for(base = 0;base < SamplesToDo;)
+    {
+        ALfloat temps[64];
+        ALuint td = minu(SamplesToDo-base, 64);
+
+        /* Perform 4x oversampling to avoid aliasing.   */
+        /* Oversampling greatly improves distortion     */
+        /* quality and allows to implement lowpass and  */
+        /* bandpass filters using high frequencies, at  */
+        /* which classic IIR filters became unstable.   */
+
+        /* Fill oversample buffer using zero stuffing */
+        for(it = 0;it < td;it++)
+        {
+            oversample_buffer[it][0] = SamplesIn[it+base];
+            oversample_buffer[it][1] = 0.0f;
+            oversample_buffer[it][2] = 0.0f;
+            oversample_buffer[it][3] = 0.0f;
+        }
+
+        /* First step, do lowpass filtering of original signal,  */
+        /* additionally perform buffer interpolation and lowpass */
+        /* cutoff for oversampling (which is fortunately first   */
+        /* step of distortion). So combine three operations into */
+        /* the one.                                              */
+        for(it = 0;it < td;it++)
+        {
+            for(ot = 0;ot < 4;ot++)
+            {
+                ALfloat smp;
+                smp = ALfilterState_processSingle(&state->lowpass, oversample_buffer[it][ot]);
+
+                /* Restore signal power by multiplying sample by amount of oversampling */
+                oversample_buffer[it][ot] = smp * 4.0f;
+            }
+        }
+
+        for(it = 0;it < td;it++)
+        {
+            /* Second step, do distortion using waveshaper function  */
+            /* to emulate signal processing during tube overdriving. */
+            /* Three steps of waveshaping are intended to modify     */
+            /* waveform without boost/clipping/attenuation process.  */
+            for(ot = 0;ot < 4;ot++)
+            {
+                ALfloat smp = oversample_buffer[it][ot];
+
+                smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp));
+                smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp)) * -1.0f;
+                smp = (1.0f + fc) * smp/(1.0f + fc*fabsf(smp));
+
+                /* Third step, do bandpass filtering of distorted signal */
+                smp = ALfilterState_processSingle(&state->bandpass, smp);
+                oversample_buffer[it][ot] = smp;
+            }
+
+            /* Fourth step, final, do attenuation and perform decimation, */
+            /* store only one sample out of 4.                            */
+            temps[it] = oversample_buffer[it][0] * state->attenuation;
+        }
+
+        for(kt = 0;kt < MaxChannels;kt++)
+        {
+            ALfloat gain = state->Gain[kt];
+            if(!(gain > GAIN_SILENCE_THRESHOLD))
+                continue;
+
+            for(it = 0;it < td;it++)
+                SamplesOut[kt][base+it] += gain * temps[it];
+        }
+
+        base += td;
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALdistortionState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALdistortionState);
+
+
+typedef struct ALdistortionStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALdistortionStateFactory;
+
+static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *UNUSED(factory))
+{
+    ALdistortionState *state;
+
+    state = ALdistortionState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALdistortionState, ALeffectState, state);
+
+    ALfilterState_clear(&state->lowpass);
+    ALfilterState_clear(&state->bandpass);
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdistortionStateFactory);
+
+
+ALeffectStateFactory *ALdistortionStateFactory_getFactory(void)
+{
+    static ALdistortionStateFactory DistortionFactory = { { GET_VTABLE2(ALdistortionStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &DistortionFactory);
+}
+
+
+void ALdistortion_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALdistortion_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALdistortion_setParami(effect, context, param, vals[0]);
+}
+void ALdistortion_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_DISTORTION_EDGE:
+            if(!(val >= AL_DISTORTION_MIN_EDGE && val <= AL_DISTORTION_MAX_EDGE))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Distortion.Edge = val;
+            break;
+
+        case AL_DISTORTION_GAIN:
+            if(!(val >= AL_DISTORTION_MIN_GAIN && val <= AL_DISTORTION_MAX_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Distortion.Gain = val;
+            break;
+
+        case AL_DISTORTION_LOWPASS_CUTOFF:
+            if(!(val >= AL_DISTORTION_MIN_LOWPASS_CUTOFF && val <= AL_DISTORTION_MAX_LOWPASS_CUTOFF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Distortion.LowpassCutoff = val;
+            break;
+
+        case AL_DISTORTION_EQCENTER:
+            if(!(val >= AL_DISTORTION_MIN_EQCENTER && val <= AL_DISTORTION_MAX_EQCENTER))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Distortion.EQCenter = val;
+            break;
+
+        case AL_DISTORTION_EQBANDWIDTH:
+            if(!(val >= AL_DISTORTION_MIN_EQBANDWIDTH && val <= AL_DISTORTION_MAX_EQBANDWIDTH))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Distortion.EQBandwidth = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALdistortion_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALdistortion_setParamf(effect, context, param, vals[0]);
+}
+
+void ALdistortion_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALdistortion_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALdistortion_getParami(effect, context, param, vals);
+}
+void ALdistortion_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_DISTORTION_EDGE:
+            *val = props->Distortion.Edge;
+            break;
+
+        case AL_DISTORTION_GAIN:
+            *val = props->Distortion.Gain;
+            break;
+
+        case AL_DISTORTION_LOWPASS_CUTOFF:
+            *val = props->Distortion.LowpassCutoff;
+            break;
+
+        case AL_DISTORTION_EQCENTER:
+            *val = props->Distortion.EQCenter;
+            break;
+
+        case AL_DISTORTION_EQBANDWIDTH:
+            *val = props->Distortion.EQBandwidth;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALdistortion_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALdistortion_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALdistortion);
@@ -0,0 +1,293 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2009 by Chris Robinson.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+typedef struct ALechoState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    ALfloat *SampleBuffer;
+    ALuint BufferLength;
+
+    // The echo is two tap. The delay is the number of samples from before the
+    // current offset
+    struct {
+        ALuint delay;
+    } Tap[2];
+    ALuint Offset;
+    /* The panning gains for the two taps */
+    ALfloat Gain[2][MaxChannels];
+
+    ALfloat FeedGain;
+
+    ALfilterState Filter;
+} ALechoState;
+
+static ALvoid ALechoState_Destruct(ALechoState *state)
+{
+    free(state->SampleBuffer);
+    state->SampleBuffer = NULL;
+}
+
+static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device)
+{
+    ALuint maxlen, i;
+
+    // Use the next power of 2 for the buffer length, so the tap offsets can be
+    // wrapped using a mask instead of a modulo
+    maxlen  = fastf2u(AL_ECHO_MAX_DELAY * Device->Frequency) + 1;
+    maxlen += fastf2u(AL_ECHO_MAX_LRDELAY * Device->Frequency) + 1;
+    maxlen  = NextPowerOf2(maxlen);
+
+    if(maxlen != state->BufferLength)
+    {
+        void *temp;
+
+        temp = realloc(state->SampleBuffer, maxlen * sizeof(ALfloat));
+        if(!temp) return AL_FALSE;
+        state->SampleBuffer = temp;
+        state->BufferLength = maxlen;
+    }
+    for(i = 0;i < state->BufferLength;i++)
+        state->SampleBuffer[i] = 0.0f;
+
+    return AL_TRUE;
+}
+
+static ALvoid ALechoState_update(ALechoState *state, ALCdevice *Device, const ALeffectslot *Slot)
+{
+    ALuint frequency = Device->Frequency;
+    ALfloat lrpan, gain;
+    ALfloat dirGain;
+
+    state->Tap[0].delay = fastf2u(Slot->EffectProps.Echo.Delay * frequency) + 1;
+    state->Tap[1].delay = fastf2u(Slot->EffectProps.Echo.LRDelay * frequency);
+    state->Tap[1].delay += state->Tap[0].delay;
+
+    lrpan = Slot->EffectProps.Echo.Spread;
+
+    state->FeedGain = Slot->EffectProps.Echo.Feedback;
+
+    ALfilterState_setParams(&state->Filter, ALfilterType_HighShelf,
+                            1.0f - Slot->EffectProps.Echo.Damping,
+                            LOWPASSFREQREF/frequency, 0.0f);
+
+    gain = Slot->Gain;
+    dirGain = fabsf(lrpan);
+
+    /* First tap panning */
+    ComputeAngleGains(Device, atan2f(-lrpan, 0.0f), (1.0f-dirGain)*F_PI, gain, state->Gain[0]);
+
+    /* Second tap panning */
+    ComputeAngleGains(Device, atan2f(+lrpan, 0.0f), (1.0f-dirGain)*F_PI, gain, state->Gain[1]);
+}
+
+static ALvoid ALechoState_process(ALechoState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+{
+    const ALuint mask = state->BufferLength-1;
+    const ALuint tap1 = state->Tap[0].delay;
+    const ALuint tap2 = state->Tap[1].delay;
+    ALuint offset = state->Offset;
+    ALfloat smp;
+    ALuint base;
+    ALuint i, k;
+
+    for(base = 0;base < SamplesToDo;)
+    {
+        ALfloat temps[64][2];
+        ALuint td = minu(SamplesToDo-base, 64);
+
+        for(i = 0;i < td;i++)
+        {
+            /* First tap */
+            temps[i][0] = state->SampleBuffer[(offset-tap1) & mask];
+            /* Second tap */
+            temps[i][1] = state->SampleBuffer[(offset-tap2) & mask];
+
+            // Apply damping and feedback gain to the second tap, and mix in the
+            // new sample
+            smp = ALfilterState_processSingle(&state->Filter, temps[i][1]+SamplesIn[i+base]);
+            state->SampleBuffer[offset&mask] = smp * state->FeedGain;
+            offset++;
+        }
+
+        for(k = 0;k < MaxChannels;k++)
+        {
+            ALfloat gain = state->Gain[0][k];
+            if(gain > GAIN_SILENCE_THRESHOLD)
+            {
+                for(i = 0;i < td;i++)
+                    SamplesOut[k][i+base] += temps[i][0] * gain;
+            }
+
+            gain = state->Gain[1][k];
+            if(gain > GAIN_SILENCE_THRESHOLD)
+            {
+                for(i = 0;i < td;i++)
+                    SamplesOut[k][i+base] += temps[i][1] * gain;
+            }
+        }
+
+        base += td;
+    }
+
+    state->Offset = offset;
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALechoState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALechoState);
+
+
+typedef struct ALechoStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALechoStateFactory;
+
+ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory))
+{
+    ALechoState *state;
+
+    state = ALechoState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALechoState, ALeffectState, state);
+
+    state->BufferLength = 0;
+    state->SampleBuffer = NULL;
+
+    state->Tap[0].delay = 0;
+    state->Tap[1].delay = 0;
+    state->Offset = 0;
+
+    ALfilterState_clear(&state->Filter);
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALechoStateFactory);
+
+ALeffectStateFactory *ALechoStateFactory_getFactory(void)
+{
+    static ALechoStateFactory EchoFactory = { { GET_VTABLE2(ALechoStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &EchoFactory);
+}
+
+
+void ALecho_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALecho_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALecho_setParami(effect, context, param, vals[0]);
+}
+void ALecho_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_ECHO_DELAY:
+            if(!(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Echo.Delay = val;
+            break;
+
+        case AL_ECHO_LRDELAY:
+            if(!(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Echo.LRDelay = val;
+            break;
+
+        case AL_ECHO_DAMPING:
+            if(!(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Echo.Damping = val;
+            break;
+
+        case AL_ECHO_FEEDBACK:
+            if(!(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Echo.Feedback = val;
+            break;
+
+        case AL_ECHO_SPREAD:
+            if(!(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Echo.Spread = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALecho_setParamf(effect, context, param, vals[0]);
+}
+
+void ALecho_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALecho_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALecho_getParami(effect, context, param, vals);
+}
+void ALecho_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_ECHO_DELAY:
+            *val = props->Echo.Delay;
+            break;
+
+        case AL_ECHO_LRDELAY:
+            *val = props->Echo.LRDelay;
+            break;
+
+        case AL_ECHO_DAMPING:
+            *val = props->Echo.Damping;
+            break;
+
+        case AL_ECHO_FEEDBACK:
+            *val = props->Echo.Feedback;
+            break;
+
+        case AL_ECHO_SPREAD:
+            *val = props->Echo.Spread;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALecho_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALecho_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALecho);
@@ -0,0 +1,334 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Mike Gorchak
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+/*  The document  "Effects Extension Guide.pdf"  says that low and high  *
+ *  frequencies are cutoff frequencies. This is not fully correct, they  *
+ *  are corner frequencies for low and high shelf filters. If they were  *
+ *  just cutoff frequencies, there would be no need in cutoff frequency  *
+ *  gains, which are present.  Documentation for  "Creative Proteus X2"  *
+ *  software describes  4-band equalizer functionality in a much better  *
+ *  way.  This equalizer seems  to be a predecessor  of  OpenAL  4-band  *
+ *  equalizer.  With low and high  shelf filters  we are able to cutoff  *
+ *  frequencies below and/or above corner frequencies using attenuation  *
+ *  gains (below 1.0) and amplify all low and/or high frequencies using  *
+ *  gains above 1.0.                                                     *
+ *                                                                       *
+ *     Low-shelf       Low Mid Band      High Mid Band     High-shelf    *
+ *      corner            center             center          corner      *
+ *     frequency        frequency          frequency       frequency     *
+ *    50Hz..800Hz     200Hz..3000Hz      1000Hz..8000Hz  4000Hz..16000Hz *
+ *                                                                       *
+ *          |               |                  |               |         *
+ *          |               |                  |               |         *
+ *   B -----+            /--+--\            /--+--\            +-----    *
+ *   O      |\          |   |   |          |   |   |          /|         *
+ *   O      | \        -    |    -        -    |    -        / |         *
+ *   S +    |  \      |     |     |      |     |     |      /  |         *
+ *   T      |   |    |      |      |    |      |      |    |   |         *
+ * ---------+---------------+------------------+---------------+-------- *
+ *   C      |   |    |      |      |    |      |      |    |   |         *
+ *   U -    |  /      |     |     |      |     |     |      \  |         *
+ *   T      | /        -    |    -        -    |    -        \ |         *
+ *   O      |/          |   |   |          |   |   |          \|         *
+ *   F -----+            \--+--/            \--+--/            +-----    *
+ *   F      |               |                  |               |         *
+ *          |               |                  |               |         *
+ *                                                                       *
+ * Gains vary from 0.126 up to 7.943, which means from -18dB attenuation *
+ * up to +18dB amplification. Band width varies from 0.01 up to 1.0 in   *
+ * octaves for two mid bands.                                            *
+ *                                                                       *
+ * Implementation is based on the "Cookbook formulae for audio EQ biquad *
+ * filter coefficients" by Robert Bristow-Johnson                        *
+ * http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt                   */
+
+typedef struct ALequalizerState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    /* Effect gains for each channel */
+    ALfloat Gain[MaxChannels];
+
+    /* Effect parameters */
+    ALfilterState filter[4];
+} ALequalizerState;
+
+static ALvoid ALequalizerState_Destruct(ALequalizerState *UNUSED(state))
+{
+}
+
+static ALboolean ALequalizerState_deviceUpdate(ALequalizerState *UNUSED(state), ALCdevice *UNUSED(device))
+{
+    return AL_TRUE;
+}
+
+static ALvoid ALequalizerState_update(ALequalizerState *state, ALCdevice *device, const ALeffectslot *slot)
+{
+    ALfloat frequency = (ALfloat)device->Frequency;
+    ALfloat gain = sqrtf(1.0f / device->NumChan) * slot->Gain;
+
+    SetGains(device, gain, state->Gain);
+
+    /* Calculate coefficients for the each type of filter */
+    ALfilterState_setParams(&state->filter[0], ALfilterType_LowShelf,
+                            sqrtf(slot->EffectProps.Equalizer.LowGain),
+                            slot->EffectProps.Equalizer.LowCutoff/frequency,
+                            0.0f);
+
+    ALfilterState_setParams(&state->filter[1], ALfilterType_Peaking,
+                            sqrtf(slot->EffectProps.Equalizer.Mid1Gain),
+                            slot->EffectProps.Equalizer.Mid1Center/frequency,
+                            slot->EffectProps.Equalizer.Mid1Width);
+
+    ALfilterState_setParams(&state->filter[2], ALfilterType_Peaking,
+                            sqrtf(slot->EffectProps.Equalizer.Mid2Gain),
+                            slot->EffectProps.Equalizer.Mid2Center/frequency,
+                            slot->EffectProps.Equalizer.Mid2Width);
+
+    ALfilterState_setParams(&state->filter[3], ALfilterType_HighShelf,
+                            sqrtf(slot->EffectProps.Equalizer.HighGain),
+                            slot->EffectProps.Equalizer.HighCutoff/frequency,
+                            0.0f);
+}
+
+static ALvoid ALequalizerState_process(ALequalizerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+{
+    ALuint base;
+    ALuint it;
+    ALuint kt;
+    ALuint ft;
+
+    for(base = 0;base < SamplesToDo;)
+    {
+        ALfloat temps[64];
+        ALuint td = minu(SamplesToDo-base, 64);
+
+        for(it = 0;it < td;it++)
+        {
+            ALfloat smp = SamplesIn[base+it];
+
+            for(ft = 0;ft < 4;ft++)
+                smp = ALfilterState_processSingle(&state->filter[ft], smp);
+
+            temps[it] = smp;
+        }
+
+        for(kt = 0;kt < MaxChannels;kt++)
+        {
+            ALfloat gain = state->Gain[kt];
+            if(!(gain > GAIN_SILENCE_THRESHOLD))
+                continue;
+
+            for(it = 0;it < td;it++)
+                SamplesOut[kt][base+it] += gain * temps[it];
+        }
+
+        base += td;
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALequalizerState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALequalizerState);
+
+
+typedef struct ALequalizerStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALequalizerStateFactory;
+
+ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *UNUSED(factory))
+{
+    ALequalizerState *state;
+    int it;
+
+    state = ALequalizerState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALequalizerState, ALeffectState, state);
+
+    /* Initialize sample history only on filter creation to avoid */
+    /* sound clicks if filter settings were changed in runtime.   */
+    for(it = 0; it < 4; it++)
+        ALfilterState_clear(&state->filter[it]);
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALequalizerStateFactory);
+
+ALeffectStateFactory *ALequalizerStateFactory_getFactory(void)
+{
+    static ALequalizerStateFactory EqualizerFactory = { { GET_VTABLE2(ALequalizerStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &EqualizerFactory);
+}
+
+
+void ALequalizer_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALequalizer_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALequalizer_setParami(effect, context, param, vals[0]);
+}
+void ALequalizer_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_EQUALIZER_LOW_GAIN:
+            if(!(val >= AL_EQUALIZER_MIN_LOW_GAIN && val <= AL_EQUALIZER_MAX_LOW_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.LowGain = val;
+            break;
+
+        case AL_EQUALIZER_LOW_CUTOFF:
+            if(!(val >= AL_EQUALIZER_MIN_LOW_CUTOFF && val <= AL_EQUALIZER_MAX_LOW_CUTOFF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.LowCutoff = val;
+            break;
+
+        case AL_EQUALIZER_MID1_GAIN:
+            if(!(val >= AL_EQUALIZER_MIN_MID1_GAIN && val <= AL_EQUALIZER_MAX_MID1_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.Mid1Gain = val;
+            break;
+
+        case AL_EQUALIZER_MID1_CENTER:
+            if(!(val >= AL_EQUALIZER_MIN_MID1_CENTER && val <= AL_EQUALIZER_MAX_MID1_CENTER))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.Mid1Center = val;
+            break;
+
+        case AL_EQUALIZER_MID1_WIDTH:
+            if(!(val >= AL_EQUALIZER_MIN_MID1_WIDTH && val <= AL_EQUALIZER_MAX_MID1_WIDTH))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.Mid1Width = val;
+            break;
+
+        case AL_EQUALIZER_MID2_GAIN:
+            if(!(val >= AL_EQUALIZER_MIN_MID2_GAIN && val <= AL_EQUALIZER_MAX_MID2_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.Mid2Gain = val;
+            break;
+
+        case AL_EQUALIZER_MID2_CENTER:
+            if(!(val >= AL_EQUALIZER_MIN_MID2_CENTER && val <= AL_EQUALIZER_MAX_MID2_CENTER))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.Mid2Center = val;
+            break;
+
+        case AL_EQUALIZER_MID2_WIDTH:
+            if(!(val >= AL_EQUALIZER_MIN_MID2_WIDTH && val <= AL_EQUALIZER_MAX_MID2_WIDTH))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.Mid2Width = val;
+            break;
+
+        case AL_EQUALIZER_HIGH_GAIN:
+            if(!(val >= AL_EQUALIZER_MIN_HIGH_GAIN && val <= AL_EQUALIZER_MAX_HIGH_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.HighGain = val;
+            break;
+
+        case AL_EQUALIZER_HIGH_CUTOFF:
+            if(!(val >= AL_EQUALIZER_MIN_HIGH_CUTOFF && val <= AL_EQUALIZER_MAX_HIGH_CUTOFF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Equalizer.HighCutoff = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALequalizer_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALequalizer_setParamf(effect, context, param, vals[0]);
+}
+
+void ALequalizer_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+void ALequalizer_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALequalizer_getParami(effect, context, param, vals);
+}
+void ALequalizer_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_EQUALIZER_LOW_GAIN:
+            *val = props->Equalizer.LowGain;
+            break;
+
+        case AL_EQUALIZER_LOW_CUTOFF:
+            *val = props->Equalizer.LowCutoff;
+            break;
+
+        case AL_EQUALIZER_MID1_GAIN:
+            *val = props->Equalizer.Mid1Gain;
+            break;
+
+        case AL_EQUALIZER_MID1_CENTER:
+            *val = props->Equalizer.Mid1Center;
+            break;
+
+        case AL_EQUALIZER_MID1_WIDTH:
+            *val = props->Equalizer.Mid1Width;
+            break;
+
+        case AL_EQUALIZER_MID2_GAIN:
+            *val = props->Equalizer.Mid2Gain;
+            break;
+
+        case AL_EQUALIZER_MID2_CENTER:
+            *val = props->Equalizer.Mid2Center;
+            break;
+
+        case AL_EQUALIZER_MID2_WIDTH:
+            *val = props->Equalizer.Mid2Width;
+            break;
+
+        case AL_EQUALIZER_HIGH_GAIN:
+            *val = props->Equalizer.HighGain;
+            break;
+
+        case AL_EQUALIZER_HIGH_CUTOFF:
+            *val = props->Equalizer.HighCutoff;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALequalizer_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALequalizer_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALequalizer);
@@ -0,0 +1,396 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2013 by Mike Gorchak
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+enum FlangerWaveForm {
+    FWF_Triangle = AL_FLANGER_WAVEFORM_TRIANGLE,
+    FWF_Sinusoid = AL_FLANGER_WAVEFORM_SINUSOID
+};
+
+typedef struct ALflangerState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    ALfloat *SampleBuffer[2];
+    ALuint BufferLength;
+    ALuint offset;
+    ALuint lfo_range;
+    ALfloat lfo_scale;
+    ALint lfo_disp;
+
+    /* Gains for left and right sides */
+    ALfloat Gain[2][MaxChannels];
+
+    /* effect parameters */
+    enum FlangerWaveForm waveform;
+    ALint delay;
+    ALfloat depth;
+    ALfloat feedback;
+} ALflangerState;
+
+static ALvoid ALflangerState_Destruct(ALflangerState *state)
+{
+    free(state->SampleBuffer[0]);
+    state->SampleBuffer[0] = NULL;
+    state->SampleBuffer[1] = NULL;
+}
+
+static ALboolean ALflangerState_deviceUpdate(ALflangerState *state, ALCdevice *Device)
+{
+    ALuint maxlen;
+    ALuint it;
+
+    maxlen = fastf2u(AL_FLANGER_MAX_DELAY * 3.0f * Device->Frequency) + 1;
+    maxlen = NextPowerOf2(maxlen);
+
+    if(maxlen != state->BufferLength)
+    {
+        void *temp;
+
+        temp = realloc(state->SampleBuffer[0], maxlen * sizeof(ALfloat) * 2);
+        if(!temp) return AL_FALSE;
+        state->SampleBuffer[0] = temp;
+        state->SampleBuffer[1] = state->SampleBuffer[0] + maxlen;
+
+        state->BufferLength = maxlen;
+    }
+
+    for(it = 0;it < state->BufferLength;it++)
+    {
+        state->SampleBuffer[0][it] = 0.0f;
+        state->SampleBuffer[1][it] = 0.0f;
+    }
+
+    return AL_TRUE;
+}
+
+static ALvoid ALflangerState_update(ALflangerState *state, ALCdevice *Device, const ALeffectslot *Slot)
+{
+    ALfloat frequency = (ALfloat)Device->Frequency;
+    ALfloat rate;
+    ALint phase;
+
+    switch(Slot->EffectProps.Flanger.Waveform)
+    {
+        case AL_FLANGER_WAVEFORM_TRIANGLE:
+            state->waveform = FWF_Triangle;
+            break;
+        case AL_FLANGER_WAVEFORM_SINUSOID:
+            state->waveform = FWF_Sinusoid;
+            break;
+    }
+    state->depth = Slot->EffectProps.Flanger.Depth;
+    state->feedback = Slot->EffectProps.Flanger.Feedback;
+    state->delay = fastf2i(Slot->EffectProps.Flanger.Delay * frequency);
+
+    /* Gains for left and right sides */
+    ComputeAngleGains(Device, atan2f(-1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[0]);
+    ComputeAngleGains(Device, atan2f(+1.0f, 0.0f), 0.0f, Slot->Gain, state->Gain[1]);
+
+    phase = Slot->EffectProps.Flanger.Phase;
+    rate = Slot->EffectProps.Flanger.Rate;
+    if(!(rate > 0.0f))
+    {
+        state->lfo_scale = 0.0f;
+        state->lfo_range = 1;
+        state->lfo_disp = 0;
+    }
+    else
+    {
+        /* Calculate LFO coefficient */
+        state->lfo_range = fastf2u(frequency/rate + 0.5f);
+        switch(state->waveform)
+        {
+            case FWF_Triangle:
+                state->lfo_scale = 4.0f / state->lfo_range;
+                break;
+            case FWF_Sinusoid:
+                state->lfo_scale = F_2PI / state->lfo_range;
+                break;
+        }
+
+        /* Calculate lfo phase displacement */
+        state->lfo_disp = fastf2i(state->lfo_range * (phase/360.0f));
+    }
+}
+
+static inline void Triangle(ALint *delay_left, ALint *delay_right, ALuint offset, const ALflangerState *state)
+{
+    ALfloat lfo_value;
+
+    lfo_value = 2.0f - fabsf(2.0f - state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_left = fastf2i(lfo_value) + state->delay;
+
+    offset += state->lfo_disp;
+    lfo_value = 2.0f - fabsf(2.0f - state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_right = fastf2i(lfo_value) + state->delay;
+}
+
+static inline void Sinusoid(ALint *delay_left, ALint *delay_right, ALuint offset, const ALflangerState *state)
+{
+    ALfloat lfo_value;
+
+    lfo_value = 1.0f + sinf(state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_left = fastf2i(lfo_value) + state->delay;
+
+    offset += state->lfo_disp;
+    lfo_value = 1.0f + sinf(state->lfo_scale*(offset%state->lfo_range));
+    lfo_value *= state->depth * state->delay;
+    *delay_right = fastf2i(lfo_value) + state->delay;
+}
+
+#define DECL_TEMPLATE(Func)                                                   \
+static void Process##Func(ALflangerState *state, const ALuint SamplesToDo,    \
+  const ALfloat *restrict SamplesIn, ALfloat (*restrict out)[2])              \
+{                                                                             \
+    const ALuint bufmask = state->BufferLength-1;                             \
+    ALfloat *restrict leftbuf = state->SampleBuffer[0];                       \
+    ALfloat *restrict rightbuf = state->SampleBuffer[1];                      \
+    ALuint offset = state->offset;                                            \
+    const ALfloat feedback = state->feedback;                                 \
+    ALuint it;                                                                \
+                                                                              \
+    for(it = 0;it < SamplesToDo;it++)                                         \
+    {                                                                         \
+        ALint delay_left, delay_right;                                        \
+        Func(&delay_left, &delay_right, offset, state);                       \
+                                                                              \
+        out[it][0] = leftbuf[(offset-delay_left)&bufmask];                    \
+        leftbuf[offset&bufmask] = (out[it][0]+SamplesIn[it]) * feedback;      \
+                                                                              \
+        out[it][1] = rightbuf[(offset-delay_right)&bufmask];                  \
+        rightbuf[offset&bufmask] = (out[it][1]+SamplesIn[it]) * feedback;     \
+                                                                              \
+        offset++;                                                             \
+    }                                                                         \
+    state->offset = offset;                                                   \
+}
+
+DECL_TEMPLATE(Triangle)
+DECL_TEMPLATE(Sinusoid)
+
+#undef DECL_TEMPLATE
+
+static ALvoid ALflangerState_process(ALflangerState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+{
+    ALuint it, kt;
+    ALuint base;
+
+    for(base = 0;base < SamplesToDo;)
+    {
+        ALfloat temps[64][2];
+        ALuint td = minu(SamplesToDo-base, 64);
+
+        switch(state->waveform)
+        {
+            case FWF_Triangle:
+                ProcessTriangle(state, td, SamplesIn+base, temps);
+                break;
+            case FWF_Sinusoid:
+                ProcessSinusoid(state, td, SamplesIn+base, temps);
+                break;
+        }
+
+        for(kt = 0;kt < MaxChannels;kt++)
+        {
+            ALfloat gain = state->Gain[0][kt];
+            if(gain > GAIN_SILENCE_THRESHOLD)
+            {
+                for(it = 0;it < td;it++)
+                    SamplesOut[kt][it+base] += temps[it][0] * gain;
+            }
+
+            gain = state->Gain[1][kt];
+            if(gain > GAIN_SILENCE_THRESHOLD)
+            {
+                for(it = 0;it < td;it++)
+                    SamplesOut[kt][it+base] += temps[it][1] * gain;
+            }
+        }
+
+        base += td;
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALflangerState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALflangerState);
+
+
+typedef struct ALflangerStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALflangerStateFactory;
+
+ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *UNUSED(factory))
+{
+    ALflangerState *state;
+
+    state = ALflangerState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALflangerState, ALeffectState, state);
+
+    state->BufferLength = 0;
+    state->SampleBuffer[0] = NULL;
+    state->SampleBuffer[1] = NULL;
+    state->offset = 0;
+    state->lfo_range = 1;
+    state->waveform = FWF_Triangle;
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALflangerStateFactory);
+
+ALeffectStateFactory *ALflangerStateFactory_getFactory(void)
+{
+    static ALflangerStateFactory FlangerFactory = { { GET_VTABLE2(ALflangerStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &FlangerFactory);
+}
+
+
+void ALflanger_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_FLANGER_WAVEFORM:
+            if(!(val >= AL_FLANGER_MIN_WAVEFORM && val <= AL_FLANGER_MAX_WAVEFORM))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Flanger.Waveform = val;
+            break;
+
+        case AL_FLANGER_PHASE:
+            if(!(val >= AL_FLANGER_MIN_PHASE && val <= AL_FLANGER_MAX_PHASE))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Flanger.Phase = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALflanger_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALflanger_setParami(effect, context, param, vals[0]);
+}
+void ALflanger_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_FLANGER_RATE:
+            if(!(val >= AL_FLANGER_MIN_RATE && val <= AL_FLANGER_MAX_RATE))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Flanger.Rate = val;
+            break;
+
+        case AL_FLANGER_DEPTH:
+            if(!(val >= AL_FLANGER_MIN_DEPTH && val <= AL_FLANGER_MAX_DEPTH))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Flanger.Depth = val;
+            break;
+
+        case AL_FLANGER_FEEDBACK:
+            if(!(val >= AL_FLANGER_MIN_FEEDBACK && val <= AL_FLANGER_MAX_FEEDBACK))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Flanger.Feedback = val;
+            break;
+
+        case AL_FLANGER_DELAY:
+            if(!(val >= AL_FLANGER_MIN_DELAY && val <= AL_FLANGER_MAX_DELAY))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Flanger.Delay = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALflanger_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALflanger_setParamf(effect, context, param, vals[0]);
+}
+
+void ALflanger_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_FLANGER_WAVEFORM:
+            *val = props->Flanger.Waveform;
+            break;
+
+        case AL_FLANGER_PHASE:
+            *val = props->Flanger.Phase;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALflanger_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALflanger_getParami(effect, context, param, vals);
+}
+void ALflanger_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_FLANGER_RATE:
+            *val = props->Flanger.Rate;
+            break;
+
+        case AL_FLANGER_DEPTH:
+            *val = props->Flanger.Depth;
+            break;
+
+        case AL_FLANGER_FEEDBACK:
+            *val = props->Flanger.Feedback;
+            break;
+
+        case AL_FLANGER_DELAY:
+            *val = props->Flanger.Delay;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALflanger_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALflanger_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALflanger);
@@ -0,0 +1,303 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2009 by Chris Robinson.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alFilter.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+#include "alu.h"
+
+
+typedef struct ALmodulatorState {
+    DERIVE_FROM_TYPE(ALeffectState);
+
+    enum {
+        SINUSOID,
+        SAWTOOTH,
+        SQUARE
+    } Waveform;
+
+    ALuint index;
+    ALuint step;
+
+    ALfloat Gain[MaxChannels];
+
+    ALfilterState Filter;
+} ALmodulatorState;
+
+#define WAVEFORM_FRACBITS  24
+#define WAVEFORM_FRACONE   (1<<WAVEFORM_FRACBITS)
+#define WAVEFORM_FRACMASK  (WAVEFORM_FRACONE-1)
+
+static inline ALfloat Sin(ALuint index)
+{
+    return sinf(index*(F_2PI/WAVEFORM_FRACONE) - F_PI)*0.5f + 0.5f;
+}
+
+static inline ALfloat Saw(ALuint index)
+{
+    return (ALfloat)index / WAVEFORM_FRACONE;
+}
+
+static inline ALfloat Square(ALuint index)
+{
+    return (ALfloat)((index >> (WAVEFORM_FRACBITS - 1)) & 1);
+}
+
+#define DECL_TEMPLATE(func)                                                   \
+static void Process##func(ALmodulatorState *state, ALuint SamplesToDo,        \
+  const ALfloat *restrict SamplesIn,                                          \
+  ALfloat (*restrict SamplesOut)[BUFFERSIZE])                                 \
+{                                                                             \
+    const ALuint step = state->step;                                          \
+    ALuint index = state->index;                                              \
+    ALuint base;                                                              \
+                                                                              \
+    for(base = 0;base < SamplesToDo;)                                         \
+    {                                                                         \
+        ALfloat temps[64];                                                    \
+        ALuint td = minu(SamplesToDo-base, 64);                               \
+        ALuint i, k;                                                          \
+                                                                              \
+        for(i = 0;i < td;i++)                                                 \
+        {                                                                     \
+            ALfloat samp;                                                     \
+            samp = SamplesIn[base+i];                                         \
+            samp = ALfilterState_processSingle(&state->Filter, samp);         \
+                                                                              \
+            index += step;                                                    \
+            index &= WAVEFORM_FRACMASK;                                       \
+            temps[i] = samp * func(index);                                    \
+        }                                                                     \
+                                                                              \
+        for(k = 0;k < MaxChannels;k++)                                        \
+        {                                                                     \
+            ALfloat gain = state->Gain[k];                                    \
+            if(!(gain > GAIN_SILENCE_THRESHOLD))                              \
+                continue;                                                     \
+                                                                              \
+            for(i = 0;i < td;i++)                                             \
+                SamplesOut[k][base+i] += gain * temps[i];                     \
+        }                                                                     \
+                                                                              \
+        base += td;                                                           \
+    }                                                                         \
+    state->index = index;                                                     \
+}
+
+DECL_TEMPLATE(Sin)
+DECL_TEMPLATE(Saw)
+DECL_TEMPLATE(Square)
+
+#undef DECL_TEMPLATE
+
+
+static ALvoid ALmodulatorState_Destruct(ALmodulatorState *UNUSED(state))
+{
+}
+
+static ALboolean ALmodulatorState_deviceUpdate(ALmodulatorState *UNUSED(state), ALCdevice *UNUSED(device))
+{
+    return AL_TRUE;
+}
+
+static ALvoid ALmodulatorState_update(ALmodulatorState *state, ALCdevice *Device, const ALeffectslot *Slot)
+{
+    ALfloat gain, cw, a;
+
+    if(Slot->EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SINUSOID)
+        state->Waveform = SINUSOID;
+    else if(Slot->EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SAWTOOTH)
+        state->Waveform = SAWTOOTH;
+    else if(Slot->EffectProps.Modulator.Waveform == AL_RING_MODULATOR_SQUARE)
+        state->Waveform = SQUARE;
+
+    state->step = fastf2u(Slot->EffectProps.Modulator.Frequency*WAVEFORM_FRACONE /
+                          Device->Frequency);
+    if(state->step == 0) state->step = 1;
+
+    /* Custom filter coeffs, which match the old version instead of a low-shelf. */
+    cw = cosf(F_2PI * Slot->EffectProps.Modulator.HighPassCutoff / Device->Frequency);
+    a = (2.0f-cw) - sqrtf(powf(2.0f-cw, 2.0f) - 1.0f);
+
+    state->Filter.b[0] = a;
+    state->Filter.b[1] = -a;
+    state->Filter.b[2] = 0.0f;
+    state->Filter.a[0] = 1.0f;
+    state->Filter.a[1] = -a;
+    state->Filter.a[2] = 0.0f;
+
+    gain = sqrtf(1.0f/Device->NumChan) * Slot->Gain;
+    SetGains(Device, gain, state->Gain);
+}
+
+static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALuint SamplesToDo, const ALfloat *restrict SamplesIn, ALfloat (*restrict SamplesOut)[BUFFERSIZE])
+{
+    switch(state->Waveform)
+    {
+        case SINUSOID:
+            ProcessSin(state, SamplesToDo, SamplesIn, SamplesOut);
+            break;
+
+        case SAWTOOTH:
+            ProcessSaw(state, SamplesToDo, SamplesIn, SamplesOut);
+            break;
+
+        case SQUARE:
+            ProcessSquare(state, SamplesToDo, SamplesIn, SamplesOut);
+            break;
+    }
+}
+
+DECLARE_DEFAULT_ALLOCATORS(ALmodulatorState)
+
+DEFINE_ALEFFECTSTATE_VTABLE(ALmodulatorState);
+
+
+typedef struct ALmodulatorStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALmodulatorStateFactory;
+
+static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *UNUSED(factory))
+{
+    ALmodulatorState *state;
+
+    state = ALmodulatorState_New(sizeof(*state));
+    if(!state) return NULL;
+    SET_VTABLE2(ALmodulatorState, ALeffectState, state);
+
+    state->index = 0;
+    state->step = 1;
+
+    ALfilterState_clear(&state->Filter);
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALmodulatorStateFactory);
+
+ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void)
+{
+    static ALmodulatorStateFactory ModulatorFactory = { { GET_VTABLE2(ALmodulatorStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &ModulatorFactory);
+}
+
+
+void ALmodulator_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_RING_MODULATOR_FREQUENCY:
+            if(!(val >= AL_RING_MODULATOR_MIN_FREQUENCY && val <= AL_RING_MODULATOR_MAX_FREQUENCY))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Modulator.Frequency = val;
+            break;
+
+        case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+            if(!(val >= AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF && val <= AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Modulator.HighPassCutoff = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALmodulator_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    ALmodulator_setParamf(effect, context, param, vals[0]);
+}
+void ALmodulator_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
+{
+    ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_RING_MODULATOR_FREQUENCY:
+        case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+            ALmodulator_setParamf(effect, context, param, (ALfloat)val);
+            break;
+
+        case AL_RING_MODULATOR_WAVEFORM:
+            if(!(val >= AL_RING_MODULATOR_MIN_WAVEFORM && val <= AL_RING_MODULATOR_MAX_WAVEFORM))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            props->Modulator.Waveform = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALmodulator_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
+{
+    ALmodulator_setParami(effect, context, param, vals[0]);
+}
+
+void ALmodulator_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_RING_MODULATOR_FREQUENCY:
+            *val = (ALint)props->Modulator.Frequency;
+            break;
+        case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+            *val = (ALint)props->Modulator.HighPassCutoff;
+            break;
+        case AL_RING_MODULATOR_WAVEFORM:
+            *val = props->Modulator.Waveform;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALmodulator_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
+{
+    ALmodulator_getParami(effect, context, param, vals);
+}
+void ALmodulator_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    const ALeffectProps *props = &effect->Props;
+    switch(param)
+    {
+        case AL_RING_MODULATOR_FREQUENCY:
+            *val = props->Modulator.Frequency;
+            break;
+        case AL_RING_MODULATOR_HIGHPASS_CUTOFF:
+            *val = props->Modulator.HighPassCutoff;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALmodulator_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    ALmodulator_getParamf(effect, context, param, vals);
+}
+
+DEFINE_ALEFFECT_VTABLE(ALmodulator);
@@ -0,0 +1,165 @@
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alAuxEffectSlot.h"
+#include "alError.h"
+
+
+typedef struct ALnullState {
+    DERIVE_FROM_TYPE(ALeffectState);
+} ALnullState;
+
+
+/* This destructs (not free!) the effect state. It's called only when the
+ * effect slot is no longer used.
+ */
+static ALvoid ALnullState_Destruct(ALnullState* UNUSED(state))
+{
+}
+
+/* This updates the device-dependant effect state. This is called on
+ * initialization and any time the device parameters (eg. playback frequency,
+ * format) have been changed.
+ */
+static ALboolean ALnullState_deviceUpdate(ALnullState* UNUSED(state), ALCdevice* UNUSED(device))
+{
+    return AL_TRUE;
+}
+
+/* This updates the effect state. This is called any time the effect is
+ * (re)loaded into a slot.
+ */
+static ALvoid ALnullState_update(ALnullState* UNUSED(state), ALCdevice* UNUSED(device), const ALeffectslot* UNUSED(slot))
+{
+}
+
+/* This processes the effect state, for the given number of samples from the
+ * input to the output buffer. The result should be added to the output buffer,
+ * not replace it.
+ */
+static ALvoid ALnullState_process(ALnullState* UNUSED(state), ALuint UNUSED(samplesToDo), const ALfloat *restrict UNUSED(samplesIn), ALfloat (*restrict samplesOut)[BUFFERSIZE])
+{
+    /* NOTE: Couldn't use the UNUSED macro on samplesOut due to the way GCC's
+     * __attribute__ declaration interacts with the parenthesis. */
+    (void)samplesOut;
+}
+
+/* This allocates memory to store the object, before it gets constructed.
+ * DECLARE_DEFAULT_ALLOCATORS can be used to declate a default method.
+ */
+static void *ALnullState_New(size_t size)
+{
+    return malloc(size);
+}
+
+/* This frees the memory used by the object, after it has been destructed.
+ * DECLARE_DEFAULT_ALLOCATORS can be used to declate a default method.
+ */
+static void ALnullState_Delete(void *ptr)
+{
+    free(ptr);
+}
+
+/* Define the forwards and the ALeffectState vtable for this type. */
+DEFINE_ALEFFECTSTATE_VTABLE(ALnullState);
+
+
+typedef struct ALnullStateFactory {
+    DERIVE_FROM_TYPE(ALeffectStateFactory);
+} ALnullStateFactory;
+
+/* Creates ALeffectState objects of the appropriate type. */
+ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory))
+{
+    ALnullState *state;
+
+    state = ALnullState_New(sizeof(*state));
+    if(!state) return NULL;
+    /* Set vtables for inherited types. */
+    SET_VTABLE2(ALnullState, ALeffectState, state);
+
+    return STATIC_CAST(ALeffectState, state);
+}
+
+/* Define the ALeffectStateFactory vtable for this type. */
+DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALnullStateFactory);
+
+ALeffectStateFactory *ALnullStateFactory_getFactory(void)
+{
+    static ALnullStateFactory NullFactory = { { GET_VTABLE2(ALnullStateFactory, ALeffectStateFactory) } };
+
+    return STATIC_CAST(ALeffectStateFactory, &NullFactory);
+}
+
+
+void ALnull_setParami(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint UNUSED(val))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALnull_setParamiv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALint* UNUSED(vals))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALnull_setParamf(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat UNUSED(val))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALnull_setParamfv(ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, const ALfloat* UNUSED(vals))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+
+void ALnull_getParami(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(val))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALnull_getParamiv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALint* UNUSED(vals))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALnull_getParamf(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(val))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+void ALnull_getParamfv(const ALeffect* UNUSED(effect), ALCcontext *context, ALenum param, ALfloat* UNUSED(vals))
+{
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+
+DEFINE_ALEFFECT_VTABLE(ALnull);
@@ -0,0 +1,31 @@
+#ifndef AL_EVTQUEUE_H
+#define AL_EVTQUEUE_H
+
+#include "AL/al.h"
+
+#include "alMain.h"
+
+typedef struct MidiEvent {
+    ALuint64 time;
+    ALuint event;
+    union {
+        ALuint val[2];
+        struct {
+            ALvoid *data;
+            ALsizei size;
+        } sysex;
+    } param;
+} MidiEvent;
+
+typedef struct EvtQueue {
+    MidiEvent *events;
+    ALsizei pos;
+    ALsizei size;
+    ALsizei maxsize;
+} EvtQueue;
+
+void InitEvtQueue(EvtQueue *queue);
+void ResetEvtQueue(EvtQueue *queue);
+ALenum InsertEvtQueue(EvtQueue *queue, const MidiEvent *evt);
+
+#endif /* AL_EVTQUEUE_H */
@@ -0,0 +1,814 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2011 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#ifdef _WIN32
+#ifdef __MINGW32__
+#define _WIN32_IE 0x501
+#else
+#define _WIN32_IE 0x400
+#endif
+#endif
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <time.h>
+#include <errno.h>
+#include <stdarg.h>
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+
+#ifndef AL_NO_UID_DEFS
+#if defined(HAVE_GUIDDEF_H) || defined(HAVE_INITGUID_H)
+#define INITGUID
+#include <windows.h>
+#ifdef HAVE_GUIDDEF_H
+#include <guiddef.h>
+#else
+#include <initguid.h>
+#endif
+
+DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM,        0x00000001, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
+DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
+
+DEFINE_GUID(IID_IDirectSoundNotify,   0xb0210783, 0x89cd, 0x11d0, 0xaf,0x08, 0x00,0xa0,0xc9,0x25,0xcd,0x16);
+
+DEFINE_GUID(CLSID_MMDeviceEnumerator, 0xbcde0395, 0xe52f, 0x467c, 0x8e,0x3d, 0xc4,0x57,0x92,0x91,0x69,0x2e);
+DEFINE_GUID(IID_IMMDeviceEnumerator,  0xa95664d2, 0x9614, 0x4f35, 0xa7,0x46, 0xde,0x8d,0xb6,0x36,0x17,0xe6);
+DEFINE_GUID(IID_IAudioClient,         0x1cb9ad4c, 0xdbfa, 0x4c32, 0xb1,0x78, 0xc2,0xf5,0x68,0xa7,0x03,0xb2);
+DEFINE_GUID(IID_IAudioRenderClient,   0xf294acfc, 0x3146, 0x4483, 0xa7,0xbf, 0xad,0xdc,0xa7,0xc2,0x60,0xe2);
+
+#ifdef HAVE_MMDEVAPI
+#include <devpropdef.h>
+DEFINE_DEVPROPKEY(DEVPKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80,0x20, 0x67,0xd1,0x46,0xa8,0x50,0xe0, 14);
+#endif
+#endif
+#endif /* AL_NO_UID_DEFS */
+
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+#ifdef HAVE_INTRIN_H
+#include <intrin.h>
+#endif
+#ifdef HAVE_CPUID_H
+#include <cpuid.h>
+#endif
+#ifdef HAVE_SYS_SYSCONF_H
+#include <sys/sysconf.h>
+#endif
+#ifdef HAVE_FLOAT_H
+#include <float.h>
+#endif
+#ifdef HAVE_IEEEFP_H
+#include <ieeefp.h>
+#endif
+
+#ifdef _WIN32_IE
+#include <shlobj.h>
+#endif
+
+#include "alMain.h"
+#include "alu.h"
+#include "atomic.h"
+#include "uintmap.h"
+#include "vector.h"
+#include "alstring.h"
+#include "compat.h"
+#include "threads.h"
+
+
+extern inline ALuint NextPowerOf2(ALuint value);
+extern inline ALint fastf2i(ALfloat f);
+extern inline ALuint fastf2u(ALfloat f);
+
+
+ALuint CPUCapFlags = 0;
+
+
+void FillCPUCaps(ALuint capfilter)
+{
+    ALuint caps = 0;
+
+/* FIXME: We really should get this for all available CPUs in case different
+ * CPUs have different caps (is that possible on one machine?). */
+#if defined(HAVE_GCC_GET_CPUID) && (defined(__i386__) || defined(__x86_64__) || \
+                                    defined(_M_IX86) || defined(_M_X64))
+    union {
+        unsigned int regs[4];
+        char str[sizeof(unsigned int[4])];
+    } cpuinf[3];
+
+    if(!__get_cpuid(0, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
+        ERR("Failed to get CPUID\n");
+    else
+    {
+        unsigned int maxfunc = cpuinf[0].regs[0];
+        unsigned int maxextfunc = 0;
+
+        if(__get_cpuid(0x80000000, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
+            maxextfunc = cpuinf[0].regs[0];
+        TRACE("Detected max CPUID function: 0x%x (ext. 0x%x)\n", maxfunc, maxextfunc);
+
+        TRACE("Vendor ID: \"%.4s%.4s%.4s\"\n", cpuinf[0].str+4, cpuinf[0].str+12, cpuinf[0].str+8);
+        if(maxextfunc >= 0x80000004 &&
+           __get_cpuid(0x80000002, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]) &&
+           __get_cpuid(0x80000003, &cpuinf[1].regs[0], &cpuinf[1].regs[1], &cpuinf[1].regs[2], &cpuinf[1].regs[3]) &&
+           __get_cpuid(0x80000004, &cpuinf[2].regs[0], &cpuinf[2].regs[1], &cpuinf[2].regs[2], &cpuinf[2].regs[3]))
+            TRACE("Name: \"%.16s%.16s%.16s\"\n", cpuinf[0].str, cpuinf[1].str, cpuinf[2].str);
+
+        if(maxfunc >= 1 &&
+           __get_cpuid(1, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
+        {
+            if((cpuinf[0].regs[3]&(1<<25)))
+            {
+                caps |= CPU_CAP_SSE;
+                if((cpuinf[0].regs[3]&(1<<26)))
+                {
+                    caps |= CPU_CAP_SSE2;
+                    if((cpuinf[0].regs[2]&(1<<19)))
+                        caps |= CPU_CAP_SSE4_1;
+                }
+            }
+        }
+    }
+#elif defined(HAVE_CPUID_INTRINSIC) && (defined(__i386__) || defined(__x86_64__) || \
+                                        defined(_M_IX86) || defined(_M_X64))
+    union {
+        int regs[4];
+        char str[sizeof(int[4])];
+    } cpuinf[3];
+
+    (__cpuid)(cpuinf[0].regs, 0);
+    if(cpuinf[0].regs[0] == 0)
+        ERR("Failed to get CPUID\n");
+    else
+    {
+        unsigned int maxfunc = cpuinf[0].regs[0];
+        unsigned int maxextfunc;
+
+        (__cpuid)(cpuinf[0].regs, 0x80000000);
+        maxextfunc = cpuinf[0].regs[0];
+
+        TRACE("Detected max CPUID function: 0x%x (ext. 0x%x)\n", maxfunc, maxextfunc);
+
+        TRACE("Vendor ID: \"%.4s%.4s%.4s\"\n", cpuinf[0].str+4, cpuinf[0].str+12, cpuinf[0].str+8);
+        if(maxextfunc >= 0x80000004)
+        {
+            (__cpuid)(cpuinf[0].regs, 0x80000002);
+            (__cpuid)(cpuinf[1].regs, 0x80000003);
+            (__cpuid)(cpuinf[2].regs, 0x80000004);
+            TRACE("Name: \"%.16s%.16s%.16s\"\n", cpuinf[0].str, cpuinf[1].str, cpuinf[2].str);
+        }
+
+        if(maxfunc >= 1)
+        {
+            (__cpuid)(cpuinf[0].regs, 1);
+            if((cpuinf[0].regs[3]&(1<<25)))
+            {
+                caps |= CPU_CAP_SSE;
+                if((cpuinf[0].regs[3]&(1<<26)))
+                {
+                    caps |= CPU_CAP_SSE2;
+                    if((cpuinf[0].regs[2]&(1<<19)))
+                        caps |= CPU_CAP_SSE4_1;
+                }
+            }
+        }
+    }
+#else
+    /* Assume support for whatever's supported if we can't check for it */
+#if defined(HAVE_SSE4_1)
+#warning "Assuming SSE 4.1 run-time support!"
+    capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2 | CPU_CAP_SSE4_1;
+#elif defined(HAVE_SSE2)
+#warning "Assuming SSE 2 run-time support!"
+    capfilter |= CPU_CAP_SSE | CPU_CAP_SSE2;
+#elif defined(HAVE_SSE)
+#warning "Assuming SSE run-time support!"
+    capfilter |= CPU_CAP_SSE;
+#endif
+#endif
+#ifdef HAVE_NEON
+    /* Assume Neon support if compiled with it */
+    caps |= CPU_CAP_NEON;
+#endif
+
+    TRACE("Extensions:%s%s%s%s%s\n",
+        ((capfilter&CPU_CAP_SSE)    ? ((caps&CPU_CAP_SSE)    ? " +SSE"    : " -SSE")    : ""),
+        ((capfilter&CPU_CAP_SSE2)   ? ((caps&CPU_CAP_SSE2)   ? " +SSE2"   : " -SSE2")   : ""),
+        ((capfilter&CPU_CAP_SSE4_1) ? ((caps&CPU_CAP_SSE4_1) ? " +SSE4.1" : " -SSE4.1") : ""),
+        ((capfilter&CPU_CAP_NEON)   ? ((caps&CPU_CAP_NEON)   ? " +Neon"   : " -Neon")   : ""),
+        ((!capfilter) ? " -none-" : "")
+    );
+    CPUCapFlags = caps & capfilter;
+}
+
+
+void *al_malloc(size_t alignment, size_t size)
+{
+#if defined(HAVE_ALIGNED_ALLOC)
+    size = (size+(alignment-1))&~(alignment-1);
+    return aligned_alloc(alignment, size);
+#elif defined(HAVE_POSIX_MEMALIGN)
+    void *ret;
+    if(posix_memalign(&ret, alignment, size) == 0)
+        return ret;
+    return NULL;
+#elif defined(HAVE__ALIGNED_MALLOC)
+    return _aligned_malloc(size, alignment);
+#else
+    char *ret = malloc(size+alignment);
+    if(ret != NULL)
+    {
+        *(ret++) = 0x00;
+        while(((ALintptrEXT)ret&(alignment-1)) != 0)
+            *(ret++) = 0x55;
+    }
+    return ret;
+#endif
+}
+
+void *al_calloc(size_t alignment, size_t size)
+{
+    void *ret = al_malloc(alignment, size);
+    if(ret) memset(ret, 0, size);
+    return ret;
+}
+
+void al_free(void *ptr)
+{
+#if defined(HAVE_ALIGNED_ALLOC) || defined(HAVE_POSIX_MEMALIGN)
+    free(ptr);
+#elif defined(HAVE__ALIGNED_MALLOC)
+    _aligned_free(ptr);
+#else
+    if(ptr != NULL)
+    {
+        char *finder = ptr;
+        do {
+            --finder;
+        } while(*finder == 0x55);
+        free(finder);
+    }
+#endif
+}
+
+
+void SetMixerFPUMode(FPUCtl *ctl)
+{
+#ifdef HAVE_FENV_H
+    fegetenv(STATIC_CAST(fenv_t, ctl));
+#if defined(__GNUC__) && defined(HAVE_SSE)
+    if((CPUCapFlags&CPU_CAP_SSE))
+        __asm__ __volatile__("stmxcsr %0" : "=m" (*&ctl->sse_state));
+#endif
+
+#ifdef FE_TOWARDZERO
+    fesetround(FE_TOWARDZERO);
+#endif
+#if defined(__GNUC__) && defined(HAVE_SSE)
+    if((CPUCapFlags&CPU_CAP_SSE))
+    {
+        int sseState = ctl->sse_state;
+        sseState |= 0x6000; /* set round-to-zero */
+        sseState |= 0x8000; /* set flush-to-zero */
+        if((CPUCapFlags&CPU_CAP_SSE2))
+            sseState |= 0x0040; /* set denormals-are-zero */
+        __asm__ __volatile__("ldmxcsr %0" : : "m" (*&sseState));
+    }
+#endif
+
+#elif defined(HAVE___CONTROL87_2)
+
+    int mode;
+    __control87_2(0, 0, &ctl->state, NULL);
+    __control87_2(_RC_CHOP, _MCW_RC, &mode, NULL);
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+    {
+        __control87_2(0, 0, NULL, &ctl->sse_state);
+        __control87_2(_RC_CHOP|_DN_FLUSH, _MCW_RC|_MCW_DN, NULL, &mode);
+    }
+#endif
+
+#elif defined(HAVE__CONTROLFP)
+
+    ctl->state = _controlfp(0, 0);
+    (void)_controlfp(_RC_CHOP, _MCW_RC);
+#endif
+}
+
+void RestoreFPUMode(const FPUCtl *ctl)
+{
+#ifdef HAVE_FENV_H
+    fesetenv(STATIC_CAST(fenv_t, ctl));
+#if defined(__GNUC__) && defined(HAVE_SSE)
+    if((CPUCapFlags&CPU_CAP_SSE))
+        __asm__ __volatile__("ldmxcsr %0" : : "m" (*&ctl->sse_state));
+#endif
+
+#elif defined(HAVE___CONTROL87_2)
+
+    int mode;
+    __control87_2(ctl->state, _MCW_RC, &mode, NULL);
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+        __control87_2(ctl->sse_state, _MCW_RC|_MCW_DN, NULL, &mode);
+#endif
+
+#elif defined(HAVE__CONTROLFP)
+
+    _controlfp(ctl->state, _MCW_RC);
+#endif
+}
+
+
+#ifdef _WIN32
+
+static WCHAR *FromUTF8(const char *str)
+{
+    WCHAR *out = NULL;
+    int len;
+
+    if((len=MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)) > 0)
+    {
+        out = calloc(sizeof(WCHAR), len);
+        MultiByteToWideChar(CP_UTF8, 0, str, -1, out, len);
+    }
+    return out;
+}
+
+
+void *LoadLib(const char *name)
+{
+    HANDLE hdl = NULL;
+    WCHAR *wname;
+
+    wname = FromUTF8(name);
+    if(!wname)
+        ERR("Failed to convert UTF-8 filename: \"%s\"\n", name);
+    else
+    {
+        hdl = LoadLibraryW(wname);
+        free(wname);
+    }
+    return hdl;
+}
+void CloseLib(void *handle)
+{ FreeLibrary((HANDLE)handle); }
+void *GetSymbol(void *handle, const char *name)
+{
+    void *ret;
+
+    ret = (void*)GetProcAddress((HANDLE)handle, name);
+    if(ret == NULL)
+        ERR("Failed to load %s\n", name);
+    return ret;
+}
+
+WCHAR *strdupW(const WCHAR *str)
+{
+    const WCHAR *n;
+    WCHAR *ret;
+    size_t len;
+
+    n = str;
+    while(*n) n++;
+    len = n - str;
+
+    ret = calloc(sizeof(WCHAR), len+1);
+    if(ret != NULL)
+        memcpy(ret, str, sizeof(WCHAR)*len);
+    return ret;
+}
+
+FILE *al_fopen(const char *fname, const char *mode)
+{
+    WCHAR *wname=NULL, *wmode=NULL;
+    FILE *file = NULL;
+
+    wname = FromUTF8(fname);
+    wmode = FromUTF8(mode);
+    if(!wname)
+        ERR("Failed to convert UTF-8 filename: \"%s\"\n", fname);
+    else if(!wmode)
+        ERR("Failed to convert UTF-8 mode: \"%s\"\n", mode);
+    else
+        file = _wfopen(wname, wmode);
+
+    free(wname);
+    free(wmode);
+
+    return file;
+}
+
+#else
+
+#ifdef HAVE_DLFCN_H
+
+void *LoadLib(const char *name)
+{
+    const char *err;
+    void *handle;
+
+    dlerror();
+    handle = dlopen(name, RTLD_NOW);
+    if((err=dlerror()) != NULL)
+        handle = NULL;
+    return handle;
+}
+void CloseLib(void *handle)
+{ dlclose(handle); }
+void *GetSymbol(void *handle, const char *name)
+{
+    const char *err;
+    void *sym;
+
+    dlerror();
+    sym = dlsym(handle, name);
+    if((err=dlerror()) != NULL)
+    {
+        WARN("Failed to load %s: %s\n", name, err);
+        sym = NULL;
+    }
+    return sym;
+}
+
+#endif
+#endif
+
+
+void al_print(const char *type, const char *func, const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    fprintf(LogFile, "AL lib: %s %s: ", type, func);
+    vfprintf(LogFile, fmt, ap);
+    va_end(ap);
+
+    fflush(LogFile);
+}
+
+#ifdef _WIN32
+static inline int is_slash(int c)
+{ return (c == '\\' || c == '/'); }
+
+FILE *OpenDataFile(const char *fname, const char *subdir)
+{
+    static const int ids[2] = { CSIDL_APPDATA, CSIDL_COMMON_APPDATA };
+    WCHAR *wname=NULL, *wsubdir=NULL;
+    FILE *f;
+    int i;
+
+    /* If the path is absolute, open it directly. */
+    if(fname[0] != '\0' && fname[1] == ':' && is_slash(fname[2]))
+    {
+        if((f=al_fopen(fname, "rb")) != NULL)
+        {
+            TRACE("Opened %s\n", fname);
+            return f;
+        }
+        WARN("Could not open %s\n", fname);
+        return NULL;
+    }
+
+    /* If it's relative, try the current directory first before the data directories. */
+    if((f=al_fopen(fname, "rb")) != NULL)
+    {
+        TRACE("Opened %s\n", fname);
+        return f;
+    }
+    WARN("Could not open %s\n", fname);
+
+    wname = FromUTF8(fname);
+    wsubdir = FromUTF8(subdir);
+    if(!wname)
+        ERR("Failed to convert UTF-8 filename: \"%s\"\n", fname);
+    else if(!wsubdir)
+        ERR("Failed to convert UTF-8 subdir: \"%s\"\n", subdir);
+    else for(i = 0;i < 2;i++)
+    {
+        WCHAR buffer[PATH_MAX];
+        size_t len;
+
+        if(SHGetSpecialFolderPathW(NULL, buffer, ids[i], FALSE) == FALSE)
+            continue;
+
+        len = lstrlenW(buffer);
+        if(len > 0 && is_slash(buffer[len-1]))
+            buffer[--len] = '\0';
+        _snwprintf(buffer+len, PATH_MAX-len, L"/%ls/%ls", wsubdir, wname);
+        len = lstrlenW(buffer);
+        while(len > 0)
+        {
+            --len;
+            if(buffer[len] == '/')
+                buffer[len] = '\\';
+        }
+
+        if((f=_wfopen(buffer, L"rb")) != NULL)
+        {
+            TRACE("Opened %ls\n", buffer);
+            return f;
+        }
+        WARN("Could not open %ls\n", buffer);
+    }
+    free(wname);
+    free(wsubdir);
+
+    return NULL;
+}
+#else
+FILE *OpenDataFile(const char *fname, const char *subdir)
+{
+    char buffer[PATH_MAX] = "";
+    const char *str, *next;
+    FILE *f;
+
+    if(fname[0] == '/')
+    {
+        if((f=al_fopen(fname, "rb")) != NULL)
+        {
+            TRACE("Opened %s\n", fname);
+            return f;
+        }
+        WARN("Could not open %s\n", fname);
+        return NULL;
+    }
+
+    if((f=al_fopen(fname, "rb")) != NULL)
+    {
+        TRACE("Opened %s\n", fname);
+        return f;
+    }
+    WARN("Could not open %s\n", fname);
+
+    if((str=getenv("XDG_DATA_HOME")) != NULL && str[0] != '\0')
+        snprintf(buffer, sizeof(buffer), "%s/%s/%s", str, subdir, fname);
+    else if((str=getenv("HOME")) != NULL && str[0] != '\0')
+        snprintf(buffer, sizeof(buffer), "%s/.local/share/%s/%s", str, subdir, fname);
+    if(buffer[0])
+    {
+        if((f=al_fopen(buffer, "rb")) != NULL)
+        {
+            TRACE("Opened %s\n", buffer);
+            return f;
+        }
+        WARN("Could not open %s\n", buffer);
+    }
+
+    if((str=getenv("XDG_DATA_DIRS")) == NULL || str[0] == '\0')
+        str = "/usr/local/share/:/usr/share/";
+
+    next = str;
+    while((str=next) != NULL && str[0] != '\0')
+    {
+        size_t len;
+        next = strchr(str, ':');
+
+        if(!next)
+            len = strlen(str);
+        else
+        {
+            len = next - str;
+            next++;
+        }
+
+        if(len > sizeof(buffer)-1)
+            len = sizeof(buffer)-1;
+        strncpy(buffer, str, len);
+        buffer[len] = '\0';
+        snprintf(buffer+len, sizeof(buffer)-len, "/%s/%s", subdir, fname);
+
+        if((f=al_fopen(buffer, "rb")) != NULL)
+        {
+            TRACE("Opened %s\n", buffer);
+            return f;
+        }
+        WARN("Could not open %s\n", buffer);
+    }
+
+    return NULL;
+}
+#endif
+
+
+void SetRTPriority(void)
+{
+    ALboolean failed = AL_FALSE;
+
+#ifdef _WIN32
+    if(RTPrioLevel > 0)
+        failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
+#elif defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
+    if(RTPrioLevel > 0)
+    {
+        struct sched_param param;
+        /* Use the minimum real-time priority possible for now (on Linux this
+         * should be 1 for SCHED_RR) */
+        param.sched_priority = sched_get_priority_min(SCHED_RR);
+        failed = !!pthread_setschedparam(pthread_self(), SCHED_RR, &param);
+    }
+#else
+    /* Real-time priority not available */
+    failed = (RTPrioLevel>0);
+#endif
+    if(failed)
+        ERR("Failed to set priority level for thread\n");
+}
+
+
+ALboolean vector_reserve(char *ptr, size_t base_size, size_t obj_size, ALsizei obj_count, ALboolean exact)
+{
+    vector_ *vecptr = (vector_*)ptr;
+    if(obj_count < 0)
+        return AL_FALSE;
+    if((*vecptr ? (*vecptr)->Capacity : 0) < obj_count)
+    {
+        ALsizei old_size = (*vecptr ? (*vecptr)->Size : 0);
+        void *temp;
+
+        /* Use the next power-of-2 size if we don't need to allocate the exact
+         * amount. This is preferred when regularly increasing the vector since
+         * it means fewer reallocations. Though it means it also wastes some
+         * memory. */
+        if(exact == AL_FALSE)
+        {
+            obj_count = NextPowerOf2((ALuint)obj_count);
+            if(obj_count < 0) return AL_FALSE;
+        }
+
+        /* Need to be explicit with the caller type's base size, because it
+         * could have extra padding before the start of the array (that is,
+         * sizeof(*vector_) may not equal base_size). */
+        temp = realloc(*vecptr, base_size + obj_size*obj_count);
+        if(temp == NULL) return AL_FALSE;
+
+        *vecptr = temp;
+        (*vecptr)->Capacity = obj_count;
+        (*vecptr)->Size = old_size;
+    }
+    return AL_TRUE;
+}
+
+ALboolean vector_resize(char *ptr, size_t base_size, size_t obj_size, ALsizei obj_count)
+{
+    vector_ *vecptr = (vector_*)ptr;
+    if(obj_count < 0)
+        return AL_FALSE;
+    if(*vecptr || obj_count > 0)
+    {
+        if(!vector_reserve((char*)vecptr, base_size, obj_size, obj_count, AL_TRUE))
+            return AL_FALSE;
+        (*vecptr)->Size = obj_count;
+    }
+    return AL_TRUE;
+}
+
+ALboolean vector_insert(char *ptr, size_t base_size, size_t obj_size, void *ins_pos, const void *datstart, const void *datend)
+{
+    vector_ *vecptr = (vector_*)ptr;
+    if(datstart != datend)
+    {
+        ptrdiff_t ins_elem = (*vecptr ? ((char*)ins_pos - ((char*)(*vecptr) + base_size)) :
+                                        ((char*)ins_pos - (char*)NULL)) /
+                             obj_size;
+        ptrdiff_t numins = ((const char*)datend - (const char*)datstart) / obj_size;
+
+        assert(numins > 0);
+        if(INT_MAX-VECTOR_SIZE(*vecptr) <= numins ||
+           !vector_reserve((char*)vecptr, base_size, obj_size, VECTOR_SIZE(*vecptr)+numins, AL_TRUE))
+            return AL_FALSE;
+
+        /* NOTE: ins_pos may have been invalidated if *vecptr moved. Use ins_elem instead. */
+        if(ins_elem < (*vecptr)->Size)
+        {
+            memmove((char*)(*vecptr) + base_size + ((ins_elem+numins)*obj_size),
+                    (char*)(*vecptr) + base_size + ((ins_elem       )*obj_size),
+                    ((*vecptr)->Size-ins_elem)*obj_size);
+        }
+        memcpy((char*)(*vecptr) + base_size + (ins_elem*obj_size),
+               datstart, numins*obj_size);
+        (*vecptr)->Size += (ALsizei)numins;
+    }
+    return AL_TRUE;
+}
+
+
+extern inline void al_string_deinit(al_string *str);
+extern inline ALsizei al_string_length(const_al_string str);
+extern inline ALboolean al_string_empty(const_al_string str);
+extern inline const al_string_char_type *al_string_get_cstr(const_al_string str);
+
+void al_string_clear(al_string *str)
+{
+    /* Reserve one more character than the total size of the string. This is to
+     * ensure we have space to add a null terminator in the string data so it
+     * can be used as a C-style string. */
+    VECTOR_RESERVE(*str, 1);
+    VECTOR_RESIZE(*str, 0);
+    *VECTOR_ITER_END(*str) = 0;
+}
+
+static inline int al_string_compare(const al_string_char_type *str1, ALsizei str1len,
+                                    const al_string_char_type *str2, ALsizei str2len)
+{
+    ALsizei complen = mini(str1len, str2len);
+    int ret = memcmp(str1, str2, complen);
+    if(ret == 0)
+    {
+        if(str1len > str2len) return  1;
+        if(str1len < str2len) return -1;
+    }
+    return ret;
+}
+int al_string_cmp(const_al_string str1, const_al_string str2)
+{
+    return al_string_compare(&VECTOR_FRONT(str1), al_string_length(str1),
+                             &VECTOR_FRONT(str2), al_string_length(str2));
+}
+int al_string_cmp_cstr(const_al_string str1, const al_string_char_type *str2)
+{
+    return al_string_compare(&VECTOR_FRONT(str1), al_string_length(str1),
+                             str2, (ALsizei)strlen(str2));
+}
+
+void al_string_copy(al_string *str, const_al_string from)
+{
+    ALsizei len = VECTOR_SIZE(from);
+    VECTOR_RESERVE(*str, len+1);
+    VECTOR_RESIZE(*str, 0);
+    VECTOR_INSERT(*str, VECTOR_ITER_END(*str), VECTOR_ITER_BEGIN(from), VECTOR_ITER_BEGIN(from)+len);
+    *VECTOR_ITER_END(*str) = 0;
+}
+
+void al_string_copy_cstr(al_string *str, const al_string_char_type *from)
+{
+    size_t len = strlen(from);
+    VECTOR_RESERVE(*str, len+1);
+    VECTOR_RESIZE(*str, 0);
+    VECTOR_INSERT(*str, VECTOR_ITER_END(*str), from, from+len);
+    *VECTOR_ITER_END(*str) = 0;
+}
+
+void al_string_append_char(al_string *str, const al_string_char_type c)
+{
+    VECTOR_RESERVE(*str, al_string_length(*str)+2);
+    VECTOR_PUSH_BACK(*str, c);
+    *VECTOR_ITER_END(*str) = 0;
+}
+
+void al_string_append_cstr(al_string *str, const al_string_char_type *from)
+{
+    size_t len = strlen(from);
+    if(len != 0)
+    {
+        VECTOR_RESERVE(*str, al_string_length(*str)+len+1);
+        VECTOR_INSERT(*str, VECTOR_ITER_END(*str), from, from+len);
+        *VECTOR_ITER_END(*str) = 0;
+    }
+}
+
+void al_string_append_range(al_string *str, const al_string_char_type *from, const al_string_char_type *to)
+{
+    if(to != from)
+    {
+        VECTOR_RESERVE(*str, al_string_length(*str)+(to-from)+1);
+        VECTOR_INSERT(*str, VECTOR_ITER_END(*str), from, to);
+        *VECTOR_ITER_END(*str) = 0;
+    }
+}
+
+#ifdef _WIN32
+void al_string_copy_wcstr(al_string *str, const wchar_t *from)
+{
+    int len;
+    if((len=WideCharToMultiByte(CP_UTF8, 0, from, -1, NULL, 0, NULL, NULL)) > 0)
+    {
+        VECTOR_RESERVE(*str, len);
+        VECTOR_RESIZE(*str, len-1);
+        WideCharToMultiByte(CP_UTF8, 0, from, -1, &VECTOR_FRONT(*str), len, NULL, NULL);
+        *VECTOR_ITER_END(*str) = 0;
+    }
+}
+#endif
@@ -0,0 +1,820 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2011 by Chris Robinson
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alSource.h"
+#include "alu.h"
+#include "hrtf.h"
+
+
+/* Current data set limits defined by the makehrtf utility. */
+#define MIN_IR_SIZE                  (8)
+#define MAX_IR_SIZE                  (128)
+#define MOD_IR_SIZE                  (8)
+
+#define MIN_EV_COUNT                 (5)
+#define MAX_EV_COUNT                 (128)
+
+#define MIN_AZ_COUNT                 (1)
+#define MAX_AZ_COUNT                 (128)
+
+struct Hrtf {
+    ALuint sampleRate;
+    ALuint irSize;
+    ALubyte evCount;
+
+    const ALubyte *azCount;
+    const ALushort *evOffset;
+    const ALshort *coeffs;
+    const ALubyte *delays;
+
+    struct Hrtf *next;
+};
+
+static const ALchar magicMarker00[8] = "MinPHR00";
+static const ALchar magicMarker01[8] = "MinPHR01";
+
+/* First value for pass-through coefficients (remaining are 0), used for omni-
+ * directional sounds. */
+static const ALfloat PassthruCoeff = 32767.0f * 0.707106781187f/*sqrt(0.5)*/;
+
+static struct Hrtf *LoadedHrtfs = NULL;
+
+/* Calculate the elevation indices given the polar elevation in radians.
+ * This will return two indices between 0 and (evcount - 1) and an
+ * interpolation factor between 0.0 and 1.0.
+ */
+static void CalcEvIndices(ALuint evcount, ALfloat ev, ALuint *evidx, ALfloat *evmu)
+{
+    ev = (F_PI_2 + ev) * (evcount-1) / F_PI;
+    evidx[0] = fastf2u(ev);
+    evidx[1] = minu(evidx[0] + 1, evcount-1);
+    *evmu = ev - evidx[0];
+}
+
+/* Calculate the azimuth indices given the polar azimuth in radians.  This
+ * will return two indices between 0 and (azcount - 1) and an interpolation
+ * factor between 0.0 and 1.0.
+ */
+static void CalcAzIndices(ALuint azcount, ALfloat az, ALuint *azidx, ALfloat *azmu)
+{
+    az = (F_2PI + az) * azcount / (F_2PI);
+    azidx[0] = fastf2u(az) % azcount;
+    azidx[1] = (azidx[0] + 1) % azcount;
+    *azmu = az - floorf(az);
+}
+
+/* Calculates the normalized HRTF transition factor (delta) from the changes
+ * in gain and listener to source angle between updates.  The result is a
+ * normalized delta factor that can be used to calculate moving HRIR stepping
+ * values.
+ */
+ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3])
+{
+    ALfloat gainChange, angleChange, change;
+
+    // Calculate the normalized dB gain change.
+    newGain = maxf(newGain, 0.0001f);
+    oldGain = maxf(oldGain, 0.0001f);
+    gainChange = fabsf(log10f(newGain / oldGain) / log10f(0.0001f));
+
+    // Calculate the angle change only when there is enough gain to notice it.
+    angleChange = 0.0f;
+    if(gainChange > 0.0001f || newGain > 0.0001f)
+    {
+        // No angle change when the directions are equal or degenerate (when
+        // both have zero length).
+        if(newdir[0] != olddir[0] || newdir[1] != olddir[1] || newdir[2] != olddir[2])
+        {
+            ALfloat dotp = olddir[0]*newdir[0] + olddir[1]*newdir[1] + olddir[2]*newdir[2];
+            angleChange = acosf(clampf(dotp, -1.0f, 1.0f)) / F_PI;
+        }
+    }
+
+    // Use the largest of the two changes for the delta factor, and apply a
+    // significance shaping function to it.
+    change = maxf(angleChange * 25.0f, gainChange) * 2.0f;
+    return minf(change, 1.0f);
+}
+
+/* Calculates static HRIR coefficients and delays for the given polar
+ * elevation and azimuth in radians.  Linear interpolation is used to
+ * increase the apparent resolution of the HRIR data set.  The coefficients
+ * are also normalized and attenuated by the specified gain.
+ */
+void GetLerpedHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat dirfact, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays)
+{
+    ALuint evidx[2], lidx[4], ridx[4];
+    ALfloat mu[3], blend[4];
+    ALuint i;
+
+    /* Claculate elevation indices and interpolation factor. */
+    CalcEvIndices(Hrtf->evCount, elevation, evidx, &mu[2]);
+
+    for(i = 0;i < 2;i++)
+    {
+        ALuint azcount = Hrtf->azCount[evidx[i]];
+        ALuint evoffset = Hrtf->evOffset[evidx[i]];
+        ALuint azidx[2];
+
+        /* Calculate azimuth indices and interpolation factor for this elevation. */
+        CalcAzIndices(azcount, azimuth, azidx, &mu[i]);
+
+        /* Calculate a set of linear HRIR indices for left and right channels. */
+        lidx[i*2 + 0] = evoffset + azidx[0];
+        lidx[i*2 + 1] = evoffset + azidx[1];
+        ridx[i*2 + 0] = evoffset + ((azcount-azidx[0]) % azcount);
+        ridx[i*2 + 1] = evoffset + ((azcount-azidx[1]) % azcount);
+    }
+
+    /* Calculate 4 blending weights for 2D bilinear interpolation. */
+    blend[0] = (1.0f-mu[0]) * (1.0f-mu[2]);
+    blend[1] = (     mu[0]) * (1.0f-mu[2]);
+    blend[2] = (1.0f-mu[1]) * (     mu[2]);
+    blend[3] = (     mu[1]) * (     mu[2]);
+
+    /* Calculate the HRIR delays using linear interpolation. */
+    delays[0] = fastf2u((Hrtf->delays[lidx[0]]*blend[0] + Hrtf->delays[lidx[1]]*blend[1] +
+                         Hrtf->delays[lidx[2]]*blend[2] + Hrtf->delays[lidx[3]]*blend[3]) *
+                        dirfact + 0.5f) << HRTFDELAY_BITS;
+    delays[1] = fastf2u((Hrtf->delays[ridx[0]]*blend[0] + Hrtf->delays[ridx[1]]*blend[1] +
+                         Hrtf->delays[ridx[2]]*blend[2] + Hrtf->delays[ridx[3]]*blend[3]) *
+                        dirfact + 0.5f) << HRTFDELAY_BITS;
+
+    /* Calculate the sample offsets for the HRIR indices. */
+    lidx[0] *= Hrtf->irSize;
+    lidx[1] *= Hrtf->irSize;
+    lidx[2] *= Hrtf->irSize;
+    lidx[3] *= Hrtf->irSize;
+    ridx[0] *= Hrtf->irSize;
+    ridx[1] *= Hrtf->irSize;
+    ridx[2] *= Hrtf->irSize;
+    ridx[3] *= Hrtf->irSize;
+
+    /* Calculate the normalized and attenuated HRIR coefficients using linear
+     * interpolation when there is enough gain to warrant it.  Zero the
+     * coefficients if gain is too low.
+     */
+    if(gain > 0.0001f)
+    {
+        ALfloat c;
+
+        gain *= 1.0f/32767.0f;
+
+        i = 0;
+        c = (Hrtf->coeffs[lidx[0]+i]*blend[0] + Hrtf->coeffs[lidx[1]+i]*blend[1] +
+             Hrtf->coeffs[lidx[2]+i]*blend[2] + Hrtf->coeffs[lidx[3]+i]*blend[3]);
+        coeffs[i][0] = lerp(PassthruCoeff, c, dirfact) * gain;
+        c = (Hrtf->coeffs[ridx[0]+i]*blend[0] + Hrtf->coeffs[ridx[1]+i]*blend[1] +
+             Hrtf->coeffs[ridx[2]+i]*blend[2] + Hrtf->coeffs[ridx[3]+i]*blend[3]);
+        coeffs[i][1] = lerp(PassthruCoeff, c, dirfact) * gain;
+
+        for(i = 1;i < Hrtf->irSize;i++)
+        {
+            c = (Hrtf->coeffs[lidx[0]+i]*blend[0] + Hrtf->coeffs[lidx[1]+i]*blend[1] +
+                 Hrtf->coeffs[lidx[2]+i]*blend[2] + Hrtf->coeffs[lidx[3]+i]*blend[3]);
+            coeffs[i][0] = lerp(0.0f, c, dirfact) * gain;
+            c = (Hrtf->coeffs[ridx[0]+i]*blend[0] + Hrtf->coeffs[ridx[1]+i]*blend[1] +
+                 Hrtf->coeffs[ridx[2]+i]*blend[2] + Hrtf->coeffs[ridx[3]+i]*blend[3]);
+            coeffs[i][1] = lerp(0.0f, c, dirfact) * gain;
+        }
+    }
+    else
+    {
+        for(i = 0;i < Hrtf->irSize;i++)
+        {
+            coeffs[i][0] = 0.0f;
+            coeffs[i][1] = 0.0f;
+        }
+    }
+}
+
+/* Calculates the moving HRIR target coefficients, target delays, and
+ * stepping values for the given polar elevation and azimuth in radians.
+ * Linear interpolation is used to increase the apparent resolution of the
+ * HRIR data set.  The coefficients are also normalized and attenuated by the
+ * specified gain.  Stepping resolution and count is determined using the
+ * given delta factor between 0.0 and 1.0.
+ */
+ALuint GetMovingHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat dirfact, ALfloat gain, ALfloat delta, ALint counter, ALfloat (*coeffs)[2], ALuint *delays, ALfloat (*coeffStep)[2], ALint *delayStep)
+{
+    ALuint evidx[2], lidx[4], ridx[4];
+    ALfloat mu[3], blend[4];
+    ALfloat left, right;
+    ALfloat step;
+    ALuint i;
+
+    /* Claculate elevation indices and interpolation factor. */
+    CalcEvIndices(Hrtf->evCount, elevation, evidx, &mu[2]);
+
+    for(i = 0;i < 2;i++)
+    {
+        ALuint azcount = Hrtf->azCount[evidx[i]];
+        ALuint evoffset = Hrtf->evOffset[evidx[i]];
+        ALuint azidx[2];
+
+        /* Calculate azimuth indices and interpolation factor for this elevation. */
+        CalcAzIndices(azcount, azimuth, azidx, &mu[i]);
+
+        /* Calculate a set of linear HRIR indices for left and right channels. */
+        lidx[i*2 + 0] = evoffset + azidx[0];
+        lidx[i*2 + 1] = evoffset + azidx[1];
+        ridx[i*2 + 0] = evoffset + ((azcount-azidx[0]) % azcount);
+        ridx[i*2 + 1] = evoffset + ((azcount-azidx[1]) % azcount);
+    }
+
+    // Calculate the stepping parameters.
+    delta = maxf(floorf(delta*(Hrtf->sampleRate*0.015f) + 0.5f), 1.0f);
+    step = 1.0f / delta;
+
+    /* Calculate 4 blending weights for 2D bilinear interpolation. */
+    blend[0] = (1.0f-mu[0]) * (1.0f-mu[2]);
+    blend[1] = (     mu[0]) * (1.0f-mu[2]);
+    blend[2] = (1.0f-mu[1]) * (     mu[2]);
+    blend[3] = (     mu[1]) * (     mu[2]);
+
+    /* Calculate the HRIR delays using linear interpolation.  Then calculate
+     * the delay stepping values using the target and previous running
+     * delays.
+     */
+    left = (ALfloat)(delays[0] - (delayStep[0] * counter));
+    right = (ALfloat)(delays[1] - (delayStep[1] * counter));
+
+    delays[0] = fastf2u((Hrtf->delays[lidx[0]]*blend[0] + Hrtf->delays[lidx[1]]*blend[1] +
+                         Hrtf->delays[lidx[2]]*blend[2] + Hrtf->delays[lidx[3]]*blend[3]) *
+                        dirfact + 0.5f) << HRTFDELAY_BITS;
+    delays[1] = fastf2u((Hrtf->delays[ridx[0]]*blend[0] + Hrtf->delays[ridx[1]]*blend[1] +
+                         Hrtf->delays[ridx[2]]*blend[2] + Hrtf->delays[ridx[3]]*blend[3]) *
+                        dirfact + 0.5f) << HRTFDELAY_BITS;
+
+    delayStep[0] = fastf2i(step * (delays[0] - left));
+    delayStep[1] = fastf2i(step * (delays[1] - right));
+
+    /* Calculate the sample offsets for the HRIR indices. */
+    lidx[0] *= Hrtf->irSize;
+    lidx[1] *= Hrtf->irSize;
+    lidx[2] *= Hrtf->irSize;
+    lidx[3] *= Hrtf->irSize;
+    ridx[0] *= Hrtf->irSize;
+    ridx[1] *= Hrtf->irSize;
+    ridx[2] *= Hrtf->irSize;
+    ridx[3] *= Hrtf->irSize;
+
+    /* Calculate the normalized and attenuated target HRIR coefficients using
+     * linear interpolation when there is enough gain to warrant it.  Zero
+     * the target coefficients if gain is too low.  Then calculate the
+     * coefficient stepping values using the target and previous running
+     * coefficients.
+     */
+    if(gain > 0.0001f)
+    {
+        ALfloat c;
+
+        gain *= 1.0f/32767.0f;
+
+        i = 0;
+        left = coeffs[i][0] - (coeffStep[i][0] * counter);
+        right = coeffs[i][1] - (coeffStep[i][1] * counter);
+
+        c = (Hrtf->coeffs[lidx[0]+i]*blend[0] + Hrtf->coeffs[lidx[1]+i]*blend[1] +
+             Hrtf->coeffs[lidx[2]+i]*blend[2] + Hrtf->coeffs[lidx[3]+i]*blend[3]);
+        coeffs[i][0] = lerp(PassthruCoeff, c, dirfact) * gain;
+        c = (Hrtf->coeffs[ridx[0]+i]*blend[0] + Hrtf->coeffs[ridx[1]+i]*blend[1] +
+             Hrtf->coeffs[ridx[2]+i]*blend[2] + Hrtf->coeffs[ridx[3]+i]*blend[3]);
+        coeffs[i][1] = lerp(PassthruCoeff, c, dirfact) * gain;
+
+        coeffStep[i][0] = step * (coeffs[i][0] - left);
+        coeffStep[i][1] = step * (coeffs[i][1] - right);
+
+        for(i = 1;i < Hrtf->irSize;i++)
+        {
+            left = coeffs[i][0] - (coeffStep[i][0] * counter);
+            right = coeffs[i][1] - (coeffStep[i][1] * counter);
+
+            c = (Hrtf->coeffs[lidx[0]+i]*blend[0] + Hrtf->coeffs[lidx[1]+i]*blend[1] +
+                 Hrtf->coeffs[lidx[2]+i]*blend[2] + Hrtf->coeffs[lidx[3]+i]*blend[3]);
+            coeffs[i][0] = lerp(0.0f, c, dirfact) * gain;
+            c = (Hrtf->coeffs[ridx[0]+i]*blend[0] + Hrtf->coeffs[ridx[1]+i]*blend[1] +
+                 Hrtf->coeffs[ridx[2]+i]*blend[2] + Hrtf->coeffs[ridx[3]+i]*blend[3]);
+            coeffs[i][1] = lerp(0.0f, c, dirfact) * gain;
+
+            coeffStep[i][0] = step * (coeffs[i][0] - left);
+            coeffStep[i][1] = step * (coeffs[i][1] - right);
+        }
+    }
+    else
+    {
+        for(i = 0;i < Hrtf->irSize;i++)
+        {
+            left = coeffs[i][0] - (coeffStep[i][0] * counter);
+            right = coeffs[i][1] - (coeffStep[i][1] * counter);
+
+            coeffs[i][0] = 0.0f;
+            coeffs[i][1] = 0.0f;
+
+            coeffStep[i][0] = step * -left;
+            coeffStep[i][1] = step * -right;
+        }
+    }
+
+    /* The stepping count is the number of samples necessary for the HRIR to
+     * complete its transition.  The mixer will only apply stepping for this
+     * many samples.
+     */
+    return fastf2u(delta);
+}
+
+
+static struct Hrtf *LoadHrtf00(FILE *f, ALuint deviceRate)
+{
+    const ALubyte maxDelay = SRC_HISTORY_LENGTH-1;
+    struct Hrtf *Hrtf = NULL;
+    ALboolean failed = AL_FALSE;
+    ALuint rate = 0, irCount = 0;
+    ALushort irSize = 0;
+    ALubyte evCount = 0;
+    ALubyte *azCount = NULL;
+    ALushort *evOffset = NULL;
+    ALshort *coeffs = NULL;
+    ALubyte *delays = NULL;
+    ALuint i, j;
+
+    rate  = fgetc(f);
+    rate |= fgetc(f)<<8;
+    rate |= fgetc(f)<<16;
+    rate |= fgetc(f)<<24;
+
+    irCount  = fgetc(f);
+    irCount |= fgetc(f)<<8;
+
+    irSize  = fgetc(f);
+    irSize |= fgetc(f)<<8;
+
+    evCount = fgetc(f);
+
+    if(rate != deviceRate)
+    {
+        ERR("HRIR rate does not match device rate: rate=%d (%d)\n",
+            rate, deviceRate);
+        failed = AL_TRUE;
+    }
+    if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
+    {
+        ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
+            irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
+        failed = AL_TRUE;
+    }
+    if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
+    {
+        ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
+            evCount, MIN_EV_COUNT, MAX_EV_COUNT);
+        failed = AL_TRUE;
+    }
+
+    if(failed)
+        return NULL;
+
+    azCount = malloc(sizeof(azCount[0])*evCount);
+    evOffset = malloc(sizeof(evOffset[0])*evCount);
+    if(azCount == NULL || evOffset == NULL)
+    {
+        ERR("Out of memory.\n");
+        failed = AL_TRUE;
+    }
+
+    if(!failed)
+    {
+        evOffset[0]  = fgetc(f);
+        evOffset[0] |= fgetc(f)<<8;
+        for(i = 1;i < evCount;i++)
+        {
+            evOffset[i]  = fgetc(f);
+            evOffset[i] |= fgetc(f)<<8;
+            if(evOffset[i] <= evOffset[i-1])
+            {
+                ERR("Invalid evOffset: evOffset[%d]=%d (last=%d)\n",
+                    i, evOffset[i], evOffset[i-1]);
+                failed = AL_TRUE;
+            }
+
+            azCount[i-1] = evOffset[i] - evOffset[i-1];
+            if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
+            {
+                ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
+                    i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
+                failed = AL_TRUE;
+            }
+        }
+        if(irCount <= evOffset[i-1])
+        {
+            ERR("Invalid evOffset: evOffset[%d]=%d (irCount=%d)\n",
+                i-1, evOffset[i-1], irCount);
+            failed = AL_TRUE;
+        }
+
+        azCount[i-1] = irCount - evOffset[i-1];
+        if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
+        {
+            ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
+                i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
+            failed = AL_TRUE;
+        }
+    }
+
+    if(!failed)
+    {
+        coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
+        delays = malloc(sizeof(delays[0])*irCount);
+        if(coeffs == NULL || delays == NULL)
+        {
+            ERR("Out of memory.\n");
+            failed = AL_TRUE;
+        }
+    }
+
+    if(!failed)
+    {
+        for(i = 0;i < irCount*irSize;i+=irSize)
+        {
+            for(j = 0;j < irSize;j++)
+            {
+                ALshort coeff;
+                coeff  = fgetc(f);
+                coeff |= fgetc(f)<<8;
+                coeffs[i+j] = coeff;
+            }
+        }
+        for(i = 0;i < irCount;i++)
+        {
+            delays[i] = fgetc(f);
+            if(delays[i] > maxDelay)
+            {
+                ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i], maxDelay);
+                failed = AL_TRUE;
+            }
+        }
+
+        if(feof(f))
+        {
+            ERR("Premature end of data\n");
+            failed = AL_TRUE;
+        }
+    }
+
+    if(!failed)
+    {
+        Hrtf = malloc(sizeof(struct Hrtf));
+        if(Hrtf == NULL)
+        {
+            ERR("Out of memory.\n");
+            failed = AL_TRUE;
+        }
+    }
+
+    if(!failed)
+    {
+        Hrtf->sampleRate = rate;
+        Hrtf->irSize = irSize;
+        Hrtf->evCount = evCount;
+        Hrtf->azCount = azCount;
+        Hrtf->evOffset = evOffset;
+        Hrtf->coeffs = coeffs;
+        Hrtf->delays = delays;
+        Hrtf->next = NULL;
+        return Hrtf;
+    }
+
+    free(azCount);
+    free(evOffset);
+    free(coeffs);
+    free(delays);
+    return NULL;
+}
+
+
+static struct Hrtf *LoadHrtf01(FILE *f, ALuint deviceRate)
+{
+    const ALubyte maxDelay = SRC_HISTORY_LENGTH-1;
+    struct Hrtf *Hrtf = NULL;
+    ALboolean failed = AL_FALSE;
+    ALuint rate = 0, irCount = 0;
+    ALubyte irSize = 0, evCount = 0;
+    ALubyte *azCount = NULL;
+    ALushort *evOffset = NULL;
+    ALshort *coeffs = NULL;
+    ALubyte *delays = NULL;
+    ALuint i, j;
+
+    rate  = fgetc(f);
+    rate |= fgetc(f)<<8;
+    rate |= fgetc(f)<<16;
+    rate |= fgetc(f)<<24;
+
+    irSize = fgetc(f);
+
+    evCount = fgetc(f);
+
+    if(rate != deviceRate)
+    {
+        ERR("HRIR rate does not match device rate: rate=%d (%d)\n",
+                rate, deviceRate);
+        failed = AL_TRUE;
+    }
+    if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
+    {
+        ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
+            irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
+        failed = AL_TRUE;
+    }
+    if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
+    {
+        ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
+            evCount, MIN_EV_COUNT, MAX_EV_COUNT);
+        failed = AL_TRUE;
+    }
+
+    if(failed)
+        return NULL;
+
+    azCount = malloc(sizeof(azCount[0])*evCount);
+    evOffset = malloc(sizeof(evOffset[0])*evCount);
+    if(azCount == NULL || evOffset == NULL)
+    {
+        ERR("Out of memory.\n");
+        failed = AL_TRUE;
+    }
+
+    if(!failed)
+    {
+        for(i = 0;i < evCount;i++)
+        {
+            azCount[i] = fgetc(f);
+            if(azCount[i] < MIN_AZ_COUNT || azCount[i] > MAX_AZ_COUNT)
+            {
+                ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
+                    i, azCount[i], MIN_AZ_COUNT, MAX_AZ_COUNT);
+                failed = AL_TRUE;
+            }
+        }
+    }
+
+    if(!failed)
+    {
+        evOffset[0] = 0;
+        irCount = azCount[0];
+        for(i = 1;i < evCount;i++)
+        {
+            evOffset[i] = evOffset[i-1] + azCount[i-1];
+            irCount += azCount[i];
+        }
+
+        coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
+        delays = malloc(sizeof(delays[0])*irCount);
+        if(coeffs == NULL || delays == NULL)
+        {
+            ERR("Out of memory.\n");
+            failed = AL_TRUE;
+        }
+    }
+
+    if(!failed)
+    {
+        for(i = 0;i < irCount*irSize;i+=irSize)
+        {
+            for(j = 0;j < irSize;j++)
+            {
+                ALshort coeff;
+                coeff  = fgetc(f);
+                coeff |= fgetc(f)<<8;
+                coeffs[i+j] = coeff;
+            }
+        }
+        for(i = 0;i < irCount;i++)
+        {
+            delays[i] = fgetc(f);
+            if(delays[i] > maxDelay)
+            {
+                ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i], maxDelay);
+                failed = AL_TRUE;
+            }
+        }
+
+        if(feof(f))
+        {
+            ERR("Premature end of data\n");
+            failed = AL_TRUE;
+        }
+    }
+
+    if(!failed)
+    {
+        Hrtf = malloc(sizeof(struct Hrtf));
+        if(Hrtf == NULL)
+        {
+            ERR("Out of memory.\n");
+            failed = AL_TRUE;
+        }
+    }
+
+    if(!failed)
+    {
+        Hrtf->sampleRate = rate;
+        Hrtf->irSize = irSize;
+        Hrtf->evCount = evCount;
+        Hrtf->azCount = azCount;
+        Hrtf->evOffset = evOffset;
+        Hrtf->coeffs = coeffs;
+        Hrtf->delays = delays;
+        Hrtf->next = NULL;
+        return Hrtf;
+    }
+
+    free(azCount);
+    free(evOffset);
+    free(coeffs);
+    free(delays);
+    return NULL;
+}
+
+
+static struct Hrtf *LoadHrtf(ALuint deviceRate)
+{
+    const char *fnamelist = "default-%r.mhr";
+
+    ConfigValueStr(NULL, "hrtf_tables", &fnamelist);
+    while(*fnamelist != '\0')
+    {
+        struct Hrtf *Hrtf = NULL;
+        char fname[PATH_MAX];
+        const char *next;
+        ALchar magic[8];
+        ALuint i;
+        FILE *f;
+
+        i = 0;
+        while(isspace(*fnamelist) || *fnamelist == ',')
+            fnamelist++;
+        next = fnamelist;
+        while(*(fnamelist=next) != '\0' && *fnamelist != ',')
+        {
+            next = strpbrk(fnamelist, "%,");
+            while(fnamelist != next && *fnamelist && i < sizeof(fname))
+                fname[i++] = *(fnamelist++);
+
+            if(!next || *next == ',')
+                break;
+
+            /* *next == '%' */
+            next++;
+            if(*next == 'r')
+            {
+                int wrote = snprintf(&fname[i], sizeof(fname)-i, "%u", deviceRate);
+                i += minu(wrote, sizeof(fname)-i);
+                next++;
+            }
+            else if(*next == '%')
+            {
+                if(i < sizeof(fname))
+                    fname[i++] = '%';
+                next++;
+            }
+            else
+                ERR("Invalid marker '%%%c'\n", *next);
+        }
+        i = minu(i, sizeof(fname)-1);
+        fname[i] = '\0';
+        while(i > 0 && isspace(fname[i-1]))
+            i--;
+        fname[i] = '\0';
+
+        if(fname[0] == '\0')
+            continue;
+
+        TRACE("Loading %s...\n", fname);
+        f = OpenDataFile(fname, "openal/hrtf");
+        if(f == NULL)
+        {
+            ERR("Could not open %s\n", fname);
+            continue;
+        }
+
+        if(fread(magic, 1, sizeof(magic), f) != sizeof(magic))
+            ERR("Failed to read header from %s\n", fname);
+        else
+        {
+            if(memcmp(magic, magicMarker00, sizeof(magicMarker00)) == 0)
+            {
+                TRACE("Detected data set format v0\n");
+                Hrtf = LoadHrtf00(f, deviceRate);
+            }
+            else if(memcmp(magic, magicMarker01, sizeof(magicMarker01)) == 0)
+            {
+                TRACE("Detected data set format v1\n");
+                Hrtf = LoadHrtf01(f, deviceRate);
+            }
+            else
+                ERR("Invalid header in %s: \"%.8s\"\n", fname, magic);
+        }
+
+        fclose(f);
+        f = NULL;
+
+        if(Hrtf)
+        {
+            Hrtf->next = LoadedHrtfs;
+            LoadedHrtfs = Hrtf;
+            TRACE("Loaded HRTF support for format: %s %uhz\n",
+                  DevFmtChannelsString(DevFmtStereo), Hrtf->sampleRate);
+            return Hrtf;
+        }
+
+        ERR("Failed to load %s\n", fname);
+    }
+
+    return NULL;
+}
+
+const struct Hrtf *GetHrtf(enum DevFmtChannels chans, ALCuint srate)
+{
+    if(chans == DevFmtStereo)
+    {
+        struct Hrtf *Hrtf = LoadedHrtfs;
+        while(Hrtf != NULL)
+        {
+            if(srate == Hrtf->sampleRate)
+                return Hrtf;
+            Hrtf = Hrtf->next;
+        }
+
+        Hrtf = LoadHrtf(srate);
+        if(Hrtf != NULL)
+            return Hrtf;
+    }
+    ERR("Incompatible format: %s %uhz\n", DevFmtChannelsString(chans), srate);
+    return NULL;
+}
+
+ALCboolean FindHrtfFormat(enum DevFmtChannels *chans, ALCuint *srate)
+{
+    const struct Hrtf *hrtf = LoadedHrtfs;
+    while(hrtf != NULL)
+    {
+        if(*srate == hrtf->sampleRate)
+            break;
+        hrtf = hrtf->next;
+    }
+
+    if(hrtf == NULL)
+    {
+        hrtf = LoadHrtf(*srate);
+        if(hrtf == NULL) return ALC_FALSE;
+    }
+
+    *chans = DevFmtStereo;
+    *srate = hrtf->sampleRate;
+    return ALC_TRUE;
+}
+
+void FreeHrtfs(void)
+{
+    struct Hrtf *Hrtf = NULL;
+
+    while((Hrtf=LoadedHrtfs) != NULL)
+    {
+        LoadedHrtfs = Hrtf->next;
+        free((void*)Hrtf->azCount);
+        free((void*)Hrtf->evOffset);
+        free((void*)Hrtf->coeffs);
+        free((void*)Hrtf->delays);
+        free(Hrtf);
+    }
+}
+
+ALuint GetHrtfIrSize (const struct Hrtf *Hrtf)
+{
+    return Hrtf->irSize;
+}
@@ -0,0 +1,28 @@
+#ifndef ALC_HRTF_H
+#define ALC_HRTF_H
+
+#include "AL/al.h"
+#include "AL/alc.h"
+
+enum DevFmtChannels;
+
+struct Hrtf;
+
+#define HRIR_BITS        (7)
+#define HRIR_LENGTH      (1<<HRIR_BITS)
+#define HRIR_MASK        (HRIR_LENGTH-1)
+#define HRTFDELAY_BITS    (20)
+#define HRTFDELAY_FRACONE (1<<HRTFDELAY_BITS)
+#define HRTFDELAY_MASK    (HRTFDELAY_FRACONE-1)
+
+const struct Hrtf *GetHrtf(enum DevFmtChannels chans, ALCuint srate);
+ALCboolean FindHrtfFormat(enum DevFmtChannels *chans, ALCuint *srate);
+
+void FreeHrtfs(void);
+
+ALuint GetHrtfIrSize(const struct Hrtf *Hrtf);
+ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3]);
+void GetLerpedHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat dirfact, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays);
+ALuint GetMovingHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat dirfact, ALfloat gain, ALfloat delta, ALint counter, ALfloat (*coeffs)[2], ALuint *delays, ALfloat (*coeffStep)[2], ALint *delayStep);
+
+#endif /* ALC_HRTF_H */
@@ -0,0 +1,244 @@
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "midi/base.h"
+
+#include "alMidi.h"
+#include "alMain.h"
+#include "alError.h"
+#include "alThunk.h"
+#include "evtqueue.h"
+#include "rwlock.h"
+#include "alu.h"
+
+
+extern inline ALboolean IsValidCtrlInput(int cc);
+
+extern inline size_t Reader_read(Reader *self, void *buf, size_t len);
+
+
+/* MIDI events */
+#define SYSEX_EVENT  (0xF0)
+
+
+void InitEvtQueue(EvtQueue *queue)
+{
+    queue->events = NULL;
+    queue->maxsize = 0;
+    queue->size = 0;
+    queue->pos = 0;
+}
+
+void ResetEvtQueue(EvtQueue *queue)
+{
+    ALsizei i;
+    for(i = 0;i < queue->size;i++)
+    {
+        if(queue->events[i].event == SYSEX_EVENT)
+        {
+            free(queue->events[i].param.sysex.data);
+            queue->events[i].param.sysex.data = NULL;
+        }
+    }
+
+    free(queue->events);
+    queue->events = NULL;
+    queue->maxsize = 0;
+    queue->size = 0;
+    queue->pos = 0;
+}
+
+ALenum InsertEvtQueue(EvtQueue *queue, const MidiEvent *evt)
+{
+    ALsizei pos;
+
+    if(queue->maxsize == queue->size)
+    {
+        if(queue->pos > 0)
+        {
+            /* Queue has some stale entries, remove them to make space for more
+             * events. */
+            for(pos = 0;pos < queue->pos;pos++)
+            {
+                if(queue->events[pos].event == SYSEX_EVENT)
+                {
+                    free(queue->events[pos].param.sysex.data);
+                    queue->events[pos].param.sysex.data = NULL;
+                }
+            }
+            memmove(&queue->events[0], &queue->events[queue->pos],
+                    (queue->size-queue->pos)*sizeof(queue->events[0]));
+            queue->size -= queue->pos;
+            queue->pos = 0;
+        }
+        else
+        {
+            /* Queue is full, double the allocated space. */
+            void *temp = NULL;
+            ALsizei newsize;
+
+            newsize = (queue->maxsize ? (queue->maxsize<<1) : 16);
+            if(newsize > queue->maxsize)
+                temp = realloc(queue->events, newsize * sizeof(queue->events[0]));
+            if(!temp)
+                return AL_OUT_OF_MEMORY;
+
+            queue->events = temp;
+            queue->maxsize = newsize;
+        }
+    }
+
+    pos = queue->pos;
+    if(queue->size > 0)
+    {
+        ALsizei high = queue->size - 1;
+        while(pos < high)
+        {
+            ALsizei mid = pos + (high-pos)/2;
+            if(queue->events[mid].time < evt->time)
+                pos = mid + 1;
+            else
+                high = mid;
+        }
+        while(pos < queue->size && queue->events[pos].time <= evt->time)
+            pos++;
+
+        if(pos < queue->size)
+            memmove(&queue->events[pos+1], &queue->events[pos],
+                    (queue->size-pos)*sizeof(queue->events[0]));
+    }
+
+    queue->events[pos] = *evt;
+    queue->size++;
+
+    return AL_NO_ERROR;
+}
+
+
+void MidiSynth_Construct(MidiSynth *self, ALCdevice *device)
+{
+    InitEvtQueue(&self->EventQueue);
+
+    RWLockInit(&self->Lock);
+
+    self->Soundfonts = NULL;
+    self->NumSoundfonts = 0;
+
+    self->Gain = 1.0f;
+    self->State = AL_INITIAL;
+
+    self->ClockBase = 0;
+    self->SamplesDone = 0;
+    self->SampleRate = device->Frequency;
+}
+
+void MidiSynth_Destruct(MidiSynth *self)
+{
+    ALsizei i;
+
+    for(i = 0;i < self->NumSoundfonts;i++)
+        DecrementRef(&self->Soundfonts[i]->ref);
+    free(self->Soundfonts);
+    self->Soundfonts = NULL;
+    self->NumSoundfonts = 0;
+
+    ResetEvtQueue(&self->EventQueue);
+}
+
+
+ALenum MidiSynth_selectSoundfonts(MidiSynth *self, ALCcontext *context, ALsizei count, const ALuint *ids)
+{
+    ALCdevice *device = context->Device;
+    ALsoundfont **sfonts;
+    ALsizei i;
+
+    if(self->State != AL_INITIAL && self->State != AL_STOPPED)
+        return AL_INVALID_OPERATION;
+
+    sfonts = calloc(1, count * sizeof(sfonts[0]));
+    if(!sfonts) return AL_OUT_OF_MEMORY;
+
+    for(i = 0;i < count;i++)
+    {
+        if(ids[i] == 0)
+            sfonts[i] = ALsoundfont_getDefSoundfont(context);
+        else if(!(sfonts[i]=LookupSfont(device, ids[i])))
+        {
+            free(sfonts);
+            return AL_INVALID_VALUE;
+        }
+    }
+
+    for(i = 0;i < count;i++)
+        IncrementRef(&sfonts[i]->ref);
+    sfonts = ExchangePtr((XchgPtr*)&self->Soundfonts, sfonts);
+    count = ExchangeInt(&self->NumSoundfonts, count);
+
+    for(i = 0;i < count;i++)
+        DecrementRef(&sfonts[i]->ref);
+    free(sfonts);
+
+    return AL_NO_ERROR;
+}
+
+extern inline void MidiSynth_setGain(MidiSynth *self, ALfloat gain);
+extern inline ALfloat MidiSynth_getGain(const MidiSynth *self);
+extern inline void MidiSynth_setState(MidiSynth *self, ALenum state);
+extern inline ALenum MidiSynth_getState(const MidiSynth *self);
+
+void MidiSynth_stop(MidiSynth *self)
+{
+    ResetEvtQueue(&self->EventQueue);
+
+    self->ClockBase = 0;
+    self->SamplesDone = 0;
+}
+
+extern inline void MidiSynth_reset(MidiSynth *self);
+extern inline ALuint64 MidiSynth_getTime(const MidiSynth *self);
+extern inline ALuint64 MidiSynth_getNextEvtTime(const MidiSynth *self);
+
+void MidiSynth_setSampleRate(MidiSynth *self, ALuint srate)
+{
+    if(self->SampleRate != srate)
+    {
+        self->ClockBase += self->SamplesDone * MIDI_CLOCK_RES / self->SampleRate;
+        self->SamplesDone = 0;
+        self->SampleRate = srate;
+    }
+}
+
+extern inline void MidiSynth_update(MidiSynth *self, ALCdevice *device);
+
+ALenum MidiSynth_insertEvent(MidiSynth *self, ALuint64 time, ALuint event, ALsizei param1, ALsizei param2)
+{
+    MidiEvent entry;
+    entry.time = time;
+    entry.event = event;
+    entry.param.val[0] = param1;
+    entry.param.val[1] = param2;
+    return InsertEvtQueue(&self->EventQueue, &entry);
+}
+
+ALenum MidiSynth_insertSysExEvent(MidiSynth *self, ALuint64 time, const ALbyte *data, ALsizei size)
+{
+    MidiEvent entry;
+    ALenum err;
+
+    entry.time = time;
+    entry.event = SYSEX_EVENT;
+    entry.param.sysex.size = size;
+    entry.param.sysex.data = malloc(size);
+    if(!entry.param.sysex.data)
+        return AL_OUT_OF_MEMORY;
+    memcpy(entry.param.sysex.data, data, size);
+
+    err = InsertEvtQueue(&self->EventQueue, &entry);
+    if(err != AL_NO_ERROR)
+        free(entry.param.sysex.data);
+    return err;
+}
@@ -0,0 +1,133 @@
+#ifndef AL_MIDI_BASE_H
+#define AL_MIDI_BASE_H
+
+#include "alMain.h"
+#include "atomic.h"
+#include "evtqueue.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ALsoundfont;
+
+typedef size_t (*ReaderCb)(void *ptr, size_t size, void *stream);
+typedef struct Reader {
+    ReaderCb cb;
+    void *ptr;
+    int error;
+} Reader;
+inline size_t Reader_read(Reader *self, void *buf, size_t len)
+{
+    size_t got = (!self->error) ? self->cb(buf, len, self->ptr) : 0;
+    if(got < len) self->error = 1;
+    return got;
+}
+#define READERR(x_) ((x_)->error)
+
+ALboolean loadSf2(Reader *stream, struct ALsoundfont *sfont, ALCcontext *context);
+
+
+#define MIDI_CLOCK_RES  U64(1000000000)
+
+
+struct MidiSynthVtable;
+
+typedef struct MidiSynth {
+    EvtQueue EventQueue;
+
+    ALuint64 ClockBase;
+    ALuint SamplesDone;
+    ALuint SampleRate;
+
+    /* NOTE: This rwlock is for the state and soundfont. The EventQueue and
+     * related must instead use the device lock as they're used in the mixer
+     * thread.
+     */
+    RWLock Lock;
+
+    struct ALsoundfont **Soundfonts;
+    ALsizei NumSoundfonts;
+
+    volatile ALfloat Gain;
+    volatile ALenum State;
+
+    const struct MidiSynthVtable *vtbl;
+} MidiSynth;
+
+void MidiSynth_Construct(MidiSynth *self, ALCdevice *device);
+void MidiSynth_Destruct(MidiSynth *self);
+ALenum MidiSynth_selectSoundfonts(MidiSynth *self, ALCcontext *context, ALsizei count, const ALuint *ids);
+inline void MidiSynth_setGain(MidiSynth *self, ALfloat gain) { self->Gain = gain; }
+inline ALfloat MidiSynth_getGain(const MidiSynth *self) { return self->Gain; }
+inline void MidiSynth_setState(MidiSynth *self, ALenum state) { ExchangeInt(&self->State, state); }
+inline ALenum MidiSynth_getState(const MidiSynth *self) { return self->State; }
+void MidiSynth_stop(MidiSynth *self);
+inline void MidiSynth_reset(MidiSynth *self) { MidiSynth_stop(self); }
+inline ALuint64 MidiSynth_getTime(const MidiSynth *self)
+{ return self->ClockBase + (self->SamplesDone*MIDI_CLOCK_RES/self->SampleRate); }
+inline ALuint64 MidiSynth_getNextEvtTime(const MidiSynth *self)
+{
+    if(self->EventQueue.pos == self->EventQueue.size)
+        return UINT64_MAX;
+    return self->EventQueue.events[self->EventQueue.pos].time;
+}
+void MidiSynth_setSampleRate(MidiSynth *self, ALuint srate);
+inline void MidiSynth_update(MidiSynth *self, ALCdevice *device)
+{ MidiSynth_setSampleRate(self, device->Frequency); }
+ALenum MidiSynth_insertEvent(MidiSynth *self, ALuint64 time, ALuint event, ALsizei param1, ALsizei param2);
+ALenum MidiSynth_insertSysExEvent(MidiSynth *self, ALuint64 time, const ALbyte *data, ALsizei size);
+
+
+struct MidiSynthVtable {
+    void (*const Destruct)(MidiSynth *self);
+
+    ALenum (*const selectSoundfonts)(MidiSynth *self, ALCcontext *context, ALsizei count, const ALuint *ids);
+
+    void (*const setGain)(MidiSynth *self, ALfloat gain);
+
+    void (*const stop)(MidiSynth *self);
+    void (*const reset)(MidiSynth *self);
+
+    void (*const update)(MidiSynth *self, ALCdevice *device);
+    void (*const process)(MidiSynth *self, ALuint samples, ALfloat (*restrict DryBuffer)[BUFFERSIZE]);
+
+    void (*const Delete)(void *ptr);
+};
+
+#define DEFINE_MIDISYNTH_VTABLE(T)                                            \
+DECLARE_THUNK(T, MidiSynth, void, Destruct)                                   \
+DECLARE_THUNK3(T, MidiSynth, ALenum, selectSoundfonts, ALCcontext*, ALsizei, const ALuint*) \
+DECLARE_THUNK1(T, MidiSynth, void, setGain, ALfloat)                          \
+DECLARE_THUNK(T, MidiSynth, void, stop)                                       \
+DECLARE_THUNK(T, MidiSynth, void, reset)                                      \
+DECLARE_THUNK1(T, MidiSynth, void, update, ALCdevice*)                        \
+DECLARE_THUNK2(T, MidiSynth, void, process, ALuint, ALfloatBUFFERSIZE*restrict) \
+static void T##_MidiSynth_Delete(void *ptr)                                   \
+{ T##_Delete(STATIC_UPCAST(T, MidiSynth, (MidiSynth*)ptr)); }                 \
+                                                                              \
+static const struct MidiSynthVtable T##_MidiSynth_vtable = {                  \
+    T##_MidiSynth_Destruct,                                                   \
+                                                                              \
+    T##_MidiSynth_selectSoundfonts,                                           \
+    T##_MidiSynth_setGain,                                                    \
+    T##_MidiSynth_stop,                                                       \
+    T##_MidiSynth_reset,                                                      \
+    T##_MidiSynth_update,                                                     \
+    T##_MidiSynth_process,                                                    \
+                                                                              \
+    T##_MidiSynth_Delete,                                                     \
+}
+
+
+MidiSynth *SSynth_create(ALCdevice *device);
+MidiSynth *FSynth_create(ALCdevice *device);
+MidiSynth *DSynth_create(ALCdevice *device);
+
+MidiSynth *SynthCreate(ALCdevice *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AL_MIDI_BASE_H */
@@ -0,0 +1,76 @@
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "alMain.h"
+#include "alError.h"
+#include "evtqueue.h"
+#include "rwlock.h"
+#include "alu.h"
+
+#include "midi/base.h"
+
+typedef struct DSynth {
+    DERIVE_FROM_TYPE(MidiSynth);
+} DSynth;
+
+static void DSynth_Construct(DSynth *self, ALCdevice *device);
+static DECLARE_FORWARD(DSynth, MidiSynth, void, Destruct)
+static DECLARE_FORWARD3(DSynth, MidiSynth, ALenum, selectSoundfonts, ALCcontext*, ALsizei, const ALuint*)
+static DECLARE_FORWARD1(DSynth, MidiSynth, void, setGain, ALfloat)
+static DECLARE_FORWARD(DSynth, MidiSynth, void, stop)
+static DECLARE_FORWARD(DSynth, MidiSynth, void, reset)
+static DECLARE_FORWARD1(DSynth, MidiSynth, void, update, ALCdevice*)
+static void DSynth_process(DSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE]);
+DECLARE_DEFAULT_ALLOCATORS(DSynth)
+DEFINE_MIDISYNTH_VTABLE(DSynth);
+
+
+static void DSynth_Construct(DSynth *self, ALCdevice *device)
+{
+    MidiSynth_Construct(STATIC_CAST(MidiSynth, self), device);
+    SET_VTABLE2(DSynth, MidiSynth, self);
+}
+
+
+static void DSynth_processQueue(DSynth *self, ALuint64 time)
+{
+    EvtQueue *queue = &STATIC_CAST(MidiSynth, self)->EventQueue;
+
+    while(queue->pos < queue->size && queue->events[queue->pos].time <= time)
+        queue->pos++;
+}
+
+static void DSynth_process(DSynth *self, ALuint SamplesToDo, ALfloatBUFFERSIZE*restrict UNUSED(DryBuffer))
+{
+    MidiSynth *synth = STATIC_CAST(MidiSynth, self);
+    ALuint64 curtime;
+
+    if(synth->State != AL_PLAYING)
+        return;
+
+    synth->SamplesDone += SamplesToDo;
+    synth->ClockBase += (synth->SamplesDone/synth->SampleRate) * MIDI_CLOCK_RES;
+    synth->SamplesDone %= synth->SampleRate;
+
+    curtime = MidiSynth_getTime(synth);
+    DSynth_processQueue(self, maxi64(curtime-1, 0));
+}
+
+
+MidiSynth *DSynth_create(ALCdevice *device)
+{
+    DSynth *synth = DSynth_New(sizeof(*synth));
+    if(!synth)
+    {
+        ERR("Failed to allocate DSynth\n");
+        return NULL;
+    }
+    memset(synth, 0, sizeof(*synth));
+    DSynth_Construct(synth, device);
+    return STATIC_CAST(MidiSynth, synth);
+}
@@ -0,0 +1,930 @@
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "midi/base.h"
+
+#include "alMain.h"
+#include "alError.h"
+#include "alMidi.h"
+#include "alu.h"
+#include "compat.h"
+#include "evtqueue.h"
+#include "rwlock.h"
+
+#ifdef HAVE_FLUIDSYNTH
+
+#include <fluidsynth.h>
+
+
+#ifdef HAVE_DYNLOAD
+#define FLUID_FUNCS(MAGIC)                                                    \
+    MAGIC(new_fluid_synth);                                                   \
+    MAGIC(delete_fluid_synth);                                                \
+    MAGIC(new_fluid_settings);                                                \
+    MAGIC(delete_fluid_settings);                                             \
+    MAGIC(fluid_settings_setint);                                             \
+    MAGIC(fluid_settings_setnum);                                             \
+    MAGIC(fluid_synth_noteon);                                                \
+    MAGIC(fluid_synth_noteoff);                                               \
+    MAGIC(fluid_synth_program_change);                                        \
+    MAGIC(fluid_synth_pitch_bend);                                            \
+    MAGIC(fluid_synth_channel_pressure);                                      \
+    MAGIC(fluid_synth_cc);                                                    \
+    MAGIC(fluid_synth_sysex);                                                 \
+    MAGIC(fluid_synth_bank_select);                                           \
+    MAGIC(fluid_synth_set_channel_type);                                      \
+    MAGIC(fluid_synth_all_sounds_off);                                        \
+    MAGIC(fluid_synth_system_reset);                                          \
+    MAGIC(fluid_synth_set_gain);                                              \
+    MAGIC(fluid_synth_set_sample_rate);                                       \
+    MAGIC(fluid_synth_write_float);                                           \
+    MAGIC(fluid_synth_add_sfloader);                                          \
+    MAGIC(fluid_synth_sfload);                                                \
+    MAGIC(fluid_synth_sfunload);                                              \
+    MAGIC(fluid_synth_alloc_voice);                                           \
+    MAGIC(fluid_synth_start_voice);                                           \
+    MAGIC(fluid_voice_gen_set);                                               \
+    MAGIC(fluid_voice_add_mod);                                               \
+    MAGIC(fluid_mod_set_source1);                                             \
+    MAGIC(fluid_mod_set_source2);                                             \
+    MAGIC(fluid_mod_set_amount);                                              \
+    MAGIC(fluid_mod_set_dest);
+
+void *fsynth_handle = NULL;
+#define DECL_FUNC(x) __typeof(x) *p##x
+FLUID_FUNCS(DECL_FUNC)
+#undef DECL_FUNC
+
+#define new_fluid_synth pnew_fluid_synth
+#define delete_fluid_synth pdelete_fluid_synth
+#define new_fluid_settings pnew_fluid_settings
+#define delete_fluid_settings pdelete_fluid_settings
+#define fluid_settings_setint pfluid_settings_setint
+#define fluid_settings_setnum pfluid_settings_setnum
+#define fluid_synth_noteon pfluid_synth_noteon
+#define fluid_synth_noteoff pfluid_synth_noteoff
+#define fluid_synth_program_change pfluid_synth_program_change
+#define fluid_synth_pitch_bend pfluid_synth_pitch_bend
+#define fluid_synth_channel_pressure pfluid_synth_channel_pressure
+#define fluid_synth_cc pfluid_synth_cc
+#define fluid_synth_sysex pfluid_synth_sysex
+#define fluid_synth_bank_select pfluid_synth_bank_select
+#define fluid_synth_set_channel_type pfluid_synth_set_channel_type
+#define fluid_synth_all_sounds_off pfluid_synth_all_sounds_off
+#define fluid_synth_system_reset pfluid_synth_system_reset
+#define fluid_synth_set_gain pfluid_synth_set_gain
+#define fluid_synth_set_sample_rate pfluid_synth_set_sample_rate
+#define fluid_synth_write_float pfluid_synth_write_float
+#define fluid_synth_add_sfloader pfluid_synth_add_sfloader
+#define fluid_synth_sfload pfluid_synth_sfload
+#define fluid_synth_sfunload pfluid_synth_sfunload
+#define fluid_synth_alloc_voice pfluid_synth_alloc_voice
+#define fluid_synth_start_voice pfluid_synth_start_voice
+#define fluid_voice_gen_set pfluid_voice_gen_set
+#define fluid_voice_add_mod pfluid_voice_add_mod
+#define fluid_mod_set_source1 pfluid_mod_set_source1
+#define fluid_mod_set_source2 pfluid_mod_set_source2
+#define fluid_mod_set_amount pfluid_mod_set_amount
+#define fluid_mod_set_dest pfluid_mod_set_dest
+
+static ALboolean LoadFSynth(void)
+{
+    ALboolean ret = AL_TRUE;
+    if(!fsynth_handle)
+    {
+        fsynth_handle = LoadLib("libfluidsynth.so.1");
+        if(!fsynth_handle) return AL_FALSE;
+
+#define LOAD_FUNC(x) do {                                                     \
+     p##x = GetSymbol(fsynth_handle, #x);                                     \
+     if(!p##x) ret = AL_FALSE;                                                \
+} while(0)
+        FLUID_FUNCS(LOAD_FUNC)
+#undef LOAD_FUNC
+
+        if(ret == AL_FALSE)
+        {
+            CloseLib(fsynth_handle);
+            fsynth_handle = NULL;
+        }
+    }
+    return ret;
+}
+#else
+static inline ALboolean LoadFSynth(void) { return AL_TRUE; }
+#endif
+
+
+/* MIDI events */
+#define SYSEX_EVENT  (0xF0)
+
+/* MIDI controllers */
+#define CTRL_BANKSELECT_MSB  (0)
+#define CTRL_BANKSELECT_LSB  (32)
+#define CTRL_ALLNOTESOFF     (123)
+
+
+static int getModInput(ALenum input)
+{
+    switch(input)
+    {
+        case AL_ONE_SOFT: return FLUID_MOD_NONE;
+        case AL_NOTEON_VELOCITY_SOFT: return FLUID_MOD_VELOCITY;
+        case AL_NOTEON_KEY_SOFT: return FLUID_MOD_KEY;
+        case AL_KEYPRESSURE_SOFT: return FLUID_MOD_KEYPRESSURE;
+        case AL_CHANNELPRESSURE_SOFT: return FLUID_MOD_CHANNELPRESSURE;
+        case AL_PITCHBEND_SOFT: return FLUID_MOD_PITCHWHEEL;
+        case AL_PITCHBEND_SENSITIVITY_SOFT: return FLUID_MOD_PITCHWHEELSENS;
+    }
+    return input&0x7F;
+}
+
+static int getModFlags(ALenum input, ALenum type, ALenum form)
+{
+    int ret = 0;
+
+    switch(type)
+    {
+        case AL_UNORM_SOFT: ret |= FLUID_MOD_UNIPOLAR | FLUID_MOD_POSITIVE; break;
+        case AL_UNORM_REV_SOFT: ret |= FLUID_MOD_UNIPOLAR | FLUID_MOD_NEGATIVE; break;
+        case AL_SNORM_SOFT: ret |= FLUID_MOD_BIPOLAR | FLUID_MOD_POSITIVE; break;
+        case AL_SNORM_REV_SOFT: ret |= FLUID_MOD_BIPOLAR | FLUID_MOD_NEGATIVE; break;
+    }
+    switch(form)
+    {
+        case AL_LINEAR_SOFT: ret |= FLUID_MOD_LINEAR; break;
+        case AL_CONCAVE_SOFT: ret |= FLUID_MOD_CONCAVE; break;
+        case AL_CONVEX_SOFT: ret |= FLUID_MOD_CONVEX; break;
+        case AL_SWITCH_SOFT: ret |= FLUID_MOD_SWITCH; break;
+    }
+    /* Source input values less than 128 correspond to a MIDI continuous
+     * controller. Otherwise, it's a general controller. */
+    if(input < 128) ret |= FLUID_MOD_CC;
+    else ret |= FLUID_MOD_GC;
+
+    return ret;
+}
+
+static enum fluid_gen_type getModDest(ALenum gen)
+{
+    switch(gen)
+    {
+        case AL_MOD_LFO_TO_PITCH_SOFT: return GEN_MODLFOTOPITCH;
+        case AL_VIBRATO_LFO_TO_PITCH_SOFT: return GEN_VIBLFOTOPITCH;
+        case AL_MOD_ENV_TO_PITCH_SOFT: return GEN_MODENVTOPITCH;
+        case AL_FILTER_CUTOFF_SOFT: return GEN_FILTERFC;
+        case AL_FILTER_RESONANCE_SOFT: return GEN_FILTERQ;
+        case AL_MOD_LFO_TO_FILTER_CUTOFF_SOFT: return GEN_MODLFOTOFILTERFC;
+        case AL_MOD_ENV_TO_FILTER_CUTOFF_SOFT: return GEN_MODENVTOFILTERFC;
+        case AL_MOD_LFO_TO_VOLUME_SOFT: return GEN_MODLFOTOVOL;
+        case AL_CHORUS_SEND_SOFT: return GEN_CHORUSSEND;
+        case AL_REVERB_SEND_SOFT: return GEN_REVERBSEND;
+        case AL_PAN_SOFT: return GEN_PAN;
+        case AL_MOD_LFO_DELAY_SOFT: return GEN_MODLFODELAY;
+        case AL_MOD_LFO_FREQUENCY_SOFT: return GEN_MODLFOFREQ;
+        case AL_VIBRATO_LFO_DELAY_SOFT: return GEN_VIBLFODELAY;
+        case AL_VIBRATO_LFO_FREQUENCY_SOFT: return GEN_VIBLFOFREQ;
+        case AL_MOD_ENV_DELAYTIME_SOFT: return GEN_MODENVDELAY;
+        case AL_MOD_ENV_ATTACKTIME_SOFT: return GEN_MODENVATTACK;
+        case AL_MOD_ENV_HOLDTIME_SOFT: return GEN_MODENVHOLD;
+        case AL_MOD_ENV_DECAYTIME_SOFT: return GEN_MODENVDECAY;
+        case AL_MOD_ENV_SUSTAINVOLUME_SOFT: return GEN_MODENVSUSTAIN;
+        case AL_MOD_ENV_RELEASETIME_SOFT: return GEN_MODENVRELEASE;
+        case AL_MOD_ENV_KEY_TO_HOLDTIME_SOFT: return GEN_KEYTOMODENVHOLD;
+        case AL_MOD_ENV_KEY_TO_DECAYTIME_SOFT: return GEN_KEYTOMODENVDECAY;
+        case AL_VOLUME_ENV_DELAYTIME_SOFT: return GEN_VOLENVDELAY;
+        case AL_VOLUME_ENV_ATTACKTIME_SOFT: return GEN_VOLENVATTACK;
+        case AL_VOLUME_ENV_HOLDTIME_SOFT: return GEN_VOLENVHOLD;
+        case AL_VOLUME_ENV_DECAYTIME_SOFT: return GEN_VOLENVDECAY;
+        case AL_VOLUME_ENV_SUSTAINVOLUME_SOFT: return GEN_VOLENVSUSTAIN;
+        case AL_VOLUME_ENV_RELEASETIME_SOFT: return GEN_VOLENVRELEASE;
+        case AL_VOLUME_ENV_KEY_TO_HOLDTIME_SOFT: return GEN_KEYTOVOLENVHOLD;
+        case AL_VOLUME_ENV_KEY_TO_DECAYTIME_SOFT: return GEN_KEYTOVOLENVDECAY;
+        case AL_ATTENUATION_SOFT: return GEN_ATTENUATION;
+        case AL_TUNING_COARSE_SOFT: return GEN_COARSETUNE;
+        case AL_TUNING_FINE_SOFT: return GEN_FINETUNE;
+        case AL_TUNING_SCALE_SOFT: return GEN_SCALETUNE;
+    }
+    ERR("Unhandled generator: 0x%04x\n", gen);
+    return 0;
+}
+
+static int getSf2LoopMode(ALenum mode)
+{
+    switch(mode)
+    {
+        case AL_NONE: return 0;
+        case AL_LOOP_CONTINUOUS_SOFT: return 1;
+        case AL_LOOP_UNTIL_RELEASE_SOFT: return 3;
+    }
+    return 0;
+}
+
+static int getSampleType(ALenum type)
+{
+    switch(type)
+    {
+        case AL_MONO_SOFT: return FLUID_SAMPLETYPE_MONO;
+        case AL_RIGHT_SOFT: return FLUID_SAMPLETYPE_RIGHT;
+        case AL_LEFT_SOFT: return FLUID_SAMPLETYPE_LEFT;
+    }
+    return FLUID_SAMPLETYPE_MONO;
+}
+
+typedef struct FSample {
+    DERIVE_FROM_TYPE(fluid_sample_t);
+
+    ALfontsound *Sound;
+
+    fluid_mod_t *Mods;
+    ALsizei NumMods;
+} FSample;
+
+static void FSample_Construct(FSample *self, ALfontsound *sound)
+{
+    fluid_sample_t *sample = STATIC_CAST(fluid_sample_t, self);
+    memset(sample->name, 0, sizeof(sample->name));
+    sample->start = sound->Start;
+    sample->end = sound->End;
+    sample->loopstart = sound->LoopStart;
+    sample->loopend = sound->LoopEnd;
+    sample->samplerate = sound->SampleRate;
+    sample->origpitch = sound->PitchKey;
+    sample->pitchadj = sound->PitchCorrection;
+    sample->sampletype = getSampleType(sound->SampleType);
+    sample->valid = !!sound->Buffer;
+    sample->data = sound->Buffer ? sound->Buffer->data : NULL;
+
+    sample->amplitude_that_reaches_noise_floor_is_valid = 0;
+    sample->amplitude_that_reaches_noise_floor = 0.0;
+
+    sample->refcount = 0;
+
+    sample->notify = NULL;
+
+    sample->userdata = self;
+
+    self->Sound = sound;
+
+    self->NumMods = 0;
+    self->Mods = calloc(sound->ModulatorMap.size*4, sizeof(fluid_mod_t[4]));
+    if(self->Mods)
+    {
+        ALsizei i, j, k;
+
+        for(i = j = 0;i < sound->ModulatorMap.size;i++)
+        {
+            ALsfmodulator *mod = sound->ModulatorMap.array[i].value;
+            for(k = 0;k < 4;k++,mod++)
+            {
+                if(mod->Dest == AL_NONE)
+                    continue;
+                fluid_mod_set_source1(&self->Mods[j], getModInput(mod->Source[0].Input),
+                                      getModFlags(mod->Source[0].Input, mod->Source[0].Type,
+                                                  mod->Source[0].Form));
+                fluid_mod_set_source2(&self->Mods[j], getModInput(mod->Source[1].Input),
+                                      getModFlags(mod->Source[1].Input, mod->Source[1].Type,
+                                                  mod->Source[1].Form));
+                fluid_mod_set_amount(&self->Mods[j], mod->Amount);
+                fluid_mod_set_dest(&self->Mods[j], getModDest(mod->Dest));
+                self->Mods[j++].next = NULL;
+            }
+        }
+        self->NumMods = j;
+    }
+}
+
+static void FSample_Destruct(FSample *self)
+{
+    free(self->Mods);
+    self->Mods = NULL;
+    self->NumMods = 0;
+}
+
+
+typedef struct FPreset {
+    DERIVE_FROM_TYPE(fluid_preset_t);
+
+    char Name[16];
+
+    int Preset;
+    int Bank;
+
+    FSample *Samples;
+    ALsizei NumSamples;
+} FPreset;
+
+static char* FPreset_getName(fluid_preset_t *preset);
+static int FPreset_getPreset(fluid_preset_t *preset);
+static int FPreset_getBank(fluid_preset_t *preset);
+static int FPreset_noteOn(fluid_preset_t *preset, fluid_synth_t *synth, int channel, int key, int velocity);
+
+static void FPreset_Construct(FPreset *self, ALsfpreset *preset, fluid_sfont_t *parent)
+{
+    STATIC_CAST(fluid_preset_t, self)->data = self;
+    STATIC_CAST(fluid_preset_t, self)->sfont = parent;
+    STATIC_CAST(fluid_preset_t, self)->free = NULL;
+    STATIC_CAST(fluid_preset_t, self)->get_name = FPreset_getName;
+    STATIC_CAST(fluid_preset_t, self)->get_banknum = FPreset_getBank;
+    STATIC_CAST(fluid_preset_t, self)->get_num = FPreset_getPreset;
+    STATIC_CAST(fluid_preset_t, self)->noteon = FPreset_noteOn;
+    STATIC_CAST(fluid_preset_t, self)->notify = NULL;
+
+    memset(self->Name, 0, sizeof(self->Name));
+    self->Preset = preset->Preset;
+    self->Bank = preset->Bank;
+
+    self->NumSamples = 0;
+    self->Samples = calloc(1, preset->NumSounds * sizeof(self->Samples[0]));
+    if(self->Samples)
+    {
+        ALsizei i;
+        self->NumSamples = preset->NumSounds;
+        for(i = 0;i < self->NumSamples;i++)
+            FSample_Construct(&self->Samples[i], preset->Sounds[i]);
+    }
+}
+
+static void FPreset_Destruct(FPreset *self)
+{
+    ALsizei i;
+
+    for(i = 0;i < self->NumSamples;i++)
+        FSample_Destruct(&self->Samples[i]);
+    free(self->Samples);
+    self->Samples = NULL;
+    self->NumSamples = 0;
+}
+
+static ALboolean FPreset_canDelete(FPreset *self)
+{
+    ALsizei i;
+    for(i = 0;i < self->NumSamples;i++)
+    {
+        if(fluid_sample_refcount(STATIC_CAST(fluid_sample_t, &self->Samples[i])) != 0)
+            return AL_FALSE;
+    }
+    return AL_TRUE;
+}
+
+static char* FPreset_getName(fluid_preset_t *preset)
+{
+    return ((FPreset*)preset->data)->Name;
+}
+
+static int FPreset_getPreset(fluid_preset_t *preset)
+{
+    return ((FPreset*)preset->data)->Preset;
+}
+
+static int FPreset_getBank(fluid_preset_t *preset)
+{
+    return ((FPreset*)preset->data)->Bank;
+}
+
+static int FPreset_noteOn(fluid_preset_t *preset, fluid_synth_t *synth, int channel, int key, int vel)
+{
+    FPreset *self = ((FPreset*)preset->data);
+    ALsizei i;
+
+    for(i = 0;i < self->NumSamples;i++)
+    {
+        FSample *sample = &self->Samples[i];
+        ALfontsound *sound = sample->Sound;
+        fluid_voice_t *voice;
+        ALsizei m;
+
+        if(!(key >= sound->MinKey && key <= sound->MaxKey && vel >= sound->MinVelocity && vel <= sound->MaxVelocity))
+            continue;
+
+        voice = fluid_synth_alloc_voice(synth, STATIC_CAST(fluid_sample_t, sample), channel, key, vel);
+        if(voice == NULL) return FLUID_FAILED;
+
+        fluid_voice_gen_set(voice, GEN_MODLFOTOPITCH, sound->ModLfoToPitch);
+        fluid_voice_gen_set(voice, GEN_VIBLFOTOPITCH, sound->VibratoLfoToPitch);
+        fluid_voice_gen_set(voice, GEN_MODENVTOPITCH, sound->ModEnvToPitch);
+        fluid_voice_gen_set(voice, GEN_FILTERFC, sound->FilterCutoff);
+        fluid_voice_gen_set(voice, GEN_FILTERQ, sound->FilterQ);
+        fluid_voice_gen_set(voice, GEN_MODLFOTOFILTERFC, sound->ModLfoToFilterCutoff);
+        fluid_voice_gen_set(voice, GEN_MODENVTOFILTERFC, sound->ModEnvToFilterCutoff);
+        fluid_voice_gen_set(voice, GEN_MODLFOTOVOL, sound->ModLfoToVolume);
+        fluid_voice_gen_set(voice, GEN_CHORUSSEND, sound->ChorusSend);
+        fluid_voice_gen_set(voice, GEN_REVERBSEND, sound->ReverbSend);
+        fluid_voice_gen_set(voice, GEN_PAN, sound->Pan);
+        fluid_voice_gen_set(voice, GEN_MODLFODELAY, sound->ModLfo.Delay);
+        fluid_voice_gen_set(voice, GEN_MODLFOFREQ, sound->ModLfo.Frequency);
+        fluid_voice_gen_set(voice, GEN_VIBLFODELAY, sound->VibratoLfo.Delay);
+        fluid_voice_gen_set(voice, GEN_VIBLFOFREQ, sound->VibratoLfo.Frequency);
+        fluid_voice_gen_set(voice, GEN_MODENVDELAY, sound->ModEnv.DelayTime);
+        fluid_voice_gen_set(voice, GEN_MODENVATTACK, sound->ModEnv.AttackTime);
+        fluid_voice_gen_set(voice, GEN_MODENVHOLD, sound->ModEnv.HoldTime);
+        fluid_voice_gen_set(voice, GEN_MODENVDECAY, sound->ModEnv.DecayTime);
+        fluid_voice_gen_set(voice, GEN_MODENVSUSTAIN, sound->ModEnv.SustainAttn);
+        fluid_voice_gen_set(voice, GEN_MODENVRELEASE, sound->ModEnv.ReleaseTime);
+        fluid_voice_gen_set(voice, GEN_KEYTOMODENVHOLD, sound->ModEnv.KeyToHoldTime);
+        fluid_voice_gen_set(voice, GEN_KEYTOMODENVDECAY, sound->ModEnv.KeyToDecayTime);
+        fluid_voice_gen_set(voice, GEN_VOLENVDELAY, sound->VolEnv.DelayTime);
+        fluid_voice_gen_set(voice, GEN_VOLENVATTACK, sound->VolEnv.AttackTime);
+        fluid_voice_gen_set(voice, GEN_VOLENVHOLD, sound->VolEnv.HoldTime);
+        fluid_voice_gen_set(voice, GEN_VOLENVDECAY, sound->VolEnv.DecayTime);
+        fluid_voice_gen_set(voice, GEN_VOLENVSUSTAIN, sound->VolEnv.SustainAttn);
+        fluid_voice_gen_set(voice, GEN_VOLENVRELEASE, sound->VolEnv.ReleaseTime);
+        fluid_voice_gen_set(voice, GEN_KEYTOVOLENVHOLD, sound->VolEnv.KeyToHoldTime);
+        fluid_voice_gen_set(voice, GEN_KEYTOVOLENVDECAY, sound->VolEnv.KeyToDecayTime);
+        fluid_voice_gen_set(voice, GEN_ATTENUATION, sound->Attenuation);
+        fluid_voice_gen_set(voice, GEN_COARSETUNE, sound->CoarseTuning);
+        fluid_voice_gen_set(voice, GEN_FINETUNE, sound->FineTuning);
+        fluid_voice_gen_set(voice, GEN_SAMPLEMODE, getSf2LoopMode(sound->LoopMode));
+        fluid_voice_gen_set(voice, GEN_SCALETUNE, sound->TuningScale);
+        fluid_voice_gen_set(voice, GEN_EXCLUSIVECLASS, sound->ExclusiveClass);
+        for(m = 0;m < sample->NumMods;m++)
+            fluid_voice_add_mod(voice, &sample->Mods[m], FLUID_VOICE_OVERWRITE);
+
+        fluid_synth_start_voice(synth, voice);
+    }
+
+    return FLUID_OK;
+}
+
+
+typedef struct FSfont {
+    DERIVE_FROM_TYPE(fluid_sfont_t);
+
+    char Name[16];
+
+    FPreset *Presets;
+    ALsizei NumPresets;
+
+    ALsizei CurrentPos;
+} FSfont;
+
+static int FSfont_free(fluid_sfont_t *sfont);
+static char* FSfont_getName(fluid_sfont_t *sfont);
+static fluid_preset_t* FSfont_getPreset(fluid_sfont_t *sfont, unsigned int bank, unsigned int prenum);
+static void FSfont_iterStart(fluid_sfont_t *sfont);
+static int FSfont_iterNext(fluid_sfont_t *sfont, fluid_preset_t *preset);
+
+static void FSfont_Construct(FSfont *self, ALsoundfont *sfont)
+{
+    STATIC_CAST(fluid_sfont_t, self)->data = self;
+    STATIC_CAST(fluid_sfont_t, self)->id = FLUID_FAILED;
+    STATIC_CAST(fluid_sfont_t, self)->free = FSfont_free;
+    STATIC_CAST(fluid_sfont_t, self)->get_name = FSfont_getName;
+    STATIC_CAST(fluid_sfont_t, self)->get_preset = FSfont_getPreset;
+    STATIC_CAST(fluid_sfont_t, self)->iteration_start = FSfont_iterStart;
+    STATIC_CAST(fluid_sfont_t, self)->iteration_next = FSfont_iterNext;
+
+    memset(self->Name, 0, sizeof(self->Name));
+    self->CurrentPos = 0;
+    self->NumPresets = 0;
+    self->Presets = calloc(1, sfont->NumPresets * sizeof(self->Presets[0]));
+    if(self->Presets)
+    {
+        ALsizei i;
+        self->NumPresets = sfont->NumPresets;
+        for(i = 0;i < self->NumPresets;i++)
+            FPreset_Construct(&self->Presets[i], sfont->Presets[i], STATIC_CAST(fluid_sfont_t, self));
+    }
+}
+
+static void FSfont_Destruct(FSfont *self)
+{
+    ALsizei i;
+
+    for(i = 0;i < self->NumPresets;i++)
+        FPreset_Destruct(&self->Presets[i]);
+    free(self->Presets);
+    self->Presets = NULL;
+    self->NumPresets = 0;
+    self->CurrentPos = 0;
+}
+
+static int FSfont_free(fluid_sfont_t *sfont)
+{
+    FSfont *self = STATIC_UPCAST(FSfont, fluid_sfont_t, sfont);
+    ALsizei i;
+
+    for(i = 0;i < self->NumPresets;i++)
+    {
+        if(!FPreset_canDelete(&self->Presets[i]))
+            return 1;
+    }
+
+    FSfont_Destruct(self);
+    free(self);
+    return 0;
+}
+
+static char* FSfont_getName(fluid_sfont_t *sfont)
+{
+    return STATIC_UPCAST(FSfont, fluid_sfont_t, sfont)->Name;
+}
+
+static fluid_preset_t *FSfont_getPreset(fluid_sfont_t *sfont, unsigned int bank, unsigned int prenum)
+{
+    FSfont *self = STATIC_UPCAST(FSfont, fluid_sfont_t, sfont);
+    ALsizei i;
+
+    for(i = 0;i < self->NumPresets;i++)
+    {
+        FPreset *preset = &self->Presets[i];
+        if(preset->Bank == (int)bank && preset->Preset == (int)prenum)
+            return STATIC_CAST(fluid_preset_t, preset);
+    }
+
+    return NULL;
+}
+
+static void FSfont_iterStart(fluid_sfont_t *sfont)
+{
+    STATIC_UPCAST(FSfont, fluid_sfont_t, sfont)->CurrentPos = 0;
+}
+
+static int FSfont_iterNext(fluid_sfont_t *sfont, fluid_preset_t *preset)
+{
+    FSfont *self = STATIC_UPCAST(FSfont, fluid_sfont_t, sfont);
+    if(self->CurrentPos >= self->NumPresets)
+        return 0;
+    *preset = *STATIC_CAST(fluid_preset_t, &self->Presets[self->CurrentPos++]);
+    preset->free = NULL;
+    return 1;
+}
+
+
+typedef struct FSynth {
+    DERIVE_FROM_TYPE(MidiSynth);
+    DERIVE_FROM_TYPE(fluid_sfloader_t);
+
+    fluid_settings_t *Settings;
+    fluid_synth_t *Synth;
+    int *FontIDs;
+    ALsizei NumFontIDs;
+
+    ALboolean ForceGM2BankSelect;
+    ALfloat GainScale;
+} FSynth;
+
+static void FSynth_Construct(FSynth *self, ALCdevice *device);
+static void FSynth_Destruct(FSynth *self);
+static ALboolean FSynth_init(FSynth *self, ALCdevice *device);
+static ALenum FSynth_selectSoundfonts(FSynth *self, ALCcontext *context, ALsizei count, const ALuint *ids);
+static void FSynth_setGain(FSynth *self, ALfloat gain);
+static void FSynth_stop(FSynth *self);
+static void FSynth_reset(FSynth *self);
+static void FSynth_update(FSynth *self, ALCdevice *device);
+static void FSynth_processQueue(FSynth *self, ALuint64 time);
+static void FSynth_process(FSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE]);
+DECLARE_DEFAULT_ALLOCATORS(FSynth)
+DEFINE_MIDISYNTH_VTABLE(FSynth);
+
+static fluid_sfont_t *FSynth_loadSfont(fluid_sfloader_t *loader, const char *filename);
+
+
+static void FSynth_Construct(FSynth *self, ALCdevice *device)
+{
+    MidiSynth_Construct(STATIC_CAST(MidiSynth, self), device);
+    SET_VTABLE2(FSynth, MidiSynth, self);
+
+    STATIC_CAST(fluid_sfloader_t, self)->data = self;
+    STATIC_CAST(fluid_sfloader_t, self)->free = NULL;
+    STATIC_CAST(fluid_sfloader_t, self)->load = FSynth_loadSfont;
+
+    self->Settings = NULL;
+    self->Synth = NULL;
+    self->FontIDs = NULL;
+    self->NumFontIDs = 0;
+    self->ForceGM2BankSelect = AL_FALSE;
+    self->GainScale = 0.2f;
+}
+
+static void FSynth_Destruct(FSynth *self)
+{
+    ALsizei i;
+
+    for(i = 0;i < self->NumFontIDs;i++)
+        fluid_synth_sfunload(self->Synth, self->FontIDs[i], 0);
+    free(self->FontIDs);
+    self->FontIDs = NULL;
+    self->NumFontIDs = 0;
+
+    if(self->Synth != NULL)
+        delete_fluid_synth(self->Synth);
+    self->Synth = NULL;
+
+    if(self->Settings != NULL)
+        delete_fluid_settings(self->Settings);
+    self->Settings = NULL;
+
+    MidiSynth_Destruct(STATIC_CAST(MidiSynth, self));
+}
+
+static ALboolean FSynth_init(FSynth *self, ALCdevice *device)
+{
+    ALfloat vol;
+
+    if(ConfigValueFloat("midi", "volume", &vol))
+    {
+        if(!(vol <= 0.0f))
+        {
+            ERR("MIDI volume %f clamped to 0\n", vol);
+            vol = 0.0f;
+        }
+        self->GainScale = powf(10.0f, vol / 20.0f);
+    }
+
+    self->Settings = new_fluid_settings();
+    if(!self->Settings)
+    {
+        ERR("Failed to create FluidSettings\n");
+        return AL_FALSE;
+    }
+
+    fluid_settings_setint(self->Settings, "synth.polyphony", 256);
+    fluid_settings_setnum(self->Settings, "synth.gain", self->GainScale);
+    fluid_settings_setnum(self->Settings, "synth.sample-rate", device->Frequency);
+
+    self->Synth = new_fluid_synth(self->Settings);
+    if(!self->Synth)
+    {
+        ERR("Failed to create FluidSynth\n");
+        return AL_FALSE;
+    }
+
+    fluid_synth_add_sfloader(self->Synth, STATIC_CAST(fluid_sfloader_t, self));
+
+    return AL_TRUE;
+}
+
+
+static fluid_sfont_t *FSynth_loadSfont(fluid_sfloader_t *loader, const char *filename)
+{
+    FSynth *self = STATIC_UPCAST(FSynth, fluid_sfloader_t, loader);
+    FSfont *sfont;
+    int idx;
+
+    if(!filename || sscanf(filename, "_al_internal %d", &idx) != 1)
+        return NULL;
+    if(idx < 0 || idx >= STATIC_CAST(MidiSynth, self)->NumSoundfonts)
+    {
+        ERR("Received invalid soundfont index %d (max: %d)\n", idx, STATIC_CAST(MidiSynth, self)->NumSoundfonts);
+        return NULL;
+    }
+
+    sfont = calloc(1, sizeof(sfont[0]));
+    if(!sfont) return NULL;
+
+    FSfont_Construct(sfont, STATIC_CAST(MidiSynth, self)->Soundfonts[idx]);
+    return STATIC_CAST(fluid_sfont_t, sfont);
+}
+
+static ALenum FSynth_selectSoundfonts(FSynth *self, ALCcontext *context, ALsizei count, const ALuint *ids)
+{
+    int *fontid;
+    ALenum ret;
+    ALsizei i;
+
+    ret = MidiSynth_selectSoundfonts(STATIC_CAST(MidiSynth, self), context, count, ids);
+    if(ret != AL_NO_ERROR) return ret;
+
+    ALCdevice_Lock(context->Device);
+    for(i = 0;i < 16;i++)
+        fluid_synth_all_sounds_off(self->Synth, i);
+    ALCdevice_Unlock(context->Device);
+
+    fontid = malloc(count * sizeof(fontid[0]));
+    if(fontid)
+    {
+        for(i = 0;i < STATIC_CAST(MidiSynth, self)->NumSoundfonts;i++)
+        {
+            char name[16];
+            snprintf(name, sizeof(name), "_al_internal %d", i);
+
+            fontid[i] = fluid_synth_sfload(self->Synth, name, 0);
+            if(fontid[i] == FLUID_FAILED)
+                ERR("Failed to load selected soundfont %d\n", i);
+        }
+
+        fontid = ExchangePtr((XchgPtr*)&self->FontIDs, fontid);
+        count = ExchangeInt(&self->NumFontIDs, count);
+    }
+    else
+    {
+        ERR("Failed to allocate space for %d font IDs!\n", count);
+        fontid = ExchangePtr((XchgPtr*)&self->FontIDs, NULL);
+        count = ExchangeInt(&self->NumFontIDs, 0);
+    }
+
+    for(i = 0;i < count;i++)
+        fluid_synth_sfunload(self->Synth, fontid[i], 0);
+    free(fontid);
+
+    return ret;
+}
+
+
+static void FSynth_setGain(FSynth *self, ALfloat gain)
+{
+    fluid_settings_setnum(self->Settings, "synth.gain", self->GainScale * gain);
+    fluid_synth_set_gain(self->Synth, self->GainScale * gain);
+    MidiSynth_setGain(STATIC_CAST(MidiSynth, self), gain);
+}
+
+
+static void FSynth_stop(FSynth *self)
+{
+    MidiSynth *synth = STATIC_CAST(MidiSynth, self);
+    ALuint64 curtime;
+    ALsizei chan;
+
+    /* Make sure all pending events are processed. */
+    curtime = MidiSynth_getTime(synth);
+    FSynth_processQueue(self, curtime);
+
+    /* All notes off */
+    for(chan = 0;chan < 16;chan++)
+        fluid_synth_cc(self->Synth, chan, CTRL_ALLNOTESOFF, 0);
+
+    MidiSynth_stop(STATIC_CAST(MidiSynth, self));
+}
+
+static void FSynth_reset(FSynth *self)
+{
+    /* Reset to power-up status. */
+    fluid_synth_system_reset(self->Synth);
+
+    MidiSynth_reset(STATIC_CAST(MidiSynth, self));
+}
+
+
+static void FSynth_update(FSynth *self, ALCdevice *device)
+{
+    fluid_settings_setnum(self->Settings, "synth.sample-rate", device->Frequency);
+    fluid_synth_set_sample_rate(self->Synth, device->Frequency);
+    MidiSynth_update(STATIC_CAST(MidiSynth, self), device);
+}
+
+
+static void FSynth_processQueue(FSynth *self, ALuint64 time)
+{
+    EvtQueue *queue = &STATIC_CAST(MidiSynth, self)->EventQueue;
+
+    while(queue->pos < queue->size && queue->events[queue->pos].time <= time)
+    {
+        const MidiEvent *evt = &queue->events[queue->pos];
+
+        if(evt->event == SYSEX_EVENT)
+        {
+            static const ALbyte gm2_on[] = { 0x7E, 0x7F, 0x09, 0x03 };
+            static const ALbyte gm2_off[] = { 0x7E, 0x7F, 0x09, 0x02 };
+            int handled = 0;
+
+            fluid_synth_sysex(self->Synth, evt->param.sysex.data, evt->param.sysex.size, NULL, NULL, &handled, 0);
+            if(!handled && evt->param.sysex.size >= (ALsizei)sizeof(gm2_on))
+            {
+                if(memcmp(evt->param.sysex.data, gm2_on, sizeof(gm2_on)) == 0)
+                    self->ForceGM2BankSelect = AL_TRUE;
+                else if(memcmp(evt->param.sysex.data, gm2_off, sizeof(gm2_off)) == 0)
+                    self->ForceGM2BankSelect = AL_FALSE;
+            }
+        }
+        else switch((evt->event&0xF0))
+        {
+            case AL_NOTEOFF_SOFT:
+                fluid_synth_noteoff(self->Synth, (evt->event&0x0F), evt->param.val[0]);
+                break;
+            case AL_NOTEON_SOFT:
+                fluid_synth_noteon(self->Synth, (evt->event&0x0F), evt->param.val[0], evt->param.val[1]);
+                break;
+            case AL_KEYPRESSURE_SOFT:
+                break;
+
+            case AL_CONTROLLERCHANGE_SOFT:
+                if(self->ForceGM2BankSelect)
+                {
+                    int chan = (evt->event&0x0F);
+                    if(evt->param.val[0] == CTRL_BANKSELECT_MSB)
+                    {
+                        if(evt->param.val[1] == 120 && (chan == 9 || chan == 10))
+                            fluid_synth_set_channel_type(self->Synth, chan, CHANNEL_TYPE_DRUM);
+                        else if(evt->param.val[1] == 121)
+                            fluid_synth_set_channel_type(self->Synth, chan, CHANNEL_TYPE_MELODIC);
+                        break;
+                    }
+                    if(evt->param.val[0] == CTRL_BANKSELECT_LSB)
+                    {
+                        fluid_synth_bank_select(self->Synth, chan, evt->param.val[1]);
+                        break;
+                    }
+                }
+                fluid_synth_cc(self->Synth, (evt->event&0x0F), evt->param.val[0], evt->param.val[1]);
+                break;
+            case AL_PROGRAMCHANGE_SOFT:
+                fluid_synth_program_change(self->Synth, (evt->event&0x0F), evt->param.val[0]);
+                break;
+
+            case AL_CHANNELPRESSURE_SOFT:
+                fluid_synth_channel_pressure(self->Synth, (evt->event&0x0F), evt->param.val[0]);
+                break;
+
+            case AL_PITCHBEND_SOFT:
+                fluid_synth_pitch_bend(self->Synth, (evt->event&0x0F), (evt->param.val[0]&0x7F) |
+                                                                       ((evt->param.val[1]&0x7F)<<7));
+                break;
+        }
+
+        queue->pos++;
+    }
+}
+
+static void FSynth_process(FSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE])
+{
+    MidiSynth *synth = STATIC_CAST(MidiSynth, self);
+    ALenum state = synth->State;
+    ALuint64 curtime;
+    ALuint total = 0;
+
+    if(state == AL_INITIAL)
+        return;
+    if(state != AL_PLAYING)
+    {
+        fluid_synth_write_float(self->Synth, SamplesToDo, DryBuffer[FrontLeft], 0, 1,
+                                                          DryBuffer[FrontRight], 0, 1);
+        return;
+    }
+
+    curtime = MidiSynth_getTime(synth);
+    while(total < SamplesToDo)
+    {
+        ALuint64 time, diff;
+        ALint tonext;
+
+        time = MidiSynth_getNextEvtTime(synth);
+        diff = maxu64(time, curtime) - curtime;
+        if(diff >= MIDI_CLOCK_RES || time == UINT64_MAX)
+        {
+            /* If there's no pending event, or if it's more than 1 second
+             * away, do as many samples as we can. */
+            tonext = INT_MAX;
+        }
+        else
+        {
+            /* Figure out how many samples until the next event. */
+            tonext  = (ALint)((diff*synth->SampleRate + (MIDI_CLOCK_RES-1)) / MIDI_CLOCK_RES);
+            tonext -= total;
+        }
+
+        if(tonext > 0)
+        {
+            ALuint todo = minu(tonext, SamplesToDo-total);
+            fluid_synth_write_float(self->Synth, todo, DryBuffer[FrontLeft], total, 1,
+                                                       DryBuffer[FrontRight], total, 1);
+            total += todo;
+            tonext -= todo;
+        }
+        if(total < SamplesToDo && tonext <= 0)
+            FSynth_processQueue(self, time);
+    }
+
+    synth->SamplesDone += SamplesToDo;
+    synth->ClockBase += (synth->SamplesDone/synth->SampleRate) * MIDI_CLOCK_RES;
+    synth->SamplesDone %= synth->SampleRate;
+}
+
+
+MidiSynth *FSynth_create(ALCdevice *device)
+{
+    FSynth *synth;
+
+    if(!LoadFSynth())
+        return NULL;
+
+    synth = FSynth_New(sizeof(*synth));
+    if(!synth)
+    {
+        ERR("Failed to allocate FSynth\n");
+        return NULL;
+    }
+    memset(synth, 0, sizeof(*synth));
+    FSynth_Construct(synth, device);
+
+    if(FSynth_init(synth, device) == AL_FALSE)
+    {
+        DELETE_OBJ(STATIC_CAST(MidiSynth, synth));
+        return NULL;
+    }
+
+    return STATIC_CAST(MidiSynth, synth);
+}
+
+#else
+
+MidiSynth *FSynth_create(ALCdevice* UNUSED(device))
+{
+    return NULL;
+}
+
+#endif
@@ -0,0 +1,140 @@
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "alMain.h"
+#include "alError.h"
+#include "evtqueue.h"
+#include "alu.h"
+
+#include "midi/base.h"
+
+
+typedef struct SSynth {
+    DERIVE_FROM_TYPE(MidiSynth);
+} SSynth;
+
+static void SSynth_mixSamples(SSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE]);
+
+static void SSynth_Construct(SSynth *self, ALCdevice *device);
+static void SSynth_Destruct(SSynth *self);
+static DECLARE_FORWARD3(SSynth, MidiSynth, ALenum, selectSoundfonts, ALCcontext*, ALsizei, const ALuint*)
+static DECLARE_FORWARD1(SSynth, MidiSynth, void, setGain, ALfloat)
+static DECLARE_FORWARD(SSynth, MidiSynth, void, stop)
+static DECLARE_FORWARD(SSynth, MidiSynth, void, reset)
+static void SSynth_update(SSynth *self, ALCdevice *device);
+static void SSynth_process(SSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE]);
+DECLARE_DEFAULT_ALLOCATORS(SSynth)
+DEFINE_MIDISYNTH_VTABLE(SSynth);
+
+
+static void SSynth_Construct(SSynth *self, ALCdevice *device)
+{
+    MidiSynth_Construct(STATIC_CAST(MidiSynth, self), device);
+    SET_VTABLE2(SSynth, MidiSynth, self);
+}
+
+static void SSynth_Destruct(SSynth* UNUSED(self))
+{
+}
+
+
+static void SSynth_update(SSynth* UNUSED(self), ALCdevice* UNUSED(device))
+{
+}
+
+
+static void SSynth_mixSamples(SSynth* UNUSED(self), ALuint UNUSED(SamplesToDo), ALfloatBUFFERSIZE *restrict UNUSED(DryBuffer))
+{
+}
+
+
+static void SSynth_processQueue(SSynth *self, ALuint64 time)
+{
+    EvtQueue *queue = &STATIC_CAST(MidiSynth, self)->EventQueue;
+
+    while(queue->pos < queue->size && queue->events[queue->pos].time <= time)
+        queue->pos++;
+}
+
+static void SSynth_process(SSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE])
+{
+    MidiSynth *synth = STATIC_CAST(MidiSynth, self);
+    ALenum state = synth->State;
+    ALuint64 curtime;
+    ALuint total = 0;
+
+    if(state == AL_INITIAL)
+        return;
+    if(state != AL_PLAYING)
+    {
+        SSynth_mixSamples(self, SamplesToDo, DryBuffer);
+        return;
+    }
+
+    curtime = MidiSynth_getTime(synth);
+    while(total < SamplesToDo)
+    {
+        ALuint64 time, diff;
+        ALint tonext;
+
+        time = MidiSynth_getNextEvtTime(synth);
+        diff = maxu64(time, curtime) - curtime;
+        if(diff >= MIDI_CLOCK_RES || time == UINT64_MAX)
+        {
+            /* If there's no pending event, or if it's more than 1 second
+             * away, do as many samples as we can. */
+            tonext = INT_MAX;
+        }
+        else
+        {
+            /* Figure out how many samples until the next event. */
+            tonext  = (ALint)((diff*synth->SampleRate + (MIDI_CLOCK_RES-1)) / MIDI_CLOCK_RES);
+            tonext -= total;
+            /* For efficiency reasons, try to mix a multiple of 64 samples
+             * (~1ms @ 44.1khz) before processing the next event. */
+            tonext = (tonext+63) & ~63;
+        }
+
+        if(tonext > 0)
+        {
+            ALuint todo = mini(tonext, SamplesToDo-total);
+            SSynth_mixSamples(self, todo, DryBuffer);
+            total += todo;
+            tonext -= todo;
+        }
+        if(total < SamplesToDo && tonext <= 0)
+            SSynth_processQueue(self, time);
+    }
+
+    synth->SamplesDone += SamplesToDo;
+    synth->ClockBase += (synth->SamplesDone/synth->SampleRate) * MIDI_CLOCK_RES;
+    synth->SamplesDone %= synth->SampleRate;
+}
+
+
+MidiSynth *SSynth_create(ALCdevice *device)
+{
+    SSynth *synth;
+
+    /* This option is temporary. Once this synth is in a more usable state, a
+     * more generic selector should be used. */
+    if(!GetConfigValueBool("midi", "internal-synth", 0))
+    {
+        TRACE("Not using internal MIDI synth\n");
+        return NULL;
+    }
+
+    synth = SSynth_New(sizeof(*synth));
+    if(!synth)
+    {
+        ERR("Failed to allocate SSynth\n");
+        return NULL;
+    }
+    SSynth_Construct(synth, device);
+    return STATIC_CAST(MidiSynth, synth);
+}
@@ -0,0 +1,510 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "alMain.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alSource.h"
+#include "alBuffer.h"
+#include "alListener.h"
+#include "alAuxEffectSlot.h"
+#include "alu.h"
+
+#include "mixer_defs.h"
+
+
+extern inline void InitiatePositionArrays(ALuint frac, ALuint increment, ALuint *frac_arr, ALuint *pos_arr, ALuint size);
+
+
+static inline HrtfMixerFunc SelectHrtfMixer(void)
+{
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+        return MixHrtf_SSE;
+#endif
+#ifdef HAVE_NEON
+    if((CPUCapFlags&CPU_CAP_NEON))
+        return MixHrtf_Neon;
+#endif
+
+    return MixHrtf_C;
+}
+
+static inline MixerFunc SelectMixer(void)
+{
+#ifdef HAVE_SSE
+    if((CPUCapFlags&CPU_CAP_SSE))
+        return Mix_SSE;
+#endif
+#ifdef HAVE_NEON
+    if((CPUCapFlags&CPU_CAP_NEON))
+        return Mix_Neon;
+#endif
+
+    return Mix_C;
+}
+
+static inline ResamplerFunc SelectResampler(enum Resampler Resampler, ALuint increment)
+{
+    if(increment == FRACTIONONE)
+        return Resample_copy32_C;
+    switch(Resampler)
+    {
+        case PointResampler:
+            return Resample_point32_C;
+        case LinearResampler:
+#ifdef HAVE_SSE4_1
+            if((CPUCapFlags&CPU_CAP_SSE4_1))
+                return Resample_lerp32_SSE41;
+#endif
+#ifdef HAVE_SSE2
+            if((CPUCapFlags&CPU_CAP_SSE2))
+                return Resample_lerp32_SSE2;
+#endif
+            return Resample_lerp32_C;
+        case CubicResampler:
+            return Resample_cubic32_C;
+        case ResamplerMax:
+            /* Shouldn't happen */
+            break;
+    }
+
+    return Resample_point32_C;
+}
+
+
+static inline ALfloat Sample_ALbyte(ALbyte val)
+{ return val * (1.0f/127.0f); }
+
+static inline ALfloat Sample_ALshort(ALshort val)
+{ return val * (1.0f/32767.0f); }
+
+static inline ALfloat Sample_ALfloat(ALfloat val)
+{ return val; }
+
+#define DECL_TEMPLATE(T)                                                      \
+static void Load_##T(ALfloat *dst, const T *src, ALuint srcstep, ALuint samples)\
+{                                                                             \
+    ALuint i;                                                                 \
+    for(i = 0;i < samples;i++)                                                \
+        dst[i] = Sample_##T(src[i*srcstep]);                                  \
+}
+
+DECL_TEMPLATE(ALbyte)
+DECL_TEMPLATE(ALshort)
+DECL_TEMPLATE(ALfloat)
+
+#undef DECL_TEMPLATE
+
+static void LoadSamples(ALfloat *dst, const ALvoid *src, ALuint srcstep, enum FmtType srctype, ALuint samples)
+{
+    switch(srctype)
+    {
+        case FmtByte:
+            Load_ALbyte(dst, src, srcstep, samples);
+            break;
+        case FmtShort:
+            Load_ALshort(dst, src, srcstep, samples);
+            break;
+        case FmtFloat:
+            Load_ALfloat(dst, src, srcstep, samples);
+            break;
+    }
+}
+
+static void SilenceSamples(ALfloat *dst, ALuint samples)
+{
+    ALuint i;
+    for(i = 0;i < samples;i++)
+        dst[i] = 0.0f;
+}
+
+
+static const ALfloat *DoFilters(ALfilterState *lpfilter, ALfilterState *hpfilter,
+                                ALfloat *restrict dst, const ALfloat *restrict src,
+                                ALuint numsamples, enum ActiveFilters type)
+{
+    ALuint i;
+    switch(type)
+    {
+        case AF_None:
+            break;
+
+        case AF_LowPass:
+            ALfilterState_process(lpfilter, dst, src, numsamples);
+            return dst;
+        case AF_HighPass:
+            ALfilterState_process(hpfilter, dst, src, numsamples);
+            return dst;
+
+        case AF_BandPass:
+            for(i = 0;i < numsamples;)
+            {
+                ALfloat temp[64];
+                ALuint todo = minu(64, numsamples-i);
+
+                ALfilterState_process(lpfilter, temp, src+i, todo);
+                ALfilterState_process(hpfilter, dst+i, temp, todo);
+                i += todo;
+            }
+            return dst;
+    }
+    return src;
+}
+
+
+ALvoid MixSource(ALactivesource *src, ALCdevice *Device, ALuint SamplesToDo)
+{
+    MixerFunc Mix;
+    HrtfMixerFunc HrtfMix;
+    ResamplerFunc Resample;
+    ALsource *Source = src->Source;
+    ALbufferlistitem *BufferListItem;
+    ALuint DataPosInt, DataPosFrac;
+    ALboolean Looping;
+    ALuint increment;
+    enum Resampler Resampler;
+    ALenum State;
+    ALuint OutPos;
+    ALuint NumChannels;
+    ALuint SampleSize;
+    ALint64 DataSize64;
+    ALuint chan, j;
+
+    /* Get source info */
+    State          = Source->state;
+    BufferListItem = ATOMIC_LOAD(&Source->current_buffer);
+    DataPosInt     = Source->position;
+    DataPosFrac    = Source->position_fraction;
+    Looping        = Source->Looping;
+    increment      = src->Step;
+    Resampler      = (increment==FRACTIONONE) ? PointResampler : Source->Resampler;
+    NumChannels    = Source->NumChannels;
+    SampleSize     = Source->SampleSize;
+
+    Mix = SelectMixer();
+    HrtfMix = SelectHrtfMixer();
+    Resample = SelectResampler(Resampler, increment);
+
+    OutPos = 0;
+    do {
+        const ALuint BufferPrePadding = ResamplerPrePadding[Resampler];
+        const ALuint BufferPadding = ResamplerPadding[Resampler];
+        ALuint SrcBufferSize, DstBufferSize;
+
+        /* Figure out how many buffer samples will be needed */
+        DataSize64  = SamplesToDo-OutPos;
+        DataSize64 *= increment;
+        DataSize64 += DataPosFrac+FRACTIONMASK;
+        DataSize64 >>= FRACTIONBITS;
+        DataSize64 += BufferPadding+BufferPrePadding;
+
+        SrcBufferSize = (ALuint)mini64(DataSize64, BUFFERSIZE);
+
+        /* Figure out how many samples we can actually mix from this. */
+        DataSize64  = SrcBufferSize;
+        DataSize64 -= BufferPadding+BufferPrePadding;
+        DataSize64 <<= FRACTIONBITS;
+        DataSize64 -= DataPosFrac;
+
+        DstBufferSize = (ALuint)((DataSize64+(increment-1)) / increment);
+        DstBufferSize = minu(DstBufferSize, (SamplesToDo-OutPos));
+
+        /* Some mixers like having a multiple of 4, so try to give that unless
+         * this is the last update. */
+        if(OutPos+DstBufferSize < SamplesToDo)
+            DstBufferSize &= ~3;
+
+        for(chan = 0;chan < NumChannels;chan++)
+        {
+            const ALfloat *ResampledData;
+            ALfloat *SrcData = Device->SourceData;
+            ALuint SrcDataSize = 0;
+
+            if(Source->SourceType == AL_STATIC)
+            {
+                const ALbuffer *ALBuffer = BufferListItem->buffer;
+                const ALubyte *Data = ALBuffer->data;
+                ALuint DataSize;
+                ALuint pos;
+
+                /* If current pos is beyond the loop range, do not loop */
+                if(Looping == AL_FALSE || DataPosInt >= (ALuint)ALBuffer->LoopEnd)
+                {
+                    Looping = AL_FALSE;
+
+                    if(DataPosInt >= BufferPrePadding)
+                        pos = DataPosInt - BufferPrePadding;
+                    else
+                    {
+                        DataSize = BufferPrePadding - DataPosInt;
+                        DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
+
+                        SilenceSamples(&SrcData[SrcDataSize], DataSize);
+                        SrcDataSize += DataSize;
+
+                        pos = 0;
+                    }
+
+                    /* Copy what's left to play in the source buffer, and clear the
+                     * rest of the temp buffer */
+                    DataSize = minu(SrcBufferSize - SrcDataSize, ALBuffer->SampleLen - pos);
+
+                    LoadSamples(&SrcData[SrcDataSize], &Data[(pos*NumChannels + chan)*SampleSize],
+                                NumChannels, ALBuffer->FmtType, DataSize);
+                    SrcDataSize += DataSize;
+
+                    SilenceSamples(&SrcData[SrcDataSize], SrcBufferSize - SrcDataSize);
+                    SrcDataSize += SrcBufferSize - SrcDataSize;
+                }
+                else
+                {
+                    ALuint LoopStart = ALBuffer->LoopStart;
+                    ALuint LoopEnd   = ALBuffer->LoopEnd;
+
+                    if(DataPosInt >= LoopStart)
+                    {
+                        pos = DataPosInt-LoopStart;
+                        while(pos < BufferPrePadding)
+                            pos += LoopEnd-LoopStart;
+                        pos -= BufferPrePadding;
+                        pos += LoopStart;
+                    }
+                    else if(DataPosInt >= BufferPrePadding)
+                        pos = DataPosInt - BufferPrePadding;
+                    else
+                    {
+                        DataSize = BufferPrePadding - DataPosInt;
+                        DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
+
+                        SilenceSamples(&SrcData[SrcDataSize], DataSize);
+                        SrcDataSize += DataSize;
+
+                        pos = 0;
+                    }
+
+                    /* Copy what's left of this loop iteration, then copy repeats
+                     * of the loop section */
+                    DataSize = LoopEnd - pos;
+                    DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
+
+                    LoadSamples(&SrcData[SrcDataSize], &Data[(pos*NumChannels + chan)*SampleSize],
+                                NumChannels, ALBuffer->FmtType, DataSize);
+                    SrcDataSize += DataSize;
+
+                    DataSize = LoopEnd-LoopStart;
+                    while(SrcBufferSize > SrcDataSize)
+                    {
+                        DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
+
+                        LoadSamples(&SrcData[SrcDataSize], &Data[(LoopStart*NumChannels + chan)*SampleSize],
+                                    NumChannels, ALBuffer->FmtType, DataSize);
+                        SrcDataSize += DataSize;
+                    }
+                }
+            }
+            else
+            {
+                /* Crawl the buffer queue to fill in the temp buffer */
+                ALbufferlistitem *tmpiter = BufferListItem;
+                ALuint pos;
+
+                if(DataPosInt >= BufferPrePadding)
+                    pos = DataPosInt - BufferPrePadding;
+                else
+                {
+                    pos = BufferPrePadding - DataPosInt;
+                    while(pos > 0)
+                    {
+                        ALbufferlistitem *prev;
+                        if((prev=tmpiter->prev) != NULL)
+                            tmpiter = prev;
+                        else if(Looping)
+                        {
+                            while(tmpiter->next)
+                                tmpiter = tmpiter->next;
+                        }
+                        else
+                        {
+                            ALuint DataSize = minu(SrcBufferSize - SrcDataSize, pos);
+
+                            SilenceSamples(&SrcData[SrcDataSize], DataSize);
+                            SrcDataSize += DataSize;
+
+                            pos = 0;
+                            break;
+                        }
+
+                        if(tmpiter->buffer)
+                        {
+                            if((ALuint)tmpiter->buffer->SampleLen > pos)
+                            {
+                                pos = tmpiter->buffer->SampleLen - pos;
+                                break;
+                            }
+                            pos -= tmpiter->buffer->SampleLen;
+                        }
+                    }
+                }
+
+                while(tmpiter && SrcBufferSize > SrcDataSize)
+                {
+                    const ALbuffer *ALBuffer;
+                    if((ALBuffer=tmpiter->buffer) != NULL)
+                    {
+                        const ALubyte *Data = ALBuffer->data;
+                        ALuint DataSize = ALBuffer->SampleLen;
+
+                        /* Skip the data already played */
+                        if(DataSize <= pos)
+                            pos -= DataSize;
+                        else
+                        {
+                            Data += (pos*NumChannels + chan)*SampleSize;
+                            DataSize -= pos;
+                            pos -= pos;
+
+                            DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
+                            LoadSamples(&SrcData[SrcDataSize], Data, NumChannels,
+                                        ALBuffer->FmtType, DataSize);
+                            SrcDataSize += DataSize;
+                        }
+                    }
+                    tmpiter = tmpiter->next;
+                    if(!tmpiter && Looping)
+                        tmpiter = ATOMIC_LOAD(&Source->queue);
+                    else if(!tmpiter)
+                    {
+                        SilenceSamples(&SrcData[SrcDataSize], SrcBufferSize - SrcDataSize);
+                        SrcDataSize += SrcBufferSize - SrcDataSize;
+                    }
+                }
+            }
+
+            /* Now resample, then filter and mix to the appropriate outputs. */
+            ResampledData = Resample(
+                &SrcData[BufferPrePadding], DataPosFrac, increment,
+                Device->ResampledData, DstBufferSize
+            );
+            {
+                DirectParams *parms = &src->Direct;
+                const ALfloat *samples;
+
+                samples = DoFilters(
+                    &parms->Filters[chan].LowPass, &parms->Filters[chan].HighPass,
+                    Device->FilteredData, ResampledData, DstBufferSize,
+                    parms->Filters[chan].ActiveType
+                );
+                if(!src->IsHrtf)
+                    Mix(samples, MaxChannels, parms->OutBuffer, parms->Mix.Gains[chan],
+                        parms->Counter, OutPos, DstBufferSize);
+                else
+                    HrtfMix(parms->OutBuffer, samples, parms->Counter, src->Offset,
+                            OutPos, parms->Mix.Hrtf.IrSize, &parms->Mix.Hrtf.Params[chan],
+                            &parms->Mix.Hrtf.State[chan], DstBufferSize);
+            }
+
+            for(j = 0;j < Device->NumAuxSends;j++)
+            {
+                SendParams *parms = &src->Send[j];
+                const ALfloat *samples;
+
+                if(!parms->OutBuffer)
+                    continue;
+
+                samples = DoFilters(
+                    &parms->Filters[chan].LowPass, &parms->Filters[chan].HighPass,
+                    Device->FilteredData, ResampledData, DstBufferSize,
+                    parms->Filters[chan].ActiveType
+                );
+                Mix(samples, 1, parms->OutBuffer, &parms->Gain,
+                    parms->Counter, OutPos, DstBufferSize);
+            }
+        }
+        /* Update positions */
+        DataPosFrac += increment*DstBufferSize;
+        DataPosInt  += DataPosFrac>>FRACTIONBITS;
+        DataPosFrac &= FRACTIONMASK;
+
+        OutPos += DstBufferSize;
+        src->Offset += DstBufferSize;
+        src->Direct.Counter = maxu(src->Direct.Counter, DstBufferSize) - DstBufferSize;
+        for(j = 0;j < Device->NumAuxSends;j++)
+            src->Send[j].Counter = maxu(src->Send[j].Counter, DstBufferSize) - DstBufferSize;
+
+        /* Handle looping sources */
+        while(1)
+        {
+            const ALbuffer *ALBuffer;
+            ALuint DataSize = 0;
+            ALuint LoopStart = 0;
+            ALuint LoopEnd = 0;
+
+            if((ALBuffer=BufferListItem->buffer) != NULL)
+            {
+                DataSize = ALBuffer->SampleLen;
+                LoopStart = ALBuffer->LoopStart;
+                LoopEnd = ALBuffer->LoopEnd;
+                if(LoopEnd > DataPosInt)
+                    break;
+            }
+
+            if(Looping && Source->SourceType == AL_STATIC)
+            {
+                assert(LoopEnd > LoopStart);
+                DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
+                break;
+            }
+
+            if(DataSize > DataPosInt)
+                break;
+
+            if(!(BufferListItem=BufferListItem->next))
+            {
+                if(Looping)
+                    BufferListItem = ATOMIC_LOAD(&Source->queue);
+                else
+                {
+                    State = AL_STOPPED;
+                    BufferListItem = NULL;
+                    DataPosInt = 0;
+                    DataPosFrac = 0;
+                    break;
+                }
+            }
+
+            DataPosInt -= DataSize;
+        }
+    } while(State == AL_PLAYING && OutPos < SamplesToDo);
+
+    /* Update source info */
+    Source->state             = State;
+    ATOMIC_STORE(&Source->current_buffer, BufferListItem);
+    Source->position          = DataPosInt;
+    Source->position_fraction = DataPosFrac;
+}
@@ -0,0 +1,126 @@
+#include "config.h"
+
+#include <assert.h>
+
+#include "alMain.h"
+#include "alu.h"
+#include "alSource.h"
+#include "alAuxEffectSlot.h"
+
+
+static inline ALfloat point32(const ALfloat *vals, ALuint UNUSED(frac))
+{ return vals[0]; }
+static inline ALfloat lerp32(const ALfloat *vals, ALuint frac)
+{ return lerp(vals[0], vals[1], frac * (1.0f/FRACTIONONE)); }
+static inline ALfloat cubic32(const ALfloat *vals, ALuint frac)
+{ return cubic(vals[-1], vals[0], vals[1], vals[2], frac * (1.0f/FRACTIONONE)); }
+
+const ALfloat *Resample_copy32_C(const ALfloat *src, ALuint UNUSED(frac),
+  ALuint increment, ALfloat *restrict dst, ALuint numsamples)
+{
+    assert(increment==FRACTIONONE);
+#if defined(HAVE_SSE) || defined(HAVE_NEON)
+    /* Avoid copying the source data if it's aligned like the destination. */
+    if((((intptr_t)src)&15) == (((intptr_t)dst)&15))
+        return src;
+#endif
+    memcpy(dst, src, numsamples*sizeof(ALfloat));
+    return dst;
+}
+
+#define DECL_TEMPLATE(Sampler)                                                \
+const ALfloat *Resample_##Sampler##_C(const ALfloat *src, ALuint frac,        \
+  ALuint increment, ALfloat *restrict dst, ALuint numsamples)                 \
+{                                                                             \
+    ALuint i;                                                                 \
+    for(i = 0;i < numsamples;i++)                                             \
+    {                                                                         \
+        dst[i] = Sampler(src, frac);                                          \
+                                                                              \
+        frac += increment;                                                    \
+        src  += frac>>FRACTIONBITS;                                           \
+        frac &= FRACTIONMASK;                                                 \
+    }                                                                         \
+    return dst;                                                               \
+}
+
+DECL_TEMPLATE(point32)
+DECL_TEMPLATE(lerp32)
+DECL_TEMPLATE(cubic32)
+
+#undef DECL_TEMPLATE
+
+
+void ALfilterState_processC(ALfilterState *filter, ALfloat *restrict dst, const ALfloat *src, ALuint numsamples)
+{
+    ALuint i;
+    for(i = 0;i < numsamples;i++)
+        *(dst++) = ALfilterState_processSingle(filter, *(src++));
+}
+
+
+static inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*restrict Values)[2],
+                                   const ALuint IrSize,
+                                   ALfloat (*restrict Coeffs)[2],
+                                   const ALfloat (*restrict CoeffStep)[2],
+                                   ALfloat left, ALfloat right)
+{
+    ALuint c;
+    for(c = 0;c < IrSize;c++)
+    {
+        const ALuint off = (Offset+c)&HRIR_MASK;
+        Values[off][0] += Coeffs[c][0] * left;
+        Values[off][1] += Coeffs[c][1] * right;
+        Coeffs[c][0] += CoeffStep[c][0];
+        Coeffs[c][1] += CoeffStep[c][1];
+    }
+}
+
+static inline void ApplyCoeffs(ALuint Offset, ALfloat (*restrict Values)[2],
+                               const ALuint IrSize,
+                               ALfloat (*restrict Coeffs)[2],
+                               ALfloat left, ALfloat right)
+{
+    ALuint c;
+    for(c = 0;c < IrSize;c++)
+    {
+        const ALuint off = (Offset+c)&HRIR_MASK;
+        Values[off][0] += Coeffs[c][0] * left;
+        Values[off][1] += Coeffs[c][1] * right;
+    }
+}
+
+#define SUFFIX C
+#include "mixer_inc.c"
+#undef SUFFIX
+
+
+void Mix_C(const ALfloat *data, ALuint OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+           MixGains *Gains, ALuint Counter, ALuint OutPos, ALuint BufferSize)
+{
+    ALfloat gain, step;
+    ALuint c;
+
+    for(c = 0;c < OutChans;c++)
+    {
+        ALuint pos = 0;
+        gain = Gains[c].Current;
+        step = Gains[c].Step;
+        if(step != 1.0f && Counter > 0)
+        {
+            for(;pos < BufferSize && pos < Counter;pos++)
+            {
+                OutBuffer[c][OutPos+pos] += data[pos]*gain;
+                gain *= step;
+            }
+            if(pos == Counter)
+                gain = Gains[c].Target;
+            Gains[c].Current = gain;
+        }
+
+        if(!(gain > GAIN_SILENCE_THRESHOLD))
+            continue;
+        for(;pos < BufferSize;pos++)
+            OutBuffer[c][OutPos+pos] += data[pos]*gain;
+    }
+}
@@ -0,0 +1,65 @@
+#ifndef MIXER_DEFS_H
+#define MIXER_DEFS_H
+
+#include "AL/alc.h"
+#include "AL/al.h"
+#include "alMain.h"
+#include "alu.h"
+
+struct MixGains;
+
+struct HrtfParams;
+struct HrtfState;
+
+/* C resamplers */
+const ALfloat *Resample_copy32_C(const ALfloat *src, ALuint frac, ALuint increment, ALfloat *restrict dst, ALuint dstlen);
+const ALfloat *Resample_point32_C(const ALfloat *src, ALuint frac, ALuint increment, ALfloat *restrict dst, ALuint dstlen);
+const ALfloat *Resample_lerp32_C(const ALfloat *src, ALuint frac, ALuint increment, ALfloat *restrict dst, ALuint dstlen);
+const ALfloat *Resample_cubic32_C(const ALfloat *src, ALuint frac, ALuint increment, ALfloat *restrict dst, ALuint dstlen);
+
+
+/* C mixers */
+void MixHrtf_C(ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat *data,
+               ALuint Counter, ALuint Offset, ALuint OutPos, const ALuint IrSize,
+               const struct HrtfParams *hrtfparams, struct HrtfState *hrtfstate,
+               ALuint BufferSize);
+void Mix_C(const ALfloat *data, ALuint OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+                 struct MixGains *Gains, ALuint Counter, ALuint OutPos, ALuint BufferSize);
+
+/* SSE mixers */
+void MixHrtf_SSE(ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat *data,
+                 ALuint Counter, ALuint Offset, ALuint OutPos, const ALuint IrSize,
+                 const struct HrtfParams *hrtfparams, struct HrtfState *hrtfstate,
+                 ALuint BufferSize);
+void Mix_SSE(const ALfloat *data, ALuint OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+             struct MixGains *Gains, ALuint Counter, ALuint OutPos, ALuint BufferSize);
+
+/* SSE resamplers */
+inline void InitiatePositionArrays(ALuint frac, ALuint increment, ALuint *frac_arr, ALuint *pos_arr, ALuint size)
+{
+    ALuint i;
+
+    pos_arr[0] = 0;
+    frac_arr[0] = frac;
+    for(i = 1;i < size;i++)
+    {
+        ALuint frac_tmp = frac_arr[i-1] + increment;
+        pos_arr[i] = pos_arr[i-1] + (frac_tmp>>FRACTIONBITS);
+        frac_arr[i] = frac_tmp&FRACTIONMASK;
+    }
+}
+
+const ALfloat *Resample_lerp32_SSE2(const ALfloat *src, ALuint frac, ALuint increment,
+                                    ALfloat *restrict dst, ALuint numsamples);
+const ALfloat *Resample_lerp32_SSE41(const ALfloat *src, ALuint frac, ALuint increment,
+                                     ALfloat *restrict dst, ALuint numsamples);
+
+/* Neon mixers */
+void MixHrtf_Neon(ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat *data,
+                  ALuint Counter, ALuint Offset, ALuint OutPos, const ALuint IrSize,
+                  const struct HrtfParams *hrtfparams, struct HrtfState *hrtfstate,
+                  ALuint BufferSize);
+void Mix_Neon(const ALfloat *data, ALuint OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+              struct MixGains *Gains, ALuint Counter, ALuint OutPos, ALuint BufferSize);
+
+#endif /* MIXER_DEFS_H */
@@ -0,0 +1,93 @@
+#include "config.h"
+
+#include "alMain.h"
+#include "alSource.h"
+
+#include "hrtf.h"
+#include "mixer_defs.h"
+#include "align.h"
+
+
+#define REAL_MERGE(a,b) a##b
+#define MERGE(a,b) REAL_MERGE(a,b)
+
+#define MixHrtf MERGE(MixHrtf_,SUFFIX)
+
+
+static inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*restrict Values)[2],
+                                   const ALuint irSize,
+                                   ALfloat (*restrict Coeffs)[2],
+                                   const ALfloat (*restrict CoeffStep)[2],
+                                   ALfloat left, ALfloat right);
+static inline void ApplyCoeffs(ALuint Offset, ALfloat (*restrict Values)[2],
+                               const ALuint irSize,
+                               ALfloat (*restrict Coeffs)[2],
+                               ALfloat left, ALfloat right);
+
+
+void MixHrtf(ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat *data,
+             ALuint Counter, ALuint Offset, ALuint OutPos, const ALuint IrSize,
+             const HrtfParams *hrtfparams, HrtfState *hrtfstate, ALuint BufferSize)
+{
+    alignas(16) ALfloat Coeffs[HRIR_LENGTH][2];
+    ALuint Delay[2];
+    ALfloat left, right;
+    ALuint pos;
+    ALuint c;
+
+    for(c = 0;c < IrSize;c++)
+    {
+        Coeffs[c][0] = hrtfparams->Coeffs[c][0] - (hrtfparams->CoeffStep[c][0]*Counter);
+        Coeffs[c][1] = hrtfparams->Coeffs[c][1] - (hrtfparams->CoeffStep[c][1]*Counter);
+    }
+    Delay[0] = hrtfparams->Delay[0] - (hrtfparams->DelayStep[0]*Counter);
+    Delay[1] = hrtfparams->Delay[1] - (hrtfparams->DelayStep[1]*Counter);
+
+    for(pos = 0;pos < BufferSize && pos < Counter;pos++)
+    {
+        hrtfstate->History[Offset&SRC_HISTORY_MASK] = data[pos];
+        left  = lerp(hrtfstate->History[(Offset-(Delay[0]>>HRTFDELAY_BITS))&SRC_HISTORY_MASK],
+                     hrtfstate->History[(Offset-(Delay[0]>>HRTFDELAY_BITS)-1)&SRC_HISTORY_MASK],
+                     (Delay[0]&HRTFDELAY_MASK)*(1.0f/HRTFDELAY_FRACONE));
+        right = lerp(hrtfstate->History[(Offset-(Delay[1]>>HRTFDELAY_BITS))&SRC_HISTORY_MASK],
+                     hrtfstate->History[(Offset-(Delay[1]>>HRTFDELAY_BITS)-1)&SRC_HISTORY_MASK],
+                     (Delay[1]&HRTFDELAY_MASK)*(1.0f/HRTFDELAY_FRACONE));
+
+        Delay[0] += hrtfparams->DelayStep[0];
+        Delay[1] += hrtfparams->DelayStep[1];
+
+        hrtfstate->Values[(Offset+IrSize)&HRIR_MASK][0] = 0.0f;
+        hrtfstate->Values[(Offset+IrSize)&HRIR_MASK][1] = 0.0f;
+        Offset++;
+
+        ApplyCoeffsStep(Offset, hrtfstate->Values, IrSize, Coeffs, hrtfparams->CoeffStep, left, right);
+        OutBuffer[FrontLeft][OutPos]  += hrtfstate->Values[Offset&HRIR_MASK][0];
+        OutBuffer[FrontRight][OutPos] += hrtfstate->Values[Offset&HRIR_MASK][1];
+        OutPos++;
+    }
+
+    Delay[0] >>= HRTFDELAY_BITS;
+    Delay[1] >>= HRTFDELAY_BITS;
+    for(;pos < BufferSize;pos++)
+    {
+        hrtfstate->History[Offset&SRC_HISTORY_MASK] = data[pos];
+        left = hrtfstate->History[(Offset-Delay[0])&SRC_HISTORY_MASK];
+        right = hrtfstate->History[(Offset-Delay[1])&SRC_HISTORY_MASK];
+
+        hrtfstate->Values[(Offset+IrSize)&HRIR_MASK][0] = 0.0f;
+        hrtfstate->Values[(Offset+IrSize)&HRIR_MASK][1] = 0.0f;
+        Offset++;
+
+        ApplyCoeffs(Offset, hrtfstate->Values, IrSize, Coeffs, left, right);
+        OutBuffer[FrontLeft][OutPos]  += hrtfstate->Values[Offset&HRIR_MASK][0];
+        OutBuffer[FrontRight][OutPos] += hrtfstate->Values[Offset&HRIR_MASK][1];
+
+        OutPos++;
+    }
+}
+
+
+#undef MixHrtf
+
+#undef MERGE
+#undef REAL_MERGE
@@ -0,0 +1,118 @@
+#include "config.h"
+
+#include <arm_neon.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alu.h"
+#include "hrtf.h"
+
+
+static inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*restrict Values)[2],
+                                   const ALuint IrSize,
+                                   ALfloat (*restrict Coeffs)[2],
+                                   const ALfloat (*restrict CoeffStep)[2],
+                                   ALfloat left, ALfloat right)
+{
+    ALuint c;
+    float32x4_t leftright4;
+    {
+        float32x2_t leftright2 = vdup_n_f32(0.0);
+        leftright2 = vset_lane_f32(left, leftright2, 0);
+        leftright2 = vset_lane_f32(right, leftright2, 1);
+        leftright4 = vcombine_f32(leftright2, leftright2);
+    }
+    for(c = 0;c < IrSize;c += 2)
+    {
+        const ALuint o0 = (Offset+c)&HRIR_MASK;
+        const ALuint o1 = (o0+1)&HRIR_MASK;
+        float32x4_t vals = vcombine_f32(vld1_f32((float32_t*)&Values[o0][0]),
+                                        vld1_f32((float32_t*)&Values[o1][0]));
+        float32x4_t coefs = vld1q_f32((float32_t*)&Coeffs[c][0]);
+        float32x4_t deltas = vld1q_f32(&CoeffStep[c][0]);
+
+        vals = vmlaq_f32(vals, coefs, leftright4);
+        coefs = vaddq_f32(coefs, deltas);
+
+        vst1_f32((float32_t*)&Values[o0][0], vget_low_f32(vals));
+        vst1_f32((float32_t*)&Values[o1][0], vget_high_f32(vals));
+        vst1q_f32(&Coeffs[c][0], coefs);
+    }
+}
+
+static inline void ApplyCoeffs(ALuint Offset, ALfloat (*restrict Values)[2],
+                               const ALuint IrSize,
+                               ALfloat (*restrict Coeffs)[2],
+                               ALfloat left, ALfloat right)
+{
+    ALuint c;
+    float32x4_t leftright4;
+    {
+        float32x2_t leftright2 = vdup_n_f32(0.0);
+        leftright2 = vset_lane_f32(left, leftright2, 0);
+        leftright2 = vset_lane_f32(right, leftright2, 1);
+        leftright4 = vcombine_f32(leftright2, leftright2);
+    }
+    for(c = 0;c < IrSize;c += 2)
+    {
+        const ALuint o0 = (Offset+c)&HRIR_MASK;
+        const ALuint o1 = (o0+1)&HRIR_MASK;
+        float32x4_t vals = vcombine_f32(vld1_f32((float32_t*)&Values[o0][0]),
+                                        vld1_f32((float32_t*)&Values[o1][0]));
+        float32x4_t coefs = vld1q_f32((float32_t*)&Coeffs[c][0]);
+
+        vals = vmlaq_f32(vals, coefs, leftright4);
+
+        vst1_f32((float32_t*)&Values[o0][0], vget_low_f32(vals));
+        vst1_f32((float32_t*)&Values[o1][0], vget_high_f32(vals));
+    }
+}
+
+
+#define SUFFIX Neon
+#include "mixer_inc.c"
+#undef SUFFIX
+
+
+void MixDirect_Neon(const ALfloat *data, ALuint OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+                    MixGains *Gains, ALuint Counter, ALuint OutPos, ALuint BufferSize)
+{
+    ALfloat gain, step;
+    float32x4_t gain4;
+    ALuint c;
+
+    for(c = 0;c < OutChans;c++)
+    {
+        ALuint pos = 0;
+        gain = Gains[c].Current;
+        step = Gains[c].Step;
+        if(step != 1.0f && Counter > 0)
+        {
+            for(;pos < BufferSize && pos < Counter;pos++)
+            {
+                OutBuffer[c][OutPos+pos] += data[pos]*gain;
+                gain *= step;
+            }
+            if(pos == Counter)
+                gain = Gains[c].Target;
+            Gains[c].Current = gain;
+            /* Mix until pos is aligned with 4 or the mix is done. */
+            for(;pos < BufferSize && (pos&3) != 0;pos++)
+                OutBuffer[c][OutPos+pos] += data[pos]*gain;
+        }
+
+        if(!(gain > GAIN_SILENCE_THRESHOLD))
+            continue;
+        gain4 = vdupq_n_f32(gain);
+        for(;BufferSize-pos > 3;pos += 4)
+        {
+            const float32x4_t val4 = vld1q_f32(&data[pos]);
+            float32x4_t dry4 = vld1q_f32(&OutBuffer[c][OutPos+pos]);
+            dry4 = vaddq_f32(dry4, vmulq_f32(val4, gain4));
+            vst1q_f32(&OutBuffer[c][OutPos+pos], dry4);
+        }
+        for(;pos < BufferSize;pos++)
+            OutBuffer[c][OutPos+pos] += data[pos]*gain;
+    }
+}
@@ -0,0 +1,202 @@
+#include "config.h"
+
+#ifdef IN_IDE_PARSER
+/* KDevelop's parser won't recognize these defines that get added by the -msse
+ * switch used to compile this source. Without them, xmmintrin.h fails to
+ * declare anything. */
+#define __MMX__
+#define __SSE__
+#endif
+#include <xmmintrin.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alu.h"
+
+#include "alSource.h"
+#include "alAuxEffectSlot.h"
+#include "mixer_defs.h"
+
+
+static inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*restrict Values)[2],
+                                   const ALuint IrSize,
+                                   ALfloat (*restrict Coeffs)[2],
+                                   const ALfloat (*restrict CoeffStep)[2],
+                                   ALfloat left, ALfloat right)
+{
+    const __m128 lrlr = _mm_setr_ps(left, right, left, right);
+    __m128 coeffs, deltas, imp0, imp1;
+    __m128 vals = _mm_setzero_ps();
+    ALuint i;
+
+    if((Offset&1))
+    {
+        const ALuint o0 = Offset&HRIR_MASK;
+        const ALuint o1 = (Offset+IrSize-1)&HRIR_MASK;
+
+        coeffs = _mm_load_ps(&Coeffs[0][0]);
+        deltas = _mm_load_ps(&CoeffStep[0][0]);
+        vals = _mm_loadl_pi(vals, (__m64*)&Values[o0][0]);
+        imp0 = _mm_mul_ps(lrlr, coeffs);
+        coeffs = _mm_add_ps(coeffs, deltas);
+        vals = _mm_add_ps(imp0, vals);
+        _mm_store_ps(&Coeffs[0][0], coeffs);
+        _mm_storel_pi((__m64*)&Values[o0][0], vals);
+        for(i = 1;i < IrSize-1;i += 2)
+        {
+            const ALuint o2 = (Offset+i)&HRIR_MASK;
+
+            coeffs = _mm_load_ps(&Coeffs[i+1][0]);
+            deltas = _mm_load_ps(&CoeffStep[i+1][0]);
+            vals = _mm_load_ps(&Values[o2][0]);
+            imp1 = _mm_mul_ps(lrlr, coeffs);
+            coeffs = _mm_add_ps(coeffs, deltas);
+            imp0 = _mm_shuffle_ps(imp0, imp1, _MM_SHUFFLE(1, 0, 3, 2));
+            vals = _mm_add_ps(imp0, vals);
+            _mm_store_ps(&Coeffs[i+1][0], coeffs);
+            _mm_store_ps(&Values[o2][0], vals);
+            imp0 = imp1;
+        }
+        vals = _mm_loadl_pi(vals, (__m64*)&Values[o1][0]);
+        imp0 = _mm_movehl_ps(imp0, imp0);
+        vals = _mm_add_ps(imp0, vals);
+        _mm_storel_pi((__m64*)&Values[o1][0], vals);
+    }
+    else
+    {
+        for(i = 0;i < IrSize;i += 2)
+        {
+            const ALuint o = (Offset + i)&HRIR_MASK;
+
+            coeffs = _mm_load_ps(&Coeffs[i][0]);
+            deltas = _mm_load_ps(&CoeffStep[i][0]);
+            vals = _mm_load_ps(&Values[o][0]);
+            imp0 = _mm_mul_ps(lrlr, coeffs);
+            coeffs = _mm_add_ps(coeffs, deltas);
+            vals = _mm_add_ps(imp0, vals);
+            _mm_store_ps(&Coeffs[i][0], coeffs);
+            _mm_store_ps(&Values[o][0], vals);
+        }
+    }
+}
+
+static inline void ApplyCoeffs(ALuint Offset, ALfloat (*restrict Values)[2],
+                               const ALuint IrSize,
+                               ALfloat (*restrict Coeffs)[2],
+                               ALfloat left, ALfloat right)
+{
+    const __m128 lrlr = _mm_setr_ps(left, right, left, right);
+    __m128 vals = _mm_setzero_ps();
+    __m128 coeffs;
+    ALuint i;
+
+    if((Offset&1))
+    {
+        const ALuint o0 = Offset&HRIR_MASK;
+        const ALuint o1 = (Offset+IrSize-1)&HRIR_MASK;
+        __m128 imp0, imp1;
+
+        coeffs = _mm_load_ps(&Coeffs[0][0]);
+        vals = _mm_loadl_pi(vals, (__m64*)&Values[o0][0]);
+        imp0 = _mm_mul_ps(lrlr, coeffs);
+        vals = _mm_add_ps(imp0, vals);
+        _mm_storel_pi((__m64*)&Values[o0][0], vals);
+        for(i = 1;i < IrSize-1;i += 2)
+        {
+            const ALuint o2 = (Offset+i)&HRIR_MASK;
+
+            coeffs = _mm_load_ps(&Coeffs[i+1][0]);
+            vals = _mm_load_ps(&Values[o2][0]);
+            imp1 = _mm_mul_ps(lrlr, coeffs);
+            imp0 = _mm_shuffle_ps(imp0, imp1, _MM_SHUFFLE(1, 0, 3, 2));
+            vals = _mm_add_ps(imp0, vals);
+            _mm_store_ps(&Values[o2][0], vals);
+            imp0 = imp1;
+        }
+        vals = _mm_loadl_pi(vals, (__m64*)&Values[o1][0]);
+        imp0 = _mm_movehl_ps(imp0, imp0);
+        vals = _mm_add_ps(imp0, vals);
+        _mm_storel_pi((__m64*)&Values[o1][0], vals);
+    }
+    else
+    {
+        for(i = 0;i < IrSize;i += 2)
+        {
+            const ALuint o = (Offset + i)&HRIR_MASK;
+
+            coeffs = _mm_load_ps(&Coeffs[i][0]);
+            vals = _mm_load_ps(&Values[o][0]);
+            vals = _mm_add_ps(vals, _mm_mul_ps(lrlr, coeffs));
+            _mm_store_ps(&Values[o][0], vals);
+        }
+    }
+}
+
+#define SUFFIX SSE
+#include "mixer_inc.c"
+#undef SUFFIX
+
+
+void Mix_SSE(const ALfloat *data, ALuint OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
+             MixGains *Gains, ALuint Counter, ALuint OutPos, ALuint BufferSize)
+{
+    ALfloat gain, step;
+    __m128 gain4, step4;
+    ALuint c;
+
+    for(c = 0;c < OutChans;c++)
+    {
+        ALuint pos = 0;
+        gain = Gains[c].Current;
+        step = Gains[c].Step;
+        if(step != 1.0f && Counter > 0)
+        {
+            /* Mix with applying gain steps in aligned multiples of 4. */
+            if(BufferSize-pos > 3 && Counter-pos > 3)
+            {
+                gain4 = _mm_setr_ps(
+                    gain,
+                    gain * step,
+                    gain * step * step,
+                    gain * step * step * step
+                );
+                step4 = _mm_set1_ps(step * step * step * step);
+                do {
+                    const __m128 val4 = _mm_load_ps(&data[pos]);
+                    __m128 dry4 = _mm_load_ps(&OutBuffer[c][OutPos+pos]);
+                    dry4 = _mm_add_ps(dry4, _mm_mul_ps(val4, gain4));
+                    gain4 = _mm_mul_ps(gain4, step4);
+                    _mm_store_ps(&OutBuffer[c][OutPos+pos], dry4);
+                    pos += 4;
+                } while(BufferSize-pos > 3 && Counter-pos > 3);
+                gain = _mm_cvtss_f32(gain4);
+            }
+            /* Mix with applying left over gain steps that aren't aligned multiples of 4. */
+            for(;pos < BufferSize && pos < Counter;pos++)
+            {
+                OutBuffer[c][OutPos+pos] += data[pos]*gain;
+                gain *= step;
+            }
+            if(pos == Counter)
+                gain = Gains[c].Target;
+            Gains[c].Current = gain;
+            /* Mix until pos is aligned with 4 or the mix is done. */
+            for(;pos < BufferSize && (pos&3) != 0;pos++)
+                OutBuffer[c][OutPos+pos] += data[pos]*gain;
+        }
+
+        if(!(gain > GAIN_SILENCE_THRESHOLD))
+            continue;
+        gain4 = _mm_set1_ps(gain);
+        for(;BufferSize-pos > 3;pos += 4)
+        {
+            const __m128 val4 = _mm_load_ps(&data[pos]);
+            __m128 dry4 = _mm_load_ps(&OutBuffer[c][OutPos+pos]);
+            dry4 = _mm_add_ps(dry4, _mm_mul_ps(val4, gain4));
+            _mm_store_ps(&OutBuffer[c][OutPos+pos], dry4);
+        }
+        for(;pos < BufferSize;pos++)
+            OutBuffer[c][OutPos+pos] += data[pos]*gain;
+    }
+}
@@ -0,0 +1,78 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2014 by Timothy Arceri <t_arceri@yahoo.com.au>.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+#include "alu.h"
+#include "mixer_defs.h"
+
+
+const ALfloat *Resample_lerp32_SSE2(const ALfloat *src, ALuint frac, ALuint increment,
+                                    ALfloat *restrict dst, ALuint numsamples)
+{
+    const __m128i increment4 = _mm_set1_epi32(increment*4);
+    const __m128 fracOne4 = _mm_set1_ps(1.0f/FRACTIONONE);
+    const __m128i fracMask4 = _mm_set1_epi32(FRACTIONMASK);
+    alignas(16) union { ALuint i[4]; float f[4]; } pos_;
+    alignas(16) union { ALuint i[4]; float f[4]; } frac_;
+    __m128i frac4, pos4;
+    ALuint pos;
+    ALuint i;
+
+    InitiatePositionArrays(frac, increment, frac_.i, pos_.i, 4);
+
+    frac4 = _mm_castps_si128(_mm_load_ps(frac_.f));
+    pos4 = _mm_castps_si128(_mm_load_ps(pos_.f));
+
+    for(i = 0;numsamples-i > 3;i += 4)
+    {
+        const __m128 val1 = _mm_setr_ps(src[pos_.i[0]], src[pos_.i[1]], src[pos_.i[2]], src[pos_.i[3]]);
+        const __m128 val2 = _mm_setr_ps(src[pos_.i[0]+1], src[pos_.i[1]+1], src[pos_.i[2]+1], src[pos_.i[3]+1]);
+
+        /* val1 + (val2-val1)*mu */
+        const __m128 r0 = _mm_sub_ps(val2, val1);
+        const __m128 mu = _mm_mul_ps(_mm_cvtepi32_ps(frac4), fracOne4);
+        const __m128 out = _mm_add_ps(val1, _mm_mul_ps(mu, r0));
+
+        _mm_store_ps(&dst[i], out);
+
+        frac4 = _mm_add_epi32(frac4, increment4);
+        pos4 = _mm_add_epi32(pos4, _mm_srli_epi32(frac4, FRACTIONBITS));
+        frac4 = _mm_and_si128(frac4, fracMask4);
+
+        _mm_store_ps(pos_.f, _mm_castsi128_ps(pos4));
+    }
+
+    pos = pos_.i[0];
+    frac = _mm_cvtsi128_si32(frac4);
+
+    for(;i < numsamples;i++)
+    {
+        dst[i] = lerp(src[pos], src[pos+1], frac * (1.0f/FRACTIONONE));
+
+        frac += increment;
+        pos  += frac>>FRACTIONBITS;
+        frac &= FRACTIONMASK;
+    }
+    return dst;
+}
@@ -0,0 +1,82 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2014 by Timothy Arceri <t_arceri@yahoo.com.au>.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <xmmintrin.h>
+#include <emmintrin.h>
+#include <smmintrin.h>
+
+#include "alu.h"
+#include "mixer_defs.h"
+
+
+const ALfloat *Resample_lerp32_SSE41(const ALfloat *src, ALuint frac, ALuint increment,
+                                     ALfloat *restrict dst, ALuint numsamples)
+{
+    const __m128i increment4 = _mm_set1_epi32(increment*4);
+    const __m128 fracOne4 = _mm_set1_ps(1.0f/FRACTIONONE);
+    const __m128i fracMask4 = _mm_set1_epi32(FRACTIONMASK);
+    alignas(16) union { ALuint i[4]; float f[4]; } pos_;
+    alignas(16) union { ALuint i[4]; float f[4]; } frac_;
+    __m128i frac4, pos4;
+    ALuint pos;
+    ALuint i;
+
+    InitiatePositionArrays(frac, increment, frac_.i, pos_.i, 4);
+
+    frac4 = _mm_castps_si128(_mm_load_ps(frac_.f));
+    pos4 = _mm_castps_si128(_mm_load_ps(pos_.f));
+
+    for(i = 0;numsamples-i > 3;i += 4)
+    {
+        const __m128 val1 = _mm_setr_ps(src[pos_.i[0]], src[pos_.i[1]], src[pos_.i[2]], src[pos_.i[3]]);
+        const __m128 val2 = _mm_setr_ps(src[pos_.i[0]+1], src[pos_.i[1]+1], src[pos_.i[2]+1], src[pos_.i[3]+1]);
+
+        /* val1 + (val2-val1)*mu */
+        const __m128 r0 = _mm_sub_ps(val2, val1);
+        const __m128 mu = _mm_mul_ps(_mm_cvtepi32_ps(frac4), fracOne4);
+        const __m128 out = _mm_add_ps(val1, _mm_mul_ps(mu, r0));
+
+        _mm_store_ps(&dst[i], out);
+
+        frac4 = _mm_add_epi32(frac4, increment4);
+        pos4 = _mm_add_epi32(pos4, _mm_srli_epi32(frac4, FRACTIONBITS));
+        frac4 = _mm_and_si128(frac4, fracMask4);
+
+        pos_.i[0] = _mm_extract_epi32(pos4, 0);
+        pos_.i[1] = _mm_extract_epi32(pos4, 1);
+        pos_.i[2] = _mm_extract_epi32(pos4, 2);
+        pos_.i[3] = _mm_extract_epi32(pos4, 3);
+    }
+
+    pos = pos_.i[0];
+    frac = _mm_cvtsi128_si32(frac4);
+
+    for(;i < numsamples;i++)
+    {
+        dst[i] = lerp(src[pos], src[pos+1], frac * (1.0f/FRACTIONONE));
+
+        frac += increment;
+        pos  += frac>>FRACTIONBITS;
+        frac &= FRACTIONMASK;
+    }
+    return dst;
+}
@@ -1,487 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <memory.h>
-#include <unistd.h>
-#include <errno.h>
-#include <math.h>
-#include "alMain.h"
-#include "AL/al.h"
-#include "AL/alc.h"
-
-#include <sys/soundcard.h>
-
-/*
- * The OSS documentation talks about SOUND_MIXER_READ, but the header
- * only contains MIXER_READ. Play safe. Same for WRITE.
- */
-#ifndef SOUND_MIXER_READ
-#define SOUND_MIXER_READ MIXER_READ
-#endif
-#ifndef SOUND_MIXER_WRITE
-#define SOUND_MIXER_WRITE MIXER_WRITE
-#endif
-
-static char *oss_device;
-static char *oss_device_capture;
-
-typedef struct {
-    int fd;
-    int killNow;
-    ALvoid *thread;
-
-    ALubyte *mix_data;
-    int data_size;
-    int silence;
-
-    RingBuffer *ring;
-    int doCapture;
-} oss_data;
-
-
-static int log2i(ALCuint x)
-{
-    int y = 0;
-    while (x > 1)
-    {
-        x >>= 1;
-        y++;
-    }
-    return y;
-}
-
-
-static ALuint OSSProc(ALvoid *ptr)
-{
-    ALCdevice *pDevice = (ALCdevice*)ptr;
-    oss_data *data = (oss_data*)pDevice->ExtraData;
-    int remaining = 0;
-    int wrote;
-
-    while(!data->killNow)
-    {
-        int len = data->data_size - remaining;
-
-        if(len > 0)
-        {
-            SuspendContext(NULL);
-            aluMixData(pDevice->Context, data->mix_data+remaining, len, pDevice->Format);
-            ProcessContext(NULL);
-        }
-
-        remaining += len;
-        wrote = write(data->fd, data->mix_data, remaining);
-        if(wrote < 0)
-        {
-            AL_PRINT("write failed: %s\n", strerror(errno));
-            remaining = 0;
-        }
-        else if(wrote > 0)
-        {
-            remaining -= wrote;
-            if(remaining > 0)
-                memmove(data->mix_data, data->mix_data+wrote, remaining);
-        }
-        else
-            usleep(1000);
-    }
-
-    return 0;
-}
-
-static ALuint OSSCaptureProc(ALvoid *ptr)
-{
-    ALCdevice *pDevice = (ALCdevice*)ptr;
-    oss_data *data = (oss_data*)pDevice->ExtraData;
-    int frameSize;
-    int amt;
-
-    frameSize  = aluBytesFromFormat(pDevice->Format);
-    frameSize *= aluChannelsFromFormat(pDevice->Format);
-
-    while(!data->killNow)
-    {
-        amt = read(data->fd, data->mix_data, data->data_size);
-        if(amt < 0)
-        {
-            AL_PRINT("read failed: %s\n", strerror(errno));
-            break;
-        }
-        if(amt == 0)
-        {
-            usleep(1000);
-            continue;
-        }
-        if(data->doCapture)
-            WriteRingBuffer(data->ring, data->mix_data, amt/frameSize);
-    }
-
-    return 0;
-}
-
-static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName)
-{
-    int numFragmentsLogSize;
-    int log2FragmentSize;
-    unsigned int periods;
-    audio_buf_info info;
-    char driver[64];
-    int numChannels;
-    oss_data *data;
-    int ossFormat;
-    int ossSpeed;
-    char *err;
-    int i;
-
-    strncpy(driver, GetConfigValue("oss", "device", "/dev/dsp"), sizeof(driver)-1);
-    driver[sizeof(driver)-1] = 0;
-    if(deviceName)
-    {
-        if(strcmp(deviceName, oss_device))
-            return ALC_FALSE;
-        device->szDeviceName = oss_device;
-    }
-    else
-        device->szDeviceName = oss_device;
-
-    data = (oss_data*)calloc(1, sizeof(oss_data));
-    data->killNow = 0;
-
-    data->fd = open(driver, O_WRONLY);
-    if(data->fd == -1)
-    {
-        free(data);
-        AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
-        return ALC_FALSE;
-    }
-
-    switch(aluBytesFromFormat(device->Format))
-    {
-        case 1:
-            data->silence = 0x80;
-            ossFormat = AFMT_U8;
-            break;
-        case 2:
-            data->silence = 0;
-            ossFormat = AFMT_S16_NE;
-            break;
-        default:
-            ossFormat = -1;
-            AL_PRINT("Unknown format?! %x\n", device->Format);
-    }
-
-    periods = GetConfigValueInt("oss", "periods", 4);
-    if((int)periods <= 0)
-        periods = 4;
-    numChannels = device->Channels;
-    ossSpeed = device->Frequency;
-    log2FragmentSize = log2i(device->UpdateFreq * device->FrameSize / periods);
-
-    /* according to the OSS spec, 16 bytes are the minimum */
-    if (log2FragmentSize < 4)
-        log2FragmentSize = 4;
-    numFragmentsLogSize = (periods << 16) | log2FragmentSize;
-
-#define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
-    if (!(ok(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize), "set fragment") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat), "set format") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels), "set channels") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed), "set speed") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_GETOSPACE, &info), "get space")))
-    {
-        AL_PRINT("%s failed: %s\n", err, strerror(errno));
-        close(data->fd);
-        free(data);
-        return ALC_FALSE;
-    }
-#undef ok
-
-    device->Frequency = ossSpeed;
-
-    if((int)device->Channels != numChannels)
-    {
-        AL_PRINT("Could not set %d channels, got %d instead\n", device->Channels, numChannels);
-        close(data->fd);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    if(!((ossFormat == AFMT_U8 && aluBytesFromFormat(device->Format) == 1) ||
-         (ossFormat == AFMT_S16_NE && aluBytesFromFormat(device->Format) == 2)))
-    {
-        AL_PRINT("Could not set %d-bit output, got format %#x\n", aluBytesFromFormat(device->Format)*8, ossFormat);
-        close(data->fd);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    device->UpdateFreq = info.fragsize / device->FrameSize;
-
-    data->data_size = device->UpdateFreq * device->FrameSize;
-    data->mix_data = calloc(1, data->data_size);
-
-    device->MaxNoOfSources = 256;
-
-    device->ExtraData = data;
-    data->thread = StartThread(OSSProc, device);
-    if(data->thread == NULL)
-    {
-        device->ExtraData = NULL;
-        free(data->mix_data);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    return ALC_TRUE;
-}
-
-static void oss_close_playback(ALCdevice *device)
-{
-    oss_data *data = (oss_data*)device->ExtraData;
-    data->killNow = 1;
-    StopThread(data->thread);
-
-    close(data->fd);
-
-    free(data->mix_data);
-    free(data);
-    device->ExtraData = NULL;
-}
-
-
-static ALCboolean oss_open_capture(ALCdevice *device, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
-{
-    int numFragmentsLogSize;
-    int log2FragmentSize;
-    unsigned int periods;
-    audio_buf_info info;
-    int numChannels;
-    char driver[64];
-    oss_data *data;
-    int ossFormat;
-    int ossSpeed;
-    char *err;
-    int i;
-
-    strncpy(driver, GetConfigValue("oss", "capture", "/dev/dsp"), sizeof(driver)-1);
-    driver[sizeof(driver)-1] = 0;
-    if(deviceName)
-    {
-        if(strcmp(deviceName, oss_device_capture))
-            return ALC_FALSE;
-        device->szDeviceName = oss_device_capture;
-    }
-    else
-        device->szDeviceName = oss_device_capture;
-
-    data = (oss_data*)calloc(1, sizeof(oss_data));
-    data->killNow = 0;
-
-    data->fd = open(driver, O_RDONLY);
-    if(data->fd == -1)
-    {
-        free(data);
-        AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
-        return ALC_FALSE;
-    }
-
-    switch(aluBytesFromFormat(format))
-    {
-        case 1:
-            data->silence = 0x80;
-            ossFormat = AFMT_U8;
-            break;
-        case 2:
-            data->silence = 0;
-            ossFormat = AFMT_S16_NE;
-            break;
-        default:
-            ossFormat = -1;
-            AL_PRINT("Unknown format?! %x\n", device->Format);
-    }
-
-    periods = 4;
-    numChannels = device->Channels;
-    ossSpeed = frequency;
-    log2FragmentSize = log2i(device->UpdateFreq * device->FrameSize / periods);
-
-    /* according to the OSS spec, 16 bytes are the minimum */
-    if (log2FragmentSize < 4)
-        log2FragmentSize = 4;
-    numFragmentsLogSize = (periods << 16) | log2FragmentSize;
-
-#define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
-    if (!(ok(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize), "set fragment") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat), "set format") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels), "set channels") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed), "set speed") &&
-          ok(ioctl(data->fd, SNDCTL_DSP_GETISPACE, &info), "get space")))
-    {
-        AL_PRINT("%s failed: %s\n", err, strerror(errno));
-        close(data->fd);
-        free(data);
-        return ALC_FALSE;
-    }
-#undef ok
-
-    device->Channels = numChannels;
-    device->Frequency = ossSpeed;
-    device->Format = 0;
-    if(ossFormat == AFMT_U8)
-    {
-        if(device->Channels == 1)
-        {
-            device->Format = AL_FORMAT_MONO8;
-            device->FrameSize = 1;
-        }
-        else if(device->Channels == 2)
-        {
-            device->Format = AL_FORMAT_STEREO8;
-            device->FrameSize = 2;
-        }
-        else if(device->Channels == 4)
-        {
-            device->Format = AL_FORMAT_QUAD8;
-            device->FrameSize = 4;
-        }
-    }
-    else if(ossFormat == AFMT_S16_NE)
-    {
-        if(device->Channels == 1)
-        {
-            device->Format = AL_FORMAT_MONO16;
-            device->FrameSize = 2;
-        }
-        else if(device->Channels == 2)
-        {
-            device->Format = AL_FORMAT_STEREO16;
-            device->FrameSize = 4;
-        }
-        else if(device->Channels == 4)
-        {
-            device->Format = AL_FORMAT_QUAD16;
-            device->FrameSize = 8;
-        }
-    }
-
-    if(!device->Format)
-    {
-        AL_PRINT("returned unknown format: %#x %d!\n", ossFormat, numChannels);
-        close(data->fd);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    data->ring = CreateRingBuffer(device->FrameSize, SampleSize);
-    if(!data->ring)
-    {
-        AL_PRINT("ring buffer create failed\n");
-        close(data->fd);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    device->UpdateFreq = info.fragsize / device->FrameSize;
-
-    data->data_size = device->UpdateFreq * device->FrameSize * info.fragments;
-    data->mix_data = calloc(1, data->data_size);
-
-    device->ExtraData = data;
-    data->thread = StartThread(OSSCaptureProc, device);
-    if(data->thread == NULL)
-    {
-        device->ExtraData = NULL;
-        free(data->mix_data);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    return ALC_TRUE;
-}
-
-static void oss_close_capture(ALCdevice *device)
-{
-    oss_data *data = (oss_data*)device->ExtraData;
-    data->killNow = 1;
-    StopThread(data->thread);
-
-    close(data->fd);
-
-    DestroyRingBuffer(data->ring);
-
-    free(data->mix_data);
-    free(data);
-    device->ExtraData = NULL;
-}
-
-static void oss_start_capture(ALCdevice *pDevice)
-{
-    oss_data *data = (oss_data*)pDevice->ExtraData;
-    data->doCapture = 1;
-}
-
-static void oss_stop_capture(ALCdevice *pDevice)
-{
-    oss_data *data = (oss_data*)pDevice->ExtraData;
-    data->doCapture = 0;
-}
-
-static void oss_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
-{
-    oss_data *data = (oss_data*)pDevice->ExtraData;
-    if(lSamples <= (ALCuint)RingBufferSize(data->ring))
-        ReadRingBuffer(data->ring, pBuffer, lSamples);
-    else
-        SetALCError(ALC_INVALID_VALUE);
-}
-
-static ALCuint oss_available_samples(ALCdevice *pDevice)
-{
-    oss_data *data = (oss_data*)pDevice->ExtraData;
-    return RingBufferSize(data->ring);
-}
-
-
-BackendFuncs oss_funcs = {
-    oss_open_playback,
-    oss_close_playback,
-    oss_open_capture,
-    oss_close_capture,
-    oss_start_capture,
-    oss_stop_capture,
-    oss_capture_samples,
-    oss_available_samples
-};
-
-void alc_oss_init(BackendFuncs *func_list)
-{
-    *func_list = oss_funcs;
-
-    oss_device = AppendDeviceList("OSS Software");
-    AppendAllDeviceList(oss_device);
-
-    oss_device_capture = AppendCaptureDeviceList("OSS Capture");
-}
@@ -0,0 +1,450 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2010 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "alMain.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alu.h"
+
+extern inline void SetGains(const ALCdevice *device, ALfloat ingain, ALfloat gains[MaxChannels]);
+
+static void SetSpeakerArrangement(const char *name, ALfloat SpeakerAngle[MaxChannels],
+                                  enum Channel Speaker2Chan[MaxChannels], ALint chans)
+{
+    char *confkey, *next;
+    char *layout_str;
+    char *sep, *end;
+    enum Channel val;
+    const char *str;
+    int i;
+
+    if(!ConfigValueStr(NULL, name, &str) && !ConfigValueStr(NULL, "layout", &str))
+        return;
+
+    layout_str = strdup(str);
+    next = confkey = layout_str;
+    while(next && *next)
+    {
+        confkey = next;
+        next = strchr(confkey, ',');
+        if(next)
+        {
+            *next = 0;
+            do {
+                next++;
+            } while(isspace(*next) || *next == ',');
+        }
+
+        sep = strchr(confkey, '=');
+        if(!sep || confkey == sep)
+        {
+            ERR("Malformed speaker key: %s\n", confkey);
+            continue;
+        }
+
+        end = sep - 1;
+        while(isspace(*end) && end != confkey)
+            end--;
+        *(++end) = 0;
+
+        if(strcmp(confkey, "fl") == 0 || strcmp(confkey, "front-left") == 0)
+            val = FrontLeft;
+        else if(strcmp(confkey, "fr") == 0 || strcmp(confkey, "front-right") == 0)
+            val = FrontRight;
+        else if(strcmp(confkey, "fc") == 0 || strcmp(confkey, "front-center") == 0)
+            val = FrontCenter;
+        else if(strcmp(confkey, "bl") == 0 || strcmp(confkey, "back-left") == 0)
+            val = BackLeft;
+        else if(strcmp(confkey, "br") == 0 || strcmp(confkey, "back-right") == 0)
+            val = BackRight;
+        else if(strcmp(confkey, "bc") == 0 || strcmp(confkey, "back-center") == 0)
+            val = BackCenter;
+        else if(strcmp(confkey, "sl") == 0 || strcmp(confkey, "side-left") == 0)
+            val = SideLeft;
+        else if(strcmp(confkey, "sr") == 0 || strcmp(confkey, "side-right") == 0)
+            val = SideRight;
+        else
+        {
+            ERR("Unknown speaker for %s: \"%s\"\n", name, confkey);
+            continue;
+        }
+
+        *(sep++) = 0;
+        while(isspace(*sep))
+            sep++;
+
+        for(i = 0;i < chans;i++)
+        {
+            if(Speaker2Chan[i] == val)
+            {
+                long angle = strtol(sep, NULL, 10);
+                if(angle >= -180 && angle <= 180)
+                    SpeakerAngle[i] = DEG2RAD(angle);
+                else
+                    ERR("Invalid angle for speaker \"%s\": %ld\n", confkey, angle);
+                break;
+            }
+        }
+    }
+    free(layout_str);
+    layout_str = NULL;
+
+    for(i = 0;i < chans;i++)
+    {
+        int min = i;
+        int i2;
+
+        for(i2 = i+1;i2 < chans;i2++)
+        {
+            if(SpeakerAngle[i2] < SpeakerAngle[min])
+                min = i2;
+        }
+
+        if(min != i)
+        {
+            ALfloat tmpf;
+            enum Channel tmpc;
+
+            tmpf = SpeakerAngle[i];
+            SpeakerAngle[i] = SpeakerAngle[min];
+            SpeakerAngle[min] = tmpf;
+
+            tmpc = Speaker2Chan[i];
+            Speaker2Chan[i] = Speaker2Chan[min];
+            Speaker2Chan[min] = tmpc;
+        }
+    }
+}
+
+
+void ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, ALfloat ingain, ALfloat gains[MaxChannels])
+{
+    ALfloat tmpgains[MaxChannels] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+    enum Channel Speaker2Chan[MaxChannels];
+    ALfloat SpeakerAngle[MaxChannels];
+    ALfloat langle, rangle;
+    ALfloat a;
+    ALuint i;
+
+    for(i = 0;i < device->NumChan;i++)
+        Speaker2Chan[i] = device->Speaker2Chan[i];
+    for(i = 0;i < device->NumChan;i++)
+        SpeakerAngle[i] = device->SpeakerAngle[i];
+
+    /* Some easy special-cases first... */
+    if(device->NumChan <= 1 || hwidth >= F_PI)
+    {
+        /* Full coverage for all speakers. */
+        for(i = 0;i < MaxChannels;i++)
+            gains[i] = 0.0f;
+        for(i = 0;i < device->NumChan;i++)
+        {
+            enum Channel chan = Speaker2Chan[i];
+            gains[chan] = ingain;
+        }
+        return;
+    }
+    if(hwidth <= 0.0f)
+    {
+        /* Infinitely small sound point. */
+        for(i = 0;i < MaxChannels;i++)
+            gains[i] = 0.0f;
+        for(i = 0;i < device->NumChan-1;i++)
+        {
+            if(angle >= SpeakerAngle[i] && angle < SpeakerAngle[i+1])
+            {
+                /* Sound is between speakers i and i+1 */
+                a =             (angle-SpeakerAngle[i]) /
+                    (SpeakerAngle[i+1]-SpeakerAngle[i]);
+                gains[Speaker2Chan[i]]   = sqrtf(1.0f-a) * ingain;
+                gains[Speaker2Chan[i+1]] = sqrtf(     a) * ingain;
+                return;
+            }
+        }
+        /* Sound is between last and first speakers */
+        if(angle < SpeakerAngle[0])
+            angle += F_2PI;
+        a =                   (angle-SpeakerAngle[i]) /
+            (F_2PI + SpeakerAngle[0]-SpeakerAngle[i]);
+        gains[Speaker2Chan[i]] = sqrtf(1.0f-a) * ingain;
+        gains[Speaker2Chan[0]] = sqrtf(     a) * ingain;
+        return;
+    }
+
+    if(fabsf(angle)+hwidth > F_PI)
+    {
+        /* The coverage area would go outside of -pi...+pi. Instead, rotate the
+         * speaker angles so it would be as if angle=0, and keep them wrapped
+         * within -pi...+pi. */
+        if(angle > 0.0f)
+        {
+            ALuint done;
+            ALuint i = 0;
+            while(i < device->NumChan && device->SpeakerAngle[i]-angle < -F_PI)
+                i++;
+            for(done = 0;i < device->NumChan;done++)
+            {
+                SpeakerAngle[done] = device->SpeakerAngle[i]-angle;
+                Speaker2Chan[done] = device->Speaker2Chan[i];
+                i++;
+            }
+            for(i = 0;done < device->NumChan;i++)
+            {
+                SpeakerAngle[done] = device->SpeakerAngle[i]-angle + F_2PI;
+                Speaker2Chan[done] = device->Speaker2Chan[i];
+                done++;
+            }
+        }
+        else
+        {
+            /* NOTE: '< device->NumChan' on the iterators is correct here since
+             * we need to handle index 0. Because the iterators are unsigned,
+             * they'll underflow and wrap to become 0xFFFFFFFF, which will
+             * break as expected. */
+            ALuint done;
+            ALuint i = device->NumChan-1;
+            while(i < device->NumChan && device->SpeakerAngle[i]-angle > F_PI)
+                i--;
+            for(done = device->NumChan-1;i < device->NumChan;done--)
+            {
+                SpeakerAngle[done] = device->SpeakerAngle[i]-angle;
+                Speaker2Chan[done] = device->Speaker2Chan[i];
+                i--;
+            }
+            for(i = device->NumChan-1;done < device->NumChan;i--)
+            {
+                SpeakerAngle[done] = device->SpeakerAngle[i]-angle - F_2PI;
+                Speaker2Chan[done] = device->Speaker2Chan[i];
+                done--;
+            }
+        }
+        angle = 0.0f;
+    }
+    langle = angle - hwidth;
+    rangle = angle + hwidth;
+
+    /* First speaker */
+    i = 0;
+    do {
+        ALuint last = device->NumChan-1;
+        enum Channel chan = Speaker2Chan[i];
+
+        if(SpeakerAngle[i] >= langle && SpeakerAngle[i] <= rangle)
+        {
+            tmpgains[chan] = 1.0f;
+            continue;
+        }
+
+        if(SpeakerAngle[i] < langle && SpeakerAngle[i+1] > langle)
+        {
+            a =            (langle-SpeakerAngle[i]) /
+                (SpeakerAngle[i+1]-SpeakerAngle[i]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, 1.0f-a);
+        }
+        if(SpeakerAngle[i] > rangle)
+        {
+            a =          (F_2PI + rangle-SpeakerAngle[last]) /
+                (F_2PI + SpeakerAngle[i]-SpeakerAngle[last]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, a);
+        }
+        else if(SpeakerAngle[last] < rangle)
+        {
+            a =                  (rangle-SpeakerAngle[last]) /
+                (F_2PI + SpeakerAngle[i]-SpeakerAngle[last]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, a);
+        }
+    } while(0);
+
+    for(i = 1;i < device->NumChan-1;i++)
+    {
+        enum Channel chan = Speaker2Chan[i];
+        if(SpeakerAngle[i] >= langle && SpeakerAngle[i] <= rangle)
+        {
+            tmpgains[chan] = 1.0f;
+            continue;
+        }
+
+        if(SpeakerAngle[i] < langle && SpeakerAngle[i+1] > langle)
+        {
+            a =            (langle-SpeakerAngle[i]) /
+                (SpeakerAngle[i+1]-SpeakerAngle[i]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, 1.0f-a);
+        }
+        if(SpeakerAngle[i] > rangle && SpeakerAngle[i-1] < rangle)
+        {
+            a =          (rangle-SpeakerAngle[i-1]) /
+                (SpeakerAngle[i]-SpeakerAngle[i-1]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, a);
+        }
+    }
+
+    /* Last speaker */
+    i = device->NumChan-1;
+    do {
+        enum Channel chan = Speaker2Chan[i];
+        if(SpeakerAngle[i] >= langle && SpeakerAngle[i] <= rangle)
+        {
+            tmpgains[Speaker2Chan[i]] = 1.0f;
+            continue;
+        }
+        if(SpeakerAngle[i] > rangle && SpeakerAngle[i-1] < rangle)
+        {
+            a =          (rangle-SpeakerAngle[i-1]) /
+                (SpeakerAngle[i]-SpeakerAngle[i-1]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, a);
+        }
+        if(SpeakerAngle[i] < langle)
+        {
+            a =                  (langle-SpeakerAngle[i]) /
+                (F_2PI + SpeakerAngle[0]-SpeakerAngle[i]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, 1.0f-a);
+        }
+        else if(SpeakerAngle[0] > langle)
+        {
+            a =          (F_2PI + langle-SpeakerAngle[i]) /
+                (F_2PI + SpeakerAngle[0]-SpeakerAngle[i]);
+            tmpgains[chan] = lerp(tmpgains[chan], 1.0f, 1.0f-a);
+        }
+    } while(0);
+
+    for(i = 0;i < device->NumChan;i++)
+    {
+        enum Channel chan = device->Speaker2Chan[i];
+        gains[chan] = sqrtf(tmpgains[chan]) * ingain;
+    }
+}
+
+
+ALvoid aluInitPanning(ALCdevice *Device)
+{
+    const char *layoutname = NULL;
+    enum Channel *Speaker2Chan;
+    ALfloat *SpeakerAngle;
+
+    Speaker2Chan = Device->Speaker2Chan;
+    SpeakerAngle = Device->SpeakerAngle;
+    switch(Device->FmtChans)
+    {
+        case DevFmtMono:
+            Device->NumChan = 1;
+            Speaker2Chan[0] = FrontCenter;
+            SpeakerAngle[0] = DEG2RAD(0.0f);
+            layoutname = NULL;
+            break;
+
+        case DevFmtStereo:
+            Device->NumChan = 2;
+            Speaker2Chan[0] = FrontLeft;
+            Speaker2Chan[1] = FrontRight;
+            SpeakerAngle[0] = DEG2RAD(-90.0f);
+            SpeakerAngle[1] = DEG2RAD( 90.0f);
+            layoutname = "layout_stereo";
+            break;
+
+        case DevFmtQuad:
+            Device->NumChan = 4;
+            Speaker2Chan[0] = BackLeft;
+            Speaker2Chan[1] = FrontLeft;
+            Speaker2Chan[2] = FrontRight;
+            Speaker2Chan[3] = BackRight;
+            SpeakerAngle[0] = DEG2RAD(-135.0f);
+            SpeakerAngle[1] = DEG2RAD( -45.0f);
+            SpeakerAngle[2] = DEG2RAD(  45.0f);
+            SpeakerAngle[3] = DEG2RAD( 135.0f);
+            layoutname = "layout_quad";
+            break;
+
+        case DevFmtX51:
+            Device->NumChan = 5;
+            Speaker2Chan[0] = BackLeft;
+            Speaker2Chan[1] = FrontLeft;
+            Speaker2Chan[2] = FrontCenter;
+            Speaker2Chan[3] = FrontRight;
+            Speaker2Chan[4] = BackRight;
+            SpeakerAngle[0] = DEG2RAD(-110.0f);
+            SpeakerAngle[1] = DEG2RAD( -30.0f);
+            SpeakerAngle[2] = DEG2RAD(   0.0f);
+            SpeakerAngle[3] = DEG2RAD(  30.0f);
+            SpeakerAngle[4] = DEG2RAD( 110.0f);
+            layoutname = "layout_surround51";
+            break;
+
+        case DevFmtX51Side:
+            Device->NumChan = 5;
+            Speaker2Chan[0] = SideLeft;
+            Speaker2Chan[1] = FrontLeft;
+            Speaker2Chan[2] = FrontCenter;
+            Speaker2Chan[3] = FrontRight;
+            Speaker2Chan[4] = SideRight;
+            SpeakerAngle[0] = DEG2RAD(-90.0f);
+            SpeakerAngle[1] = DEG2RAD(-30.0f);
+            SpeakerAngle[2] = DEG2RAD(  0.0f);
+            SpeakerAngle[3] = DEG2RAD( 30.0f);
+            SpeakerAngle[4] = DEG2RAD( 90.0f);
+            layoutname = "layout_side51";
+            break;
+
+        case DevFmtX61:
+            Device->NumChan = 6;
+            Speaker2Chan[0] = SideLeft;
+            Speaker2Chan[1] = FrontLeft;
+            Speaker2Chan[2] = FrontCenter;
+            Speaker2Chan[3] = FrontRight;
+            Speaker2Chan[4] = SideRight;
+            Speaker2Chan[5] = BackCenter;
+            SpeakerAngle[0] = DEG2RAD(-90.0f);
+            SpeakerAngle[1] = DEG2RAD(-30.0f);
+            SpeakerAngle[2] = DEG2RAD(  0.0f);
+            SpeakerAngle[3] = DEG2RAD( 30.0f);
+            SpeakerAngle[4] = DEG2RAD( 90.0f);
+            SpeakerAngle[5] = DEG2RAD(180.0f);
+            layoutname = "layout_surround61";
+            break;
+
+        case DevFmtX71:
+            Device->NumChan = 7;
+            Speaker2Chan[0] = BackLeft;
+            Speaker2Chan[1] = SideLeft;
+            Speaker2Chan[2] = FrontLeft;
+            Speaker2Chan[3] = FrontCenter;
+            Speaker2Chan[4] = FrontRight;
+            Speaker2Chan[5] = SideRight;
+            Speaker2Chan[6] = BackRight;
+            SpeakerAngle[0] = DEG2RAD(-150.0f);
+            SpeakerAngle[1] = DEG2RAD( -90.0f);
+            SpeakerAngle[2] = DEG2RAD( -30.0f);
+            SpeakerAngle[3] = DEG2RAD(   0.0f);
+            SpeakerAngle[4] = DEG2RAD(  30.0f);
+            SpeakerAngle[5] = DEG2RAD(  90.0f);
+            SpeakerAngle[6] = DEG2RAD( 150.0f);
+            layoutname = "layout_surround71";
+            break;
+    }
+    if(layoutname && Device->Type != Loopback)
+        SetSpeakerArrangement(layoutname, SpeakerAngle, Speaker2Chan, Device->NumChan);
+}
@@ -0,0 +1,87 @@
+#ifndef AL_VECTOR_H
+#define AL_VECTOR_H
+
+#include <stdlib.h>
+
+#include <AL/al.h>
+
+/* "Base" vector type, designed to alias with the actual vector types. */
+typedef struct vector__s {
+    ALsizei Capacity;
+    ALsizei Size;
+} *vector_;
+
+#define TYPEDEF_VECTOR(T, N) typedef struct {                                 \
+    ALsizei Capacity;                                                         \
+    ALsizei Size;                                                             \
+    T Data[];                                                                 \
+} _##N;                                                                       \
+typedef _##N* N;                                                              \
+typedef const _##N* const_##N;
+
+#define VECTOR(T) struct {                                                    \
+    ALsizei Capacity;                                                         \
+    ALsizei Size;                                                             \
+    T Data[];                                                                 \
+}*
+
+#define VECTOR_INIT(_x)       do { (_x) = NULL; } while(0)
+#define VECTOR_INIT_STATIC()  NULL
+#define VECTOR_DEINIT(_x)     do { free((_x)); (_x) = NULL; } while(0)
+
+/* Helper to increase a vector's reserve. Do not call directly. */
+ALboolean vector_reserve(char *ptr, size_t base_size, size_t obj_size, ALsizei obj_count, ALboolean exact);
+#define VECTOR_RESERVE(_x, _c) (vector_reserve((char*)&(_x), sizeof(*(_x)), sizeof((_x)->Data[0]), (_c), AL_TRUE))
+
+ALboolean vector_resize(char *ptr, size_t base_size, size_t obj_size, ALsizei obj_count);
+#define VECTOR_RESIZE(_x, _c) (vector_resize((char*)&(_x), sizeof(*(_x)), sizeof((_x)->Data[0]), (_c)))
+
+#define VECTOR_CAPACITY(_x) ((_x) ? (_x)->Capacity : 0)
+#define VECTOR_SIZE(_x)     ((_x) ? (_x)->Size : 0)
+
+#define VECTOR_ITER_BEGIN(_x) ((_x) ? (_x)->Data + 0 : NULL)
+#define VECTOR_ITER_END(_x)   ((_x) ? (_x)->Data + (_x)->Size : NULL)
+
+ALboolean vector_insert(char *ptr, size_t base_size, size_t obj_size, void *ins_pos, const void *datstart, const void *datend);
+#ifdef __GNUC__
+#define TYPE_CHECK(T1, T2) __builtin_types_compatible_p(T1, T2)
+#define VECTOR_INSERT(_x, _i, _s, _e) __extension__({                         \
+    ALboolean _r;                                                             \
+    static_assert(TYPE_CHECK(__typeof((_x)->Data[0]), __typeof(*(_i))), "Incompatible insertion iterator"); \
+    static_assert(TYPE_CHECK(__typeof((_x)->Data[0]), __typeof(*(_s))), "Incompatible insertion source type"); \
+    static_assert(TYPE_CHECK(__typeof(*(_s)), __typeof(*(_e))), "Incompatible iterator sources"); \
+    _r = vector_insert((char*)&(_x), sizeof(*(_x)), sizeof((_x)->Data[0]), (_i), (_s), (_e)); \
+    _r;                                                                       \
+})
+#else
+#define VECTOR_INSERT(_x, _i, _s, _e) (vector_insert((char*)&(_x), sizeof(*(_x)), sizeof((_x)->Data[0]), (_i), (_s), (_e)))
+#endif
+
+#define VECTOR_PUSH_BACK(_x, _obj) (vector_reserve((char*)&(_x), sizeof(*(_x)), sizeof((_x)->Data[0]), VECTOR_SIZE(_x)+1, AL_FALSE) && \
+                                    (((_x)->Data[(_x)->Size++] = (_obj)),AL_TRUE))
+#define VECTOR_POP_BACK(_x) ((void)((_x)->Size--))
+
+#define VECTOR_BACK(_x)  ((_x)->Data[(_x)->Size-1])
+#define VECTOR_FRONT(_x) ((_x)->Data[0])
+
+#define VECTOR_ELEM(_x, _o) ((_x)->Data[(_o)])
+
+#define VECTOR_FOR_EACH(_t, _x, _f)  do {                                     \
+    _t *_iter = VECTOR_ITER_BEGIN((_x));                                      \
+    _t *_end = VECTOR_ITER_END((_x));                                         \
+    for(;_iter != _end;++_iter)                                               \
+        _f(_iter);                                                            \
+} while(0)
+
+#define VECTOR_FIND_IF(_i, _t, _x, _f)  do {                                  \
+    _t *_iter = VECTOR_ITER_BEGIN((_x));                                      \
+    _t *_end = VECTOR_ITER_END((_x));                                         \
+    for(;_iter != _end;++_iter)                                               \
+    {                                                                         \
+        if(_f(_iter))                                                         \
+            break;                                                            \
+    }                                                                         \
+    (_i) = _iter;                                                             \
+} while(0)
+
+#endif /* AL_VECTOR_H */
@@ -1,420 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <memory.h>
-
-#include <windows.h>
-#include <mmsystem.h>
-
-#include "alMain.h"
-#include "AL/al.h"
-#include "AL/alc.h"
-
-
-typedef struct {
-    // MMSYSTEM Capture Device
-    ALboolean        bWaveInShutdown;
-    HANDLE           hWaveInHdrEvent;
-    HANDLE           hWaveInThreadEvent;
-    HANDLE           hWaveInThread;
-    DWORD            ulWaveInThreadID;
-    ALint            lWaveInBuffersCommitted;
-    HWAVEIN          hWaveInHandle;
-    WAVEHDR          WaveInBuffer[4];
-    ALCchar          *pCapturedSampleData;
-    ALuint           ulCapturedDataSize;
-    ALuint           ulReadCapturedDataPos;
-    ALuint           ulWriteCapturedDataPos;
-} WinMMData;
-
-
-static ALCchar *CaptureDeviceList[16];
-
-/*
-    WaveInProc
-
-    Posts a message to 'CaptureThreadProc' everytime a WaveIn Buffer is completed and
-    returns to the application (with more data)
-*/
-static void CALLBACK WaveInProc(HWAVEIN hDevice,UINT uMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)
-{
-    ALCdevice *pDevice = (ALCdevice *)dwInstance;
-    WinMMData *pData = pDevice->ExtraData;
-
-    (void)hDevice;
-    (void)dwParam2;
-
-    if ((uMsg==WIM_DATA) && (pDevice))
-    {
-        // Decrement number of buffers in use
-        pData->lWaveInBuffersCommitted--;
-
-        if (pData->bWaveInShutdown == AL_FALSE)
-        {
-            // Notify Wave Processor Thread that a Wave Header has returned
-            PostThreadMessage(pData->ulWaveInThreadID,uMsg,0,dwParam1);
-        }
-        else
-        {
-            if (pData->lWaveInBuffersCommitted == 0)
-            {
-                // Signal Wave Buffers Returned event
-                if (pData->hWaveInHdrEvent)
-                    SetEvent(pData->hWaveInHdrEvent);
-
-                // Post 'Quit' Message to WaveIn Processor Thread
-                PostThreadMessage(pData->ulWaveInThreadID,WM_QUIT,0,0);
-            }
-        }
-    }
-}
-
-/*
-    CaptureThreadProc
-
-    Used by "MMSYSTEM" Device.  Called when a WaveIn buffer had been filled with new
-    audio data.
-*/
-DWORD WINAPI CaptureThreadProc(LPVOID lpParameter)
-{
-    ALCdevice *pDevice = (ALCdevice*)lpParameter;
-    WinMMData *pData = pDevice->ExtraData;
-    ALuint ulOffset, ulMaxSize, ulSection;
-    LPWAVEHDR pWaveHdr;
-    MSG msg;
-
-    while (GetMessage(&msg, NULL, 0, 0))
-    {
-        if ((msg.message==WIM_DATA)&&(!pData->bWaveInShutdown))
-        {
-            SuspendContext(NULL);
-
-            pWaveHdr = ((LPWAVEHDR)msg.lParam);
-
-            // Calculate offset in local buffer to write data to
-            ulOffset = pData->ulWriteCapturedDataPos % pData->ulCapturedDataSize;
-
-            if ((ulOffset + pWaveHdr->dwBytesRecorded) > pData->ulCapturedDataSize)
-            {
-                ulSection = pData->ulCapturedDataSize - ulOffset;
-                memcpy(pData->pCapturedSampleData + ulOffset, pWaveHdr->lpData, ulSection);
-                memcpy(pData->pCapturedSampleData, pWaveHdr->lpData + ulSection, pWaveHdr->dwBytesRecorded - ulSection);
-            }
-            else
-            {
-                memcpy(pData->pCapturedSampleData + ulOffset, pWaveHdr->lpData, pWaveHdr->dwBytesRecorded);
-            }
-
-            pData->ulWriteCapturedDataPos += pWaveHdr->dwBytesRecorded;
-
-            if (pData->ulWriteCapturedDataPos > (pData->ulReadCapturedDataPos + pData->ulCapturedDataSize))
-            {
-                // Application has not read enough audio data from the capture buffer so data has been
-                // overwritten.  Reset ReadPosition.
-                pData->ulReadCapturedDataPos = pData->ulWriteCapturedDataPos - pData->ulCapturedDataSize;
-            }
-
-            // To prevent an over-flow prevent the offset values from getting too large
-            ulMaxSize = pData->ulCapturedDataSize << 4;
-            if ((pData->ulReadCapturedDataPos > ulMaxSize) && (pData->ulWriteCapturedDataPos > ulMaxSize))
-            {
-                pData->ulReadCapturedDataPos -= ulMaxSize;
-                pData->ulWriteCapturedDataPos -= ulMaxSize;
-            }
-
-            // Send buffer back to capture more data
-            waveInAddBuffer(pData->hWaveInHandle,pWaveHdr,sizeof(WAVEHDR));
-            pData->lWaveInBuffersCommitted++;
-
-            ProcessContext(NULL);
-        }
-    }
-
-    // Signal Wave Thread completed event
-    if (pData->hWaveInThreadEvent)
-        SetEvent(pData->hWaveInThreadEvent);
-
-    ExitThread(0);
-
-    return 0;
-}
-
-
-static ALCboolean WinMMOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
-{
-    (void)device;
-    (void)deviceName;
-    return ALC_FALSE;
-}
-
-static void WinMMClosePlayback(ALCdevice *device)
-{
-    (void)device;
-}
-
-
-static ALCboolean WinMMOpenCapture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
-{
-    WAVEFORMATEX wfexCaptureFormat;
-    WinMMData *pData = NULL;
-    ALint lDeviceID = 0;
-    ALint lBufferSize;
-    ALint i;
-
-    (void)format;
-
-    // Find the Device ID matching the deviceName if valid
-    if (deviceName)
-    {
-        for(i = 0;CaptureDeviceList[i];i++)
-        {
-            if (!strcmp(deviceName, CaptureDeviceList[i]))
-            {
-                lDeviceID = i;
-                break;
-            }
-        }
-        if(!CaptureDeviceList[i])
-            return ALC_FALSE;
-    }
-    pDevice->szDeviceName = CaptureDeviceList[lDeviceID];
-
-    pData = calloc(1, sizeof(*pData));
-    if(!pData)
-    {
-        SetALCError(ALC_OUT_OF_MEMORY);
-        return ALC_FALSE;
-    }
-
-    memset(&wfexCaptureFormat, 0, sizeof(WAVEFORMATEX));
-    wfexCaptureFormat.wFormatTag = WAVE_FORMAT_PCM;
-    wfexCaptureFormat.nChannels = pDevice->Channels;
-    wfexCaptureFormat.wBitsPerSample = pDevice->FrameSize / pDevice->Channels * 8;
-    wfexCaptureFormat.nBlockAlign = pDevice->FrameSize;
-    wfexCaptureFormat.nSamplesPerSec = frequency;
-    wfexCaptureFormat.nAvgBytesPerSec = wfexCaptureFormat.nSamplesPerSec *
-                                        pDevice->FrameSize;
-    wfexCaptureFormat.cbSize = 0;
-
-    if (waveInOpen(&pData->hWaveInHandle, lDeviceID, &wfexCaptureFormat, (DWORD_PTR)&WaveInProc, (DWORD_PTR)pDevice, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
-        goto failure;
-
-    pData->hWaveInHdrEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInAllHeadersReturned");
-    if (pData->hWaveInHdrEvent == NULL)
-        goto failure;
-
-    pData->hWaveInThreadEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInThreadDestroyed");
-    if (pData->hWaveInThreadEvent == NULL)
-        goto failure;
-
-    pData->hWaveInThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CaptureThreadProc, (LPVOID)pDevice, 0, &pData->ulWaveInThreadID);
-    if (pData->hWaveInThread == NULL)
-        goto failure;
-
-    // Allocate circular memory buffer for the captured audio
-    pData->ulCapturedDataSize = SampleSize * wfexCaptureFormat.nBlockAlign;
-
-    // Make sure circular buffer is at least 100ms in size (and an exact multiple of
-    // the block alignment
-    if (pData->ulCapturedDataSize < (wfexCaptureFormat.nAvgBytesPerSec / 10))
-    {
-        pData->ulCapturedDataSize = wfexCaptureFormat.nAvgBytesPerSec / 10;
-        pData->ulCapturedDataSize -= (pData->ulCapturedDataSize % wfexCaptureFormat.nBlockAlign);
-    }
-
-    pData->pCapturedSampleData = (ALCchar*)malloc(pData->ulCapturedDataSize);
-    pData->lWaveInBuffersCommitted=0;
-
-    // Create 4 Buffers of 50ms each
-    lBufferSize = wfexCaptureFormat.nAvgBytesPerSec / 20;
-    lBufferSize -= (lBufferSize % wfexCaptureFormat.nBlockAlign);
-
-    for (i=0;i<4;i++)
-    {
-        memset(&pData->WaveInBuffer[i], 0, sizeof(WAVEHDR));
-        pData->WaveInBuffer[i].dwBufferLength = lBufferSize;
-        pData->WaveInBuffer[i].lpData = calloc(1,pData->WaveInBuffer[i].dwBufferLength);
-        pData->WaveInBuffer[i].dwFlags = 0;
-        pData->WaveInBuffer[i].dwLoops = 0;
-        waveInPrepareHeader(pData->hWaveInHandle, &pData->WaveInBuffer[i], sizeof(WAVEHDR));
-        waveInAddBuffer(pData->hWaveInHandle, &pData->WaveInBuffer[i], sizeof(WAVEHDR));
-        pData->lWaveInBuffersCommitted++;
-    }
-
-    pData->ulReadCapturedDataPos = 0;
-    pData->ulWriteCapturedDataPos = 0;
-
-    pDevice->ExtraData = pData;
-    return ALC_TRUE;
-
-failure:
-    if (pData->hWaveInThreadEvent)
-        CloseHandle(pData->hWaveInThreadEvent);
-    if (pData->hWaveInHdrEvent)
-        CloseHandle(pData->hWaveInHdrEvent);
-    if (pData->hWaveInHandle)
-        waveInClose(pData->hWaveInHandle);
-
-    free(pData);
-    return ALC_FALSE;
-}
-
-static void WinMMCloseCapture(ALCdevice *pDevice)
-{
-    WinMMData *pData = (WinMMData*)pDevice->ExtraData;
-    int i;
-
-    // Call waveOutReset to shutdown wave device
-    pData->bWaveInShutdown = AL_TRUE;
-    waveInReset(pData->hWaveInHandle);
-
-    // Wait for signal that all Wave Buffers have returned
-    WaitForSingleObjectEx(pData->hWaveInHdrEvent, 5000, FALSE);
-
-    // Wait for signal that Wave Thread has been destroyed
-    WaitForSingleObjectEx(pData->hWaveInThreadEvent, 5000, FALSE);
-
-    // Release the wave buffers
-    for (i=0;i<4;i++)
-    {
-        waveInUnprepareHeader(pData->hWaveInHandle, &pData->WaveInBuffer[i], sizeof(WAVEHDR));
-        free(pData->WaveInBuffer[i].lpData);
-    }
-
-    // Free Audio Buffer data
-    free(pData->pCapturedSampleData);
-    pData->pCapturedSampleData = NULL;
-
-    // Close the Wave device
-    waveInClose(pData->hWaveInHandle);
-    pData->hWaveInHandle = 0;
-
-    CloseHandle(pData->hWaveInThread);
-    pData->hWaveInThread = 0;
-
-    if (pData->hWaveInHdrEvent)
-    {
-        CloseHandle(pData->hWaveInHdrEvent);
-        pData->hWaveInHdrEvent = 0;
-    }
-
-    if (pData->hWaveInThreadEvent)
-    {
-        CloseHandle(pData->hWaveInThreadEvent);
-        pData->hWaveInThreadEvent = 0;
-    }
-
-    free(pData);
-    pDevice->ExtraData = NULL;
-}
-
-static void WinMMStartCapture(ALCdevice *pDevice)
-{
-    WinMMData *pData = (WinMMData*)pDevice->ExtraData;
-    waveInStart(pData->hWaveInHandle);
-}
-
-static void WinMMStopCapture(ALCdevice *pDevice)
-{
-    WinMMData *pData = (WinMMData*)pDevice->ExtraData;
-    waveInStop(pData->hWaveInHandle);
-}
-
-static void WinMMCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
-{
-    WinMMData *pData = (WinMMData*)pDevice->ExtraData;
-    ALuint ulSamples = (unsigned long)lSamples;
-    ALuint ulBytes, ulBytesToCopy;
-    ALuint ulCapturedSamples;
-    ALuint ulReadOffset;
-
-    // Check that we have the requested numbers of Samples
-    ulCapturedSamples = (pData->ulWriteCapturedDataPos - pData->ulReadCapturedDataPos) / pDevice->FrameSize;
-    if(ulSamples > ulCapturedSamples)
-    {
-        SetALCError(ALC_INVALID_VALUE);
-        return;
-    }
-
-    ulBytes = ulSamples * pDevice->FrameSize;
-
-    // Get Read Offset
-    ulReadOffset = (pData->ulReadCapturedDataPos % pData->ulCapturedDataSize);
-
-    // Check for wrap-around condition
-    if ((ulReadOffset + ulBytes) > pData->ulCapturedDataSize)
-    {
-        // Copy data from last Read position to end of data
-        ulBytesToCopy = pData->ulCapturedDataSize - ulReadOffset;
-        memcpy(pBuffer, pData->pCapturedSampleData + ulReadOffset, ulBytesToCopy);
-
-        // Copy rest of the data from the start of the captured data
-        memcpy(((char *)pBuffer) + ulBytesToCopy, pData->pCapturedSampleData, ulBytes - ulBytesToCopy);
-    }
-    else
-    {
-        // Copy data from the read position in the captured data
-        memcpy(pBuffer, pData->pCapturedSampleData + ulReadOffset, ulBytes);
-    }
-
-    // Update Read Position
-    pData->ulReadCapturedDataPos += ulBytes;
-}
-
-static ALCuint WinMMAvailableSamples(ALCdevice *pDevice)
-{
-    WinMMData *pData = (WinMMData*)pDevice->ExtraData;
-    ALCuint lCapturedBytes = (pData->ulWriteCapturedDataPos - pData->ulReadCapturedDataPos);
-    return lCapturedBytes / pDevice->FrameSize;
-}
-
-
-BackendFuncs WinMMFuncs = {
-    WinMMOpenPlayback,
-    WinMMClosePlayback,
-    WinMMOpenCapture,
-    WinMMCloseCapture,
-    WinMMStartCapture,
-    WinMMStopCapture,
-    WinMMCaptureSamples,
-    WinMMAvailableSamples
-};
-
-void alcWinMMInit(BackendFuncs *FuncList)
-{
-    ALint lNumDevs;
-    ALint lLoop;
-
-    *FuncList = WinMMFuncs;
-
-    lNumDevs = waveInGetNumDevs();
-    for (lLoop = 0; lLoop < lNumDevs; lLoop++)
-    {
-        WAVEINCAPS WaveInCaps;
-        if(waveInGetDevCaps(lLoop, &WaveInCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR)
-        {
-            char name[128];
-            snprintf(name, sizeof(name), "WaveIn on %s", WaveInCaps.szPname);
-            CaptureDeviceList[lLoop] = AppendCaptureDeviceList(name);
-        }
-    }
-}
@@ -0,0 +1,117 @@
+#ifndef _AL_AUXEFFECTSLOT_H_
+#define _AL_AUXEFFECTSLOT_H_
+
+#include "alMain.h"
+#include "alEffect.h"
+
+#include "align.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ALeffectStateVtable;
+struct ALeffectslot;
+
+typedef struct ALeffectState {
+    const struct ALeffectStateVtable *vtbl;
+} ALeffectState;
+
+struct ALeffectStateVtable {
+    void (*const Destruct)(ALeffectState *state);
+
+    ALboolean (*const deviceUpdate)(ALeffectState *state, ALCdevice *device);
+    void (*const update)(ALeffectState *state, ALCdevice *device, const struct ALeffectslot *slot);
+    void (*const process)(ALeffectState *state, ALuint samplesToDo, const ALfloat *restrict samplesIn, ALfloat (*restrict samplesOut)[BUFFERSIZE]);
+
+    void (*const Delete)(void *ptr);
+};
+
+#define DEFINE_ALEFFECTSTATE_VTABLE(T)                                        \
+DECLARE_THUNK(T, ALeffectState, void, Destruct)                               \
+DECLARE_THUNK1(T, ALeffectState, ALboolean, deviceUpdate, ALCdevice*)         \
+DECLARE_THUNK2(T, ALeffectState, void, update, ALCdevice*, const ALeffectslot*) \
+DECLARE_THUNK3(T, ALeffectState, void, process, ALuint, const ALfloat*restrict, ALfloatBUFFERSIZE*restrict) \
+static void T##_ALeffectState_Delete(void *ptr)                               \
+{ return T##_Delete(STATIC_UPCAST(T, ALeffectState, (ALeffectState*)ptr)); }  \
+                                                                              \
+static const struct ALeffectStateVtable T##_ALeffectState_vtable = {          \
+    T##_ALeffectState_Destruct,                                               \
+                                                                              \
+    T##_ALeffectState_deviceUpdate,                                           \
+    T##_ALeffectState_update,                                                 \
+    T##_ALeffectState_process,                                                \
+                                                                              \
+    T##_ALeffectState_Delete,                                                 \
+}
+
+
+struct ALeffectStateFactoryVtable;
+
+typedef struct ALeffectStateFactory {
+    const struct ALeffectStateFactoryVtable *vtbl;
+} ALeffectStateFactory;
+
+struct ALeffectStateFactoryVtable {
+    ALeffectState *(*const create)(ALeffectStateFactory *factory);
+};
+
+#define DEFINE_ALEFFECTSTATEFACTORY_VTABLE(T)                                 \
+DECLARE_THUNK(T, ALeffectStateFactory, ALeffectState*, create)                \
+                                                                              \
+static const struct ALeffectStateFactoryVtable T##_ALeffectStateFactory_vtable = { \
+    T##_ALeffectStateFactory_create,                                          \
+}
+
+
+typedef struct ALeffectslot {
+    ALenum EffectType;
+    ALeffectProps EffectProps;
+
+    volatile ALfloat   Gain;
+    volatile ALboolean AuxSendAuto;
+
+    ATOMIC(ALenum) NeedsUpdate;
+    ALeffectState *EffectState;
+
+    alignas(16) ALfloat WetBuffer[1][BUFFERSIZE];
+
+    RefCount ref;
+
+    /* Self ID */
+    ALuint id;
+} ALeffectslot;
+
+inline struct ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id)
+{ return (struct ALeffectslot*)LookupUIntMapKey(&context->EffectSlotMap, id); }
+inline struct ALeffectslot *RemoveEffectSlot(ALCcontext *context, ALuint id)
+{ return (struct ALeffectslot*)RemoveUIntMapKey(&context->EffectSlotMap, id); }
+
+ALenum InitEffectSlot(ALeffectslot *slot);
+ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);
+
+
+ALeffectStateFactory *ALnullStateFactory_getFactory(void);
+ALeffectStateFactory *ALreverbStateFactory_getFactory(void);
+ALeffectStateFactory *ALautowahStateFactory_getFactory(void);
+ALeffectStateFactory *ALchorusStateFactory_getFactory(void);
+ALeffectStateFactory *ALcompressorStateFactory_getFactory(void);
+ALeffectStateFactory *ALdistortionStateFactory_getFactory(void);
+ALeffectStateFactory *ALechoStateFactory_getFactory(void);
+ALeffectStateFactory *ALequalizerStateFactory_getFactory(void);
+ALeffectStateFactory *ALflangerStateFactory_getFactory(void);
+ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void);
+
+ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void);
+
+
+ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *effect);
+
+void InitEffectFactoryMap(void);
+void DeinitEffectFactoryMap(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -1,29 +1,113 @@
 #ifndef _AL_BUFFER_H_
 #define _AL_BUFFER_H_

-#include "AL/al.h"
+#include "alMain.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

-#define UNUSED    0
-#define PENDING   1
-#define PROCESSED 2
+/* User formats */
+enum UserFmtType {
+    UserFmtByte   = AL_BYTE_SOFT,
+    UserFmtUByte  = AL_UNSIGNED_BYTE_SOFT,
+    UserFmtShort  = AL_SHORT_SOFT,
+    UserFmtUShort = AL_UNSIGNED_SHORT_SOFT,
+    UserFmtInt    = AL_INT_SOFT,
+    UserFmtUInt   = AL_UNSIGNED_INT_SOFT,
+    UserFmtFloat  = AL_FLOAT_SOFT,
+    UserFmtDouble = AL_DOUBLE_SOFT,
+    UserFmtByte3  = AL_BYTE3_SOFT,
+    UserFmtUByte3 = AL_UNSIGNED_BYTE3_SOFT,
+    UserFmtMulaw,
+    UserFmtAlaw,
+    UserFmtIMA4,
+    UserFmtMSADPCM,
+};
+enum UserFmtChannels {
+    UserFmtMono   = AL_MONO_SOFT,
+    UserFmtStereo = AL_STEREO_SOFT,
+    UserFmtRear   = AL_REAR_SOFT,
+    UserFmtQuad   = AL_QUAD_SOFT,
+    UserFmtX51    = AL_5POINT1_SOFT, /* (WFX order) */
+    UserFmtX61    = AL_6POINT1_SOFT, /* (WFX order) */
+    UserFmtX71    = AL_7POINT1_SOFT, /* (WFX order) */
+};

-typedef struct ALbuffer_struct 
+ALuint BytesFromUserFmt(enum UserFmtType type) DECL_CONST;
+ALuint ChannelsFromUserFmt(enum UserFmtChannels chans) DECL_CONST;
+inline ALuint FrameSizeFromUserFmt(enum UserFmtChannels chans, enum UserFmtType type)
 {
-    ALenum   format;
-    ALenum   eOriginalFormat;
-    ALshort *data;
-    ALsizei  size;
-    ALsizei  frequency;
-    ALenum   state;
-    ALuint   refcount; // Number of sources using this buffer (deletion can only occur when this is 0)
-    struct ALbuffer_struct *next;
+    return ChannelsFromUserFmt(chans) * BytesFromUserFmt(type);
+}
+
+
+/* Storable formats */
+enum FmtType {
+    FmtByte  = UserFmtByte,
+    FmtShort = UserFmtShort,
+    FmtFloat = UserFmtFloat,
+};
+enum FmtChannels {
+    FmtMono   = UserFmtMono,
+    FmtStereo = UserFmtStereo,
+    FmtRear   = UserFmtRear,
+    FmtQuad   = UserFmtQuad,
+    FmtX51    = UserFmtX51,
+    FmtX61    = UserFmtX61,
+    FmtX71    = UserFmtX71,
+};
+#define MAX_INPUT_CHANNELS  (8)
+
+ALuint BytesFromFmt(enum FmtType type) DECL_CONST;
+ALuint ChannelsFromFmt(enum FmtChannels chans) DECL_CONST;
+inline ALuint FrameSizeFromFmt(enum FmtChannels chans, enum FmtType type)
+{
+    return ChannelsFromFmt(chans) * BytesFromFmt(type);
+}
+
+
+typedef struct ALbuffer {
+    ALvoid  *data;
+
+    ALsizei  Frequency;
+    ALenum   Format;
+    ALsizei  SampleLen;
+
+    enum FmtChannels FmtChannels;
+    enum FmtType     FmtType;
+
+    enum UserFmtChannels OriginalChannels;
+    enum UserFmtType     OriginalType;
+    ALsizei              OriginalSize;
+    ALsizei              OriginalAlign;
+
+    ALsizei  LoopStart;
+    ALsizei  LoopEnd;
+
+    ALsizei UnpackAlign;
+    ALsizei PackAlign;
+
+    /* Number of times buffer was attached to a source (deletion can only occur when 0) */
+    RefCount ref;
+
+    RWLock lock;
+
+    /* Self ID */
+    ALuint id;
 } ALbuffer;

-ALvoid ReleaseALBuffers(ALvoid);
+ALbuffer *NewBuffer(ALCcontext *context);
+void DeleteBuffer(ALCdevice *device, ALbuffer *buffer);
+
+ALenum LoadData(ALbuffer *buffer, ALuint freq, ALenum NewFormat, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALboolean storesrc);
+
+inline struct ALbuffer *LookupBuffer(ALCdevice *device, ALuint id)
+{ return (struct ALbuffer*)LookupUIntMapKey(&device->BufferMap, id); }
+inline struct ALbuffer *RemoveBuffer(ALCdevice *device, ALuint id)
+{ return (struct ALbuffer*)RemoveUIntMapKey(&device->BufferMap, id); }
+
+ALvoid ReleaseALBuffers(ALCdevice *device);

 #ifdef __cplusplus
 }
@@ -0,0 +1,197 @@
+#ifndef _AL_EFFECT_H_
+#define _AL_EFFECT_H_
+
+#include "alMain.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ALeffect;
+
+enum {
+    EAXREVERB = 0,
+    REVERB,
+    AUTOWAH,
+    CHORUS,
+    COMPRESSOR,
+    DISTORTION,
+    ECHO,
+    EQUALIZER,
+    FLANGER,
+    MODULATOR,
+    DEDICATED,
+
+    MAX_EFFECTS
+};
+extern ALboolean DisabledEffects[MAX_EFFECTS];
+
+extern ALfloat ReverbBoost;
+extern ALboolean EmulateEAXReverb;
+
+struct ALeffectVtable {
+    void (*const setParami)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALint val);
+    void (*const setParamiv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals);
+    void (*const setParamf)(struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val);
+    void (*const setParamfv)(struct ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals);
+
+    void (*const getParami)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *val);
+    void (*const getParamiv)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals);
+    void (*const getParamf)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val);
+    void (*const getParamfv)(const struct ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals);
+};
+
+#define DEFINE_ALEFFECT_VTABLE(T)           \
+const struct ALeffectVtable T##_vtable = {  \
+    T##_setParami, T##_setParamiv,          \
+    T##_setParamf, T##_setParamfv,          \
+    T##_getParami, T##_getParamiv,          \
+    T##_getParamf, T##_getParamfv,          \
+}
+
+extern const struct ALeffectVtable ALeaxreverb_vtable;
+extern const struct ALeffectVtable ALreverb_vtable;
+extern const struct ALeffectVtable ALautowah_vtable;
+extern const struct ALeffectVtable ALchorus_vtable;
+extern const struct ALeffectVtable ALcompressor_vtable;
+extern const struct ALeffectVtable ALdistortion_vtable;
+extern const struct ALeffectVtable ALecho_vtable;
+extern const struct ALeffectVtable ALequalizer_vtable;
+extern const struct ALeffectVtable ALflanger_vtable;
+extern const struct ALeffectVtable ALmodulator_vtable;
+extern const struct ALeffectVtable ALnull_vtable;
+extern const struct ALeffectVtable ALdedicated_vtable;
+
+
+typedef union ALeffectProps {
+    struct {
+        // Shared Reverb Properties
+        ALfloat Density;
+        ALfloat Diffusion;
+        ALfloat Gain;
+        ALfloat GainHF;
+        ALfloat DecayTime;
+        ALfloat DecayHFRatio;
+        ALfloat ReflectionsGain;
+        ALfloat ReflectionsDelay;
+        ALfloat LateReverbGain;
+        ALfloat LateReverbDelay;
+        ALfloat AirAbsorptionGainHF;
+        ALfloat RoomRolloffFactor;
+        ALboolean DecayHFLimit;
+
+        // Additional EAX Reverb Properties
+        ALfloat GainLF;
+        ALfloat DecayLFRatio;
+        ALfloat ReflectionsPan[3];
+        ALfloat LateReverbPan[3];
+        ALfloat EchoTime;
+        ALfloat EchoDepth;
+        ALfloat ModulationTime;
+        ALfloat ModulationDepth;
+        ALfloat HFReference;
+        ALfloat LFReference;
+    } Reverb;
+
+    struct {
+        ALfloat AttackTime;
+        ALfloat ReleaseTime;
+        ALfloat PeakGain;
+        ALfloat Resonance;
+    } Autowah;
+
+    struct {
+        ALint Waveform;
+        ALint Phase;
+        ALfloat Rate;
+        ALfloat Depth;
+        ALfloat Feedback;
+        ALfloat Delay;
+    } Chorus;
+
+    struct {
+        ALboolean OnOff;
+    } Compressor;
+
+    struct {
+        ALfloat Edge;
+        ALfloat Gain;
+        ALfloat LowpassCutoff;
+        ALfloat EQCenter;
+        ALfloat EQBandwidth;
+    } Distortion;
+
+    struct {
+        ALfloat Delay;
+        ALfloat LRDelay;
+
+        ALfloat Damping;
+        ALfloat Feedback;
+
+        ALfloat Spread;
+    } Echo;
+
+    struct {
+        ALfloat Delay;
+        ALfloat LowCutoff;
+        ALfloat LowGain;
+        ALfloat Mid1Center;
+        ALfloat Mid1Gain;
+        ALfloat Mid1Width;
+        ALfloat Mid2Center;
+        ALfloat Mid2Gain;
+        ALfloat Mid2Width;
+        ALfloat HighCutoff;
+        ALfloat HighGain;
+    } Equalizer;
+
+    struct {
+        ALint Waveform;
+        ALint Phase;
+        ALfloat Rate;
+        ALfloat Depth;
+        ALfloat Feedback;
+        ALfloat Delay;
+    } Flanger;
+
+    struct {
+        ALfloat Frequency;
+        ALfloat HighPassCutoff;
+        ALint Waveform;
+    } Modulator;
+
+    struct {
+        ALfloat Gain;
+    } Dedicated;
+} ALeffectProps;
+
+typedef struct ALeffect {
+    // Effect type (AL_EFFECT_NULL, ...)
+    ALenum type;
+
+    ALeffectProps Props;
+
+    const struct ALeffectVtable *vtbl;
+
+    /* Self ID */
+    ALuint id;
+} ALeffect;
+
+inline struct ALeffect *LookupEffect(ALCdevice *device, ALuint id)
+{ return (struct ALeffect*)LookupUIntMapKey(&device->EffectMap, id); }
+inline struct ALeffect *RemoveEffect(ALCdevice *device, ALuint id)
+{ return (struct ALeffect*)RemoveUIntMapKey(&device->EffectMap, id); }
+
+inline ALboolean IsReverbEffect(ALenum type)
+{ return type == AL_EFFECT_REVERB || type == AL_EFFECT_EAXREVERB; }
+
+ALenum InitEffect(ALeffect *effect);
+ALvoid ReleaseALEffects(ALCdevice *device);
+
+ALvoid LoadReverbPreset(const char *name, ALeffect *effect);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -1,13 +1,30 @@
 #ifndef _AL_ERROR_H_
 #define _AL_ERROR_H_

-#include "AL/al.h"
+#include "alMain.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

-ALvoid alSetError(ALenum errorCode);
+extern ALboolean TrapALError;
+
+ALvoid alSetError(ALCcontext *Context, ALenum errorCode);
+
+#define SET_ERROR_AND_RETURN(ctx, err) do {                                    \
+    alSetError((ctx), (err));                                                  \
+    return;                                                                    \
+} while(0)
+
+#define SET_ERROR_AND_RETURN_VALUE(ctx, err, val) do {                         \
+    alSetError((ctx), (err));                                                  \
+    return (val);                                                              \
+} while(0)
+
+#define SET_ERROR_AND_GOTO(ctx, err, lbl) do {                                 \
+    alSetError((ctx), (err));                                                  \
+    goto lbl;                                                                  \
+} while(0)

 #ifdef __cplusplus
 }
@@ -1,33 +0,0 @@
-#ifndef _AL_EXTENSION_H_
-#define _AL_EXTENSION_H_
-
-#include "AL/al.h"
-#include "AL/alc.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct ALextension_struct
-{
-	ALchar		*extName;
-	ALvoid		*address;
-} ALextension;
-
-typedef struct ALfunction_struct
-{
-	ALchar		*funcName;
-	ALvoid		*address;
-} ALfunction;
-
-typedef struct ALenum_struct
-{
-	ALchar		*enumName;
-	ALenum		value;
-} ALenums;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -0,0 +1,112 @@
+#ifndef _AL_FILTER_H_
+#define _AL_FILTER_H_
+
+#include "alMain.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LOWPASSFREQREF  (5000.0f)
+#define HIGHPASSFREQREF  (250.0f)
+
+
+/* Filters implementation is based on the "Cookbook formulae for audio   *
+ * EQ biquad filter coefficients" by Robert Bristow-Johnson              *
+ * http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt                   */
+
+typedef enum ALfilterType {
+    /** EFX-style low-pass filter, specifying a gain and reference frequency. */
+    ALfilterType_HighShelf,
+    /** EFX-style high-pass filter, specifying a gain and reference frequency. */
+    ALfilterType_LowShelf,
+    /** Peaking filter, specifying a gain, reference frequency, and bandwidth. */
+    ALfilterType_Peaking,
+
+    /** Low-pass cut-off filter, specifying a cut-off frequency and bandwidth. */
+    ALfilterType_LowPass,
+    /** High-pass cut-off filter, specifying a cut-off frequency and bandwidth. */
+    ALfilterType_HighPass,
+    /** Band-pass filter, specifying a center frequency and bandwidth. */
+    ALfilterType_BandPass,
+} ALfilterType;
+
+typedef struct ALfilterState {
+    ALfloat x[2]; /* History of two last input samples  */
+    ALfloat y[2]; /* History of two last output samples */
+    ALfloat a[3]; /* Transfer function coefficients "a" */
+    ALfloat b[3]; /* Transfer function coefficients "b" */
+
+    void (*process)(struct ALfilterState *self, ALfloat *restrict dst, const ALfloat *src, ALuint numsamples);
+} ALfilterState;
+#define ALfilterState_process(a, ...) ((a)->process((a), __VA_ARGS__))
+
+void ALfilterState_clear(ALfilterState *filter);
+void ALfilterState_setParams(ALfilterState *filter, ALfilterType type, ALfloat gain, ALfloat freq_mult, ALfloat bandwidth);
+
+inline ALfloat ALfilterState_processSingle(ALfilterState *filter, ALfloat sample)
+{
+    ALfloat outsmp;
+
+    outsmp = filter->b[0] * sample +
+             filter->b[1] * filter->x[0] +
+             filter->b[2] * filter->x[1] -
+             filter->a[1] * filter->y[0] -
+             filter->a[2] * filter->y[1];
+    filter->x[1] = filter->x[0];
+    filter->x[0] = sample;
+    filter->y[1] = filter->y[0];
+    filter->y[0] = outsmp;
+
+    return outsmp;
+}
+
+void ALfilterState_processC(ALfilterState *filter, ALfloat *restrict dst, const ALfloat *src, ALuint numsamples);
+
+
+typedef struct ALfilter {
+    // Filter type (AL_FILTER_NULL, ...)
+    ALenum type;
+
+    ALfloat Gain;
+    ALfloat GainHF;
+    ALfloat HFReference;
+    ALfloat GainLF;
+    ALfloat LFReference;
+
+    void (*SetParami)(struct ALfilter *filter, ALCcontext *context, ALenum param, ALint val);
+    void (*SetParamiv)(struct ALfilter *filter, ALCcontext *context, ALenum param, const ALint *vals);
+    void (*SetParamf)(struct ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val);
+    void (*SetParamfv)(struct ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals);
+
+    void (*GetParami)(struct ALfilter *filter, ALCcontext *context, ALenum param, ALint *val);
+    void (*GetParamiv)(struct ALfilter *filter, ALCcontext *context, ALenum param, ALint *vals);
+    void (*GetParamf)(struct ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val);
+    void (*GetParamfv)(struct ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals);
+
+    /* Self ID */
+    ALuint id;
+} ALfilter;
+
+#define ALfilter_SetParami(x, c, p, v)  ((x)->SetParami((x),(c),(p),(v)))
+#define ALfilter_SetParamiv(x, c, p, v) ((x)->SetParamiv((x),(c),(p),(v)))
+#define ALfilter_SetParamf(x, c, p, v)  ((x)->SetParamf((x),(c),(p),(v)))
+#define ALfilter_SetParamfv(x, c, p, v) ((x)->SetParamfv((x),(c),(p),(v)))
+
+#define ALfilter_GetParami(x, c, p, v)  ((x)->GetParami((x),(c),(p),(v)))
+#define ALfilter_GetParamiv(x, c, p, v) ((x)->GetParamiv((x),(c),(p),(v)))
+#define ALfilter_GetParamf(x, c, p, v)  ((x)->GetParamf((x),(c),(p),(v)))
+#define ALfilter_GetParamfv(x, c, p, v) ((x)->GetParamfv((x),(c),(p),(v)))
+
+inline struct ALfilter *LookupFilter(ALCdevice *device, ALuint id)
+{ return (struct ALfilter*)LookupUIntMapKey(&device->FilterMap, id); }
+inline struct ALfilter *RemoveFilter(ALCdevice *device, ALuint id)
+{ return (struct ALfilter*)RemoveUIntMapKey(&device->FilterMap, id); }
+
+ALvoid ReleaseALFilters(ALCdevice *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -1,19 +1,24 @@
 #ifndef _AL_LISTENER_H_
 #define _AL_LISTENER_H_

-#include "AL/al.h"
+#include "alMain.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

-typedef struct ALlistener_struct
-{
-    ALfloat Position[3];
-    ALfloat Velocity[3];
-    ALfloat Forward[3];
-    ALfloat Up[3];
-    ALfloat Gain;
+typedef struct ALlistener {
+    volatile ALfloat Position[3];
+    volatile ALfloat Velocity[3];
+    volatile ALfloat Forward[3];
+    volatile ALfloat Up[3];
+    volatile ALfloat Gain;
+    volatile ALfloat MetersPerUnit;
+
+    struct {
+        ALfloat Matrix[4][4];
+        ALfloat Velocity[3];
+    } Params;
 } ALlistener;

 #ifdef __cplusplus
@@ -0,0 +1,172 @@
+#ifndef ALMIDI_H
+#define ALMIDI_H
+
+#include "alMain.h"
+#include "atomic.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ALsfmodulator {
+    struct {
+        ALenum Input;
+        ALenum Type;
+        ALenum Form;
+    } Source[2];
+    ALint Amount;
+    ALenum TransformOp;
+    ALenum Dest;
+} ALsfmodulator;
+
+typedef struct ALenvelope {
+    ALint DelayTime;
+    ALint AttackTime;
+    ALint HoldTime;
+    ALint DecayTime;
+    ALint SustainAttn;
+    ALint ReleaseTime;
+    ALint KeyToHoldTime;
+    ALint KeyToDecayTime;
+} ALenvelope;
+
+
+typedef struct ALfontsound {
+    RefCount ref;
+
+    struct ALbuffer *Buffer;
+
+    ALint MinKey, MaxKey;
+    ALint MinVelocity, MaxVelocity;
+
+    ALint ModLfoToPitch;
+    ALint VibratoLfoToPitch;
+    ALint ModEnvToPitch;
+
+    ALint FilterCutoff;
+    ALint FilterQ;
+    ALint ModLfoToFilterCutoff;
+    ALint ModEnvToFilterCutoff;
+    ALint ModLfoToVolume;
+
+    ALint ChorusSend;
+    ALint ReverbSend;
+
+    ALint Pan;
+
+    struct {
+        ALint Delay;
+        ALint Frequency;
+    } ModLfo;
+    struct {
+        ALint Delay;
+        ALint Frequency;
+    } VibratoLfo;
+
+    ALenvelope ModEnv;
+    ALenvelope VolEnv;
+
+    ALint Attenuation;
+
+    ALint CoarseTuning;
+    ALint FineTuning;
+
+    ALenum LoopMode;
+
+    ALint TuningScale;
+
+    ALint ExclusiveClass;
+
+    ALuint Start;
+    ALuint End;
+    ALuint LoopStart;
+    ALuint LoopEnd;
+    ALuint SampleRate;
+    ALubyte PitchKey;
+    ALbyte PitchCorrection;
+    ALenum SampleType;
+    struct ALfontsound *Link;
+
+    /* NOTE: Each map entry contains *four* (4) ALsfmodulator objects. */
+    UIntMap ModulatorMap;
+
+    ALuint id;
+} ALfontsound;
+
+void ALfontsound_setPropi(ALfontsound *self, ALCcontext *context, ALenum param, ALint value);
+void ALfontsound_setModStagei(ALfontsound *self, ALCcontext *context, ALsizei stage, ALenum param, ALint value);
+
+ALfontsound *NewFontsound(ALCcontext *context);
+void DeleteFontsound(ALCdevice *device, ALfontsound *sound);
+
+inline struct ALfontsound *LookupFontsound(ALCdevice *device, ALuint id)
+{ return (struct ALfontsound*)LookupUIntMapKey(&device->FontsoundMap, id); }
+inline struct ALfontsound *RemoveFontsound(ALCdevice *device, ALuint id)
+{ return (struct ALfontsound*)RemoveUIntMapKey(&device->FontsoundMap, id); }
+
+void ReleaseALFontsounds(ALCdevice *device);
+
+
+typedef struct ALsfpreset {
+    RefCount ref;
+
+    ALint Preset; /* a.k.a. MIDI program number */
+    ALint Bank; /* MIDI bank 0...127, or percussion (bank 128) */
+
+    ALfontsound **Sounds;
+    ALsizei NumSounds;
+
+    ALuint id;
+} ALsfpreset;
+
+ALsfpreset *NewPreset(ALCcontext *context);
+void DeletePreset(ALCdevice *device, ALsfpreset *preset);
+
+inline struct ALsfpreset *LookupPreset(ALCdevice *device, ALuint id)
+{ return (struct ALsfpreset*)LookupUIntMapKey(&device->PresetMap, id); }
+inline struct ALsfpreset *RemovePreset(ALCdevice *device, ALuint id)
+{ return (struct ALsfpreset*)RemoveUIntMapKey(&device->PresetMap, id); }
+
+void ReleaseALPresets(ALCdevice *device);
+
+
+typedef struct ALsoundfont {
+    RefCount ref;
+
+    ALsfpreset **Presets;
+    ALsizei NumPresets;
+
+    RWLock Lock;
+
+    ALuint id;
+} ALsoundfont;
+
+ALsoundfont *ALsoundfont_getDefSoundfont(ALCcontext *context);
+void ALsoundfont_deleteSoundfont(ALsoundfont *self, ALCdevice *device);
+
+inline struct ALsoundfont *LookupSfont(ALCdevice *device, ALuint id)
+{ return (struct ALsoundfont*)LookupUIntMapKey(&device->SfontMap, id); }
+inline struct ALsoundfont *RemoveSfont(ALCdevice *device, ALuint id)
+{ return (struct ALsoundfont*)RemoveUIntMapKey(&device->SfontMap, id); }
+
+void ReleaseALSoundfonts(ALCdevice *device);
+
+
+inline ALboolean IsValidCtrlInput(int cc)
+{
+    /* These correspond to MIDI functions, not real controller values. */
+    if(cc == 0 || cc == 6 || cc == 32 || cc == 38 || (cc >= 98 && cc <= 101) || cc >= 120)
+        return AL_FALSE;
+    /* These are the LSB components of CC0...CC31, which are automatically used when
+     * reading the MSB controller value. */
+    if(cc >= 32 && cc <= 63)
+        return AL_FALSE;
+    /* All the rest are okay! */
+    return AL_TRUE;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ALMIDI_H */
@@ -1,69 +1,145 @@
 #ifndef _AL_SOURCE_H_
 #define _AL_SOURCE_H_

-#define AL_NUM_SOURCE_PARAMS    128
+#define MAX_SENDS                 4

-#include "AL/al.h"
+#include "alMain.h"
+#include "alu.h"
+#include "hrtf.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

-typedef struct ALbufferlistitem
-{
-    ALuint                   buffer;
-    ALuint                   bufferstate;
-    ALuint                   flag;
-    struct ALbufferlistitem *next;
+extern enum Resampler DefaultResampler;
+
+extern const ALsizei ResamplerPadding[ResamplerMax];
+extern const ALsizei ResamplerPrePadding[ResamplerMax];
+
+
+typedef struct ALbufferlistitem {
+    struct ALbuffer *buffer;
+    struct ALbufferlistitem *volatile next;
+    struct ALbufferlistitem *volatile prev;
 } ALbufferlistitem;

-typedef struct ALsource
-{
-    ALfloat      flPitch;
-    ALfloat      flGain;
-    ALfloat      flOuterGain;
-    ALfloat      flMinGain;
-    ALfloat      flMaxGain;
-    ALfloat      flInnerAngle;
-    ALfloat      flOuterAngle;
-    ALfloat      flRefDistance;
-    ALfloat      flMaxDistance;
-    ALfloat      flRollOffFactor;
-    ALfloat      vPosition[3];
-    ALfloat      vVelocity[3];
-    ALfloat      vOrientation[3];
-    ALboolean    bHeadRelative;
-    ALboolean    bLooping;

-    ALuint       ulBufferID;
+typedef struct ALactivesource {
+    struct ALsource *Source;

-    ALboolean    inuse;
-    ALboolean    play;
-    ALenum       state;
-    ALuint       position;
-    ALuint       position_fraction;
-    struct ALbufferlistitem *queue; // Linked list of buffers in queue
-    ALuint       BuffersInQueue;    // Number of buffers in queue
-    ALuint       BuffersProcessed;  // Number of buffers already processed (played)
+    /** Method to update mixing parameters. */
+    ALvoid (*Update)(struct ALactivesource *self, const ALCcontext *context);

-    ALuint TotalBufferDataSize; // Total amount of data contained in the buffers queued for this source
-    ALuint BuffersPlayed;       // Number of buffers played on this loop
-    ALuint BufferPosition;      // Read position in audio data of current buffer
+    /** Current target parameters used for mixing. */
+    ALint Step;

-    // Index to itself
-    ALuint source;
+    ALboolean IsHrtf;

-    ALint  lBytesPlayed;
+    ALuint Offset; /* Number of output samples mixed since starting. */

-    ALint  lOffset;
-    ALint  lOffsetType;
+    DirectParams Direct;
+    SendParams Send[MAX_SENDS];
+} ALactivesource;

-    // Source Type (Static, Streaming, or Undetermined)
-    ALint  lSourceType;

-    struct ALsource *next;
+typedef struct ALsource {
+    /** Source properties. */
+    volatile ALfloat   Pitch;
+    volatile ALfloat   Gain;
+    volatile ALfloat   OuterGain;
+    volatile ALfloat   MinGain;
+    volatile ALfloat   MaxGain;
+    volatile ALfloat   InnerAngle;
+    volatile ALfloat   OuterAngle;
+    volatile ALfloat   RefDistance;
+    volatile ALfloat   MaxDistance;
+    volatile ALfloat   RollOffFactor;
+    volatile ALfloat   Position[3];
+    volatile ALfloat   Velocity[3];
+    volatile ALfloat   Orientation[3];
+    volatile ALboolean HeadRelative;
+    volatile ALboolean Looping;
+    volatile enum DistanceModel DistanceModel;
+    volatile ALboolean DirectChannels;
+
+    volatile ALboolean DryGainHFAuto;
+    volatile ALboolean WetGainAuto;
+    volatile ALboolean WetGainHFAuto;
+    volatile ALfloat   OuterGainHF;
+
+    volatile ALfloat AirAbsorptionFactor;
+    volatile ALfloat RoomRolloffFactor;
+    volatile ALfloat DopplerFactor;
+
+    volatile ALfloat Radius;
+
+    enum Resampler Resampler;
+
+    /**
+     * Last user-specified offset, and the offset type (bytes, samples, or
+     * seconds).
+     */
+    ALdouble Offset;
+    ALenum   OffsetType;
+
+    /** Source type (static, streaming, or undetermined) */
+    volatile ALint SourceType;
+
+    /** Source state (initial, playing, paused, or stopped) */
+    volatile ALenum state;
+    ALenum new_state;
+
+    /**
+     * Source offset in samples, relative to the currently playing buffer, NOT
+     * the whole queue, and the fractional (fixed-point) offset to the next
+     * sample.
+     */
+    ALuint position;
+    ALuint position_fraction;
+
+    /** Source Buffer Queue info. */
+    ATOMIC(ALbufferlistitem*) queue;
+    ATOMIC(ALbufferlistitem*) current_buffer;
+    RWLock queue_lock;
+
+    /** Current buffer sample info. */
+    ALuint NumChannels;
+    ALuint SampleSize;
+
+    /** Direct filter and auxiliary send info. */
+    struct {
+        ALfloat Gain;
+        ALfloat GainHF;
+        ALfloat HFReference;
+        ALfloat GainLF;
+        ALfloat LFReference;
+    } Direct;
+    struct {
+        struct ALeffectslot *Slot;
+        ALfloat Gain;
+        ALfloat GainHF;
+        ALfloat HFReference;
+        ALfloat GainLF;
+        ALfloat LFReference;
+    } Send[MAX_SENDS];
+
+    /** Source needs to update its mixing parameters. */
+    ATOMIC(ALenum) NeedsUpdate;
+
+    /** Self ID */
+    ALuint id;
 } ALsource;

+inline struct ALsource *LookupSource(ALCcontext *context, ALuint id)
+{ return (struct ALsource*)LookupUIntMapKey(&context->SourceMap, id); }
+inline struct ALsource *RemoveSource(ALCcontext *context, ALuint id)
+{ return (struct ALsource*)RemoveUIntMapKey(&context->SourceMap, id); }
+
+ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state);
+ALboolean ApplyOffset(ALsource *Source);
+
+ALvoid ReleaseALSources(ALCcontext *Context);
+
 #ifdef __cplusplus
 }
 #endif
@@ -1,14 +0,0 @@
-#ifndef _AL_STATE_H_
-#define _AL_STATE_H_
-
-#include "AL/al.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -1,42 +1,20 @@
-#ifndef _AL_THUNK_H_
-#define _AL_THUNK_H_
+#ifndef ALTHUNK_H
+#define ALTHUNK_H

-#include "config.h"
-
-#include "AL/al.h"
-#include "AL/alc.h"
+#include "alMain.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

-void alThunkInit(void);
-void alThunkExit(void);
-ALuint alThunkAddEntry(ALvoid * ptr);
-void alThunkRemoveEntry(ALuint index);
-ALvoid *alThunkLookupEntry(ALuint index);
-
-#if (SIZEOF_VOIDP > SIZEOF_UINT)
-
-#define ALTHUNK_INIT()          alThunkInit()
-#define ALTHUNK_EXIT()          alThunkExit()
-#define ALTHUNK_ADDENTRY(p)     alThunkAddEntry(p)
-#define ALTHUNK_REMOVEENTRY(i)  alThunkRemoveEntry(i)
-#define ALTHUNK_LOOKUPENTRY(i)  alThunkLookupEntry(i)
-
-#else
-
-#define ALTHUNK_INIT()
-#define ALTHUNK_EXIT()
-#define ALTHUNK_ADDENTRY(p)     ((ALuint)p)
-#define ALTHUNK_REMOVEENTRY(i)
-#define ALTHUNK_LOOKUPENTRY(i)  ((ALvoid*)(i))
-
-#endif // (SIZEOF_VOIDP > SIZEOF_INT)
+void ThunkInit(void);
+void ThunkExit(void);
+ALenum NewThunkEntry(ALuint *index);
+void FreeThunkEntry(ALuint index);

 #ifdef __cplusplus
 }
 #endif

-#endif //_AL_THUNK_H_
+#endif //ALTHUNK_H

@@ -1,16 +1,232 @@
 #ifndef _ALU_H_
 #define _ALU_H_

-#include "AL/al.h"
-#include "AL/alc.h"
+#include <limits.h>
+#include <math.h>
+#ifdef HAVE_FLOAT_H
+#include <float.h>
+#endif
+#ifdef HAVE_IEEEFP_H
+#include <ieeefp.h>
+#endif
+
+#include "alMain.h"
+#include "alBuffer.h"
+#include "alFilter.h"
+
+#include "hrtf.h"
+#include "align.h"
+
+
+#define F_PI    (3.14159265358979323846f)
+#define F_PI_2  (1.57079632679489661923f)
+#define F_2PI   (6.28318530717958647692f)
+
+#ifndef FLT_EPSILON
+#define FLT_EPSILON (1.19209290e-07f)
+#endif
+
+#define DEG2RAD(x)  ((ALfloat)(x) * (F_PI/180.0f))
+#define RAD2DEG(x)  ((ALfloat)(x) * (180.0f/F_PI))
+
+
+#define SRC_HISTORY_BITS   (6)
+#define SRC_HISTORY_LENGTH (1<<SRC_HISTORY_BITS)
+#define SRC_HISTORY_MASK   (SRC_HISTORY_LENGTH-1)
+
+#define MAX_PITCH  (10)
+

 #ifdef __cplusplus
 extern "C" {
 #endif

-__inline ALuint aluBytesFromFormat(ALenum format);
-__inline ALuint aluChannelsFromFormat(ALenum format);
-ALvoid aluMixData(ALCcontext *context,ALvoid *buffer,ALsizei size,ALenum format);
+enum ActiveFilters {
+    AF_None = 0,
+    AF_LowPass = 1,
+    AF_HighPass = 2,
+    AF_BandPass = AF_LowPass | AF_HighPass
+};
+
+
+typedef struct HrtfState {
+    alignas(16) ALfloat History[SRC_HISTORY_LENGTH];
+    alignas(16) ALfloat Values[HRIR_LENGTH][2];
+} HrtfState;
+
+typedef struct HrtfParams {
+    alignas(16) ALfloat Coeffs[HRIR_LENGTH][2];
+    alignas(16) ALfloat CoeffStep[HRIR_LENGTH][2];
+    ALuint Delay[2];
+    ALint DelayStep[2];
+} HrtfParams;
+
+
+typedef struct MixGains {
+    ALfloat Current;
+    ALfloat Step;
+    ALfloat Target;
+} MixGains;
+
+
+typedef struct DirectParams {
+    ALfloat (*OutBuffer)[BUFFERSIZE];
+
+    /* If not 'moving', gain/coefficients are set directly without fading. */
+    ALboolean Moving;
+    /* Stepping counter for gain/coefficient fading. */
+    ALuint Counter;
+
+    struct {
+        enum ActiveFilters ActiveType;
+        ALfilterState LowPass;
+        ALfilterState HighPass;
+    } Filters[MAX_INPUT_CHANNELS];
+
+    union {
+        struct {
+            HrtfParams Params[MAX_INPUT_CHANNELS];
+            HrtfState State[MAX_INPUT_CHANNELS];
+            ALuint IrSize;
+            ALfloat Gain;
+            ALfloat Dir[3];
+        } Hrtf;
+
+        MixGains Gains[MAX_INPUT_CHANNELS][MaxChannels];
+    } Mix;
+} DirectParams;
+
+typedef struct SendParams {
+    ALfloat (*OutBuffer)[BUFFERSIZE];
+
+    ALboolean Moving;
+    ALuint Counter;
+
+    struct {
+        enum ActiveFilters ActiveType;
+        ALfilterState LowPass;
+        ALfilterState HighPass;
+    } Filters[MAX_INPUT_CHANNELS];
+
+    /* Gain control, which applies to all input channels to a single (mono)
+     * output buffer. */
+    MixGains Gain;
+} SendParams;
+
+
+typedef const ALfloat* (*ResamplerFunc)(const ALfloat *src, ALuint frac, ALuint increment,
+                                        ALfloat *restrict dst, ALuint dstlen);
+
+typedef void (*MixerFunc)(const ALfloat *data, ALuint OutChans,
+                          ALfloat (*restrict OutBuffer)[BUFFERSIZE], struct MixGains *Gains,
+                          ALuint Counter, ALuint OutPos, ALuint BufferSize);
+typedef void (*HrtfMixerFunc)(ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat *data,
+                              ALuint Counter, ALuint Offset, ALuint OutPos,
+                              const ALuint IrSize, const HrtfParams *hrtfparams,
+                              HrtfState *hrtfstate, ALuint BufferSize);
+
+
+#define GAIN_SILENCE_THRESHOLD  (0.00001f) /* -100dB */
+
+#define SPEEDOFSOUNDMETRESPERSEC  (343.3f)
+#define AIRABSORBGAINHF           (0.99426f) /* -0.05dB */
+
+#define FRACTIONBITS (14)
+#define FRACTIONONE  (1<<FRACTIONBITS)
+#define FRACTIONMASK (FRACTIONONE-1)
+
+
+inline ALfloat minf(ALfloat a, ALfloat b)
+{ return ((a > b) ? b : a); }
+inline ALfloat maxf(ALfloat a, ALfloat b)
+{ return ((a > b) ? a : b); }
+inline ALfloat clampf(ALfloat val, ALfloat min, ALfloat max)
+{ return minf(max, maxf(min, val)); }
+
+inline ALdouble mind(ALdouble a, ALdouble b)
+{ return ((a > b) ? b : a); }
+inline ALdouble maxd(ALdouble a, ALdouble b)
+{ return ((a > b) ? a : b); }
+inline ALdouble clampd(ALdouble val, ALdouble min, ALdouble max)
+{ return mind(max, maxd(min, val)); }
+
+inline ALuint minu(ALuint a, ALuint b)
+{ return ((a > b) ? b : a); }
+inline ALuint maxu(ALuint a, ALuint b)
+{ return ((a > b) ? a : b); }
+inline ALuint clampu(ALuint val, ALuint min, ALuint max)
+{ return minu(max, maxu(min, val)); }
+
+inline ALint mini(ALint a, ALint b)
+{ return ((a > b) ? b : a); }
+inline ALint maxi(ALint a, ALint b)
+{ return ((a > b) ? a : b); }
+inline ALint clampi(ALint val, ALint min, ALint max)
+{ return mini(max, maxi(min, val)); }
+
+inline ALint64 mini64(ALint64 a, ALint64 b)
+{ return ((a > b) ? b : a); }
+inline ALint64 maxi64(ALint64 a, ALint64 b)
+{ return ((a > b) ? a : b); }
+inline ALint64 clampi64(ALint64 val, ALint64 min, ALint64 max)
+{ return mini64(max, maxi64(min, val)); }
+
+inline ALuint64 minu64(ALuint64 a, ALuint64 b)
+{ return ((a > b) ? b : a); }
+inline ALuint64 maxu64(ALuint64 a, ALuint64 b)
+{ return ((a > b) ? a : b); }
+inline ALuint64 clampu64(ALuint64 val, ALuint64 min, ALuint64 max)
+{ return minu64(max, maxu64(min, val)); }
+
+
+inline ALfloat lerp(ALfloat val1, ALfloat val2, ALfloat mu)
+{
+    return val1 + (val2-val1)*mu;
+}
+inline ALfloat cubic(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat val3, ALfloat mu)
+{
+    ALfloat mu2 = mu*mu;
+    ALfloat a0 = -0.5f*val0 +  1.5f*val1 + -1.5f*val2 +  0.5f*val3;
+    ALfloat a1 =       val0 + -2.5f*val1 +  2.0f*val2 + -0.5f*val3;
+    ALfloat a2 = -0.5f*val0              +  0.5f*val2;
+    ALfloat a3 =                    val1;
+
+    return a0*mu*mu2 + a1*mu2 + a2*mu + a3;
+}
+
+
+ALvoid aluInitPanning(ALCdevice *Device);
+
+/**
+ * ComputeAngleGains
+ *
+ * Sets channel gains based on a given source's angle and its half-width. The
+ * angle and hwidth parameters are in radians.
+ */
+void ComputeAngleGains(const ALCdevice *device, ALfloat angle, ALfloat hwidth, ALfloat ingain, ALfloat gains[MaxChannels]);
+
+/**
+ * SetGains
+ *
+ * Helper to set the appropriate channels to the specified gain.
+ */
+inline void SetGains(const ALCdevice *device, ALfloat ingain, ALfloat gains[MaxChannels])
+{
+    ComputeAngleGains(device, 0.0f, F_PI, ingain, gains);
+}
+
+
+ALvoid CalcSourceParams(struct ALactivesource *src, const ALCcontext *ALContext);
+ALvoid CalcNonAttnSourceParams(struct ALactivesource *src, const ALCcontext *ALContext);
+
+ALvoid MixSource(struct ALactivesource *src, ALCdevice *Device, ALuint SamplesToDo);
+
+ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size);
+/* Caller must lock the device. */
+ALvoid aluHandleDisconnect(ALCdevice *device);
+
+extern ALfloat ConeScale;
+extern ALfloat ZScale;

 #ifdef __cplusplus
 }
@@ -1,109 +1,128 @@
-/*-
- * Copyright (c) 2005 Boris Mikhaylov
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef BS2B_H
-#define BS2B_H
-
-/* Number of crossfeed levels */
-#define BS2B_CLEVELS           3
-
-/* Normal crossfeed levels */
-#define BS2B_HIGH_CLEVEL       3
-#define BS2B_MIDDLE_CLEVEL     2
-#define BS2B_LOW_CLEVEL        1
-
-/* Easy crossfeed levels */
-#define BS2B_HIGH_ECLEVEL      BS2B_HIGH_CLEVEL    + BS2B_CLEVELS
-#define BS2B_MIDDLE_ECLEVEL    BS2B_MIDDLE_CLEVEL  + BS2B_CLEVELS
-#define BS2B_LOW_ECLEVEL       BS2B_LOW_CLEVEL     + BS2B_CLEVELS
-
-/* Default crossfeed levels */
-#define BS2B_DEFAULT_CLEVEL    BS2B_HIGH_ECLEVEL
-/* Default sample rate (Hz) */
-#define BS2B_DEFAULT_SRATE     44100
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-struct bs2b {
-    int level;  /* Crossfeed level */
-    int srate;   /* Sample rate (Hz) */
-
-    /* Lowpass IIR filter coefficients */
-    double a0_lo;
-    double b1_lo;
-
-    /* Highboost IIR filter coefficients */
-    double a0_hi;
-    double a1_hi;
-    double b1_hi;
-
-    /* Global gain against overloading */
-    double gain;
-
-    /* Buffer of last filtered sample.
-     * [0] - first channel, [1] - second channel
-     */
-    struct t_last_sample {
-        double asis[2];
-        double lo[2];
-        double hi[2];
-    } last_sample;
-};
-
-/* Clear buffers and set new coefficients with new crossfeed level value.
- * level - crossfeed level of *LEVEL values.
- */
-void bs2b_set_level(struct bs2b *bs2b, int level);
-
-/* Return current crossfeed level value */
-int bs2b_get_level(struct bs2b *bs2b);
-
-/* Clear buffers and set new coefficients with new sample rate value.
- * srate - sample rate by Hz.
- */
-void bs2b_set_srate(struct bs2b *bs2b, int srate);
-
-/* Return current sample rate value */
-int bs2b_get_srate(struct bs2b *bs2b);
-
-/* Clear buffer */
-void bs2b_clear(struct bs2b *bs2b);
-
-/* Return 1 if buffer is clear */
-int bs2b_is_clear(struct bs2b *bs2b);
-
-/* Crossfeeds one stereo sample that are pointed by sample.
- * [0] - first channel, [1] - second channel.
- * Returns crossfided samle by sample pointer.
- */
-
-/* sample poits to floats */
-void bs2b_cross_feed(struct bs2b *bs2b, float *sample);
-
-#ifdef __cplusplus
-}    /* extern "C" */
-#endif /* __cplusplus */
-
-#endif /* BS2B_H */
+/*-
+ * Copyright (c) 2005 Boris Mikhaylov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef BS2B_H
+#define BS2B_H
+
+/* Number of crossfeed levels */
+#define BS2B_CLEVELS           3
+
+/* Normal crossfeed levels */
+#define BS2B_HIGH_CLEVEL       3
+#define BS2B_MIDDLE_CLEVEL     2
+#define BS2B_LOW_CLEVEL        1
+
+/* Easy crossfeed levels */
+#define BS2B_HIGH_ECLEVEL      BS2B_HIGH_CLEVEL    + BS2B_CLEVELS
+#define BS2B_MIDDLE_ECLEVEL    BS2B_MIDDLE_CLEVEL  + BS2B_CLEVELS
+#define BS2B_LOW_ECLEVEL       BS2B_LOW_CLEVEL     + BS2B_CLEVELS
+
+/* Default crossfeed levels */
+#define BS2B_DEFAULT_CLEVEL    BS2B_HIGH_ECLEVEL
+/* Default sample rate (Hz) */
+#define BS2B_DEFAULT_SRATE     44100
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+struct bs2b {
+    int level;  /* Crossfeed level */
+    int srate;   /* Sample rate (Hz) */
+
+    /* Lowpass IIR filter coefficients */
+    float a0_lo;
+    float b1_lo;
+
+    /* Highboost IIR filter coefficients */
+    float a0_hi;
+    float a1_hi;
+    float b1_hi;
+
+    /* Buffer of last filtered sample.
+     * [0] - first channel, [1] - second channel
+     */
+    struct t_last_sample {
+        float asis[2];
+        float lo[2];
+        float hi[2];
+    } last_sample;
+};
+
+/* Clear buffers and set new coefficients with new crossfeed level value.
+ * level - crossfeed level of *LEVEL values.
+ */
+void bs2b_set_level(struct bs2b *bs2b, int level);
+
+/* Return current crossfeed level value */
+int bs2b_get_level(struct bs2b *bs2b);
+
+/* Clear buffers and set new coefficients with new sample rate value.
+ * srate - sample rate by Hz.
+ */
+void bs2b_set_srate(struct bs2b *bs2b, int srate);
+
+/* Return current sample rate value */
+int bs2b_get_srate(struct bs2b *bs2b);
+
+/* Clear buffer */
+void bs2b_clear(struct bs2b *bs2b);
+
+/* Crossfeeds one stereo sample that are pointed by sample.
+ * [0] - first channel, [1] - second channel.
+ * Returns crossfided sample by sample pointer.
+ */
+inline void bs2b_cross_feed(struct bs2b *bs2b, float *restrict sample)
+{
+/* Single pole IIR filter.
+ * O[n] = a0*I[n] + a1*I[n-1] + b1*O[n-1]
+ */
+
+/* Lowpass filter */
+#define lo_filter(in, out_1) (bs2b->a0_lo*(in) + bs2b->b1_lo*(out_1))
+
+/* Highboost filter */
+#define hi_filter(in, in_1, out_1) (bs2b->a0_hi*(in) + bs2b->a1_hi*(in_1) + bs2b->b1_hi*(out_1))
+
+    /* Lowpass filter */
+    bs2b->last_sample.lo[0] = lo_filter(sample[0], bs2b->last_sample.lo[0]);
+    bs2b->last_sample.lo[1] = lo_filter(sample[1], bs2b->last_sample.lo[1]);
+
+    /* Highboost filter */
+    bs2b->last_sample.hi[0] = hi_filter(sample[0], bs2b->last_sample.asis[0], bs2b->last_sample.hi[0]);
+    bs2b->last_sample.hi[1] = hi_filter(sample[1], bs2b->last_sample.asis[1], bs2b->last_sample.hi[1]);
+    bs2b->last_sample.asis[0] = sample[0];
+    bs2b->last_sample.asis[1] = sample[1];
+
+    /* Crossfeed */
+    sample[0] = bs2b->last_sample.hi[0] + bs2b->last_sample.lo[1];
+    sample[1] = bs2b->last_sample.hi[1] + bs2b->last_sample.lo[0];
+#undef hi_filter
+#undef lo_filter
+} /* bs2b_cross_feed */
+
+#ifdef __cplusplus
+}    /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* BS2B_H */
@@ -0,0 +1,9 @@
+#ifndef SAMPLE_CVT_H
+#define SAMPLE_CVT_H
+
+#include "AL/al.h"
+#include "alBuffer.h"
+
+void ConvertData(ALvoid *dst, enum UserFmtType dstType, const ALvoid *src, enum UserFmtType srcType, ALsizei numchans, ALsizei len, ALsizei align);
+
+#endif /* SAMPLE_CVT_H */
@@ -1,63 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#include "alMain.h"
-#include "alBuffer.h"
-#include "alThunk.h"
-
-CRITICAL_SECTION _alMutex;
-
-#ifdef _WIN32
-BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
-{
-    (void)lpReserved;
-
-    // Perform actions based on the reason for calling.
-    switch(ul_reason_for_call)
-    {
-        case DLL_PROCESS_ATTACH:
-            DisableThreadLibraryCalls(hModule);
-            break;
-
-        case DLL_PROCESS_DETACH:
-            ReleaseALBuffers();
-            FreeALConfig();
-            ALTHUNK_EXIT();
-            DeleteCriticalSection(&_alMutex);
-            break;
-    }
-    return TRUE;
-}
-#else
-#ifdef HAVE_GCC_DESTRUCTOR
-static void my_deinit() __attribute__((destructor));
-static void my_deinit()
-{
-    static ALenum once = AL_FALSE;
-    if(once) return;
-    once = AL_TRUE;
-
-    ReleaseALBuffers();
-    FreeALConfig();
-    ALTHUNK_EXIT();
-    DeleteCriticalSection(&_alMutex);
-}
-#endif
-#endif
@@ -0,0 +1,550 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alAuxEffectSlot.h"
+#include "alThunk.h"
+#include "alError.h"
+#include "alSource.h"
+
+
+extern inline struct ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id);
+extern inline struct ALeffectslot *RemoveEffectSlot(ALCcontext *context, ALuint id);
+
+static ALenum AddEffectSlotArray(ALCcontext *Context, ALeffectslot **start, ALsizei count);
+static void RemoveEffectSlotArray(ALCcontext *Context, const ALeffectslot *slot);
+
+
+static UIntMap EffectStateFactoryMap;
+static inline ALeffectStateFactory *getFactoryByType(ALenum type)
+{
+    ALeffectStateFactory* (*getFactory)(void) = LookupUIntMapKey(&EffectStateFactoryMap, type);
+    if(getFactory != NULL)
+        return getFactory();
+    return NULL;
+}
+
+
+AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
+{
+    ALCcontext *context;
+    VECTOR(ALeffectslot*) slotvec;
+    ALsizei cur;
+    ALenum err;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    VECTOR_INIT(slotvec);
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    if(!VECTOR_RESERVE(slotvec, n))
+        SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
+
+    for(cur = 0;cur < n;cur++)
+    {
+        ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
+        err = AL_OUT_OF_MEMORY;
+        if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
+        {
+            al_free(slot);
+            alDeleteAuxiliaryEffectSlots(cur, effectslots);
+            SET_ERROR_AND_GOTO(context, err, done);
+        }
+
+        err = NewThunkEntry(&slot->id);
+        if(err == AL_NO_ERROR)
+            err = InsertUIntMapEntry(&context->EffectSlotMap, slot->id, slot);
+        if(err != AL_NO_ERROR)
+        {
+            FreeThunkEntry(slot->id);
+            DELETE_OBJ(slot->EffectState);
+            al_free(slot);
+
+            alDeleteAuxiliaryEffectSlots(cur, effectslots);
+            SET_ERROR_AND_GOTO(context, err, done);
+        }
+
+        VECTOR_PUSH_BACK(slotvec, slot);
+
+        effectslots[cur] = slot->id;
+    }
+    err = AddEffectSlotArray(context, VECTOR_ITER_BEGIN(slotvec), n);
+    if(err != AL_NO_ERROR)
+    {
+        alDeleteAuxiliaryEffectSlots(cur, effectslots);
+        SET_ERROR_AND_GOTO(context, err, done);
+    }
+
+done:
+    VECTOR_DEINIT(slotvec);
+
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots)
+{
+    ALCcontext *context;
+    ALeffectslot *slot;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    for(i = 0;i < n;i++)
+    {
+        if((slot=LookupEffectSlot(context, effectslots[i])) == NULL)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        if(ReadRef(&slot->ref) != 0)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    }
+
+    // All effectslots are valid
+    for(i = 0;i < n;i++)
+    {
+        if((slot=RemoveEffectSlot(context, effectslots[i])) == NULL)
+            continue;
+        FreeThunkEntry(slot->id);
+
+        RemoveEffectSlotArray(context, slot);
+        DELETE_OBJ(slot->EffectState);
+
+        memset(slot, 0, sizeof(*slot));
+        al_free(slot);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
+{
+    ALCcontext *context;
+    ALboolean  ret;
+
+    context = GetContextRef();
+    if(!context) return AL_FALSE;
+
+    ret = (LookupEffectSlot(context, effectslot) ? AL_TRUE : AL_FALSE);
+
+    ALCcontext_DecRef(context);
+
+    return ret;
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint value)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALeffectslot *slot;
+    ALeffect *effect = NULL;
+    ALenum err;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if((slot=LookupEffectSlot(context, effectslot)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    case AL_EFFECTSLOT_EFFECT:
+        effect = (value ? LookupEffect(device, value) : NULL);
+        if(!(value == 0 || effect != NULL))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+        err = InitializeEffect(device, slot, effect);
+        if(err != AL_NO_ERROR)
+            SET_ERROR_AND_GOTO(context, err, done);
+        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+        break;
+
+    case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+        if(!(value == AL_TRUE || value == AL_FALSE))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+        slot->AuxSendAuto = value;
+        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *values)
+{
+    ALCcontext *context;
+
+    switch(param)
+    {
+    case AL_EFFECTSLOT_EFFECT:
+    case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+        alAuxiliaryEffectSloti(effectslot, param, values[0]);
+        return;
+    }
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(LookupEffectSlot(context, effectslot) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat value)
+{
+    ALCcontext *context;
+    ALeffectslot *slot;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if((slot=LookupEffectSlot(context, effectslot)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    case AL_EFFECTSLOT_GAIN:
+        if(!(value >= 0.0f && value <= 1.0f))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+        slot->Gain = value;
+        ATOMIC_STORE(&slot->NeedsUpdate, AL_TRUE);
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *values)
+{
+    ALCcontext *context;
+
+    switch(param)
+    {
+    case AL_EFFECTSLOT_GAIN:
+        alAuxiliaryEffectSlotf(effectslot, param, values[0]);
+        return;
+    }
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(LookupEffectSlot(context, effectslot) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *value)
+{
+    ALCcontext *context;
+    ALeffectslot *slot;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if((slot=LookupEffectSlot(context, effectslot)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+        *value = slot->AuxSendAuto;
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *values)
+{
+    ALCcontext *context;
+
+    switch(param)
+    {
+    case AL_EFFECTSLOT_EFFECT:
+    case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
+        alGetAuxiliaryEffectSloti(effectslot, param, values);
+        return;
+    }
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(LookupEffectSlot(context, effectslot) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value)
+{
+    ALCcontext *context;
+    ALeffectslot *slot;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if((slot=LookupEffectSlot(context, effectslot)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    case AL_EFFECTSLOT_GAIN:
+        *value = slot->Gain;
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *values)
+{
+    ALCcontext *context;
+
+    switch(param)
+    {
+    case AL_EFFECTSLOT_GAIN:
+        alGetAuxiliaryEffectSlotf(effectslot, param, values);
+        return;
+    }
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(LookupEffectSlot(context, effectslot) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+
+static ALenum AddEffectSlotArray(ALCcontext *context, ALeffectslot **start, ALsizei count)
+{
+    ALenum err = AL_NO_ERROR;
+
+    LockContext(context);
+    if(!VECTOR_INSERT(context->ActiveAuxSlots, VECTOR_ITER_END(context->ActiveAuxSlots), start, start+count))
+        err = AL_OUT_OF_MEMORY;
+    UnlockContext(context);
+
+    return err;
+}
+
+static void RemoveEffectSlotArray(ALCcontext *context, const ALeffectslot *slot)
+{
+    ALeffectslot **iter;
+
+    LockContext(context);
+#define MATCH_SLOT(_i)  (slot == *(_i))
+    VECTOR_FIND_IF(iter, ALeffectslot*, context->ActiveAuxSlots, MATCH_SLOT);
+    if(iter != VECTOR_ITER_END(context->ActiveAuxSlots))
+    {
+        *iter = VECTOR_BACK(context->ActiveAuxSlots);
+        VECTOR_POP_BACK(context->ActiveAuxSlots);
+    }
+#undef MATCH_SLOT
+    UnlockContext(context);
+}
+
+
+void InitEffectFactoryMap(void)
+{
+    InitUIntMap(&EffectStateFactoryMap, ~0);
+
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_NULL, ALnullStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_EAXREVERB, ALreverbStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_REVERB, ALreverbStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_AUTOWAH, ALautowahStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_CHORUS, ALchorusStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_COMPRESSOR, ALcompressorStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DISTORTION, ALdistortionStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_ECHO, ALechoStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_EQUALIZER, ALequalizerStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_FLANGER, ALflangerStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_RING_MODULATOR, ALmodulatorStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DEDICATED_DIALOGUE, ALdedicatedStateFactory_getFactory);
+    InsertUIntMapEntry(&EffectStateFactoryMap, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, ALdedicatedStateFactory_getFactory);
+}
+
+void DeinitEffectFactoryMap(void)
+{
+    ResetUIntMap(&EffectStateFactoryMap);
+}
+
+
+ALenum InitializeEffect(ALCdevice *Device, ALeffectslot *EffectSlot, ALeffect *effect)
+{
+    ALenum newtype = (effect ? effect->type : AL_EFFECT_NULL);
+    ALeffectStateFactory *factory;
+
+    if(newtype != EffectSlot->EffectType)
+    {
+        ALeffectState *State;
+        FPUCtl oldMode;
+
+        factory = getFactoryByType(newtype);
+        if(!factory)
+        {
+            ERR("Failed to find factory for effect type 0x%04x\n", newtype);
+            return AL_INVALID_ENUM;
+        }
+        State = V0(factory,create)();
+        if(!State)
+            return AL_OUT_OF_MEMORY;
+
+        SetMixerFPUMode(&oldMode);
+
+        ALCdevice_Lock(Device);
+        if(V(State,deviceUpdate)(Device) == AL_FALSE)
+        {
+            ALCdevice_Unlock(Device);
+            RestoreFPUMode(&oldMode);
+            DELETE_OBJ(State);
+            return AL_OUT_OF_MEMORY;
+        }
+
+        State = ExchangePtr((XchgPtr*)&EffectSlot->EffectState, State);
+        if(!effect)
+        {
+            memset(&EffectSlot->EffectProps, 0, sizeof(EffectSlot->EffectProps));
+            EffectSlot->EffectType = AL_EFFECT_NULL;
+        }
+        else
+        {
+            memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props));
+            EffectSlot->EffectType = effect->type;
+        }
+
+        /* FIXME: This should be done asynchronously, but since the EffectState
+         * object was changed, it needs an update before its Process method can
+         * be called. */
+        ATOMIC_STORE(&EffectSlot->NeedsUpdate, AL_FALSE);
+        V(EffectSlot->EffectState,update)(Device, EffectSlot);
+        ALCdevice_Unlock(Device);
+
+        RestoreFPUMode(&oldMode);
+
+        DELETE_OBJ(State);
+        State = NULL;
+    }
+    else
+    {
+        if(effect)
+        {
+            ALCdevice_Lock(Device);
+            memcpy(&EffectSlot->EffectProps, &effect->Props, sizeof(effect->Props));
+            ALCdevice_Unlock(Device);
+            ATOMIC_STORE(&EffectSlot->NeedsUpdate, AL_TRUE);
+        }
+    }
+
+    return AL_NO_ERROR;
+}
+
+
+ALenum InitEffectSlot(ALeffectslot *slot)
+{
+    ALeffectStateFactory *factory;
+    ALuint i, c;
+
+    slot->EffectType = AL_EFFECT_NULL;
+
+    factory = getFactoryByType(AL_EFFECT_NULL);
+    if(!(slot->EffectState=V0(factory,create)()))
+        return AL_OUT_OF_MEMORY;
+
+    slot->Gain = 1.0;
+    slot->AuxSendAuto = AL_TRUE;
+    ATOMIC_INIT(&slot->NeedsUpdate, AL_FALSE);
+    for(c = 0;c < 1;c++)
+    {
+        for(i = 0;i < BUFFERSIZE;i++)
+            slot->WetBuffer[c][i] = 0.0f;
+    }
+    InitRef(&slot->ref, 0);
+
+    return AL_NO_ERROR;
+}
+
+ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
+{
+    ALsizei pos;
+    for(pos = 0;pos < Context->EffectSlotMap.size;pos++)
+    {
+        ALeffectslot *temp = Context->EffectSlotMap.array[pos].value;
+        Context->EffectSlotMap.array[pos].value = NULL;
+
+        DELETE_OBJ(temp->EffectState);
+
+        FreeThunkEntry(temp->id);
+        memset(temp, 0, sizeof(ALeffectslot));
+        al_free(temp);
+    }
+}
@@ -0,0 +1,686 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <math.h>
+#include <float.h>
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alEffect.h"
+#include "alThunk.h"
+#include "alError.h"
+
+
+ALboolean DisabledEffects[MAX_EFFECTS];
+
+extern inline struct ALeffect *LookupEffect(ALCdevice *device, ALuint id);
+extern inline struct ALeffect *RemoveEffect(ALCdevice *device, ALuint id);
+extern inline ALboolean IsReverbEffect(ALenum type);
+
+static void InitEffectParams(ALeffect *effect, ALenum type);
+
+
+AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsizei cur;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    for(cur = 0;cur < n;cur++)
+    {
+        ALeffect *effect = calloc(1, sizeof(ALeffect));
+        ALenum err = AL_OUT_OF_MEMORY;
+        if(!effect || (err=InitEffect(effect)) != AL_NO_ERROR)
+        {
+            free(effect);
+            alDeleteEffects(cur, effects);
+            SET_ERROR_AND_GOTO(context, err, done);
+        }
+
+        err = NewThunkEntry(&effect->id);
+        if(err == AL_NO_ERROR)
+            err = InsertUIntMapEntry(&device->EffectMap, effect->id, effect);
+        if(err != AL_NO_ERROR)
+        {
+            FreeThunkEntry(effect->id);
+            memset(effect, 0, sizeof(ALeffect));
+            free(effect);
+
+            alDeleteEffects(cur, effects);
+            SET_ERROR_AND_GOTO(context, err, done);
+        }
+
+        effects[cur] = effect->id;
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALeffect *effect;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    for(i = 0;i < n;i++)
+    {
+        if(effects[i] && LookupEffect(device, effects[i]) == NULL)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    }
+    for(i = 0;i < n;i++)
+    {
+        if((effect=RemoveEffect(device, effects[i])) == NULL)
+            continue;
+        FreeThunkEntry(effect->id);
+
+        memset(effect, 0, sizeof(*effect));
+        free(effect);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
+{
+    ALCcontext *Context;
+    ALboolean  result;
+
+    Context = GetContextRef();
+    if(!Context) return AL_FALSE;
+
+    result = ((!effect || LookupEffect(Context->Device, effect)) ?
+              AL_TRUE : AL_FALSE);
+
+    ALCcontext_DecRef(Context);
+
+    return result;
+}
+
+AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        if(param == AL_EFFECT_TYPE)
+        {
+            ALboolean isOk = (value == AL_EFFECT_NULL);
+            ALint i;
+            for(i = 0;!isOk && EffectList[i].val;i++)
+            {
+                if(value == EffectList[i].val &&
+                   !DisabledEffects[EffectList[i].type])
+                    isOk = AL_TRUE;
+            }
+
+            if(isOk)
+                InitEffectParams(ALEffect, value);
+            else
+                alSetError(Context, AL_INVALID_VALUE);
+        }
+        else
+        {
+            /* Call the appropriate handler */
+            V(ALEffect,setParami)(Context, param, value);
+        }
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    switch(param)
+    {
+        case AL_EFFECT_TYPE:
+            alEffecti(effect, param, values[0]);
+            return;
+    }
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        V(ALEffect,setParamiv)(Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        V(ALEffect,setParamf)(Context, param, value);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        V(ALEffect,setParamfv)(Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        if(param == AL_EFFECT_TYPE)
+            *value = ALEffect->type;
+        else
+        {
+            /* Call the appropriate handler */
+            V(ALEffect,getParami)(Context, param, value);
+        }
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    switch(param)
+    {
+        case AL_EFFECT_TYPE:
+            alGetEffecti(effect, param, values);
+            return;
+    }
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        V(ALEffect,getParamiv)(Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        V(ALEffect,getParamf)(Context, param, value);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALeffect   *ALEffect;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALEffect=LookupEffect(Device, effect)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        V(ALEffect,getParamfv)(Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+
+ALenum InitEffect(ALeffect *effect)
+{
+    InitEffectParams(effect, AL_EFFECT_NULL);
+    return AL_NO_ERROR;
+}
+
+ALvoid ReleaseALEffects(ALCdevice *device)
+{
+    ALsizei i;
+    for(i = 0;i < device->EffectMap.size;i++)
+    {
+        ALeffect *temp = device->EffectMap.array[i].value;
+        device->EffectMap.array[i].value = NULL;
+
+        // Release effect structure
+        FreeThunkEntry(temp->id);
+        memset(temp, 0, sizeof(ALeffect));
+        free(temp);
+    }
+}
+
+
+static void InitEffectParams(ALeffect *effect, ALenum type)
+{
+    switch(type)
+    {
+    case AL_EFFECT_EAXREVERB:
+        effect->Props.Reverb.Density   = AL_EAXREVERB_DEFAULT_DENSITY;
+        effect->Props.Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
+        effect->Props.Reverb.Gain   = AL_EAXREVERB_DEFAULT_GAIN;
+        effect->Props.Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF;
+        effect->Props.Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF;
+        effect->Props.Reverb.DecayTime    = AL_EAXREVERB_DEFAULT_DECAY_TIME;
+        effect->Props.Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
+        effect->Props.Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
+        effect->Props.Reverb.ReflectionsGain   = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN;
+        effect->Props.Reverb.ReflectionsDelay  = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY;
+        effect->Props.Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+        effect->Props.Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+        effect->Props.Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+        effect->Props.Reverb.LateReverbGain   = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN;
+        effect->Props.Reverb.LateReverbDelay  = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY;
+        effect->Props.Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+        effect->Props.Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+        effect->Props.Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+        effect->Props.Reverb.EchoTime  = AL_EAXREVERB_DEFAULT_ECHO_TIME;
+        effect->Props.Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH;
+        effect->Props.Reverb.ModulationTime  = AL_EAXREVERB_DEFAULT_MODULATION_TIME;
+        effect->Props.Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH;
+        effect->Props.Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
+        effect->Props.Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
+        effect->Props.Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
+        effect->Props.Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
+        effect->Props.Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT;
+        SET_VTABLE1(ALeaxreverb, effect);
+        break;
+    case AL_EFFECT_REVERB:
+        effect->Props.Reverb.Density   = AL_REVERB_DEFAULT_DENSITY;
+        effect->Props.Reverb.Diffusion = AL_REVERB_DEFAULT_DIFFUSION;
+        effect->Props.Reverb.Gain   = AL_REVERB_DEFAULT_GAIN;
+        effect->Props.Reverb.GainHF = AL_REVERB_DEFAULT_GAINHF;
+        effect->Props.Reverb.DecayTime    = AL_REVERB_DEFAULT_DECAY_TIME;
+        effect->Props.Reverb.DecayHFRatio = AL_REVERB_DEFAULT_DECAY_HFRATIO;
+        effect->Props.Reverb.ReflectionsGain   = AL_REVERB_DEFAULT_REFLECTIONS_GAIN;
+        effect->Props.Reverb.ReflectionsDelay  = AL_REVERB_DEFAULT_REFLECTIONS_DELAY;
+        effect->Props.Reverb.LateReverbGain   = AL_REVERB_DEFAULT_LATE_REVERB_GAIN;
+        effect->Props.Reverb.LateReverbDelay  = AL_REVERB_DEFAULT_LATE_REVERB_DELAY;
+        effect->Props.Reverb.AirAbsorptionGainHF = AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
+        effect->Props.Reverb.RoomRolloffFactor = AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
+        effect->Props.Reverb.DecayHFLimit = AL_REVERB_DEFAULT_DECAY_HFLIMIT;
+        SET_VTABLE1(ALreverb, effect);
+        break;
+    case AL_EFFECT_AUTOWAH:
+        effect->Props.Autowah.AttackTime = AL_AUTOWAH_DEFAULT_ATTACK_TIME;
+        effect->Props.Autowah.PeakGain = AL_AUTOWAH_DEFAULT_PEAK_GAIN;
+        effect->Props.Autowah.ReleaseTime = AL_AUTOWAH_DEFAULT_RELEASE_TIME;
+        effect->Props.Autowah.Resonance = AL_AUTOWAH_DEFAULT_RESONANCE;
+        SET_VTABLE1(ALautowah, effect);
+        break;
+    case AL_EFFECT_CHORUS:
+        effect->Props.Chorus.Waveform = AL_CHORUS_DEFAULT_WAVEFORM;
+        effect->Props.Chorus.Phase = AL_CHORUS_DEFAULT_PHASE;
+        effect->Props.Chorus.Rate = AL_CHORUS_DEFAULT_RATE;
+        effect->Props.Chorus.Depth = AL_CHORUS_DEFAULT_DEPTH;
+        effect->Props.Chorus.Feedback = AL_CHORUS_DEFAULT_FEEDBACK;
+        effect->Props.Chorus.Delay = AL_CHORUS_DEFAULT_DELAY;
+        SET_VTABLE1(ALchorus, effect);
+        break;
+    case AL_EFFECT_COMPRESSOR:
+        effect->Props.Compressor.OnOff = AL_COMPRESSOR_DEFAULT_ONOFF;
+        SET_VTABLE1(ALcompressor, effect);
+        break;
+    case AL_EFFECT_DISTORTION:
+        effect->Props.Distortion.Edge = AL_DISTORTION_DEFAULT_EDGE;
+        effect->Props.Distortion.Gain = AL_DISTORTION_DEFAULT_GAIN;
+        effect->Props.Distortion.LowpassCutoff = AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF;
+        effect->Props.Distortion.EQCenter = AL_DISTORTION_DEFAULT_EQCENTER;
+        effect->Props.Distortion.EQBandwidth = AL_DISTORTION_DEFAULT_EQBANDWIDTH;
+        SET_VTABLE1(ALdistortion, effect);
+        break;
+    case AL_EFFECT_ECHO:
+        effect->Props.Echo.Delay    = AL_ECHO_DEFAULT_DELAY;
+        effect->Props.Echo.LRDelay  = AL_ECHO_DEFAULT_LRDELAY;
+        effect->Props.Echo.Damping  = AL_ECHO_DEFAULT_DAMPING;
+        effect->Props.Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK;
+        effect->Props.Echo.Spread   = AL_ECHO_DEFAULT_SPREAD;
+        SET_VTABLE1(ALecho, effect);
+        break;
+    case AL_EFFECT_EQUALIZER:
+        effect->Props.Equalizer.LowCutoff = AL_EQUALIZER_DEFAULT_LOW_CUTOFF;
+        effect->Props.Equalizer.LowGain = AL_EQUALIZER_DEFAULT_LOW_GAIN;
+        effect->Props.Equalizer.Mid1Center = AL_EQUALIZER_DEFAULT_MID1_CENTER;
+        effect->Props.Equalizer.Mid1Gain = AL_EQUALIZER_DEFAULT_MID1_GAIN;
+        effect->Props.Equalizer.Mid1Width = AL_EQUALIZER_DEFAULT_MID1_WIDTH;
+        effect->Props.Equalizer.Mid2Center = AL_EQUALIZER_DEFAULT_MID2_CENTER;
+        effect->Props.Equalizer.Mid2Gain = AL_EQUALIZER_DEFAULT_MID2_GAIN;
+        effect->Props.Equalizer.Mid2Width = AL_EQUALIZER_DEFAULT_MID2_WIDTH;
+        effect->Props.Equalizer.HighCutoff = AL_EQUALIZER_DEFAULT_HIGH_CUTOFF;
+        effect->Props.Equalizer.HighGain = AL_EQUALIZER_DEFAULT_HIGH_GAIN;
+        SET_VTABLE1(ALequalizer, effect);
+        break;
+    case AL_EFFECT_FLANGER:
+        effect->Props.Flanger.Waveform = AL_FLANGER_DEFAULT_WAVEFORM;
+        effect->Props.Flanger.Phase = AL_FLANGER_DEFAULT_PHASE;
+        effect->Props.Flanger.Rate = AL_FLANGER_DEFAULT_RATE;
+        effect->Props.Flanger.Depth = AL_FLANGER_DEFAULT_DEPTH;
+        effect->Props.Flanger.Feedback = AL_FLANGER_DEFAULT_FEEDBACK;
+        effect->Props.Flanger.Delay = AL_FLANGER_DEFAULT_DELAY;
+        SET_VTABLE1(ALflanger, effect);
+        break;
+    case AL_EFFECT_RING_MODULATOR:
+        effect->Props.Modulator.Frequency      = AL_RING_MODULATOR_DEFAULT_FREQUENCY;
+        effect->Props.Modulator.HighPassCutoff = AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF;
+        effect->Props.Modulator.Waveform       = AL_RING_MODULATOR_DEFAULT_WAVEFORM;
+        SET_VTABLE1(ALmodulator, effect);
+        break;
+    case AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT:
+    case AL_EFFECT_DEDICATED_DIALOGUE:
+        effect->Props.Dedicated.Gain = 1.0f;
+        SET_VTABLE1(ALdedicated, effect);
+        break;
+    default:
+        SET_VTABLE1(ALnull, effect);
+        break;
+    }
+    effect->type = type;
+}
+
+
+#include "AL/efx-presets.h"
+
+#define DECL(x) { #x, EFX_REVERB_PRESET_##x }
+static const struct {
+    const char name[32];
+    EFXEAXREVERBPROPERTIES props;
+} reverblist[] = {
+    DECL(GENERIC),
+    DECL(PADDEDCELL),
+    DECL(ROOM),
+    DECL(BATHROOM),
+    DECL(LIVINGROOM),
+    DECL(STONEROOM),
+    DECL(AUDITORIUM),
+    DECL(CONCERTHALL),
+    DECL(CAVE),
+    DECL(ARENA),
+    DECL(HANGAR),
+    DECL(CARPETEDHALLWAY),
+    DECL(HALLWAY),
+    DECL(STONECORRIDOR),
+    DECL(ALLEY),
+    DECL(FOREST),
+    DECL(CITY),
+    DECL(MOUNTAINS),
+    DECL(QUARRY),
+    DECL(PLAIN),
+    DECL(PARKINGLOT),
+    DECL(SEWERPIPE),
+    DECL(UNDERWATER),
+    DECL(DRUGGED),
+    DECL(DIZZY),
+    DECL(PSYCHOTIC),
+
+    DECL(CASTLE_SMALLROOM),
+    DECL(CASTLE_SHORTPASSAGE),
+    DECL(CASTLE_MEDIUMROOM),
+    DECL(CASTLE_LARGEROOM),
+    DECL(CASTLE_LONGPASSAGE),
+    DECL(CASTLE_HALL),
+    DECL(CASTLE_CUPBOARD),
+    DECL(CASTLE_COURTYARD),
+    DECL(CASTLE_ALCOVE),
+
+    DECL(FACTORY_SMALLROOM),
+    DECL(FACTORY_SHORTPASSAGE),
+    DECL(FACTORY_MEDIUMROOM),
+    DECL(FACTORY_LARGEROOM),
+    DECL(FACTORY_LONGPASSAGE),
+    DECL(FACTORY_HALL),
+    DECL(FACTORY_CUPBOARD),
+    DECL(FACTORY_COURTYARD),
+    DECL(FACTORY_ALCOVE),
+
+    DECL(ICEPALACE_SMALLROOM),
+    DECL(ICEPALACE_SHORTPASSAGE),
+    DECL(ICEPALACE_MEDIUMROOM),
+    DECL(ICEPALACE_LARGEROOM),
+    DECL(ICEPALACE_LONGPASSAGE),
+    DECL(ICEPALACE_HALL),
+    DECL(ICEPALACE_CUPBOARD),
+    DECL(ICEPALACE_COURTYARD),
+    DECL(ICEPALACE_ALCOVE),
+
+    DECL(SPACESTATION_SMALLROOM),
+    DECL(SPACESTATION_SHORTPASSAGE),
+    DECL(SPACESTATION_MEDIUMROOM),
+    DECL(SPACESTATION_LARGEROOM),
+    DECL(SPACESTATION_LONGPASSAGE),
+    DECL(SPACESTATION_HALL),
+    DECL(SPACESTATION_CUPBOARD),
+    DECL(SPACESTATION_ALCOVE),
+
+    DECL(WOODEN_SMALLROOM),
+    DECL(WOODEN_SHORTPASSAGE),
+    DECL(WOODEN_MEDIUMROOM),
+    DECL(WOODEN_LARGEROOM),
+    DECL(WOODEN_LONGPASSAGE),
+    DECL(WOODEN_HALL),
+    DECL(WOODEN_CUPBOARD),
+    DECL(WOODEN_COURTYARD),
+    DECL(WOODEN_ALCOVE),
+
+    DECL(SPORT_EMPTYSTADIUM),
+    DECL(SPORT_SQUASHCOURT),
+    DECL(SPORT_SMALLSWIMMINGPOOL),
+    DECL(SPORT_LARGESWIMMINGPOOL),
+    DECL(SPORT_GYMNASIUM),
+    DECL(SPORT_FULLSTADIUM),
+    DECL(SPORT_STADIUMTANNOY),
+
+    DECL(PREFAB_WORKSHOP),
+    DECL(PREFAB_SCHOOLROOM),
+    DECL(PREFAB_PRACTISEROOM),
+    DECL(PREFAB_OUTHOUSE),
+    DECL(PREFAB_CARAVAN),
+
+    DECL(DOME_TOMB),
+    DECL(PIPE_SMALL),
+    DECL(DOME_SAINTPAULS),
+    DECL(PIPE_LONGTHIN),
+    DECL(PIPE_LARGE),
+    DECL(PIPE_RESONANT),
+
+    DECL(OUTDOORS_BACKYARD),
+    DECL(OUTDOORS_ROLLINGPLAINS),
+    DECL(OUTDOORS_DEEPCANYON),
+    DECL(OUTDOORS_CREEK),
+    DECL(OUTDOORS_VALLEY),
+
+    DECL(MOOD_HEAVEN),
+    DECL(MOOD_HELL),
+    DECL(MOOD_MEMORY),
+
+    DECL(DRIVING_COMMENTATOR),
+    DECL(DRIVING_PITGARAGE),
+    DECL(DRIVING_INCAR_RACER),
+    DECL(DRIVING_INCAR_SPORTS),
+    DECL(DRIVING_INCAR_LUXURY),
+    DECL(DRIVING_FULLGRANDSTAND),
+    DECL(DRIVING_EMPTYGRANDSTAND),
+    DECL(DRIVING_TUNNEL),
+
+    DECL(CITY_STREETS),
+    DECL(CITY_SUBWAY),
+    DECL(CITY_MUSEUM),
+    DECL(CITY_LIBRARY),
+    DECL(CITY_UNDERPASS),
+    DECL(CITY_ABANDONED),
+
+    DECL(DUSTYROOM),
+    DECL(CHAPEL),
+    DECL(SMALLWATERROOM),
+};
+#undef DECL
+
+ALvoid LoadReverbPreset(const char *name, ALeffect *effect)
+{
+    size_t i;
+
+    if(strcasecmp(name, "NONE") == 0)
+    {
+        InitEffectParams(effect, AL_EFFECT_NULL);
+        TRACE("Loading reverb '%s'\n", "NONE");
+        return;
+    }
+
+    if(!DisabledEffects[EAXREVERB])
+        InitEffectParams(effect, AL_EFFECT_EAXREVERB);
+    else if(!DisabledEffects[REVERB])
+        InitEffectParams(effect, AL_EFFECT_REVERB);
+    else
+        InitEffectParams(effect, AL_EFFECT_NULL);
+    for(i = 0;i < COUNTOF(reverblist);i++)
+    {
+        const EFXEAXREVERBPROPERTIES *props;
+
+        if(strcasecmp(name, reverblist[i].name) != 0)
+            continue;
+
+        TRACE("Loading reverb '%s'\n", reverblist[i].name);
+        props = &reverblist[i].props;
+        effect->Props.Reverb.Density   = props->flDensity;
+        effect->Props.Reverb.Diffusion = props->flDiffusion;
+        effect->Props.Reverb.Gain   = props->flGain;
+        effect->Props.Reverb.GainHF = props->flGainHF;
+        effect->Props.Reverb.GainLF = props->flGainLF;
+        effect->Props.Reverb.DecayTime    = props->flDecayTime;
+        effect->Props.Reverb.DecayHFRatio = props->flDecayHFRatio;
+        effect->Props.Reverb.DecayLFRatio = props->flDecayLFRatio;
+        effect->Props.Reverb.ReflectionsGain   = props->flReflectionsGain;
+        effect->Props.Reverb.ReflectionsDelay  = props->flReflectionsDelay;
+        effect->Props.Reverb.ReflectionsPan[0] = props->flReflectionsPan[0];
+        effect->Props.Reverb.ReflectionsPan[1] = props->flReflectionsPan[1];
+        effect->Props.Reverb.ReflectionsPan[2] = props->flReflectionsPan[2];
+        effect->Props.Reverb.LateReverbGain   = props->flLateReverbGain;
+        effect->Props.Reverb.LateReverbDelay  = props->flLateReverbDelay;
+        effect->Props.Reverb.LateReverbPan[0] = props->flLateReverbPan[0];
+        effect->Props.Reverb.LateReverbPan[1] = props->flLateReverbPan[1];
+        effect->Props.Reverb.LateReverbPan[2] = props->flLateReverbPan[2];
+        effect->Props.Reverb.EchoTime  = props->flEchoTime;
+        effect->Props.Reverb.EchoDepth = props->flEchoDepth;
+        effect->Props.Reverb.ModulationTime  = props->flModulationTime;
+        effect->Props.Reverb.ModulationDepth = props->flModulationDepth;
+        effect->Props.Reverb.AirAbsorptionGainHF = props->flAirAbsorptionGainHF;
+        effect->Props.Reverb.HFReference = props->flHFReference;
+        effect->Props.Reverb.LFReference = props->flLFReference;
+        effect->Props.Reverb.RoomRolloffFactor = props->flRoomRolloffFactor;
+        effect->Props.Reverb.DecayHFLimit = props->iDecayHFLimit;
+        return;
+    }
+
+    WARN("Reverb preset '%s' not found\n", name);
+}
@@ -18,40 +18,60 @@
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

+#include "config.h"
+
+#include <signal.h>
+
+#ifdef HAVE_WINDOWS_H
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
 #include "alMain.h"
 #include "AL/alc.h"
 #include "alError.h"

-ALAPI ALenum ALAPIENTRY alGetError(ALvoid)
+ALboolean TrapALError = AL_FALSE;
+
+ALvoid alSetError(ALCcontext *Context, ALenum errorCode)
 {
-	ALCcontext *Context;
-	ALenum errorCode;
-
-	Context = alcGetCurrentContext();
-	SuspendContext(Context);
-
-	if (Context)
-	{
-		errorCode = Context->LastError;
-		Context->LastError = AL_NO_ERROR;
-	}
-	else
-		errorCode = AL_INVALID_OPERATION;
-
-	ProcessContext(Context);
-
-	return errorCode;
+    ALenum curerr = AL_NO_ERROR;
+    if(TrapALError)
+    {
+#ifdef _WIN32
+        /* DebugBreak will cause an exception if there is no debugger */
+        if(IsDebuggerPresent())
+            DebugBreak();
+#elif defined(SIGTRAP)
+        raise(SIGTRAP);
+#endif
+    }
+    ATOMIC_COMPARE_EXCHANGE_STRONG(ALenum, &Context->LastError, &curerr, errorCode);
 }

-ALvoid alSetError(ALenum errorCode)
+AL_API ALenum AL_APIENTRY alGetError(void)
 {
-	ALCcontext *Context;
+    ALCcontext *Context;
+    ALenum errorCode;

-	Context=alcGetCurrentContext();
-	SuspendContext(Context);
+    Context = GetContextRef();
+    if(!Context)
+    {
+        if(TrapALError)
+        {
+#ifdef _WIN32
+            if(IsDebuggerPresent())
+                DebugBreak();
+#elif defined(SIGTRAP)
+            raise(SIGTRAP);
+#endif
+        }
+        return AL_INVALID_OPERATION;
+    }

-	if (Context && Context->LastError == AL_NO_ERROR)
-		Context->LastError = errorCode;
+    errorCode = ATOMIC_EXCHANGE(ALenum, &Context->LastError, AL_NO_ERROR);

-	ProcessContext(Context);
+    ALCcontext_DecRef(Context);
+
+    return errorCode;
 }
@@ -18,272 +18,89 @@
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

+#include "config.h"
+
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
-#include "alExtension.h"
+
 #include "alError.h"
 #include "alMain.h"
+#include "alFilter.h"
+#include "alEffect.h"
+#include "alAuxEffectSlot.h"
+#include "alSource.h"
+#include "alBuffer.h"
 #include "AL/al.h"
 #include "AL/alc.h"

-static ALfunction  function[]=   {
-    { "alEnable",                   (ALvoid *) alEnable                  },
-    { "alDisable",                  (ALvoid *) alDisable                 },
-    { "alIsEnabled",                (ALvoid *) alIsEnabled               },
-    { "alGetString",                (ALvoid *) alGetString               },
-    { "alGetBooleanv",              (ALvoid *) alGetBooleanv             },
-    { "alGetIntegerv",              (ALvoid *) alGetIntegerv             },
-    { "alGetFloatv",                (ALvoid *) alGetFloatv               },
-    { "alGetDoublev",               (ALvoid *) alGetDoublev              },
-    { "alGetBoolean",               (ALvoid *) alGetBoolean              },
-    { "alGetInteger",               (ALvoid *) alGetInteger              },
-    { "alGetFloat",                 (ALvoid *) alGetFloat                },
-    { "alGetDouble",                (ALvoid *) alGetDouble               },
-    { "alGetError",                 (ALvoid *) alGetError                },
-    { "alIsExtensionPresent",       (ALvoid *) alIsExtensionPresent      },
-    { "alGetProcAddress",           (ALvoid *) alGetProcAddress          },
-    { "alGetEnumValue",             (ALvoid *) alGetEnumValue            },
-    { "alListenerf",                (ALvoid *) alListenerf               },
-    { "alListener3f",               (ALvoid *) alListener3f              },
-    { "alListenerfv",               (ALvoid *) alListenerfv              },
-    { "alListeneri",                (ALvoid *) alListeneri               },
-    { "alListener3i",               (ALvoid *) alListener3i              },
-    { "alListeneriv",               (ALvoid *) alListeneriv              },
-    { "alGetListenerf",             (ALvoid *) alGetListenerf            },
-    { "alGetListener3f",            (ALvoid *) alGetListener3f           },
-    { "alGetListenerfv",            (ALvoid *) alGetListenerfv           },
-    { "alGetListeneri",             (ALvoid *) alGetListeneri            },
-    { "alGetListener3i",            (ALvoid *) alGetListener3i           },
-    { "alGetListeneriv",            (ALvoid *) alGetListeneriv           },
-    { "alGenSources",               (ALvoid *) alGenSources              },
-    { "alDeleteSources",            (ALvoid *) alDeleteSources           },
-    { "alIsSource",                 (ALvoid *) alIsSource                },
-    { "alSourcef",                  (ALvoid *) alSourcef                 },
-    { "alSource3f",                 (ALvoid *) alSource3f                },
-    { "alSourcefv",                 (ALvoid *) alSourcefv                },
-    { "alSourcei",                  (ALvoid *) alSourcei                 },
-    { "alSource3i",                 (ALvoid *) alSource3i                },
-    { "alSourceiv",                 (ALvoid *) alSourceiv                },
-    { "alGetSourcef",               (ALvoid *) alGetSourcef              },
-    { "alGetSource3f",              (ALvoid *) alGetSource3f             },
-    { "alGetSourcefv",              (ALvoid *) alGetSourcefv             },
-    { "alGetSourcei",               (ALvoid *) alGetSourcei              },
-    { "alGetSource3i",              (ALvoid *) alGetSource3i             },
-    { "alGetSourceiv",              (ALvoid *) alGetSourceiv             },
-    { "alSourcePlayv",              (ALvoid *) alSourcePlayv             },
-    { "alSourceStopv",              (ALvoid *) alSourceStopv             },
-    { "alSourceRewindv",            (ALvoid *) alSourceRewindv           },
-    { "alSourcePausev",             (ALvoid *) alSourcePausev            },
-    { "alSourcePlay",               (ALvoid *) alSourcePlay              },
-    { "alSourceStop",               (ALvoid *) alSourceStop              },
-    { "alSourceRewind",             (ALvoid *) alSourceRewind            },
-    { "alSourcePause",              (ALvoid *) alSourcePause             },
-    { "alSourceQueueBuffers",       (ALvoid *) alSourceQueueBuffers      },
-    { "alSourceUnqueueBuffers",     (ALvoid *) alSourceUnqueueBuffers    },
-    { "alGenBuffers",               (ALvoid *) alGenBuffers              },
-    { "alDeleteBuffers",            (ALvoid *) alDeleteBuffers           },
-    { "alIsBuffer",                 (ALvoid *) alIsBuffer                },
-    { "alBufferData",               (ALvoid *) alBufferData              },
-    { "alBufferf",                  (ALvoid *) alBufferf                 },
-    { "alBuffer3f",                 (ALvoid *) alBuffer3f                },
-    { "alBufferfv",                 (ALvoid *) alBufferfv                },
-    { "alBufferi",                  (ALvoid *) alBufferi                 },
-    { "alBuffer3i",                 (ALvoid *) alBuffer3i                },
-    { "alBufferiv",                 (ALvoid *) alBufferiv                },
-    { "alGetBufferf",               (ALvoid *) alGetBufferf              },
-    { "alGetBuffer3f",              (ALvoid *) alGetBuffer3f             },
-    { "alGetBufferfv",              (ALvoid *) alGetBufferfv             },
-    { "alGetBufferi",               (ALvoid *) alGetBufferi              },
-    { "alGetBuffer3i",              (ALvoid *) alGetBuffer3i             },
-    { "alGetBufferiv",              (ALvoid *) alGetBufferiv             },
-    { "alDopplerFactor",            (ALvoid *) alDopplerFactor           },
-    { "alDopplerVelocity",          (ALvoid *) alDopplerVelocity         },
-    { "alSpeedOfSound",             (ALvoid *) alSpeedOfSound            },
-    { "alDistanceModel",            (ALvoid *) alDistanceModel           },
-    { NULL,                         (ALvoid *) NULL                      } };

-static ALenums enumeration[]={
-    // Types
-    { (ALchar *)"AL_INVALID",                           AL_INVALID                          },
-    { (ALchar *)"AL_NONE",                              AL_NONE                             },
-    { (ALchar *)"AL_FALSE",                             AL_FALSE                            },
-    { (ALchar *)"AL_TRUE",                              AL_TRUE                             },
-
-    // Source and Listener Properties
-    { (ALchar *)"AL_SOURCE_RELATIVE",                   AL_SOURCE_RELATIVE                  },
-    { (ALchar *)"AL_CONE_INNER_ANGLE",                  AL_CONE_INNER_ANGLE                 },
-    { (ALchar *)"AL_CONE_OUTER_ANGLE",                  AL_CONE_OUTER_ANGLE                 },
-    { (ALchar *)"AL_PITCH",                             AL_PITCH                            },
-    { (ALchar *)"AL_POSITION",                          AL_POSITION                         },
-    { (ALchar *)"AL_DIRECTION",                         AL_DIRECTION                        },
-    { (ALchar *)"AL_VELOCITY",                          AL_VELOCITY                         },
-    { (ALchar *)"AL_LOOPING",                           AL_LOOPING                          },
-    { (ALchar *)"AL_BUFFER",                            AL_BUFFER                           },
-    { (ALchar *)"AL_GAIN",                              AL_GAIN                             },
-    { (ALchar *)"AL_MIN_GAIN",                          AL_MIN_GAIN                         },
-    { (ALchar *)"AL_MAX_GAIN",                          AL_MAX_GAIN                         },
-    { (ALchar *)"AL_ORIENTATION",                       AL_ORIENTATION                      },
-    { (ALchar *)"AL_REFERENCE_DISTANCE",                AL_REFERENCE_DISTANCE               },
-    { (ALchar *)"AL_ROLLOFF_FACTOR",                    AL_ROLLOFF_FACTOR                   },
-    { (ALchar *)"AL_CONE_OUTER_GAIN",                   AL_CONE_OUTER_GAIN                  },
-    { (ALchar *)"AL_MAX_DISTANCE",                      AL_MAX_DISTANCE                     },
-    { (ALchar *)"AL_SEC_OFFSET",                        AL_SEC_OFFSET                       },
-    { (ALchar *)"AL_SAMPLE_OFFSET",                     AL_SAMPLE_OFFSET                    },
-    { (ALchar *)"AL_BYTE_OFFSET",                       AL_BYTE_OFFSET                      },
-    { (ALchar *)"AL_SOURCE_TYPE",                       AL_SOURCE_TYPE                      },
-    { (ALchar *)"AL_STATIC",                            AL_STATIC                           },
-    { (ALchar *)"AL_STREAMING",                         AL_STREAMING                        },
-    { (ALchar *)"AL_UNDETERMINED",                      AL_UNDETERMINED                     },
-
-    // Source State information
-    { (ALchar *)"AL_SOURCE_STATE",                      AL_SOURCE_STATE                     },
-    { (ALchar *)"AL_INITIAL",                           AL_INITIAL                          },
-    { (ALchar *)"AL_PLAYING",                           AL_PLAYING                          },
-    { (ALchar *)"AL_PAUSED",                            AL_PAUSED                           },
-    { (ALchar *)"AL_STOPPED",                           AL_STOPPED                          },
-
-    // Queue information
-    { (ALchar *)"AL_BUFFERS_QUEUED",                    AL_BUFFERS_QUEUED                   },
-    { (ALchar *)"AL_BUFFERS_PROCESSED",                 AL_BUFFERS_PROCESSED                },
-
-    // Buffer Formats
-    { (ALchar *)"AL_FORMAT_MONO8",                      AL_FORMAT_MONO8                     },
-    { (ALchar *)"AL_FORMAT_MONO16",                     AL_FORMAT_MONO16                    },
-    { (ALchar *)"AL_FORMAT_MONO_FLOAT32",               AL_FORMAT_MONO_FLOAT32              },
-    { (ALchar *)"AL_FORMAT_STEREO8",                    AL_FORMAT_STEREO8                   },
-    { (ALchar *)"AL_FORMAT_STEREO16",                   AL_FORMAT_STEREO16                  },
-    { (ALchar *)"AL_FORMAT_STEREO_FLOAT32",             AL_FORMAT_STEREO_FLOAT32            },
-    { (ALchar *)"AL_FORMAT_MONO_IMA4",                  AL_FORMAT_MONO_IMA4                 },
-    { (ALchar *)"AL_FORMAT_STEREO_IMA4",                AL_FORMAT_STEREO_IMA4               },
-    { (ALchar *)"AL_FORMAT_QUAD8",                      AL_FORMAT_QUAD8                     },
-    { (ALchar *)"AL_FORMAT_QUAD16",                     AL_FORMAT_QUAD16                    },
-    { (ALchar *)"AL_FORMAT_QUAD32",                     AL_FORMAT_QUAD32                    },
-    { (ALchar *)"AL_FORMAT_51CHN8",                     AL_FORMAT_51CHN8                    },
-    { (ALchar *)"AL_FORMAT_51CHN16",                    AL_FORMAT_51CHN16                   },
-    { (ALchar *)"AL_FORMAT_51CHN32",                    AL_FORMAT_51CHN32                   },
-    { (ALchar *)"AL_FORMAT_61CHN8",                     AL_FORMAT_61CHN8                    },
-    { (ALchar *)"AL_FORMAT_61CHN16",                    AL_FORMAT_61CHN16                   },
-    { (ALchar *)"AL_FORMAT_61CHN32",                    AL_FORMAT_61CHN32                   },
-    { (ALchar *)"AL_FORMAT_71CHN8",                     AL_FORMAT_71CHN8                    },
-    { (ALchar *)"AL_FORMAT_71CHN16",                    AL_FORMAT_71CHN16                   },
-    { (ALchar *)"AL_FORMAT_71CHN32",                    AL_FORMAT_71CHN32                   },
-    { (ALchar *)"AL_FORMAT_REAR8",                      AL_FORMAT_REAR8                     },
-    { (ALchar *)"AL_FORMAT_REAR16",                     AL_FORMAT_REAR16                    },
-    { (ALchar *)"AL_FORMAT_REAR32",                     AL_FORMAT_REAR32                    },
-
-    // Buffer attributes
-    { (ALchar *)"AL_FREQUENCY",                         AL_FREQUENCY                        },
-    { (ALchar *)"AL_BITS",                              AL_BITS                             },
-    { (ALchar *)"AL_CHANNELS",                          AL_CHANNELS                         },
-    { (ALchar *)"AL_SIZE",                              AL_SIZE                             },
-
-    // Buffer States (not supported yet)
-    { (ALchar *)"AL_UNUSED",                            AL_UNUSED                           },
-    { (ALchar *)"AL_PENDING",                           AL_PENDING                          },
-    { (ALchar *)"AL_PROCESSED",                         AL_PROCESSED                        },
-
-    // AL Error Messages
-    { (ALchar *)"AL_NO_ERROR",                          AL_NO_ERROR                         },
-    { (ALchar *)"AL_INVALID_NAME",                      AL_INVALID_NAME                     },
-    { (ALchar *)"AL_INVALID_ENUM",                      AL_INVALID_ENUM                     },
-    { (ALchar *)"AL_INVALID_VALUE",                     AL_INVALID_VALUE                    },
-    { (ALchar *)"AL_INVALID_OPERATION",                 AL_INVALID_OPERATION                },
-    { (ALchar *)"AL_OUT_OF_MEMORY",                     AL_OUT_OF_MEMORY                    },
-
-    // Context strings
-    { (ALchar *)"AL_VENDOR",                            AL_VENDOR                           },
-    { (ALchar *)"AL_VERSION",                           AL_VERSION                          },
-    { (ALchar *)"AL_RENDERER",                          AL_RENDERER                         },
-    { (ALchar *)"AL_EXTENSIONS",                        AL_EXTENSIONS                       },
-
-    // Global states
-    { (ALchar *)"AL_DOPPLER_FACTOR",                    AL_DOPPLER_FACTOR                   },
-    { (ALchar *)"AL_DOPPLER_VELOCITY",                  AL_DOPPLER_VELOCITY                 },
-    { (ALchar *)"AL_DISTANCE_MODEL",                    AL_DISTANCE_MODEL                   },
-    { (ALchar *)"AL_SPEED_OF_SOUND",                    AL_SPEED_OF_SOUND                   },
-
-    // Distance Models
-    { (ALchar *)"AL_INVERSE_DISTANCE",                  AL_INVERSE_DISTANCE                 },
-    { (ALchar *)"AL_INVERSE_DISTANCE_CLAMPED",          AL_INVERSE_DISTANCE_CLAMPED         },
-    { (ALchar *)"AL_LINEAR_DISTANCE",                   AL_LINEAR_DISTANCE                  },
-    { (ALchar *)"AL_LINEAR_DISTANCE_CLAMPED",           AL_LINEAR_DISTANCE_CLAMPED          },
-    { (ALchar *)"AL_EXPONENT_DISTANCE",                 AL_EXPONENT_DISTANCE                },
-    { (ALchar *)"AL_EXPONENT_DISTANCE_CLAMPED",         AL_EXPONENT_DISTANCE_CLAMPED        },
-
-    // Default
-    { (ALchar *)NULL,                                (ALenum  ) 0                         } };
+const struct EffectList EffectList[] = {
+    { "eaxreverb",  EAXREVERB,  "AL_EFFECT_EAXREVERB",      AL_EFFECT_EAXREVERB },
+    { "reverb",     REVERB,     "AL_EFFECT_REVERB",         AL_EFFECT_REVERB },
+#if 0
+    { "autowah",    AUTOWAH,    "AL_EFFECT_AUTOWAH",        AL_EFFECT_AUTOWAH },
+#endif
+    { "chorus",     CHORUS,     "AL_EFFECT_CHORUS",         AL_EFFECT_CHORUS },
+    { "compressor", COMPRESSOR, "AL_EFFECT_COMPRESSOR",     AL_EFFECT_COMPRESSOR },
+    { "distortion", DISTORTION, "AL_EFFECT_DISTORTION",     AL_EFFECT_DISTORTION },
+    { "echo",       ECHO,       "AL_EFFECT_ECHO",           AL_EFFECT_ECHO },
+    { "equalizer",  EQUALIZER,  "AL_EFFECT_EQUALIZER",      AL_EFFECT_EQUALIZER },
+    { "flanger",    FLANGER,    "AL_EFFECT_FLANGER",        AL_EFFECT_FLANGER },
+    { "modulator",  MODULATOR,  "AL_EFFECT_RING_MODULATOR", AL_EFFECT_RING_MODULATOR },
+    { "dedicated",  DEDICATED,  "AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT", AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT },
+    { "dedicated",  DEDICATED,  "AL_EFFECT_DEDICATED_DIALOGUE", AL_EFFECT_DEDICATED_DIALOGUE },
+    { NULL, 0, NULL, (ALenum)0 }
+};


-
-ALAPI ALboolean ALAPIENTRY alIsExtensionPresent(const ALchar *extName)
+AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extName)
 {
-    ALboolean bIsSupported = AL_FALSE;
-    ALCcontext *pContext;
-    char *ptr, *ext;
+    ALboolean ret = AL_FALSE;
+    ALCcontext *context;
+    const char *ptr;
+    size_t len;

-    if (!extName)
+    context = GetContextRef();
+    if(!context) return AL_FALSE;
+
+    if(!(extName))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    len = strlen(extName);
+    ptr = context->ExtensionList;
+    while(ptr && *ptr)
    {
-        alSetError(AL_INVALID_VALUE);
-        return AL_FALSE;
-    }
-
-    pContext = alcGetCurrentContext();
-    if(!pContext)
-    {
-        alSetError(AL_INVALID_OPERATION);
-        return AL_FALSE;
-    }
-
-    ext = strdup(extName);
-    ptr = ext;
-    do {
-        *ptr = (char)toupper(*ptr);
-    } while(*(ptr++));
-
-    SuspendContext(pContext);
-
-    ptr = pContext->ExtensionList;
-    while((ptr=strstr(ptr, ext)) != NULL)
-    {
-        if(ptr == pContext->ExtensionList || ptr[-1] == ' ')
+        if(strncasecmp(ptr, extName, len) == 0 &&
+           (ptr[len] == '\0' || isspace(ptr[len])))
        {
-            char e = ptr[strlen(ext)];
-            if(e == ' ' || e == 0)
-            {
-                bIsSupported = AL_TRUE;
-                break;
-            }
+            ret = AL_TRUE;
+            break;
+        }
+        if((ptr=strchr(ptr, ' ')) != NULL)
+        {
+            do {
+                ++ptr;
+            } while(isspace(*ptr));
        }
-        ptr++;
    }

-    ProcessContext(pContext);
-
-    free(ext);
-    return bIsSupported;
+done:
+    ALCcontext_DecRef(context);
+    return ret;
 }


-ALAPI ALvoid * ALAPIENTRY alGetProcAddress(const ALchar *funcName)
+AL_API ALvoid* AL_APIENTRY alGetProcAddress(const ALchar *funcName)
 {
-    ALsizei i = 0;
-
-    while(function[i].funcName &&
-          strcmp((char*)function[i].funcName, (char*)funcName) != 0)
-        i++;
-
-    return function[i].address;
+    if(!funcName)
+        return NULL;
+    return alcGetProcAddress(NULL, funcName);
 }

-/* NOTE: This function must be able to run without a context! */
-ALAPI ALenum ALAPIENTRY alGetEnumValue(const ALchar *enumName)
+AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *enumName)
 {
-    ALsizei i = 0;
-
-    while(enumeration[i].enumName &&
-          strcmp(enumeration[i].enumName, enumName) != 0)
-        i++;
-
-    return enumeration[i].value;
+    if(!enumName)
+        return (ALenum)0;
+    return alcGetEnumValue(NULL, enumName);
 }
@@ -0,0 +1,701 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "alu.h"
+#include "alFilter.h"
+#include "alThunk.h"
+#include "alError.h"
+
+
+extern inline struct ALfilter *LookupFilter(ALCdevice *device, ALuint id);
+extern inline struct ALfilter *RemoveFilter(ALCdevice *device, ALuint id);
+extern inline ALfloat ALfilterState_processSingle(ALfilterState *filter, ALfloat sample);
+
+static void InitFilterParams(ALfilter *filter, ALenum type);
+
+
+AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsizei cur = 0;
+    ALenum err;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    for(cur = 0;cur < n;cur++)
+    {
+        ALfilter *filter = calloc(1, sizeof(ALfilter));
+        if(!filter)
+        {
+            alDeleteFilters(cur, filters);
+            SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
+        }
+        InitFilterParams(filter, AL_FILTER_NULL);
+
+        err = NewThunkEntry(&filter->id);
+        if(err == AL_NO_ERROR)
+            err = InsertUIntMapEntry(&device->FilterMap, filter->id, filter);
+        if(err != AL_NO_ERROR)
+        {
+            FreeThunkEntry(filter->id);
+            memset(filter, 0, sizeof(ALfilter));
+            free(filter);
+
+            alDeleteFilters(cur, filters);
+            SET_ERROR_AND_GOTO(context, err, done);
+        }
+
+        filters[cur] = filter->id;
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALfilter *filter;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    for(i = 0;i < n;i++)
+    {
+        if(filters[i] && LookupFilter(device, filters[i]) == NULL)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    }
+    for(i = 0;i < n;i++)
+    {
+        if((filter=RemoveFilter(device, filters[i])) == NULL)
+            continue;
+        FreeThunkEntry(filter->id);
+
+        memset(filter, 0, sizeof(*filter));
+        free(filter);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
+{
+    ALCcontext *Context;
+    ALboolean  result;
+
+    Context = GetContextRef();
+    if(!Context) return AL_FALSE;
+
+    result = ((!filter || LookupFilter(Context->Device, filter)) ?
+              AL_TRUE : AL_FALSE);
+
+    ALCcontext_DecRef(Context);
+
+    return result;
+}
+
+AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        if(param == AL_FILTER_TYPE)
+        {
+            if(value == AL_FILTER_NULL || value == AL_FILTER_LOWPASS ||
+               value == AL_FILTER_HIGHPASS || value == AL_FILTER_BANDPASS)
+                InitFilterParams(ALFilter, value);
+            else
+                alSetError(Context, AL_INVALID_VALUE);
+        }
+        else
+        {
+            /* Call the appropriate handler */
+            ALfilter_SetParami(ALFilter, Context, param, value);
+        }
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    switch(param)
+    {
+        case AL_FILTER_TYPE:
+            alFilteri(filter, param, values[0]);
+            return;
+    }
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        ALfilter_SetParamiv(ALFilter, Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        ALfilter_SetParamf(ALFilter, Context, param, value);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        ALfilter_SetParamfv(ALFilter, Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        if(param == AL_FILTER_TYPE)
+            *value = ALFilter->type;
+        else
+        {
+            /* Call the appropriate handler */
+            ALfilter_GetParami(ALFilter, Context, param, value);
+        }
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    switch(param)
+    {
+        case AL_FILTER_TYPE:
+            alGetFilteri(filter, param, values);
+            return;
+    }
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        ALfilter_GetParamiv(ALFilter, Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *value)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        ALfilter_GetParamf(ALFilter, Context, param, value);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *values)
+{
+    ALCcontext *Context;
+    ALCdevice  *Device;
+    ALfilter   *ALFilter;
+
+    Context = GetContextRef();
+    if(!Context) return;
+
+    Device = Context->Device;
+    if((ALFilter=LookupFilter(Device, filter)) == NULL)
+        alSetError(Context, AL_INVALID_NAME);
+    else
+    {
+        /* Call the appropriate handler */
+        ALfilter_GetParamfv(ALFilter, Context, param, values);
+    }
+
+    ALCcontext_DecRef(Context);
+}
+
+
+void ALfilterState_clear(ALfilterState *filter)
+{
+    filter->x[0] = 0.0f;
+    filter->x[1] = 0.0f;
+    filter->y[0] = 0.0f;
+    filter->y[1] = 0.0f;
+}
+
+void ALfilterState_setParams(ALfilterState *filter, ALfilterType type, ALfloat gain, ALfloat freq_mult, ALfloat bandwidth)
+{
+    ALfloat alpha;
+    ALfloat w0;
+
+    // Limit gain to -100dB
+    gain = maxf(gain, 0.00001f);
+
+    w0 = F_2PI * freq_mult;
+
+    /* Calculate filter coefficients depending on filter type */
+    switch(type)
+    {
+        case ALfilterType_HighShelf:
+            alpha = sinf(w0)/2.0f*sqrtf((gain + 1.0f/gain)*(1.0f/0.75f - 1.0f) + 2.0f);
+            filter->b[0] =       gain*((gain+1.0f) + (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha);
+            filter->b[1] = -2.0f*gain*((gain-1.0f) + (gain+1.0f)*cosf(w0)                         );
+            filter->b[2] =       gain*((gain+1.0f) + (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha);
+            filter->a[0] =             (gain+1.0f) - (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha;
+            filter->a[1] =  2.0f*     ((gain-1.0f) - (gain+1.0f)*cosf(w0)                         );
+            filter->a[2] =             (gain+1.0f) - (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha;
+            break;
+        case ALfilterType_LowShelf:
+            alpha = sinf(w0)/2.0f*sqrtf((gain + 1.0f/gain)*(1.0f/0.75f - 1.0f) + 2.0f);
+            filter->b[0] =       gain*((gain+1.0f) - (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha);
+            filter->b[1] =  2.0f*gain*((gain-1.0f) - (gain+1.0f)*cosf(w0)                         );
+            filter->b[2] =       gain*((gain+1.0f) - (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha);
+            filter->a[0] =             (gain+1.0f) + (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha;
+            filter->a[1] = -2.0f*     ((gain-1.0f) + (gain+1.0f)*cosf(w0)                         );
+            filter->a[2] =             (gain+1.0f) + (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha;
+            break;
+        case ALfilterType_Peaking:
+            alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
+            filter->b[0] =  1.0f + alpha * gain;
+            filter->b[1] = -2.0f * cosf(w0);
+            filter->b[2] =  1.0f - alpha * gain;
+            filter->a[0] =  1.0f + alpha / gain;
+            filter->a[1] = -2.0f * cosf(w0);
+            filter->a[2] =  1.0f - alpha / gain;
+            break;
+
+        case ALfilterType_LowPass:
+            alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
+            filter->b[0] = (1.0f - cosf(w0)) / 2.0f;
+            filter->b[1] =  1.0f - cosf(w0);
+            filter->b[2] = (1.0f - cosf(w0)) / 2.0f;
+            filter->a[0] =  1.0f + alpha;
+            filter->a[1] = -2.0f * cosf(w0);
+            filter->a[2] =  1.0f - alpha;
+            break;
+        case ALfilterType_HighPass:
+            alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
+            filter->b[0] = (1.0f + cosf(w0)) / 2.0f;
+            filter->b[1] =  1.0f + cosf(w0);
+            filter->b[2] = (1.0f + cosf(w0)) / 2.0f;
+            filter->a[0] =  1.0f + alpha;
+            filter->a[1] = -2.0f * cosf(w0);
+            filter->a[2] =  1.0f - alpha;
+            break;
+        case ALfilterType_BandPass:
+            alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
+            filter->b[0] =  alpha;
+            filter->b[1] =  0;
+            filter->b[2] = -alpha;
+            filter->a[0] =  1.0f + alpha;
+            filter->a[1] = -2.0f * cosf(w0);
+            filter->a[2] =  1.0f - alpha;
+            break;
+    }
+
+    filter->b[2] /= filter->a[0];
+    filter->b[1] /= filter->a[0];
+    filter->b[0] /= filter->a[0];
+    filter->a[2] /= filter->a[0];
+    filter->a[1] /= filter->a[0];
+    filter->a[0] /= filter->a[0];
+
+    filter->process = ALfilterState_processC;
+}
+
+
+static void lp_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void lp_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void lp_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
+{
+    switch(param)
+    {
+        case AL_LOWPASS_GAIN:
+            if(!(val >= AL_LOWPASS_MIN_GAIN && val <= AL_LOWPASS_MAX_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            filter->Gain = val;
+            break;
+
+        case AL_LOWPASS_GAINHF:
+            if(!(val >= AL_LOWPASS_MIN_GAINHF && val <= AL_LOWPASS_MAX_GAINHF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            filter->GainHF = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+static void lp_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    lp_SetParamf(filter, context, param, vals[0]);
+}
+
+static void lp_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void lp_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void lp_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    switch(param)
+    {
+        case AL_LOWPASS_GAIN:
+            *val = filter->Gain;
+            break;
+
+        case AL_LOWPASS_GAINHF:
+            *val = filter->GainHF;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+static void lp_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    lp_GetParamf(filter, context, param, vals);
+}
+
+
+static void hp_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void hp_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void hp_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
+{
+    switch(param)
+    {
+        case AL_HIGHPASS_GAIN:
+            if(!(val >= AL_HIGHPASS_MIN_GAIN && val <= AL_HIGHPASS_MAX_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            filter->Gain = val;
+            break;
+
+        case AL_HIGHPASS_GAINLF:
+            if(!(val >= AL_HIGHPASS_MIN_GAINLF && val <= AL_HIGHPASS_MAX_GAINLF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            filter->GainLF = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+static void hp_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    hp_SetParamf(filter, context, param, vals[0]);
+}
+
+static void hp_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void hp_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void hp_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    switch(param)
+    {
+        case AL_HIGHPASS_GAIN:
+            *val = filter->Gain;
+            break;
+
+        case AL_HIGHPASS_GAINLF:
+            *val = filter->GainLF;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+static void hp_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    hp_GetParamf(filter, context, param, vals);
+}
+
+
+static void bp_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void bp_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void bp_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
+{
+    switch(param)
+    {
+        case AL_BANDPASS_GAIN:
+            if(!(val >= AL_BANDPASS_MIN_GAIN && val <= AL_BANDPASS_MAX_GAIN))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            filter->Gain = val;
+            break;
+
+        case AL_BANDPASS_GAINHF:
+            if(!(val >= AL_BANDPASS_MIN_GAINHF && val <= AL_BANDPASS_MAX_GAINHF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            filter->GainHF = val;
+            break;
+
+        case AL_BANDPASS_GAINLF:
+            if(!(val >= AL_BANDPASS_MIN_GAINLF && val <= AL_BANDPASS_MAX_GAINLF))
+                SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
+            filter->GainLF = val;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+static void bp_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
+{
+    bp_SetParamf(filter, context, param, vals[0]);
+}
+
+static void bp_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void bp_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void bp_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
+{
+    switch(param)
+    {
+        case AL_BANDPASS_GAIN:
+            *val = filter->Gain;
+            break;
+
+        case AL_BANDPASS_GAINHF:
+            *val = filter->GainHF;
+            break;
+
+        case AL_BANDPASS_GAINLF:
+            *val = filter->GainLF;
+            break;
+
+        default:
+            SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
+    }
+}
+static void bp_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
+{
+    bp_GetParamf(filter, context, param, vals);
+}
+
+
+static void null_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void null_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void null_SetParamf(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALfloat UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void null_SetParamfv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALfloat *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+
+static void null_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void null_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void null_GetParamf(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+static void null_GetParamfv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(vals))
+{ SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
+
+
+ALvoid ReleaseALFilters(ALCdevice *device)
+{
+    ALsizei i;
+    for(i = 0;i < device->FilterMap.size;i++)
+    {
+        ALfilter *temp = device->FilterMap.array[i].value;
+        device->FilterMap.array[i].value = NULL;
+
+        // Release filter structure
+        FreeThunkEntry(temp->id);
+        memset(temp, 0, sizeof(ALfilter));
+        free(temp);
+    }
+}
+
+
+static void InitFilterParams(ALfilter *filter, ALenum type)
+{
+    if(type == AL_FILTER_LOWPASS)
+    {
+        filter->Gain = AL_LOWPASS_DEFAULT_GAIN;
+        filter->GainHF = AL_LOWPASS_DEFAULT_GAINHF;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = 1.0f;
+        filter->LFReference = HIGHPASSFREQREF;
+
+        filter->SetParami  = lp_SetParami;
+        filter->SetParamiv = lp_SetParamiv;
+        filter->SetParamf  = lp_SetParamf;
+        filter->SetParamfv = lp_SetParamfv;
+        filter->GetParami  = lp_GetParami;
+        filter->GetParamiv = lp_GetParamiv;
+        filter->GetParamf  = lp_GetParamf;
+        filter->GetParamfv = lp_GetParamfv;
+    }
+    else if(type == AL_FILTER_HIGHPASS)
+    {
+        filter->Gain = AL_HIGHPASS_DEFAULT_GAIN;
+        filter->GainHF = 1.0f;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = AL_HIGHPASS_DEFAULT_GAINLF;
+        filter->LFReference = HIGHPASSFREQREF;
+
+        filter->SetParami  = hp_SetParami;
+        filter->SetParamiv = hp_SetParamiv;
+        filter->SetParamf  = hp_SetParamf;
+        filter->SetParamfv = hp_SetParamfv;
+        filter->GetParami  = hp_GetParami;
+        filter->GetParamiv = hp_GetParamiv;
+        filter->GetParamf  = hp_GetParamf;
+        filter->GetParamfv = hp_GetParamfv;
+    }
+    else if(type == AL_FILTER_BANDPASS)
+    {
+        filter->Gain = AL_BANDPASS_DEFAULT_GAIN;
+        filter->GainHF = AL_BANDPASS_DEFAULT_GAINHF;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = AL_BANDPASS_DEFAULT_GAINLF;
+        filter->LFReference = HIGHPASSFREQREF;
+
+        filter->SetParami  = bp_SetParami;
+        filter->SetParamiv = bp_SetParamiv;
+        filter->SetParamf  = bp_SetParamf;
+        filter->SetParamfv = bp_SetParamfv;
+        filter->GetParami  = bp_GetParami;
+        filter->GetParamiv = bp_GetParamiv;
+        filter->GetParamf  = bp_GetParamf;
+        filter->GetParamfv = bp_GetParamfv;
+    }
+    else
+    {
+        filter->Gain = 1.0f;
+        filter->GainHF = 1.0f;
+        filter->HFReference = LOWPASSFREQREF;
+        filter->GainLF = 1.0f;
+        filter->LFReference = HIGHPASSFREQREF;
+
+        filter->SetParami  = null_SetParami;
+        filter->SetParamiv = null_SetParamiv;
+        filter->SetParamf  = null_SetParamf;
+        filter->SetParamfv = null_SetParamfv;
+        filter->GetParami  = null_GetParami;
+        filter->GetParamiv = null_GetParamiv;
+        filter->GetParamf  = null_GetParamf;
+        filter->GetParamfv = null_GetParamfv;
+    }
+    filter->type = type;
+}
@@ -18,496 +18,429 @@
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

+#include "config.h"
+
 #include "alMain.h"
 #include "AL/alc.h"
 #include "alError.h"
 #include "alListener.h"
+#include "alSource.h"

-ALAPI ALvoid ALAPIENTRY alListenerf(ALenum eParam, ALfloat flValue)
+AL_API ALvoid AL_APIENTRY alListenerf(ALenum param, ALfloat value)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    context = GetContextRef();
+    if(!context) return;
+
+    switch(param)
    {
-        SuspendContext(pContext);
+    case AL_GAIN:
+        if(!(value >= 0.0f && isfinite(value)))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);

-        switch (eParam)
+        context->Listener->Gain = value;
+        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+        break;
+
+    case AL_METERS_PER_UNIT:
+        if(!(value >= 0.0f && isfinite(value)))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+        context->Listener->MetersPerUnit = value;
+        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+
+AL_API ALvoid AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
+{
+    ALCcontext *context;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    switch(param)
+    {
+    case AL_POSITION:
+        if(!(isfinite(value1) && isfinite(value2) && isfinite(value3)))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+        LockContext(context);
+        context->Listener->Position[0] = value1;
+        context->Listener->Position[1] = value2;
+        context->Listener->Position[2] = value3;
+        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+        UnlockContext(context);
+        break;
+
+    case AL_VELOCITY:
+        if(!(isfinite(value1) && isfinite(value2) && isfinite(value3)))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+        LockContext(context);
+        context->Listener->Velocity[0] = value1;
+        context->Listener->Velocity[1] = value2;
+        context->Listener->Velocity[2] = value3;
+        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+        UnlockContext(context);
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+
+AL_API ALvoid AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values)
+{
+    ALCcontext *context;
+
+    if(values)
+    {
+        switch(param)
        {
        case AL_GAIN:
-            if (flValue >= 0.0f)
-                pContext->Listener.Gain = flValue;
-            else
-                alSetError(AL_INVALID_VALUE);
-            break;
+        case AL_METERS_PER_UNIT:
+            alListenerf(param, values[0]);
+            return;

-        default:
-            alSetError(AL_INVALID_ENUM);
-            break;
-        }
-
-        ProcessContext(pContext);
-    }
-    else
-        alSetError(AL_INVALID_OPERATION);
-
-    return;
-}
-
-
-ALAPI ALvoid ALAPIENTRY alListener3f(ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
-{
-    ALCcontext *pContext;
-
-    pContext = alcGetCurrentContext();
-    if (pContext)
-    {
-        SuspendContext(pContext);
-
-        switch(eParam)
-        {
        case AL_POSITION:
-            pContext->Listener.Position[0] = flValue1;
-            pContext->Listener.Position[1] = flValue2;
-            pContext->Listener.Position[2] = flValue3;
-            break;
-
        case AL_VELOCITY:
-            pContext->Listener.Velocity[0] = flValue1;
-            pContext->Listener.Velocity[1] = flValue2;
-            pContext->Listener.Velocity[2] = flValue3;
-            break;
-
-        default:
-            alSetError(AL_INVALID_ENUM);
-            break;
+            alListener3f(param, values[0], values[1], values[2]);
+            return;
        }
-
-        ProcessContext(pContext);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(values))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch(param)
+    {
+    case AL_ORIENTATION:
+        if(!(isfinite(values[0]) && isfinite(values[1]) && isfinite(values[2]) &&
+             isfinite(values[3]) && isfinite(values[4]) && isfinite(values[5])))
+            SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+        LockContext(context);
+        /* AT then UP */
+        context->Listener->Forward[0] = values[0];
+        context->Listener->Forward[1] = values[1];
+        context->Listener->Forward[2] = values[2];
+        context->Listener->Up[0] = values[3];
+        context->Listener->Up[1] = values[4];
+        context->Listener->Up[2] = values[5];
+        ATOMIC_STORE(&context->UpdateSources, AL_TRUE);
+        UnlockContext(context);
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI ALvoid ALAPIENTRY alListenerfv(ALenum eParam, const ALfloat *pflValues)
+AL_API ALvoid AL_APIENTRY alListeneri(ALenum param, ALint UNUSED(value))
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    context = GetContextRef();
+    if(!context) return;
+
+    switch(param)
    {
-        SuspendContext(pContext);
-
-        if (pflValues)
-        {
-            switch (eParam)
-            {
-            case AL_GAIN:
-                if (pflValues[0] >= 0.0f)
-                    pContext->Listener.Gain = pflValues[0];
-                else
-                    alSetError(AL_INVALID_VALUE);
-                break;
-
-            case AL_POSITION:
-                pContext->Listener.Position[0] = pflValues[0];
-                pContext->Listener.Position[1] = pflValues[1];
-                pContext->Listener.Position[2] = pflValues[2];
-                break;
-
-            case AL_VELOCITY:
-                pContext->Listener.Velocity[0] = pflValues[0];
-                pContext->Listener.Velocity[1] = pflValues[1];
-                pContext->Listener.Velocity[2] = pflValues[2];
-                break;
-
-            case AL_ORIENTATION:
-                // AT then UP
-                pContext->Listener.Forward[0] = pflValues[0];
-                pContext->Listener.Forward[1] = pflValues[1];
-                pContext->Listener.Forward[2] = pflValues[2];
-                pContext->Listener.Up[0] = pflValues[3];
-                pContext->Listener.Up[1] = pflValues[4];
-                pContext->Listener.Up[2] = pflValues[5];
-                break;
-
-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI ALvoid ALAPIENTRY alListeneri(ALenum eParam, ALint lValue)
+AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    (void)lValue;
-
-    pContext = alcGetCurrentContext();
-    if (pContext)
+    switch(param)
    {
-        SuspendContext(pContext);
-
-        switch (eParam)
-        {
-        default:
-            alSetError(AL_INVALID_ENUM);
-            break;
-        }
-
-        ProcessContext(pContext);
+    case AL_POSITION:
+    case AL_VELOCITY:
+        alListener3f(param, (ALfloat)value1, (ALfloat)value2, (ALfloat)value3);
+        return;
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+    context = GetContextRef();
+    if(!context) return;
+
+    switch(param)
+    {
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI void ALAPIENTRY alListener3i(ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
+AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    if(values)
    {
-        SuspendContext(pContext);
-
-        switch(eParam)
+        ALfloat fvals[6];
+        switch(param)
        {
        case AL_POSITION:
        case AL_VELOCITY:
-            alListener3f(eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
-            break;
+            alListener3f(param, (ALfloat)values[0], (ALfloat)values[1], (ALfloat)values[2]);
+            return;

-        default:
-            alSetError(AL_INVALID_ENUM);
-            break;
+        case AL_ORIENTATION:
+            fvals[0] = (ALfloat)values[0];
+            fvals[1] = (ALfloat)values[1];
+            fvals[2] = (ALfloat)values[2];
+            fvals[3] = (ALfloat)values[3];
+            fvals[4] = (ALfloat)values[4];
+            fvals[5] = (ALfloat)values[5];
+            alListenerfv(param, fvals);
+            return;
        }
-
-        ProcessContext(pContext);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
-}
+    context = GetContextRef();
+    if(!context) return;

-
-ALAPI void ALAPIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
-{
-    ALCcontext *pContext;
-    ALfloat flValues[6];
-
-    pContext = alcGetCurrentContext();
-    if (pContext)
+    if(!(values))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch(param)
    {
-        SuspendContext(pContext);
-
-        if (plValues)
-        {
-            switch (eParam)
-            {
-            case AL_POSITION:
-            case AL_VELOCITY:
-                flValues[0] = (ALfloat)plValues[0];
-                flValues[1] = (ALfloat)plValues[1];
-                flValues[2] = (ALfloat)plValues[2];
-                alListenerfv(eParam, flValues);
-                break;
-
-            case AL_ORIENTATION:
-                flValues[0] = (ALfloat)plValues[0];
-                flValues[1] = (ALfloat)plValues[1];
-                flValues[2] = (ALfloat)plValues[2];
-                flValues[3] = (ALfloat)plValues[3];
-                flValues[4] = (ALfloat)plValues[4];
-                flValues[5] = (ALfloat)plValues[5];
-                alListenerfv(eParam, flValues);
-                break;
-
-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI ALvoid ALAPIENTRY alGetListenerf(ALenum eParam, ALfloat *pflValue)
+AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(value))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch(param)
    {
-        SuspendContext(pContext);
+    case AL_GAIN:
+        *value = context->Listener->Gain;
+        break;

-        if (pflValue)
-        {
-            switch (eParam)
-            {
-            case AL_GAIN:
-                *pflValue = pContext->Listener.Gain;
-                break;
+    case AL_METERS_PER_UNIT:
+        *value = context->Listener->MetersPerUnit;
+        break;

-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI ALvoid ALAPIENTRY alGetListener3f(ALenum eParam, ALfloat *pflValue1, ALfloat *pflValue2, ALfloat *pflValue3)
+AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(value1 && value2 && value3))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch(param)
    {
-        SuspendContext(pContext);
+    case AL_POSITION:
+        LockContext(context);
+        *value1 = context->Listener->Position[0];
+        *value2 = context->Listener->Position[1];
+        *value3 = context->Listener->Position[2];
+        UnlockContext(context);
+        break;

-        if ((pflValue1) && (pflValue2) && (pflValue3))
-        {
-            switch (eParam)
-            {
-            case AL_POSITION:
-                *pflValue1 = pContext->Listener.Position[0];
-                *pflValue2 = pContext->Listener.Position[1];
-                *pflValue3 = pContext->Listener.Position[2];
-                break;
+    case AL_VELOCITY:
+        LockContext(context);
+        *value1 = context->Listener->Velocity[0];
+        *value2 = context->Listener->Velocity[1];
+        *value3 = context->Listener->Velocity[2];
+        UnlockContext(context);
+        break;

-            case AL_VELOCITY:
-                *pflValue1 = pContext->Listener.Velocity[0];
-                *pflValue2 = pContext->Listener.Velocity[1];
-                *pflValue3 = pContext->Listener.Velocity[2];
-                break;
-
-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI ALvoid ALAPIENTRY alGetListenerfv(ALenum eParam, ALfloat *pflValues)
+AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    switch(param)
    {
-        SuspendContext(pContext);
+    case AL_GAIN:
+    case AL_METERS_PER_UNIT:
+        alGetListenerf(param, values);
+        return;

-        if (pflValues)
-        {
-            switch (eParam)
-            {
-            case AL_GAIN:
-                pflValues[0] = pContext->Listener.Gain;
-                break;
-
-            case AL_POSITION:
-                pflValues[0] = pContext->Listener.Position[0];
-                pflValues[1] = pContext->Listener.Position[1];
-                pflValues[2] = pContext->Listener.Position[2];
-                break;
-
-            case AL_VELOCITY:
-                pflValues[0] = pContext->Listener.Velocity[0];
-                pflValues[1] = pContext->Listener.Velocity[1];
-                pflValues[2] = pContext->Listener.Velocity[2];
-                break;
-
-            case AL_ORIENTATION:
-                // AT then UP
-                pflValues[0] = pContext->Listener.Forward[0];
-                pflValues[1] = pContext->Listener.Forward[1];
-                pflValues[2] = pContext->Listener.Forward[2];
-                pflValues[3] = pContext->Listener.Up[0];
-                pflValues[4] = pContext->Listener.Up[1];
-                pflValues[5] = pContext->Listener.Up[2];
-                break;
-
-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    case AL_POSITION:
+    case AL_VELOCITY:
+        alGetListener3f(param, values+0, values+1, values+2);
+        return;
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(values))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch(param)
+    {
+    case AL_ORIENTATION:
+        LockContext(context);
+        // AT then UP
+        values[0] = context->Listener->Forward[0];
+        values[1] = context->Listener->Forward[1];
+        values[2] = context->Listener->Forward[2];
+        values[3] = context->Listener->Up[0];
+        values[4] = context->Listener->Up[1];
+        values[5] = context->Listener->Up[2];
+        UnlockContext(context);
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI ALvoid ALAPIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
+AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum param, ALint *value)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(value))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch(param)
    {
-        SuspendContext(pContext);
-
-        if (plValue)
-        {
-            switch (eParam)
-            {
-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI void ALAPIENTRY alGetListener3i(ALenum eParam, ALint *plValue1, ALint *plValue2, ALint *plValue3)
+AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(value1 && value2 && value3))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch (param)
    {
-        SuspendContext(pContext);
+    case AL_POSITION:
+        LockContext(context);
+        *value1 = (ALint)context->Listener->Position[0];
+        *value2 = (ALint)context->Listener->Position[1];
+        *value3 = (ALint)context->Listener->Position[2];
+        UnlockContext(context);
+        break;

-        if ((plValue1) && (plValue2) && (plValue3))
-        {
-            switch (eParam)
-            {
-            case AL_POSITION:
-                *plValue1 = (ALint)pContext->Listener.Position[0];
-                *plValue2 = (ALint)pContext->Listener.Position[1];
-                *plValue3 = (ALint)pContext->Listener.Position[2];
-                break;
+    case AL_VELOCITY:
+        LockContext(context);
+        *value1 = (ALint)context->Listener->Velocity[0];
+        *value2 = (ALint)context->Listener->Velocity[1];
+        *value3 = (ALint)context->Listener->Velocity[2];
+        UnlockContext(context);
+        break;

-            case AL_VELOCITY:
-                *plValue1 = (ALint)pContext->Listener.Velocity[0];
-                *plValue2 = (ALint)pContext->Listener.Velocity[1];
-                *plValue3 = (ALint)pContext->Listener.Velocity[2];
-                break;
-
-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+done:
+    ALCcontext_DecRef(context);
 }


-ALAPI void ALAPIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
+AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint* values)
 {
-    ALCcontext *pContext;
+    ALCcontext *context;

-    pContext = alcGetCurrentContext();
-    if (pContext)
+    switch(param)
    {
-        SuspendContext(pContext);
-
-        if (plValues)
-        {
-            switch (eParam)
-            {
-            case AL_POSITION:
-                plValues[0] = (ALint)pContext->Listener.Position[0];
-                plValues[1] = (ALint)pContext->Listener.Position[1];
-                plValues[2] = (ALint)pContext->Listener.Position[2];
-                break;
-
-            case AL_VELOCITY:
-                plValues[0] = (ALint)pContext->Listener.Velocity[0];
-                plValues[1] = (ALint)pContext->Listener.Velocity[1];
-                plValues[2] = (ALint)pContext->Listener.Velocity[2];
-                break;
-
-            case AL_ORIENTATION:
-                // AT then UP
-                plValues[0] = (ALint)pContext->Listener.Forward[0];
-                plValues[1] = (ALint)pContext->Listener.Forward[1];
-                plValues[2] = (ALint)pContext->Listener.Forward[2];
-                plValues[3] = (ALint)pContext->Listener.Up[0];
-                plValues[4] = (ALint)pContext->Listener.Up[1];
-                plValues[5] = (ALint)pContext->Listener.Up[2];
-                break;
-
-            default:
-                alSetError(AL_INVALID_ENUM);
-                break;
-            }
-        }
-        else
-            alSetError(AL_INVALID_VALUE);
-
-        ProcessContext(pContext);
+    case AL_POSITION:
+    case AL_VELOCITY:
+        alGetListener3i(param, values+0, values+1, values+2);
+        return;
    }
-    else
-        alSetError(AL_INVALID_OPERATION);

-    return;
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(values))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    switch(param)
+    {
+    case AL_ORIENTATION:
+        LockContext(context);
+        // AT then UP
+        values[0] = (ALint)context->Listener->Forward[0];
+        values[1] = (ALint)context->Listener->Forward[1];
+        values[2] = (ALint)context->Listener->Forward[2];
+        values[3] = (ALint)context->Listener->Up[0];
+        values[4] = (ALint)context->Listener->Up[1];
+        values[5] = (ALint)context->Listener->Up[2];
+        UnlockContext(context);
+        break;
+
+    default:
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
 }
@@ -0,0 +1,217 @@
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "alMain.h"
+#include "alMidi.h"
+#include "alError.h"
+#include "alThunk.h"
+#include "evtqueue.h"
+#include "rwlock.h"
+#include "alu.h"
+
+#include "midi/base.h"
+
+
+MidiSynth *SynthCreate(ALCdevice *device)
+{
+    MidiSynth *synth = NULL;
+    if(!synth) synth = SSynth_create(device);
+    if(!synth) synth = FSynth_create(device);
+    if(!synth) synth = DSynth_create(device);
+    return synth;
+}
+
+
+AL_API void AL_APIENTRY alMidiSoundfontSOFT(ALuint id)
+{
+    alMidiSoundfontvSOFT(1, &id);
+}
+
+AL_API void AL_APIENTRY alMidiSoundfontvSOFT(ALsizei count, const ALuint *ids)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    MidiSynth *synth;
+    ALenum err;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(count < 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    synth = device->Synth;
+
+    WriteLock(&synth->Lock);
+    if(synth->State == AL_PLAYING || synth->State == AL_PAUSED)
+        alSetError(context, AL_INVALID_OPERATION);
+    else
+    {
+        err = V(synth,selectSoundfonts)(context, count, ids);
+        if(err != AL_NO_ERROR)
+            alSetError(context, err);
+    }
+    WriteUnlock(&synth->Lock);
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+
+AL_API void AL_APIENTRY alMidiEventSOFT(ALuint64SOFT time, ALenum event, ALsizei channel, ALsizei param1, ALsizei param2)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALenum err;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(event == AL_NOTEOFF_SOFT || event == AL_NOTEON_SOFT ||
+         event == AL_KEYPRESSURE_SOFT || event == AL_CONTROLLERCHANGE_SOFT ||
+         event == AL_PROGRAMCHANGE_SOFT || event == AL_CHANNELPRESSURE_SOFT ||
+         event == AL_PITCHBEND_SOFT))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    if(!(channel >= 0 && channel <= 15))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    if(!(param1 >= 0 && param1 <= 127))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+    if(!(param2 >= 0 && param2 <= 127))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    ALCdevice_Lock(device);
+    err = MidiSynth_insertEvent(device->Synth, time, event|channel, param1, param2);
+    ALCdevice_Unlock(device);
+    if(err != AL_NO_ERROR)
+        alSetError(context, err);
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alMidiSysExSOFT(ALuint64SOFT time, const ALbyte *data, ALsizei size)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALenum err;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!data || size < 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    ALCdevice_Lock(device);
+    err = MidiSynth_insertSysExEvent(device->Synth, time, data, size);
+    ALCdevice_Unlock(device);
+    if(err != AL_NO_ERROR)
+        alSetError(context, err);
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alMidiPlaySOFT(void)
+{
+    ALCcontext *context;
+    MidiSynth *synth;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    synth = context->Device->Synth;
+    WriteLock(&synth->Lock);
+    MidiSynth_setState(synth, AL_PLAYING);
+    WriteUnlock(&synth->Lock);
+
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alMidiPauseSOFT(void)
+{
+    ALCcontext *context;
+    MidiSynth *synth;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    synth = context->Device->Synth;
+    WriteLock(&synth->Lock);
+    MidiSynth_setState(synth, AL_PAUSED);
+    WriteUnlock(&synth->Lock);
+
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alMidiStopSOFT(void)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    MidiSynth *synth;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    synth = device->Synth;
+
+    WriteLock(&synth->Lock);
+    MidiSynth_setState(synth, AL_STOPPED);
+
+    ALCdevice_Lock(device);
+    V0(synth,stop)();
+    ALCdevice_Unlock(device);
+    WriteUnlock(&synth->Lock);
+
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alMidiResetSOFT(void)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    MidiSynth *synth;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    synth = device->Synth;
+
+    WriteLock(&synth->Lock);
+    MidiSynth_setState(synth, AL_INITIAL);
+
+    ALCdevice_Lock(device);
+    V0(synth,reset)();
+    ALCdevice_Unlock(device);
+    WriteUnlock(&synth->Lock);
+
+    ALCcontext_DecRef(context);
+}
+
+
+AL_API void AL_APIENTRY alMidiGainSOFT(ALfloat value)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(value >= 0.0f && isfinite(value)))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    V(device->Synth,setGain)(value);
+
+done:
+    ALCcontext_DecRef(context);
+}
@@ -0,0 +1,339 @@
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "alMain.h"
+#include "alMidi.h"
+#include "alError.h"
+#include "alThunk.h"
+
+#include "midi/base.h"
+
+
+extern inline struct ALsfpreset *LookupPreset(ALCdevice *device, ALuint id);
+extern inline struct ALsfpreset *RemovePreset(ALCdevice *device, ALuint id);
+
+static void ALsfpreset_Construct(ALsfpreset *self);
+static void ALsfpreset_Destruct(ALsfpreset *self);
+
+
+AL_API void AL_APIENTRY alGenPresetsSOFT(ALsizei n, ALuint *ids)
+{
+    ALCcontext *context;
+    ALsizei cur = 0;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    for(cur = 0;cur < n;cur++)
+    {
+        ALsfpreset *preset = NewPreset(context);
+        if(!preset)
+        {
+            alDeletePresetsSOFT(cur, ids);
+            break;
+        }
+
+        ids[cur] = preset->id;
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alDeletePresetsSOFT(ALsizei n, const ALuint *ids)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsfpreset *preset;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    for(i = 0;i < n;i++)
+    {
+        /* Check for valid ID */
+        if((preset=LookupPreset(device, ids[i])) == NULL)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        if(ReadRef(&preset->ref) != 0)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    }
+
+    for(i = 0;i < n;i++)
+    {
+        if((preset=LookupPreset(device, ids[i])) != NULL)
+            DeletePreset(device, preset);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsPresetSOFT(ALuint id)
+{
+    ALCcontext *context;
+    ALboolean ret;
+
+    context = GetContextRef();
+    if(!context) return AL_FALSE;
+
+    ret = LookupPreset(context->Device, id) ? AL_TRUE : AL_FALSE;
+
+    ALCcontext_DecRef(context);
+
+    return ret;
+}
+
+AL_API void AL_APIENTRY alPresetiSOFT(ALuint id, ALenum param, ALint value)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsfpreset *preset;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if((preset=LookupPreset(device, id)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    if(ReadRef(&preset->ref) != 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    switch(param)
+    {
+        case AL_MIDI_PRESET_SOFT:
+            if(!(value >= 0 && value <= 127))
+                SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+            preset->Preset = value;
+            break;
+
+        case AL_MIDI_BANK_SOFT:
+            if(!(value >= 0 && value <= 128))
+                SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+            preset->Bank = value;
+            break;
+
+        default:
+            SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alPresetivSOFT(ALuint id, ALenum param, const ALint *values)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsfpreset *preset;
+
+    switch(param)
+    {
+        case AL_MIDI_PRESET_SOFT:
+        case AL_MIDI_BANK_SOFT:
+            alPresetiSOFT(id, param, values[0]);
+            return;
+    }
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if((preset=LookupPreset(device, id)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    if(ReadRef(&preset->ref) != 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    switch(param)
+    {
+        default:
+            SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alGetPresetivSOFT(ALuint id, ALenum param, ALint *values)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsfpreset *preset;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if((preset=LookupPreset(device, id)) == NULL)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+        case AL_MIDI_PRESET_SOFT:
+            values[0] = preset->Preset;
+            break;
+
+        case AL_MIDI_BANK_SOFT:
+            values[0] = preset->Bank;
+            break;
+
+        case AL_FONTSOUNDS_SIZE_SOFT:
+            values[0] = preset->NumSounds;
+            break;
+
+        case AL_FONTSOUNDS_SOFT:
+            for(i = 0;i < preset->NumSounds;i++)
+                values[i] = preset->Sounds[i]->id;
+            break;
+
+        default:
+            SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alPresetFontsoundsSOFT(ALuint id, ALsizei count, const ALuint *fsids)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsfpreset *preset;
+    ALfontsound **sounds;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if(!(preset=LookupPreset(device, id)))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    if(count < 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    if(ReadRef(&preset->ref) != 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+
+    if(count == 0)
+        sounds = NULL;
+    else
+    {
+        sounds = calloc(count, sizeof(sounds[0]));
+        if(!sounds)
+            SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
+
+        for(i = 0;i < count;i++)
+        {
+            if(!(sounds[i]=LookupFontsound(device, fsids[i])))
+            {
+                free(sounds);
+                SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+            }
+        }
+    }
+
+    for(i = 0;i < count;i++)
+        IncrementRef(&sounds[i]->ref);
+
+    sounds = ExchangePtr((XchgPtr*)&preset->Sounds, sounds);
+    count = ExchangeInt(&preset->NumSounds, count);
+
+    for(i = 0;i < count;i++)
+        DecrementRef(&sounds[i]->ref);
+    free(sounds);
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+
+ALsfpreset *NewPreset(ALCcontext *context)
+{
+    ALCdevice *device = context->Device;
+    ALsfpreset *preset;
+    ALenum err;
+
+    preset = calloc(1, sizeof(*preset));
+    if(!preset)
+        SET_ERROR_AND_RETURN_VALUE(context, AL_OUT_OF_MEMORY, NULL);
+    ALsfpreset_Construct(preset);
+
+    err = NewThunkEntry(&preset->id);
+    if(err == AL_NO_ERROR)
+        err = InsertUIntMapEntry(&device->PresetMap, preset->id, preset);
+    if(err != AL_NO_ERROR)
+    {
+        ALsfpreset_Destruct(preset);
+        memset(preset, 0, sizeof(*preset));
+        free(preset);
+
+        SET_ERROR_AND_RETURN_VALUE(context, err, NULL);
+    }
+
+    return preset;
+}
+
+void DeletePreset(ALCdevice *device, ALsfpreset *preset)
+{
+    RemovePreset(device, preset->id);
+
+    ALsfpreset_Destruct(preset);
+    memset(preset, 0, sizeof(*preset));
+    free(preset);
+}
+
+
+static void ALsfpreset_Construct(ALsfpreset *self)
+{
+    InitRef(&self->ref, 0);
+
+    self->Preset = 0;
+    self->Bank = 0;
+
+    self->Sounds = NULL;
+    self->NumSounds = 0;
+
+    self->id = 0;
+}
+
+static void ALsfpreset_Destruct(ALsfpreset *self)
+{
+    ALsizei i;
+
+    FreeThunkEntry(self->id);
+    self->id = 0;
+
+    for(i = 0;i < self->NumSounds;i++)
+        DecrementRef(&self->Sounds[i]->ref);
+    free(self->Sounds);
+    self->Sounds = NULL;
+    self->NumSounds = 0;
+}
+
+
+/* ReleaseALPresets
+ *
+ * Called to destroy any presets that still exist on the device
+ */
+void ReleaseALPresets(ALCdevice *device)
+{
+    ALsizei i;
+    for(i = 0;i < device->PresetMap.size;i++)
+    {
+        ALsfpreset *temp = device->PresetMap.array[i].value;
+        device->PresetMap.array[i].value = NULL;
+
+        ALsfpreset_Destruct(temp);
+
+        memset(temp, 0, sizeof(*temp));
+        free(temp);
+    }
+}
@@ -0,0 +1,454 @@
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "alMain.h"
+#include "alMidi.h"
+#include "alThunk.h"
+#include "alError.h"
+#include <alBuffer.h>
+
+#include "midi/base.h"
+
+
+extern inline struct ALsoundfont *LookupSfont(ALCdevice *device, ALuint id);
+extern inline struct ALsoundfont *RemoveSfont(ALCdevice *device, ALuint id);
+
+static void ALsoundfont_Construct(ALsoundfont *self);
+static void ALsoundfont_Destruct(ALsoundfont *self);
+void ALsoundfont_deleteSoundfont(ALsoundfont *self, ALCdevice *device);
+ALsoundfont *ALsoundfont_getDefSoundfont(ALCcontext *context);
+static size_t ALsoundfont_read(ALvoid *buf, size_t bytes, ALvoid *ptr);
+
+
+AL_API void AL_APIENTRY alGenSoundfontsSOFT(ALsizei n, ALuint *ids)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsizei cur = 0;
+    ALenum err;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    for(cur = 0;cur < n;cur++)
+    {
+        ALsoundfont *sfont = calloc(1, sizeof(ALsoundfont));
+        if(!sfont)
+        {
+            alDeleteSoundfontsSOFT(cur, ids);
+            SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
+        }
+        ALsoundfont_Construct(sfont);
+
+        err = NewThunkEntry(&sfont->id);
+        if(err == AL_NO_ERROR)
+            err = InsertUIntMapEntry(&device->SfontMap, sfont->id, sfont);
+        if(err != AL_NO_ERROR)
+        {
+            ALsoundfont_Destruct(sfont);
+            memset(sfont, 0, sizeof(ALsoundfont));
+            free(sfont);
+
+            alDeleteSoundfontsSOFT(cur, ids);
+            SET_ERROR_AND_GOTO(context, err, done);
+        }
+
+        ids[cur] = sfont->id;
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALvoid AL_APIENTRY alDeleteSoundfontsSOFT(ALsizei n, const ALuint *ids)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsoundfont *sfont;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    if(!(n >= 0))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    device = context->Device;
+    for(i = 0;i < n;i++)
+    {
+        /* Check for valid soundfont ID */
+        if(ids[i] == 0)
+        {
+            if(!(sfont=device->DefaultSfont))
+                continue;
+        }
+        else if((sfont=LookupSfont(device, ids[i])) == NULL)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+        if(ReadRef(&sfont->ref) != 0)
+            SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    }
+
+    for(i = 0;i < n;i++)
+    {
+        if(ids[i] == 0)
+        {
+            MidiSynth *synth = device->Synth;
+            WriteLock(&synth->Lock);
+            if(device->DefaultSfont != NULL)
+                ALsoundfont_deleteSoundfont(device->DefaultSfont, device);
+            device->DefaultSfont = NULL;
+            WriteUnlock(&synth->Lock);
+            continue;
+        }
+        else if((sfont=RemoveSfont(device, ids[i])) == NULL)
+            continue;
+
+        ALsoundfont_Destruct(sfont);
+
+        memset(sfont, 0, sizeof(*sfont));
+        free(sfont);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API ALboolean AL_APIENTRY alIsSoundfontSOFT(ALuint id)
+{
+    ALCcontext *context;
+    ALboolean ret;
+
+    context = GetContextRef();
+    if(!context) return AL_FALSE;
+
+    ret = ((!id || LookupSfont(context->Device, id)) ?
+           AL_TRUE : AL_FALSE);
+
+    ALCcontext_DecRef(context);
+
+    return ret;
+}
+
+AL_API void AL_APIENTRY alGetSoundfontivSOFT(ALuint id, ALenum param, ALint *values)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsoundfont *sfont;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if(id == 0)
+        sfont = ALsoundfont_getDefSoundfont(context);
+    else if(!(sfont=LookupSfont(device, id)))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    switch(param)
+    {
+        case AL_PRESETS_SIZE_SOFT:
+            values[0] = sfont->NumPresets;
+            break;
+
+        case AL_PRESETS_SOFT:
+            for(i = 0;i < sfont->NumPresets;i++)
+                values[i] = sfont->Presets[i]->id;
+            break;
+
+        default:
+            SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
+    }
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+AL_API void AL_APIENTRY alSoundfontPresetsSOFT(ALuint id, ALsizei count, const ALuint *pids)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsoundfont *sfont;
+    ALsfpreset **presets;
+    ALsizei i;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if(id == 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    if(!(sfont=LookupSfont(device, id)))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+    if(count < 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+
+    WriteLock(&sfont->Lock);
+    if(ReadRef(&sfont->ref) != 0)
+    {
+        WriteUnlock(&sfont->Lock);
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    }
+
+    if(count == 0)
+        presets = NULL;
+    else
+    {
+        presets = calloc(count, sizeof(presets[0]));
+        if(!presets)
+        {
+            WriteUnlock(&sfont->Lock);
+            SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
+        }
+
+        for(i = 0;i < count;i++)
+        {
+            if(!(presets[i]=LookupPreset(device, pids[i])))
+            {
+                free(presets);
+                WriteUnlock(&sfont->Lock);
+                SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
+            }
+        }
+    }
+
+    for(i = 0;i < count;i++)
+        IncrementRef(&presets[i]->ref);
+
+    presets = ExchangePtr((XchgPtr*)&sfont->Presets, presets);
+    count = ExchangeInt(&sfont->NumPresets, count);
+    WriteUnlock(&sfont->Lock);
+
+    for(i = 0;i < count;i++)
+        DecrementRef(&presets[i]->ref);
+    free(presets);
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+
+AL_API void AL_APIENTRY alLoadSoundfontSOFT(ALuint id, size_t(*cb)(ALvoid*,size_t,ALvoid*), ALvoid *user)
+{
+    ALCdevice *device;
+    ALCcontext *context;
+    ALsoundfont *sfont;
+    Reader reader;
+
+    context = GetContextRef();
+    if(!context) return;
+
+    device = context->Device;
+    if(id == 0)
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    if(!(sfont=LookupSfont(device, id)))
+        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
+
+    WriteLock(&sfont->Lock);
+    if(ReadRef(&sfont->ref) != 0)
+    {
+        WriteUnlock(&sfont->Lock);
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    }
+    if(sfont->NumPresets > 0)
+    {
+        WriteUnlock(&sfont->Lock);
+        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
+    }
+
+    reader.cb = cb;
+    reader.ptr = user;
+    reader.error = 0;
+    loadSf2(&reader, sfont, context);
+    WriteUnlock(&sfont->Lock);
+
+done:
+    ALCcontext_DecRef(context);
+}
+
+
+static void ALsoundfont_Construct(ALsoundfont *self)
+{
+    InitRef(&self->ref, 0);
+
+    self->Presets = NULL;
+    self->NumPresets = 0;
+
+    RWLockInit(&self->Lock);
+
+    self->id = 0;
+}
+
+static void ALsoundfont_Destruct(ALsoundfont *self)
+{
+    ALsizei i;
+
+    FreeThunkEntry(self->id);
+    self->id = 0;
+
+    for(i = 0;i < self->NumPresets;i++)
+    {
+        DecrementRef(&self->Presets[i]->ref);
+        self->Presets[i] = NULL;
+    }
+    free(self->Presets);
+    self->Presets = NULL;
+    self->NumPresets = 0;
+}
+
+ALsoundfont *ALsoundfont_getDefSoundfont(ALCcontext *context)
+{
+    ALCdevice *device = context->Device;
+    al_string fname = AL_STRING_INIT_STATIC();
+    const char *namelist;
+
+    if(device->DefaultSfont)
+        return device->DefaultSfont;
+
+    device->DefaultSfont = calloc(1, sizeof(device->DefaultSfont[0]));
+    ALsoundfont_Construct(device->DefaultSfont);
+
+    namelist = getenv("ALSOFT_SOUNDFONT");
+    if(!namelist || !namelist[0])
+        ConfigValueStr("midi", "soundfont", &namelist);
+    while(namelist && namelist[0])
+    {
+        const char *next, *end;
+        FILE *f;
+
+        while(*namelist && (isspace(*namelist) || *namelist == ','))
+            namelist++;
+        if(!*namelist)
+            break;
+        next = strchr(namelist, ',');
+        end = next ? next++ : (namelist+strlen(namelist));
+        while(--end != namelist && isspace(*end)) {
+        }
+        if(end == namelist)
+            continue;
+        al_string_append_range(&fname, namelist, end+1);
+        namelist = next;
+
+        f = OpenDataFile(al_string_get_cstr(fname), "openal/soundfonts");
+        if(f == NULL)
+            ERR("Failed to open %s\n", al_string_get_cstr(fname));
+        else
+        {
+            Reader reader;
+            reader.cb = ALsoundfont_read;
+            reader.ptr = f;
+            reader.error = 0;
+            TRACE("Loading %s\n", al_string_get_cstr(fname));
+            loadSf2(&reader, device->DefaultSfont, context);
+            fclose(f);
+        }
+
+        al_string_clear(&fname);
+    }
+    AL_STRING_DEINIT(fname);
+
+    return device->DefaultSfont;
+}
+
+void ALsoundfont_deleteSoundfont(ALsoundfont *self, ALCdevice *device)
+{
+    ALsfpreset **presets;
+    ALsizei num_presets;
+    VECTOR(ALbuffer*) buffers;
+    ALsizei i;
+
+    VECTOR_INIT(buffers);
+    presets = ExchangePtr((XchgPtr*)&self->Presets, NULL);
+    num_presets = ExchangeInt(&self->NumPresets, 0);
+
+    for(i = 0;i < num_presets;i++)
+    {
+        ALsfpreset *preset = presets[i];
+        ALfontsound **sounds;
+        ALsizei num_sounds;
+        ALboolean deleting;
+        ALsizei j;
+
+        sounds = ExchangePtr((XchgPtr*)&preset->Sounds, NULL);
+        num_sounds = ExchangeInt(&preset->NumSounds, 0);
+
+        DeletePreset(device, preset);
+        preset = NULL;
+
+        for(j = 0;j < num_sounds;j++)
+            DecrementRef(&sounds[j]->ref);
+        /* Some fontsounds may not be immediately deletable because they're
+         * linked to another fontsound. When those fontsounds are deleted
+         * they should become deletable, so use a loop until all fontsounds
+         * are deleted. */
+        do {
+            deleting = AL_FALSE;
+            for(j = 0;j < num_sounds;j++)
+            {
+                if(sounds[j] && ReadRef(&sounds[j]->ref) == 0)
+                {
+                    deleting = AL_TRUE;
+                    if(sounds[j]->Buffer)
+                    {
+                        ALbuffer *buffer = sounds[j]->Buffer;
+                        ALbuffer **iter;
+
+#define MATCH_BUFFER(_i) (buffer == *(_i))
+                        VECTOR_FIND_IF(iter, ALbuffer*, buffers, MATCH_BUFFER);
+                        if(iter == VECTOR_ITER_END(buffers))
+                            VECTOR_PUSH_BACK(buffers, buffer);
+#undef MATCH_BUFFER
+                    }
+                    DeleteFontsound(device, sounds[j]);
+                    sounds[j] = NULL;
+                }
+            }
+        } while(deleting);
+        free(sounds);
+    }
+
+    ALsoundfont_Destruct(self);
+    free(self);
+
+#define DELETE_BUFFER(iter) do {           \
+    assert(ReadRef(&(*(iter))->ref) == 0); \
+    DeleteBuffer(device, *(iter));         \
+} while(0)
+    VECTOR_FOR_EACH(ALbuffer*, buffers, DELETE_BUFFER);
+    VECTOR_DEINIT(buffers);
+#undef DELETE_BUFFER
+}
+
+
+static size_t ALsoundfont_read(ALvoid *buf, size_t bytes, ALvoid *ptr)
+{
+    return fread(buf, 1, bytes, (FILE*)ptr);
+}
+
+
+/* ReleaseALSoundfonts
+ *
+ * Called to destroy any soundfonts that still exist on the device
+ */
+void ReleaseALSoundfonts(ALCdevice *device)
+{
+    ALsizei i;
+    for(i = 0;i < device->SfontMap.size;i++)
+    {
+        ALsoundfont *temp = device->SfontMap.array[i].value;
+        device->SfontMap.array[i].value = NULL;
+
+        ALsoundfont_Destruct(temp);
+
+        memset(temp, 0, sizeof(*temp));
+        free(temp);
+    }
+}
@@ -18,91 +18,72 @@
 * Or go to http://www.gnu.org/copyleft/lgpl.html
 */

+#include "config.h"
+
 #include <stdlib.h>

 #include "alMain.h"
 #include "alThunk.h"

-typedef struct {
-    ALvoid *ptr;
-    ALboolean InUse;
-} ThunkEntry;

-static ThunkEntry *g_ThunkArray;
-static ALuint      g_ThunkArraySize;
+static ALenum *ThunkArray;
+static ALuint  ThunkArraySize;
+static RWLock  ThunkLock;

-static CRITICAL_SECTION g_ThunkLock;
-
-void alThunkInit(void)
+void ThunkInit(void)
 {
-    InitializeCriticalSection(&g_ThunkLock);
-    g_ThunkArraySize = 1;
-    g_ThunkArray = calloc(1, g_ThunkArraySize * sizeof(ThunkEntry));
+    RWLockInit(&ThunkLock);
+    ThunkArraySize = 1;
+    ThunkArray = calloc(1, ThunkArraySize * sizeof(*ThunkArray));
 }

-void alThunkExit(void)
+void ThunkExit(void)
 {
-    free(g_ThunkArray);
-    g_ThunkArray = NULL;
-    g_ThunkArraySize = 0;
-    DeleteCriticalSection(&g_ThunkLock);
+    free(ThunkArray);
+    ThunkArray = NULL;
+    ThunkArraySize = 0;
 }

-ALuint alThunkAddEntry(ALvoid *ptr)
+ALenum NewThunkEntry(ALuint *index)
 {
-    ALuint index;
+    ALenum *NewList;
+    ALuint i;

-    EnterCriticalSection(&g_ThunkLock);
-
-    for(index = 0;index < g_ThunkArraySize;index++)
+    ReadLock(&ThunkLock);
+    for(i = 0;i < ThunkArraySize;i++)
    {
-        if(g_ThunkArray[index].InUse == AL_FALSE)
-            break;
-    }
-
-    if(index == g_ThunkArraySize)
-    {
-        ThunkEntry *NewList;
-
-        NewList = realloc(g_ThunkArray, g_ThunkArraySize*2 * sizeof(ThunkEntry));
-        if(!NewList)
+        if(ExchangeInt(&ThunkArray[i], AL_TRUE) == AL_FALSE)
        {
-            LeaveCriticalSection(&g_ThunkLock);
-            return 0;
+            ReadUnlock(&ThunkLock);
+            *index = i+1;
+            return AL_NO_ERROR;
        }
-        memset(&NewList[g_ThunkArraySize], 0, g_ThunkArraySize*sizeof(ThunkEntry));
-        g_ThunkArraySize *= 2;
-        g_ThunkArray = NewList;
    }
+    ReadUnlock(&ThunkLock);

-    g_ThunkArray[index].ptr = ptr;
-    g_ThunkArray[index].InUse = AL_TRUE;
+    WriteLock(&ThunkLock);
+    NewList = realloc(ThunkArray, ThunkArraySize*2 * sizeof(*ThunkArray));
+    if(!NewList)
+    {
+        WriteUnlock(&ThunkLock);
+        ERR("Realloc failed to increase to %u entries!\n", ThunkArraySize*2);
+        return AL_OUT_OF_MEMORY;
+    }
+    memset(&NewList[ThunkArraySize], 0, ThunkArraySize*sizeof(*ThunkArray));
+    ThunkArraySize *= 2;
+    ThunkArray = NewList;

-    LeaveCriticalSection(&g_ThunkLock);
+    ThunkArray[i] = AL_TRUE;
+    WriteUnlock(&ThunkLock);

-    return index+1;
+    *index = i+1;
+    return AL_NO_ERROR;
 }

-void alThunkRemoveEntry(ALuint index)
+void FreeThunkEntry(ALuint index)
 {
-    EnterCriticalSection(&g_ThunkLock);
-
-    if(index > 0 && index <= g_ThunkArraySize)
-        g_ThunkArray[index-1].InUse = AL_FALSE;
-
-    LeaveCriticalSection(&g_ThunkLock);
-}
-
-ALvoid *alThunkLookupEntry(ALuint index)
-{
-    ALvoid *ptr = NULL;
-
-    EnterCriticalSection(&g_ThunkLock);
-
-    if(index > 0 && index <= g_ThunkArraySize)
-        ptr = g_ThunkArray[index-1].ptr;
-
-    LeaveCriticalSection(&g_ThunkLock);
-
-    return ptr;
+    ReadLock(&ThunkLock);
+    if(index > 0 && index <= ThunkArraySize)
+        ExchangeInt(&ThunkArray[index-1], AL_FALSE);
+    ReadUnlock(&ThunkLock);
 }
@@ -0,0 +1,53 @@
+Source Install
+==============
+
+To install OpenAL Soft, use your favorite shell to go into the build/
+directory, and run:
+
+cmake ..
+
+Assuming configuration went well, you can then build it, typically using GNU
+Make (KDevelop, MSVC, and others are possible depending on your system setup
+and CMake configuration).
+
+Please Note: Double check that the appropriate backends were detected. Often,
+complaints of no sound, crashing, and missing devices can be solved by making
+sure the correct backends are being used. CMake's output will identify which
+backends were enabled.
+
+For most systems, you will likely want to make sure ALSA, OSS, and PulseAudio
+were detected (if your target system uses them). For Windows, make sure
+DirectSound was detected.
+
+
+Utilities
+=========
+
+The source package comes with an informational utility, openal-info, and is
+built by default. It prints out information provided by the ALC and AL sub-
+systems, including discovered devices, version information, and extensions.
+
+
+Configuration
+=============
+
+OpenAL Soft can be configured on a per-user and per-system basis. This allows
+users and sysadmins to control information provided to applications, as well
+as application-agnostic behavior of the library. See alsoftrc.sample for
+available settings.
+
+
+Acknowledgements
+================
+
+Special thanks go to:
+
+Creative Labs for the original source code this is based off of.
+
+Christopher Fitzgerald for the current reverb effect implementation, and
+helping with the low-pass filter.
+
+Christian Borss for the 3D panning code the current implementation is heavilly
+based on.
+
+Ben Davis for the idea behind the current click-removal code.
@@ -0,0 +1,30 @@
+# Cross-compiling requires CMake 2.6 or newer. To use it from build/, call it
+# like this:
+# cmake .. -DCMAKE_TOOLCHAIN_FILE=../XCompile.txt -DHOST=i686-pc-mingw32
+# Where 'i686-pc-mingw32' is the host prefix for your cross-compiler. If you
+# already have a toolchain file setup, you may use that instead of this file.
+
+# the name of the target operating system
+SET(CMAKE_SYSTEM_NAME Windows)
+
+# which compilers to use for C and C++
+SET(CMAKE_C_COMPILER "${HOST}-gcc")
+SET(CMAKE_CXX_COMPILER "${HOST}-g++")
+
+# here is the target environment located
+SET(CMAKE_FIND_ROOT_PATH "/usr/${HOST}")
+
+# here is where stuff gets installed to
+SET(CMAKE_INSTALL_PREFIX "${CMAKE_FIND_ROOT_PATH}/usr" CACHE STRING "Install path prefix, prepended onto install directories." FORCE)
+
+# adjust the default behaviour of the FIND_XXX() commands:
+# search headers and libraries in the target environment, search 
+# programs in the host environment
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+# set env vars so that pkg-config will look in the appropriate directory for
+# .pc files (as there seems to be no way to force using ${HOST}-pkg-config)
+set(ENV{PKG_CONFIG_LIBDIR} "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig")
+set(ENV{PKG_CONFIG_PATH} "")
@@ -0,0 +1,382 @@
+# OpenAL config file.
+#
+# Option blocks may appear multiple times, and duplicated options will take the
+# last value specified. Environment variables may be specified within option
+# values, and are automatically substituted when the config file is loaded.
+# Environment variable names may only contain alpha-numeric characters (a-z,
+# A-Z, 0-9) and underscores (_), and are prefixed with $. For example,
+# specifying "$HOME/file.ext" would typically result in something like
+# "/home/user/file.ext". To specify an actual "$" character, use "$$".
+#
+# The system-wide settings can be put in /etc/openal/alsoft.conf and user-
+# specific override settings in $HOME/.alsoftrc.
+# For Windows, these settings should go into $AppData\alsoft.ini
+#
+# Option and block names are case-insenstive. The supplied values are only
+# hints and may not be honored (though generally it'll try to get as close as
+# possible). Note: options that are left unset may default to app- or system-
+# specified values. These are the current available settings:
+
+##
+## General stuff
+##
+[general]
+
+## disable-cpu-exts:
+#  Disables use of specialized methods that use specific CPU intrinsics.
+#  Certain methods may utilize CPU extensions for improved performance, and
+#  this option is useful for preventing some or all of those methods from being
+#  used. The available extensions are: sse, sse2, sse4.1, and neon. Specifying
+#  'all' disables use of all such specialized methods.
+#disable-cpu-exts =
+
+## channels:
+#  Sets the output channel configuration. If left unspecified, one will try to
+#  be detected from the system, and defaulting to stereo. The available values
+#  are: mono, stereo, quad, surround51, surround61, surround71
+#channels =
+
+## sample-type:
+#  Sets the output sample type. Currently, all mixing is done with 32-bit float
+#  and converted to the output sample type as needed. Available values are:
+#  int8    - signed 8-bit int
+#  uint8   - unsigned 8-bit int
+#  int16   - signed 16-bit int
+#  uint16  - unsigned 16-bit int
+#  int32   - signed 32-bit int
+#  uint32  - unsigned 32-bit int
+#  float32 - 32-bit float
+#sample-type = float32
+
+## hrtf:
+#  Enables HRTF filters. These filters provide for better sound spatialization
+#  while using headphones. The default filter will only work when output is
+#  44100hz stereo. While HRTF is active, the cf_level option is disabled.
+#  Default is disabled since stereo speaker output quality may suffer.
+#hrtf = false
+
+## hrtf_tables
+#  Specifies a comma-separated list of files containing HRTF data sets. The
+#  format of the files are described in hrtf.txt. The filenames may contain
+#  these markers, which will be replaced as needed:
+#  %r - Device sampling rate
+#  %% - Percent sign (%)
+#  The listed files are relative to system-dependant data directories. On
+#  Windows this is:
+#  $AppData\openal\hrtf
+#  And on other systems, it's (in order):
+#  $XDG_DATA_HOME/openal/hrtf  (defaults to $HOME/.local/share/openal/hrtf)
+#  $XDG_DATA_DIRS/openal/hrtf  (defaults to /usr/local/share/openal/hrtf and
+#                               /usr/share/openal/hrtf)
+#  An absolute path may also be specified, if the given file is elsewhere.
+#hrtf_tables = default-%r.mhr
+
+## cf_level:
+#  Sets the crossfeed level for stereo output. Valid values are:
+#  0 - No crossfeed
+#  1 - Low crossfeed
+#  2 - Middle crossfeed
+#  3 - High crossfeed (virtual speakers are closer to itself)
+#  4 - Low easy crossfeed
+#  5 - Middle easy crossfeed
+#  6 - High easy crossfeed
+#  Users of headphones may want to try various settings. Has no effect on non-
+#  stereo modes.
+#cf_level = 0
+
+## wide-stereo:
+#  Specifies that stereo sources are given a width of about 120 degrees on each
+#  channel, centering on -90 (left) and +90 (right), as opposed to being points
+#  placed at -30 (left) and +30 (right). This can be useful for surround-sound
+#  to give stereo sources a more encompassing sound. Note that the sound's
+#  overall volume will be slightly reduced to account for the extra output.
+#wide-stereo = false
+
+## frequency:
+#  Sets the output frequency. If left unspecified it will try to detect a
+#  default from the system, otherwise it will default to 44100.
+#frequency =
+
+## resampler:
+#  Selects the resampler used when mixing sources. Valid values are:
+#  point - nearest sample, no interpolation
+#  linear - extrapolates samples using a linear slope between samples
+#  cubic - extrapolates samples using a Catmull-Rom spline
+#  Specifying other values will result in using the default (linear).
+#resampler = linear
+
+## rt-prio:
+#  Sets real-time priority for the mixing thread. Not all drivers may use this
+#  (eg. PortAudio) as they already control the priority of the mixing thread.
+#  0 and negative values will disable it. Note that this may constitute a
+#  security risk since a real-time priority thread can indefinitely block
+#  normal-priority threads if it fails to wait. As such, the default is
+#  disabled.
+#rt-prio = 0
+
+## period_size:
+#  Sets the update period size, in frames. This is the number of frames needed
+#  for each mixing update. Acceptable values range between 64 and 8192.
+#period_size = 1024
+
+## periods:
+#  Sets the number of update periods. Higher values create a larger mix ahead,
+#  which helps protect against skips when the CPU is under load, but increases
+#  the delay between a sound getting mixed and being heard. Acceptable values
+#  range between 2 and 16.
+#periods = 4
+
+## sources:
+#  Sets the maximum number of allocatable sources. Lower values may help for
+#  systems with apps that try to play more sounds than the CPU can handle.
+#sources = 256
+
+## drivers:
+#  Sets the backend driver list order, comma-seperated. Unknown backends and
+#  duplicated names are ignored. Unlisted backends won't be considered for use
+#  unless the list is ended with a comma (e.g. 'oss,' will try OSS first before
+#  other backends, while 'oss' will try OSS only). Backends prepended with -
+#  won't be considered for use (e.g. '-oss,' will try all available backends
+#  except OSS). An empty list means to try all backends.
+#drivers =
+
+## excludefx:
+#  Sets which effects to exclude, preventing apps from using them. This can
+#  help for apps that try to use effects which are too CPU intensive for the
+#  system to handle. Available effects are: eaxreverb,reverb,autowah,chorus,
+#  compressor,distortion,echo,equalizer,flanger,modulator,dedicated
+#excludefx =
+
+## slots:
+#  Sets the maximum number of Auxiliary Effect Slots an app can create. A slot
+#  can use a non-negligible amount of CPU time if an effect is set on it even
+#  if no sources are feeding it, so this may help when apps use more than the
+#  system can handle.
+#slots = 4
+
+## sends:
+#  Sets the number of auxiliary sends per source. When not specified (default),
+#  it allows the app to request how many it wants. The maximum value currently
+#  possible is 4.
+#sends =
+
+## layout:
+#  Sets the virtual speaker layout. Values are specified in degrees, where 0 is
+#  straight in front, negative goes left, and positive goes right. Unspecified
+#  speakers will remain at their default positions (which are dependant on the
+#  output format). Available speakers are back-left(bl), side-left(sl), front-
+#  left(fl), front-center(fc), front-right(fr), side-right(sr), back-right(br),
+#  and back-center(bc).
+#layout =
+
+## layout_*:
+#  Channel-specific layouts may be specified to override the layout option. The
+#  same speakers as the layout option are available, and the default settings
+#  are shown below.
+#layout_stereo     = fl=-90, fr=90
+#layout_quad       = fl=-45, fr=45, bl=-135, br=135
+#layout_surround51 = fl=-30, fr=30, fc=0, bl=-110, br=110
+#layout_surround61 = fl=-30, fr=30, fc=0, sl=-90, sr=90, bc=180
+#layout_surround71 = fl=-30, fr=30, fc=0, sl=-90, sr=90, bl=-150, br=150
+
+## default-reverb:
+#  A reverb preset that applies by default to all sources on send 0
+#  (applications that set their own slots on send 0 will override this).
+#  Available presets are: None, Generic, PaddedCell, Room, Bathroom,
+#  Livingroom, Stoneroom, Auditorium, ConcertHall, Cave, Arena, Hangar,
+#  CarpetedHallway, Hallway, StoneCorridor, Alley, Forest, City, Moutains,
+#  Quarry, Plain, ParkingLot, SewerPipe, Underwater, Drugged, Dizzy, Psychotic.
+#default-reverb =
+
+## trap-alc-error:
+#  Generates a SIGTRAP signal when an ALC device error is generated, on systems
+#  that support it. This helps when debugging, while trying to find the cause
+#  of a device error. On Windows, a breakpoint exception is generated.
+#trap-alc-error = false
+
+## trap-al-error:
+#  Generates a SIGTRAP signal when an AL context error is generated, on systems
+#  that support it. This helps when debugging, while trying to find the cause
+#  of a context error. On Windows, a breakpoint exception is generated.
+#trap-al-error = false
+
+##
+## MIDI stuff (EXPERIMENTAL)
+##
+[midi]
+
+## soundfont:
+#  A default soundfont (sf2 format). Used when an app requests the system
+#  default. The listed file is relative to system-dependant data directories.
+#  On Windows this is:
+#  $AppData\openal\soundfonts
+#  And on other systems, it's (in order):
+#  $XDG_DATA_HOME/openal/soundfonts
+#  $XDG_DATA_DIRS/openal/soundfonts
+#  An absolute path may also be specified, if the given file is elsewhere.
+#soundfont =
+
+## volume:
+#  Additional attenuation applied to MIDI output, expressed in decibels. This
+#  is used to help keep the mix from clipping, and so must be 0 or less. The
+#  value is logarithmic, so -6 will be about half amplitude, and -12 about
+#  1/4th. The default is roughly -13.9794 (0.2, or 1/5th).
+#volume =
+
+##
+## Reverb effect stuff (includes EAX reverb)
+##
+[reverb]
+
+## boost:
+#  A global amplification for reverb output, expressed in decibels. The value
+#  is logarithmic, so +6 will be a scale of (approximately) 2x, +12 will be a
+#  scale of 4x, etc. Similarly, -6 will be about half, and -12 about 1/4th. A
+#  value of 0 means no change.
+#boost = 0
+
+## emulate-eax:
+#  Allows the standard reverb effect to be used in place of EAX reverb. EAX
+#  reverb processing is a bit more CPU intensive than standard, so this option
+#  allows a simpler effect to be used at the loss of some quality.
+#emulate-eax = false
+
+##
+## PulseAudio backend stuff
+##
+[pulse]
+
+## spawn-server:
+#  Attempts to autospawn a PulseAudio server whenever needed (initializing the
+#  backend, enumerating devices, etc). Setting autospawn to false in Pulse's
+#  client.conf will still prevent autospawning even if this is set to true.
+#spawn-server = true
+
+## allow-moves:
+#  Allows PulseAudio to move active streams to different devices. Note that the
+#  device specifier (seen by applications) will not be updated when this
+#  occurs, and neither will the AL device configuration (sample rate, format,
+#  etc).
+#allow-moves = false
+
+##
+## ALSA backend stuff
+##
+[alsa]
+
+## device:
+#  Sets the device name for the default playback device.
+#device = default
+
+## device-prefix:
+#  Sets the prefix used by the discovered (non-default) playback devices. This
+#  will be appended with "CARD=c,DEV=d", where c is the card id and d is the
+#  device index for the requested device name.
+#device-prefix = plughw:
+
+## device-prefix-*:
+#  Card- and device-specific prefixes may be used to override the device-prefix
+#  option. The option may specify the card id (eg, device-prefix-NVidia), or
+#  the card id and device index (eg, device-prefix-NVidia-0). The card id is
+#  case-sensitive.
+#device-prefix- =
+
+## capture:
+#  Sets the device name for the default capture device.
+#capture = default
+
+## capture-prefix:
+#  Sets the prefix used by the discovered (non-default) capture devices. This
+#  will be appended with "CARD=c,DEV=d", where c is the card id and d is the
+#  device number for the requested device name.
+#capture-prefix = plughw:
+
+## capture-prefix-*:
+#  Card- and device-specific prefixes may be used to override the
+#  capture-prefix option. The option may specify the card id (eg,
+#  capture-prefix-NVidia), or the card id and device index (eg,
+#  capture-prefix-NVidia-0). The card id is case-sensitive.
+#capture-prefix- =
+
+## mmap:
+#  Sets whether to try using mmap mode (helps reduce latencies and CPU
+#  consumption). If mmap isn't available, it will automatically fall back to
+#  non-mmap mode. True, yes, on, and non-0 values will attempt to use mmap. 0
+#  and anything else will force mmap off.
+#mmap = true
+
+##
+## OSS backend stuff
+##
+[oss]
+
+## device:
+#  Sets the device name for OSS output.
+#device = /dev/dsp
+
+## capture:
+#  Sets the device name for OSS capture.
+#capture = /dev/dsp
+
+##
+## Solaris backend stuff
+##
+[solaris]
+
+## device:
+#  Sets the device name for Solaris output.
+#device = /dev/audio
+
+##
+## QSA backend stuff
+##
+[qsa]
+
+## device:
+#  Sets the device name for the default playback device.
+#device = default
+
+## capture:
+#  Sets the device name for the default capture device.
+#capture = default
+
+##
+## MMDevApi backend stuff
+##
+[mmdevapi]
+
+##
+## DirectSound backend stuff
+##
+[dsound]
+
+##
+## Windows Multimedia backend stuff
+##
+[winmm]
+
+##
+## PortAudio backend stuff
+##
+[port]
+
+## device:
+#  Sets the device index for output. Negative values will use the default as
+#  given by PortAudio itself.
+#device = -1
+
+## capture:
+#  Sets the device index for capture. Negative values will use the default as
+#  given by PortAudio itself.
+#capture = -1
+
+##
+## Wave File Writer stuff
+##
+[wave]
+
+## file:
+#  Sets the filename of the wave file to write to. An empty name prevents the
+#  backend from opening, even when explicitly requested.
+#  THIS WILL OVERWRITE EXISTING FILES WITHOUT QUESTION!
+#file =
@@ -0,0 +1,9 @@
+#include <sys/types.h>
+
+#define KB ((off_t)(1024))
+#define MB ((off_t)(KB*1024))
+#define GB ((off_t)(MB*1024))
+int tb[((GB+GB+GB) > GB) ? 1 : -1];
+
+int main()
+{ return 0; }
@@ -0,0 +1,39 @@
+# - Check if the _FILE_OFFSET_BITS macro is needed for large files
+# CHECK_FILE_OFFSET_BITS()
+#
+# The following variables may be set before calling this macro to
+# modify the way the check is run:
+#
+#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
+#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
+#  CMAKE_REQUIRED_INCLUDES = list of include directories
+# Copyright (c) 2009, Chris Robinson
+#
+# Redistribution and use is allowed according to the terms of the LGPL license.
+
+
+MACRO(CHECK_FILE_OFFSET_BITS)
+
+  IF(NOT DEFINED _FILE_OFFSET_BITS)
+    MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files")
+    TRY_COMPILE(__WITHOUT_FILE_OFFSET_BITS_64
+      ${CMAKE_BINARY_DIR}
+      ${CMAKE_SOURCE_DIR}/cmake/CheckFileOffsetBits.c
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS})
+    IF(NOT __WITHOUT_FILE_OFFSET_BITS_64)
+      TRY_COMPILE(__WITH_FILE_OFFSET_BITS_64
+        ${CMAKE_BINARY_DIR}
+        ${CMAKE_SOURCE_DIR}/cmake/CheckFileOffsetBits.c
+        COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -D_FILE_OFFSET_BITS=64)
+    ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64)
+
+    IF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64)
+      SET(_FILE_OFFSET_BITS 64 CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files")
+      MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files - 64")
+    ELSE(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64)
+      SET(_FILE_OFFSET_BITS "" CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files")
+      MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files - not needed")
+    ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64)
+  ENDIF(NOT DEFINED _FILE_OFFSET_BITS)
+
+ENDMACRO(CHECK_FILE_OFFSET_BITS)
@@ -0,0 +1,92 @@
+# - Check if a symbol exists as a function, variable, or macro
+# CHECK_SYMBOL_EXISTS(<symbol> <files> <variable>)
+#
+# Check that the <symbol> is available after including given header
+# <files> and store the result in a <variable>.  Specify the list
+# of files in one argument as a semicolon-separated list.
+#
+# If the header files define the symbol as a macro it is considered
+# available and assumed to work.  If the header files declare the
+# symbol as a function or variable then the symbol must also be
+# available for linking.  If the symbol is a type or enum value
+# it will not be recognized (consider using CheckTypeSize or
+# CheckCSourceCompiles).
+#
+# The following variables may be set before calling this macro to
+# modify the way the check is run:
+#
+#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
+#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
+#  CMAKE_REQUIRED_INCLUDES = list of include directories
+#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link
+
+#=============================================================================
+# Copyright 2003-2011 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+MACRO(CHECK_SHARED_FUNCTION_EXISTS SYMBOL FILES LIBRARY LOCATION VARIABLE)
+  IF("${VARIABLE}" MATCHES "^${VARIABLE}$")
+    SET(CMAKE_CONFIGURABLE_FILE_CONTENT "/* */\n")
+    SET(MACRO_CHECK_SYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS})
+    IF(CMAKE_REQUIRED_LIBRARIES)
+      SET(CHECK_SYMBOL_EXISTS_LIBS 
+        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES};${LIBRARY}")
+    ELSE(CMAKE_REQUIRED_LIBRARIES)
+      SET(CHECK_SYMBOL_EXISTS_LIBS
+        "-DLINK_LIBRARIES:STRING=${LIBRARY}")
+    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+    IF(CMAKE_REQUIRED_INCLUDES)
+      SET(CMAKE_SYMBOL_EXISTS_INCLUDES
+        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
+    ELSE(CMAKE_REQUIRED_INCLUDES)
+      SET(CMAKE_SYMBOL_EXISTS_INCLUDES)
+    ENDIF(CMAKE_REQUIRED_INCLUDES)
+    FOREACH(FILE ${FILES})
+      SET(CMAKE_CONFIGURABLE_FILE_CONTENT
+        "${CMAKE_CONFIGURABLE_FILE_CONTENT}#include <${FILE}>\n")
+    ENDFOREACH(FILE)
+    SET(CMAKE_CONFIGURABLE_FILE_CONTENT
+      "${CMAKE_CONFIGURABLE_FILE_CONTENT}\nvoid cmakeRequireSymbol(int dummy,...){(void)dummy;}\nint main()\n{\n  cmakeRequireSymbol(0,&${SYMBOL});\n  return 0;\n}\n")
+
+    CONFIGURE_FILE("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
+      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c" @ONLY)
+
+    MESSAGE(STATUS "Looking for ${SYMBOL} in ${LIBRARY}")
+    TRY_COMPILE(${VARIABLE}
+      ${CMAKE_BINARY_DIR}
+      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
+      CMAKE_FLAGS 
+      -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_SYMBOL_EXISTS_FLAGS}
+      -DLINK_DIRECTORIES:STRING=${LOCATION}
+      "${CHECK_SYMBOL_EXISTS_LIBS}"
+      "${CMAKE_SYMBOL_EXISTS_INCLUDES}"
+      OUTPUT_VARIABLE OUTPUT)
+    IF(${VARIABLE})
+      MESSAGE(STATUS "Looking for ${SYMBOL} in ${LIBRARY} - found")
+      SET(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL} in ${LIBRARY}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+        "Determining if the ${SYMBOL} "
+        "exist in ${LIBRARY} passed with the following output:\n"
+        "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c:\n"
+        "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n")
+    ELSE(${VARIABLE})
+      MESSAGE(STATUS "Looking for ${SYMBOL} in ${LIBRARY} - not found.")
+      SET(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL} in ${LIBRARY}")
+      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 
+        "Determining if the ${SYMBOL} "
+        "exist in ${LIBRARY} failed with the following output:\n"
+        "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckSymbolExists.c:\n"
+        "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n")
+    ENDIF(${VARIABLE})
+  ENDIF("${VARIABLE}" MATCHES "^${VARIABLE}$")
+ENDMACRO(CHECK_SHARED_FUNCTION_EXISTS)
--- a/Show More
+++ b/Show More