Move the core mixer functions to a separate source file
This commit is contained in:
Chris Robinson
@@ -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)
|
||||
{
|
||||
|
||||
+791
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user