summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Alc/ALu.c753
-rw-r--r--Alc/mixer.c791
-rw-r--r--CMakeLists.txt1
3 files changed, 793 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)
{
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
+}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c88baa27..4ab0ded4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -309,6 +309,7 @@ SET(ALC_OBJS Alc/ALc.c
Alc/alcRing.c
Alc/alcThread.c
Alc/bs2b.c
+ Alc/mixer.c
Alc/panning.c
Alc/null.c
)
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-16 07:45:17 +0000