Move the core mixer functions to a separate source file

1 files changed, 791 insertions, 0 deletions

diff --git a/Alc/mixer.c b/Alc/mixer.c
new file mode 100644
index 00000000..e880ad3a
--- /dev/null
+++ b/Alc/mixer.c
@@ -0,0 +1,791 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "alMain.h"
+#include "AL/al.h"
+#include "AL/alc.h"
+#include "alSource.h"
+#include "alBuffer.h"
+#include "alListener.h"
+#include "alAuxEffectSlot.h"
+#include "alu.h"
+#include "bs2b.h"
+
+#define FRACTIONBITS 14
+#define FRACTIONMASK ((1L<<FRACTIONBITS)-1)
+#define MAX_PITCH 65536
+
+/* Minimum ramp length in milliseconds. The value below was chosen to
+ * adequately reduce clicks and pops from harsh gain changes. */
+#define MIN_RAMP_LENGTH  16
+
+
+static __inline ALfloat aluF2F(ALfloat Value)
+{
+    return Value;
+}
+
+static __inline ALshort aluF2S(ALfloat Value)
+{
+    ALint i;
+
+    if(Value < 0.0f)
+    {
+        i = (ALint)(Value*32768.0f);
+        i = max(-32768, i);
+    }
+    else
+    {
+        i = (ALint)(Value*32767.0f);
+        i = min( 32767, i);
+    }
+    return ((ALshort)i);
+}
+
+static __inline ALubyte aluF2UB(ALfloat Value)
+{
+    ALshort i = aluF2S(Value);
+    return (i>>8)+128;
+}
+
+
+static __inline ALfloat point(ALfloat val1, ALfloat val2, ALint frac)
+{
+    return val1;
+    (void)val2;
+    (void)frac;
+}
+static __inline ALfloat lerp(ALfloat val1, ALfloat val2, ALint frac)
+{
+    return val1 + ((val2-val1)*(frac * (1.0f/(1<<FRACTIONBITS))));
+}
+static __inline ALfloat cos_lerp(ALfloat val1, ALfloat val2, ALint frac)
+{
+    ALfloat mult = (1.0f-cos(frac * (1.0f/(1<<FRACTIONBITS)) * M_PI)) * 0.5f;
+    return val1 + ((val2-val1)*mult);
+}
+
+
+static void MixSource(ALsource *ALSource, ALCcontext *ALContext,
+                      float (*DryBuffer)[OUTPUTCHANNELS], ALuint SamplesToDo)
+{
+    static float DummyBuffer[BUFFERSIZE];
+    ALfloat *WetBuffer[MAX_SENDS];
+    ALfloat DrySend[OUTPUTCHANNELS];
+    ALfloat dryGainStep[OUTPUTCHANNELS];
+    ALfloat wetGainStep[MAX_SENDS];
+    ALuint i, j, out;
+    ALfloat value, outsamp;
+    ALbufferlistitem *BufferListItem;
+    ALint64 DataSize64,DataPos64;
+    FILTER *DryFilter, *WetFilter[MAX_SENDS];
+    ALfloat WetSend[MAX_SENDS];
+    ALuint rampLength;
+    ALboolean DuplicateStereo;
+    ALuint DeviceFreq;
+    ALint increment;
+    ALuint DataPosInt, DataPosFrac;
+    ALuint Channels, Bytes;
+    ALuint Frequency;
+    resampler_t Resampler;
+    ALuint BuffersPlayed;
+    ALboolean Looping;
+    ALfloat Pitch;
+    ALenum State;
+
+    DuplicateStereo = ALContext->Device->DuplicateStereo;
+    DeviceFreq = ALContext->Device->Frequency;
+
+    rampLength = DeviceFreq * MIN_RAMP_LENGTH / 1000;
+    rampLength = max(rampLength, SamplesToDo);
+
+    /* Find buffer format */
+    Frequency = 0;
+    Channels = 0;
+    Bytes = 0;
+    BufferListItem = ALSource->queue;
+    while(BufferListItem != NULL)
+    {
+        ALbuffer *ALBuffer;
+        if((ALBuffer=BufferListItem->buffer) != NULL)
+        {
+            Channels  = aluChannelsFromFormat(ALBuffer->format);
+            Bytes     = aluBytesFromFormat(ALBuffer->format);
+            Frequency = ALBuffer->frequency;
+            break;
+        }
+        BufferListItem = BufferListItem->next;
+    }
+
+    if(ALSource->NeedsUpdate)
+    {
+        ALsource_Update(ALSource, ALContext);
+        ALSource->NeedsUpdate = AL_FALSE;
+    }
+
+    /* Get source info */
+    Resampler     = ALSource->Resampler;
+    State         = ALSource->state;
+    BuffersPlayed = ALSource->BuffersPlayed;
+    DataPosInt    = ALSource->position;
+    DataPosFrac   = ALSource->position_fraction;
+    Looping       = ALSource->bLooping;
+
+    /* Compute 18.14 fixed point step */
+    Pitch = (ALSource->Params.Pitch*Frequency) / DeviceFreq;
+    if(Pitch > (float)MAX_PITCH)  Pitch = (float)MAX_PITCH;
+    increment = (ALint)(Pitch*(ALfloat)(1L<<FRACTIONBITS));
+    if(increment <= 0)  increment = (1<<FRACTIONBITS);
+
+    if(ALSource->FirstStart)
+    {
+        for(i = 0;i < OUTPUTCHANNELS;i++)
+            DrySend[i] = ALSource->Params.DryGains[i];
+        for(i = 0;i < MAX_SENDS;i++)
+            WetSend[i] = ALSource->Params.WetGains[i];
+    }
+    else
+    {
+        for(i = 0;i < OUTPUTCHANNELS;i++)
+            DrySend[i] = ALSource->DryGains[i];
+        for(i = 0;i < MAX_SENDS;i++)
+            WetSend[i] = ALSource->WetGains[i];
+    }
+
+    DryFilter = &ALSource->Params.iirFilter;
+    for(i = 0;i < MAX_SENDS;i++)
+    {
+        WetFilter[i] = &ALSource->Params.Send[i].iirFilter;
+        WetBuffer[i] = (ALSource->Send[i].Slot ?
+                        ALSource->Send[i].Slot->WetBuffer :
+                        DummyBuffer);
+    }
+
+    /* Get current buffer queue item */
+    BufferListItem = ALSource->queue;
+    for(i = 0;i < BuffersPlayed && BufferListItem;i++)
+        BufferListItem = BufferListItem->next;
+
+    j = 0;
+    do {
+        ALfloat *Data = NULL;
+        ALuint LoopStart = 0;
+        ALuint LoopEnd = 0;
+        ALuint DataSize = 0;
+        ALbuffer *ALBuffer;
+        ALuint BufferSize;
+
+        /* Get buffer info */
+        if((ALBuffer=BufferListItem->buffer) != NULL)
+        {
+            Data      = ALBuffer->data;
+            DataSize  = ALBuffer->size;
+            DataSize /= Channels * Bytes;
+            LoopStart = ALBuffer->LoopStart;
+            LoopEnd   = ALBuffer->LoopEnd;
+        }
+
+        if(Looping && ALSource->lSourceType == AL_STATIC)
+        {
+            /* If current offset is beyond the loop range, do not loop */
+            if(DataPosInt >= LoopEnd)
+                Looping = AL_FALSE;
+        }
+        if(!Looping || ALSource->lSourceType != AL_STATIC)
+        {
+            /* Non-looping and non-static sources ignore loop points */
+            LoopStart = 0;
+            LoopEnd = DataSize;
+        }
+
+        if(DataPosInt >= DataSize)
+            goto skipmix;
+
+        if(BufferListItem->next)
+        {
+            ALbuffer *NextBuf = BufferListItem->next->buffer;
+            if(NextBuf && NextBuf->size)
+            {
+                ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
+                ulExtraSamples = min(NextBuf->size, ulExtraSamples);
+                memcpy(&Data[DataSize*Channels], NextBuf->data, ulExtraSamples);
+            }
+        }
+        else if(Looping)
+        {
+            ALbuffer *NextBuf = ALSource->queue->buffer;
+            if(NextBuf && NextBuf->size)
+            {
+                ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
+                ulExtraSamples = min(NextBuf->size, ulExtraSamples);
+                memcpy(&Data[DataSize*Channels], &NextBuf->data[LoopStart*Channels], ulExtraSamples);
+            }
+        }
+        else
+            memset(&Data[DataSize*Channels], 0, (BUFFER_PADDING*Channels*Bytes));
+
+        /* Compute the gain steps for each output channel */
+        for(i = 0;i < OUTPUTCHANNELS;i++)
+            dryGainStep[i] = (ALSource->Params.DryGains[i]-DrySend[i]) /
+                             rampLength;
+        for(i = 0;i < MAX_SENDS;i++)
+            wetGainStep[i] = (ALSource->Params.WetGains[i]-WetSend[i]) /
+                             rampLength;
+
+        /* Figure out how many samples we can mix. */
+        DataSize64 = LoopEnd;
+        DataSize64 <<= FRACTIONBITS;
+        DataPos64 = DataPosInt;
+        DataPos64 <<= FRACTIONBITS;
+        DataPos64 += DataPosFrac;
+        BufferSize = (ALuint)((DataSize64-DataPos64+(increment-1)) / increment);
+
+        BufferSize = min(BufferSize, (SamplesToDo-j));
+
+        /* Actual sample mixing loops */
+        if(Channels == 1) /* Mono */
+        {
+#define DO_MIX(resampler) do {                                                \
+    while(BufferSize--)                                                       \
+    {                                                                         \
+        for(i = 0;i < OUTPUTCHANNELS;i++)                                     \
+            DrySend[i] += dryGainStep[i];                                     \
+        for(i = 0;i < MAX_SENDS;i++)                                          \
+            WetSend[i] += wetGainStep[i];                                     \
+                                                                              \
+        /* First order interpolator */                                        \
+        value = (resampler)(Data[DataPosInt], Data[DataPosInt+1],             \
+                            DataPosFrac);                                     \
+                                                                              \
+        /* Direct path final mix buffer and panning */                        \
+        outsamp = lpFilter4P(DryFilter, 0, value);                            \
+        DryBuffer[j][FRONT_LEFT]   += outsamp*DrySend[FRONT_LEFT];            \
+        DryBuffer[j][FRONT_RIGHT]  += outsamp*DrySend[FRONT_RIGHT];           \
+        DryBuffer[j][SIDE_LEFT]    += outsamp*DrySend[SIDE_LEFT];             \
+        DryBuffer[j][SIDE_RIGHT]   += outsamp*DrySend[SIDE_RIGHT];            \
+        DryBuffer[j][BACK_LEFT]    += outsamp*DrySend[BACK_LEFT];             \
+        DryBuffer[j][BACK_RIGHT]   += outsamp*DrySend[BACK_RIGHT];            \
+        DryBuffer[j][FRONT_CENTER] += outsamp*DrySend[FRONT_CENTER];          \
+        DryBuffer[j][BACK_CENTER]  += outsamp*DrySend[BACK_CENTER];           \
+                                                                              \
+        /* Room path final mix buffer and panning */                          \
+        for(i = 0;i < MAX_SENDS;i++)                                          \
+        {                                                                     \
+            outsamp = lpFilter2P(WetFilter[i], 0, value);                     \
+            WetBuffer[i][j] += outsamp*WetSend[i];                            \
+        }                                                                     \
+                                                                              \
+        DataPosFrac += increment;                                             \
+        DataPosInt += DataPosFrac>>FRACTIONBITS;                              \
+        DataPosFrac &= FRACTIONMASK;                                          \
+        j++;                                                                  \
+    }                                                                         \
+} while(0)
+
+            switch(Resampler)
+            {
+                case POINT_RESAMPLER:
+                DO_MIX(point); break;
+                case LINEAR_RESAMPLER:
+                DO_MIX(lerp); break;
+                case COSINE_RESAMPLER:
+                DO_MIX(cos_lerp); break;
+                case RESAMPLER_MIN:
+                case RESAMPLER_MAX:
+                break;
+            }
+#undef DO_MIX
+        }
+        else if(Channels == 2 && DuplicateStereo) /* Stereo */
+        {
+            const int chans[] = {
+                FRONT_LEFT, FRONT_RIGHT
+            };
+            const int chans2[] = {
+                BACK_LEFT, SIDE_LEFT, BACK_RIGHT, SIDE_RIGHT
+            };
+            const ALfloat dupscaler = aluSqrt(1.0f/3.0f);
+
+#define DO_MIX(resampler) do {                                                \
+    const ALfloat scaler = 1.0f/Channels;                                     \
+    while(BufferSize--)                                                       \
+    {                                                                         \
+        for(i = 0;i < OUTPUTCHANNELS;i++)                                     \
+            DrySend[i] += dryGainStep[i];                                     \
+        for(i = 0;i < MAX_SENDS;i++)                                          \
+            WetSend[i] += wetGainStep[i];                                     \
+                                                                              \
+        for(i = 0;i < Channels;i++)                                           \
+        {                                                                     \
+            value = (resampler)(Data[DataPosInt*Channels + i],                \
+                                Data[(DataPosInt+1)*Channels + i],            \
+                                DataPosFrac);                                 \
+                                                                              \
+            outsamp = lpFilter2P(DryFilter, chans[i]*2, value) * dupscaler;   \
+            DryBuffer[j][chans[i]] += outsamp*DrySend[chans[i]];              \
+            DryBuffer[j][chans2[i*2+0]] += outsamp*DrySend[chans2[i*2+0]];    \
+            DryBuffer[j][chans2[i*2+1]] += outsamp*DrySend[chans2[i*2+1]];    \
+                                                                              \
+            for(out = 0;out < MAX_SENDS;out++)                                \
+            {                                                                 \
+                outsamp = lpFilter1P(WetFilter[out], chans[i], value);        \
+                WetBuffer[out][j] += outsamp*WetSend[out]*scaler;             \
+            }                                                                 \
+        }                                                                     \
+                                                                              \
+        DataPosFrac += increment;                                             \
+        DataPosInt += DataPosFrac>>FRACTIONBITS;                              \
+        DataPosFrac &= FRACTIONMASK;                                          \
+        j++;                                                                  \
+    }                                                                         \
+} while(0)
+
+            switch(Resampler)
+            {
+                case POINT_RESAMPLER:
+                DO_MIX(point); break;
+                case LINEAR_RESAMPLER:
+                DO_MIX(lerp); break;
+                case COSINE_RESAMPLER:
+                DO_MIX(cos_lerp); break;
+                case RESAMPLER_MIN:
+                case RESAMPLER_MAX:
+                break;
+            }
+#undef DO_MIX
+        }
+        else if(Channels == 2) /* Stereo */
+        {
+            const int chans[] = {
+                FRONT_LEFT, FRONT_RIGHT
+            };
+
+#define DO_MIX(resampler) do {                                                \
+    const ALfloat scaler = 1.0f/Channels;                                     \
+    while(BufferSize--)                                                       \
+    {                                                                         \
+        for(i = 0;i < OUTPUTCHANNELS;i++)                                     \
+            DrySend[i] += dryGainStep[i];                                     \
+        for(i = 0;i < MAX_SENDS;i++)                                          \
+            WetSend[i] += wetGainStep[i];                                     \
+                                                                              \
+        for(i = 0;i < Channels;i++)                                           \
+        {                                                                     \
+            value = (resampler)(Data[DataPosInt*Channels + i],                \
+                                Data[(DataPosInt+1)*Channels + i],            \
+                                DataPosFrac);                                 \
+                                                                              \
+            outsamp = lpFilter2P(DryFilter, chans[i]*2, value);               \
+            DryBuffer[j][chans[i]] += outsamp*DrySend[chans[i]];              \
+                                                                              \
+            for(out = 0;out < MAX_SENDS;out++)                                \
+            {                                                                 \
+                outsamp = lpFilter1P(WetFilter[out], chans[i], value);        \
+                WetBuffer[out][j] += outsamp*WetSend[out]*scaler;             \
+            }                                                                 \
+        }                                                                     \
+                                                                              \
+        DataPosFrac += increment;                                             \
+        DataPosInt += DataPosFrac>>FRACTIONBITS;                              \
+        DataPosFrac &= FRACTIONMASK;                                          \
+        j++;                                                                  \
+    }                                                                         \
+} while(0)
+
+            switch(Resampler)
+            {
+                case POINT_RESAMPLER:
+                DO_MIX(point); break;
+                case LINEAR_RESAMPLER:
+                DO_MIX(lerp); break;
+                case COSINE_RESAMPLER:
+                DO_MIX(cos_lerp); break;
+                case RESAMPLER_MIN:
+                case RESAMPLER_MAX:
+                break;
+            }
+        }
+        else if(Channels == 4) /* Quad */
+        {
+            const int chans[] = {
+                FRONT_LEFT, FRONT_RIGHT,
+                BACK_LEFT,  BACK_RIGHT
+            };
+
+            switch(Resampler)
+            {
+                case POINT_RESAMPLER:
+                DO_MIX(point); break;
+                case LINEAR_RESAMPLER:
+                DO_MIX(lerp); break;
+                case COSINE_RESAMPLER:
+                DO_MIX(cos_lerp); break;
+                case RESAMPLER_MIN:
+                case RESAMPLER_MAX:
+                break;
+            }
+        }
+        else if(Channels == 6) /* 5.1 */
+        {
+            const int chans[] = {
+                FRONT_LEFT,   FRONT_RIGHT,
+                FRONT_CENTER, LFE,
+                BACK_LEFT,    BACK_RIGHT
+            };
+
+            switch(Resampler)
+            {
+                case POINT_RESAMPLER:
+                DO_MIX(point); break;
+                case LINEAR_RESAMPLER:
+                DO_MIX(lerp); break;
+                case COSINE_RESAMPLER:
+                DO_MIX(cos_lerp); break;
+                case RESAMPLER_MIN:
+                case RESAMPLER_MAX:
+                break;
+            }
+        }
+        else if(Channels == 7) /* 6.1 */
+        {
+            const int chans[] = {
+                FRONT_LEFT,   FRONT_RIGHT,
+                FRONT_CENTER, LFE,
+                BACK_CENTER,
+                SIDE_LEFT,    SIDE_RIGHT
+            };
+
+            switch(Resampler)
+            {
+                case POINT_RESAMPLER:
+                DO_MIX(point); break;
+                case LINEAR_RESAMPLER:
+                DO_MIX(lerp); break;
+                case COSINE_RESAMPLER:
+                DO_MIX(cos_lerp); break;
+                case RESAMPLER_MIN:
+                case RESAMPLER_MAX:
+                break;
+            }
+        }
+        else if(Channels == 8) /* 7.1 */
+        {
+            const int chans[] = {
+                FRONT_LEFT,   FRONT_RIGHT,
+                FRONT_CENTER, LFE,
+                BACK_LEFT,    BACK_RIGHT,
+                SIDE_LEFT,    SIDE_RIGHT
+            };
+
+            switch(Resampler)
+            {
+                case POINT_RESAMPLER:
+                DO_MIX(point); break;
+                case LINEAR_RESAMPLER:
+                DO_MIX(lerp); break;
+                case COSINE_RESAMPLER:
+                DO_MIX(cos_lerp); break;
+                case RESAMPLER_MIN:
+                case RESAMPLER_MAX:
+                break;
+            }
+#undef DO_MIX
+        }
+        else /* Unknown? */
+        {
+            for(i = 0;i < OUTPUTCHANNELS;i++)
+                DrySend[i] += dryGainStep[i]*BufferSize;
+            for(i = 0;i < MAX_SENDS;i++)
+                WetSend[i] += wetGainStep[i]*BufferSize;
+            while(BufferSize--)
+            {
+                DataPosFrac += increment;
+                DataPosInt += DataPosFrac>>FRACTIONBITS;
+                DataPosFrac &= FRACTIONMASK;
+                j++;
+            }
+        }
+
+    skipmix:
+        /* Handle looping sources */
+        if(DataPosInt >= LoopEnd)
+        {
+            if(BuffersPlayed < (ALSource->BuffersInQueue-1))
+            {
+                BufferListItem = BufferListItem->next;
+                BuffersPlayed++;
+                DataPosInt -= DataSize;
+            }
+            else if(Looping)
+            {
+                BufferListItem = ALSource->queue;
+                BuffersPlayed = 0;
+                if(ALSource->lSourceType == AL_STATIC)
+                    DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
+                else
+                    DataPosInt -= DataSize;
+            }
+            else
+            {
+                State = AL_STOPPED;
+                BufferListItem = ALSource->queue;
+                BuffersPlayed = ALSource->BuffersInQueue;
+                DataPosInt = 0;
+                DataPosFrac = 0;
+            }
+        }
+    } while(State == AL_PLAYING && j < SamplesToDo);
+
+    /* Update source info */
+    ALSource->state             = State;
+    ALSource->BuffersPlayed     = BuffersPlayed;
+    ALSource->position          = DataPosInt;
+    ALSource->position_fraction = DataPosFrac;
+    ALSource->Buffer            = BufferListItem->buffer;
+
+    for(i = 0;i < OUTPUTCHANNELS;i++)
+        ALSource->DryGains[i] = DrySend[i];
+    for(i = 0;i < MAX_SENDS;i++)
+        ALSource->WetGains[i] = WetSend[i];
+
+    ALSource->FirstStart = AL_FALSE;
+}
+
+ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
+{
+    float (*DryBuffer)[OUTPUTCHANNELS];
+    ALfloat (*Matrix)[OUTPUTCHANNELS];
+    const ALuint *ChanMap;
+    ALuint SamplesToDo;
+    ALeffectslot *ALEffectSlot;
+    ALCcontext *ALContext;
+    ALfloat samp;
+    int fpuState;
+    ALuint i, j, c;
+    ALsizei e, s;
+
+#if defined(HAVE_FESETROUND)
+    fpuState = fegetround();
+    fesetround(FE_TOWARDZERO);
+#elif defined(HAVE__CONTROLFP)
+    fpuState = _controlfp(0, 0);
+    _controlfp(_RC_CHOP, _MCW_RC);
+#else
+    (void)fpuState;
+#endif
+
+    DryBuffer = device->DryBuffer;
+    while(size > 0)
+    {
+        /* Setup variables */
+        SamplesToDo = min(size, BUFFERSIZE);
+
+        /* Clear mixing buffer */
+        memset(DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
+
+        SuspendContext(NULL);
+        for(c = 0;c < device->NumContexts;c++)
+        {
+            ALContext = device->Contexts[c];
+            SuspendContext(ALContext);
+
+            s = 0;
+            while(s < ALContext->ActiveSourceCount)
+            {
+                ALsource *Source = ALContext->ActiveSources[s];
+                if(Source->state != AL_PLAYING)
+                {
+                    ALsizei end = --(ALContext->ActiveSourceCount);
+                    ALContext->ActiveSources[s] = ALContext->ActiveSources[end];
+                    continue;
+                }
+                MixSource(Source, ALContext, DryBuffer, SamplesToDo);
+                s++;
+            }
+
+            /* effect slot processing */
+            for(e = 0;e < ALContext->EffectSlotMap.size;e++)
+            {
+                ALEffectSlot = ALContext->EffectSlotMap.array[e].value;
+                if(ALEffectSlot->EffectState)
+                    ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot, SamplesToDo, ALEffectSlot->WetBuffer, DryBuffer);
+
+                for(i = 0;i < SamplesToDo;i++)
+                    ALEffectSlot->WetBuffer[i] = 0.0f;
+            }
+            ProcessContext(ALContext);
+        }
+        device->SamplesPlayed += SamplesToDo;
+        ProcessContext(NULL);
+
+        //Post processing loop
+        ChanMap = device->DevChannels;
+        Matrix = device->ChannelMatrix;
+        switch(device->Format)
+        {
+#define CHECK_WRITE_FORMAT(bits, type, func)                                  \
+        case AL_FORMAT_MONO##bits:                                            \
+            for(i = 0;i < SamplesToDo;i++)                                    \
+            {                                                                 \
+                samp = 0.0f;                                                  \
+                for(c = 0;c < OUTPUTCHANNELS;c++)                             \
+                    samp += DryBuffer[i][c] * Matrix[c][FRONT_CENTER];        \
+                ((type*)buffer)[ChanMap[FRONT_CENTER]] = (func)(samp);        \
+                buffer = ((type*)buffer) + 1;                                 \
+            }                                                                 \
+            break;                                                            \
+        case AL_FORMAT_STEREO##bits:                                          \
+            if(device->Bs2b)                                                  \
+            {                                                                 \
+                for(i = 0;i < SamplesToDo;i++)                                \
+                {                                                             \
+                    float samples[2] = { 0.0f, 0.0f };                        \
+                    for(c = 0;c < OUTPUTCHANNELS;c++)                         \
+                    {                                                         \
+                        samples[0] += DryBuffer[i][c]*Matrix[c][FRONT_LEFT];  \
+                        samples[1] += DryBuffer[i][c]*Matrix[c][FRONT_RIGHT]; \
+                    }                                                         \
+                    bs2b_cross_feed(device->Bs2b, samples);                   \
+                    ((type*)buffer)[ChanMap[FRONT_LEFT]] = (func)(samples[0]);\
+                    ((type*)buffer)[ChanMap[FRONT_RIGHT]]= (func)(samples[1]);\
+                    buffer = ((type*)buffer) + 2;                             \
+                }                                                             \
+            }                                                                 \
+            else                                                              \
+            {                                                                 \
+                for(i = 0;i < SamplesToDo;i++)                                \
+                {                                                             \
+                    static const Channel chans[] = {                          \
+                        FRONT_LEFT, FRONT_RIGHT                               \
+                    };                                                        \
+                    for(j = 0;j < 2;j++)                                      \
+                    {                                                         \
+                        samp = 0.0f;                                          \
+                        for(c = 0;c < OUTPUTCHANNELS;c++)                     \
+                            samp += DryBuffer[i][c] * Matrix[c][chans[j]];    \
+                        ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp);    \
+                    }                                                         \
+                    buffer = ((type*)buffer) + 2;                             \
+                }                                                             \
+            }                                                                 \
+            break;                                                            \
+        case AL_FORMAT_QUAD##bits:                                            \
+            for(i = 0;i < SamplesToDo;i++)                                    \
+            {                                                                 \
+                static const Channel chans[] = {                              \
+                    FRONT_LEFT, FRONT_RIGHT,                                  \
+                    BACK_LEFT,  BACK_RIGHT,                                   \
+                };                                                            \
+                for(j = 0;j < 4;j++)                                          \
+                {                                                             \
+                    samp = 0.0f;                                              \
+                    for(c = 0;c < OUTPUTCHANNELS;c++)                         \
+                        samp += DryBuffer[i][c] * Matrix[c][chans[j]];        \
+                    ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp);        \
+                }                                                             \
+                buffer = ((type*)buffer) + 4;                                 \
+            }                                                                 \
+            break;                                                            \
+        case AL_FORMAT_51CHN##bits:                                           \
+            for(i = 0;i < SamplesToDo;i++)                                    \
+            {                                                                 \
+                static const Channel chans[] = {                              \
+                    FRONT_LEFT, FRONT_RIGHT,                                  \
+                    FRONT_CENTER, LFE,                                        \
+                    BACK_LEFT,  BACK_RIGHT,                                   \
+                };                                                            \
+                for(j = 0;j < 6;j++)                                          \
+                {                                                             \
+                    samp = 0.0f;                                              \
+                    for(c = 0;c < OUTPUTCHANNELS;c++)                         \
+                        samp += DryBuffer[i][c] * Matrix[c][chans[j]];        \
+                    ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp);        \
+                }                                                             \
+                buffer = ((type*)buffer) + 6;                                 \
+            }                                                                 \
+            break;                                                            \
+        case AL_FORMAT_61CHN##bits:                                           \
+            for(i = 0;i < SamplesToDo;i++)                                    \
+            {                                                                 \
+                static const Channel chans[] = {                              \
+                    FRONT_LEFT, FRONT_RIGHT,                                  \
+                    FRONT_CENTER, LFE, BACK_CENTER,                           \
+                    SIDE_LEFT,  SIDE_RIGHT,                                   \
+                };                                                            \
+                for(j = 0;j < 7;j++)                                          \
+                {                                                             \
+                    samp = 0.0f;                                              \
+                    for(c = 0;c < OUTPUTCHANNELS;c++)                         \
+                        samp += DryBuffer[i][c] * Matrix[c][chans[j]];        \
+                    ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp);        \
+                }                                                             \
+                buffer = ((type*)buffer) + 7;                                 \
+            }                                                                 \
+            break;                                                            \
+        case AL_FORMAT_71CHN##bits:                                           \
+            for(i = 0;i < SamplesToDo;i++)                                    \
+            {                                                                 \
+                static const Channel chans[] = {                              \
+                    FRONT_LEFT, FRONT_RIGHT,                                  \
+                    FRONT_CENTER, LFE,                                        \
+                    BACK_LEFT,  BACK_RIGHT,                                   \
+                    SIDE_LEFT,  SIDE_RIGHT                                    \
+                };                                                            \
+                for(j = 0;j < 8;j++)                                          \
+                {                                                             \
+                    samp = 0.0f;                                              \
+                    for(c = 0;c < OUTPUTCHANNELS;c++)                         \
+                        samp += DryBuffer[i][c] * Matrix[c][chans[j]];        \
+                    ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp);        \
+                }                                                             \
+                buffer = ((type*)buffer) + 8;                                 \
+            }                                                                 \
+            break;
+
+#define AL_FORMAT_MONO32 AL_FORMAT_MONO_FLOAT32
+#define AL_FORMAT_STEREO32 AL_FORMAT_STEREO_FLOAT32
+            CHECK_WRITE_FORMAT(8,  ALubyte, aluF2UB)
+            CHECK_WRITE_FORMAT(16, ALshort, aluF2S)
+            CHECK_WRITE_FORMAT(32, ALfloat, aluF2F)
+#undef AL_FORMAT_STEREO32
+#undef AL_FORMAT_MONO32
+#undef CHECK_WRITE_FORMAT
+
+            default:
+                break;
+        }
+
+        size -= SamplesToDo;
+    }
+
+#if defined(HAVE_FESETROUND)
+    fesetround(fpuState);
+#elif defined(HAVE__CONTROLFP)
+    _controlfp(fpuState, 0xfffff);
+#endif
+}