Release 1.8.466

MSVC won't accept zero-sized arrays at the end of structs, if that struct is
used in another struct that's not also at the end. This wastes a float for each
FILTER object

Alc/ALc.c

@@ -18,8 +18,6 @@
  * Or go to http://www.gnu.org/copyleft/lgpl.html
  */
 
-#define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
-
 #include "config.h"
 
 #include <math.h>
@@ -33,16 +31,11 @@
 #include "AL/alc.h"
 #include "alThunk.h"
 #include "alSource.h"
+#include "alBuffer.h"
 #include "alExtension.h"
 #include "alAuxEffectSlot.h"
 #include "bs2b.h"
-
-///////////////////////////////////////////////////////
-// DEBUG INFORMATION
-
-char _alDebug[256];
-
-///////////////////////////////////////////////////////
+#include "alu.h"
 
 
 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
@@ -57,12 +50,21 @@ static struct {
 #ifdef HAVE_OSS
     { "oss", alc_oss_init, EmptyFuncs },
 #endif
+#ifdef HAVE_SOLARIS
+    { "solaris", alc_solaris_init, EmptyFuncs },
+#endif
 #ifdef HAVE_DSOUND
     { "dsound", alcDSoundInit, EmptyFuncs },
 #endif
 #ifdef HAVE_WINMM
     { "winmm", alcWinMMInit, EmptyFuncs },
 #endif
+#ifdef HAVE_PORTAUDIO
+    { "port", alc_pa_init, EmptyFuncs },
+#endif
+#ifdef HAVE_PULSEAUDIO
+    { "pulse", alc_pulse_init, EmptyFuncs },
+#endif
 
     { "wave", alc_wave_init, EmptyFuncs },
 
@@ -182,6 +184,8 @@ static ALCint alcEFXMinorVersion = 0;
 static ALCdevice *g_pDeviceList = NULL;
 static ALCuint    g_ulDeviceCount = 0;
 
+static CRITICAL_SECTION g_csMutex;
+
 // Context List
 static ALCcontext *g_pContextList = NULL;
 static ALCuint     g_ulContextCount = 0;
@@ -189,23 +193,69 @@ static ALCuint     g_ulContextCount = 0;
 // Context Error
 static ALCenum g_eLastContextError = ALC_NO_ERROR;
 
+static ALboolean init_done = AL_FALSE;
+
 ///////////////////////////////////////////////////////
 
 
 ///////////////////////////////////////////////////////
 // ALC Related helper functions
+#ifdef _WIN32
+BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
+{
+    (void)lpReserved;
+
+    // Perform actions based on the reason for calling.
+    switch(ul_reason_for_call)
+    {
+        case DLL_PROCESS_ATTACH:
+            DisableThreadLibraryCalls(hModule);
+            break;
+
+        case DLL_PROCESS_DETACH:
+            if(!init_done)
+                break;
+            ReleaseALC();
+            ReleaseALBuffers();
+            ReleaseALEffects();
+            ReleaseALFilters();
+            FreeALConfig();
+            ALTHUNK_EXIT();
+            DeleteCriticalSection(&g_csMutex);
+            break;
+    }
+    return TRUE;
+}
+#else
+#ifdef HAVE_GCC_DESTRUCTOR
+static void my_deinit() __attribute__((destructor));
+static void my_deinit()
+{
+    static ALenum once = AL_FALSE;
+    if(once || !init_done) return;
+    once = AL_TRUE;
+
+    ReleaseALC();
+    ReleaseALBuffers();
+    ReleaseALEffects();
+    ReleaseALFilters();
+    FreeALConfig();
+    ALTHUNK_EXIT();
+    DeleteCriticalSection(&g_csMutex);
+}
+#endif
+#endif
 
 static void InitAL(void)
 {
-    static int done = 0;
-    if(!done)
+    if(!init_done)
     {
         int i;
         const char *devs, *str;
 
-        done = 1;
+        init_done = AL_TRUE;
 
-        InitializeCriticalSection(&_alMutex);
+        InitializeCriticalSection(&g_csMutex);
         ALTHUNK_INIT();
         ReadALConfig();
 
@@ -257,6 +307,39 @@ static void InitAL(void)
                            strcasecmp(str, "yes") == 0 ||
                            strcasecmp(str, "on") == 0 ||
                            atoi(str) != 0);
+
+        str = GetConfigValue(NULL, "excludefx", "");
+        if(str[0])
+        {
+            const struct {
+                const char *name;
+                int type;
+            } EffectList[] = {
+                { "eaxreverb", EAXREVERB },
+                { "reverb", REVERB },
+                { "echo", ECHO },
+                { NULL, 0 }
+            };
+            int n;
+            size_t len;
+            const char *next = str;
+
+            do {
+                str = next;
+                next = strchr(str, ',');
+
+                if(!str[0] || next == str)
+                    continue;
+
+                len = (next ? ((size_t)(next-str)) : strlen(str));
+                for(n = 0;EffectList[n].name;n++)
+                {
+                    if(len == strlen(EffectList[n].name) &&
+                       strncmp(EffectList[n].name, str, len) == 0)
+                        DisabledEffects[EffectList[n].type] = AL_TRUE;
+                }
+            } while(next++);
+        }
     }
 }
 
@@ -335,7 +418,7 @@ ALCvoid SetALCError(ALenum errorCode)
 ALCvoid SuspendContext(ALCcontext *pContext)
 {
     (void)pContext;
-    EnterCriticalSection(&_alMutex);
+    EnterCriticalSection(&g_csMutex);
 }
 
 
@@ -347,7 +430,7 @@ ALCvoid SuspendContext(ALCcontext *pContext)
 ALCvoid ProcessContext(ALCcontext *pContext)
 {
     (void)pContext;
-    LeaveCriticalSection(&_alMutex);
+    LeaveCriticalSection(&g_csMutex);
 }
 
 
@@ -392,7 +475,11 @@ static ALvoid InitContext(ALCcontext *pContext)
     pContext->lNumStereoSources = 1;
     pContext->lNumMonoSources = pContext->Device->MaxNoOfSources - pContext->lNumStereoSources;
 
-    strcpy(pContext->ExtensionList, "AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_OFFSET AL_LOKI_quadriphonic");
+    pContext->NumSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);
+    if(pContext->NumSends > MAX_SENDS)
+        pContext->NumSends = MAX_SENDS;
+
+    pContext->ExtensionList = "AL_EXTX_buffer_sub_data AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_OFFSET AL_EXTX_source_distance_model AL_LOKI_quadriphonic";
 
     level = GetConfigValueInt(NULL, "cf_level", 0);
     if(level > 0 && level <= 6)
@@ -401,6 +488,8 @@ static ALvoid InitContext(ALCcontext *pContext)
         bs2b_set_srate(pContext->bs2b, pContext->Frequency);
         bs2b_set_level(pContext->bs2b, level);
     }
+
+    aluInitPanning(pContext);
 }
 
 
@@ -435,44 +524,46 @@ ALCAPI ALCdevice* ALCAPIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, AL
 
     InitAL();
 
+    if(SampleSize <= 0)
+    {
+        SetALCError(ALC_INVALID_VALUE);
+        return NULL;
+    }
+
     if(deviceName && !deviceName[0])
         deviceName = NULL;
 
     pDevice = malloc(sizeof(ALCdevice));
     if (pDevice)
     {
-        if (SampleSize > 0)
+        //Initialise device structure
+        memset(pDevice, 0, sizeof(ALCdevice));
+
+        //Validate device
+        pDevice->IsCaptureDevice = AL_TRUE;
+
+        pDevice->Frequency = frequency;
+        pDevice->Format = format;
+
+        for(i = 0;BackendList[i].Init;i++)
         {
-            //Initialise device structure
-            memset(pDevice, 0, sizeof(ALCdevice));
-
-            //Validate device
-            pDevice->IsCaptureDevice = AL_TRUE;
-
-            pDevice->Frequency = frequency;
-            pDevice->Format = format;
-
-            for(i = 0;BackendList[i].Init;i++)
+            pDevice->Funcs = &BackendList[i].Funcs;
+            if(ALCdevice_OpenCapture(pDevice, deviceName, frequency, format, SampleSize))
             {
-                pDevice->Funcs = &BackendList[i].Funcs;
-                if(ALCdevice_OpenCapture(pDevice, deviceName, frequency, format, SampleSize))
-                {
-                    SuspendContext(NULL);
-                    pDevice->next = g_pDeviceList;
-                    g_pDeviceList = pDevice;
-                    g_ulDeviceCount++;
-                    ProcessContext(NULL);
+                SuspendContext(NULL);
+                pDevice->next = g_pDeviceList;
+                g_pDeviceList = pDevice;
+                g_ulDeviceCount++;
+                ProcessContext(NULL);
 
-                    DeviceFound = ALC_TRUE;
-                    break;
-                }
+                DeviceFound = ALC_TRUE;
+                break;
             }
         }
-        else
-            SetALCError(ALC_INVALID_VALUE);
 
         if(!DeviceFound)
         {
+            SetALCError(ALC_INVALID_VALUE);
             free(pDevice);
             pDevice = NULL;
         }
@@ -725,6 +816,8 @@ ALCAPI ALCvoid ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsize
                 case ALC_MAX_AUXILIARY_SENDS:
                     if(!size)
                         SetALCError(ALC_INVALID_VALUE);
+                    else if(device && device->Context)
+                        *data = device->Context->NumSends;
                     else
                         *data = MAX_SENDS;
                     break;
@@ -766,7 +859,7 @@ ALCAPI ALCvoid ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsize
                             data[i++] = device->Context->lNumStereoSources;
 
                             data[i++] = ALC_MAX_AUXILIARY_SENDS;
-                            data[i++] = MAX_SENDS;
+                            data[i++] = device->Context->NumSends;
                         }
                         ProcessContext(NULL);
 
@@ -931,6 +1024,7 @@ ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice *device, const ALCint
 {
     ALCcontext *ALContext = NULL;
     ALuint      ulAttributeIndex, ulRequestedStereoSources;
+    ALuint      RequestedSends;
 
     if ((device)&&(!device->IsCaptureDevice))
     {
@@ -960,7 +1054,7 @@ ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice *device, const ALCint
 
             ProcessContext(NULL);
 
-            // Check for Voice Count attributes
+            // Check for attributes
             if (attrList)
             {
                 ulAttributeIndex = 0;
@@ -975,7 +1069,16 @@ ALCAPI ALCcontext* ALCAPIENTRY alcCreateContext(ALCdevice *device, const ALCint
 
                         ALContext->lNumStereoSources = ulRequestedStereoSources;
                         ALContext->lNumMonoSources = ALContext->Device->MaxNoOfSources - ALContext->lNumStereoSources;
-                        break;
+                    }
+
+                    if(attrList[ulAttributeIndex] == ALC_MAX_AUXILIARY_SENDS)
+                    {
+                        RequestedSends = attrList[ulAttributeIndex + 1];
+
+                        if(RequestedSends > ALContext->NumSends)
+                            RequestedSends = ALContext->NumSends;
+
+                        ALContext->NumSends = RequestedSends;
                     }
 
                     ulAttributeIndex += 2;
@@ -1169,38 +1272,45 @@ ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(const ALCchar *deviceName)
         if(!aluChannelsFromFormat(device->Format))
             device->Format = AL_FORMAT_STEREO16;
 
-        device->UpdateSize = GetConfigValueInt(NULL, "refresh", 8192);
+        device->UpdateSize = GetConfigValueInt(NULL, "refresh", 4096);
         if((ALint)device->UpdateSize <= 0)
-            device->UpdateSize = 8192;
+            device->UpdateSize = 4096;
 
         device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);
         if((ALint)device->MaxNoOfSources <= 0)
             device->MaxNoOfSources = 256;
 
+        device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);
+        if((ALint)device->AuxiliaryEffectSlotMax <= 0)
+            device->AuxiliaryEffectSlotMax = 4;
+
         // Find a playback device to open
+        SuspendContext(NULL);
         for(i = 0;BackendList[i].Init;i++)
         {
             device->Funcs = &BackendList[i].Funcs;
             if(ALCdevice_OpenPlayback(device, deviceName))
             {
-                SuspendContext(NULL);
                 device->next = g_pDeviceList;
                 g_pDeviceList = device;
                 g_ulDeviceCount++;
-                ProcessContext(NULL);
 
                 bDeviceFound = AL_TRUE;
                 break;
             }
         }
+        ProcessContext(NULL);
 
         if (!bDeviceFound)
         {
             // No suitable output device found
+            SetALCError(ALC_INVALID_VALUE);
             free(device);
             device = NULL;
         }
     }
+    else
+        SetALCError(ALC_OUT_OF_MEMORY);
 
     return device;
 }
@@ -1230,7 +1340,12 @@ ALCAPI ALCboolean ALCAPIENTRY alcCloseDevice(ALCdevice *pDevice)
         ProcessContext(NULL);
 
         if(pDevice->Context)
+        {
+#ifdef _DEBUG
+            AL_PRINT("alcCloseDevice(): destroying 1 Context\n");
+#endif
             alcDestroyContext(pDevice->Context);
+        }
         ALCdevice_ClosePlayback(pDevice);
 
         //Release device structure
@@ -1248,11 +1363,9 @@ ALCAPI ALCboolean ALCAPIENTRY alcCloseDevice(ALCdevice *pDevice)
 
 ALCvoid ReleaseALC(ALCvoid)
 {
-    InitAL();
-
 #ifdef _DEBUG
-    if(g_ulContextCount > 0)
-        AL_PRINT("exit() %u device(s) and %u context(s) NOT deleted\n", g_ulDeviceCount, g_ulContextCount);
+    if(g_ulDeviceCount > 0)
+        AL_PRINT("exit(): closing %u Device%s\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");
 #endif
 
     while(g_pDeviceList)

Alc/alcConfig.c

@@ -18,6 +18,10 @@
  * Or go to http://www.gnu.org/copyleft/lgpl.html
  */
 
+#ifdef _WIN32
+#define _WIN32_IE 0x400
+#endif
+
 #include "config.h"
 
 #include <stdlib.h>
@@ -27,8 +31,7 @@
 
 #include "alMain.h"
 
-#ifdef _WIN32
-#define _WIN32_IE 0x400
+#ifdef _WIN32_IE
 #include <shlobj.h>
 #endif
 
@@ -219,13 +222,6 @@ void ReadALConfig(void)
     }
 #else
     f = fopen("/etc/openal/alsoft.conf", "r");
-    if(!f)
-    {
-        f = fopen("/etc/openal/config", "r");
-        if(f)
-            AL_PRINT("Reading /etc/openal/config; this file is deprecated\n"
-                     "\tPlease rename it to /etc/openal/alsoft.conf\n");
-    }
     if(f)
     {
         LoadConfigFromFile(f);
@@ -235,14 +231,6 @@ void ReadALConfig(void)
     {
         snprintf(buffer, sizeof(buffer), "%s/.alsoftrc", getenv("HOME"));
         f = fopen(buffer, "r");
-        if(!f)
-        {
-            snprintf(buffer, sizeof(buffer), "%s/.openalrc", getenv("HOME"));
-            f = fopen(buffer, "r");
-            if(f)
-                AL_PRINT("Reading ~/.openalrc; this file is deprecated\n"
-                         "\tPlease rename it to ~/.alsoftrc\n");
-        }
         if(f)
         {
             LoadConfigFromFile(f);
@@ -250,6 +238,15 @@ void ReadALConfig(void)
         }
     }
 #endif
+    if(getenv("ALSOFT_CONF"))
+    {
+        f = fopen(getenv("ALSOFT_CONF"), "r");
+        if(f)
+        {
+            LoadConfigFromFile(f);
+            fclose(f);
+        }
+    }
 }
 
 void FreeALConfig(void)

Alc/alcEcho.c

@@ -0,0 +1,201 @@
+/**
+ * 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 {
+    // Must be first in all effects!
+    ALeffectState state;
+
+    ALfloat *SampleBuffer;
+    ALuint BufferLength;
+
+    // The echo is two tap. The third tap is the offset to write the feedback
+    // and input sample to
+    struct {
+        ALuint offset;
+    } Tap[3];
+    // The LR gains for the first tap. The second tap uses the reverse
+    ALfloat GainL;
+    ALfloat GainR;
+
+    ALfloat FeedGain;
+
+    FILTER iirFilter;
+    ALfloat history[2];
+} ALechoState;
+
+// Find the next power of 2.  Actually, this will return the input value if
+// it is already a power of 2.
+static ALuint NextPowerOf2(ALuint value)
+{
+    ALuint powerOf2 = 1;
+
+    if(value)
+    {
+        value--;
+        while(value)
+        {
+            value >>= 1;
+            powerOf2 <<= 1;
+        }
+    }
+    return powerOf2;
+}
+
+ALvoid EchoDestroy(ALeffectState *effect)
+{
+    ALechoState *state = (ALechoState*)effect;
+    if(state)
+    {
+        free(state->SampleBuffer);
+        state->SampleBuffer = NULL;
+        free(state);
+    }
+}
+
+ALvoid EchoUpdate(ALeffectState *effect, ALCcontext *Context, ALeffect *Effect)
+{
+    ALechoState *state = (ALechoState*)effect;
+    ALuint newdelay1, newdelay2;
+    ALfloat lrpan, cw, a, g;
+
+    newdelay1 = (ALuint)(Effect->Echo.Delay * Context->Frequency);
+    newdelay2 = (ALuint)(Effect->Echo.LRDelay * Context->Frequency);
+
+    state->Tap[0].offset = (state->BufferLength - newdelay1 - 1 +
+                            state->Tap[2].offset)%state->BufferLength;
+    state->Tap[1].offset = (state->BufferLength - newdelay1 - newdelay2 - 1 +
+                            state->Tap[2].offset)%state->BufferLength;
+
+    lrpan = Effect->Echo.Spread*0.5f + 0.5f;
+    state->GainL = aluSqrt(     lrpan);
+    state->GainR = aluSqrt(1.0f-lrpan);
+
+    state->FeedGain = Effect->Echo.Feedback;
+
+    cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Context->Frequency);
+    g = 1.0f - Effect->Echo.Damping;
+    a = 0.0f;
+    if(g < 0.9999f) // 1-epsilon
+        a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) / (1 - g);
+    state->iirFilter.coeff = a;
+}
+
+ALvoid EchoProcess(ALeffectState *effect, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
+{
+    ALechoState *state = (ALechoState*)effect;
+    const ALuint delay = state->BufferLength-1;
+    ALuint tap1off = state->Tap[0].offset;
+    ALuint tap2off = state->Tap[1].offset;
+    ALuint fboff = state->Tap[2].offset;
+    ALfloat gain = Slot->Gain;
+    ALfloat samp[2];
+    ALuint i;
+
+    for(i = 0;i < SamplesToDo;i++)
+    {
+        // Apply damping
+        samp[0] = lpFilter2P(&state->iirFilter, 0, state->SampleBuffer[tap2off]+SamplesIn[i]);
+
+        // Apply feedback gain and mix in the new sample
+        state->SampleBuffer[fboff] = samp[0] * state->FeedGain;
+
+        tap1off = (tap1off+1) & delay;
+        tap2off = (tap2off+1) & delay;
+        fboff = (fboff+1) & delay;
+
+        // Sample first tap
+        samp[0] = state->SampleBuffer[tap1off]*state->GainL;
+        samp[1] = state->SampleBuffer[tap1off]*state->GainR;
+        // Sample second tap. Reverse LR panning
+        samp[0] += state->SampleBuffer[tap2off]*state->GainR;
+        samp[1] += state->SampleBuffer[tap2off]*state->GainL;
+        // Apply slot gain
+        samp[0] *= gain;
+        samp[1] *= gain;
+
+        SamplesOut[i][FRONT_LEFT]  += samp[0];
+        SamplesOut[i][FRONT_RIGHT] += samp[1];
+        SamplesOut[i][SIDE_LEFT]   += samp[0];
+        SamplesOut[i][SIDE_RIGHT]  += samp[1];
+        SamplesOut[i][BACK_LEFT]   += samp[0];
+        SamplesOut[i][BACK_RIGHT]  += samp[1];
+    }
+
+    state->Tap[0].offset = tap1off;
+    state->Tap[1].offset = tap2off;
+    state->Tap[2].offset = fboff;
+}
+
+ALeffectState *EchoCreate(ALCcontext *Context)
+{
+    ALechoState *state;
+    ALuint i, maxlen;
+
+    state = malloc(sizeof(*state));
+    if(!state)
+    {
+        alSetError(AL_OUT_OF_MEMORY);
+        return NULL;
+    }
+
+    state->state.Destroy = EchoDestroy;
+    state->state.Update = EchoUpdate;
+    state->state.Process = EchoProcess;
+
+    maxlen  = (ALuint)(AL_ECHO_MAX_DELAY * Context->Frequency);
+    maxlen += (ALuint)(AL_ECHO_MAX_LRDELAY * Context->Frequency);
+
+    // Use the next power of 2 for the buffer length, so the tap offsets can be
+    // wrapped using a mask instead of a modulo
+    state->BufferLength = NextPowerOf2(maxlen+1);
+    state->SampleBuffer = malloc(state->BufferLength * sizeof(ALfloat));
+    if(!state->SampleBuffer)
+    {
+        free(state);
+        alSetError(AL_OUT_OF_MEMORY);
+        return NULL;
+    }
+
+    for(i = 0;i < state->BufferLength;i++)
+        state->SampleBuffer[i] = 0.0f;
+
+    state->Tap[0].offset = 0;
+    state->Tap[1].offset = 0;
+    state->Tap[2].offset = 0;
+    state->GainL = 0.0f;
+    state->GainR = 0.0f;
+
+    for(i = 0;i < 2;i++)
+        state->iirFilter.history[i] = 0.0f;
+    state->iirFilter.coeff = 0.0f;
+
+    return &state->state;
+}

Alc/alcReverb.c

@@ -0,0 +1,795 @@
+/**
+ * Reverb for the OpenAL cross platform audio library
+ * Copyright (C) 2008-2009 by Christopher Fitzgerald.
+ * 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 "AL/al.h"
+#include "AL/alc.h"
+#include "alMain.h"
+#include "alAuxEffectSlot.h"
+#include "alEffect.h"
+#include "alError.h"
+#include "alu.h"
+
+typedef struct DelayLine
+{
+    // The delay lines use sample lengths that are powers of 2 to allow
+    // bitmasking instead of modulus wrapping.
+    ALuint   Mask;
+    ALfloat *Line;
+} DelayLine;
+
+typedef struct ALverbState {
+    // Must be first in all effects!
+    ALeffectState state;
+
+    // All delay lines are allocated as a single buffer to reduce memory
+    // fragmentation and management code.
+    ALfloat  *SampleBuffer;
+    // Master effect low-pass filter (2 chained 1-pole filters).
+    FILTER    LpFilter;
+    ALfloat   LpHistory[2];
+    // Initial effect delay and decorrelation.
+    DelayLine Delay;
+    // The tap points for the initial delay.  First tap goes to early
+    // reflections, the last four decorrelate to late reverb.
+    ALuint    Tap[5];
+    struct {
+        // Total gain for early reflections.
+        ALfloat   Gain;
+        // Early reflections are done with 4 delay lines.
+        ALfloat   Coeff[4];
+        DelayLine Delay[4];
+        ALuint    Offset[4];
+        // The gain for each output channel based on 3D panning.
+        ALfloat   PanGain[OUTPUTCHANNELS];
+    } Early;
+    struct {
+        // Total gain for late reverb.
+        ALfloat   Gain;
+        // Attenuation to compensate for modal density and decay rate.
+        ALfloat   DensityGain;
+        // The feed-back and feed-forward all-pass coefficient.
+        ALfloat   ApFeedCoeff;
+        // Mixing matrix coefficient.
+        ALfloat   MixCoeff;
+        // Late reverb has 4 parallel all-pass filters.
+        ALfloat   ApCoeff[4];
+        DelayLine ApDelay[4];
+        ALuint    ApOffset[4];
+        // In addition to 4 cyclical delay lines.
+        ALfloat   Coeff[4];
+        DelayLine Delay[4];
+        ALuint    Offset[4];
+        // The cyclical delay lines are 1-pole low-pass filtered.
+        ALfloat   LpCoeff[4];
+        ALfloat   LpSample[4];
+        // The gain for each output channel based on 3D panning.
+        ALfloat   PanGain[OUTPUTCHANNELS];
+    } Late;
+    // The current read offset for all delay lines.
+    ALuint Offset;
+} ALverbState;
+
+// All delay line lengths are specified in seconds.
+
+// The lengths of the early delay lines.
+static const ALfloat EARLY_LINE_LENGTH[4] =
+{
+    0.0015f, 0.0045f, 0.0135f, 0.0405f
+};
+
+// The lengths of the late all-pass delay lines.
+static const ALfloat ALLPASS_LINE_LENGTH[4] =
+{
+    0.0151f, 0.0167f, 0.0183f, 0.0200f,
+};
+
+// The lengths of the late cyclical delay lines.
+static const ALfloat LATE_LINE_LENGTH[4] =
+{
+    0.0211f, 0.0311f, 0.0461f, 0.0680f
+};
+
+// The late cyclical delay lines have a variable length dependent on the
+// effect's density parameter (inverted for some reason) and this multiplier.
+static const ALfloat LATE_LINE_MULTIPLIER = 4.0f;
+
+// Input into the late reverb is decorrelated between four channels.  Their
+// timings are dependent on a fraction and multiplier.  See VerbUpdate() for
+// the calculations involved.
+static const ALfloat DECO_FRACTION = 1.0f / 32.0f;
+static const ALfloat DECO_MULTIPLIER = 2.0f;
+
+// The maximum length of initial delay for the master delay line (a sum of
+// the maximum early reflection and late reverb delays).
+static const ALfloat MASTER_LINE_LENGTH = 0.3f + 0.1f;
+
+// Find the next power of 2.  Actually, this will return the input value if
+// it is already a power of 2.
+static ALuint NextPowerOf2(ALuint value)
+{
+    ALuint powerOf2 = 1;
+
+    if(value)
+    {
+        value--;
+        while(value)
+        {
+            value >>= 1;
+            powerOf2 <<= 1;
+        }
+    }
+    return powerOf2;
+}
+
+// Basic delay line input/output routines.
+static __inline ALfloat DelayLineOut(DelayLine *Delay, ALuint offset)
+{
+    return Delay->Line[offset&Delay->Mask];
+}
+
+static __inline ALvoid DelayLineIn(DelayLine *Delay, ALuint offset, ALfloat in)
+{
+    Delay->Line[offset&Delay->Mask] = in;
+}
+
+// Delay line output routine for early reflections.
+static __inline ALfloat EarlyDelayLineOut(ALverbState *State, ALuint index)
+{
+    return State->Early.Coeff[index] *
+           DelayLineOut(&State->Early.Delay[index],
+                        State->Offset - State->Early.Offset[index]);
+}
+
+// Given an input sample, this function produces stereo output for early
+// reflections.
+static __inline ALvoid EarlyReflection(ALverbState *State, ALfloat in, ALfloat *out)
+{
+    ALfloat d[4], v, f[4];
+
+    // Obtain the decayed results of each early delay line.
+    d[0] = EarlyDelayLineOut(State, 0);
+    d[1] = EarlyDelayLineOut(State, 1);
+    d[2] = EarlyDelayLineOut(State, 2);
+    d[3] = EarlyDelayLineOut(State, 3);
+
+    /* The following uses a lossless scattering junction from waveguide
+     * theory.  It actually amounts to a householder mixing matrix, which
+     * will produce a maximally diffuse response, and means this can probably
+     * be considered a simple feedback delay network (FDN).
+     *          N
+     *         ---
+     *         \
+     * v = 2/N /   d_i
+     *         ---
+     *         i=1
+     */
+    v = (d[0] + d[1] + d[2] + d[3]) * 0.5f;
+    // The junction is loaded with the input here.
+    v += in;
+
+    // Calculate the feed values for the delay lines.
+    f[0] = v - d[0];
+    f[1] = v - d[1];
+    f[2] = v - d[2];
+    f[3] = v - d[3];
+
+    // Refeed the delay lines.
+    DelayLineIn(&State->Early.Delay[0], State->Offset, f[0]);
+    DelayLineIn(&State->Early.Delay[1], State->Offset, f[1]);
+    DelayLineIn(&State->Early.Delay[2], State->Offset, f[2]);
+    DelayLineIn(&State->Early.Delay[3], State->Offset, f[3]);
+
+    // Output the results of the junction for all four lines.
+    out[0] = State->Early.Gain * f[0];
+    out[1] = State->Early.Gain * f[1];
+    out[2] = State->Early.Gain * f[2];
+    out[3] = State->Early.Gain * f[3];
+}
+
+// All-pass input/output routine for late reverb.
+static __inline ALfloat LateAllPassInOut(ALverbState *State, ALuint index, ALfloat in)
+{
+    ALfloat out;
+
+    out = State->Late.ApCoeff[index] *
+          DelayLineOut(&State->Late.ApDelay[index],
+                       State->Offset - State->Late.ApOffset[index]);
+    out -= (State->Late.ApFeedCoeff * in);
+    DelayLineIn(&State->Late.ApDelay[index], State->Offset,
+                (State->Late.ApFeedCoeff * out) + in);
+    return out;
+}
+
+// Delay line output routine for late reverb.
+static __inline ALfloat LateDelayLineOut(ALverbState *State, ALuint index)
+{
+    return State->Late.Coeff[index] *
+           DelayLineOut(&State->Late.Delay[index],
+                        State->Offset - State->Late.Offset[index]);
+}
+
+// Low-pass filter input/output routine for late reverb.
+static __inline ALfloat LateLowPassInOut(ALverbState *State, ALuint index, ALfloat in)
+{
+    State->Late.LpSample[index] = in +
+        ((State->Late.LpSample[index] - in) * State->Late.LpCoeff[index]);
+    return State->Late.LpSample[index];
+}
+
+// Given four decorrelated input samples, this function produces stereo
+// output for late reverb.
+static __inline ALvoid LateReverb(ALverbState *State, ALfloat *in, ALfloat *out)
+{
+    ALfloat d[4], f[4];
+
+    // Obtain the decayed results of the cyclical delay lines, and add the
+    // corresponding input channels attenuated by density.  Then pass the
+    // results through the low-pass filters.
+    d[0] = LateLowPassInOut(State, 0, (State->Late.DensityGain * in[0]) +
+                                      LateDelayLineOut(State, 0));
+    d[1] = LateLowPassInOut(State, 1, (State->Late.DensityGain * in[1]) +
+                                      LateDelayLineOut(State, 1));
+    d[2] = LateLowPassInOut(State, 2, (State->Late.DensityGain * in[2]) +
+                                      LateDelayLineOut(State, 2));
+    d[3] = LateLowPassInOut(State, 3, (State->Late.DensityGain * in[3]) +
+                                      LateDelayLineOut(State, 3));
+
+    // To help increase diffusion, run each line through an all-pass filter.
+    // The order of the all-pass filters is selected so that the shortest
+    // all-pass filter will feed the shortest delay line.
+    d[0] = LateAllPassInOut(State, 1, d[0]);
+    d[1] = LateAllPassInOut(State, 3, d[1]);
+    d[2] = LateAllPassInOut(State, 0, d[2]);
+    d[3] = LateAllPassInOut(State, 2, d[3]);
+
+    /* Late reverb is done with a modified feedback delay network (FDN)
+     * topology.  Four input lines are each fed through their own all-pass
+     * filter and then into the mixing matrix.  The four outputs of the
+     * mixing matrix are then cycled back to the inputs.  Each output feeds
+     * a different input to form a circlular feed cycle.
+     *
+     * The mixing matrix used is a 4D skew-symmetric rotation matrix derived
+     * using a single unitary rotational parameter:
+     *
+     *  [  d,  a,  b,  c ]          1 = a^2 + b^2 + c^2 + d^2
+     *  [ -a,  d,  c, -b ]
+     *  [ -b, -c,  d,  a ]
+     *  [ -c,  b, -a,  d ]
+     *
+     * The rotation is constructed from the effect's diffusion parameter,
+     * yielding:  1 = x^2 + 3 y^2; where a, b, and c are the coefficient y
+     * with differing signs, and d is the coefficient x.  The matrix is thus:
+     *
+     *  [  x,  y, -y,  y ]          x = 1 - (0.5 diffusion^3)
+     *  [ -y,  x,  y,  y ]          y = sqrt((1 - x^2) / 3)
+     *  [  y, -y,  x,  y ]
+     *  [ -y, -y, -y,  x ]
+     *
+     * To reduce the number of multiplies, the x coefficient is applied with
+     * the cyclical delay line coefficients.  Thus only the y coefficient is
+     * applied when mixing, and is modified to be:  y / x.
+     */
+    f[0] = d[0] + (State->Late.MixCoeff * ( d[1] - d[2] + d[3]));
+    f[1] = d[1] + (State->Late.MixCoeff * (-d[0] + d[2] + d[3]));
+    f[2] = d[2] + (State->Late.MixCoeff * ( d[0] - d[1] + d[3]));
+    f[3] = d[3] + (State->Late.MixCoeff * (-d[0] - d[1] - d[2]));
+
+    // Output the results of the matrix for all four cyclical delay lines,
+    // attenuated by the late reverb gain (which is attenuated by the 'x'
+    // mix coefficient).
+    out[0] = State->Late.Gain * f[0];
+    out[1] = State->Late.Gain * f[1];
+    out[2] = State->Late.Gain * f[2];
+    out[3] = State->Late.Gain * f[3];
+
+    // The delay lines are fed circularly in the order:
+    // 0 -> 1 -> 3 -> 2 -> 0 ...
+    DelayLineIn(&State->Late.Delay[0], State->Offset, f[2]);
+    DelayLineIn(&State->Late.Delay[1], State->Offset, f[0]);
+    DelayLineIn(&State->Late.Delay[2], State->Offset, f[3]);
+    DelayLineIn(&State->Late.Delay[3], State->Offset, f[1]);
+}
+
+// Process the reverb for a given input sample, resulting in separate four-
+// channel output for both early reflections and late reverb.
+static __inline ALvoid ReverbInOut(ALverbState *State, ALfloat in, ALfloat *early, ALfloat *late)
+{
+    ALfloat taps[4];
+
+    // Low-pass filter the incoming sample.
+    in = lpFilter2P(&State->LpFilter, 0, in);
+
+    // Feed the initial delay line.
+    DelayLineIn(&State->Delay, State->Offset, in);
+
+    // Calculate the early reflection from the first delay tap.
+    in = DelayLineOut(&State->Delay, State->Offset - State->Tap[0]);
+    EarlyReflection(State, in, early);
+
+    // Calculate the late reverb from the last four delay taps.
+    taps[0] = DelayLineOut(&State->Delay, State->Offset - State->Tap[1]);
+    taps[1] = DelayLineOut(&State->Delay, State->Offset - State->Tap[2]);
+    taps[2] = DelayLineOut(&State->Delay, State->Offset - State->Tap[3]);
+    taps[3] = DelayLineOut(&State->Delay, State->Offset - State->Tap[4]);
+    LateReverb(State, taps, late);
+
+    // Step all delays forward one sample.
+    State->Offset++;
+}
+
+// This destroys the reverb state.  It should be called only when the effect
+// slot has a different (or no) effect loaded over the reverb effect.
+ALvoid VerbDestroy(ALeffectState *effect)
+{
+    ALverbState *State = (ALverbState*)effect;
+    if(State)
+    {
+        free(State->SampleBuffer);
+        State->SampleBuffer = NULL;
+        free(State);
+    }
+}
+
+// NOTE:  Temp, remove later.
+static __inline ALint aluCart2LUTpos(ALfloat re, ALfloat im)
+{
+    ALint pos = 0;
+    ALfloat denom = aluFabs(re) + aluFabs(im);
+    if(denom > 0.0f)
+        pos = (ALint)(QUADRANT_NUM*aluFabs(im) / denom + 0.5);
+
+    if(re < 0.0)
+        pos = 2 * QUADRANT_NUM - pos;
+    if(im < 0.0)
+        pos = LUT_NUM - pos;
+    return pos%LUT_NUM;
+}
+
+// This updates the reverb state.  This is called any time the reverb effect
+// is loaded into a slot.
+ALvoid VerbUpdate(ALeffectState *effect, ALCcontext *Context, ALeffect *Effect)
+{
+    ALverbState *State = (ALverbState*)effect;
+    ALuint index;
+    ALfloat length, mixCoeff, cw, g, coeff;
+    ALfloat hfRatio = Effect->Reverb.DecayHFRatio;
+
+    // Calculate the master low-pass filter (from the master effect HF gain).
+    cw = cos(2.0 * M_PI * Effect->Reverb.HFReference / Context->Frequency);
+    g = __max(Effect->Reverb.GainHF, 0.0001f);
+    State->LpFilter.coeff = 0.0f;
+    if(g < 0.9999f) // 1-epsilon
+        State->LpFilter.coeff = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) / (1 - g);
+
+    // Calculate the initial delay taps.
+    length = Effect->Reverb.ReflectionsDelay;
+    State->Tap[0] = (ALuint)(length * Context->Frequency);
+
+    length += Effect->Reverb.LateReverbDelay;
+
+    /* The four inputs to the late reverb are decorrelated to smooth the
+     * initial reverb and reduce harsh echos.  The timings are calculated as
+     * multiples of a fraction of the smallest cyclical delay time. This
+     * result is then adjusted so that the first tap occurs immediately (all
+     * taps are reduced by the shortest fraction).
+     *
+     * offset[index] = ((FRACTION MULTIPLIER^index) - 1) delay
+     */
+    for(index = 0;index < 4;index++)
+    {
+        length += LATE_LINE_LENGTH[0] *
+            (1.0f + (Effect->Reverb.Density * LATE_LINE_MULTIPLIER)) *
+            (DECO_FRACTION * (pow(DECO_MULTIPLIER, (ALfloat)index) - 1.0f));
+        State->Tap[1 + index] = (ALuint)(length * Context->Frequency);
+    }
+
+    // Calculate the early reflections gain (from the master effect gain, and
+    // reflections gain parameters).
+    State->Early.Gain = Effect->Reverb.Gain * Effect->Reverb.ReflectionsGain;
+
+    // Calculate the gain (coefficient) for each early delay line.
+    for(index = 0;index < 4;index++)
+        State->Early.Coeff[index] = pow(10.0f, EARLY_LINE_LENGTH[index] /
+                                               Effect->Reverb.LateReverbDelay *
+                                               -60.0f / 20.0f);
+
+    // Calculate the first mixing matrix coefficient (x).
+    mixCoeff = 1.0f - (0.5f * pow(Effect->Reverb.Diffusion, 3.0f));
+
+    // Calculate the late reverb gain (from the master effect gain, and late
+    // reverb gain parameters).  Since the output is tapped prior to the
+    // application of the delay line coefficients, this gain needs to be
+    // attenuated by the 'x' mix coefficient from above.
+    State->Late.Gain = Effect->Reverb.Gain * Effect->Reverb.LateReverbGain * mixCoeff;
+
+    /* To compensate for changes in modal density and decay time of the late
+     * reverb signal, the input is attenuated based on the maximal energy of
+     * the outgoing signal.  This is calculated as the ratio between a
+     * reference value and the current approximation of energy for the output
+     * signal.
+     *
+     * Reverb output matches exponential decay of the form Sum(a^n), where a
+     * is the attenuation coefficient, and n is the sample ranging from 0 to
+     * infinity.  The signal energy can thus be approximated using the area
+     * under this curve, calculated as:  1 / (1 - a).
+     *
+     * The reference energy is calculated from a signal at the lowest (effect
+     * at 1.0) density with a decay time of one second.
+     *
+     * The coefficient is calculated as the average length of the cyclical
+     * delay lines.  This produces a better result than calculating the gain
+     * for each line individually (most likely a side effect of diffusion).
+     *
+     * The final result is the square root of the ratio bound to a maximum
+     * value of 1 (no amplification).
+     */
+    length = (LATE_LINE_LENGTH[0] + LATE_LINE_LENGTH[1] +
+              LATE_LINE_LENGTH[2] + LATE_LINE_LENGTH[3]);
+    g = length * (1.0f + LATE_LINE_MULTIPLIER) * 0.25f;
+    g = pow(10.0f, g * -60.0f / 20.0f);
+    g = 1.0f / (1.0f - (g * g));
+    length *= 1.0f + (Effect->Reverb.Density * LATE_LINE_MULTIPLIER) * 0.25f;
+    length = pow(10.0f, length / Effect->Reverb.DecayTime * -60.0f / 20.0f);
+    length = 1.0f / (1.0f - (length * length));
+    State->Late.DensityGain = __min(aluSqrt(g / length), 1.0f);
+
+    // Calculate the all-pass feed-back and feed-forward coefficient.
+    State->Late.ApFeedCoeff = 0.6f * pow(Effect->Reverb.Diffusion, 3.0f);
+
+    // Calculate the mixing matrix coefficient (y / x).
+    g = aluSqrt((1.0f - (mixCoeff * mixCoeff)) / 3.0f);
+    State->Late.MixCoeff = g / mixCoeff;
+
+    for(index = 0;index < 4;index++)
+    {
+        // Calculate the gain (coefficient) for each all-pass line.
+        State->Late.ApCoeff[index] = pow(10.0f, ALLPASS_LINE_LENGTH[index] /
+                                                Effect->Reverb.DecayTime *
+                                                -60.0f / 20.0f);
+    }
+
+    // If the HF limit parameter is flagged, calculate an appropriate limit
+    // based on the air absorption parameter.
+    if(Effect->Reverb.DecayHFLimit && Effect->Reverb.AirAbsorptionGainHF < 1.0f)
+    {
+        ALfloat limitRatio;
+
+        // For each of the cyclical delays, find the attenuation due to air
+        // absorption in dB (converting delay time to meters using the speed
+        // of sound).  Then reversing the decay equation, solve for HF ratio.
+        // The delay length is cancelled out of the equation, so it can be
+        // calculated once for all lines.
+        limitRatio = 1.0f / (log10(Effect->Reverb.AirAbsorptionGainHF) *
+                             SPEEDOFSOUNDMETRESPERSEC *
+                             Effect->Reverb.DecayTime / -60.0f * 20.0f);
+        // Need to limit the result to a minimum of 0.1, just like the HF
+        // ratio parameter.
+        limitRatio = __max(limitRatio, 0.1f);
+
+        // Using the limit calculated above, apply the upper bound to the
+        // HF ratio.
+        hfRatio = __min(hfRatio, limitRatio);
+    }
+
+    // Calculate the low-pass filter frequency.
+    cw = cos(2.0f * M_PI * Effect->Reverb.HFReference / Context->Frequency);
+
+    for(index = 0;index < 4;index++)
+    {
+        // Calculate the length (in seconds) of each cyclical delay line.
+        length = LATE_LINE_LENGTH[index] * (1.0f + (Effect->Reverb.Density *
+                                                    LATE_LINE_MULTIPLIER));
+        // Calculate the delay offset for the cyclical delay lines.
+        State->Late.Offset[index] = (ALuint)(length * Context->Frequency);
+
+        // Calculate the gain (coefficient) for each cyclical line.
+        State->Late.Coeff[index] = pow(10.0f, length / Effect->Reverb.DecayTime *
+                                              -60.0f / 20.0f);
+
+        // Eventually this should boost the high frequencies when the ratio
+        // exceeds 1.
+        coeff = 0.0f;
+        if (hfRatio < 1.0f)
+        {
+            // Calculate the decay equation for each low-pass filter.
+            g = pow(10.0f, length / (Effect->Reverb.DecayTime * hfRatio) *
+                       -60.0f / 20.0f) / State->Late.Coeff[index];
+            g  = __max(g, 0.1f);
+            g *= g;
+
+            // Calculate the gain (coefficient) for each low-pass filter.
+            if(g < 0.9999f) // 1-epsilon
+                coeff = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) / (1 - g);
+
+            // Very low decay times will produce minimal output, so apply an
+            // upper bound to the coefficient.
+            coeff = __min(coeff, 0.98f);
+        }
+        State->Late.LpCoeff[index] = coeff;
+
+        // Attenuate the cyclical line coefficients by the mixing coefficient
+        // (x).
+        State->Late.Coeff[index] *= mixCoeff;
+    }
+
+    // Calculate the 3D-panning gains for the early reflections and late
+    // reverb (for EAX mode).
+    {
+        ALfloat earlyPan[3] = { Effect->Reverb.ReflectionsPan[0], Effect->Reverb.ReflectionsPan[1], Effect->Reverb.ReflectionsPan[2] };
+        ALfloat latePan[3] = { Effect->Reverb.LateReverbPan[0], Effect->Reverb.LateReverbPan[1], Effect->Reverb.LateReverbPan[2] };
+        ALfloat *speakerGain, dirGain, ambientGain;
+        ALfloat length;
+        ALint pos;
+
+        length = earlyPan[0]*earlyPan[0] + earlyPan[1]*earlyPan[1] + earlyPan[2]*earlyPan[2];
+        if(length > 1.0f)
+        {
+            length = 1.0f / aluSqrt(length);
+            earlyPan[0] *= length;
+            earlyPan[1] *= length;
+            earlyPan[2] *= length;
+        }
+        length = latePan[0]*latePan[0] + latePan[1]*latePan[1] + latePan[2]*latePan[2];
+        if(length > 1.0f)
+        {
+            length = 1.0f / aluSqrt(length);
+            latePan[0] *= length;
+            latePan[1] *= length;
+            latePan[2] *= length;
+        }
+
+        // This code applies directional reverb just like the mixer applies
+        // directional sources.  It diffuses the sound toward all speakers
+        // as the magnitude of the panning vector drops, which is only an
+        // approximation of the expansion of sound across the speakers from
+        // the panning direction.
+        pos = aluCart2LUTpos(earlyPan[2], earlyPan[0]);
+        speakerGain = &Context->PanningLUT[OUTPUTCHANNELS * pos];
+        dirGain = aluSqrt((earlyPan[0] * earlyPan[0]) + (earlyPan[2] * earlyPan[2]));
+        ambientGain = (1.0 - dirGain);
+        for(index = 0;index < OUTPUTCHANNELS;index++)
+             State->Early.PanGain[index] = dirGain * speakerGain[index] + ambientGain;
+
+        pos = aluCart2LUTpos(latePan[2], latePan[0]);
+        speakerGain = &Context->PanningLUT[OUTPUTCHANNELS * pos];
+        dirGain = aluSqrt((latePan[0] * latePan[0]) + (latePan[2] * latePan[2]));
+        ambientGain = (1.0 - dirGain);
+        for(index = 0;index < OUTPUTCHANNELS;index++)
+             State->Late.PanGain[index] = dirGain * speakerGain[index] + ambientGain;
+    }
+}
+
+// This processes the reverb state, given the input samples and an output
+// buffer.
+ALvoid VerbProcess(ALeffectState *effect, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
+{
+    ALverbState *State = (ALverbState*)effect;
+    ALuint index;
+    ALfloat early[4], late[4], out[4];
+    ALfloat gain = Slot->Gain;
+
+    for(index = 0;index < SamplesToDo;index++)
+    {
+        // Process reverb for this sample.
+        ReverbInOut(State, SamplesIn[index], early, late);
+
+        // Mix early reflections and late reverb.
+        out[0] = (early[0] + late[0]) * gain;
+        out[1] = (early[1] + late[1]) * gain;
+        out[2] = (early[2] + late[2]) * gain;
+        out[3] = (early[3] + late[3]) * gain;
+
+        // Output the results.
+        SamplesOut[index][FRONT_LEFT]   += out[0];
+        SamplesOut[index][FRONT_RIGHT]  += out[1];
+        SamplesOut[index][FRONT_CENTER] += out[3];
+        SamplesOut[index][SIDE_LEFT]    += out[0];
+        SamplesOut[index][SIDE_RIGHT]   += out[1];
+        SamplesOut[index][BACK_LEFT]    += out[0];
+        SamplesOut[index][BACK_RIGHT]   += out[1];
+        SamplesOut[index][BACK_CENTER]  += out[2];
+    }
+}
+
+// This processes the EAX reverb state, given the input samples and an output
+// buffer.
+ALvoid EAXVerbProcess(ALeffectState *effect, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
+{
+    ALverbState *State = (ALverbState*)effect;
+    ALuint index;
+    ALfloat early[4], late[4];
+    ALfloat gain = Slot->Gain;
+
+    for(index = 0;index < SamplesToDo;index++)
+    {
+        // Process reverb for this sample.
+        ReverbInOut(State, SamplesIn[index], early, late);
+
+        // Unfortunately, while the number and configuration of gains for
+        // panning adjust according to OUTPUTCHANNELS, the output from the
+        // reverb engine is not so scalable.
+        SamplesOut[index][FRONT_LEFT] +=
+           (State->Early.PanGain[FRONT_LEFT]*early[0] +
+            State->Late.PanGain[FRONT_LEFT]*late[0]) * gain;
+        SamplesOut[index][FRONT_RIGHT] +=
+           (State->Early.PanGain[FRONT_RIGHT]*early[1] +
+            State->Late.PanGain[FRONT_RIGHT]*late[1]) * gain;
+        SamplesOut[index][FRONT_CENTER] +=
+           (State->Early.PanGain[FRONT_CENTER]*early[3] +
+            State->Late.PanGain[FRONT_CENTER]*late[3]) * gain;
+        SamplesOut[index][SIDE_LEFT] +=
+           (State->Early.PanGain[SIDE_LEFT]*early[0] +
+            State->Late.PanGain[SIDE_LEFT]*late[0]) * gain;
+        SamplesOut[index][SIDE_RIGHT] +=
+           (State->Early.PanGain[SIDE_RIGHT]*early[1] +
+            State->Late.PanGain[SIDE_RIGHT]*late[1]) * gain;
+        SamplesOut[index][BACK_LEFT] +=
+           (State->Early.PanGain[BACK_LEFT]*early[0] +
+            State->Late.PanGain[BACK_LEFT]*late[0]) * gain;
+        SamplesOut[index][BACK_RIGHT] +=
+           (State->Early.PanGain[BACK_RIGHT]*early[1] +
+            State->Late.PanGain[BACK_RIGHT]*late[1]) * gain;
+        SamplesOut[index][BACK_CENTER] +=
+           (State->Early.PanGain[BACK_CENTER]*early[2] +
+            State->Late.PanGain[BACK_CENTER]*late[2]) * gain;
+    }
+}
+
+// This creates the reverb state.  It should be called only when the reverb
+// effect is loaded into a slot that doesn't already have a reverb effect.
+ALeffectState *VerbCreate(ALCcontext *Context)
+{
+    ALverbState *State = NULL;
+    ALuint samples, length[13], totalLength, index;
+
+    State = malloc(sizeof(ALverbState));
+    if(!State)
+    {
+        alSetError(AL_OUT_OF_MEMORY);
+        return NULL;
+    }
+
+    State->state.Destroy = VerbDestroy;
+    State->state.Update = VerbUpdate;
+    State->state.Process = VerbProcess;
+
+    // All line lengths are powers of 2, calculated from their lengths, with
+    // an additional sample in case of rounding errors.
+
+    // See VerbUpdate() for an explanation of the additional calculation
+    // added to the master line length.
+    samples = (ALuint)
+              ((MASTER_LINE_LENGTH +
+                (LATE_LINE_LENGTH[0] * (1.0f + LATE_LINE_MULTIPLIER) *
+                 (DECO_FRACTION * ((DECO_MULTIPLIER * DECO_MULTIPLIER *
+                                    DECO_MULTIPLIER) - 1.0f)))) *
+               Context->Frequency) + 1;
+    length[0] = NextPowerOf2(samples);
+    totalLength = length[0];
+    for(index = 0;index < 4;index++)
+    {
+        samples = (ALuint)(EARLY_LINE_LENGTH[index] * Context->Frequency) + 1;
+        length[1 + index] = NextPowerOf2(samples);
+        totalLength += length[1 + index];
+    }
+    for(index = 0;index < 4;index++)
+    {
+        samples = (ALuint)(ALLPASS_LINE_LENGTH[index] * Context->Frequency) + 1;
+        length[5 + index] = NextPowerOf2(samples);
+        totalLength += length[5 + index];
+    }
+    for(index = 0;index < 4;index++)
+    {
+        samples = (ALuint)(LATE_LINE_LENGTH[index] *
+                           (1.0f + LATE_LINE_MULTIPLIER) * Context->Frequency) + 1;
+        length[9 + index] = NextPowerOf2(samples);
+        totalLength += length[9 + index];
+    }
+
+    // All lines share a single sample buffer and have their masks and start
+    // addresses calculated once.
+    State->SampleBuffer = malloc(totalLength * sizeof(ALfloat));
+    if(!State->SampleBuffer)
+    {
+        free(State);
+        alSetError(AL_OUT_OF_MEMORY);
+        return NULL;
+    }
+    for(index = 0; index < totalLength;index++)
+        State->SampleBuffer[index] = 0.0f;
+
+    State->LpFilter.coeff = 0.0f;
+    State->LpFilter.history[0] = 0.0f;
+    State->LpFilter.history[1] = 0.0f;
+    State->Delay.Mask = length[0] - 1;
+    State->Delay.Line = &State->SampleBuffer[0];
+    totalLength = length[0];
+
+    State->Tap[0] = 0;
+    State->Tap[1] = 0;
+    State->Tap[2] = 0;
+    State->Tap[3] = 0;
+    State->Tap[4] = 0;
+
+    State->Early.Gain = 0.0f;
+    for(index = 0;index < 4;index++)
+    {
+        State->Early.Coeff[index] = 0.0f;
+        State->Early.Delay[index].Mask = length[1 + index] - 1;
+        State->Early.Delay[index].Line = &State->SampleBuffer[totalLength];
+        totalLength += length[1 + index];
+
+        // The early delay lines have their read offsets calculated once.
+        State->Early.Offset[index] = (ALuint)(EARLY_LINE_LENGTH[index] *
+                                              Context->Frequency);
+    }
+
+    State->Late.Gain = 0.0f;
+    State->Late.DensityGain = 0.0f;
+    State->Late.ApFeedCoeff = 0.0f;
+    State->Late.MixCoeff = 0.0f;
+
+    for(index = 0;index < 4;index++)
+    {
+        State->Late.ApCoeff[index] = 0.0f;
+        State->Late.ApDelay[index].Mask = length[5 + index] - 1;
+        State->Late.ApDelay[index].Line = &State->SampleBuffer[totalLength];
+        totalLength += length[5 + index];
+
+        // The late all-pass lines have their read offsets calculated once.
+        State->Late.ApOffset[index] = (ALuint)(ALLPASS_LINE_LENGTH[index] *
+                                               Context->Frequency);
+    }
+
+    for(index = 0;index < 4;index++)
+    {
+        State->Late.Coeff[index] = 0.0f;
+        State->Late.Delay[index].Mask = length[9 + index] - 1;
+        State->Late.Delay[index].Line = &State->SampleBuffer[totalLength];
+        totalLength += length[9 + index];
+
+        State->Late.Offset[index] = 0;
+
+        State->Late.LpCoeff[index] = 0.0f;
+        State->Late.LpSample[index] = 0.0f;
+    }
+
+    // Panning is applied as an independent gain for each output channel.
+    for(index = 0;index < OUTPUTCHANNELS;index++)
+    {
+        State->Early.PanGain[index] = 0.0f;
+        State->Late.PanGain[index] = 0.0f;
+    }
+
+    State->Offset = 0;
+    return &State->state;
+}
+
+ALeffectState *EAXVerbCreate(ALCcontext *Context)
+{
+    ALeffectState *State = VerbCreate(Context);
+    if(State) State->Process = EAXVerbProcess;
+    return State;
+}

Alc/alcRing.c

@@ -81,10 +81,11 @@ ALsizei RingBufferSize(RingBuffer *ring)
 
 void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len)
 {
-    int remain = ring->length - ring->write_pos;
+    int remain;
 
     EnterCriticalSection(&ring->cs);
 
+    remain = ring->length - ring->write_pos;
     if((ring->read_pos-ring->write_pos+ring->length)%ring->length < len)
         ring->read_pos = (ring->write_pos+len) % ring->length;
 
@@ -104,10 +105,11 @@ void WriteRingBuffer(RingBuffer *ring, const ALubyte *data, ALsizei len)
 
 void ReadRingBuffer(RingBuffer *ring, ALubyte *data, ALsizei len)
 {
-    int remain = ring->length - ring->read_pos;
+    int remain;
 
     EnterCriticalSection(&ring->cs);
 
+    remain = ring->length - ring->read_pos;
     if(remain < len)
     {
         memcpy(data, ring->mem+(ring->read_pos*ring->frame_size), remain*ring->frame_size);

Alc/alcThread.c

@@ -47,13 +47,14 @@ static DWORD CALLBACK StarterFunc(void *ptr)
 
 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr)
 {
+    DWORD dummy;
     ThreadInfo *inf = malloc(sizeof(ThreadInfo));
     if(!inf) return 0;
 
     inf->func = func;
     inf->ptr = ptr;
 
-    inf->thread = CreateThread(NULL, 0, StarterFunc, inf, 0, NULL);
+    inf->thread = CreateThread(NULL, 0, StarterFunc, inf, 0, &dummy);
     if(!inf->thread)
     {
         free(inf);
@@ -70,6 +71,7 @@ ALuint StopThread(ALvoid *thread)
 
     WaitForSingleObject(inf->thread, INFINITE);
     GetExitCodeThread(inf->thread, &ret);
+    CloseHandle(inf->thread);
 
     free(inf);
 
@@ -83,22 +85,21 @@ ALuint StopThread(ALvoid *thread)
 typedef struct {
     ALuint (*func)(ALvoid*);
     ALvoid *ptr;
+    ALuint ret;
     pthread_t thread;
 } ThreadInfo;
 
 static void *StarterFunc(void *ptr)
 {
     ThreadInfo *inf = (ThreadInfo*)ptr;
-    ALint ret;
-
-    ret = inf->func(inf->ptr);
-    return (void*)ret;
+    inf->ret = inf->func(inf->ptr);
+    return NULL;
 }
 
 ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr)
 {
     ThreadInfo *inf = malloc(sizeof(ThreadInfo));
-    if(!inf) return 0;
+    if(!inf) return NULL;
 
     inf->func = func;
     inf->ptr = ptr;
@@ -114,12 +115,14 @@ ALvoid *StartThread(ALuint (*func)(ALvoid*), ALvoid *ptr)
 ALuint StopThread(ALvoid *thread)
 {
     ThreadInfo *inf = thread;
-    void *ret;
+    ALuint ret;
+
+    pthread_join(inf->thread, NULL);
+    ret = inf->ret;
 
-    pthread_join(inf->thread, &ret);
     free(inf);
 
-    return (ALuint)ret;
+    return ret;
 }
 
 #endif

Alc/alsa.c

@@ -40,7 +40,10 @@ typedef struct {
     ALvoid *buffer;
     ALsizei size;
 
-    int killNow;
+    RingBuffer *ring;
+    int doCapture;
+
+    volatile int killNow;
     ALvoid *thread;
 } alsa_data;
 
@@ -67,9 +70,15 @@ MAKE_FUNC(snd_pcm_hw_params_set_rate_near);
 MAKE_FUNC(snd_pcm_hw_params_set_rate);
 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 MAKE_FUNC(snd_pcm_hw_params_set_buffer_size_min);
+MAKE_FUNC(snd_pcm_hw_params_get_buffer_size);
 MAKE_FUNC(snd_pcm_hw_params_get_period_size);
 MAKE_FUNC(snd_pcm_hw_params_get_access);
 MAKE_FUNC(snd_pcm_hw_params);
+MAKE_FUNC(snd_pcm_sw_params_malloc);
+MAKE_FUNC(snd_pcm_sw_params_current);
+MAKE_FUNC(snd_pcm_sw_params_set_avail_min);
+MAKE_FUNC(snd_pcm_sw_params);
+MAKE_FUNC(snd_pcm_sw_params_free);
 MAKE_FUNC(snd_pcm_prepare);
 MAKE_FUNC(snd_pcm_start);
 MAKE_FUNC(snd_pcm_resume);
@@ -79,6 +88,7 @@ MAKE_FUNC(snd_pcm_avail_update);
 MAKE_FUNC(snd_pcm_areas_silence);
 MAKE_FUNC(snd_pcm_mmap_begin);
 MAKE_FUNC(snd_pcm_mmap_commit);
+MAKE_FUNC(snd_pcm_readi);
 MAKE_FUNC(snd_pcm_writei);
 MAKE_FUNC(snd_pcm_drain);
 MAKE_FUNC(snd_pcm_info_malloc);
@@ -98,11 +108,10 @@ MAKE_FUNC(snd_ctl_card_info_get_name);
 MAKE_FUNC(snd_card_next);
 #undef MAKE_FUNC
 
-#define MAX_DEVICES 16
 #define MAX_ALL_DEVICES 32
 
+static ALCchar *alsaDevice;
 static DevMap allDevNameMap[MAX_ALL_DEVICES];
-static ALCchar *alsaDeviceList[MAX_DEVICES];
 static DevMap allCaptureDevNameMap[MAX_ALL_DEVICES];
 
 static int xrun_recovery(snd_pcm_t *handle, int err)
@@ -173,7 +182,7 @@ static ALuint ALSAProc(ALvoid *ptr)
         }
 
         // make sure there's frames to process
-        if(avail == 0)
+        if(avail >= 0 && avail < (snd_pcm_sframes_t)pDevice->UpdateSize)
         {
             if(state != SND_PCM_STATE_RUNNING)
             {
@@ -190,34 +199,37 @@ static ALuint ALSAProc(ALvoid *ptr)
                 AL_PRINT("Wait timeout... buffer size too low?\n");
             continue;
         }
+        avail = pDevice->UpdateSize;
 
         // it is possible that contiguous areas are smaller, thus we use a loop
         while (avail > 0)
         {
             frames = avail;
 
+            SuspendContext(NULL);
             err = psnd_pcm_mmap_begin(data->pcmHandle, &areas, &offset, &frames);
             if (err < 0)
             {
                 err = xrun_recovery(data->pcmHandle, err);
                 if (err < 0)
                     AL_PRINT("mmap begin error: %s\n", psnd_strerror(err));
+                ProcessContext(NULL);
                 break;
             }
 
-            SuspendContext(NULL);
             WritePtr = (char*)areas->addr + (offset * areas->step / 8);
             WriteCnt = psnd_pcm_frames_to_bytes(data->pcmHandle, frames);
             aluMixData(pDevice->Context, WritePtr, WriteCnt, pDevice->Format);
-            ProcessContext(NULL);
 
             commitres = psnd_pcm_mmap_commit(data->pcmHandle, offset, frames);
             if (commitres < 0 || (commitres-frames) != 0)
             {
                 AL_PRINT("mmap commit error: %s\n",
                          psnd_strerror(commitres >= 0 ? -EPIPE : commitres));
+                ProcessContext(NULL);
                 break;
             }
+            ProcessContext(NULL);
 
             avail -= frames;
         }
@@ -274,12 +286,50 @@ static ALuint ALSANoMMapProc(ALvoid *ptr)
     return 0;
 }
 
+static ALuint ALSANoMMapCaptureProc(ALvoid *ptr)
+{
+    ALCdevice *pDevice = (ALCdevice*)ptr;
+    alsa_data *data = (alsa_data*)pDevice->ExtraData;
+    snd_pcm_sframes_t avail;
+
+    while(!data->killNow)
+    {
+        avail = (snd_pcm_uframes_t)data->size / psnd_pcm_frames_to_bytes(data->pcmHandle, 1);
+        avail = psnd_pcm_readi(data->pcmHandle, data->buffer, avail);
+        switch(avail)
+        {
+            case -EAGAIN:
+                continue;
+            case -ESTRPIPE:
+                while((avail=psnd_pcm_resume(data->pcmHandle)) == -EAGAIN)
+                    Sleep(1);
+                break;
+            case -EPIPE:
+                break;
+            default:
+                if (avail >= 0 && data->doCapture)
+                    WriteRingBuffer(data->ring, data->buffer, avail);
+                break;
+        }
+        if(avail < 0)
+        {
+            avail = psnd_pcm_prepare(data->pcmHandle);
+            if(avail < 0)
+                AL_PRINT("prepare error: %s\n", psnd_strerror(avail));
+        }
+    }
+
+    return 0;
+}
+
 static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceName)
 {
     snd_pcm_uframes_t bufferSizeInFrames;
+    snd_pcm_sw_params_t *sp = NULL;
     snd_pcm_hw_params_t *p = NULL;
     snd_pcm_access_t access;
     unsigned int periods;
+    unsigned int rate;
     alsa_data *data;
     char driver[64];
     const char *str;
@@ -307,21 +357,15 @@ static ALCboolean alsa_open_playback(ALCdevice *device, const ALCchar *deviceNam
                 goto open_alsa;
             }
         }
-        for(idx = 0;idx < MAX_DEVICES;idx++)
+        if(strcmp(deviceName, alsaDevice) == 0)
         {
-            if(alsaDeviceList[idx] &&
-               strcmp(deviceName, alsaDeviceList[idx]) == 0)
-            {
-                device->szDeviceName = alsaDeviceList[idx];
-                if(idx > 0)
-                    sprintf(driver, "hw:%zd,0", idx-1);
-                goto open_alsa;
-            }
+            device->szDeviceName = alsaDevice;
+            goto open_alsa;
         }
         return ALC_FALSE;
     }
     else
-        device->szDeviceName = alsaDeviceList[0];
+        device->szDeviceName = alsaDevice;
 
 open_alsa:
     data = (alsa_data*)calloc(1, sizeof(alsa_data));
@@ -360,6 +404,7 @@ open_alsa:
 
     periods = GetConfigValueInt("alsa", "periods", 0);
     bufferSizeInFrames = device->UpdateSize;
+    rate = device->Frequency;
 
     str = GetConfigValue("alsa", "mmap", "true");
     allowmmap = (strcasecmp(str, "true") == 0 ||
@@ -367,25 +412,40 @@ open_alsa:
                  strcasecmp(str, "on") == 0 ||
                  atoi(str) != 0);
 
+    err = NULL;
     psnd_pcm_hw_params_malloc(&p);
-#define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
-    /* start with the largest configuration space possible */
-    if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
-         /* set interleaved access */
-         ((allowmmap && ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access")) ||
-          ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED), "set access")) &&
-         /* set format (implicitly sets sample bits) */
-         ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format), "set format") &&
-         /* set channels (implicitly sets frame bits) */
-         ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format)), "set channels") &&
-         /* set periods (implicitly constrains period/buffer parameters) */
-         (!periods || ok(psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL), "set periods near")) &&
-         /* set rate (implicitly constrains period/buffer parameters) */
-         ok(psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &device->Frequency, NULL), "set rate near") &&
-         /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
-         ok(psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size near") &&
-         /* install and prepare hardware configuration */
-         ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
+
+    if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
+        err = "any";
+    /* set interleaved access */
+    if(err == NULL && (!allowmmap || (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0))
+    {
+        if((i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
+            err = "set access";
+    }
+    /* set format (implicitly sets sample bits) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
+        err = "set format";
+    /* set channels (implicitly sets frame bits) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(device->Format))) < 0)
+        err = "set channels";
+    /* set periods (implicitly constrains period/buffer parameters) */
+    if(err == NULL && periods && (i=psnd_pcm_hw_params_set_periods_near(data->pcmHandle, p, &periods, NULL)) < 0)
+        err = "set periods near";
+    /* set rate (implicitly constrains period/buffer parameters) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_rate_near(data->pcmHandle, p, &rate, NULL)) < 0)
+        err = "set rate near";
+    /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
+        err = "set buffer size near";
+    /* install and prepare hardware configuration */
+    if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
+        err = "set params";
+    if(err == NULL && (i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
+        err = "get access";
+    if(err == NULL && (i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
+        err = "get period size";
+    if(err != NULL)
     {
         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
         psnd_pcm_hw_params_free(p);
@@ -393,31 +453,30 @@ open_alsa:
         free(data);
         return ALC_FALSE;
     }
-#undef ok
-
-    if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
-    {
-        AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
-        psnd_pcm_hw_params_free(p);
-        psnd_pcm_close(data->pcmHandle);
-        free(data);
-        return ALC_FALSE;
-    }
-
-    if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
-    {
-        AL_PRINT("get_period_size failed: %s\n", psnd_strerror(i));
-        psnd_pcm_hw_params_free(p);
-        psnd_pcm_close(data->pcmHandle);
-        free(data);
-        return ALC_FALSE;
-    }
 
     psnd_pcm_hw_params_free(p);
 
-    device->UpdateSize = bufferSizeInFrames;
+    err = NULL;
+    psnd_pcm_sw_params_malloc(&sp);
 
-    data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, device->UpdateSize);
+    if((i=psnd_pcm_sw_params_current(data->pcmHandle, sp)) != 0)
+        err = "sw current";
+    if(err == NULL && (i=psnd_pcm_sw_params_set_avail_min(data->pcmHandle, sp, bufferSizeInFrames)) != 0)
+        err = "sw set avail min";
+    if(err == NULL && (i=psnd_pcm_sw_params(data->pcmHandle, sp)) != 0)
+        err = "sw set params";
+    if(err != NULL)
+    {
+        AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
+        psnd_pcm_sw_params_free(sp);
+        psnd_pcm_close(data->pcmHandle);
+        free(data);
+        return ALC_FALSE;
+    }
+
+    psnd_pcm_sw_params_free(sp);
+
+    data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
     if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
     {
         data->buffer = malloc(data->size);
@@ -449,6 +508,7 @@ open_alsa:
         data->thread = StartThread(ALSAProc, device);
     if(data->thread == NULL)
     {
+        AL_PRINT("Could not create playback thread\n");
         psnd_pcm_close(data->pcmHandle);
         device->ExtraData = NULL;
         free(data->buffer);
@@ -456,6 +516,9 @@ open_alsa:
         return ALC_FALSE;
     }
 
+    device->UpdateSize = bufferSizeInFrames;
+    device->Frequency = rate;
+
     return ALC_TRUE;
 }
 
@@ -477,8 +540,11 @@ static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceNam
     snd_pcm_format_t alsaFormat;
     snd_pcm_hw_params_t *p;
     snd_pcm_uframes_t bufferSizeInFrames;
+    snd_pcm_access_t access;
+    const char *str;
     alsa_data *data;
     char driver[64];
+    int allowmmap;
     char *err;
     int i;
 
@@ -498,7 +564,7 @@ static ALCboolean alsa_open_capture(ALCdevice *pDevice, const ALCchar *deviceNam
             {
                 pDevice->szDeviceName = allCaptureDevNameMap[idx].name;
                 if(idx > 0)
-                    sprintf(driver, "hw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
+                    sprintf(driver, "plughw:%d,%d", allCaptureDevNameMap[idx].card, allCaptureDevNameMap[idx].dev);
                 goto open_alsa;
             }
         }
@@ -542,24 +608,69 @@ open_alsa:
             AL_PRINT("Unknown format?! %x\n", format);
     }
 
-    bufferSizeInFrames = SampleSize;
+    str = GetConfigValue("alsa", "mmap", "true");
+    allowmmap = (strcasecmp(str, "true") == 0 ||
+                 strcasecmp(str, "yes") == 0 ||
+                 strcasecmp(str, "on") == 0 ||
+                 atoi(str) != 0);
 
+    err = NULL;
+    bufferSizeInFrames = SampleSize;
     psnd_pcm_hw_params_malloc(&p);
-#define ok(func, str) (i=(func),((i<0)?(err=(str)),0:1))
-    /* start with the largest configuration space possible */
-    if(!(ok(psnd_pcm_hw_params_any(data->pcmHandle, p), "any") &&
-         /* set interleaved access */
-         ok(psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set access") &&
-         /* set format (implicitly sets sample bits) */
-         ok(psnd_pcm_hw_params_set_format(data->pcmHandle, p, alsaFormat), "set format") &&
-         /* set channels (implicitly sets frame bits) */
-         ok(psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format)), "set channels") &&
-         /* set rate (implicitly constrains period/buffer parameters) */
-         ok(psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0), "set rate") &&
-         /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
-         ok(psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames), "set buffer size min") &&
-         /* install and prepare hardware configuration */
-         ok(psnd_pcm_hw_params(data->pcmHandle, p), "set params")))
+
+    if(!allowmmap)
+        err = "no mmap";
+    if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
+        err = "any";
+    /* set interleaved access */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0)
+    {
+        err = "set access";
+        allowmmap = 0;
+    }
+    /* set format (implicitly sets sample bits) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
+        err = "set format";
+    /* set channels (implicitly sets frame bits) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
+        err = "set channels";
+    /* set rate (implicitly constrains period/buffer parameters) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
+        err = "set rate near";
+    /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
+    if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_min(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
+    {
+        err = "set buffer size min";
+        allowmmap = 0;
+    }
+    /* install and prepare hardware configuration */
+    if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
+        err = "set params";
+    if(!allowmmap)
+    {
+        err = NULL;
+        if((i=psnd_pcm_hw_params_any(data->pcmHandle, p)) < 0)
+            err = "any";
+        /* set interleaved access */
+        if(err == NULL && (i=psnd_pcm_hw_params_set_access(data->pcmHandle, p, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0)
+            err = "set access";
+        /* set format (implicitly sets sample bits) */
+        if(err == NULL && (i=psnd_pcm_hw_params_set_format(data->pcmHandle, p, data->format)) < 0)
+            err = "set format";
+        /* set channels (implicitly sets frame bits) */
+        if(err == NULL && (i=psnd_pcm_hw_params_set_channels(data->pcmHandle, p, aluChannelsFromFormat(pDevice->Format))) < 0)
+            err = "set channels";
+        /* set rate (implicitly constrains period/buffer parameters) */
+        if(err == NULL && (i=psnd_pcm_hw_params_set_rate(data->pcmHandle, p, frequency, 0)) < 0)
+            err = "set rate near";
+        /* set buffer size in frame units (implicitly sets period size/bytes/time and buffer time/bytes) */
+        if(err == NULL && (i=psnd_pcm_hw_params_set_buffer_size_near(data->pcmHandle, p, &bufferSizeInFrames)) < 0)
+            err = "set buffer size near";
+        /* install and prepare hardware configuration */
+        if(err == NULL && (i=psnd_pcm_hw_params(data->pcmHandle, p)) < 0)
+            err = "set params";
+    }
+    if(err != NULL)
     {
         AL_PRINT("%s failed: %s\n", err, psnd_strerror(i));
         psnd_pcm_hw_params_free(p);
@@ -567,25 +678,90 @@ open_alsa:
         free(data);
         return ALC_FALSE;
     }
-#undef ok
-    psnd_pcm_hw_params_free(p);
 
-    i = psnd_pcm_prepare(data->pcmHandle);
-    if(i < 0)
+    if((i=psnd_pcm_hw_params_get_access(p, &access)) < 0)
     {
-        AL_PRINT("prepare error: %s\n", psnd_strerror(i));
+        AL_PRINT("get_access failed: %s\n", psnd_strerror(i));
+        psnd_pcm_hw_params_free(p);
+        psnd_pcm_close(data->pcmHandle);
+        free(data);
+        return ALC_FALSE;
+    }
+    if((i=psnd_pcm_hw_params_get_period_size(p, &bufferSizeInFrames, NULL)) < 0)
+    {
+        AL_PRINT("get size failed: %s\n", psnd_strerror(i));
+        psnd_pcm_hw_params_free(p);
         psnd_pcm_close(data->pcmHandle);
         free(data);
         return ALC_FALSE;
     }
 
-    pDevice->ExtraData = data;
+    psnd_pcm_hw_params_free(p);
+
+    if(access == SND_PCM_ACCESS_RW_INTERLEAVED)
+    {
+        ALuint frameSize = aluChannelsFromFormat(pDevice->Format);
+        frameSize *= aluBytesFromFormat(pDevice->Format);
+
+        data->ring = CreateRingBuffer(frameSize, SampleSize);
+        if(!data->ring)
+        {
+            AL_PRINT("ring buffer create failed\n");
+            psnd_pcm_close(data->pcmHandle);
+            free(data);
+            return ALC_FALSE;
+        }
+
+        data->size = psnd_pcm_frames_to_bytes(data->pcmHandle, bufferSizeInFrames);
+        data->buffer = malloc(data->size);
+        if(!data->buffer)
+        {
+            AL_PRINT("buffer malloc failed\n");
+            psnd_pcm_close(data->pcmHandle);
+            DestroyRingBuffer(data->ring);
+            free(data);
+            return ALC_FALSE;
+        }
+
+        pDevice->ExtraData = data;
+        data->thread = StartThread(ALSANoMMapCaptureProc, pDevice);
+        if(data->thread == NULL)
+        {
+            AL_PRINT("Could not create capture thread\n");
+            pDevice->ExtraData = NULL;
+            psnd_pcm_close(data->pcmHandle);
+            DestroyRingBuffer(data->ring);
+            free(data->buffer);
+            free(data);
+            return ALC_FALSE;
+        }
+    }
+    else
+    {
+        i = psnd_pcm_prepare(data->pcmHandle);
+        if(i < 0)
+        {
+            AL_PRINT("prepare error: %s\n", psnd_strerror(i));
+            psnd_pcm_close(data->pcmHandle);
+            free(data);
+            return ALC_FALSE;
+        }
+        pDevice->ExtraData = data;
+    }
+
     return ALC_TRUE;
 }
 
 static void alsa_close_capture(ALCdevice *pDevice)
 {
     alsa_data *data = (alsa_data*)pDevice->ExtraData;
+
+    if(data->thread)
+    {
+        data->killNow = 1;
+        StopThread(data->thread);
+        DestroyRingBuffer(data->ring);
+    }
     psnd_pcm_close(data->pcmHandle);
 
     free(data);
@@ -595,14 +771,20 @@ static void alsa_close_capture(ALCdevice *pDevice)
 static void alsa_start_capture(ALCdevice *pDevice)
 {
     alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    psnd_pcm_prepare(data->pcmHandle);
-    psnd_pcm_start(data->pcmHandle);
+    data->doCapture = 1;
+    if(!data->thread)
+    {
+        psnd_pcm_prepare(data->pcmHandle);
+        psnd_pcm_start(data->pcmHandle);
+    }
 }
 
 static void alsa_stop_capture(ALCdevice *pDevice)
 {
     alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    psnd_pcm_drain(data->pcmHandle);
+    data->doCapture = 0;
+    if(!data->thread)
+        psnd_pcm_drain(data->pcmHandle);
 }
 
 static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
@@ -611,8 +793,29 @@ static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint l
     const snd_pcm_channel_area_t *areas = NULL;
     snd_pcm_sframes_t frames, commitres;
     snd_pcm_uframes_t size, offset;
+    snd_pcm_state_t state;
     int err;
 
+    if(data->thread)
+    {
+        if(lSamples <= (ALCuint)RingBufferSize(data->ring))
+            ReadRingBuffer(data->ring, pBuffer, lSamples);
+        else
+            SetALCError(ALC_INVALID_VALUE);
+        return;
+    }
+
+    state = psnd_pcm_state(data->pcmHandle);
+    if(state == SND_PCM_STATE_XRUN)
+    {
+        err = xrun_recovery(data->pcmHandle, -EPIPE);
+        if(err < 0)
+        {
+            AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
+            return;
+        }
+    }
+
     frames = psnd_pcm_avail_update(data->pcmHandle);
     if(frames < 0)
     {
@@ -668,16 +871,37 @@ static void alsa_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint l
 static ALCuint alsa_available_samples(ALCdevice *pDevice)
 {
     alsa_data *data = (alsa_data*)pDevice->ExtraData;
-    snd_pcm_sframes_t frames = psnd_pcm_avail_update(data->pcmHandle);
+    snd_pcm_sframes_t frames;
+    snd_pcm_state_t state;
+    int err;
+
+    if(data->thread)
+        return RingBufferSize(data->ring);
+
+    state = psnd_pcm_state(data->pcmHandle);
+    if(state == SND_PCM_STATE_XRUN)
+    {
+        err = xrun_recovery(data->pcmHandle, -EPIPE);
+        if(err >= 0)
+        {
+            if(data->doCapture)
+                err = psnd_pcm_start(data->pcmHandle);
+        }
+        if (err < 0)
+        {
+            AL_PRINT("XRUN recovery failed: %s\n", psnd_strerror(err));
+            return 0;
+        }
+    }
+
+    frames = psnd_pcm_avail_update(data->pcmHandle);
     if(frames < 0)
     {
-        int err = xrun_recovery(data->pcmHandle, frames);
+        err = xrun_recovery(data->pcmHandle, frames);
         if (err < 0)
             AL_PRINT("available update failed: %s\n", psnd_strerror(err));
         else
             frames = psnd_pcm_avail_update(data->pcmHandle);
-        if(frames < 0) /* ew.. */
-            SetALCError(ALC_INVALID_DEVICE);
     }
     return max(frames, 0);
 }
@@ -724,7 +948,7 @@ void alc_alsa_init(BackendFuncs *func_list)
 } while(0)
 #else
     str = NULL;
-    alsa_handle = 0xDEADBEEF;
+    alsa_handle = (void*)0xDEADBEEF;
 #define LOAD_FUNC(f) p##f = f
 #endif
 
@@ -744,9 +968,15 @@ LOAD_FUNC(snd_pcm_hw_params_set_rate_near);
 LOAD_FUNC(snd_pcm_hw_params_set_rate);
 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near);
 LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min);
+LOAD_FUNC(snd_pcm_hw_params_get_buffer_size);
 LOAD_FUNC(snd_pcm_hw_params_get_period_size);
 LOAD_FUNC(snd_pcm_hw_params_get_access);
 LOAD_FUNC(snd_pcm_hw_params);
+LOAD_FUNC(snd_pcm_sw_params_malloc);
+LOAD_FUNC(snd_pcm_sw_params_current);
+LOAD_FUNC(snd_pcm_sw_params_set_avail_min);
+LOAD_FUNC(snd_pcm_sw_params);
+LOAD_FUNC(snd_pcm_sw_params_free);
 LOAD_FUNC(snd_pcm_prepare);
 LOAD_FUNC(snd_pcm_start);
 LOAD_FUNC(snd_pcm_resume);
@@ -756,6 +986,7 @@ LOAD_FUNC(snd_pcm_avail_update);
 LOAD_FUNC(snd_pcm_areas_silence);
 LOAD_FUNC(snd_pcm_mmap_begin);
 LOAD_FUNC(snd_pcm_mmap_commit);
+LOAD_FUNC(snd_pcm_readi);
 LOAD_FUNC(snd_pcm_writei);
 LOAD_FUNC(snd_pcm_drain);
 
@@ -783,15 +1014,11 @@ LOAD_FUNC(snd_card_next);
     card = -1;
     if(psnd_card_next(&card) < 0 || card < 0)
         AL_PRINT("no playback cards found...\n");
-    else
-    {
-        alsaDeviceList[0] = AppendDeviceList("ALSA Software on default");
-        allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
-    }
+
+    alsaDevice = AppendDeviceList("ALSA Software");
+    allDevNameMap[0].name = AppendAllDeviceList("ALSA Software on default");
 
     while (card >= 0) {
-        int firstDev = 1;
-
         sprintf(name, "hw:%d", card);
         if ((err = psnd_ctl_open(&handle, name, 0)) < 0) {
             AL_PRINT("control open (%i): %s\n", card, psnd_strerror(err));
@@ -812,13 +1039,6 @@ LOAD_FUNC(snd_card_next);
             if (dev < 0)
                 break;
 
-            if(firstDev && card < MAX_DEVICES-1) {
-                firstDev = 0;
-                snprintf(name, sizeof(name), "ALSA Software on %s",
-                         psnd_ctl_card_info_get_name(info));
-                alsaDeviceList[card+1] = AppendDeviceList(name);
-            }
-
             psnd_pcm_info_set_device(pcminfo, dev);
             psnd_pcm_info_set_subdevice(pcminfo, 0);
             psnd_pcm_info_set_stream(pcminfo, stream);
@@ -830,8 +1050,8 @@ LOAD_FUNC(snd_card_next);
 
             cname = psnd_ctl_card_info_get_name(info);
             dname = psnd_pcm_info_get_name(pcminfo);
-            snprintf(name, sizeof(name), "ALSA Software on %s [%s]",
-                     cname, dname);
+            snprintf(name, sizeof(name), "ALSA Software on %s [%s] (hw:%d,%d)",
+                     cname, dname, card, dev);
             allDevNameMap[idx].name = AppendAllDeviceList(name);
             allDevNameMap[idx].card = card;
             allDevNameMap[idx].dev = dev;
@@ -889,8 +1109,8 @@ next_card:
 
                 cname = psnd_ctl_card_info_get_name(info);
                 dname = psnd_pcm_info_get_name(pcminfo);
-                snprintf(name, sizeof(name), "ALSA Capture on %s [%s]",
-                         cname, dname);
+                snprintf(name, sizeof(name), "ALSA Capture on %s [%s] (hw:%d,%d)",
+                         cname, dname, card, dev);
                 allCaptureDevNameMap[idx].name = AppendCaptureDeviceList(name);
                 allCaptureDevNameMap[idx].card = card;
                 allCaptureDevNameMap[idx].dev = dev;

Alc/dsound.c

@@ -28,19 +28,30 @@
 
 #include <dsound.h>
 #include <mmreg.h>
+#ifndef _WAVEFORMATEXTENSIBLE_
+#include <ks.h>
+#include <ksmedia.h>
+#endif
 
 #include "alMain.h"
 #include "AL/al.h"
 #include "AL/alc.h"
 
+#ifndef DSSPEAKER_5POINT1
+#define DSSPEAKER_5POINT1       6
+#endif
 #ifndef DSSPEAKER_7POINT1
 #define DSSPEAKER_7POINT1       7
 #endif
 
 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
 
-// Since DSound doesn't report the fragment size, just assume 4 fragments
-#define DS_FRAGS 4
+static void *ds_handle;
+static HRESULT (WINAPI *pDirectSoundCreate)(LPCGUID pcGuidDevice, LPDIRECTSOUND *ppDS, LPUNKNOWN pUnkOuter);
+static HRESULT (WINAPI *pDirectSoundEnumerateA)(LPDSENUMCALLBACKA pDSEnumCallback, LPVOID pContext);
+
+// Since DSound doesn't report the fragment size, emulate it
+static int num_frags;
 
 typedef struct {
     // DirectSound Playback Device
@@ -48,7 +59,7 @@ typedef struct {
     LPDIRECTSOUNDBUFFER    DSpbuffer;
     LPDIRECTSOUNDBUFFER    DSsbuffer;
 
-    int killNow;
+    volatile int killNow;
     ALvoid *thread;
 } DSoundData;
 
@@ -64,29 +75,38 @@ static ALuint DSoundProc(ALvoid *ptr)
 {
     ALCdevice *pDevice = (ALCdevice*)ptr;
     DSoundData *pData = (DSoundData*)pDevice->ExtraData;
+    DSBCAPS DSBCaps;
     DWORD LastCursor = 0;
     DWORD PlayCursor;
     VOID *WritePtr1, *WritePtr2;
     DWORD WriteCnt1,  WriteCnt2;
-    DWORD BufferSize;
+    DWORD FragSize;
     DWORD avail;
     HRESULT err;
 
-    BufferSize  = pDevice->UpdateSize * DS_FRAGS *
-                  aluBytesFromFormat(pDevice->Format) *
-                  aluChannelsFromFormat(pDevice->Format);
+    memset(&DSBCaps, 0, sizeof(DSBCaps));
+    DSBCaps.dwSize = sizeof(DSBCaps);
+    err = IDirectSoundBuffer_GetCaps(pData->DSsbuffer, &DSBCaps);
+    if(FAILED(err))
+    {
+        AL_PRINT("Failed to get buffer caps: 0x%lx\n", err);
+        return 1;
+    }
+    FragSize = DSBCaps.dwBufferBytes / num_frags;
 
+    IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer, &LastCursor, NULL);
     while(!pData->killNow)
     {
         // Get current play and write cursors
         IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer, &PlayCursor, NULL);
-        avail = (PlayCursor-LastCursor+BufferSize) % BufferSize;
+        avail = (PlayCursor-LastCursor+DSBCaps.dwBufferBytes) % DSBCaps.dwBufferBytes;
 
-        if(avail == 0)
+        if(avail < FragSize)
         {
             Sleep(1);
             continue;
         }
+        avail -= avail%FragSize;
 
         // Lock output buffer
         WriteCnt1 = 0;
@@ -120,7 +140,7 @@ static ALuint DSoundProc(ALvoid *ptr)
 
         // Update old write cursor location
         LastCursor += WriteCnt1+WriteCnt2;
-        LastCursor %= BufferSize;
+        LastCursor %= DSBCaps.dwBufferBytes;
     }
 
     return 0;
@@ -133,9 +153,13 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
     WAVEFORMATEXTENSIBLE OutputType;
     DWORD frameSize = 0;
     LPGUID guid = NULL;
+    ALenum format = 0;
     DWORD speakers;
     HRESULT hr;
 
+    if(ds_handle == NULL)
+        return ALC_FALSE;
+
     if(deviceName)
     {
         int i;
@@ -167,13 +191,13 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
     }
 
     //DirectSound Init code
-    hr = DirectSoundCreate(guid, &pData->lpDS, NULL);
+    hr = pDirectSoundCreate(guid, &pData->lpDS, NULL);
     if(SUCCEEDED(hr))
         hr = IDirectSound_SetCooperativeLevel(pData->lpDS, GetForegroundWindow(), DSSCL_PRIORITY);
 
     if(SUCCEEDED(hr))
     {
-        if(*(GetConfigValue(NULL, "format", "")) != 0)
+        if(*(GetConfigValue(NULL, "format", "")) == 0)
             hr = IDirectSound_GetSpeakerConfig(pData->lpDS, &speakers);
         else
         {
@@ -197,23 +221,23 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
         if(speakers == DSSPEAKER_MONO)
         {
             if(aluBytesFromFormat(device->Format) == 1)
-                device->Format = AL_FORMAT_MONO8;
+                format = AL_FORMAT_MONO8;
             else
-                device->Format = AL_FORMAT_MONO16;
+                format = AL_FORMAT_MONO16;
         }
         else if(speakers == DSSPEAKER_STEREO)
         {
             if(aluBytesFromFormat(device->Format) == 1)
-                device->Format = AL_FORMAT_STEREO8;
+                format = AL_FORMAT_STEREO8;
             else
-                device->Format = AL_FORMAT_STEREO16;
+                format = AL_FORMAT_STEREO16;
         }
         else if(speakers == DSSPEAKER_QUAD)
         {
             if(aluBytesFromFormat(device->Format) == 1)
-                device->Format = AL_FORMAT_QUAD8;
+                format = AL_FORMAT_QUAD8;
             else
-                device->Format = AL_FORMAT_QUAD16;
+                format = AL_FORMAT_QUAD16;
             OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
                                        SPEAKER_FRONT_RIGHT |
                                        SPEAKER_BACK_LEFT |
@@ -222,9 +246,9 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
         else if(speakers == DSSPEAKER_5POINT1)
         {
             if(aluBytesFromFormat(device->Format) == 1)
-                device->Format = AL_FORMAT_51CHN8;
+                format = AL_FORMAT_51CHN8;
             else
-                device->Format = AL_FORMAT_51CHN16;
+                format = AL_FORMAT_51CHN16;
             OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
                                        SPEAKER_FRONT_RIGHT |
                                        SPEAKER_FRONT_CENTER |
@@ -235,9 +259,9 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
         else if(speakers == DSSPEAKER_7POINT1)
         {
             if(aluBytesFromFormat(device->Format) == 1)
-                device->Format = AL_FORMAT_71CHN8;
+                format = AL_FORMAT_71CHN8;
             else
-                device->Format = AL_FORMAT_71CHN16;
+                format = AL_FORMAT_71CHN16;
             OutputType.dwChannelMask = SPEAKER_FRONT_LEFT |
                                        SPEAKER_FRONT_RIGHT |
                                        SPEAKER_FRONT_CENTER |
@@ -247,18 +271,17 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
                                        SPEAKER_SIDE_LEFT |
                                        SPEAKER_SIDE_RIGHT;
         }
-        frameSize = aluBytesFromFormat(device->Format) *
-                    aluChannelsFromFormat(device->Format);
+        else
+            format = device->Format;
+        frameSize = aluBytesFromFormat(format) * aluChannelsFromFormat(format);
 
         OutputType.Format.wFormatTag = WAVE_FORMAT_PCM;
-        OutputType.Format.nChannels = aluChannelsFromFormat(device->Format);
-        OutputType.Format.wBitsPerSample = aluBytesFromFormat(device->Format) * 8;
+        OutputType.Format.nChannels = aluChannelsFromFormat(format);
+        OutputType.Format.wBitsPerSample = aluBytesFromFormat(format) * 8;
         OutputType.Format.nBlockAlign = OutputType.Format.nChannels*OutputType.Format.wBitsPerSample/8;
         OutputType.Format.nSamplesPerSec = device->Frequency;
         OutputType.Format.nAvgBytesPerSec = OutputType.Format.nSamplesPerSec*OutputType.Format.nBlockAlign;
         OutputType.Format.cbSize = 0;
-
-        device->UpdateSize /= DS_FRAGS;
     }
 
     if(OutputType.Format.nChannels > 2)
@@ -286,7 +309,7 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
         memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
         DSBDescription.dwSize=sizeof(DSBUFFERDESC);
         DSBDescription.dwFlags=DSBCAPS_GLOBALFOCUS|DSBCAPS_GETCURRENTPOSITION2;
-        DSBDescription.dwBufferBytes=device->UpdateSize * DS_FRAGS * frameSize;
+        DSBDescription.dwBufferBytes=(device->UpdateSize/num_frags) * num_frags * frameSize;
         DSBDescription.lpwfxFormat=&OutputType.Format;
         hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSsbuffer, NULL);
     }
@@ -315,6 +338,9 @@ static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceNam
         return ALC_FALSE;
     }
 
+    device->Format = format;
+    device->UpdateSize /= num_frags;
+
     return ALC_TRUE;
 }
 
@@ -411,7 +437,37 @@ void alcDSoundInit(BackendFuncs *FuncList)
 
     *FuncList = DSoundFuncs;
 
-    hr = DirectSoundEnumerate(DSoundEnumDevices, &iter);
+#ifdef _WIN32
+    ds_handle = LoadLibraryA("dsound.dll");
+    if(ds_handle == NULL)
+    {
+        AL_PRINT("Failed to load dsound.dll\n");
+        return;
+    }
+
+#define LOAD_FUNC(f) do { \
+    p##f = (void*)GetProcAddress((HMODULE)ds_handle, #f); \
+    if(p##f == NULL) \
+    { \
+        FreeLibrary(ds_handle); \
+        ds_handle = NULL; \
+        AL_PRINT("Could not load %s from dsound.dll\n", #f); \
+        return; \
+    } \
+} while(0)
+#else
+    ds_handle = (void*)0xDEADBEEF;
+#define LOAD_FUNC(f) p##f = f
+#endif
+
+LOAD_FUNC(DirectSoundCreate);
+LOAD_FUNC(DirectSoundEnumerateA);
+#undef LOAD_FUNC
+
+    num_frags = GetConfigValueInt("dsound", "periods", 4);
+    if(num_frags < 2) num_frags = 2;
+
+    hr = pDirectSoundEnumerateA(DSoundEnumDevices, &iter);
     if(FAILED(hr))
         AL_PRINT("Error enumerating DirectSound devices (%#x)!\n", (unsigned int)hr);
 }

Alc/oss.c

@@ -52,7 +52,7 @@ static char *oss_device_capture;
 
 typedef struct {
     int fd;
-    int killNow;
+    volatile int killNow;
     ALvoid *thread;
 
     ALubyte *mix_data;
@@ -79,35 +79,35 @@ static ALuint OSSProc(ALvoid *ptr)
 {
     ALCdevice *pDevice = (ALCdevice*)ptr;
     oss_data *data = (oss_data*)pDevice->ExtraData;
-    int remaining = 0;
     int wrote;
 
     while(!data->killNow)
     {
-        int len = data->data_size - remaining;
+        ALint len = data->data_size;
+        ALubyte *WritePtr = data->mix_data;
 
-        if(len > 0)
-        {
-            SuspendContext(NULL);
-            aluMixData(pDevice->Context, data->mix_data+remaining, len, pDevice->Format);
-            ProcessContext(NULL);
-        }
+        SuspendContext(NULL);
+        aluMixData(pDevice->Context, WritePtr, len, pDevice->Format);
+        ProcessContext(NULL);
 
-        remaining += len;
-        wrote = write(data->fd, data->mix_data, remaining);
-        if(wrote < 0)
+        while(len > 0 && !data->killNow)
         {
-            AL_PRINT("write failed: %s\n", strerror(errno));
-            remaining = 0;
+            wrote = write(data->fd, WritePtr, len);
+            if(wrote < 0)
+            {
+                if(errno != EAGAIN && errno != EWOULDBLOCK)
+                {
+                    AL_PRINT("write failed: %s\n", strerror(errno));
+                    len = 0;
+                }
+                else
+                    Sleep(1);
+                continue;
+            }
+
+            len -= wrote;
+            WritePtr += wrote;
         }
-        else if(wrote > 0)
-        {
-            remaining -= wrote;
-            if(remaining > 0)
-                memmove(data->mix_data, data->mix_data+wrote, remaining);
-        }
-        else
-            Sleep(1);
     }
 
     return 0;
@@ -221,8 +221,6 @@ static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName
     }
 #undef ok
 
-    device->Frequency = ossSpeed;
-
     if((int)aluChannelsFromFormat(device->Format) != numChannels)
     {
         AL_PRINT("Could not set %d channels, got %d instead\n", aluChannelsFromFormat(device->Format), numChannels);
@@ -240,8 +238,6 @@ static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName
         return ALC_FALSE;
     }
 
-    device->UpdateSize = info.fragsize / frameSize;
-
     data->data_size = device->UpdateSize * frameSize;
     data->mix_data = calloc(1, data->data_size);
 
@@ -255,6 +251,9 @@ static ALCboolean oss_open_playback(ALCdevice *device, const ALCchar *deviceName
         return ALC_FALSE;
     }
 
+    device->Frequency = ossSpeed;
+    device->UpdateSize = info.fragsize / frameSize;
+
     return ALC_TRUE;
 }
 

Alc/portaudio.c

@@ -0,0 +1,239 @@
+/**
+ * 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 "AL/al.h"
+#include "AL/alc.h"
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <portaudio.h>
+
+static void *pa_handle;
+#define MAKE_FUNC(x) static typeof(x) * p##x
+MAKE_FUNC(Pa_Initialize);
+MAKE_FUNC(Pa_GetErrorText);
+MAKE_FUNC(Pa_StartStream);
+MAKE_FUNC(Pa_StopStream);
+MAKE_FUNC(Pa_OpenStream);
+MAKE_FUNC(Pa_CloseStream);
+MAKE_FUNC(Pa_GetDefaultOutputDevice);
+#undef MAKE_FUNC
+
+
+static char *pa_device;
+
+typedef struct {
+    PaStream *stream;
+} pa_data;
+
+
+static int pa_callback(const void *inputBuffer, void *outputBuffer,
+                       unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *timeInfo,
+                       const PaStreamCallbackFlags statusFlags, void *userData)
+{
+    ALCdevice *device = (ALCdevice*)userData;
+    int frameSize;
+
+    (void)inputBuffer;
+    (void)timeInfo;
+    (void)statusFlags;
+
+    frameSize  = aluBytesFromFormat(device->Format);
+    frameSize *= aluChannelsFromFormat(device->Format);
+
+    SuspendContext(NULL);
+    aluMixData(device->Context, outputBuffer, framesPerBuffer*frameSize, device->Format);
+    ProcessContext(NULL);
+
+    return 0;
+}
+
+
+static ALCboolean pa_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    PaStreamParameters outParams;
+    pa_data *data;
+    int periods;
+    PaError err;
+
+    if(pa_handle == NULL)
+        return ALC_FALSE;
+
+    if(deviceName)
+    {
+        if(strcmp(deviceName, pa_device) != 0)
+            return ALC_FALSE;
+    }
+
+    device->szDeviceName = pa_device;
+
+    data = (pa_data*)calloc(1, sizeof(pa_data));
+    device->ExtraData = data;
+
+    outParams.device = GetConfigValueInt("port", "device", -1);
+    if(outParams.device < 0)
+        outParams.device = pPa_GetDefaultOutputDevice();
+    outParams.suggestedLatency = (float)device->UpdateSize /
+                                 (float)device->Frequency;
+    outParams.hostApiSpecificStreamInfo = NULL;
+
+    switch(aluBytesFromFormat(device->Format))
+    {
+        case 1:
+            outParams.sampleFormat = paUInt8;
+            break;
+        case 2:
+            outParams.sampleFormat = paInt16;
+            break;
+        default:
+            outParams.sampleFormat = -1;
+            AL_PRINT("Unknown format?! %x\n", device->Format);
+    }
+
+    periods = GetConfigValueInt("port", "periods", 4);
+    if((int)periods <= 0)
+        periods = 4;
+    outParams.channelCount = aluChannelsFromFormat(device->Format);
+
+    err = pPa_OpenStream(&data->stream, NULL, &outParams, device->Frequency,
+                        device->UpdateSize/periods, paNoFlag,
+                        pa_callback, device);
+    if(err != paNoError)
+    {
+        AL_PRINT("Pa_OpenStream() returned an error: %s\n", pPa_GetErrorText(err));
+        device->ExtraData = NULL;
+        free(data);
+        return ALC_FALSE;
+    }
+
+    err = pPa_StartStream(data->stream);
+    if(err != paNoError)
+    {
+        AL_PRINT("Pa_StartStream() returned an error: %s\n", pPa_GetErrorText(err));
+        pPa_CloseStream(data->stream);
+        device->ExtraData = NULL;
+        free(data);
+        return ALC_FALSE;
+    }
+
+    device->UpdateSize /= periods;
+    return ALC_TRUE;
+}
+
+static void pa_close_playback(ALCdevice *device)
+{
+    pa_data *data = (pa_data*)device->ExtraData;
+    PaError err;
+
+    err = pPa_StopStream(data->stream);
+    if(err != paNoError)
+      fprintf(stderr, "Error stopping stream: %s\n", pPa_GetErrorText(err));
+
+    err = pPa_CloseStream(data->stream);
+    if(err != paNoError)
+        fprintf(stderr, "Error closing stream: %s\n", pPa_GetErrorText(err));
+
+    free(data);
+    device->ExtraData = NULL;
+}
+
+
+static ALCboolean pa_open_capture(ALCdevice *device, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
+{
+    return ALC_FALSE;
+    (void)device;
+    (void)deviceName;
+    (void)frequency;
+    (void)format;
+    (void)SampleSize;
+}
+
+
+
+static const BackendFuncs pa_funcs = {
+    pa_open_playback,
+    pa_close_playback,
+    pa_open_capture,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+void alc_pa_init(BackendFuncs *func_list)
+{
+    const char *str;
+    PaError err;
+
+    *func_list = pa_funcs;
+
+#ifdef HAVE_DLFCN_H
+#if defined(__APPLE__) && defined(__MACH__)
+# define PALIB "libportaudio.2.dylib"
+#else
+# define PALIB "libportaudio.so.2"
+#endif
+    pa_handle = dlopen(PALIB, RTLD_NOW);
+    if(!pa_handle)
+        return;
+    dlerror();
+
+#define LOAD_FUNC(f) do { \
+    p##f = (typeof(f)*)dlsym(pa_handle, #f); \
+    if((str=dlerror()) != NULL) \
+    { \
+        dlclose(pa_handle); \
+        pa_handle = NULL; \
+        AL_PRINT("Could not load %s from "PALIB": %s\n", #f, str); \
+        return; \
+    } \
+} while(0)
+#else
+    str = NULL;
+    pa_handle = (void*)0xDEADBEEF;
+#define LOAD_FUNC(f) p##f = f
+#endif
+
+    LOAD_FUNC(Pa_Initialize);
+    LOAD_FUNC(Pa_GetErrorText);
+    LOAD_FUNC(Pa_StartStream);
+    LOAD_FUNC(Pa_StopStream);
+    LOAD_FUNC(Pa_OpenStream);
+    LOAD_FUNC(Pa_CloseStream);
+    LOAD_FUNC(Pa_GetDefaultOutputDevice);
+#undef LOAD_FUNC
+
+    if((err=pPa_Initialize()) != paNoError)
+    {
+        AL_PRINT("Pa_Initialize() returned an error: %s\n", pPa_GetErrorText(err));
+        return;
+    }
+
+    pa_device = AppendDeviceList("PortAudio Software");
+    AppendAllDeviceList(pa_device);
+}

Alc/pulseaudio.c

@@ -0,0 +1,595 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2009 by Konstantinos Natsakis <konstantinos.natsakis@gmail.com>
+ * 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 "alMain.h"
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <pulse/pulseaudio.h>
+
+#if PA_API_VERSION == 11
+#define PA_STREAM_ADJUST_LATENCY 0x2000U
+static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x)
+{
+    return (x == PA_STREAM_CREATING || x == PA_STREAM_READY);
+}
+static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x)
+{
+    return (x == PA_CONTEXT_CONNECTING || x == PA_CONTEXT_AUTHORIZING ||
+            x == PA_CONTEXT_SETTING_NAME || x == PA_CONTEXT_READY);
+}
+#define PA_STREAM_IS_GOOD PA_STREAM_IS_GOOD
+#define PA_CONTEXT_IS_GOOD PA_CONTEXT_IS_GOOD
+#elif PA_API_VERSION != 12
+#error Invalid PulseAudio API version
+#endif
+
+static void *pa_handle;
+#define MAKE_FUNC(x) static typeof(x) * p##x
+MAKE_FUNC(pa_context_unref);
+MAKE_FUNC(pa_sample_spec_valid);
+MAKE_FUNC(pa_stream_drop);
+MAKE_FUNC(pa_strerror);
+MAKE_FUNC(pa_context_get_state);
+MAKE_FUNC(pa_stream_get_state);
+MAKE_FUNC(pa_threaded_mainloop_signal);
+MAKE_FUNC(pa_stream_peek);
+MAKE_FUNC(pa_threaded_mainloop_wait);
+MAKE_FUNC(pa_threaded_mainloop_unlock);
+MAKE_FUNC(pa_context_new);
+MAKE_FUNC(pa_threaded_mainloop_stop);
+MAKE_FUNC(pa_context_disconnect);
+MAKE_FUNC(pa_threaded_mainloop_start);
+MAKE_FUNC(pa_threaded_mainloop_get_api);
+MAKE_FUNC(pa_context_set_state_callback);
+MAKE_FUNC(pa_stream_write);
+MAKE_FUNC(pa_xfree);
+MAKE_FUNC(pa_stream_connect_record);
+MAKE_FUNC(pa_stream_connect_playback);
+MAKE_FUNC(pa_path_get_filename);
+MAKE_FUNC(pa_get_binary_name);
+MAKE_FUNC(pa_threaded_mainloop_free);
+MAKE_FUNC(pa_context_errno);
+MAKE_FUNC(pa_xmalloc0);
+MAKE_FUNC(pa_stream_unref);
+MAKE_FUNC(pa_threaded_mainloop_accept);
+MAKE_FUNC(pa_stream_set_write_callback);
+MAKE_FUNC(pa_threaded_mainloop_new);
+MAKE_FUNC(pa_context_connect);
+MAKE_FUNC(pa_stream_set_read_callback);
+MAKE_FUNC(pa_stream_set_state_callback);
+MAKE_FUNC(pa_stream_new);
+MAKE_FUNC(pa_stream_disconnect);
+MAKE_FUNC(pa_threaded_mainloop_lock);
+#undef MAKE_FUNC
+
+typedef struct {
+    ALCdevice *device;
+
+    ALCenum format;
+    ALCuint samples;
+    ALCuint frequency;
+    ALCuint frame_size;
+
+    RingBuffer *ring;
+
+    pa_buffer_attr attr;
+    pa_sample_spec spec;
+
+    char path_name[PATH_MAX];
+    const char *context_name;
+    const char *stream_name;
+
+    pa_threaded_mainloop *loop;
+
+    pa_stream *stream;
+    pa_context *context;
+} pulse_data;
+
+static char *pulse_device;
+static char *pulse_capture_device;
+
+// PulseAudio Event Callbacks {{{
+static void stream_state_callback(pa_stream *stream, void *pdata) //{{{
+{
+    pulse_data *data = pdata;
+
+    switch(ppa_stream_get_state(stream))
+	{
+		case PA_STREAM_READY:
+            AL_PRINT("%s: %s ready!\n", data->context_name, data->stream_name);
+			break;
+
+		case PA_STREAM_FAILED:
+            AL_PRINT("%s: %s: Connection failed: %s\n", data->context_name,
+                     data->stream_name, ppa_strerror(ppa_context_errno(data->context)));
+			break;
+
+		case PA_STREAM_TERMINATED:
+            AL_PRINT("%s: %s terminated!\n", data->context_name, data->stream_name);
+			break;
+
+		default:
+			break;
+	}
+
+    ppa_threaded_mainloop_signal(data->loop, 1);
+} //}}}
+
+static void context_state_callback(pa_context *context, void *pdata) //{{{
+{
+    pulse_data *data = pdata;
+
+    switch(ppa_context_get_state(context))
+	{
+		case PA_CONTEXT_READY:
+            AL_PRINT("%s ready!\n", data->context_name);
+			break;
+
+		case PA_CONTEXT_FAILED:
+            AL_PRINT("%s: Connection failed: %s\n", data->context_name,
+                     ppa_strerror(ppa_context_errno(context)));
+            break;
+
+		case PA_CONTEXT_TERMINATED:
+            AL_PRINT("%s terminated!\n", data->context_name);
+			break;
+
+		default:
+			break;
+	}
+
+    ppa_threaded_mainloop_signal(data->loop, 1);
+} //}}}
+//}}}
+
+// PulseAudio I/O Callbacks //{{{
+static void stream_write_callback(pa_stream *stream, size_t len, void *pdata) //{{{
+{
+    ALCdevice *Device = pdata;
+    void *buf = ppa_xmalloc0(len);
+
+    SuspendContext(NULL);
+    aluMixData(Device->Context, buf, len, Device->Format);
+    ProcessContext(NULL);
+
+    ppa_stream_write(stream, buf, len, ppa_xfree, 0, PA_SEEK_RELATIVE);
+} //}}}
+
+static void stream_read_callback(pa_stream *stream, size_t length, void *pdata) //{{{
+{
+    ALCdevice *Device = pdata;
+    pulse_data *data = Device->ExtraData;
+    const void *buf;
+
+    if(ppa_stream_peek(stream, &buf, &length) < 0)
+    {
+        AL_PRINT("pa_stream_peek() failed: %s\n",
+                 ppa_strerror(ppa_context_errno(data->context)));
+        return;
+    }
+
+    assert(buf);
+    assert(length);
+
+    length /= data->frame_size;
+
+    if(data->samples < length)
+        AL_PRINT("stream_read_callback: buffer overflow!\n");
+
+    WriteRingBuffer(data->ring, buf, (length<data->samples) ? length : data->samples);
+
+    ppa_stream_drop(stream);
+} //}}}
+//}}}
+
+static ALCboolean pulse_open(ALCdevice *device, ALCchar *device_name, ALCenum format, ALCuint samples, ALCuint frequency) //{{{
+{
+    pulse_data *data = ppa_xmalloc0(sizeof(pulse_data));
+
+    data->device = device;
+    data->format = format;
+    data->samples = samples;
+    data->frequency = frequency;
+    data->frame_size = aluBytesFromFormat(format) * aluChannelsFromFormat(format);
+
+    if(ppa_get_binary_name(data->path_name, sizeof(data->path_name)))
+        data->context_name = ppa_path_get_filename(data->path_name);
+    else
+        data->context_name = "OpenAL Soft";
+
+    if(!(data->ring = CreateRingBuffer(data->frame_size, data->samples)))
+    {
+        ppa_xfree(data);
+        return ALC_FALSE;
+    }
+
+    device->ExtraData = data;
+    device->szDeviceName = device_name;
+
+    data->attr.minreq = -1;
+    data->attr.prebuf = -1;
+    data->attr.maxlength = -1;
+
+    if(device->IsCaptureDevice)
+    {
+        data->attr.tlength = -1;
+        data->attr.fragsize = data->frame_size * data->samples / 2;
+        data->stream_name = "Capture Stream";
+    }
+    else
+    {
+        data->attr.tlength = data->frame_size * (device->UpdateSize&~3);
+        data->attr.fragsize = -1;
+        data->stream_name = "Playback Stream";
+    }
+
+    data->spec.rate = data->frequency;
+    data->spec.channels = aluChannelsFromFormat(data->format);
+
+    switch(aluBytesFromFormat(data->format))
+    {
+        case 1:
+            data->spec.format = PA_SAMPLE_U8;
+            break;
+        case 2:
+            data->spec.format = PA_SAMPLE_S16NE;
+            break;
+        default:
+            AL_PRINT("Unknown format: %x\n", data->format);
+			goto out2;
+    }
+
+    if(ppa_sample_spec_valid(&data->spec) == 0)
+    {
+        AL_PRINT("Invalid sample format\n");
+		goto out2;
+    }
+
+    if(!(data->loop = ppa_threaded_mainloop_new()))
+    {
+        AL_PRINT("pa_threaded_mainloop_new() failed!\n");
+		goto out2;
+    }
+
+    if(ppa_threaded_mainloop_start(data->loop) < 0)
+    {
+        AL_PRINT("pa_threaded_mainloop_start() failed\n");
+		goto out3;
+    }
+
+    ppa_threaded_mainloop_lock(data->loop);
+
+    data->context = ppa_context_new(ppa_threaded_mainloop_get_api(data->loop), data->context_name);
+    if(!data->context)
+    {
+        AL_PRINT("pa_context_new() failed: %s\n",
+                 ppa_strerror(ppa_context_errno(data->context)));
+
+        ppa_threaded_mainloop_unlock(data->loop);
+		goto out3;
+    }
+
+    ppa_context_set_state_callback(data->context, context_state_callback, data);
+
+    if(ppa_context_connect(data->context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0)
+    {
+        AL_PRINT("Context did not connect: %s\n",
+                 ppa_strerror(ppa_context_errno(data->context)));
+
+        ppa_context_unref(data->context);
+        ppa_threaded_mainloop_unlock(data->loop);
+
+        data->context = NULL;
+		goto out3;
+    }
+
+    while(ppa_context_get_state(data->context) != PA_CONTEXT_READY)
+    {
+        if(!PA_CONTEXT_IS_GOOD(ppa_context_get_state(data->context)))
+        {
+            ppa_context_unref(data->context);
+            ppa_threaded_mainloop_unlock(data->loop);
+
+            data->context = NULL;
+			goto out3;
+        }
+
+        ppa_threaded_mainloop_wait(data->loop);
+        ppa_threaded_mainloop_accept(data->loop);
+    }
+
+    data->stream = ppa_stream_new(data->context, data->stream_name, &data->spec, NULL);
+    if(!data->stream)
+    {
+        AL_PRINT("pa_stream_new() failed: %s\n",
+                 ppa_strerror(ppa_context_errno(data->context)));
+
+        ppa_threaded_mainloop_unlock(data->loop);
+		goto out4;
+    }
+
+    ppa_stream_set_state_callback(data->stream, stream_state_callback, data);
+
+    if(device->IsCaptureDevice)
+    {
+        if(ppa_stream_connect_record(data->stream, NULL, &data->attr, PA_STREAM_ADJUST_LATENCY) < 0)
+        {
+            AL_PRINT("Stream did not connect: %s\n",
+                     ppa_strerror(ppa_context_errno(data->context)));
+
+            ppa_stream_unref(data->stream);
+            ppa_threaded_mainloop_unlock(data->loop);
+
+            data->stream = NULL;
+			goto out4;
+        }
+    }
+    else
+    {
+        ppa_stream_set_write_callback(data->stream, stream_write_callback, device);
+
+        if(ppa_stream_connect_playback(data->stream, NULL, &data->attr, PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0)
+        {
+            AL_PRINT("Stream did not connect: %s\n",
+                     ppa_strerror(ppa_context_errno(data->context)));
+
+            ppa_stream_unref(data->stream);
+            ppa_threaded_mainloop_unlock(data->loop);
+
+            data->stream = NULL;
+			goto out4;
+        }
+    }
+
+    while(ppa_stream_get_state(data->stream) != PA_STREAM_READY)
+    {
+        if(!PA_STREAM_IS_GOOD(ppa_stream_get_state(data->stream)))
+        {
+            ppa_stream_unref(data->stream);
+            ppa_threaded_mainloop_unlock(data->loop);
+
+            data->stream = NULL;
+			goto out4;
+        }
+
+        ppa_threaded_mainloop_wait(data->loop);
+        ppa_threaded_mainloop_accept(data->loop);
+    }
+
+    device->UpdateSize /= 4;
+    ppa_threaded_mainloop_unlock(data->loop);
+
+    return ALC_TRUE;
+
+out4:
+    ppa_threaded_mainloop_lock(data->loop);
+
+    ppa_context_disconnect(data->context);
+    ppa_context_unref(data->context);
+
+    ppa_threaded_mainloop_unlock(data->loop);
+out3:
+    ppa_threaded_mainloop_stop(data->loop);
+    ppa_threaded_mainloop_free(data->loop);
+out2:
+    device->ExtraData = NULL;
+    device->szDeviceName = NULL;
+    DestroyRingBuffer(data->ring);
+
+    ppa_xfree(data);
+    return ALC_FALSE;
+} //}}}
+
+static void pulse_close(ALCdevice *device) //{{{
+{
+    pulse_data *data = device->ExtraData;
+
+    ppa_threaded_mainloop_lock(data->loop);
+
+    ppa_stream_disconnect(data->stream);
+    ppa_stream_unref(data->stream);
+
+    ppa_context_disconnect(data->context);
+    ppa_context_unref(data->context);
+
+    ppa_threaded_mainloop_unlock(data->loop);
+
+    ppa_threaded_mainloop_stop(data->loop);
+    ppa_threaded_mainloop_free(data->loop);
+
+    device->ExtraData = NULL;
+    device->szDeviceName = NULL;
+    DestroyRingBuffer(data->ring);
+
+    ppa_xfree(data);
+} //}}}
+//}}}
+
+// OpenAL {{{
+static ALCboolean pulse_open_playback(ALCdevice *device, const ALCchar *device_name) //{{{
+{
+    if(!pa_handle)
+        return ALC_FALSE;
+
+    if(device_name)
+    {
+        if(strcmp(device_name, pulse_device) != 0)
+            return ALC_FALSE;
+    }
+
+    return pulse_open(device, pulse_device, device->Format, 0, device->Frequency);
+} //}}}
+
+static void pulse_close_playback(ALCdevice *device) //{{{
+{
+    pulse_close(device);
+} //}}}
+
+static ALCboolean pulse_open_capture(ALCdevice *device, const ALCchar *device_name, ALCuint frequency, ALCenum format, ALCsizei samples) //{{{
+{
+    if(!pa_handle)
+        return ALC_FALSE;
+
+    if(device_name)
+    {
+        if(strcmp(device_name, pulse_capture_device) != 0)
+            return ALC_FALSE;
+    }
+
+    return pulse_open(device, pulse_capture_device, format, samples, frequency);
+} //}}}
+
+static void pulse_close_capture(ALCdevice *device) //{{{
+{
+    pulse_close(device);
+} //}}}
+
+static void pulse_start_capture(ALCdevice *device) //{{{
+{
+    pulse_data *data = device->ExtraData;
+
+    ppa_threaded_mainloop_lock(data->loop);
+    ppa_stream_set_read_callback(data->stream, stream_read_callback, device);
+    ppa_threaded_mainloop_unlock(data->loop);
+} //}}}
+
+static void pulse_stop_capture(ALCdevice *device) //{{{
+{
+    pulse_data *data = device->ExtraData;
+
+    ppa_threaded_mainloop_lock(data->loop);
+    ppa_stream_set_read_callback(data->stream, NULL, NULL);
+    ppa_threaded_mainloop_unlock(data->loop);
+} //}}}
+
+static void pulse_capture_samples(ALCdevice *device, ALCvoid *buffer, ALCuint samples) //{{{
+{
+    pulse_data *data = device->ExtraData;
+    ALCuint available = RingBufferSize(data->ring);
+
+    if(available < samples)
+        SetALCError(ALC_INVALID_VALUE);
+    else
+        ReadRingBuffer(data->ring, buffer, samples);
+} //}}}
+
+static ALCuint pulse_available_samples(ALCdevice *device) //{{{
+{
+    pulse_data *data = device->ExtraData;
+    return RingBufferSize(data->ring);
+} //}}}
+
+BackendFuncs pulse_funcs = { //{{{
+    pulse_open_playback,
+    pulse_close_playback,
+    pulse_open_capture,
+    pulse_close_capture,
+    pulse_start_capture,
+    pulse_stop_capture,
+    pulse_capture_samples,
+    pulse_available_samples
+}; //}}}
+
+void alc_pulse_init(BackendFuncs *func_list) //{{{
+{
+    *func_list = pulse_funcs;
+
+#ifdef _WIN32
+    pa_handle = LoadLibrary("libpulse-0.dll");
+#define LOAD_FUNC(x) do { \
+    p##x = GetProcAddress(pa_handle, #x); \
+    if(!(p##x)) { \
+        FreeLibrary(pa_handle); \
+        pa_handle = NULL; \
+        return; \
+    } \
+} while(0)
+
+#elif defined (HAVE_DLFCN_H)
+
+#if defined(__APPLE__) && defined(__MACH__)
+    pa_handle = dlopen("libpulse.0.dylib", RTLD_NOW);
+#else
+    pa_handle = dlopen("libpulse.so.0", RTLD_NOW);
+#endif
+#define LOAD_FUNC(x) do { \
+    p##x = dlsym(pa_handle, #x); \
+    if(!(p##x)) { \
+        dlclose(pa_handle); \
+        pa_handle = NULL; \
+        return; \
+    } \
+} while(0)
+
+#else
+
+    pa_handle = (void*)0xDEADBEEF;
+#define LOAD_FUNC(x) p##x = (x)
+
+#endif
+
+LOAD_FUNC(pa_context_unref);
+LOAD_FUNC(pa_sample_spec_valid);
+LOAD_FUNC(pa_stream_drop);
+LOAD_FUNC(pa_strerror);
+LOAD_FUNC(pa_context_get_state);
+LOAD_FUNC(pa_stream_get_state);
+LOAD_FUNC(pa_threaded_mainloop_signal);
+LOAD_FUNC(pa_stream_peek);
+LOAD_FUNC(pa_threaded_mainloop_wait);
+LOAD_FUNC(pa_threaded_mainloop_unlock);
+LOAD_FUNC(pa_context_new);
+LOAD_FUNC(pa_threaded_mainloop_stop);
+LOAD_FUNC(pa_context_disconnect);
+LOAD_FUNC(pa_threaded_mainloop_start);
+LOAD_FUNC(pa_threaded_mainloop_get_api);
+LOAD_FUNC(pa_context_set_state_callback);
+LOAD_FUNC(pa_stream_write);
+LOAD_FUNC(pa_xfree);
+LOAD_FUNC(pa_stream_connect_record);
+LOAD_FUNC(pa_stream_connect_playback);
+LOAD_FUNC(pa_path_get_filename);
+LOAD_FUNC(pa_get_binary_name);
+LOAD_FUNC(pa_threaded_mainloop_free);
+LOAD_FUNC(pa_context_errno);
+LOAD_FUNC(pa_xmalloc0);
+LOAD_FUNC(pa_stream_unref);
+LOAD_FUNC(pa_threaded_mainloop_accept);
+LOAD_FUNC(pa_stream_set_write_callback);
+LOAD_FUNC(pa_threaded_mainloop_new);
+LOAD_FUNC(pa_context_connect);
+LOAD_FUNC(pa_stream_set_read_callback);
+LOAD_FUNC(pa_stream_set_state_callback);
+LOAD_FUNC(pa_stream_new);
+LOAD_FUNC(pa_stream_disconnect);
+LOAD_FUNC(pa_threaded_mainloop_lock);
+
+#undef LOAD_FUNC
+
+    pulse_device = AppendDeviceList("PulseAudio Software");
+    AppendAllDeviceList(pulse_device);
+
+    pulse_capture_device = AppendCaptureDeviceList("PulseAudio Capture");
+} //}}}
+//}}}

Alc/solaris.c

@@ -0,0 +1,258 @@
+/**
+ * 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 "AL/al.h"
+#include "AL/alc.h"
+
+#include <sys/audioio.h>
+
+
+static char *solaris_device;
+
+typedef struct {
+    int fd;
+    volatile int killNow;
+    ALvoid *thread;
+
+    ALubyte *mix_data;
+    int data_size;
+} solaris_data;
+
+
+static ALuint SolarisProc(ALvoid *ptr)
+{
+    ALCdevice *pDevice = (ALCdevice*)ptr;
+    solaris_data *data = (solaris_data*)pDevice->ExtraData;
+    int remaining = 0;
+    int wrote;
+
+    while(!data->killNow)
+    {
+        int len = data->data_size - remaining;
+
+        if(len > 0)
+        {
+            SuspendContext(NULL);
+            aluMixData(pDevice->Context, data->mix_data+remaining, len, pDevice->Format);
+            ProcessContext(NULL);
+        }
+
+        remaining += len;
+        wrote = write(data->fd, data->mix_data, remaining);
+        if(wrote < 0)
+        {
+            AL_PRINT("write failed: %s\n", strerror(errno));
+            remaining = 0;
+        }
+        else if(wrote > 0)
+        {
+            remaining -= wrote;
+            if(remaining > 0)
+                memmove(data->mix_data, data->mix_data+wrote, remaining);
+        }
+        else
+            Sleep(1);
+    }
+
+    return 0;
+}
+
+
+static ALCboolean solaris_open_playback(ALCdevice *device, const ALCchar *deviceName)
+{
+    audio_info_t info;
+    ALuint frameSize;
+    char driver[64];
+    int numChannels;
+    solaris_data *data;
+
+    strncpy(driver, GetConfigValue("solaris", "device", "/dev/audio"), sizeof(driver)-1);
+    driver[sizeof(driver)-1] = 0;
+    if(deviceName)
+    {
+        if(strcmp(deviceName, solaris_device))
+            return ALC_FALSE;
+        device->szDeviceName = solaris_device;
+    }
+    else
+        device->szDeviceName = solaris_device;
+
+    data = (solaris_data*)calloc(1, sizeof(solaris_data));
+    data->killNow = 0;
+
+    data->fd = open(driver, O_WRONLY);
+    if(data->fd == -1)
+    {
+        free(data);
+        AL_PRINT("Could not open %s: %s\n", driver, strerror(errno));
+        return ALC_FALSE;
+    }
+
+    numChannels = aluChannelsFromFormat(device->Format);
+    AUDIO_INITINFO(&info);
+    info.play.sample_rate = device->Frequency;
+    info.play.channels = numChannels;
+
+    switch(aluBytesFromFormat(device->Format))
+    {
+        case 1:
+            info.play.precision = 8;
+            info.play.encoding = AUDIO_ENCODING_LINEAR8;
+            break;
+        case 2:
+            info.play.precision = 16;
+            info.play.encoding = AUDIO_ENCODING_LINEAR;
+            break;
+        default:
+            AL_PRINT("Unknown format?! %x\n", device->Format);
+    }
+
+    frameSize = numChannels * aluBytesFromFormat(device->Format);
+    info.play.buffer_size = device->UpdateSize * frameSize;
+
+    if(ioctl(data->fd, AUDIO_SETINFO, &info) < 0)
+    {
+        AL_PRINT("ioctl failed: %s\n", strerror(errno));
+        close(data->fd);
+        free(data);
+        return ALC_FALSE;
+    }
+
+    device->Frequency = info.play.sample_rate;
+
+    if(aluChannelsFromFormat(device->Format) != info.play.channels)
+    {
+        AL_PRINT("Could not set %d channels, got %d instead\n", aluChannelsFromFormat(device->Format), info.play.channels);
+        close(data->fd);
+        free(data);
+        return ALC_FALSE;
+    }
+
+    if(!((info.play.precision == 8 && aluBytesFromFormat(device->Format) == 1) ||
+         (info.play.precision == 16 && aluBytesFromFormat(device->Format) == 2)))
+    {
+        AL_PRINT("Could not set %d-bit output, got %d\n", aluBytesFromFormat(device->Format)*8, info.play.precision);
+        close(data->fd);
+        free(data);
+        return ALC_FALSE;
+    }
+
+    device->UpdateSize = info.play.buffer_size / 4;
+
+    data->data_size = device->UpdateSize * frameSize;
+    data->mix_data = calloc(1, data->data_size);
+
+    device->ExtraData = data;
+    data->thread = StartThread(SolarisProc, device);
+    if(data->thread == NULL)
+    {
+        device->ExtraData = NULL;
+        free(data->mix_data);
+        free(data);
+        return ALC_FALSE;
+    }
+
+    return ALC_TRUE;
+}
+
+static void solaris_close_playback(ALCdevice *device)
+{
+    solaris_data *data = (solaris_data*)device->ExtraData;
+    data->killNow = 1;
+    StopThread(data->thread);
+
+    close(data->fd);
+
+    free(data->mix_data);
+    free(data);
+    device->ExtraData = NULL;
+}
+
+
+static ALCboolean solaris_open_capture(ALCdevice *device, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
+{
+    (void)device;
+    (void)deviceName;
+    (void)frequency;
+    (void)format;
+    (void)SampleSize;
+    return ALC_FALSE;
+}
+
+static void solaris_close_capture(ALCdevice *device)
+{
+    (void)device;
+}
+
+static void solaris_start_capture(ALCdevice *pDevice)
+{
+    (void)pDevice;
+}
+
+static void solaris_stop_capture(ALCdevice *pDevice)
+{
+    (void)pDevice;
+}
+
+static void solaris_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
+{
+    (void)pDevice;
+    (void)pBuffer;
+    (void)lSamples;
+}
+
+static ALCuint solaris_available_samples(ALCdevice *pDevice)
+{
+    (void)pDevice;
+    return 0;
+}
+
+
+BackendFuncs solaris_funcs = {
+    solaris_open_playback,
+    solaris_close_playback,
+    solaris_open_capture,
+    solaris_close_capture,
+    solaris_start_capture,
+    solaris_stop_capture,
+    solaris_capture_samples,
+    solaris_available_samples
+};
+
+void alc_solaris_init(BackendFuncs *func_list)
+{
+    *func_list = solaris_funcs;
+
+    solaris_device = AppendDeviceList("Solaris Software");
+    AppendAllDeviceList(solaris_device);
+}

Alc/wave.c

@@ -35,7 +35,7 @@ typedef struct {
     ALvoid *buffer;
     ALuint size;
 
-    int killNow;
+    volatile int killNow;
     ALvoid *thread;
 } wave_data;
 
@@ -50,6 +50,7 @@ static ALuint WaveProc(ALvoid *ptr)
     ALuint frameSize;
     ALuint now, last;
     size_t WriteCnt;
+    size_t fs;
     ALuint avail;
     union {
         short s;
@@ -89,7 +90,7 @@ static ALuint WaveProc(ALvoid *ptr)
                     fputc(bytes[i^1], data->f);
             }
             else
-                fwrite(data->buffer, frameSize, WriteCnt, data->f);
+                fs = fwrite(data->buffer, frameSize, WriteCnt, data->f);
             if(ferror(data->f))
             {
                 AL_PRINT("Error writing to file\n");

CMakeLists.txt

@@ -1,15 +1,22 @@
 # CMake build file list for OpenAL
 
+CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
+
+IF(COMMAND CMAKE_POLICY)
+  CMAKE_POLICY(SET CMP0003 NEW)
+ENDIF(COMMAND CMAKE_POLICY)
+
 INCLUDE(CheckFunctionExists)
 INCLUDE(CheckLibraryExists)
 INCLUDE(CheckIncludeFile)
 INCLUDE(CheckIncludeFiles)
+INCLUDE(CheckSymbolExists)
 INCLUDE(CheckCCompilerFlag)
 INCLUDE(CheckCSourceCompiles)
 INCLUDE(CheckTypeSize)
 
 
-PROJECT(OpenAL)
+PROJECT(OpenAL C)
 
 
 SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS TRUE)
@@ -17,8 +24,11 @@ SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS TRUE)
 
 OPTION(ALSA    "Check for ALSA backend"                ON)
 OPTION(OSS     "Check for OSS backend"                 ON)
+OPTION(SOLARIS "Check for Solaris backend"             ON)
 OPTION(DSOUND  "Check for DirectSound backend"         ON)
 OPTION(WINMM   "Check for Windows Multimedia backend"  ON)
+OPTION(PORTAUDIO  "Check for PortAudio backend"        ON)
+OPTION(PULSEAUDIO "Check for PulseAudio backend"       ON)
 
 OPTION(DLOPEN  "Check for the dlopen API for loading optional libs"  ON)
 
@@ -26,11 +36,23 @@ OPTION(WERROR  "Treat compile warnings as errors"      OFF)
 
 OPTION(EXAMPLES  "Build example programs"              ON)
 
+OPTION(ALSOFT_CONFIG "Install alsoft.conf configuration file" OFF)
+
+
+IF(WIN32)
+    SET(LIBNAME OpenAL32)
+    ADD_DEFINITIONS("-D_WIN32")
+ELSE()
+    SET(LIBNAME openal)
+ENDIF()
 
 SET(LIB_MAJOR_VERSION "1")
-SET(LIB_MINOR_VERSION "4")
-SET(LIB_BUILD_VERSION "270")
+SET(LIB_MINOR_VERSION "8")
+SET(LIB_BUILD_VERSION "466")
 SET(LIB_VERSION "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_BUILD_VERSION}")
+IF(NOT DEFINED LIB_INSTALL_DIR)
+  SET(LIB_INSTALL_DIR "lib${LIB_SUFFIX}")
+ENDIF(NOT DEFINED LIB_INSTALL_DIR)
 
 
 CHECK_TYPE_SIZE("long" SIZEOF_LONG)
@@ -47,6 +69,11 @@ IF(NOT CMAKE_BUILD_TYPE)
         "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
         FORCE)
 ENDIF()
+IF(NOT CMAKE_DEBUG_POSTFIX)
+    SET(CMAKE_DEBUG_POSTFIX "" CACHE STRING
+        "Library postfix for debug builds. Normally left blank."
+        FORCE)
+ENDIF()
 
 IF(MSVC)
     # ???
@@ -54,10 +81,11 @@ IF(MSVC)
     SET(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} -DNDEBUG")
     SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DNDEBUG")
     SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -D_DEBUG")
+    ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
 ELSE()
     ADD_DEFINITIONS(-Wall)
     CHECK_C_COMPILER_FLAG(-Wextra HAVE_W_EXTRA)
-    IF("${HAVE_W_EXTRA}")
+    IF(HAVE_W_EXTRA)
         ADD_DEFINITIONS(-Wextra)
     ENDIF()
 
@@ -84,23 +112,31 @@ ELSE()
                                  int main() {return 0;}" HAVE_GCC_DESTRUCTOR)
 
         CHECK_C_COMPILER_FLAG(-fvisibility=hidden HAVE_VISIBILITY_SWITCH)
-        IF("${HAVE_VISIBILITY_SWITCH}")
+        IF(HAVE_VISIBILITY_SWITCH)
             CHECK_C_SOURCE_COMPILES("int foo() __attribute__((visibility(\"default\")));
                                      int main() {return 0;}" HAVE_GCC_VISIBILITY)
-            IF("${HAVE_GCC_VISIBILITY}")
+            IF(HAVE_GCC_VISIBILITY)
                 ADD_DEFINITIONS(-fvisibility=hidden -DHAVE_GCC_VISIBILITY)
             ENDIF()
         ENDIF()
     ENDIF()
 ENDIF()
 
+CHECK_INCLUDE_FILE(fenv.h HAVE_FENV_H)
+CHECK_INCLUDE_FILE(float.h HAVE_FLOAT_H)
 
 CHECK_LIBRARY_EXISTS(m  sqrtf  "" HAVE_SQRTF)
 CHECK_LIBRARY_EXISTS(m  acosf  "" HAVE_ACOSF)
-IF(HAVE_SQRTF OR HAVE_ACOSF)
+CHECK_LIBRARY_EXISTS(m  atanf  "" HAVE_ATANF)
+CHECK_LIBRARY_EXISTS(m  fabsf  "" HAVE_FABSF)
+IF(HAVE_FENV_H)
+    CHECK_LIBRARY_EXISTS(m  fesetround  "" HAVE_FESETROUND)
+ENDIF()
+IF(HAVE_SQRTF OR HAVE_ACOSF OR HAVE_ATANF OR HAVE_FABSF OR HAVE_FESETROUND)
     SET(EXTRA_LIBS m ${EXTRA_LIBS})
 ENDIF()
 CHECK_FUNCTION_EXISTS(strtof HAVE_STRTOF)
+CHECK_FUNCTION_EXISTS(_controlfp HAVE__CONTROLFP)
 
 CHECK_FUNCTION_EXISTS(strcasecmp HAVE_STRCASECMP)
 IF(NOT HAVE_STRCASECMP)
@@ -132,6 +168,27 @@ IF(NOT HAVE_SNPRINTF)
     ADD_DEFINITIONS(-Dsnprintf=_snprintf)
 ENDIF()
 
+CHECK_FUNCTION_EXISTS(vsnprintf HAVE_VSNPRINTF)
+IF(NOT HAVE_VSNPRINTF)
+    CHECK_FUNCTION_EXISTS(_vsnprintf HAVE__VSNPRINTF)
+    IF(NOT HAVE__VSNPRINTF)
+        MESSAGE(FATAL_ERROR "No vsnprintf function found, please report!")
+    ENDIF()
+
+    ADD_DEFINITIONS(-Dvsnprintf=_vsnprintf)
+ENDIF()
+
+CHECK_SYMBOL_EXISTS(isnan math.h HAVE_ISNAN)
+IF(NOT HAVE_ISNAN)
+    CHECK_FUNCTION_EXISTS(_isnan HAVE__ISNAN)
+    IF(NOT HAVE__ISNAN)
+        MESSAGE(FATAL_ERROR "No isnan function found, please report!")
+    ENDIF()
+
+    ADD_DEFINITIONS(-Disnan=_isnan)
+ENDIF()
+
+
 # Check for the dlopen API (for dynamicly loading backend libs)
 IF(DLOPEN)
     CHECK_INCLUDE_FILE(dlfcn.h HAVE_DLFCN_H)
@@ -203,11 +260,12 @@ SET(OPENAL_OBJS  OpenAL32/alAuxEffectSlot.c
                  OpenAL32/alSource.c
                  OpenAL32/alState.c
                  OpenAL32/alThunk.c
-                 OpenAL32/OpenAL32.c
 )
 SET(ALC_OBJS  Alc/ALc.c
               Alc/ALu.c
               Alc/alcConfig.c
+              Alc/alcEcho.c
+              Alc/alcReverb.c
               Alc/alcRing.c
               Alc/alcThread.c
               Alc/bs2b.c
@@ -244,24 +302,35 @@ IF(OSS)
     ENDIF()
 ENDIF()
 
+# Check Solaris backend
+IF(SOLARIS)
+    CHECK_INCLUDE_FILE(sys/audioio.h HAVE_SYS_AUDIOIO_H)
+    IF(HAVE_SYS_AUDIOIO_H)
+        SET(HAVE_SOLARIS 1)
+        SET(ALC_OBJS  ${ALC_OBJS} Alc/solaris.c)
+        SET(BACKENDS  "${BACKENDS} Solaris,")
+    ENDIF()
+ENDIF()
+
 # Check DSound/MMSystem backend
-IF(HAVE_WINDOWS_H)
-    IF(DSOUND)
-        CHECK_INCLUDE_FILE(dsound.h HAVE_DSOUND_H)
-        IF(HAVE_DSOUND_H)
+IF(DSOUND)
+    CHECK_INCLUDE_FILE(dsound.h HAVE_DSOUND_H)
+    IF(HAVE_DSOUND_H)
+        CHECK_LIBRARY_EXISTS(dsound DirectSoundCreate "" HAVE_LIBDSOUND)
+        IF(HAVE_LIBDSOUND OR WIN32)
             SET(HAVE_DSOUND 1)
             SET(ALC_OBJS  ${ALC_OBJS} Alc/dsound.c)
-            SET(BACKENDS  "${BACKENDS} DirectSound,")
 
-            SET(CMAKE_REQUIRED_LIBRARIES dsound)
-            CHECK_C_SOURCE_COMPILES("int main() {return 0;}" HAVE_LIBDSOUND)
-            SET(CMAKE_REQUIRED_LIBRARIES "")
-#            CHECK_LIBRARY_EXISTS(dsound DirectSoundCreate "" HAVE_LIBDSOUND)
-            IF(HAVE_LIBDSOUND)
+            IF(WIN32)
+                SET(BACKENDS  "${BACKENDS} DirectSound,")
+            ELSE()
+                SET(BACKENDS  "${BACKENDS} DirectSound \(linked\),")
                 SET(EXTRA_LIBS dsound ${EXTRA_LIBS})
             ENDIF()
         ENDIF()
     ENDIF()
+ENDIF()
+IF(HAVE_WINDOWS_H)
     IF(WINMM)
         CHECK_INCLUDE_FILES("windows.h;mmsystem.h" HAVE_MMSYSTEM_H -D_WIN32_WINNT=0x0500)
         IF(HAVE_MMSYSTEM_H)
@@ -280,24 +349,69 @@ IF(HAVE_WINDOWS_H)
     ENDIF()
 ENDIF()
 
+# Check PortAudio backend
+IF(PORTAUDIO)
+    CHECK_INCLUDE_FILE(portaudio.h HAVE_PORTAUDIO_H)
+    IF(HAVE_PORTAUDIO_H)
+        CHECK_LIBRARY_EXISTS(portaudio Pa_Initialize "" HAVE_LIBPORTAUDIO)
+        IF(HAVE_LIBPORTAUDIO)
+            SET(HAVE_PORTAUDIO 1)
+            SET(ALC_OBJS  ${ALC_OBJS} Alc/portaudio.c)
+            IF(HAVE_DLFCN_H)
+                SET(BACKENDS  "${BACKENDS} PortAudio,")
+            ELSE()
+                SET(BACKENDS  "${BACKENDS} PortAudio \(linked\),")
+                SET(EXTRA_LIBS portaudio ${EXTRA_LIBS})
+            ENDIF()
+        ENDIF()
+    ENDIF()
+ENDIF()
+
+# Check PortAudio backend
+IF(PULSEAUDIO)
+    CHECK_INCLUDE_FILE(pulse/pulseaudio.h HAVE_PULSE_PULSEAUDIO_H)
+    IF(HAVE_PULSE_PULSEAUDIO_H)
+        CHECK_LIBRARY_EXISTS(pulse pa_context_new "" HAVE_LIBPULSE)
+        IF(HAVE_LIBPULSE)
+            SET(HAVE_PULSEAUDIO 1)
+            SET(ALC_OBJS  ${ALC_OBJS} Alc/pulseaudio.c)
+            IF(HAVE_DLFCN_H)
+                SET(BACKENDS  "${BACKENDS} PulseAudio,")
+            ELSE()
+                SET(BACKENDS  "${BACKENDS} PulseAudio \(linked\),")
+                SET(EXTRA_LIBS pulse ${EXTRA_LIBS})
+            ENDIF()
+        ENDIF()
+    ENDIF()
+ENDIF()
+
 # This is always available
 SET(BACKENDS  "${BACKENDS} WaveFile")
 
+# Needed for openal.pc.in
+SET(prefix ${CMAKE_INSTALL_PREFIX})
+SET(exec_prefix "\${prefix}")
+SET(libdir "\${exec_prefix}/${LIB_INSTALL_DIR}")
+SET(bindir "\${exec_prefix}/bin")
+SET(includedir "\${prefix}/include")
+SET(PACKAGE_VERSION "${LIB_VERSION}")
+
 # End configuration
 CONFIGURE_FILE(
     "${OpenAL_SOURCE_DIR}/config.h.in"
     "${OpenAL_BINARY_DIR}/config.h")
+CONFIGURE_FILE(
+    "${OpenAL_SOURCE_DIR}/admin/pkgconfig/openal.pc.in"
+    "${OpenAL_BINARY_DIR}/admin/pkgconfig/openal.pc"
+    @ONLY)
 
 ADD_DEFINITIONS(-DAL_BUILD_LIBRARY)
 
-# Build a shared library
-IF(WIN32)
-    SET(LIBNAME openal32)
-ELSE()
-    SET(LIBNAME openal)
+# Build a library
+IF(NOT LIBTYPE)
+    SET(LIBTYPE SHARED)
 ENDIF()
-
-ADD_LIBRARY(${LIBNAME} SHARED ${OPENAL_OBJS} ${ALC_OBJS})
+ADD_LIBRARY(${LIBNAME} ${LIBTYPE} ${OPENAL_OBJS} ${ALC_OBJS})
 SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES VERSION ${LIB_VERSION}
                                             SOVERSION ${LIB_MAJOR_VERSION})
 IF(WIN32)
@@ -309,22 +423,32 @@ TARGET_LINK_LIBRARIES(${LIBNAME} ${EXTRA_LIBS})
 # Add an install target here
 INSTALL(TARGETS ${LIBNAME}
         RUNTIME DESTINATION bin
-        LIBRARY DESTINATION lib
-        ARCHIVE DESTINATION lib
+        LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+        ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
 )
 INSTALL(FILES include/AL/al.h
               include/AL/alc.h
               include/AL/alext.h
         DESTINATION include/AL
 )
+INSTALL(FILES "${OpenAL_BINARY_DIR}/admin/pkgconfig/openal.pc"
+        DESTINATION "${LIB_INSTALL_DIR}/pkgconfig")
+
+# Install alsoft.conf configuration file
+IF(ALSOFT_CONFIG)
+    INSTALL(FILES alsoftrc.sample
+            DESTINATION /etc/openal
+            RENAME alsoft.conf
+    )
+ENDIF()
 
 IF(EXAMPLES)
     ADD_EXECUTABLE(openal-info examples/openal-info.c)
     TARGET_LINK_LIBRARIES(openal-info ${LIBNAME})
     INSTALL(TARGETS openal-info
             RUNTIME DESTINATION bin
-            LIBRARY DESTINATION lib
-            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+            ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
     )
 ENDIF()
 
@@ -332,3 +456,11 @@ MESSAGE(STATUS "")
 MESSAGE(STATUS "Building OpenAL with support for the following backends:")
 MESSAGE(STATUS "    ${BACKENDS}")
 MESSAGE(STATUS "")
+
+IF(WIN32)
+    IF(NOT HAVE_DSOUND)
+        MESSAGE(STATUS "WARNING: Building the Windows version without DirectSound output")
+        MESSAGE(STATUS "         This is probably NOT what you want!")
+        MESSAGE(STATUS "")
+    ENDIF()
+ENDIF()

OpenAL32/Include/alAuxEffectSlot.h

@@ -1,8 +1,9 @@
 #ifndef _AL_AUXEFFECTSLOT_H_
 #define _AL_AUXEFFECTSLOT_H_
 
-#include "alEffect.h"
 #include "AL/al.h"
+#include "alEffect.h"
+#include "alFilter.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -14,6 +15,8 @@ extern "C" {
 
 #define AL_EFFECTSLOT_NULL                                 0x0000
 
+typedef struct ALeffectState ALeffectState;
+
 typedef struct ALeffectslot
 {
     ALeffect effect;
@@ -21,14 +24,9 @@ typedef struct ALeffectslot
     ALfloat Gain;
     ALboolean AuxSendAuto;
 
-    ALfloat *ReverbBuffer;
-    // in frames!
-    ALuint ReverbLength;
-    ALuint ReverbPos;
-    ALuint ReverbReflectPos;
-    ALuint ReverbLatePos;
-    ALfloat ReverbDecayGain;
-    ALfloat LastDecaySample;
+    ALeffectState *EffectState;
+
+    ALfloat WetBuffer[BUFFERSIZE];
 
     ALuint refcount;
 
@@ -38,22 +36,38 @@ typedef struct ALeffectslot
     struct ALeffectslot *next;
 } ALeffectslot;
 
-AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
-AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
-AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot);
+ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
+ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
+ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot);
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
+ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue);
+ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
+ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue);
+ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue);
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue);
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
 
 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);
 
+
+struct ALeffectState {
+    ALvoid (*Destroy)(ALeffectState *State);
+    ALvoid (*Update)(ALeffectState *State, ALCcontext *Context, ALeffect *Effect);
+    ALvoid (*Process)(ALeffectState *State, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS]);
+};
+
+ALeffectState *EAXVerbCreate(ALCcontext *Context);
+ALeffectState *VerbCreate(ALCcontext *Context);
+ALeffectState *EchoCreate(ALCcontext *Context);
+
+#define ALEffect_Destroy(a)         ((a)->Destroy((a)))
+#define ALEffect_Update(a,b,c)      ((a)->Update((a),(b),(c)))
+#define ALEffect_Process(a,b,c,d,e) ((a)->Process((a),(b),(c),(d),(e)))
+
+
 #ifdef __cplusplus
 }
 #endif

OpenAL32/Include/alBuffer.h

@@ -18,11 +18,14 @@ typedef struct ALbuffer_struct
     ALshort *data;
     ALsizei  size;
     ALsizei  frequency;
+    ALsizei  padding;
     ALenum   state;
     ALuint   refcount; // Number of sources using this buffer (deletion can only occur when this is 0)
     struct ALbuffer_struct *next;
 } ALbuffer;
 
+ALvoid ALAPIENTRY alBufferSubDataEXT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
+
 ALvoid ReleaseALBuffers(ALvoid);
 
 #ifdef __cplusplus

OpenAL32/Include/alEffect.h

@@ -1,3 +1,5 @@
+// NOTE:  The effect structure is getting too large, it may be a good idea to
+//        start using a union or another form of unified storage.
 #ifndef _AL_EFFECT_H_
 #define _AL_EFFECT_H_
 
@@ -22,6 +24,7 @@ extern "C" {
 #define AL_EFFECT_AUTOWAH                                  0x000A
 #define AL_EFFECT_COMPRESSOR                               0x000B
 #define AL_EFFECT_EQUALIZER                                0x000C
+#define AL_EFFECT_EAXREVERB                                0x8000
 
 #define AL_REVERB_DENSITY                                  0x0001
 #define AL_REVERB_DIFFUSION                                0x0002
@@ -37,6 +40,166 @@ extern "C" {
 #define AL_REVERB_ROOM_ROLLOFF_FACTOR                      0x000C
 #define AL_REVERB_DECAY_HFLIMIT                            0x000D
 
+#define AL_REVERB_MIN_DENSITY                              (0.0f)
+#define AL_REVERB_MAX_DENSITY                              (1.0f)
+#define AL_REVERB_DEFAULT_DENSITY                          (1.0f)
+#define AL_REVERB_MIN_DIFFUSION                            (0.0f)
+#define AL_REVERB_MAX_DIFFUSION                            (1.0f)
+#define AL_REVERB_DEFAULT_DIFFUSION                        (1.0f)
+#define AL_REVERB_MIN_GAIN                                 (0.0f)
+#define AL_REVERB_MAX_GAIN                                 (1.0f)
+#define AL_REVERB_DEFAULT_GAIN                             (0.32f)
+#define AL_REVERB_MIN_GAINHF                               (0.0f)
+#define AL_REVERB_MAX_GAINHF                               (1.0f)
+#define AL_REVERB_DEFAULT_GAINHF                           (0.89f)
+#define AL_REVERB_MIN_DECAY_TIME                           (0.1f)
+#define AL_REVERB_MAX_DECAY_TIME                           (20.0f)
+#define AL_REVERB_DEFAULT_DECAY_TIME                       (1.49f)
+#define AL_REVERB_MIN_DECAY_HFRATIO                        (0.1f)
+#define AL_REVERB_MAX_DECAY_HFRATIO                        (2.0f)
+#define AL_REVERB_DEFAULT_DECAY_HFRATIO                    (0.83f)
+#define AL_REVERB_MIN_REFLECTIONS_GAIN                     (0.0f)
+#define AL_REVERB_MAX_REFLECTIONS_GAIN                     (3.16f)
+#define AL_REVERB_DEFAULT_REFLECTIONS_GAIN                 (0.05f)
+#define AL_REVERB_MIN_REFLECTIONS_DELAY                    (0.0f)
+#define AL_REVERB_MAX_REFLECTIONS_DELAY                    (0.3f)
+#define AL_REVERB_DEFAULT_REFLECTIONS_DELAY                (0.007f)
+#define AL_REVERB_MIN_LATE_REVERB_GAIN                     (0.0f)
+#define AL_REVERB_MAX_LATE_REVERB_GAIN                     (10.0f)
+#define AL_REVERB_DEFAULT_LATE_REVERB_GAIN                 (1.26f)
+#define AL_REVERB_MIN_LATE_REVERB_DELAY                    (0.0f)
+#define AL_REVERB_MAX_LATE_REVERB_DELAY                    (0.1f)
+#define AL_REVERB_DEFAULT_LATE_REVERB_DELAY                (0.011f)
+#define AL_REVERB_MIN_AIR_ABSORPTION_GAINHF                (0.892f)
+#define AL_REVERB_MAX_AIR_ABSORPTION_GAINHF                (1.0f)
+#define AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF            (0.994f)
+#define AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR                  (0.0f)
+#define AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR                  (10.0f)
+#define AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR              (0.0f)
+#define AL_REVERB_MIN_DECAY_HFLIMIT                        (AL_FALSE)
+#define AL_REVERB_MAX_DECAY_HFLIMIT                        (AL_TRUE)
+#define AL_REVERB_DEFAULT_DECAY_HFLIMIT                    (AL_TRUE)
+
+#define AL_ECHO_DELAY                                      0x0001
+#define AL_ECHO_LRDELAY                                    0x0002
+#define AL_ECHO_DAMPING                                    0x0003
+#define AL_ECHO_FEEDBACK                                   0x0004
+#define AL_ECHO_SPREAD                                     0x0005
+
+#define AL_ECHO_MIN_DELAY                                  (0.0f)
+#define AL_ECHO_MAX_DELAY                                  (0.207f)
+#define AL_ECHO_DEFAULT_DELAY                              (0.1f)
+#define AL_ECHO_MIN_LRDELAY                                (0.0f)
+#define AL_ECHO_MAX_LRDELAY                                (0.404f)
+#define AL_ECHO_DEFAULT_LRDELAY                            (0.1f)
+#define AL_ECHO_MIN_DAMPING                                (0.0f)
+#define AL_ECHO_MAX_DAMPING                                (0.99f)
+#define AL_ECHO_DEFAULT_DAMPING                            (0.5f)
+#define AL_ECHO_MIN_FEEDBACK                               (0.0f)
+#define AL_ECHO_MAX_FEEDBACK                               (1.0f)
+#define AL_ECHO_DEFAULT_FEEDBACK                           (0.5f)
+#define AL_ECHO_MIN_SPREAD                                 (-1.0f)
+#define AL_ECHO_MAX_SPREAD                                 (1.0f)
+#define AL_ECHO_DEFAULT_SPREAD                             (-1.0f)
+
+#define AL_EAXREVERB_DENSITY                               0x0001
+#define AL_EAXREVERB_DIFFUSION                             0x0002
+#define AL_EAXREVERB_GAIN                                  0x0003
+#define AL_EAXREVERB_GAINHF                                0x0004
+#define AL_EAXREVERB_GAINLF                                0x0005
+#define AL_EAXREVERB_DECAY_TIME                            0x0006
+#define AL_EAXREVERB_DECAY_HFRATIO                         0x0007
+#define AL_EAXREVERB_DECAY_LFRATIO                         0x0008
+#define AL_EAXREVERB_REFLECTIONS_GAIN                      0x0009
+#define AL_EAXREVERB_REFLECTIONS_DELAY                     0x000A
+#define AL_EAXREVERB_REFLECTIONS_PAN                       0x000B
+#define AL_EAXREVERB_LATE_REVERB_GAIN                      0x000C
+#define AL_EAXREVERB_LATE_REVERB_DELAY                     0x000D
+#define AL_EAXREVERB_LATE_REVERB_PAN                       0x000E
+#define AL_EAXREVERB_ECHO_TIME                             0x000F
+#define AL_EAXREVERB_ECHO_DEPTH                            0x0010
+#define AL_EAXREVERB_MODULATION_TIME                       0x0011
+#define AL_EAXREVERB_MODULATION_DEPTH                      0x0012
+#define AL_EAXREVERB_AIR_ABSORPTION_GAINHF                 0x0013
+#define AL_EAXREVERB_HFREFERENCE                           0x0014
+#define AL_EAXREVERB_LFREFERENCE                           0x0015
+#define AL_EAXREVERB_ROOM_ROLLOFF_FACTOR                   0x0016
+#define AL_EAXREVERB_DECAY_HFLIMIT                         0x0017
+
+#define AL_EAXREVERB_MIN_DENSITY                           (0.0f)
+#define AL_EAXREVERB_MAX_DENSITY                           (1.0f)
+#define AL_EAXREVERB_DEFAULT_DENSITY                       (1.0f)
+#define AL_EAXREVERB_MIN_DIFFUSION                         (0.0f)
+#define AL_EAXREVERB_MAX_DIFFUSION                         (1.0f)
+#define AL_EAXREVERB_DEFAULT_DIFFUSION                     (1.0f)
+#define AL_EAXREVERB_MIN_GAIN                              (0.0f)
+#define AL_EAXREVERB_MAX_GAIN                              (1.0f)
+#define AL_EAXREVERB_DEFAULT_GAIN                          (0.32f)
+#define AL_EAXREVERB_MIN_GAINHF                            (0.0f)
+#define AL_EAXREVERB_MAX_GAINHF                            (1.0f)
+#define AL_EAXREVERB_DEFAULT_GAINHF                        (0.89f)
+#define AL_EAXREVERB_MIN_GAINLF                            (0.0f)
+#define AL_EAXREVERB_MAX_GAINLF                            (1.0f)
+#define AL_EAXREVERB_DEFAULT_GAINLF                        (1.0f)
+#define AL_EAXREVERB_MIN_DECAY_TIME                        (0.1f)
+#define AL_EAXREVERB_MAX_DECAY_TIME                        (20.0f)
+#define AL_EAXREVERB_DEFAULT_DECAY_TIME                    (1.49f)
+#define AL_EAXREVERB_MIN_DECAY_HFRATIO                     (0.1f)
+#define AL_EAXREVERB_MAX_DECAY_HFRATIO                     (2.0f)
+#define AL_EAXREVERB_DEFAULT_DECAY_HFRATIO                 (0.83f)
+#define AL_EAXREVERB_MIN_DECAY_LFRATIO                     (0.1f)
+#define AL_EAXREVERB_MAX_DECAY_LFRATIO                     (2.0f)
+#define AL_EAXREVERB_DEFAULT_DECAY_LFRATIO                 (1.0f)
+#define AL_EAXREVERB_MIN_REFLECTIONS_GAIN                  (0.0f)
+#define AL_EAXREVERB_MAX_REFLECTIONS_GAIN                  (3.16f)
+#define AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN              (0.05f)
+#define AL_EAXREVERB_MIN_REFLECTIONS_DELAY                 (0.0f)
+#define AL_EAXREVERB_MAX_REFLECTIONS_DELAY                 (0.3f)
+#define AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY             (0.007f)
+#define AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ           (0.0f)
+#define AL_EAXREVERB_MIN_LATE_REVERB_GAIN                  (0.0f)
+#define AL_EAXREVERB_MAX_LATE_REVERB_GAIN                  (10.0f)
+#define AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN              (1.26f)
+#define AL_EAXREVERB_MIN_LATE_REVERB_DELAY                 (0.0f)
+#define AL_EAXREVERB_MAX_LATE_REVERB_DELAY                 (0.1f)
+#define AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY             (0.011f)
+#define AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ           (0.0f)
+#define AL_EAXREVERB_MIN_ECHO_TIME                         (0.075f)
+#define AL_EAXREVERB_MAX_ECHO_TIME                         (0.25f)
+#define AL_EAXREVERB_DEFAULT_ECHO_TIME                     (0.25f)
+#define AL_EAXREVERB_MIN_ECHO_DEPTH                        (0.0f)
+#define AL_EAXREVERB_MAX_ECHO_DEPTH                        (1.0f)
+#define AL_EAXREVERB_DEFAULT_ECHO_DEPTH                    (0.0f)
+#define AL_EAXREVERB_MIN_MODULATION_TIME                   (0.04f)
+#define AL_EAXREVERB_MAX_MODULATION_TIME                   (4.0f)
+#define AL_EAXREVERB_DEFAULT_MODULATION_TIME               (0.25f)
+#define AL_EAXREVERB_MIN_MODULATION_DEPTH                  (0.0f)
+#define AL_EAXREVERB_MAX_MODULATION_DEPTH                  (1.0f)
+#define AL_EAXREVERB_DEFAULT_MODULATION_DEPTH              (0.0f)
+#define AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF             (0.892f)
+#define AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF             (1.0f)
+#define AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF         (0.994f)
+#define AL_EAXREVERB_MIN_HFREFERENCE                       (1000.0f)
+#define AL_EAXREVERB_MAX_HFREFERENCE                       (20000.0f)
+#define AL_EAXREVERB_DEFAULT_HFREFERENCE                   (5000.0f)
+#define AL_EAXREVERB_MIN_LFREFERENCE                       (20.0f)
+#define AL_EAXREVERB_MAX_LFREFERENCE                       (1000.0f)
+#define AL_EAXREVERB_DEFAULT_LFREFERENCE                   (250.0f)
+#define AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR               (0.0f)
+#define AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR               (10.0f)
+#define AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR           (0.0f)
+#define AL_EAXREVERB_MIN_DECAY_HFLIMIT                     (AL_FALSE)
+#define AL_EAXREVERB_MAX_DECAY_HFLIMIT                     (AL_TRUE)
+#define AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT                 (AL_TRUE)
+
+enum {
+    EAXREVERB = 0,
+    REVERB,
+    ECHO,
+
+    MAX_EFFECTS
+};
+extern ALboolean DisabledEffects[MAX_EFFECTS];
 
 typedef struct ALeffect_struct
 {
@@ -44,9 +207,9 @@ typedef struct ALeffect_struct
     ALenum type;
 
     struct {
+        // Shared Reverb Properties
         ALfloat Density;
         ALfloat Diffusion;
-
         ALfloat Gain;
         ALfloat GainHF;
         ALfloat DecayTime;
@@ -58,27 +221,49 @@ typedef struct ALeffect_struct
         ALfloat AirAbsorptionGainHF;
         ALfloat RoomRolloffFactor;
         ALboolean DecayHFLimit;
+
+        // Additional EAX Reverb Properties
+        ALfloat GainLF;
+        ALfloat DecayLFRatio;
+        ALfloat ReflectionsPan[3];
+        ALfloat LateReverbPan[3];
+        ALfloat EchoTime;
+        ALfloat EchoDepth;
+        ALfloat ModulationTime;
+        ALfloat ModulationDepth;
+        ALfloat HFReference;
+        ALfloat LFReference;
     } Reverb;
 
+    struct {
+        ALfloat Delay;
+        ALfloat LRDelay;
+
+        ALfloat Damping;
+        ALfloat Feedback;
+
+        ALfloat Spread;
+    } Echo;
+
     // Index to itself
     ALuint effect;
 
     struct ALeffect_struct *next;
 } ALeffect;
 
-AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects);
-AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects);
-AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect);
+ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects);
+ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects);
+ALboolean AL_APIENTRY alIsEffect(ALuint effect);
 
-AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
+ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue);
+ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues);
+ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue);
+ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
 
-AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
+ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue);
+ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues);
+ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue);
+ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
 
 ALvoid ReleaseALEffects(ALvoid);
 

OpenAL32/Include/alFilter.h

@@ -2,11 +2,54 @@
 #define _AL_FILTER_H_
 
 #include "AL/al.h"
+#include "alu.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef struct {
+    ALfloat coeff;
+#ifndef _MSC_VER
+    ALfloat history[0];
+#else
+    ALfloat history[1];
+#endif
+} FILTER;
+
+static __inline ALfloat lpFilter4P(FILTER *iir, ALuint offset, ALfloat input)
+{
+    ALfloat *history = &iir->history[offset];
+    ALfloat a = iir->coeff;
+    ALfloat output = input;
+
+    output = output + (history[0]-output)*a;
+    history[0] = output;
+    output = output + (history[1]-output)*a;
+    history[1] = output;
+    output = output + (history[2]-output)*a;
+    history[2] = output;
+    output = output + (history[3]-output)*a;
+    history[3] = output;
+
+    return output;
+}
+
+static __inline ALfloat lpFilter2P(FILTER *iir, ALuint offset, ALfloat input)
+{
+    ALfloat *history = &iir->history[offset];
+    ALfloat a = iir->coeff;
+    ALfloat output = input;
+
+    output = output + (history[0]-output)*a;
+    history[0] = output;
+    output = output + (history[1]-output)*a;
+    history[1] = output;
+
+    return output;
+}
+
+
 #define AL_FILTER_TYPE                                     0x8001
 
 #define AL_FILTER_NULL                                     0x0000
@@ -32,19 +75,19 @@ typedef struct ALfilter_struct
     struct ALfilter_struct *next;
 } ALfilter;
 
-AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters);
-AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters);
-AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter);
+ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters);
+ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters);
+ALboolean AL_APIENTRY alIsFilter(ALuint filter);
 
-AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue);
-AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue);
-AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
+ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue);
+ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues);
+ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue);
+ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
 
-AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue);
-AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues);
-AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue);
-AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
+ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue);
+ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues);
+ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue);
+ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
 
 ALvoid ReleaseALFilters(ALvoid);
 

OpenAL32/Include/alMain.h

@@ -3,8 +3,15 @@
 
 #include <string.h>
 #include <stdio.h>
+#include <stdarg.h>
 
-#include "alu.h"
+#ifdef HAVE_FENV_H
+#include <fenv.h>
+#endif
+
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "AL/alext.h"
 
 #ifdef _WIN32
 
@@ -94,36 +101,49 @@ static inline void Sleep(ALuint t)
 #define max(x,y) (((x)>(y))?(x):(y))
 #endif
 
-#include "AL/al.h"
-#include "AL/alc.h"
-#include "AL/alext.h"
 #include "alListener.h"
+#include "alu.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-extern CRITICAL_SECTION _alMutex;
+static __inline void al_print(const char *fname, unsigned int line, const char *fmt, ...)
+{
+    const char *fn;
+    char str[256];
+    int i;
 
-extern char _alDebug[256];
+    fn = strrchr(fname, '/');
+    if(!fn) fn = strrchr(fname, '\\');;
+    if(!fn) fn = fname;
+    else fn += 1;
 
-#define AL_PRINT(...) do {                             \
-    int _al_print_i;                                   \
-    const char *_al_print_fn = strrchr(__FILE__, '/'); \
-    if(!_al_print_fn) _al_print_fn  = __FILE__;        \
-    else              _al_print_fn += 1;               \
-    _al_print_i = snprintf(_alDebug, sizeof(_alDebug), "AL lib: %s:%d: ", _al_print_fn, __LINE__); \
-    if(_al_print_i < (int)sizeof(_alDebug) && _al_print_i > 0)                     \
-        snprintf(_alDebug+_al_print_i, sizeof(_alDebug)-_al_print_i, __VA_ARGS__); \
-    _alDebug[sizeof(_alDebug)-1] = 0; \
-    fprintf(stderr, "%s", _alDebug);  \
-} while(0)
+    i = snprintf(str, sizeof(str), "AL lib: %s:%d: ", fn, line);
+    if(i < (int)sizeof(str) && i > 0)
+    {
+        va_list ap;
+        va_start(ap, fmt);
+        vsnprintf(str+i, sizeof(str)-i, fmt, ap);
+        va_end(ap);
+    }
+    str[sizeof(str)-1] = 0;
+
+    fprintf(stderr, "%s", str);
+}
+#define AL_PRINT(...) al_print(__FILE__, __LINE__, __VA_ARGS__)
 
 
 #define SWMIXER_OUTPUT_RATE        44100
 
 #define SPEEDOFSOUNDMETRESPERSEC   (343.3f)
-#define AIRABSORBGAINHF            (0.994f)
+#define AIRABSORBGAINDBHF          (-0.05f)
+
+#define LOWPASSFREQCUTOFF          (5000)
+
+#define QUADRANT_NUM 128
+#define LUT_NUM (4 * QUADRANT_NUM)
+
 
 typedef struct {
     ALCboolean (*OpenPlayback)(ALCdevice*, const ALCchar*);
@@ -139,9 +159,12 @@ typedef struct {
 
 void alc_alsa_init(BackendFuncs *func_list);
 void alc_oss_init(BackendFuncs *func_list);
+void alc_solaris_init(BackendFuncs *func_list);
 void alcDSoundInit(BackendFuncs *func_list);
 void alcWinMMInit(BackendFuncs *FuncList);
+void alc_pa_init(BackendFuncs *func_list);
 void alc_wave_init(BackendFuncs *func_list);
+void alc_pulse_init(BackendFuncs *func_list);
 
 
 struct ALCdevice_struct
@@ -156,6 +179,8 @@ struct ALCdevice_struct
 
     // Maximum number of sources that can be created
     ALuint       MaxNoOfSources;
+    // Maximum number of slots that can be created
+    ALuint       AuxiliaryEffectSlotMax;
 
     // Context created on this device
     ALCcontext   *Context;
@@ -199,8 +224,15 @@ struct ALCcontext_struct
     ALint       lNumMonoSources;
     ALint       lNumStereoSources;
 
+    ALuint      NumSends;
+
+    ALfloat     PanningLUT[OUTPUTCHANNELS * LUT_NUM];
+    ALint       NumChan;
+
+    ALfloat     ChannelMatrix[OUTPUTCHANNELS][OUTPUTCHANNELS];
+
     ALCdevice  *Device;
-    ALCchar     ExtensionList[1024];
+    const ALCchar *ExtensionList;
 
     struct bs2b *bs2b;
 

OpenAL32/Include/alSource.h

@@ -3,10 +3,10 @@
 
 #define AL_NUM_SOURCE_PARAMS    128
 
-/* This cannot be changed without working on the code! */
-#define MAX_SENDS                 1
+#define MAX_SENDS                 2
 
 #include "alFilter.h"
+#include "alu.h"
 #include "AL/al.h"
 
 #define AL_DIRECT_FILTER                                   0x20005
@@ -47,6 +47,7 @@ typedef struct ALsource
     ALfloat      vOrientation[3];
     ALboolean    bHeadRelative;
     ALboolean    bLooping;
+    ALenum       DistanceModel;
 
     ALuint       ulBufferID;
 
@@ -55,44 +56,50 @@ typedef struct ALsource
     ALenum       state;
     ALuint       position;
     ALuint       position_fraction;
+
     struct ALbufferlistitem *queue; // Linked list of buffers in queue
     ALuint       BuffersInQueue;    // Number of buffers in queue
-    ALuint       BuffersProcessed;  // Number of buffers already processed (played)
 
     ALuint TotalBufferDataSize; // Total amount of data contained in the buffers queued for this source
     ALuint BuffersPlayed;       // Number of buffers played on this loop
-    ALuint BufferPosition;      // Read position in audio data of current buffer
 
     ALfilter DirectFilter;
 
     struct {
         struct ALeffectslot *Slot;
         ALfilter WetFilter;
+        FILTER iirFilter;
+        ALfloat history[2];
     } Send[MAX_SENDS];
 
-    ALfloat LastDrySample;
-    ALfloat LastWetSample;
-
     ALboolean DryGainHFAuto;
     ALboolean WetGainAuto;
     ALboolean WetGainHFAuto;
     ALfloat   OuterGainHF;
 
+    FILTER iirFilter;
+    ALfloat history[OUTPUTCHANNELS*2];
+
     ALfloat AirAbsorptionFactor;
 
     ALfloat RoomRolloffFactor;
 
+    ALfloat DopplerFactor;
+
     // Index to itself
     ALuint source;
 
-    ALint  lBytesPlayed;
-
     ALint  lOffset;
     ALint  lOffsetType;
 
     // Source Type (Static, Streaming, or Undetermined)
     ALint  lSourceType;
 
+    // Current gains, which are ramped while mixed
+    ALfloat DryGains[OUTPUTCHANNELS];
+    ALfloat WetGains[MAX_SENDS];
+    ALboolean FirstStart;
+
     struct ALsource *next;
 } ALsource;
 

OpenAL32/Include/alu.h

@@ -3,15 +3,149 @@
 
 #include "AL/al.h"
 #include "AL/alc.h"
+#include "AL/alext.h"
+
+#ifdef HAVE_FLOAT_H
+#include <float.h>
+#endif
+
+#ifndef M_PI
+#define M_PI           3.14159265358979323846  /* pi */
+#define M_PI_2         1.57079632679489661923  /* pi/2 */
+#endif
+
+#ifdef HAVE_SQRTF
+#define aluSqrt(x) ((ALfloat)sqrtf((float)(x)))
+#else
+#define aluSqrt(x) ((ALfloat)sqrt((double)(x)))
+#endif
+
+#ifdef HAVE_ACOSF
+#define aluAcos(x) ((ALfloat)acosf((float)(x)))
+#else
+#define aluAcos(x) ((ALfloat)acos((double)(x)))
+#endif
+
+#ifdef HAVE_ATANF
+#define aluAtan(x) ((ALfloat)atanf((float)(x)))
+#else
+#define aluAtan(x) ((ALfloat)atan((double)(x)))
+#endif
+
+#ifdef HAVE_FABSF
+#define aluFabs(x) ((ALfloat)fabsf((float)(x)))
+#else
+#define aluFabs(x) ((ALfloat)fabs((double)(x)))
+#endif
+
+// fixes for mingw32.
+#if defined(max) && !defined(__max)
+#define __max max
+#endif
+#if defined(min) && !defined(__min)
+#define __min min
+#endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+enum {
+    FRONT_LEFT = 0,
+    FRONT_RIGHT,
+    FRONT_CENTER,
+    SIDE_LEFT,
+    SIDE_RIGHT,
+    BACK_LEFT,
+    BACK_RIGHT,
+    BACK_CENTER,
+    LFE,
+
+    OUTPUTCHANNELS
+};
+
+#define BUFFERSIZE 24000
+
 extern ALboolean DuplicateStereo;
 
-__inline ALuint aluBytesFromFormat(ALenum format);
-__inline ALuint aluChannelsFromFormat(ALenum format);
+/* NOTE: The AL_FORMAT_REAR* enums aren't handled here be cause they're
+ *       converted to AL_FORMAT_QUAD* when loaded */
+static __inline ALuint aluBytesFromFormat(ALenum format)
+{
+    switch(format)
+    {
+        case AL_FORMAT_MONO8:
+        case AL_FORMAT_STEREO8:
+        case AL_FORMAT_QUAD8_LOKI:
+        case AL_FORMAT_QUAD8:
+        case AL_FORMAT_51CHN8:
+        case AL_FORMAT_61CHN8:
+        case AL_FORMAT_71CHN8:
+            return 1;
+
+        case AL_FORMAT_MONO16:
+        case AL_FORMAT_STEREO16:
+        case AL_FORMAT_QUAD16_LOKI:
+        case AL_FORMAT_QUAD16:
+        case AL_FORMAT_51CHN16:
+        case AL_FORMAT_61CHN16:
+        case AL_FORMAT_71CHN16:
+            return 2;
+
+        case AL_FORMAT_MONO_FLOAT32:
+        case AL_FORMAT_STEREO_FLOAT32:
+        case AL_FORMAT_QUAD32:
+        case AL_FORMAT_51CHN32:
+        case AL_FORMAT_61CHN32:
+        case AL_FORMAT_71CHN32:
+            return 4;
+
+        default:
+            return 0;
+    }
+}
+static __inline ALuint aluChannelsFromFormat(ALenum format)
+{
+    switch(format)
+    {
+        case AL_FORMAT_MONO8:
+        case AL_FORMAT_MONO16:
+        case AL_FORMAT_MONO_FLOAT32:
+            return 1;
+
+        case AL_FORMAT_STEREO8:
+        case AL_FORMAT_STEREO16:
+        case AL_FORMAT_STEREO_FLOAT32:
+            return 2;
+
+        case AL_FORMAT_QUAD8_LOKI:
+        case AL_FORMAT_QUAD16_LOKI:
+        case AL_FORMAT_QUAD8:
+        case AL_FORMAT_QUAD16:
+        case AL_FORMAT_QUAD32:
+            return 4;
+
+        case AL_FORMAT_51CHN8:
+        case AL_FORMAT_51CHN16:
+        case AL_FORMAT_51CHN32:
+            return 6;
+
+        case AL_FORMAT_61CHN8:
+        case AL_FORMAT_61CHN16:
+        case AL_FORMAT_61CHN32:
+            return 7;
+
+        case AL_FORMAT_71CHN8:
+        case AL_FORMAT_71CHN16:
+        case AL_FORMAT_71CHN32:
+            return 8;
+
+        default:
+            return 0;
+    }
+}
+
+ALvoid aluInitPanning(ALCcontext *Context);
 ALvoid aluMixData(ALCcontext *context,ALvoid *buffer,ALsizei size,ALenum format);
 
 #ifdef __cplusplus

OpenAL32/OpenAL32.c

@@ -1,74 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 1999-2007 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#include "config.h"
-
-#include "alMain.h"
-#include "alBuffer.h"
-#include "alFilter.h"
-#include "alEffect.h"
-#include "alAuxEffectSlot.h"
-#include "alThunk.h"
-
-CRITICAL_SECTION _alMutex;
-
-#ifdef _WIN32
-BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
-{
-    (void)lpReserved;
-
-    // Perform actions based on the reason for calling.
-    switch(ul_reason_for_call)
-    {
-        case DLL_PROCESS_ATTACH:
-            DisableThreadLibraryCalls(hModule);
-            break;
-
-        case DLL_PROCESS_DETACH:
-            ReleaseALC();
-            ReleaseALBuffers();
-            ReleaseALEffects();
-            ReleaseALFilters();
-            FreeALConfig();
-            ALTHUNK_EXIT();
-            DeleteCriticalSection(&_alMutex);
-            break;
-    }
-    return TRUE;
-}
-#else
-#ifdef HAVE_GCC_DESTRUCTOR
-static void my_deinit() __attribute__((destructor));
-static void my_deinit()
-{
-    static ALenum once = AL_FALSE;
-    if(once) return;
-    once = AL_TRUE;
-
-    ReleaseALC();
-    ReleaseALBuffers();
-    ReleaseALEffects();
-    ReleaseALFilters();
-    FreeALConfig();
-    ALTHUNK_EXIT();
-    DeleteCriticalSection(&_alMutex);
-}
-#endif
-#endif

OpenAL32/alAuxEffectSlot.c

@@ -34,10 +34,10 @@
 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *ALEffectSlot, ALeffect *effect);
 
 
-AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
+ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 {
     ALCcontext *Context;
-    ALsizei i;
+    ALsizei i, j;
 
     Context = alcGetCurrentContext();
     if(!Context)
@@ -49,8 +49,9 @@ AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslo
 
     if (n > 0)
     {
-        /* NOTE: We only support one slot currently */
-        if(n == 1 && Context->AuxiliaryEffectSlotCount == 0)
+        ALCdevice *Device = alcGetContextsDevice(Context);
+
+        if(Context->AuxiliaryEffectSlotCount+n <= Device->AuxiliaryEffectSlotMax)
         {
             // Check that enough memory has been allocted in the 'effectslots' array for n Effect Slots
             if (!IsBadWritePtr((void*)effectslots, n * sizeof(ALuint)))
@@ -73,6 +74,8 @@ AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslo
 
                     (*list)->Gain = 1.0;
                     (*list)->AuxSendAuto = AL_TRUE;
+                    for(j = 0;j < BUFFERSIZE;j++)
+                        (*list)->WetBuffer[j] = 0.0f;
                     (*list)->refcount = 0;
 
                     effectslots[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
@@ -92,7 +95,7 @@ AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslo
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
+ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 {
     ALCcontext *Context;
     ALeffectslot *ALAuxiliaryEffectSlot;
@@ -148,7 +151,8 @@ AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effect
                         *list = (*list)->next;
                     ALTHUNK_REMOVEENTRY(ALAuxiliaryEffectSlot->effectslot);
 
-                    free(ALAuxiliaryEffectSlot->ReverbBuffer);
+                    if(ALAuxiliaryEffectSlot->EffectState)
+                        ALEffect_Destroy(ALAuxiliaryEffectSlot->EffectState);
 
                     memset(ALAuxiliaryEffectSlot, 0, sizeof(ALeffectslot));
                     free(ALAuxiliaryEffectSlot);
@@ -164,7 +168,7 @@ AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effect
     ProcessContext(Context);
 }
 
-AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
+ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 {
     ALCcontext *Context;
     ALeffectslot **list;
@@ -186,7 +190,7 @@ AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
     return (*list ? AL_TRUE : AL_FALSE);
 }
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
+ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
 {
     ALCcontext *Context;
 
@@ -232,7 +236,7 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
+ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 {
     ALCcontext *Context;
 
@@ -264,7 +268,7 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum para
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
+ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
 {
     ALCcontext *Context;
 
@@ -300,7 +304,7 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
+ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 {
     ALCcontext *Context;
 
@@ -331,7 +335,7 @@ AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum para
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
 {
     ALCcontext *Context;
 
@@ -368,7 +372,7 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum pa
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 {
     ALCcontext *Context;
 
@@ -400,7 +404,7 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum p
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
 {
     ALCcontext *Context;
 
@@ -433,7 +437,7 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum pa
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
+ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 {
     ALCcontext *Context;
 
@@ -467,54 +471,32 @@ AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum p
 
 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *ALEffectSlot, ALeffect *effect)
 {
-    ALfloat *ptr = NULL;
-
+    if((!effect) || (effect->type != ALEffectSlot->effect.type))
+    {
+        ALeffectState *NewState = NULL;
+        if(effect)
+        {
+            if(effect->type == AL_EFFECT_EAXREVERB)
+                NewState = EAXVerbCreate(Context);
+            else if(effect->type == AL_EFFECT_REVERB)
+                NewState = VerbCreate(Context);
+            else if(effect->type == AL_EFFECT_ECHO)
+                NewState = EchoCreate(Context);
+            /* No new state? An error occured.. */
+            if(!NewState)
+                return;
+        }
+        if(ALEffectSlot->EffectState)
+            ALEffect_Destroy(ALEffectSlot->EffectState);
+        ALEffectSlot->EffectState = NewState;
+    }
     if(!effect)
     {
         memset(&ALEffectSlot->effect, 0, sizeof(ALEffectSlot->effect));
-        goto done;
+        return;
     }
-
-    if(effect->type == AL_EFFECT_REVERB)
-    {
-        ALuint size;
-        ALfloat reverbwait;
-
-        reverbwait = (1.0f-effect->Reverb.Density)*(0.1f-0.075f) + 0.075f;
-
-        size = (ALuint)((ALfloat)Context->Frequency *
-                        (effect->Reverb.ReflectionsDelay +
-                         effect->Reverb.LateReverbDelay +
-                         reverbwait)) + 1;
-
-        ptr = calloc(size, sizeof(ALfloat));
-        if(!ptr)
-        {
-            alSetError(AL_OUT_OF_MEMORY);
-            return;
-        }
-        if(ALEffectSlot->ReverbBuffer)
-            memcpy(ptr, ALEffectSlot->ReverbBuffer, min(size, ALEffectSlot->ReverbLength)*sizeof(ALfloat));
-        ALEffectSlot->ReverbLength = size;
-        ALEffectSlot->ReverbPos %= size;
-        ALEffectSlot->ReverbReflectPos = (ALuint)(ALEffectSlot->ReverbLength -
-                                          ((ALfloat)Context->Frequency *
-                                           effect->Reverb.ReflectionsDelay) +
-                                          ALEffectSlot->ReverbPos) %
-                                         ALEffectSlot->ReverbLength;
-        ALEffectSlot->ReverbLatePos = (ALuint)(ALEffectSlot->ReverbLength -
-                                               ((ALfloat)Context->Frequency *
-                                              (effect->Reverb.LateReverbDelay +
-                                           effect->Reverb.ReflectionsDelay)) +
-                                          ALEffectSlot->ReverbPos) %
-                                         ALEffectSlot->ReverbLength;
-        ALEffectSlot->ReverbDecayGain = pow(1.0/32768.0, 1.0/(effect->Reverb.DecayTime/reverbwait));
-    }
-
     memcpy(&ALEffectSlot->effect, effect, sizeof(*effect));
-done:
-    free(ALEffectSlot->ReverbBuffer);
-    ALEffectSlot->ReverbBuffer = ptr;
+    ALEffect_Update(ALEffectSlot->EffectState, Context, effect);
 }
 
 
@@ -522,7 +504,7 @@ ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 {
 #ifdef _DEBUG
     if(Context->AuxiliaryEffectSlotCount > 0)
-        AL_PRINT("alcDestroyContext(): %d AuxiliaryEffectSlot(s) NOT deleted\n", Context->AuxiliaryEffectSlotCount);
+        AL_PRINT("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", Context->AuxiliaryEffectSlotCount);
 #endif
 
     while(Context->AuxiliaryEffectSlot)
@@ -531,7 +513,8 @@ ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
         Context->AuxiliaryEffectSlot = Context->AuxiliaryEffectSlot->next;
 
         // Release effectslot structure
-        free(temp->ReverbBuffer);
+        if(temp->EffectState)
+            ALEffect_Destroy(temp->EffectState);
         ALTHUNK_REMOVEENTRY(temp->effectslot);
 
         memset(temp, 0, sizeof(ALeffectslot));

OpenAL32/alBuffer.c

@@ -18,8 +18,6 @@
  * Or go to http://www.gnu.org/copyleft/lgpl.html
  */
 
-#define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
-
 #include "config.h"
 
 #include <stdlib.h>
@@ -34,6 +32,9 @@
 
 
 static void LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat);
+static void ConvertData(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len);
+static void ConvertDataRear(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len);
+static void ConvertDataIMA4(ALshort *dst, const ALvoid *src, ALint origChans, ALsizei len);
 
 /*
  *  AL Buffer Functions
@@ -142,63 +143,59 @@ ALAPI ALvoid ALAPIENTRY alDeleteBuffers(ALsizei n, const ALuint *puiBuffers)
     // Check we are actually Deleting some Buffers
     if (n >= 0)
     {
-        if ((ALuint)n <= g_uiBufferCount)
+        // Check that all the buffers are valid and can actually be deleted
+        for (i = 0; i < n; i++)
         {
-            // Check that all the buffers are valid and can actually be deleted
-            for (i = 0; i < n; i++)
+            // Check for valid Buffer ID (can be NULL buffer)
+            if (alIsBuffer(puiBuffers[i]))
             {
-                // Check for valid Buffer ID (can be NULL buffer)
-                if (alIsBuffer(puiBuffers[i]))
+                // If not the NULL buffer, check that the reference count is 0
+                ALBuf = ((ALbuffer *)ALTHUNK_LOOKUPENTRY(puiBuffers[i]));
+                if (ALBuf)
                 {
-                    // If not the NULL buffer, check that the reference count is 0
-                    ALBuf = ((ALbuffer *)ALTHUNK_LOOKUPENTRY(puiBuffers[i]));
-                    if (ALBuf)
+                    if (ALBuf->refcount != 0)
                     {
-                        if (ALBuf->refcount != 0)
-                        {
-                            // Buffer still in use, cannot be deleted
-                            alSetError(AL_INVALID_OPERATION);
-                            bFailed = AL_TRUE;
-                        }
+                        // Buffer still in use, cannot be deleted
+                        alSetError(AL_INVALID_OPERATION);
+                        bFailed = AL_TRUE;
                     }
                 }
-                else
-                {
-                    // Invalid Buffer
-                    alSetError(AL_INVALID_NAME);
-                    bFailed = AL_TRUE;
-                }
             }
-
-            // If all the Buffers were valid (and have Reference Counts of 0), then we can delete them
-            if (!bFailed)
+            else
             {
-                for (i = 0; i < n; i++)
+                // Invalid Buffer
+                alSetError(AL_INVALID_NAME);
+                bFailed = AL_TRUE;
+            }
+        }
+
+        // If all the Buffers were valid (and have Reference Counts of 0), then we can delete them
+        if (!bFailed)
+        {
+            for (i = 0; i < n; i++)
+            {
+                if (puiBuffers[i] && alIsBuffer(puiBuffers[i]))
                 {
+                    ALbuffer **list = &g_pBuffers;
+
                     ALBuf=((ALbuffer *)ALTHUNK_LOOKUPENTRY(puiBuffers[i]));
-                    if (ALBuf)
-                    {
-                        ALbuffer **list = &g_pBuffers;
-                        while(*list && *list != ALBuf)
-                            list = &(*list)->next;
+                    while(*list && *list != ALBuf)
+                        list = &(*list)->next;
 
-                        if(*list)
-                            *list = (*list)->next;
+                    if(*list)
+                        *list = (*list)->next;
 
-                        // Release the memory used to store audio data
-                        free(ALBuf->data);
+                    // Release the memory used to store audio data
+                    free(ALBuf->data);
 
-                        // Release buffer structure
-                        ALTHUNK_REMOVEENTRY(puiBuffers[i]);
-                        memset(ALBuf, 0, sizeof(ALbuffer));
-                        g_uiBufferCount--;
-                        free(ALBuf);
-                    }
+                    // Release buffer structure
+                    ALTHUNK_REMOVEENTRY(puiBuffers[i]);
+                    memset(ALBuf, 0, sizeof(ALbuffer));
+                    g_uiBufferCount--;
+                    free(ALBuf);
                 }
             }
         }
-        else
-            alSetError(AL_INVALID_NAME);
     }
     else
         alSetError(AL_INVALID_VALUE);
@@ -259,14 +256,10 @@ ALAPI ALboolean ALAPIENTRY alIsBuffer(ALuint uiBuffer)
 */
 ALAPI ALvoid ALAPIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *data,ALsizei size,ALsizei freq)
 {
-    ALuint *IMAData,IMACode;
     ALCcontext *Context;
-    ALint Sample,Index;
-    ALint LeftSample,LeftIndex;
-    ALint RightSample,RightIndex;
-    ALuint LeftIMACode,RightIMACode;
+    ALsizei padding = 2;
     ALbuffer *ALBuf;
-    ALsizei i,j,k;
+    ALvoid *temp;
 
     Context = alcGetCurrentContext();
     SuspendContext(Context);
@@ -298,107 +291,35 @@ ALAPI ALvoid ALAPIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *d
                     ALuint OrigBytes = ((format==AL_FORMAT_REAR8) ? 1 :
                                         ((format==AL_FORMAT_REAR16) ? 2 :
                                          4));
-                    ALsizei i;
 
                     assert(aluBytesFromFormat(NewFormat) == 2);
 
-                    if ((size%(OrigBytes*2)) != 0)
+                    if((size%(OrigBytes*2)) != 0)
                     {
                         alSetError(AL_INVALID_VALUE);
                         break;
                     }
 
-                    switch(OrigBytes)
+                    size /= OrigBytes;
+                    size *= 2;
+
+                    // Samples are converted to 16 bit here
+                    temp = realloc(ALBuf->data, (padding*NewChannels + size) * sizeof(ALshort));
+                    if(temp)
                     {
-                    case 1:
-                        size /= sizeof(ALubyte);
-                        size *= 2;
+                        ALBuf->data = temp;
+                        ConvertDataRear(ALBuf->data, data, OrigBytes, size);
 
-                        // 8bit Samples are converted to 16 bit here
-                        // Allocate 8 extra samples
-                        ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
-                        if (ALBuf->data)
-                        {
-                            for (i = 0;i < size;i+=4)
-                            {
-                                ALBuf->data[i+0] = 0;
-                                ALBuf->data[i+1] = 0;
-                                ALBuf->data[i+2] = (ALshort)((((ALubyte*)data)[i/2+0]-128) << 8);
-                                ALBuf->data[i+3] = (ALshort)((((ALubyte*)data)[i/2+1]-128) << 8);
-                            }
-                            memset(&(ALBuf->data[size]), 0, 16*NewChannels);
+                        memset(&(ALBuf->data[size]), 0, padding*NewChannels*sizeof(ALshort));
 
-                            ALBuf->format = NewFormat;
-                            ALBuf->eOriginalFormat = format;
-                            ALBuf->size = size*1*sizeof(ALshort);
-                            ALBuf->frequency = freq;
-                        }
-                        else
-                            alSetError(AL_OUT_OF_MEMORY);
-                        break;
-
-                    case 2:
-                        size /= sizeof(ALshort);
-                        size *= 2;
-
-                        // Allocate 8 extra samples
-                        ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
-                        if (ALBuf->data)
-                        {
-                            for (i = 0;i < size;i+=4)
-                            {
-                                ALBuf->data[i+0] = 0;
-                                ALBuf->data[i+1] = 0;
-                                ALBuf->data[i+2] = ((ALshort*)data)[i/2+0];
-                                ALBuf->data[i+3] = ((ALshort*)data)[i/2+1];
-                            }
-                            memset(&(ALBuf->data[size]), 0, 16*NewChannels);
-
-                            ALBuf->format = NewFormat;
-                            ALBuf->eOriginalFormat = format;
-                            ALBuf->size = size*1*sizeof(ALshort);
-                            ALBuf->frequency = freq;
-                        }
-                        else
-                            alSetError(AL_OUT_OF_MEMORY);
-                        break;
-
-                    case 4:
-                        size /= sizeof(ALfloat);
-                        size *= 2;
-
-                        // Allocate 8 extra samples
-                        ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
-                        if (ALBuf->data)
-                        {
-                            ALint smp;
-                            for (i = 0;i < size;i+=4)
-                            {
-                                ALBuf->data[i+0] = 0;
-                                ALBuf->data[i+1] = 0;
-                                smp = (((ALfloat*)data)[i/2+0] * 32767.5f - 0.5);
-                                smp = min(smp,  32767);
-                                smp = max(smp, -32768);
-                                ALBuf->data[i+2] = (ALshort)smp;
-                                smp = (((ALfloat*)data)[i/2+1] * 32767.5f - 0.5);
-                                smp = min(smp,  32767);
-                                smp = max(smp, -32768);
-                                ALBuf->data[i+3] = (ALshort)smp;
-                            }
-                            memset(&(ALBuf->data[size]), 0, 16*NewChannels);
-
-                            ALBuf->format = NewFormat;
-                            ALBuf->eOriginalFormat = format;
-                            ALBuf->size = size*1*sizeof(ALshort);
-                            ALBuf->frequency = freq;
-                        }
-                        else
-                            alSetError(AL_OUT_OF_MEMORY);
-                        break;
-
-                    default:
-                        assert(0);
+                        ALBuf->format = NewFormat;
+                        ALBuf->eOriginalFormat = format;
+                        ALBuf->size = size*sizeof(ALshort);
+                        ALBuf->frequency = freq;
+                        ALBuf->padding = padding;
                     }
+                    else
+                        alSetError(AL_OUT_OF_MEMORY);
                 }   break;
 
                 case AL_FORMAT_QUAD8_LOKI:
@@ -428,157 +349,39 @@ ALAPI ALvoid ALAPIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *d
                     break;
 
                 case AL_FORMAT_MONO_IMA4:
+                case AL_FORMAT_STEREO_IMA4: {
+                    int OrigChans = ((format==AL_FORMAT_MONO_IMA4) ? 1 : 2);
+
                     // Here is where things vary:
-                    // nVidia and Apple use 64+1 samples per block => block_size=36 bytes
-                    // Most PC sound software uses 2040+1 samples per block -> block_size=1024 bytes
-                    if ((size%36) == 0)
+                    // nVidia and Apple use 64+1 samples per channel per block => block_size=36*chans bytes
+                    // Most PC sound software uses 2040+1 samples per channel per block -> block_size=1024*chans bytes
+                    if((size%(36*OrigChans)) != 0)
                     {
-                        // Allocate 8 extra samples (16 bytes)
-                        ALBuf->data=realloc(ALBuf->data,16+(size/36)*(65*sizeof(ALshort)));
-                        if (ALBuf->data)
-                        {
-                            ALBuf->format = AL_FORMAT_MONO16;
-                            ALBuf->eOriginalFormat = AL_FORMAT_MONO_IMA4;
-                            IMAData=(ALuint *)data;
-                            for (i=0;i<size/36;i++)
-                            {
-                                Sample=((ALshort *)IMAData)[0];
-                                Index=((ALshort *)IMAData)[1];
-
-                                Index=Index<0?0:Index;
-                                Index=Index>88?88:Index;
-
-                                ALBuf->data[i*65]=(short)Sample;
-
-                                IMAData++;
-
-                                for (j=1;j<65;j+=8)
-                                {
-                                    IMACode=*IMAData;
-                                    for (k=0;k<8;k+=2)
-                                    {
-                                        Sample+=((g_IMAStep_size[Index]*g_IMACodeword_4[IMACode&15])/8);
-                                        Index+=g_IMAIndex_adjust_4[IMACode&15];
-                                        if (Sample<-32768) Sample=-32768;
-                                        else if (Sample>32767) Sample=32767;
-                                        if (Index<0) Index=0;
-                                        else if (Index>88) Index=88;
-                                        ALBuf->data[i*65+j+k]=(short)Sample;
-                                        IMACode>>=4;
-
-                                        Sample+=((g_IMAStep_size[Index]*g_IMACodeword_4[IMACode&15])/8);
-                                        Index+=g_IMAIndex_adjust_4[IMACode&15];
-                                        if (Sample<-32768) Sample=-32768;
-                                        else if (Sample>32767) Sample=32767;
-                                        if (Index<0) Index=0;
-                                        else if (Index>88) Index=88;
-                                        ALBuf->data[i*65+j+k+1]=(short)Sample;
-                                        IMACode>>=4;
-                                    }
-                                    IMAData++;
-                                }
-                            }
-                            memset(&(ALBuf->data[(size/36*65)]), 0, 16);
-                            ALBuf->size=size/36*65*sizeof(ALshort);
-                            ALBuf->frequency=freq;
-                        }
-                        else
-                            alSetError(AL_OUT_OF_MEMORY);
-                    }
-                    else
-                         alSetError(AL_INVALID_VALUE);
-                    break;
-
-                case AL_FORMAT_STEREO_IMA4:
-                    // Here is where things vary:
-                    // nVidia and Apple use 64+1 samples per channel per block => block_size=72 bytes
-                    // Most PC sound software uses 2040+1 samples per channel per block -> block_size=2048 bytes
-                    if ((size%72) == 0)
-                    {
-                        // Allocate 8 extra samples (32 bytes)
-                        ALBuf->data=realloc(ALBuf->data,32+(size/72)*(2*65*sizeof(ALshort)));
-                        if (ALBuf->data)
-                        {
-                            ALBuf->format = AL_FORMAT_STEREO16;
-                            ALBuf->eOriginalFormat = AL_FORMAT_STEREO_IMA4;
-                            IMAData=(ALuint *)data;
-                            for (i=0;i<size/72;i++)
-                            {
-                                LeftSample=((ALshort *)IMAData)[0];
-                                LeftIndex=((ALshort *)IMAData)[1];
-
-                                LeftIndex=LeftIndex<0?0:LeftIndex;
-                                LeftIndex=LeftIndex>88?88:LeftIndex;
-
-                                ALBuf->data[i*2*65]=(short)LeftSample;
-
-                                IMAData++;
-
-                                RightSample=((ALshort *)IMAData)[0];
-                                RightIndex=((ALshort *)IMAData)[1];
-
-                                RightIndex=RightIndex<0?0:RightIndex;
-                                RightIndex=RightIndex>88?88:RightIndex;
-
-                                ALBuf->data[i*2*65+1]=(short)RightSample;
-
-                                IMAData++;
-
-                                for (j=2;j<130;j+=16)
-                                {
-                                    LeftIMACode=IMAData[0];
-                                    RightIMACode=IMAData[1];
-                                    for (k=0;k<16;k+=4)
-                                    {
-                                        LeftSample+=((g_IMAStep_size[LeftIndex]*g_IMACodeword_4[LeftIMACode&15])/8);
-                                        LeftIndex+=g_IMAIndex_adjust_4[LeftIMACode&15];
-                                        if (LeftSample<-32768) LeftSample=-32768;
-                                        else if (LeftSample>32767) LeftSample=32767;
-                                        if (LeftIndex<0) LeftIndex=0;
-                                        else if (LeftIndex>88) LeftIndex=88;
-                                        ALBuf->data[i*2*65+j+k]=(short)LeftSample;
-                                        LeftIMACode>>=4;
-
-                                        RightSample+=((g_IMAStep_size[RightIndex]*g_IMACodeword_4[RightIMACode&15])/8);
-                                        RightIndex+=g_IMAIndex_adjust_4[RightIMACode&15];
-                                        if (RightSample<-32768) RightSample=-32768;
-                                        else if (RightSample>32767) RightSample=32767;
-                                        if (RightIndex<0) RightIndex=0;
-                                        else if (RightIndex>88) RightIndex=88;
-                                        ALBuf->data[i*2*65+j+k+1]=(short)RightSample;
-                                        RightIMACode>>=4;
-
-                                        LeftSample+=((g_IMAStep_size[LeftIndex]*g_IMACodeword_4[LeftIMACode&15])/8);
-                                        LeftIndex+=g_IMAIndex_adjust_4[LeftIMACode&15];
-                                        if (LeftSample<-32768) LeftSample=-32768;
-                                        else if (LeftSample>32767) LeftSample=32767;
-                                        if (LeftIndex<0) LeftIndex=0;
-                                        else if (LeftIndex>88) LeftIndex=88;
-                                        ALBuf->data[i*2*65+j+k+2]=(short)LeftSample;
-                                        LeftIMACode>>=4;
-
-                                        RightSample+=((g_IMAStep_size[RightIndex]*g_IMACodeword_4[RightIMACode&15])/8);
-                                        RightIndex+=g_IMAIndex_adjust_4[RightIMACode&15];
-                                        if (RightSample<-32768) RightSample=-32768;
-                                        else if (RightSample>32767) RightSample=32767;
-                                        if (RightIndex<0) RightIndex=0;
-                                        else if (RightIndex>88) RightIndex=88;
-                                        ALBuf->data[i*2*65+j+k+3]=(short)RightSample;
-                                        RightIMACode>>=4;
-                                    }
-                                    IMAData+=2;
-                                }
-                            }
-                            memset(&(ALBuf->data[(size/72*2*65)]), 0, 32);
-                            ALBuf->size=size/72*2*65*sizeof(ALshort);
-                            ALBuf->frequency=freq;
-                        }
-                        else
-                            alSetError(AL_OUT_OF_MEMORY);
-                    }
-                    else
                         alSetError(AL_INVALID_VALUE);
-                    break;
+                        break;
+                    }
+
+                    size /= 36;
+                    size *= 65;
+
+                    // Allocate extra padding samples
+                    temp = realloc(ALBuf->data, (padding*OrigChans + size)*sizeof(ALshort));
+                    if(temp)
+                    {
+                        ALBuf->data = temp;
+                        ConvertDataIMA4(ALBuf->data, data, OrigChans, size/65);
+
+                        memset(&(ALBuf->data[size]), 0, padding*sizeof(ALshort)*OrigChans);
+
+                        ALBuf->format = ((OrigChans==1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16);
+                        ALBuf->eOriginalFormat = format;
+                        ALBuf->size = size*sizeof(ALshort);
+                        ALBuf->frequency = freq;
+                        ALBuf->padding = padding;
+                    }
+                    else
+                        alSetError(AL_OUT_OF_MEMORY);
+                }   break;
 
                 default:
                     alSetError(AL_INVALID_ENUM);
@@ -600,6 +403,110 @@ ALAPI ALvoid ALAPIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *d
     ProcessContext(Context);
 }
 
+/*
+*    alBufferSubDataEXT(ALuint buffer,ALenum format,ALvoid *data,ALsizei offset,ALsizei length)
+*
+*    Fill buffer with audio data
+*/
+ALvoid ALAPIENTRY alBufferSubDataEXT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
+{
+    ALCcontext *Context;
+    ALbuffer *ALBuf;
+
+    Context = alcGetCurrentContext();
+    SuspendContext(Context);
+
+    if(alIsBuffer(buffer) && buffer != 0)
+    {
+        ALBuf = (ALbuffer*)ALTHUNK_LOOKUPENTRY(buffer);
+        if(ALBuf->data == NULL)
+        {
+            // buffer does not have any data
+            alSetError(AL_INVALID_NAME);
+        }
+        else if(length < 0 || offset < 0 || (length > 0 && data == NULL))
+        {
+            // data is NULL or offset/length is negative
+            alSetError(AL_INVALID_VALUE);
+        }
+        else
+        {
+            switch(format)
+            {
+                case AL_FORMAT_REAR8:
+                case AL_FORMAT_REAR16:
+                case AL_FORMAT_REAR32: {
+                    ALuint OrigBytes = ((format==AL_FORMAT_REAR8) ? 1 :
+                                        ((format==AL_FORMAT_REAR16) ? 2 :
+                                         4));
+
+                    if(ALBuf->eOriginalFormat != AL_FORMAT_REAR8 &&
+                       ALBuf->eOriginalFormat != AL_FORMAT_REAR16 &&
+                       ALBuf->eOriginalFormat != AL_FORMAT_REAR32)
+                    {
+                        alSetError(AL_INVALID_ENUM);
+                        break;
+                    }
+
+                    if(ALBuf->size/4/sizeof(ALshort) < (ALuint)offset+length)
+                    {
+                        alSetError(AL_INVALID_VALUE);
+                        break;
+                    }
+
+                    ConvertDataRear(&ALBuf->data[offset*4], data, OrigBytes, length*2);
+                }   break;
+
+                case AL_FORMAT_MONO_IMA4:
+                case AL_FORMAT_STEREO_IMA4: {
+                    int Channels = aluChannelsFromFormat(ALBuf->format);
+
+                    if(ALBuf->eOriginalFormat != format)
+                    {
+                        alSetError(AL_INVALID_ENUM);
+                        break;
+                    }
+
+                    if((offset%65) != 0 || (length%65) != 0 ||
+                       ALBuf->size/Channels/sizeof(ALshort) < (ALuint)offset+length)
+                    {
+                        alSetError(AL_INVALID_VALUE);
+                        break;
+                    }
+
+                    ConvertDataIMA4(&ALBuf->data[offset*Channels], data, Channels, length/65*Channels);
+                }   break;
+
+                default: {
+                    ALuint Channels = aluChannelsFromFormat(format);
+                    ALuint Bytes = aluBytesFromFormat(format);
+
+                    if(Channels != aluChannelsFromFormat(ALBuf->format))
+                    {
+                        alSetError(AL_INVALID_ENUM);
+                        break;
+                    }
+
+                    if(ALBuf->size/Channels/sizeof(ALshort) < (ALuint)offset+length)
+                    {
+                        alSetError(AL_INVALID_VALUE);
+                        break;
+                    }
+
+                    ConvertData(&ALBuf->data[offset*Channels], data, Bytes, length*Channels);
+                }   break;
+            }
+        }
+    }
+    else
+    {
+        // Invalid Buffer Name
+        alSetError(AL_INVALID_NAME);
+    }
+
+    ProcessContext(Context);
+}
+
 
 ALAPI void ALAPIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
 {
@@ -997,7 +904,8 @@ static void LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint
     ALuint NewChannels = aluChannelsFromFormat(NewFormat);
     ALuint OrigBytes = aluBytesFromFormat(OrigFormat);
     ALuint OrigChannels = aluChannelsFromFormat(OrigFormat);
-    ALsizei i;
+    ALsizei padding = 2;
+    ALvoid *temp;
 
     assert(aluBytesFromFormat(NewFormat) == 2);
     assert(NewChannels == OrigChannels);
@@ -1008,79 +916,153 @@ static void LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint
         return;
     }
 
-    switch(OrigBytes)
+    // Samples are converted to 16 bit here
+    size /= OrigBytes;
+    temp = realloc(ALBuf->data, (padding*NewChannels + size) * sizeof(ALshort));
+    if(temp)
     {
-    case 1:
-        size /= sizeof(ALubyte);
+        ALBuf->data = temp;
+        ConvertData(ALBuf->data, data, OrigBytes, size);
 
-        // 8bit Samples are converted to 16 bit here
-        // Allocate 8 extra samples
-        ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
-        if (ALBuf->data)
-        {
-            for (i = 0;i < size;i++)
-                ALBuf->data[i] = (ALshort)((data[i]-128) << 8);
-            memset(&(ALBuf->data[size]), 0, 16*NewChannels);
+        memset(&(ALBuf->data[size]), 0, padding*NewChannels*sizeof(ALshort));
 
-            ALBuf->format = NewFormat;
-            ALBuf->eOriginalFormat = OrigFormat;
-            ALBuf->size = size*1*sizeof(ALshort);
-            ALBuf->frequency = freq;
-        }
-        else
-            alSetError(AL_OUT_OF_MEMORY);
-        break;
+        ALBuf->format = NewFormat;
+        ALBuf->eOriginalFormat = OrigFormat;
+        ALBuf->size = size*sizeof(ALshort);
+        ALBuf->frequency = freq;
+        ALBuf->padding = padding;
+    }
+    else
+        alSetError(AL_OUT_OF_MEMORY);
+}
 
-    case 2:
-        size /= sizeof(ALshort);
+static void ConvertData(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len)
+{
+    ALsizei i;
+    switch(origBytes)
+    {
+        case 1:
+            for(i = 0;i < len;i++)
+                dst[i] = ((ALshort)((ALubyte*)src)[i] - 128) << 8;
+            break;
 
-        // Allocate 8 extra samples
-        ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
-        if (ALBuf->data)
-        {
-            memcpy(ALBuf->data, data, size*1*sizeof(ALshort));
-            memset(&(ALBuf->data[size]), 0, 16*NewChannels);
+        case 2:
+            memcpy(dst, src, len*sizeof(ALshort));
+            break;
 
-            ALBuf->format = NewFormat;
-            ALBuf->eOriginalFormat = OrigFormat;
-            ALBuf->size = size*1*sizeof(ALshort);
-            ALBuf->frequency = freq;
-        }
-        else
-            alSetError(AL_OUT_OF_MEMORY);
-        break;
-
-    case 4:
-        size /= sizeof(ALfloat);
-
-        // Allocate 8 extra samples
-        ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
-        if (ALBuf->data)
-        {
-            ALint smp;
-            for (i = 0;i < size;i++)
+        case 4:
+            for(i = 0;i < len;i++)
             {
-                smp = (((ALfloat*)data)[i] * 32767.5f - 0.5f);
+                ALint smp;
+                smp = (((ALfloat*)src)[i] * 32767.5f - 0.5f);
                 smp = min(smp,  32767);
                 smp = max(smp, -32768);
-                ALBuf->data[i] = (ALshort)smp;
+                dst[i] = (ALshort)smp;
             }
-            memset(&(ALBuf->data[size]), 0, 16*NewChannels);
+            break;
 
-            ALBuf->format = NewFormat;
-            ALBuf->eOriginalFormat = OrigFormat;
-            ALBuf->size = size*1*sizeof(ALshort);
-            ALBuf->frequency = freq;
-        }
-        else
-            alSetError(AL_OUT_OF_MEMORY);
-        break;
-
-    default:
-        assert(0);
+        default:
+            assert(0);
     }
 }
 
+static void ConvertDataRear(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len)
+{
+    ALsizei i;
+    switch(origBytes)
+    {
+        case 1:
+            for(i = 0;i < len;i+=4)
+            {
+                dst[i+0] = 0;
+                dst[i+1] = 0;
+                dst[i+2] = ((ALshort)((ALubyte*)src)[i/2+0] - 128) << 8;
+                dst[i+3] = ((ALshort)((ALubyte*)src)[i/2+1] - 128) << 8;
+            }
+            break;
+
+        case 2:
+            for(i = 0;i < len;i+=4)
+            {
+                dst[i+0] = 0;
+                dst[i+1] = 0;
+                dst[i+2] = ((ALshort*)src)[i/2+0];
+                dst[i+3] = ((ALshort*)src)[i/2+1];
+            }
+            break;
+
+        case 4:
+            for(i = 0;i < len;i+=4)
+            {
+                ALint smp;
+                dst[i+0] = 0;
+                dst[i+1] = 0;
+                smp = (((ALfloat*)src)[i/2+0] * 32767.5f - 0.5);
+                smp = min(smp,  32767);
+                smp = max(smp, -32768);
+                dst[i+2] = (ALshort)smp;
+                smp = (((ALfloat*)src)[i/2+1] * 32767.5f - 0.5);
+                smp = min(smp,  32767);
+                smp = max(smp, -32768);
+                dst[i+3] = (ALshort)smp;
+            }
+            break;
+
+        default:
+            assert(0);
+    }
+}
+
+static void ConvertDataIMA4(ALshort *dst, const ALvoid *src, ALint origChans, ALsizei len)
+{
+    const ALuint *IMAData;
+    ALint Sample[2],Index[2];
+    ALuint IMACode[2];
+    ALsizei i,j,k,c;
+
+    assert(origChans <= 2);
+
+    IMAData = src;
+    for(i = 0;i < len/origChans;i++)
+    {
+        for(c = 0;c < origChans;c++)
+        {
+            Sample[c] = ((ALshort*)IMAData)[0];
+            Index[c] = ((ALshort*)IMAData)[1];
+
+            Index[c] = ((Index[c]<0) ? 0 : Index[c]);
+            Index[c] = ((Index[c]>88) ? 88 : Index[c]);
+
+            dst[i*65*origChans + c] = (ALshort)Sample[c];
+
+            IMAData++;
+        }
+
+        for(j = 1;j < 65;j += 8)
+        {
+            for(c = 0;c < origChans;c++)
+                IMACode[c] = *(IMAData++);
+
+            for(k = 0;k < 8;k++)
+            {
+                for(c = 0;c < origChans;c++)
+                {
+                    Sample[c] += ((g_IMAStep_size[Index[c]]*g_IMACodeword_4[IMACode[c]&15])/8);
+                    Index[c] += g_IMAIndex_adjust_4[IMACode[c]&15];
+
+                    if(Sample[c] < -32768) Sample[c] = -32768;
+                    else if(Sample[c] > 32767) Sample[c] = 32767;
+
+                    if(Index[c]<0) Index[c] = 0;
+                    else if(Index[c]>88) Index[c] = 88;
+
+                    dst[(i*65+j+k)*origChans + c] = (ALshort)Sample[c];
+                    IMACode[c] >>= 4;
+                }
+            }
+        }
+    }
+}
 
 /*
 *    ReleaseALBuffers()
@@ -1094,7 +1076,7 @@ ALvoid ReleaseALBuffers(ALvoid)
 
 #ifdef _DEBUG
     if(g_uiBufferCount > 0)
-        AL_PRINT("exit() %d Buffer(s) NOT deleted\n", g_uiBufferCount);
+        AL_PRINT("exit(): deleting %d Buffer(s)\n", g_uiBufferCount);
 #endif
 
     ALBuffer = g_pBuffers;

OpenAL32/alEffect.c

@@ -21,6 +21,7 @@
 #include "config.h"
 
 #include <stdlib.h>
+#include <math.h>
 
 #include "AL/al.h"
 #include "AL/alc.h"
@@ -29,13 +30,17 @@
 #include "alThunk.h"
 #include "alError.h"
 
+
+ALboolean DisabledEffects[MAX_EFFECTS];
+
+
 static ALeffect *g_EffectList;
 static ALuint    g_EffectCount;
 
 static void InitEffectParams(ALeffect *effect, ALenum type);
 
 
-AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
+ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
 {
     ALCcontext *Context;
     ALsizei i;
@@ -79,7 +84,7 @@ AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
+ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
 {
     ALCcontext *Context;
     ALeffect *ALEffect;
@@ -135,7 +140,7 @@ AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
     ProcessContext(Context);
 }
 
-AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
+ALboolean AL_APIENTRY alIsEffect(ALuint effect)
 {
     ALCcontext *Context;
     ALeffect **list;
@@ -152,7 +157,7 @@ AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
     return ((*list || !effect) ? AL_TRUE : AL_FALSE);
 }
 
-AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
+ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
 {
     ALCcontext *Context;
 
@@ -165,18 +170,40 @@ AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
 
         if(param == AL_EFFECT_TYPE)
         {
-            if(iValue == AL_EFFECT_NULL ||
-               iValue == AL_EFFECT_REVERB)
+            ALboolean isOk = (iValue == AL_EFFECT_NULL ||
+                (iValue == AL_EFFECT_EAXREVERB && !DisabledEffects[EAXREVERB]) ||
+                (iValue == AL_EFFECT_REVERB && !DisabledEffects[REVERB]) ||
+                (iValue == AL_EFFECT_ECHO && !DisabledEffects[ECHO]));
+
+            if(isOk)
                 InitEffectParams(ALEffect, iValue);
             else
                 alSetError(AL_INVALID_VALUE);
         }
+        else if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DECAY_HFLIMIT:
+                if(iValue >= AL_EAXREVERB_MIN_DECAY_HFLIMIT &&
+                   iValue <= AL_EAXREVERB_MAX_DECAY_HFLIMIT)
+                    ALEffect->Reverb.DecayHFLimit = iValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
             {
             case AL_REVERB_DECAY_HFLIMIT:
-                if(iValue == AL_TRUE || iValue == AL_FALSE)
+                if(iValue >= AL_REVERB_MIN_DECAY_HFLIMIT &&
+                   iValue <= AL_REVERB_MAX_DECAY_HFLIMIT)
                     ALEffect->Reverb.DecayHFLimit = iValue;
                 else
                     alSetError(AL_INVALID_VALUE);
@@ -187,6 +214,15 @@ AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -196,7 +232,7 @@ AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues)
+ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues)
 {
     ALCcontext *Context;
 
@@ -211,6 +247,19 @@ AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValue
         {
             alEffecti(effect, param, piValues[0]);
         }
+        else if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DECAY_HFLIMIT:
+                alEffecti(effect, param, piValues[0]);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
@@ -224,6 +273,15 @@ AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValue
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -233,7 +291,7 @@ AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValue
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
+ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
 {
     ALCcontext *Context;
 
@@ -244,89 +302,269 @@ AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue
     {
         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 
-        if(ALEffect->type == AL_EFFECT_REVERB)
+        if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DENSITY:
+                if(flValue >= AL_EAXREVERB_MIN_DENSITY &&
+                   flValue <= AL_EAXREVERB_MAX_DENSITY)
+                    ALEffect->Reverb.Density = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_DIFFUSION:
+                if(flValue >= AL_EAXREVERB_MIN_DIFFUSION &&
+                   flValue <= AL_EAXREVERB_MAX_DIFFUSION)
+                    ALEffect->Reverb.Diffusion = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_GAIN:
+                if(flValue >= AL_EAXREVERB_MIN_GAIN &&
+                   flValue <= AL_EAXREVERB_MAX_GAIN)
+                    ALEffect->Reverb.Gain = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_GAINHF:
+                if(flValue >= AL_EAXREVERB_MIN_GAINHF &&
+                   flValue <= AL_EAXREVERB_MAX_GAIN)
+                    ALEffect->Reverb.GainHF = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_GAINLF:
+                if(flValue >= AL_EAXREVERB_MIN_GAINLF &&
+                   flValue <= AL_EAXREVERB_MAX_GAINLF)
+                    ALEffect->Reverb.GainLF = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_DECAY_TIME:
+                if(flValue >= AL_EAXREVERB_MIN_DECAY_TIME &&
+                   flValue <= AL_EAXREVERB_MAX_DECAY_TIME)
+                    ALEffect->Reverb.DecayTime = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_DECAY_HFRATIO:
+                if(flValue >= AL_EAXREVERB_MIN_DECAY_HFRATIO &&
+                   flValue <= AL_EAXREVERB_MAX_DECAY_HFRATIO)
+                    ALEffect->Reverb.DecayHFRatio = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_DECAY_LFRATIO:
+                if(flValue >= AL_EAXREVERB_MIN_DECAY_LFRATIO &&
+                   flValue <= AL_EAXREVERB_MAX_DECAY_LFRATIO)
+                    ALEffect->Reverb.DecayLFRatio = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_REFLECTIONS_GAIN:
+                if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN &&
+                   flValue <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN)
+                    ALEffect->Reverb.ReflectionsGain = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_REFLECTIONS_DELAY:
+                if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY &&
+                   flValue <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY)
+                    ALEffect->Reverb.ReflectionsDelay = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_LATE_REVERB_GAIN:
+                if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN &&
+                   flValue <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN)
+                    ALEffect->Reverb.LateReverbGain = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_LATE_REVERB_DELAY:
+                if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY &&
+                   flValue <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY)
+                    ALEffect->Reverb.LateReverbDelay = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
+                if(flValue >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF &&
+                   flValue <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF)
+                    ALEffect->Reverb.AirAbsorptionGainHF = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_ECHO_TIME:
+                if(flValue >= AL_EAXREVERB_MIN_ECHO_TIME &&
+                   flValue <= AL_EAXREVERB_MAX_ECHO_TIME)
+                    ALEffect->Reverb.EchoTime = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_ECHO_DEPTH:
+                if(flValue >= AL_EAXREVERB_MIN_ECHO_DEPTH &&
+                   flValue <= AL_EAXREVERB_MAX_ECHO_DEPTH)
+                    ALEffect->Reverb.EchoDepth = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_MODULATION_TIME:
+                if(flValue >= AL_EAXREVERB_MIN_MODULATION_TIME &&
+                   flValue <= AL_EAXREVERB_MAX_MODULATION_TIME)
+                    ALEffect->Reverb.ModulationTime = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_MODULATION_DEPTH:
+                if(flValue >= AL_EAXREVERB_MIN_MODULATION_DEPTH &&
+                   flValue <= AL_EAXREVERB_MAX_MODULATION_DEPTH)
+                    ALEffect->Reverb.ModulationDepth = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_HFREFERENCE:
+                if(flValue >= AL_EAXREVERB_MIN_HFREFERENCE &&
+                   flValue <= AL_EAXREVERB_MAX_HFREFERENCE)
+                    ALEffect->Reverb.HFReference = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_LFREFERENCE:
+                if(flValue >= AL_EAXREVERB_MIN_LFREFERENCE &&
+                   flValue <= AL_EAXREVERB_MAX_LFREFERENCE)
+                    ALEffect->Reverb.LFReference = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
+                if(flValue >= 0.0f && flValue <= 10.0f)
+                    ALEffect->Reverb.RoomRolloffFactor = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
             {
             case AL_REVERB_DENSITY:
-                if(flValue >= 0.0f && flValue <= 1.0f)
+                if(flValue >= AL_REVERB_MIN_DENSITY &&
+                   flValue <= AL_REVERB_MAX_DENSITY)
                     ALEffect->Reverb.Density = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_DIFFUSION:
-                if(flValue >= 0.0f && flValue <= 1.0f)
+                if(flValue >= AL_REVERB_MIN_DIFFUSION &&
+                   flValue <= AL_REVERB_MAX_DIFFUSION)
                     ALEffect->Reverb.Diffusion = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_GAIN:
-                if(flValue >= 0.0f && flValue <= 1.0f)
+                if(flValue >= AL_REVERB_MIN_GAIN &&
+                   flValue <= AL_REVERB_MAX_GAIN)
                     ALEffect->Reverb.Gain = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_GAINHF:
-                if(flValue >= 0.0f && flValue <= 1.0f)
+                if(flValue >= AL_REVERB_MIN_GAINHF &&
+                   flValue <= AL_REVERB_MAX_GAINHF)
                     ALEffect->Reverb.GainHF = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_DECAY_TIME:
-                if(flValue >= 0.1f && flValue <= 20.0f)
+                if(flValue >= AL_REVERB_MIN_DECAY_TIME &&
+                   flValue <= AL_REVERB_MAX_DECAY_TIME)
                     ALEffect->Reverb.DecayTime = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_DECAY_HFRATIO:
-                if(flValue >= 0.1f && flValue <= 2.0f)
+                if(flValue >= AL_REVERB_MIN_DECAY_HFRATIO &&
+                   flValue <= AL_REVERB_MAX_DECAY_HFRATIO)
                     ALEffect->Reverb.DecayHFRatio = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_REFLECTIONS_GAIN:
-                if(flValue >= 0.0f && flValue <= 3.16f)
+                if(flValue >= AL_REVERB_MIN_REFLECTIONS_GAIN &&
+                   flValue <= AL_REVERB_MAX_REFLECTIONS_GAIN)
                     ALEffect->Reverb.ReflectionsGain = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_REFLECTIONS_DELAY:
-                if(flValue >= 0.0f && flValue <= 0.3f)
+                if(flValue >= AL_REVERB_MIN_REFLECTIONS_DELAY &&
+                   flValue <= AL_REVERB_MAX_REFLECTIONS_DELAY)
                     ALEffect->Reverb.ReflectionsDelay = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_LATE_REVERB_GAIN:
-                if(flValue >= 0.0f && flValue <= 10.0f)
+                if(flValue >= AL_REVERB_MIN_LATE_REVERB_GAIN &&
+                   flValue <= AL_REVERB_MAX_LATE_REVERB_GAIN)
                     ALEffect->Reverb.LateReverbGain = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_LATE_REVERB_DELAY:
-                if(flValue >= 0.0f && flValue <= 0.1f)
+                if(flValue >= AL_REVERB_MIN_LATE_REVERB_DELAY &&
+                   flValue <= AL_REVERB_MAX_LATE_REVERB_DELAY)
                     ALEffect->Reverb.LateReverbDelay = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_AIR_ABSORPTION_GAINHF:
-                if(flValue >= 0.892f && flValue <= 1.0f)
+                if(flValue >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF &&
+                   flValue <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF)
                     ALEffect->Reverb.AirAbsorptionGainHF = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
-                if(flValue >= 0.0f && flValue <= 10.0f)
+                if(flValue >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR &&
+                   flValue <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR)
                     ALEffect->Reverb.RoomRolloffFactor = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
@@ -337,6 +575,50 @@ AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            case AL_ECHO_DELAY:
+                if(flValue >= AL_ECHO_MIN_DELAY && flValue <= AL_ECHO_MAX_DELAY)
+                    ALEffect->Echo.Delay = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_ECHO_LRDELAY:
+                if(flValue >= AL_ECHO_MIN_LRDELAY && flValue <= AL_ECHO_MAX_LRDELAY)
+                    ALEffect->Echo.LRDelay = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_ECHO_DAMPING:
+                if(flValue >= AL_ECHO_MIN_DAMPING && flValue <= AL_ECHO_MAX_DAMPING)
+                    ALEffect->Echo.Damping = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_ECHO_FEEDBACK:
+                if(flValue >= AL_ECHO_MIN_FEEDBACK && flValue <= AL_ECHO_MAX_FEEDBACK)
+                    ALEffect->Echo.Feedback = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            case AL_ECHO_SPREAD:
+                if(flValue >= AL_ECHO_MIN_SPREAD && flValue <= AL_ECHO_MAX_SPREAD)
+                    ALEffect->Echo.Spread = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -346,7 +628,7 @@ AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
+ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 {
     ALCcontext *Context;
 
@@ -357,7 +639,60 @@ AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflVa
     {
         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 
-        if(ALEffect->type == AL_EFFECT_REVERB)
+        if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DENSITY:
+            case AL_EAXREVERB_DIFFUSION:
+            case AL_EAXREVERB_GAIN:
+            case AL_EAXREVERB_GAINHF:
+            case AL_EAXREVERB_GAINLF:
+            case AL_EAXREVERB_DECAY_TIME:
+            case AL_EAXREVERB_DECAY_HFRATIO:
+            case AL_EAXREVERB_DECAY_LFRATIO:
+            case AL_EAXREVERB_REFLECTIONS_GAIN:
+            case AL_EAXREVERB_REFLECTIONS_DELAY:
+            case AL_EAXREVERB_LATE_REVERB_GAIN:
+            case AL_EAXREVERB_LATE_REVERB_DELAY:
+            case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
+            case AL_EAXREVERB_ECHO_TIME:
+            case AL_EAXREVERB_ECHO_DEPTH:
+            case AL_EAXREVERB_MODULATION_TIME:
+            case AL_EAXREVERB_MODULATION_DEPTH:
+            case AL_EAXREVERB_HFREFERENCE:
+            case AL_EAXREVERB_LFREFERENCE:
+            case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
+                alEffectf(effect, param, pflValues[0]);
+                break;
+
+            case AL_EAXREVERB_REFLECTIONS_PAN:
+                if(!isnan(pflValues[0]) && !isnan(pflValues[1]) && !isnan(pflValues[2]))
+                {
+                    ALEffect->Reverb.ReflectionsPan[0] = pflValues[0];
+                    ALEffect->Reverb.ReflectionsPan[1] = pflValues[1];
+                    ALEffect->Reverb.ReflectionsPan[2] = pflValues[2];
+                }
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+            case AL_EAXREVERB_LATE_REVERB_PAN:
+                if(!isnan(pflValues[0]) && !isnan(pflValues[1]) && !isnan(pflValues[2]))
+                {
+                    ALEffect->Reverb.LateReverbPan[0] = pflValues[0];
+                    ALEffect->Reverb.LateReverbPan[1] = pflValues[1];
+                    ALEffect->Reverb.LateReverbPan[2] = pflValues[2];
+                }
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
             {
@@ -381,6 +716,23 @@ AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflVa
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            case AL_ECHO_DELAY:
+            case AL_ECHO_LRDELAY:
+            case AL_ECHO_DAMPING:
+            case AL_ECHO_FEEDBACK:
+            case AL_ECHO_SPREAD:
+                alEffectf(effect, param, pflValues[0]);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -390,7 +742,7 @@ AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflVa
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
+ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
 {
     ALCcontext *Context;
 
@@ -405,6 +757,19 @@ AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piVal
         {
             *piValue = ALEffect->type;
         }
+        else if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DECAY_HFLIMIT:
+                *piValue = ALEffect->Reverb.DecayHFLimit;
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
@@ -418,6 +783,15 @@ AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piVal
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -427,7 +801,7 @@ AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piVal
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
+ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
 {
     ALCcontext *Context;
 
@@ -442,6 +816,19 @@ AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piVa
         {
             alGetEffecti(effect, param, piValues);
         }
+        else if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DECAY_HFLIMIT:
+                alGetEffecti(effect, param, piValues);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
@@ -455,6 +842,15 @@ AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piVa
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -464,7 +860,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piVa
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
+ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
 {
     ALCcontext *Context;
 
@@ -475,7 +871,96 @@ AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pfl
     {
         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 
-        if(ALEffect->type == AL_EFFECT_REVERB)
+        if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DENSITY:
+                *pflValue = ALEffect->Reverb.Density;
+                break;
+
+            case AL_EAXREVERB_DIFFUSION:
+                *pflValue = ALEffect->Reverb.Diffusion;
+                break;
+
+            case AL_EAXREVERB_GAIN:
+                *pflValue = ALEffect->Reverb.Gain;
+                break;
+
+            case AL_EAXREVERB_GAINHF:
+                *pflValue = ALEffect->Reverb.GainHF;
+                break;
+
+            case AL_EAXREVERB_GAINLF:
+                *pflValue = ALEffect->Reverb.GainLF;
+                break;
+
+            case AL_EAXREVERB_DECAY_TIME:
+                *pflValue = ALEffect->Reverb.DecayTime;
+                break;
+
+            case AL_EAXREVERB_DECAY_HFRATIO:
+                *pflValue = ALEffect->Reverb.DecayHFRatio;
+                break;
+
+            case AL_EAXREVERB_DECAY_LFRATIO:
+                *pflValue = ALEffect->Reverb.DecayLFRatio;
+                break;
+
+            case AL_EAXREVERB_REFLECTIONS_GAIN:
+                *pflValue = ALEffect->Reverb.ReflectionsGain;
+                break;
+
+            case AL_EAXREVERB_REFLECTIONS_DELAY:
+                *pflValue = ALEffect->Reverb.ReflectionsDelay;
+                break;
+
+            case AL_EAXREVERB_LATE_REVERB_GAIN:
+                *pflValue = ALEffect->Reverb.LateReverbGain;
+                break;
+
+            case AL_EAXREVERB_LATE_REVERB_DELAY:
+                *pflValue = ALEffect->Reverb.LateReverbDelay;
+                break;
+
+            case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
+                *pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
+                break;
+
+            case AL_EAXREVERB_ECHO_TIME:
+                *pflValue = ALEffect->Reverb.EchoTime;
+                break;
+
+            case AL_EAXREVERB_ECHO_DEPTH:
+                *pflValue = ALEffect->Reverb.EchoDepth;
+                break;
+
+            case AL_EAXREVERB_MODULATION_TIME:
+                *pflValue = ALEffect->Reverb.ModulationTime;
+                break;
+
+            case AL_EAXREVERB_MODULATION_DEPTH:
+                *pflValue = ALEffect->Reverb.ModulationDepth;
+                break;
+
+            case AL_EAXREVERB_HFREFERENCE:
+                *pflValue = ALEffect->Reverb.HFReference;
+                break;
+
+            case AL_EAXREVERB_LFREFERENCE:
+                *pflValue = ALEffect->Reverb.LFReference;
+                break;
+
+            case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
+                *pflValue = ALEffect->Reverb.RoomRolloffFactor;
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
             {
@@ -532,6 +1017,35 @@ AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pfl
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            case AL_ECHO_DELAY:
+                *pflValue = ALEffect->Echo.Delay;
+                break;
+
+            case AL_ECHO_LRDELAY:
+                *pflValue = ALEffect->Echo.LRDelay;
+                break;
+
+            case AL_ECHO_DAMPING:
+                *pflValue = ALEffect->Echo.Damping;
+                break;
+
+            case AL_ECHO_FEEDBACK:
+                *pflValue = ALEffect->Echo.Feedback;
+                break;
+
+            case AL_ECHO_SPREAD:
+                *pflValue = ALEffect->Echo.Spread;
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -541,7 +1055,7 @@ AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pfl
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
+ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 {
     ALCcontext *Context;
 
@@ -552,7 +1066,50 @@ AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pf
     {
         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 
-        if(ALEffect->type == AL_EFFECT_REVERB)
+        if(ALEffect->type == AL_EFFECT_EAXREVERB)
+        {
+            switch(param)
+            {
+            case AL_EAXREVERB_DENSITY:
+            case AL_EAXREVERB_DIFFUSION:
+            case AL_EAXREVERB_GAIN:
+            case AL_EAXREVERB_GAINHF:
+            case AL_EAXREVERB_GAINLF:
+            case AL_EAXREVERB_DECAY_TIME:
+            case AL_EAXREVERB_DECAY_HFRATIO:
+            case AL_EAXREVERB_DECAY_LFRATIO:
+            case AL_EAXREVERB_REFLECTIONS_GAIN:
+            case AL_EAXREVERB_REFLECTIONS_DELAY:
+            case AL_EAXREVERB_LATE_REVERB_GAIN:
+            case AL_EAXREVERB_LATE_REVERB_DELAY:
+            case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
+            case AL_EAXREVERB_ECHO_TIME:
+            case AL_EAXREVERB_ECHO_DEPTH:
+            case AL_EAXREVERB_MODULATION_TIME:
+            case AL_EAXREVERB_MODULATION_DEPTH:
+            case AL_EAXREVERB_HFREFERENCE:
+            case AL_EAXREVERB_LFREFERENCE:
+            case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
+                alGetEffectf(effect, param, pflValues);
+                break;
+
+            case AL_EAXREVERB_REFLECTIONS_PAN:
+                pflValues[0] = ALEffect->Reverb.ReflectionsPan[0];
+                pflValues[1] = ALEffect->Reverb.ReflectionsPan[1];
+                pflValues[2] = ALEffect->Reverb.ReflectionsPan[2];
+                break;
+            case AL_EAXREVERB_LATE_REVERB_PAN:
+                pflValues[0] = ALEffect->Reverb.LateReverbPan[0];
+                pflValues[1] = ALEffect->Reverb.LateReverbPan[1];
+                pflValues[2] = ALEffect->Reverb.LateReverbPan[2];
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
+        else if(ALEffect->type == AL_EFFECT_REVERB)
         {
             switch(param)
             {
@@ -576,6 +1133,23 @@ AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pf
                 break;
             }
         }
+        else if(ALEffect->type == AL_EFFECT_ECHO)
+        {
+            switch(param)
+            {
+            case AL_ECHO_DELAY:
+            case AL_ECHO_LRDELAY:
+            case AL_ECHO_DAMPING:
+            case AL_ECHO_FEEDBACK:
+            case AL_ECHO_SPREAD:
+                alGetEffectf(effect, param, pflValues);
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+        }
         else
             alSetError(AL_INVALID_ENUM);
     }
@@ -590,7 +1164,7 @@ ALvoid ReleaseALEffects(ALvoid)
 {
 #ifdef _DEBUG
     if(g_EffectCount > 0)
-        AL_PRINT("exit() %d Effect(s) NOT deleted\n", g_EffectCount);
+        AL_PRINT("exit(): deleting %d Effect(s)\n", g_EffectCount);
 #endif
 
     while(g_EffectList)
@@ -611,20 +1185,46 @@ static void InitEffectParams(ALeffect *effect, ALenum type)
     effect->type = type;
     switch(type)
     {
+    /* NOTE: Standard reverb and EAX reverb use the same defaults for the
+     *       shared parameters, and EAX's additional parameters default to
+     *       values assumed by standard reverb.
+     */
+    case AL_EFFECT_EAXREVERB:
     case AL_EFFECT_REVERB:
-        effect->Reverb.Density = 1.0f;
-        effect->Reverb.Diffusion = 1.0f;
-        effect->Reverb.Gain = 0.32f;
-        effect->Reverb.GainHF = 0.89f;
-        effect->Reverb.DecayTime = 1.49f;
-        effect->Reverb.DecayHFRatio = 0.83f;
-        effect->Reverb.ReflectionsGain = 0.05f;
-        effect->Reverb.ReflectionsDelay = 0.007f;
-        effect->Reverb.LateReverbGain = 1.26f;
-        effect->Reverb.LateReverbDelay = 0.011f;
-        effect->Reverb.AirAbsorptionGainHF = 0.994f;
-        effect->Reverb.RoomRolloffFactor = 0.0f;
-        effect->Reverb.DecayHFLimit = AL_TRUE;
+        effect->Reverb.Density = AL_EAXREVERB_DEFAULT_DENSITY;
+        effect->Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
+        effect->Reverb.Gain = AL_EAXREVERB_DEFAULT_GAIN;
+        effect->Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF;
+        effect->Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF;
+        effect->Reverb.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME;
+        effect->Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
+        effect->Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
+        effect->Reverb.ReflectionsGain = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN;
+        effect->Reverb.ReflectionsDelay = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY;
+        effect->Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+        effect->Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+        effect->Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
+        effect->Reverb.LateReverbGain = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN;
+        effect->Reverb.LateReverbDelay = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY;
+        effect->Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+        effect->Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+        effect->Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
+        effect->Reverb.EchoTime = AL_EAXREVERB_DEFAULT_ECHO_TIME;
+        effect->Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH;
+        effect->Reverb.ModulationTime = AL_EAXREVERB_DEFAULT_MODULATION_TIME;
+        effect->Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH;
+        effect->Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
+        effect->Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
+        effect->Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
+        effect->Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
+        effect->Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT;
+        break;
+    case AL_EFFECT_ECHO:
+        effect->Echo.Delay = AL_ECHO_DEFAULT_DELAY;
+        effect->Echo.LRDelay = AL_ECHO_DEFAULT_LRDELAY;
+        effect->Echo.Damping = AL_ECHO_DEFAULT_DAMPING;
+        effect->Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK;
+        effect->Echo.Spread = AL_ECHO_DEFAULT_SPREAD;
         break;
     }
 }

OpenAL32/alExtension.c

@@ -30,6 +30,7 @@
 #include "alEffect.h"
 #include "alAuxEffectSlot.h"
 #include "alSource.h"
+#include "alBuffer.h"
 #include "AL/al.h"
 #include "AL/alc.h"
 
@@ -144,6 +145,8 @@ static ALfunction  function[]=   {
     { "alGetAuxiliaryEffectSlotf",  (ALvoid *) alGetAuxiliaryEffectSlotf },
     { "alGetAuxiliaryEffectSlotfv", (ALvoid *) alGetAuxiliaryEffectSlotfv},
 
+    { "alBufferSubDataEXT",         (ALvoid *) alBufferSubDataEXT        },
+
     { NULL,                         (ALvoid *) NULL                      } };
 
 static ALenums enumeration[]={

OpenAL32/alFilter.c

@@ -35,7 +35,7 @@ static ALuint    g_FilterCount;
 static void InitFilterParams(ALfilter *filter, ALenum type);
 
 
-AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
+ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
 {
     ALCcontext *Context;
     ALsizei i;
@@ -79,7 +79,7 @@ AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)
+ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)
 {
     ALCcontext *Context;
     ALfilter *ALFilter;
@@ -135,7 +135,7 @@ AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)
     ProcessContext(Context);
 }
 
-AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
+ALboolean AL_APIENTRY alIsFilter(ALuint filter)
 {
     ALCcontext *Context;
     ALfilter **list;
@@ -152,7 +152,7 @@ AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
     return ((*list || !filter) ? AL_TRUE : AL_FALSE);
 }
 
-AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
+ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
 {
     ALCcontext *Context;
 
@@ -184,7 +184,7 @@ AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)
+ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)
 {
     ALCcontext *Context;
 
@@ -210,7 +210,7 @@ AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValue
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
+ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
 {
     ALCcontext *Context;
 
@@ -221,26 +221,29 @@ AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue
     {
         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 
-        switch(param)
+        switch(ALFilter->type)
         {
-        case AL_LOWPASS_GAIN:
-            if(ALFilter->type == AL_FILTER_LOWPASS)
+        case AL_FILTER_LOWPASS:
+            switch(param)
             {
+            case AL_LOWPASS_GAIN:
                 if(flValue >= 0.0f && flValue <= 1.0f)
                     ALFilter->Gain = flValue;
-            }
-            else
-                alSetError(AL_INVALID_ENUM);
-            break;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
 
-        case AL_LOWPASS_GAINHF:
-            if(ALFilter->type == AL_FILTER_LOWPASS)
-            {
+            case AL_LOWPASS_GAINHF:
                 if(flValue >= 0.0f && flValue <= 1.0f)
                     ALFilter->GainHF = flValue;
-            }
-            else
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
+            default:
                 alSetError(AL_INVALID_ENUM);
+                break;
+            }
             break;
 
         default:
@@ -254,7 +257,7 @@ AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
+ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 {
     ALCcontext *Context;
 
@@ -265,14 +268,9 @@ AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflVa
     {
         switch(param)
         {
-        case AL_LOWPASS_GAIN:
-        case AL_LOWPASS_GAINHF:
+        default:
             alFilterf(filter, param, pflValues[0]);
             break;
-
-        default:
-            alSetError(AL_INVALID_ENUM);
-            break;
         }
     }
     else
@@ -281,55 +279,7 @@ AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflVa
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
-{
-    ALCcontext *Context;
-
-    (void)piValue;
-
-    Context = alcGetCurrentContext();
-    SuspendContext(Context);
-
-    if (filter && alIsFilter(filter))
-    {
-        switch(param)
-        {
-        default:
-            alSetError(AL_INVALID_ENUM);
-            break;
-        }
-    }
-    else
-        alSetError(AL_INVALID_NAME);
-
-    ProcessContext(Context);
-}
-
-AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
-{
-    ALCcontext *Context;
-
-    (void)piValues;
-
-    Context = alcGetCurrentContext();
-    SuspendContext(Context);
-
-    if (filter && alIsFilter(filter))
-    {
-        switch(param)
-        {
-        default:
-            alSetError(AL_INVALID_ENUM);
-            break;
-        }
-    }
-    else
-        alSetError(AL_INVALID_NAME);
-
-    ProcessContext(Context);
-}
-
-AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
+ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
 {
     ALCcontext *Context;
 
@@ -342,18 +292,8 @@ AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pfl
 
         switch(param)
         {
-        case AL_LOWPASS_GAIN:
-            if(ALFilter->type == AL_FILTER_LOWPASS)
-                *pflValue = ALFilter->Gain;
-            else
-                alSetError(AL_INVALID_ENUM);
-            break;
-
-        case AL_LOWPASS_GAINHF:
-            if(ALFilter->type == AL_FILTER_LOWPASS)
-                *pflValue = ALFilter->GainHF;
-            else
-                alSetError(AL_INVALID_ENUM);
+        case AL_FILTER_TYPE:
+            *piValue = ALFilter->type;
             break;
 
         default:
@@ -367,7 +307,7 @@ AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pfl
     ProcessContext(Context);
 }
 
-AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
+ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
 {
     ALCcontext *Context;
 
@@ -378,9 +318,8 @@ AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pf
     {
         switch(param)
         {
-        case AL_LOWPASS_GAIN:
-        case AL_LOWPASS_GAINHF:
-            alGetFilterf(filter, param, pflValues);
+        case AL_FILTER_TYPE:
+            alGetFilteri(filter, param, piValues);
             break;
 
         default:
@@ -394,12 +333,75 @@ AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pf
     ProcessContext(Context);
 }
 
+ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
+{
+    ALCcontext *Context;
+
+    Context = alcGetCurrentContext();
+    SuspendContext(Context);
+
+    if (filter && alIsFilter(filter))
+    {
+        ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
+
+        switch(ALFilter->type)
+        {
+        case AL_FILTER_LOWPASS:
+            switch(param)
+            {
+            case AL_LOWPASS_GAIN:
+                *pflValue = ALFilter->Gain;
+                break;
+
+            case AL_LOWPASS_GAINHF:
+                *pflValue = ALFilter->GainHF;
+                break;
+
+            default:
+                alSetError(AL_INVALID_ENUM);
+                break;
+            }
+            break;
+
+        default:
+            alSetError(AL_INVALID_ENUM);
+            break;
+        }
+    }
+    else
+        alSetError(AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
+ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
+{
+    ALCcontext *Context;
+
+    Context = alcGetCurrentContext();
+    SuspendContext(Context);
+
+    if (filter && alIsFilter(filter))
+    {
+        switch(param)
+        {
+        default:
+            alGetFilterf(filter, param, pflValues);
+            break;
+        }
+    }
+    else
+        alSetError(AL_INVALID_NAME);
+
+    ProcessContext(Context);
+}
+
 
 ALvoid ReleaseALFilters(ALvoid)
 {
 #ifdef _DEBUG
     if(g_FilterCount > 0)
-        AL_PRINT("exit() %d Filter(s) NOT deleted\n", g_FilterCount);
+        AL_PRINT("exit(): deleting %d Filter(s)\n", g_FilterCount);
 #endif
 
     while(g_FilterList)

OpenAL32/alSource.c

@@ -32,8 +32,8 @@
 #include "alThunk.h"
 #include "alAuxEffectSlot.h"
 
-static ALvoid InitSourceParams(ALsource *pSource);
-static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset);
+static ALvoid InitSourceParams(ALCcontext *Context, ALsource *pSource);
+static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset, ALuint updateSize);
 static ALvoid ApplyOffset(ALsource *pSource, ALboolean bUpdateContext);
 static ALint GetByteOffset(ALsource *pSource);
 
@@ -78,7 +78,7 @@ ALAPI ALvoid ALAPIENTRY alGenSources(ALsizei n,ALuint *sources)
                             sources[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
                             (*list)->source = sources[i];
 
-                            InitSourceParams(*list);
+                            InitSourceParams(Context, *list);
                             Context->SourceCount++;
                             i++;
 
@@ -137,73 +137,64 @@ ALAPI ALvoid ALAPIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
 
             if (Device)
             {
-                if ((ALuint)n <= Context->SourceCount)
+                // Check that all Sources are valid (and can therefore be deleted)
+                for (i = 0; i < n; i++)
                 {
-                    // Check that all Sources are valid (and can therefore be deleted)
-                    for (i = 0; i < n; i++)
+                    if (!alIsSource(sources[i]))
                     {
-                        if (!alIsSource(sources[i]))
-                        {
-                            alSetError(AL_INVALID_NAME);
-                            bSourcesValid = AL_FALSE;
-                            break;
-                        }
-                    }
-
-                    if (bSourcesValid)
-                    {
-                        // All Sources are valid, and can be deleted
-                        for (i = 0; i < n; i++)
-                        {
-                            // Recheck that the Source is valid, because there could be duplicated Source names
-                            if (alIsSource(sources[i]))
-                            {
-                                ALSource=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
-                                alSourceStop((ALuint)ALSource->source);
-
-                                // For each buffer in the source's queue, decrement its reference counter and remove it
-                                while (ALSource->queue != NULL)
-                                {
-                                    ALBufferList = ALSource->queue;
-                                    // Decrement buffer's reference counter
-                                    if (ALBufferList->buffer != 0)
-                                        ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->refcount--;
-                                    // Update queue to point to next element in list
-                                    ALSource->queue = ALBufferList->next;
-                                    // Release memory allocated for buffer list item
-                                    free(ALBufferList);
-                                }
-
-                                for(j = 0;j < MAX_SENDS;++j)
-                                {
-                                    if(ALSource->Send[j].Slot)
-                                        ALSource->Send[j].Slot->refcount--;
-                                    ALSource->Send[j].Slot = NULL;
-                                }
-
-                                // Decrement Source count
-                                Context->SourceCount--;
-
-                                // Remove Source from list of Sources
-                                list = &Context->Source;
-                                while(*list && *list != ALSource)
-                                    list = &(*list)->next;
-
-                                if(*list)
-                                    *list = (*list)->next;
-                                ALTHUNK_REMOVEENTRY(ALSource->source);
-
-                                memset(ALSource,0,sizeof(ALsource));
-                                free(ALSource);
-                            }
-                        }
-
+                        alSetError(AL_INVALID_NAME);
+                        bSourcesValid = AL_FALSE;
+                        break;
                     }
                 }
-                else
+
+                if (bSourcesValid)
                 {
-                    // Trying to delete more Sources than have been generated
-                    alSetError(AL_INVALID_NAME);
+                    // All Sources are valid, and can be deleted
+                    for (i = 0; i < n; i++)
+                    {
+                        // Recheck that the Source is valid, because there could be duplicated Source names
+                        if (alIsSource(sources[i]))
+                        {
+                            ALSource=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
+                            alSourceStop((ALuint)ALSource->source);
+
+                            // For each buffer in the source's queue, decrement its reference counter and remove it
+                            while (ALSource->queue != NULL)
+                            {
+                                ALBufferList = ALSource->queue;
+                                // Decrement buffer's reference counter
+                                if (ALBufferList->buffer != 0)
+                                    ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->refcount--;
+                                // Update queue to point to next element in list
+                                ALSource->queue = ALBufferList->next;
+                                // Release memory allocated for buffer list item
+                                free(ALBufferList);
+                            }
+
+                            for(j = 0;j < MAX_SENDS;++j)
+                            {
+                                if(ALSource->Send[j].Slot)
+                                    ALSource->Send[j].Slot->refcount--;
+                                ALSource->Send[j].Slot = NULL;
+                            }
+
+                            // Decrement Source count
+                            Context->SourceCount--;
+
+                            // Remove Source from list of Sources
+                            list = &Context->Source;
+                            while(*list && *list != ALSource)
+                                list = &(*list)->next;
+
+                            if(*list)
+                                *list = (*list)->next;
+                            ALTHUNK_REMOVEENTRY(ALSource->source);
+
+                            memset(ALSource,0,sizeof(ALsource));
+                            free(ALSource);
+                        }
+                    }
                 }
             }
             else
@@ -368,12 +359,19 @@ ALAPI ALvoid ALAPIENTRY alSourcef(ALuint source, ALenum eParam, ALfloat flValue)
                 break;
 
             case AL_ROOM_ROLLOFF_FACTOR:
-                if (flValue >= 0.0f && flValue <= 1.0f)
+                if (flValue >= 0.0f && flValue <= 10.0f)
                     pSource->RoomRolloffFactor = flValue;
                 else
                     alSetError(AL_INVALID_VALUE);
                 break;
 
+            case AL_DOPPLER_FACTOR:
+                if (flValue >= 0.0f && flValue <= 1.0f)
+                    pSource->DopplerFactor = flValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
             case AL_SEC_OFFSET:
             case AL_SAMPLE_OFFSET:
             case AL_BYTE_OFFSET:
@@ -634,9 +632,6 @@ ALAPI ALvoid ALAPIENTRY alSourcei(ALuint source,ALenum eParam,ALint lValue)
                             pSource->lSourceType = AL_UNDETERMINED;
                         }
 
-                        // Set Buffers Processed
-                        pSource->BuffersProcessed = 0;
-
                         // Update AL_BUFFER parameter
                         pSource->ulBufferID = lValue;
                     }
@@ -709,6 +704,19 @@ ALAPI ALvoid ALAPIENTRY alSourcei(ALuint source,ALenum eParam,ALint lValue)
                     alSetError(AL_INVALID_VALUE);
                 break;
 
+            case AL_DISTANCE_MODEL:
+                if(lValue == AL_NONE ||
+                   lValue == AL_INVERSE_DISTANCE ||
+                   lValue == AL_INVERSE_DISTANCE_CLAMPED ||
+                   lValue == AL_LINEAR_DISTANCE ||
+                   lValue == AL_LINEAR_DISTANCE_CLAMPED ||
+                   lValue == AL_EXPONENT_DISTANCE ||
+                   lValue == AL_EXPONENT_DISTANCE_CLAMPED)
+                    pSource->DistanceModel = lValue;
+                else
+                    alSetError(AL_INVALID_VALUE);
+                break;
+
             default:
                 alSetError(AL_INVALID_ENUM);
                 break;
@@ -824,6 +832,7 @@ ALAPI void ALAPIENTRY alSourceiv(ALuint source, ALenum eParam, const ALint* plVa
                 case AL_DIRECT_FILTER_GAINHF_AUTO:
                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
+                case AL_DISTANCE_MODEL:
                     alSourcei(source, eParam, plValues[0]);
                     break;
 
@@ -858,7 +867,7 @@ ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint source, ALenum eParam, ALfloat *pflV
 {
     ALCcontext    *pContext;
     ALsource    *pSource;
-    ALfloat        flOffset;
+    ALfloat        flOffset[2];
 
     pContext = alcGetCurrentContext();
     if (pContext)
@@ -908,8 +917,20 @@ ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint source, ALenum eParam, ALfloat *pflV
                 case AL_SEC_OFFSET:
                 case AL_SAMPLE_OFFSET:
                 case AL_BYTE_OFFSET:
-                    if (GetSourceOffset(pSource, eParam, &flOffset))
-                        *pflValue = flOffset;
+                    if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
+                        *pflValue = flOffset[0];
+                    else
+                        alSetError(AL_INVALID_OPERATION);
+                    break;
+
+                case AL_SEC_RW_OFFSETS_EXT:
+                case AL_SAMPLE_RW_OFFSETS_EXT:
+                case AL_BYTE_RW_OFFSETS_EXT:
+                    if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
+                    {
+                        pflValue[0] = flOffset[0];
+                        pflValue[1] = flOffset[1];
+                    }
                     else
                         alSetError(AL_INVALID_OPERATION);
                     break;
@@ -934,6 +955,10 @@ ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint source, ALenum eParam, ALfloat *pflV
                     *pflValue = pSource->RoomRolloffFactor;
                     break;
 
+                case AL_DOPPLER_FACTOR:
+                    *pflValue = pSource->DopplerFactor;
+                    break;
+
                 default:
                     alSetError(AL_INVALID_ENUM);
                     break;
@@ -1034,6 +1059,7 @@ ALAPI ALvoid ALAPIENTRY alGetSourcefv(ALuint source, ALenum eParam, ALfloat *pfl
                 case AL_MAX_GAIN:
                 case AL_MAX_DISTANCE:
                 case AL_ROLLOFF_FACTOR:
+                case AL_DOPPLER_FACTOR:
                 case AL_CONE_OUTER_GAIN:
                 case AL_SEC_OFFSET:
                 case AL_SAMPLE_OFFSET:
@@ -1089,7 +1115,7 @@ ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValu
 {
     ALCcontext *pContext;
     ALsource   *pSource;
-    ALfloat     flOffset;
+    ALfloat     flOffset[2];
 
     pContext = alcGetCurrentContext();
     if (pContext)
@@ -1152,7 +1178,7 @@ ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValu
                         *plValue = 0;
                     }
                     else
-                        *plValue = pSource->BuffersProcessed;
+                        *plValue = pSource->BuffersPlayed;
                     break;
 
                 case AL_SOURCE_TYPE:
@@ -1162,8 +1188,20 @@ ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValu
                 case AL_SEC_OFFSET:
                 case AL_SAMPLE_OFFSET:
                 case AL_BYTE_OFFSET:
-                    if (GetSourceOffset(pSource, eParam, &flOffset))
-                        *plValue = (ALint)flOffset;
+                    if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
+                        *plValue = (ALint)flOffset[0];
+                    else
+                        alSetError(AL_INVALID_OPERATION);
+                    break;
+
+                case AL_SEC_RW_OFFSETS_EXT:
+                case AL_SAMPLE_RW_OFFSETS_EXT:
+                case AL_BYTE_RW_OFFSETS_EXT:
+                    if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
+                    {
+                        plValue[0] = (ALint)flOffset[0];
+                        plValue[1] = (ALint)flOffset[1];
+                    }
                     else
                         alSetError(AL_INVALID_OPERATION);
                     break;
@@ -1184,6 +1222,14 @@ ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValu
                     *plValue = pSource->WetGainHFAuto;
                     break;
 
+                case AL_DOPPLER_FACTOR:
+                    *plValue = (ALint)pSource->DopplerFactor;
+                    break;
+
+                case AL_DISTANCE_MODEL:
+                    *plValue = pSource->DistanceModel;
+                    break;
+
                 default:
                     alSetError(AL_INVALID_ENUM);
                     break;
@@ -1291,12 +1337,14 @@ ALAPI void ALAPIENTRY alGetSourceiv(ALuint source, ALenum eParam, ALint* plValue
                 case AL_BYTE_OFFSET:
                 case AL_MAX_DISTANCE:
                 case AL_ROLLOFF_FACTOR:
+                case AL_DOPPLER_FACTOR:
                 case AL_REFERENCE_DISTANCE:
                 case AL_SOURCE_TYPE:
                 case AL_DIRECT_FILTER:
                 case AL_DIRECT_FILTER_GAINHF_AUTO:
                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
+                case AL_DISTANCE_MODEL:
                     alGetSourcei(source, eParam, plValues);
                     break;
 
@@ -1351,7 +1399,7 @@ ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
     ALbufferlistitem    *ALBufferList;
     ALboolean            bSourcesValid = AL_TRUE;
     ALboolean            bPlay;
-    ALsizei              i;
+    ALsizei              i, j;
 
     pContext = alcGetCurrentContext();
     if (pContext)
@@ -1394,6 +1442,11 @@ ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
 
                     if (bPlay)
                     {
+                        for(j = 0;j < OUTPUTCHANNELS;j++)
+                            pSource->DryGains[j] = 0.0f;
+                        for(j = 0;j < MAX_SENDS;j++)
+                            pSource->WetGains[j] = 0.0f;
+
                         if (pSource->state != AL_PAUSED)
                         {
                             pSource->state = AL_PLAYING;
@@ -1401,10 +1454,8 @@ ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
                             pSource->play = AL_TRUE;
                             pSource->position = 0;
                             pSource->position_fraction = 0;
-                            pSource->BuffersProcessed = 0;
                             pSource->BuffersPlayed = 0;
-                            pSource->BufferPosition = 0;
-                            pSource->lBytesPlayed = 0;
+                            pSource->FirstStart = AL_TRUE;
 
                             pSource->ulBufferID = pSource->queue->buffer;
 
@@ -1421,6 +1472,7 @@ ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
                             pSource->state = AL_PLAYING;
                             pSource->inuse = AL_TRUE;
                             pSource->play = AL_TRUE;
+                            pSource->FirstStart = AL_FALSE;
                         }
 
                         // Check if an Offset has been set
@@ -1437,7 +1489,7 @@ ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
                             ALBufferList = ALBufferList->next;
                         }
 
-                        pSource->BuffersPlayed = pSource->BuffersProcessed = pSource->BuffersInQueue;
+                        pSource->BuffersPlayed = pSource->BuffersInQueue;
                     }
                 }
             }
@@ -1561,7 +1613,7 @@ ALAPI ALvoid ALAPIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
                     {
                         Source->state=AL_STOPPED;
                         Source->inuse=AL_FALSE;
-                        Source->BuffersPlayed = Source->BuffersProcessed = Source->BuffersInQueue;
+                        Source->BuffersPlayed = Source->BuffersInQueue;
                         ALBufferListItem= Source->queue;
                         while (ALBufferListItem != NULL)
                         {
@@ -1633,7 +1685,7 @@ ALAPI ALvoid ALAPIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
                         Source->inuse=AL_FALSE;
                         Source->position=0;
                         Source->position_fraction=0;
-                        Source->BuffersProcessed = 0;
+                        Source->BuffersPlayed = 0;
                         ALBufferListItem= Source->queue;
                         while (ALBufferListItem != NULL)
                         {
@@ -1906,7 +1958,6 @@ ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint
                     // Release memory for buffer list item
                     free(ALBufferList);
                     ALSource->BuffersInQueue--;
-                    ALSource->BuffersProcessed--;
                 }
 
                 if (ALSource->state != AL_PLAYING)
@@ -1920,10 +1971,7 @@ ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint
                 }
 
                 if((ALuint)n > ALSource->BuffersPlayed)
-                {
                     ALSource->BuffersPlayed = 0;
-                    ALSource->BufferPosition = 0;
-                }
                 else
                     ALSource->BuffersPlayed -= n;
             }
@@ -1951,7 +1999,7 @@ ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint
 }
 
 
-static ALvoid InitSourceParams(ALsource *pSource)
+static ALvoid InitSourceParams(ALCcontext *Context, ALsource *pSource)
 {
     pSource->flInnerAngle = 360.0f;
     pSource->flOuterAngle = 360.0f;
@@ -1980,6 +2028,9 @@ static ALvoid InitSourceParams(ALsource *pSource)
     pSource->WetGainHFAuto = AL_TRUE;
     pSource->AirAbsorptionFactor = 0.0f;
     pSource->RoomRolloffFactor = 0.0f;
+    pSource->DopplerFactor = 1.0f;
+
+    pSource->DistanceModel = Context->DistanceModel;
 
     pSource->state = AL_INITIAL;
     pSource->lSourceType = AL_UNDETERMINED;
@@ -1994,12 +2045,13 @@ static ALvoid InitSourceParams(ALsource *pSource)
     Gets the current playback position in the given Source, in the appropriate format (Bytes, Samples or MilliSeconds)
     The offset is relative to the start of the queue (not the start of the current buffer)
 */
-static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset)
+static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset, ALuint updateSize)
 {
     ALbufferlistitem *pBufferList;
     ALbuffer         *pBuffer;
     ALfloat        flBufferFreq;
-    ALint        lBytesPlayed, lChannels;
+    ALint        lChannels;
+    ALint        readPos, writePos;
     ALenum        eOriginalFormat;
     ALboolean    bReturn = AL_TRUE;
     ALint        lTotalBufferDataSize;
@@ -2013,15 +2065,20 @@ static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOf
         lChannels = aluChannelsFromFormat(pBuffer->format);
 
         // Get Current BytesPlayed
-        lBytesPlayed = pSource->position * lChannels * 2; // NOTE : This is the byte offset into the *current* buffer
+        readPos = pSource->position * lChannels * 2; // NOTE : This is the byte offset into the *current* buffer
         // Add byte length of any processed buffers in the queue
         pBufferList = pSource->queue;
         while ((pBufferList) && (pBufferList->bufferstate == PROCESSED))
         {
-            lBytesPlayed += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
+            readPos += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
             pBufferList = pBufferList->next;
         }
 
+        if(pSource->state == AL_PLAYING)
+            writePos = readPos + (updateSize * lChannels * 2);
+        else
+            writePos = readPos;
+
         lTotalBufferDataSize = 0;
         pBufferList = pSource->queue;
         while (pBufferList)
@@ -2033,64 +2090,88 @@ static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOf
 
         if (pSource->bLooping)
         {
-            if (lBytesPlayed < 0)
-                lBytesPlayed = 0;
+            if(readPos < 0)
+                readPos = 0;
             else
-                lBytesPlayed = lBytesPlayed % lTotalBufferDataSize;
+                readPos %= lTotalBufferDataSize;
+            if(writePos < 0)
+                writePos = 0;
+            else
+                writePos %= lTotalBufferDataSize;
         }
         else
         {
             // Clamp BytesPlayed to within 0 and lTotalBufferDataSize
-            if(lBytesPlayed < 0)
-                lBytesPlayed = 0;
-            if(lBytesPlayed > lTotalBufferDataSize)
-                lBytesPlayed = lTotalBufferDataSize;
+            if(readPos < 0)
+                readPos = 0;
+            else if(readPos > lTotalBufferDataSize)
+                readPos = lTotalBufferDataSize;
+            if(writePos < 0)
+                writePos = 0;
+            else if(writePos > lTotalBufferDataSize)
+                writePos = lTotalBufferDataSize;
         }
 
         switch (eName)
         {
         case AL_SEC_OFFSET:
-            *pflOffset = ((ALfloat)lBytesPlayed / (lChannels * 2.0f * flBufferFreq));
+        case AL_SEC_RW_OFFSETS_EXT:
+            pflOffset[0] = (ALfloat)readPos / (lChannels * 2.0f * flBufferFreq);
+            pflOffset[1] = (ALfloat)writePos / (lChannels * 2.0f * flBufferFreq);
             break;
         case AL_SAMPLE_OFFSET:
-            *pflOffset = (ALfloat)(lBytesPlayed / (lChannels * 2));
+        case AL_SAMPLE_RW_OFFSETS_EXT:
+            pflOffset[0] = (ALfloat)(readPos / (lChannels * 2));
+            pflOffset[1] = (ALfloat)(writePos / (lChannels * 2));
             break;
         case AL_BYTE_OFFSET:
+        case AL_BYTE_RW_OFFSETS_EXT:
             // Take into account the original format of the Buffer
             if ((eOriginalFormat == AL_FORMAT_MONO_IMA4) ||
                 (eOriginalFormat == AL_FORMAT_STEREO_IMA4))
             {
-                // Compression rate of the ADPCM supported is 3.6111 to 1
-                lBytesPlayed = (ALint)((ALfloat)lBytesPlayed / 3.6111f);
                 // Round down to nearest ADPCM block
-                *pflOffset = (ALfloat)((lBytesPlayed / (36 * lChannels)) * 36 * lChannels);
+                pflOffset[0] = (ALfloat)((readPos / (65 * 2 * lChannels)) * 36 * lChannels);
+                if(pSource->state == AL_PLAYING)
+                {
+                    // Round up to nearest ADPCM block
+                    pflOffset[1] = (ALfloat)(((writePos + (65 * 2 * lChannels) - 1) / (65 * 2 * lChannels)) * 36 * lChannels);
+                }
+                else
+                    pflOffset[1] = pflOffset[0];
             }
             else if (eOriginalFormat == AL_FORMAT_REAR8)
             {
-                *pflOffset = (ALfloat)(lBytesPlayed >> 2);
+                pflOffset[0] = (ALfloat)(readPos >> 2);
+                pflOffset[1] = (ALfloat)(writePos >> 2);
             }
             else if (eOriginalFormat == AL_FORMAT_REAR16)
             {
-                *pflOffset = (ALfloat)(lBytesPlayed >> 1);
+                pflOffset[0] = (ALfloat)(readPos >> 1);
+                pflOffset[1] = (ALfloat)(writePos >> 1);
             }
             else if (aluBytesFromFormat(eOriginalFormat) == 1)
             {
-                *pflOffset = (ALfloat)(lBytesPlayed >> 1);
+                pflOffset[0] = (ALfloat)(readPos >> 1);
+                pflOffset[1] = (ALfloat)(writePos >> 1);
             }
             else if (aluBytesFromFormat(eOriginalFormat) == 4)
             {
-                *pflOffset = (ALfloat)(lBytesPlayed << 1);
+                pflOffset[0] = (ALfloat)(readPos << 1);
+                pflOffset[1] = (ALfloat)(writePos << 1);
             }
             else
             {
-                *pflOffset = (ALfloat)lBytesPlayed;
+                pflOffset[0] = (ALfloat)readPos;
+                pflOffset[1] = (ALfloat)writePos;
             }
             break;
         }
     }
     else
     {
-        *pflOffset = 0.0f;
+        pflOffset[0] = 0.0f;
+        pflOffset[1] = 0.0f;
     }
 
     return bReturn;
@@ -2120,7 +2201,6 @@ static void ApplyOffset(ALsource *pSource, ALboolean bUpdateContext)
         pBufferList = pSource->queue;
         lTotalBufferSize = 0;
         pSource->BuffersPlayed = 0;
-        pSource->BuffersProcessed = 0;
         while (pBufferList)
         {
             pBuffer = ALTHUNK_LOOKUPENTRY(pBufferList->buffer);
@@ -2133,10 +2213,7 @@ static void ApplyOffset(ALsource *pSource, ALboolean bUpdateContext)
                 pSource->BuffersPlayed++;
 
                 if (!pSource->bLooping)
-                {
                     pBufferList->bufferstate = PROCESSED;
-                    pSource->BuffersProcessed++;
-                }
             }
             else if (lTotalBufferSize <= lByteOffset)
             {
@@ -2146,14 +2223,8 @@ static void ApplyOffset(ALsource *pSource, ALboolean bUpdateContext)
                 // Set Current Buffer ID
                 pSource->ulBufferID = pBufferList->buffer;
 
-                // Set current position in this buffer
-                pSource->BufferPosition = lByteOffset - lTotalBufferSize;
-
-                // Set Total Bytes Played to Offset
-                pSource->lBytesPlayed = lByteOffset;
-
                 // SW Mixer Positions are in Samples
-                pSource->position = pSource->BufferPosition /
+                pSource->position = (lByteOffset - lTotalBufferSize) /
                                     aluBytesFromFormat(pBuffer->format) /
                                     aluChannelsFromFormat(pBuffer->format);
             }
@@ -2288,7 +2359,7 @@ ALvoid ReleaseALSources(ALCcontext *Context)
 {
 #ifdef _DEBUG
     if(Context->SourceCount > 0)
-        AL_PRINT("alcDestroyContext(): %d Source(s) NOT deleted\n", Context->SourceCount);
+        AL_PRINT("alcDestroyContext(): deleting %d Source(s)\n", Context->SourceCount);
 #endif
 
     while(Context->Source)

OpenAL32/alState.c

@@ -24,10 +24,11 @@
 #include "alMain.h"
 #include "AL/alc.h"
 #include "alError.h"
+#include "alSource.h"
 #include "alState.h"
 
 static const ALchar alVendor[] = "OpenAL Community";
-static const ALchar alVersion[] = "1.1";
+static const ALchar alVersion[] = "1.1 ALSOFT "ALSOFT_VERSION;
 static const ALchar alRenderer[] = "OpenAL Soft";
 
 // Error Messages
@@ -644,6 +645,7 @@ ALAPI ALvoid ALAPIENTRY alSpeedOfSound(ALfloat flSpeedOfSound)
 ALAPI ALvoid ALAPIENTRY alDistanceModel(ALenum value)
 {
     ALCcontext *Context;
+    ALsource *Source;
 
     Context=alcGetCurrentContext();
     if (Context)
@@ -660,6 +662,8 @@ ALAPI ALvoid ALAPIENTRY alDistanceModel(ALenum value)
             case AL_EXPONENT_DISTANCE:
             case AL_EXPONENT_DISTANCE_CLAMPED:
                 Context->DistanceModel = value;
+                for(Source = Context->Source;Source != NULL;Source = Source->next)
+                    Source->DistanceModel = value;
                 break;
 
             default:

XCompile.txt

@@ -0,0 +1,24 @@
+# Cross-compiling requires CMake 2.6 or newer. To cross-compile, first modify
+# this file to set the proper settings and paths. Then use it from CMakeConf/
+# like:
+# cmake .. -DCMAKE_TOOLCHAIN_FILE=../XCompile.txt \
+#          -DCMAKE_INSTALL_PREFIX=/usr/mingw32/mingw
+# If you already have a toolchain file setup, you may use that instead of this
+# file.
+
+# the name of the target operating system
+SET(CMAKE_SYSTEM_NAME Windows)
+
+# which compilers to use for C and C++
+SET(CMAKE_C_COMPILER mingw32-gcc)
+SET(CMAKE_CXX_COMPILER mingw32-g++)
+
+# here is the target environment located
+SET(CMAKE_FIND_ROOT_PATH /usr/mingw32/mingw)
+
+# adjust the default behaviour of the FIND_XXX() commands:
+# search headers and libraries in the target environment, search 
+# programs in the host environment
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

admin/pkgconfig/openal.pc.in

@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: OpenAL
+Description: OpenAL is a cross-platform 3D audio API
+Requires: @PKG_CONFIG_REQUIRES@
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -l@LIBNAME@ @PKG_CONFIG_LIBS@
+Cflags: -I${includedir}

alsoftrc.sample

@@ -5,91 +5,210 @@
 # The system-wide settings can be put in /etc/openal/alsoft.conf and user-
 # specific override settings in ~/.alsoftrc.
 # For Windows, these settings should go into %AppData%\alsoft.ini
+# The environment variable ALSOFT_CONF can be used to specify another config
+# override
 
 # Option and block names are case-insenstive. The supplied values are only
 # hints and may not be honored (though generally it'll try to get as close as
 # possible). These are the current available settings:
 
-format = AL_FORMAT_STEREO16  # Sets the output format. Can be one of:
-                             # AL_FORMAT_MONO8    (8-bit mono)
-                             # AL_FORMAT_STEREO8  (8-bit stereo)
-                             # AL_FORMAT_QUAD8    (8-bit 4-channel)
-                             # AL_FORMAT_51CHN8   (8-bit 5.1 output)
-                             # AL_FORMAT_61CHN8   (8-bit 6.1 output)
-                             # AL_FORMAT_71CHN8   (8-bit 7.1 output)
-                             # AL_FORMAT_MONO16   (16-bit mono)
-                             # AL_FORMAT_STEREO16 (16-bit stereo)
-                             # AL_FORMAT_QUAD16   (16-bit 4-channel)
-                             # AL_FORMAT_51CHN16  (16-bit 5.1 output)
-                             # AL_FORMAT_61CHN16  (16-bit 6.1 output)
-                             # AL_FORMAT_71CHN16  (16-bit 7.1 output)
-                             # Default is AL_FORMAT_STEREO16
+## format:
+#  Sets the output format. Can be one of:
+#  AL_FORMAT_MONO8    (8-bit mono)
+#  AL_FORMAT_STEREO8  (8-bit stereo)
+#  AL_FORMAT_QUAD8    (8-bit 4-channel)
+#  AL_FORMAT_51CHN8   (8-bit 5.1 output)
+#  AL_FORMAT_61CHN8   (8-bit 6.1 output)
+#  AL_FORMAT_71CHN8   (8-bit 7.1 output)
+#  AL_FORMAT_MONO16   (16-bit mono)
+#  AL_FORMAT_STEREO16 (16-bit stereo)
+#  AL_FORMAT_QUAD16   (16-bit 4-channel)
+#  AL_FORMAT_51CHN16  (16-bit 5.1 output)
+#  AL_FORMAT_61CHN16  (16-bit 6.1 output)
+#  AL_FORMAT_71CHN16  (16-bit 7.1 output)
+#format = AL_FORMAT_STEREO16
 
-cf_level = 0  # Sets the crossfeed level for stereo output. Valid values are:
-              # 0 - No crossfeed
-              # 1 - Low crossfeed
-              # 2 - Middle crossfeed
-              # 3 - High crossfeed (virtual speakers are closer to itself)
-              # 4 - Low easy crossfeed
-              # 5 - Middle easy crossfeed
-              # 6 - High easy crossfeed
-              # Default is 0. Users of headphones may want to try various
-              # settings. Has no effect on non-stereo modes.
+## cf_level:
+#  Sets the crossfeed level for stereo output. Valid values are:
+#  0 - No crossfeed
+#  1 - Low crossfeed
+#  2 - Middle crossfeed
+#  3 - High crossfeed (virtual speakers are closer to itself)
+#  4 - Low easy crossfeed
+#  5 - Middle easy crossfeed
+#  6 - High easy crossfeed
+#  Users of headphones may want to try various settings. Has no effect on non-
+#  stereo modes.
+#cf_level = 0
 
-frequency = 44100  # Sets the output frequency. Default is 44100
+## frequency:
+#  Sets the output frequency.
+#frequency = 44100
 
-refresh = 8192  # Sets the buffer size, in frames. Default is 8192. Note that
-                # the actual granularity may or may not be less than this.
+## refresh:
+#  Sets the buffer size, in frames. Note that the actual granularity may or may
+#  not be less than this.
+#refresh = 4096
 
-sources = 256  # Sets the maximum number of allocatable sources. Lower values
-               # may help for systems with apps that try to play more sounds
-               # than the CPU can handle. Default is 256
+## sources:
+#  Sets the maximum number of allocatable sources. Lower values may help for
+#  systems with apps that try to play more sounds than the CPU can handle.
+#sources = 256
 
-stereodup =  # Sets whether to duplicate stereo sounds on the rear speakers for
-             # 4+ channel output. This can make stereo sources substantially
-             # louder than mono or even 4+ channel sources, but provides a
-             # "fuller" playback quality. True, yes, on, and non-0 values will
-             # duplicate stereo sources. 0 and anything else will cause stereo
-             # sounds to only play out the front speakers.
-             # Default is false
+## stereodup:
+#  Sets whether to duplicate stereo sounds on the rear and side speakers for 4+
+#  channel output. This can make stereo sources substantially louder than mono
+#  or even 4+ channel sources, but provides a "fuller" playback quality. True,
+#  yes, on, and non-0 values will duplicate stereo sources. 0 and anything else
+#  will cause stereo sounds to only play out the front speakers.
+#stereodup = false
 
-drivers =  # Sets the backend driver list order, comma-seperated. Unknown
-           # backends and duplicated names are ignored, and unlisted backends
-           # won't be considered for use. An empty list means the default.
-           # Default is:
-           # alsa,oss,dsound,winmm,wave
+## drivers:
+#  Sets the backend driver list order, comma-seperated. Unknown backends and
+#  duplicated names are ignored, and unlisted backends won't be considered for
+#  use. An empty list means the default.
+#drivers = alsa,oss,solaris,dsound,winmm,port,pulse,wave
 
-[alsa]  # ALSA backend stuff
-device = default  # Sets the device name for the default playback device.
-                  # Default is default
+## excludefx:
+#  Sets which effects to exclude, preventing apps from using them. This can
+#  help for apps that try to use effects which are too CPU intensive for the
+#  system to handle. Available effects are: eaxreverb,reverb,echo
+#excludefx =
 
-periods = 0  # Sets the number of update buffers for playback. A value of 0
-             # means auto-select. Default is 0
+## slots:
+#  Sets the maximum number of Auxiliary Effect Slots an app can create. A slot
+#  can use a non-negligible amount of CPU time if an effect is set on it even
+#  if no sources are feeding it, so this may help when apps use more than the
+#  system can handle.
+#slots = 4
 
-capture = default  # Sets the device name for the default capture device.
-                   # Default is default
+## sends:
+#  Sets the maximum number of auxiliary sends per source. The total number of
+#  sends possible is defined at compile time and thus can not be increased
+#  beyond the default (2).
+#sends = 2
 
-mmap = true  # Sets whether to try using mmap mode (helps reduce latencies and
-             # CPU consumption). If mmap isn't available, it will automatically
-             # fall back to non-mmap mode. True, yes, on, and non-0 values will
-             # attempt to use mmap. 0 and anything else will force mmap off.
-             # Default is true.
+## layout_STEREO:
+#  Sets the speaker layout when using stereo output. Values are specified in
+#  degrees, where 0 is straight in front, negative goes left, and positive goes
+#  right. The values must define a circular pattern, starting with the back-
+#  left at the most negative, around the front to back-center. Unspecified
+#  speakers will remain at their default position. Available speakers are
+#  front-left(fl) and front-right(fr).
+#layout_STEREO = fl=-90, fr=90
 
-[oss]  # OSS backend stuff
-device = /dev/dsp  # Sets the device name for OSS output. Default is /dev/dsp
+## laytout_QUAD:
+#  Sets the speaker layout when using quadriphonic output. Available speakers
+#  are back-left(bl), front-left(fl), front-right(fr), and back-right(br).
+#layout_QUAD = bl=-135, fl=-45, fr=45, br=135
 
-periods = 4  # Sets the number of update buffers. Default is 4
+## layout_51CHN:
+#  Sets the speaker layout when using 5.1 output. Available speakers are back-
+#  left(bl), front-left(fl), front-center(fc), front-right(fr), and back-
+#  right(br).
+#layout_51CHN = bl=-110, fl=-30, fc=0, fr=30, br=110
 
-capture = /dev/dsp  # Sets the device name for OSS capture. Default is /dev/dsp
+## layout_61CHN:
+#  Sets the speaker layout when using 6.1 output. Available speakers are side-
+#  left(sl), front-left(fl), front-center(fc), front-right(fr), side-right(sr),
+#  and back-center(bc).
+#layout_61CHN = sl=-90, fl=-30, fc=0, fr=30, sr=90, bc=180
 
-[dsound]  # DirectSound backend stuff
-          # Nothing yet...
+## layout_71CHN:
+#  Sets the speaker layout when using 7.1 output. Available speakers are back-
+#  left(bl), side-left(sl), front-left(fl), front-center(fc), front-right(fr),
+#  side-right(sr), and back-right(br).
+#layout_71CHN = bl=-150, sl=-90, fl=-30, fc=0, fr=30, sr=90, br=150
 
-[winmm]  # Windows Multimedia backend stuff
-         # Nothing yet...
+##
+## ALSA backend stuff
+##
+[alsa]
 
-[wave]  # Wave File Writer stuff
-file =  # Sets the filename of the wave file to write to. An empty name
-        # prevents the backend from opening, even when explicitly requested.
-        # THIS WILL OVERWRITE EXISTING FILES WITHOUT QUESTION!
-        # Default is empty
+## device:
+#  Sets the device name for the default playback device.
+#device = default
+
+## periods:
+#  Sets the number of update buffers for playback. A value of 0 means auto-
+#  select.
+#periods = 0
+
+## capture:
+#  Sets the device name for the default capture device.
+#capture = default
+
+## mmap:
+#  Sets whether to try using mmap mode (helps reduce latencies and CPU
+#  consumption). If mmap isn't available, it will automatically fall back to
+#  non-mmap mode. True, yes, on, and non-0 values will attempt to use mmap. 0
+#  and anything else will force mmap off.
+#mmap = true
+
+##
+## OSS backend stuff
+##
+[oss]
+
+## device:
+#  Sets the device name for OSS output.
+#device = /dev/dsp
+
+## periods:
+#  Sets the number of update buffers.
+#periods = 4
+
+## capture:
+#  Sets the device name for OSS capture.
+#capture = /dev/dsp
+
+##
+## Solaris backend stuff
+##
+[solaris]
+
+## device:
+#  Sets the device name for Solaris output.
+#device = /dev/audio
+
+## DirectSound backend stuff
+[dsound]
+
+## periods:
+#  Sets the number of updates for the output buffer.
+#periods = 4
+
+##
+## Windows Multimedia backend stuff
+##
+[winmm]
+
+##
+## PortAudio backend stuff
+##
+[port]
+
+## device:
+#  Sets the device index for output. Negative values will use the default as
+#  given by PortAudio itself.
+#device = -1
+
+## periods:
+#  Sets the number of update buffers.
+#periods = 4
+
+##
+## PulseAudio backend stuff
+##
+[pulse]
+
+##
+## Wave File Writer stuff
+##
+[wave]
+
+## file:
+#  Sets the filename of the wave file to write to. An empty name prevents the
+#  backend from opening, even when explicitly requested.
+#  THIS WILL OVERWRITE EXISTING FILES WITHOUT QUESTION!
+#file =

config.h.in

@@ -1,18 +1,30 @@
 #ifndef CONFIG_H
 #define CONFIG_H
 
+/* Define to the library version */
+#define ALSOFT_VERSION "${LIB_VERSION}"
+
 /* Define if we have the ALSA backend */
 #cmakedefine HAVE_ALSA
 
 /* Define if we have the OSS backend */
 #cmakedefine HAVE_OSS
 
+/* Define if we have the Solaris backend */
+#cmakedefine HAVE_SOLARIS
+
 /* Define if we have the DSound backend */
 #cmakedefine HAVE_DSOUND
 
 /* Define if we have the Windows Multimedia backend */
 #cmakedefine HAVE_WINMM
 
+/* Define if we have the PortAudio backend */
+#cmakedefine HAVE_PORTAUDIO
+
+/* Define if we have the PulseAudio backend */
+#cmakedefine HAVE_PULSEAUDIO
+
 /* Define if we have dlfcn.h */
 #cmakedefine HAVE_DLFCN_H
 
@@ -22,6 +34,12 @@
 /* Define if we have the acosf function */
 #cmakedefine HAVE_ACOSF
 
+/* Define if we have the atanf function */
+#cmakedefine HAVE_ATANF
+
+/* Define if we have the fabsf function */
+#cmakedefine HAVE_FABSF
+
 /* Define if we have the strtof function */
 #cmakedefine HAVE_STRTOF
 
@@ -49,4 +67,16 @@
 /* Define if we have pthread_np.h */
 #cmakedefine HAVE_PTHREAD_NP_H
 
+/* Define if we have float.h */
+#cmakedefine HAVE_FLOAT_H
+
+/* Define if we have fenv.h */
+#cmakedefine HAVE_FENV_H
+
+/* Define if we have fesetround() */
+#cmakedefine HAVE_FESETROUND
+
+/* Define if we have _controlfp() */
+#cmakedefine HAVE__CONTROLFP
+
 #endif

examples/openal-info.c

@@ -19,6 +19,37 @@
 #include "AL/al.h"
 #include "AL/alext.h"
 
+#ifndef ALC_EXT_EFX
+#define AL_FILTER_TYPE                                     0x8001
+#define AL_EFFECT_TYPE                                     0x8001
+#define AL_FILTER_NULL                                     0x0000
+#define AL_FILTER_LOWPASS                                  0x0001
+#define AL_FILTER_HIGHPASS                                 0x0002
+#define AL_FILTER_BANDPASS                                 0x0003
+#define AL_EFFECT_NULL                                     0x0000
+#define AL_EFFECT_EAXREVERB                                0x8000
+#define AL_EFFECT_REVERB                                   0x0001
+#define AL_EFFECT_CHORUS                                   0x0002
+#define AL_EFFECT_DISTORTION                               0x0003
+#define AL_EFFECT_ECHO                                     0x0004
+#define AL_EFFECT_FLANGER                                  0x0005
+#define AL_EFFECT_FREQUENCY_SHIFTER                        0x0006
+#define AL_EFFECT_VOCAL_MORPHER                            0x0007
+#define AL_EFFECT_PITCH_SHIFTER                            0x0008
+#define AL_EFFECT_RING_MODULATOR                           0x0009
+#define AL_EFFECT_AUTOWAH                                  0x000A
+#define AL_EFFECT_COMPRESSOR                               0x000B
+#define AL_EFFECT_EQUALIZER                                0x000C
+#define ALC_EFX_MAJOR_VERSION                              0x20001
+#define ALC_EFX_MINOR_VERSION                              0x20002
+#define ALC_MAX_AUXILIARY_SENDS                            0x20003
+#endif
+ALvoid (AL_APIENTRY *p_alGenFilters)(ALsizei,ALuint*);
+ALvoid (AL_APIENTRY *p_alDeleteFilters)(ALsizei,ALuint*);
+ALvoid (AL_APIENTRY *p_alFilteri)(ALuint,ALenum,ALint);
+ALvoid (AL_APIENTRY *p_alGenEffects)(ALsizei,ALuint*);
+ALvoid (AL_APIENTRY *p_alDeleteEffects)(ALsizei,ALuint*);
+ALvoid (AL_APIENTRY *p_alEffecti)(ALuint,ALenum,ALint);
 
 static const int indentation = 4;
 static const int maxmimumWidth = 79;
@@ -134,7 +165,7 @@ static void printALCInfo (void)
            alcGetString(device, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER));
 
     alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &major);
-    alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &minor);
+    alcGetIntegerv(device, ALC_MINOR_VERSION, 1, &minor);
     checkForErrors();
     printf("ALC version: %d.%d\n", (int)major, (int)minor);
 
@@ -152,6 +183,97 @@ static void printALInfo(void)
     checkForErrors();
 }
 
+static void printEFXInfo(void)
+{
+    ALCint major, minor, sends;
+    ALCdevice *device;
+    ALuint obj;
+    int i;
+    const struct {
+        ALenum type;
+        const char *name;
+    } effects[] = {
+        { AL_EFFECT_EAXREVERB,         "EAX Reverb"        },
+        { AL_EFFECT_REVERB,            "Reverb"            },
+        { AL_EFFECT_CHORUS,            "Chorus"            },
+        { AL_EFFECT_DISTORTION,        "Distortion"        },
+        { AL_EFFECT_ECHO,              "Echo"              },
+        { AL_EFFECT_FLANGER,           "Flanger"           },
+        { AL_EFFECT_FREQUENCY_SHIFTER, "Frequency Shifter" },
+        { AL_EFFECT_VOCAL_MORPHER,     "Vocal Morpher"     },
+        { AL_EFFECT_PITCH_SHIFTER,     "Pitch Shifter"     },
+        { AL_EFFECT_RING_MODULATOR,    "Ring Modulator"    },
+        { AL_EFFECT_AUTOWAH,           "Autowah"           },
+        { AL_EFFECT_COMPRESSOR,        "Compressor"        },
+        { AL_EFFECT_EQUALIZER,         "Equalizer"         },
+        { AL_EFFECT_NULL, NULL }
+    };
+    const struct {
+        ALenum type;
+        const char *name;
+    } filters[] = {
+        { AL_FILTER_LOWPASS,  "Low-pass"  },
+        { AL_FILTER_HIGHPASS, "High-pass" },
+        { AL_FILTER_BANDPASS, "Band-pass" },
+        { AL_FILTER_NULL, NULL }
+    };
+
+    device = alcGetContextsDevice(alcGetCurrentContext());
+
+    if(alcIsExtensionPresent(device, (const ALCchar*)"ALC_EXT_EFX") == AL_FALSE)
+    {
+        printf("EFX not available\n");
+        return;
+    }
+
+    alcGetIntegerv(device, ALC_EFX_MAJOR_VERSION, 1, &major);
+    alcGetIntegerv(device, ALC_EFX_MINOR_VERSION, 1, &minor);
+    checkForErrors();
+    printf("EFX version: %d.%d\n", (int)major, (int)minor);
+
+    alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, &sends);
+    checkForErrors();
+    printf("Max auxiliary sends: %d\n", (int)sends);
+
+    p_alGenFilters = alGetProcAddress("alGenFilters");
+    p_alDeleteFilters = alGetProcAddress("alDeleteFilters");
+    p_alFilteri = alGetProcAddress("alFilteri");
+    p_alGenEffects = alGetProcAddress("alGenEffects");
+    p_alDeleteEffects = alGetProcAddress("alDeleteEffects");
+    p_alEffecti = alGetProcAddress("alEffecti");
+    checkForErrors();
+    if(!p_alGenEffects || !p_alDeleteEffects || !p_alEffecti ||
+       !p_alGenFilters || !p_alDeleteFilters || !p_alFilteri)
+    {
+        printf("Missing EFX functions!\n");
+        return;
+    }
+
+    p_alGenFilters(1, &obj);
+    checkForErrors();
+    printf("Available filters:\n");
+    for(i = 0;filters[i].type != AL_FILTER_NULL;i++)
+    {
+        p_alFilteri(obj, AL_FILTER_TYPE, filters[i].type);
+        if(alGetError() == AL_NO_ERROR)
+            printf("    %s\n", filters[i].name);
+    }
+    p_alDeleteFilters(1, &obj);
+    checkForErrors();
+
+    p_alGenEffects(1, &obj);
+    checkForErrors();
+    printf("Available effects:\n");
+    for(i = 0;effects[i].type != AL_EFFECT_NULL;i++)
+    {
+        p_alEffecti(obj, AL_EFFECT_TYPE, effects[i].type);
+        if(alGetError() == AL_NO_ERROR)
+            printf("    %s\n", effects[i].name);
+    }
+    p_alDeleteEffects(1, &obj);
+    checkForErrors();
+}
+
 int main()
 {
     ALCdevice *device = alcOpenDevice(NULL);
@@ -161,6 +283,7 @@ int main()
 
     printALCInfo();
     printALInfo();
+    printEFXInfo();
     checkForErrors();
 
     alcMakeContextCurrent(NULL);

include/AL/alc.h

@@ -166,11 +166,6 @@ typedef void ALCvoid;
 #define ALC_ATTRIBUTES_SIZE                      0x1002
 #define ALC_ALL_ATTRIBUTES                       0x1003
 
-/**
- * ALC_ENUMERATE_ALL_EXT enums
- */
-#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER        0x1012
-#define ALC_ALL_DEVICES_SPECIFIER                0x1013
 
 /**
  * Capture extension

include/AL/alext.h

@@ -25,10 +25,20 @@
 extern "C" {
 #endif
 
-#ifndef AL_EXT_float32
-#define AL_EXT_float32 1
-#define AL_FORMAT_MONO_FLOAT32                   0x10010
-#define AL_FORMAT_STEREO_FLOAT32                 0x10011
+#ifndef AL_LOKI_IMA_ADPCM_format
+#define AL_LOKI_IMA_ADPCM_format 1
+#define AL_FORMAT_IMA_ADPCM_MONO16_EXT           0x10000
+#define AL_FORMAT_IMA_ADPCM_STEREO16_EXT         0x10001
+#endif
+
+#ifndef AL_LOKI_WAVE_format
+#define AL_LOKI_WAVE_format 1
+#define AL_FORMAT_WAVE_EXT                       0x10002
+#endif
+
+#ifndef AL_EXT_vorbis
+#define AL_EXT_vorbis 1
+#define AL_FORMAT_VORBIS_EXT                     0x10003
 #endif
 
 #ifndef AL_LOKI_quadriphonic
@@ -37,6 +47,25 @@ extern "C" {
 #define AL_FORMAT_QUAD16_LOKI                    0x10005
 #endif
 
+#ifndef AL_EXT_float32
+#define AL_EXT_float32 1
+#define AL_FORMAT_MONO_FLOAT32                   0x10010
+#define AL_FORMAT_STEREO_FLOAT32                 0x10011
+#endif
+
+#ifndef ALC_LOKI_audio_channel
+#define ALC_LOKI_audio_channel 1
+#define ALC_CHAN_MAIN_LOKI                       0x500001
+#define ALC_CHAN_PCM_LOKI                        0x500002
+#define ALC_CHAN_CD_LOKI                         0x500003
+#endif
+
+#ifndef ALC_ENUMERATE_ALL_EXT
+#define ALC_ENUMERATE_ALL_EXT 1
+#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER        0x1012
+#define ALC_ALL_DEVICES_SPECIFIER                0x1013
+#endif
+
 #ifndef AL_EXT_MCFORMATS
 #define AL_EXT_MCFORMATS 1
 #define AL_FORMAT_QUAD8                          0x1204
@@ -62,6 +91,14 @@ extern "C" {
 #define AL_FORMAT_STEREO_IMA4                    0x1301
 #endif
 
+#ifndef AL_EXT_buffer_sub_data
+#define AL_EXT_buffer_sub_data 1
+#define AL_BYTE_RW_OFFSETS_EXT                   0x1031
+#define AL_SAMPLE_RW_OFFSETS_EXT                 0x1032
+#define AL_SEC_RW_OFFSETS_EXT                    0x1033
+typedef ALvoid (AL_APIENTRY*PFNALBUFFERSUBDATAEXTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei);
+#endif
+
 #ifdef __cplusplus
 }
 #endif