Move the core mixer functions to a separate source file

1 files changed, 1 insertions, 752 deletions

diff --git a/Alc/ALu.c b/Alc/ALu.c
index 7270cc16..cc3f95cf 100644
--- a/Alc/ALu.c
+++ b/Alc/ALu.c
@@ -31,49 +31,11 @@
 #include "AL/alc.h"
 #include "alSource.h"
 #include "alBuffer.h"
-#include "alThunk.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 ALvoid aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
 {
@@ -113,6 +75,7 @@ static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat w,ALfloat matrix[
     vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
 }
 
+
 ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
 {
     ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
@@ -566,720 +529,6 @@ ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
     }
 }
 
-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
-}
 
 ALvoid aluHandleDisconnect(ALCdevice *device)
 {