Added OpenAL-Soft 1.16.0.

libs/openal-soft/Alc/alcConfig.c

@@ -0,0 +1,515 @@
+/**
+ * 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
+ */
+
+#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;
+    char *value;
+} ConfigEntry;
+
+typedef struct ConfigBlock {
+    ConfigEntry *entries;
+    unsigned int entryCount;
+} ConfigBlock;
+static ConfigBlock cfgBlock;
+
+
+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)
+{
+    char curSection[128] = "";
+    char *buffer = NULL;
+    size_t maxlen = 0;
+    ConfigEntry *ent;
+
+    while(readline(f, &buffer, &maxlen))
+    {
+        char *line, *comment;
+        char key[256] = "";
+        char value[256] = "";
+
+        comment = strchr(buffer, '#');
+        if(comment) *(comment++) = 0;
+
+        line = rstrip(lstrip(buffer));
+        if(!line[0])
+            continue;
+
+        if(line[0] == '[')
+        {
+            char *section = line+1;
+            char *endsection;
+
+            endsection = strchr(section, ']');
+            if(!endsection || section == endsection || endsection[1] != 0)
+            {
+                 ERR("config parse error: bad line \"%s\"\n", line);
+                 continue;
+            }
+            *endsection = 0;
+
+            if(strcasecmp(section, "general") == 0)
+                curSection[0] = 0;
+            else
+            {
+                strncpy(curSection, section, sizeof(curSection)-1);
+                curSection[sizeof(curSection)-1] = 0;
+            }
+
+            continue;
+        }
+
+        if(sscanf(line, "%255[^=] = \"%255[^\"]\"", key, value) == 2 ||
+           sscanf(line, "%255[^=] = '%255[^\']'", key, value) == 2 ||
+           sscanf(line, "%255[^=] = %255[^\n]", key, value) == 2)
+        {
+            /* 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);
+
+        if(curSection[0] != 0)
+        {
+            size_t len = strlen(curSection);
+            memmove(&key[len+1], key, sizeof(key)-1-len);
+            key[len] = '/';
+            memcpy(key, curSection, len);
+        }
+
+        /* Check if we already have this option set */
+        ent = cfgBlock.entries;
+        while((unsigned int)(ent-cfgBlock.entries) < cfgBlock.entryCount)
+        {
+            if(strcasecmp(ent->key, key) == 0)
+                break;
+            ent++;
+        }
+
+        if((unsigned int)(ent-cfgBlock.entries) >= cfgBlock.entryCount)
+        {
+            /* Allocate a new option entry */
+            ent = realloc(cfgBlock.entries, (cfgBlock.entryCount+1)*sizeof(ConfigEntry));
+            if(!ent)
+            {
+                 ERR("config parse error: error reallocating config entries\n");
+                 continue;
+            }
+            cfgBlock.entries = ent;
+            ent = cfgBlock.entries + cfgBlock.entryCount;
+            cfgBlock.entryCount++;
+
+            ent->key = strdup(key);
+            ent->value = NULL;
+        }
+
+        free(ent->value);
+        ent->value = expdup(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;
+
+    if(SHGetSpecialFolderPathW(NULL, buffer, CSIDL_APPDATA, FALSE) != FALSE)
+    {
+        size_t p = lstrlenW(buffer);
+        _snwprintf(buffer+p, PATH_MAX-p, L"\\alsoft.ini");
+
+        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);
+        }
+    }
+}
+#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)
+{
+    unsigned int i;
+
+    for(i = 0;i < cfgBlock.entryCount;i++)
+    {
+        free(cfgBlock.entries[i].key);
+        free(cfgBlock.entries[i].value);
+    }
+    free(cfgBlock.entries);
+}
+
+const char *GetConfigValue(const char *blockName, const char *keyName, const char *def)
+{
+    unsigned int i;
+    char key[256];
+
+    if(!keyName)
+        return def;
+
+    if(blockName && strcasecmp(blockName, "general") != 0)
+        snprintf(key, sizeof(key), "%s/%s", blockName, keyName);
+    else
+    {
+        strncpy(key, keyName, sizeof(key)-1);
+        key[sizeof(key)-1] = 0;
+    }
+
+    for(i = 0;i < cfgBlock.entryCount;i++)
+    {
+        if(strcasecmp(cfgBlock.entries[i].key, key) == 0)
+        {
+            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 ConfigValueExists(const char *blockName, const char *keyName)
+{
+    const char *val = GetConfigValue(blockName, keyName, "");
+    return !!val[0];
+}
+
+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;
+
+#ifdef HAVE_STRTOF
+    *ret = strtof(val, NULL);
+#else
+    *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);
+}

libs/openal-soft/Alc/alcRing.c

@@ -0,0 +1,129 @@
+/**
+ * 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 <string.h>
+#include <stdlib.h>
+
+#include "alMain.h"
+#include "threads.h"
+#include "compat.h"
+
+
+struct RingBuffer {
+    ALubyte *mem;
+
+    ALsizei frame_size;
+    ALsizei length;
+    ALint read_pos;
+    ALint write_pos;
+
+    almtx_t mtx;
+};
+
+
+RingBuffer *CreateRingBuffer(ALsizei frame_size, ALsizei length)
+{
+    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->read_pos = 0;
+        ring->write_pos = 0;
+
+        almtx_init(&ring->mtx, almtx_plain);
+    }
+    return ring;
+}
+
+void DestroyRingBuffer(RingBuffer *ring)
+{
+    if(ring)
+    {
+        almtx_destroy(&ring->mtx);
+        free(ring);
+    }
+}
+
+ALsizei RingBufferSize(RingBuffer *ring)
+{
+    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;
+
+    almtx_lock(&ring->mtx);
+
+    remain = (ring->read_pos-ring->write_pos-1+ring->length) % ring->length;
+    if(remain < len) len = remain;
+
+    if(len > 0)
+    {
+        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;
+    }
+
+    almtx_unlock(&ring->mtx);
+}
+
+void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len)
+{
+    int remain;
+
+    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);
+        memcpy(data+(remain*ring->frame_size), ring->mem, (len-remain)*ring->frame_size);
+    }
+    else
+        memcpy(data, ring->mem+(ring->read_pos*ring->frame_size), len*ring->frame_size);
+
+    ring->read_pos += len;
+    ring->read_pos %= ring->length;
+
+    almtx_unlock(&ring->mtx);
+}

libs/openal-soft/Alc/alstring.h

@@ -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 */

libs/openal-soft/Alc/backends/base.c

@@ -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;
+}

libs/openal-soft/Alc/backends/base.h

@@ -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 */

libs/openal-soft/Alc/backends/coreaudio.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/backends/loopback.c

@@ -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;
+}

libs/openal-soft/Alc/backends/null.c

@@ -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;
+}

libs/openal-soft/Alc/backends/opensl.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/backends/oss.c

@@ -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;
+}

libs/openal-soft/Alc/backends/portaudio.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/backends/sndio.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/backends/solaris.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/backends/wave.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/backends/winmm.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/bs2b.c

@@ -0,0 +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 "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);

libs/openal-soft/Alc/compat.h

@@ -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 */

libs/openal-soft/Alc/effects/autowah.c

@@ -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);

libs/openal-soft/Alc/effects/chorus.c

@@ -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);

libs/openal-soft/Alc/effects/compressor.c

@@ -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);

libs/openal-soft/Alc/effects/dedicated.c

@@ -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);

libs/openal-soft/Alc/effects/distortion.c

@@ -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);

libs/openal-soft/Alc/effects/echo.c

@@ -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);

libs/openal-soft/Alc/effects/equalizer.c

@@ -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);

libs/openal-soft/Alc/effects/flanger.c

@@ -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);

libs/openal-soft/Alc/effects/modulator.c

@@ -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);

libs/openal-soft/Alc/effects/null.c

@@ -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);

libs/openal-soft/Alc/evtqueue.h

@@ -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 */

libs/openal-soft/Alc/helpers.c

@@ -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

libs/openal-soft/Alc/hrtf.c

@@ -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;
+}

libs/openal-soft/Alc/hrtf.h

@@ -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 */

libs/openal-soft/Alc/midi/base.c

@@ -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;
+}

libs/openal-soft/Alc/midi/base.h

@@ -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 */

libs/openal-soft/Alc/midi/dummy.c

@@ -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);
+}

libs/openal-soft/Alc/midi/fluidsynth.c

@@ -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

libs/openal-soft/Alc/midi/soft.c

@@ -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);
+}

libs/openal-soft/Alc/mixer.c

@@ -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;
+}

libs/openal-soft/Alc/mixer_c.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/mixer_defs.h

@@ -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 */

libs/openal-soft/Alc/mixer_inc.c

@@ -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

libs/openal-soft/Alc/mixer_neon.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/mixer_sse.c

@@ -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;
+    }
+}

libs/openal-soft/Alc/mixer_sse2.c

@@ -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;
+}

libs/openal-soft/Alc/mixer_sse41.c

@@ -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;
+}

libs/openal-soft/Alc/panning.c

@@ -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);
+}

libs/openal-soft/Alc/vector.h

@@ -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 */