Move mixers into separate source files

1 files changed, 305 insertions, 0 deletions

diff --git a/Alc/mixer_inc.c b/Alc/mixer_inc.c
new file mode 100644
index 00000000..21166b60
--- /dev/null
+++ b/Alc/mixer_inc.c
@@ -0,0 +1,305 @@
+#include "config.h"
+
+#include "AL/alc.h"
+#include "AL/al.h"
+#include "alMain.h"
+#include "alSource.h"
+#include "alAuxEffectSlot.h"
+#include "mixer_defs.h"
+
+#ifdef __GNUC__
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+#define UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define LIKELY(x) (x)
+#define UNLIKELY(x) (x)
+#endif
+
+#define REAL_MERGE2(a,b) a##b
+#define MERGE2(a,b) REAL_MERGE2(a,b)
+#define REAL_MERGE4(a,b,c,d) a##b##c##d
+#define MERGE4(a,b,c,d) REAL_MERGE4(a,b,c,d)
+
+
+void MERGE4(MixDirect_Hrtf_,SAMPLER,_,SUFFIX)(
+  ALsource *Source, ALCdevice *Device, DirectParams *params,
+  const ALfloat *RESTRICT data, ALuint srcfrac,
+  ALuint OutPos, ALuint SamplesToDo, ALuint BufferSize)
+{
+    const ALuint NumChannels = Source->NumChannels;
+    const ALint *RESTRICT DelayStep = params->Hrtf.DelayStep;
+    ALfloat (*RESTRICT DryBuffer)[MaxChannels];
+    ALfloat *RESTRICT ClickRemoval, *RESTRICT PendingClicks;
+    ALfloat (*RESTRICT CoeffStep)[2] = params->Hrtf.CoeffStep;
+    ALuint pos, frac;
+    FILTER *DryFilter;
+    ALuint BufferIdx;
+    ALuint increment;
+    ALfloat value;
+    ALuint i,  c;
+
+    increment = Source->Params.Step;
+
+    DryBuffer = Device->DryBuffer;
+    ClickRemoval = Device->ClickRemoval;
+    PendingClicks = Device->PendingClicks;
+    DryFilter = &params->iirFilter;
+
+    for(i = 0;i < NumChannels;i++)
+    {
+        ALfloat (*RESTRICT TargetCoeffs)[2] = params->Hrtf.Coeffs[i];
+        ALuint *RESTRICT TargetDelay = params->Hrtf.Delay[i];
+        ALfloat *RESTRICT History = Source->Hrtf.History[i];
+        ALfloat (*RESTRICT Values)[2] = Source->Hrtf.Values[i];
+        ALint Counter = maxu(Source->Hrtf.Counter, OutPos) - OutPos;
+        ALuint Offset = Source->Hrtf.Offset + OutPos;
+        ALfloat Coeffs[HRIR_LENGTH][2];
+        ALuint Delay[2];
+        ALfloat left, right;
+
+        pos = 0;
+        frac = srcfrac;
+
+        for(c = 0;c < HRIR_LENGTH;c++)
+        {
+            Coeffs[c][0] = TargetCoeffs[c][0] - (CoeffStep[c][0]*Counter);
+            Coeffs[c][1] = TargetCoeffs[c][1] - (CoeffStep[c][1]*Counter);
+        }
+
+        Delay[0] = TargetDelay[0] - (DelayStep[0]*Counter);
+        Delay[1] = TargetDelay[1] - (DelayStep[1]*Counter);
+
+        if(LIKELY(OutPos == 0))
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+            value = lpFilter2PC(DryFilter, i, value);
+
+            History[Offset&SRC_HISTORY_MASK] = value;
+            left  = lerp(History[(Offset-(Delay[0]>>HRTFDELAY_BITS))&SRC_HISTORY_MASK],
+                         History[(Offset-(Delay[0]>>HRTFDELAY_BITS)-1)&SRC_HISTORY_MASK],
+                         (Delay[0]&HRTFDELAY_MASK)*(1.0f/HRTFDELAY_FRACONE));
+            right = lerp(History[(Offset-(Delay[1]>>HRTFDELAY_BITS))&SRC_HISTORY_MASK],
+                         History[(Offset-(Delay[1]>>HRTFDELAY_BITS)-1)&SRC_HISTORY_MASK],
+                         (Delay[1]&HRTFDELAY_MASK)*(1.0f/HRTFDELAY_FRACONE));
+
+            ClickRemoval[FrontLeft]  -= Values[(Offset+1)&HRIR_MASK][0] +
+                                        Coeffs[0][0] * left;
+            ClickRemoval[FrontRight] -= Values[(Offset+1)&HRIR_MASK][1] +
+                                        Coeffs[0][1] * right;
+        }
+        for(BufferIdx = 0;BufferIdx < BufferSize && Counter > 0;BufferIdx++)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+            value = lpFilter2P(DryFilter, i, value);
+
+            History[Offset&SRC_HISTORY_MASK] = value;
+            left  = lerp(History[(Offset-(Delay[0]>>HRTFDELAY_BITS))&SRC_HISTORY_MASK],
+                         History[(Offset-(Delay[0]>>HRTFDELAY_BITS)-1)&SRC_HISTORY_MASK],
+                         (Delay[0]&HRTFDELAY_MASK)*(1.0f/HRTFDELAY_FRACONE));
+            right = lerp(History[(Offset-(Delay[1]>>HRTFDELAY_BITS))&SRC_HISTORY_MASK],
+                         History[(Offset-(Delay[1]>>HRTFDELAY_BITS)-1)&SRC_HISTORY_MASK],
+                         (Delay[1]&HRTFDELAY_MASK)*(1.0f/HRTFDELAY_FRACONE));
+
+            Delay[0] += DelayStep[0];
+            Delay[1] += DelayStep[1];
+
+            Values[Offset&HRIR_MASK][0] = 0.0f;
+            Values[Offset&HRIR_MASK][1] = 0.0f;
+            Offset++;
+
+            for(c = 0;c < HRIR_LENGTH;c++)
+            {
+                const ALuint off = (Offset+c)&HRIR_MASK;
+                Values[off][0] += Coeffs[c][0] * left;
+                Values[off][1] += Coeffs[c][1] * right;
+                Coeffs[c][0] += CoeffStep[c][0];
+                Coeffs[c][1] += CoeffStep[c][1];
+            }
+
+            DryBuffer[OutPos][FrontLeft]  += Values[Offset&HRIR_MASK][0];
+            DryBuffer[OutPos][FrontRight] += Values[Offset&HRIR_MASK][1];
+
+            frac += increment;
+            pos  += frac>>FRACTIONBITS;
+            frac &= FRACTIONMASK;
+            OutPos++;
+            Counter--;
+        }
+
+        Delay[0] >>= HRTFDELAY_BITS;
+        Delay[1] >>= HRTFDELAY_BITS;
+        for(;BufferIdx < BufferSize;BufferIdx++)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+            value = lpFilter2P(DryFilter, i, value);
+
+            History[Offset&SRC_HISTORY_MASK] = value;
+            left = History[(Offset-Delay[0])&SRC_HISTORY_MASK];
+            right = History[(Offset-Delay[1])&SRC_HISTORY_MASK];
+
+            Values[Offset&HRIR_MASK][0] = 0.0f;
+            Values[Offset&HRIR_MASK][1] = 0.0f;
+            Offset++;
+
+            ApplyCoeffs(Offset, Values, Coeffs, left, right);
+            DryBuffer[OutPos][FrontLeft]  += Values[Offset&HRIR_MASK][0];
+            DryBuffer[OutPos][FrontRight] += Values[Offset&HRIR_MASK][1];
+
+            frac += increment;
+            pos  += frac>>FRACTIONBITS;
+            frac &= FRACTIONMASK;
+            OutPos++;
+        }
+        if(LIKELY(OutPos == SamplesToDo))
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+            value = lpFilter2PC(DryFilter, i, value);
+
+            History[Offset&SRC_HISTORY_MASK] = value;
+            left = History[(Offset-Delay[0])&SRC_HISTORY_MASK];
+            right = History[(Offset-Delay[1])&SRC_HISTORY_MASK];
+
+            PendingClicks[FrontLeft]  += Values[(Offset+1)&HRIR_MASK][0] +
+                                         Coeffs[0][0] * left;
+            PendingClicks[FrontRight] += Values[(Offset+1)&HRIR_MASK][1] +
+                                         Coeffs[0][1] * right;
+        }
+        OutPos -= BufferSize;
+    }
+}
+
+
+void MERGE4(MixDirect_,SAMPLER,_,SUFFIX)(
+  ALsource *Source, ALCdevice *Device, DirectParams *params,
+  const ALfloat *RESTRICT data, ALuint srcfrac,
+  ALuint OutPos, ALuint SamplesToDo, ALuint BufferSize)
+{
+    const ALuint NumChannels = Source->NumChannels;
+    ALfloat (*RESTRICT DryBuffer)[MaxChannels];
+    ALfloat *RESTRICT ClickRemoval, *RESTRICT PendingClicks;
+    ALfloat DrySend[MaxChannels];
+    FILTER *DryFilter;
+    ALuint pos, frac;
+    ALuint BufferIdx;
+    ALuint increment;
+    ALfloat value;
+    ALuint i,  c;
+
+    increment = Source->Params.Step;
+
+    DryBuffer = Device->DryBuffer;
+    ClickRemoval = Device->ClickRemoval;
+    PendingClicks = Device->PendingClicks;
+    DryFilter = &params->iirFilter;
+
+    for(i = 0;i < NumChannels;i++)
+    {
+        for(c = 0;c < MaxChannels;c++)
+            DrySend[c] = params->Gains[i][c];
+
+        pos = 0;
+        frac = srcfrac;
+
+        if(OutPos == 0)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+
+            value = lpFilter2PC(DryFilter, i, value);
+            for(c = 0;c < MaxChannels;c++)
+                ClickRemoval[c] -= value*DrySend[c];
+        }
+        for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+
+            value = lpFilter2P(DryFilter, i, value);
+            for(c = 0;c < MaxChannels;c++)
+                DryBuffer[OutPos][c] += value*DrySend[c];
+
+            frac += increment;
+            pos  += frac>>FRACTIONBITS;
+            frac &= FRACTIONMASK;
+            OutPos++;
+        }
+        if(OutPos == SamplesToDo)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+
+            value = lpFilter2PC(DryFilter, i, value);
+            for(c = 0;c < MaxChannels;c++)
+                PendingClicks[c] += value*DrySend[c];
+        }
+        OutPos -= BufferSize;
+    }
+}
+
+
+void MERGE4(MixSend_,SAMPLER,_,SUFFIX)(
+  ALsource *Source, ALuint sendidx, SendParams *params,
+  const ALfloat *RESTRICT data, ALuint srcfrac,
+  ALuint OutPos, ALuint SamplesToDo, ALuint BufferSize)
+{
+    const ALuint NumChannels = Source->NumChannels;
+    ALeffectslot *Slot;
+    ALfloat  WetSend;
+    ALfloat *WetBuffer;
+    ALfloat *WetClickRemoval;
+    ALfloat *WetPendingClicks;
+    FILTER  *WetFilter;
+    ALuint pos, frac;
+    ALuint BufferIdx;
+    ALuint increment;
+    ALfloat value;
+    ALuint i;
+
+    increment = Source->Params.Step;
+
+    Slot = Source->Params.Slot[sendidx];
+    WetBuffer = Slot->WetBuffer;
+    WetClickRemoval = Slot->ClickRemoval;
+    WetPendingClicks = Slot->PendingClicks;
+    WetFilter = &params->iirFilter;
+    WetSend = params->Gain;
+
+    for(i = 0;i < NumChannels;i++)
+    {
+        pos = 0;
+        frac = srcfrac;
+
+        if(OutPos == 0)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+
+            value = lpFilter2PC(WetFilter, i, value);
+            WetClickRemoval[0] -= value * WetSend;
+        }
+        for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+
+            value = lpFilter2P(WetFilter, i, value);
+            WetBuffer[OutPos] += value * WetSend;
+
+            frac += increment;
+            pos  += frac>>FRACTIONBITS;
+            frac &= FRACTIONMASK;
+            OutPos++;
+        }
+        if(OutPos == SamplesToDo)
+        {
+            value = SAMPLER(data + pos*NumChannels + i, NumChannels, frac);
+
+            value = lpFilter2PC(WetFilter, i, value);
+            WetPendingClicks[0] += value * WetSend;
+        }
+        OutPos -= BufferSize;
+    }
+}
+
+#undef MERGE4
+#undef REAL_MERGE4
+#undef MERGE2
+#undef REAL_MERGE2
+
+#undef UNLIKELY
+#undef LIKELY