kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
openal-soft/Alc/ALu.c
Chris Robinson 55f851093f Remove the now-unneeded click removal buffers for the device 
They are still there for auxiliary sends. However, they should go away soon
enough too, and then we won't have to mess around with calculating extra
"predictive" samples in the mixer.
2014-03-23 07:31:33 -07:00

1336 lines
45 KiB
C
Raw Blame History

/**
* 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 "alSource.h"
#include "alBuffer.h"
#include "alListener.h"
#include "alAuxEffectSlot.h"
#include "alu.h"
#include "bs2b.h"
#include "hrtf.h"
#include "mixer_defs.h"
#include "midi/base.h"
struct ChanMap {
enum Channel channel;
ALfloat angle;
};
/* Cone scalar */
ALfloat ConeScale = 1.0f;
/* Localized Z scalar for mono sources */
ALfloat ZScale = 1.0f;
extern inline ALfloat minf(ALfloat a, ALfloat b);
extern inline ALfloat maxf(ALfloat a, ALfloat b);
extern inline ALfloat clampf(ALfloat val, ALfloat min, ALfloat max);
extern inline ALdouble mind(ALdouble a, ALdouble b);
extern inline ALdouble maxd(ALdouble a, ALdouble b);
extern inline ALdouble clampd(ALdouble val, ALdouble min, ALdouble max);
extern inline ALuint minu(ALuint a, ALuint b);
extern inline ALuint maxu(ALuint a, ALuint b);
extern inline ALuint clampu(ALuint val, ALuint min, ALuint max);
extern inline ALint mini(ALint a, ALint b);
extern inline ALint maxi(ALint a, ALint b);
extern inline ALint clampi(ALint val, ALint min, ALint max);
extern inline ALint64 mini64(ALint64 a, ALint64 b);
extern inline ALint64 maxi64(ALint64 a, ALint64 b);
extern inline ALint64 clampi64(ALint64 val, ALint64 min, ALint64 max);
extern inline ALuint64 minu64(ALuint64 a, ALuint64 b);
extern inline ALuint64 maxu64(ALuint64 a, ALuint64 b);
extern inline ALuint64 clampu64(ALuint64 val, ALuint64 min, ALuint64 max);
extern inline ALfloat lerp(ALfloat val1, ALfloat val2, ALfloat mu);
extern inline ALfloat cubic(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat val3, ALfloat mu);
static ResamplerFunc SelectResampler(enum Resampler Resampler, ALuint increment)
{
if(increment == FRACTIONONE)
return Resample_copy32_C;
switch(Resampler)
{
case PointResampler:
return Resample_point32_C;
case LinearResampler:
return Resample_lerp32_C;
case CubicResampler:
return Resample_cubic32_C;
case ResamplerMax:
/* Shouldn't happen */
break;
}
return Resample_point32_C;
}
static DryMixerFunc SelectHrtfMixer(void)
{
#ifdef HAVE_SSE
if((CPUCapFlags&CPU_CAP_SSE))
return MixDirect_Hrtf_SSE;
#endif
#ifdef HAVE_NEON
if((CPUCapFlags&CPU_CAP_NEON))
return MixDirect_Hrtf_Neon;
#endif
return MixDirect_Hrtf_C;
}
static DryMixerFunc SelectDirectMixer(void)
{
#ifdef HAVE_SSE
if((CPUCapFlags&CPU_CAP_SSE))
return MixDirect_SSE;
#endif
#ifdef HAVE_NEON
if((CPUCapFlags&CPU_CAP_NEON))
return MixDirect_Neon;
#endif
return MixDirect_C;
}
static WetMixerFunc SelectSendMixer(void)
{
#ifdef HAVE_SSE
if((CPUCapFlags&CPU_CAP_SSE))
return MixSend_SSE;
#endif
#ifdef HAVE_NEON
if((CPUCapFlags&CPU_CAP_NEON))
return MixSend_Neon;
#endif
return MixSend_C;
}
static inline void aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
{
outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
}
static inline ALfloat aluDotproduct(const ALfloat *inVector1, const ALfloat *inVector2)
{
return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
inVector1[2]*inVector2[2];
}
static inline void aluNormalize(ALfloat *inVector)
{
ALfloat lengthsqr = aluDotproduct(inVector, inVector);
if(lengthsqr > 0.0f)
{
ALfloat inv_length = 1.0f/sqrtf(lengthsqr);
inVector[0] *= inv_length;
inVector[1] *= inv_length;
inVector[2] *= inv_length;
}
}
static inline ALvoid aluMatrixVector(ALfloat *vector, ALfloat w, ALfloat (*restrict matrix)[4])
{
ALfloat temp[4] = {
vector[0], vector[1], vector[2], w
};
vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
}
static ALvoid CalcListenerParams(ALlistener *Listener)
{
ALfloat N[3], V[3], U[3], P[3];
/* AT then UP */
N[0] = Listener->Forward[0];
N[1] = Listener->Forward[1];
N[2] = Listener->Forward[2];
aluNormalize(N);
V[0] = Listener->Up[0];
V[1] = Listener->Up[1];
V[2] = Listener->Up[2];
aluNormalize(V);
/* Build and normalize right-vector */
aluCrossproduct(N, V, U);
aluNormalize(U);
Listener->Params.Matrix[0][0] = U[0];
Listener->Params.Matrix[0][1] = V[0];
Listener->Params.Matrix[0][2] = -N[0];
Listener->Params.Matrix[0][3] = 0.0f;
Listener->Params.Matrix[1][0] = U[1];
Listener->Params.Matrix[1][1] = V[1];
Listener->Params.Matrix[1][2] = -N[1];
Listener->Params.Matrix[1][3] = 0.0f;
Listener->Params.Matrix[2][0] = U[2];
Listener->Params.Matrix[2][1] = V[2];
Listener->Params.Matrix[2][2] = -N[2];
Listener->Params.Matrix[2][3] = 0.0f;
Listener->Params.Matrix[3][0] = 0.0f;
Listener->Params.Matrix[3][1] = 0.0f;
Listener->Params.Matrix[3][2] = 0.0f;
Listener->Params.Matrix[3][3] = 1.0f;
P[0] = Listener->Position[0];
P[1] = Listener->Position[1];
P[2] = Listener->Position[2];
aluMatrixVector(P, 1.0f, Listener->Params.Matrix);
Listener->Params.Matrix[3][0] = -P[0];
Listener->Params.Matrix[3][1] = -P[1];
Listener->Params.Matrix[3][2] = -P[2];
Listener->Params.Velocity[0] = Listener->Velocity[0];
Listener->Params.Velocity[1] = Listener->Velocity[1];
Listener->Params.Velocity[2] = Listener->Velocity[2];
aluMatrixVector(Listener->Params.Velocity, 0.0f, Listener->Params.Matrix);
}
ALvoid CalcNonAttnSourceParams(ALactivesource *src, const ALCcontext *ALContext)
{
static const struct ChanMap MonoMap[1] = { { FrontCenter, 0.0f } };
static const struct ChanMap StereoMap[2] = {
{ FrontLeft, DEG2RAD(-30.0f) },
{ FrontRight, DEG2RAD( 30.0f) }
};
static const struct ChanMap StereoWideMap[2] = {
{ FrontLeft, DEG2RAD(-90.0f) },
{ FrontRight, DEG2RAD( 90.0f) }
};
static const struct ChanMap RearMap[2] = {
{ BackLeft, DEG2RAD(-150.0f) },
{ BackRight, DEG2RAD( 150.0f) }
};
static const struct ChanMap QuadMap[4] = {
{ FrontLeft, DEG2RAD( -45.0f) },
{ FrontRight, DEG2RAD( 45.0f) },
{ BackLeft, DEG2RAD(-135.0f) },
{ BackRight, DEG2RAD( 135.0f) }
};
static const struct ChanMap X51Map[6] = {
{ FrontLeft, DEG2RAD( -30.0f) },
{ FrontRight, DEG2RAD( 30.0f) },
{ FrontCenter, DEG2RAD( 0.0f) },
{ LFE, 0.0f },
{ BackLeft, DEG2RAD(-110.0f) },
{ BackRight, DEG2RAD( 110.0f) }
};
static const struct ChanMap X61Map[7] = {
{ FrontLeft, DEG2RAD(-30.0f) },
{ FrontRight, DEG2RAD( 30.0f) },
{ FrontCenter, DEG2RAD( 0.0f) },
{ LFE, 0.0f },
{ BackCenter, DEG2RAD(180.0f) },
{ SideLeft, DEG2RAD(-90.0f) },
{ SideRight, DEG2RAD( 90.0f) }
};
static const struct ChanMap X71Map[8] = {
{ FrontLeft, DEG2RAD( -30.0f) },
{ FrontRight, DEG2RAD( 30.0f) },
{ FrontCenter, DEG2RAD( 0.0f) },
{ LFE, 0.0f },
{ BackLeft, DEG2RAD(-150.0f) },
{ BackRight, DEG2RAD( 150.0f) },
{ SideLeft, DEG2RAD( -90.0f) },
{ SideRight, DEG2RAD( 90.0f) }
};
ALCdevice *Device = ALContext->Device;
ALsource *ALSource = src->Source;
ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
ALbufferlistitem *BufferListItem;
enum FmtChannels Channels;
ALfloat DryGain, DryGainHF;
ALfloat WetGain[MAX_SENDS];
ALfloat WetGainHF[MAX_SENDS];
ALint NumSends, Frequency;
const struct ChanMap *chans = NULL;
enum Resampler Resampler;
ALint num_channels = 0;
ALboolean DirectChannels;
ALfloat hwidth = 0.0f;
ALfloat Pitch;
ALint i, j, c;
/* Get device properties */
NumSends = Device->NumAuxSends;
Frequency = Device->Frequency;
/* Get listener properties */
ListenerGain = ALContext->Listener->Gain;
/* Get source properties */
SourceVolume = ALSource->Gain;
MinVolume = ALSource->MinGain;
MaxVolume = ALSource->MaxGain;
Pitch = ALSource->Pitch;
Resampler = ALSource->Resampler;
DirectChannels = ALSource->DirectChannels;
src->Direct.OutBuffer = Device->DryBuffer;
for(i = 0;i < NumSends;i++)
{
ALeffectslot *Slot = ALSource->Send[i].Slot;
if(!Slot && i == 0)
Slot = Device->DefaultSlot;
if(!Slot || Slot->EffectType == AL_EFFECT_NULL)
{
src->Send[i].OutBuffer = NULL;
src->Send[i].ClickRemoval = NULL;
src->Send[i].PendingClicks = NULL;
}
else
{
src->Send[i].OutBuffer = Slot->WetBuffer;
src->Send[i].ClickRemoval = Slot->ClickRemoval;
src->Send[i].PendingClicks = Slot->PendingClicks;
}
}
/* Calculate the stepping value */
Channels = FmtMono;
BufferListItem = ALSource->queue;
while(BufferListItem != NULL)
{
ALbuffer *ALBuffer;
if((ALBuffer=BufferListItem->buffer) != NULL)
{
Pitch = Pitch * ALBuffer->Frequency / Frequency;
if(Pitch > 10.0f)
src->Step = 10<<FRACTIONBITS;
else
{
src->Step = fastf2i(Pitch*FRACTIONONE);
if(src->Step == 0)
src->Step = 1;
}
src->Resample = SelectResampler(Resampler, src->Step);
Channels = ALBuffer->FmtChannels;
break;
}
BufferListItem = BufferListItem->next;
}
/* Calculate gains */
DryGain = clampf(SourceVolume, MinVolume, MaxVolume);
DryGain *= ALSource->DirectGain * ListenerGain;
DryGainHF = ALSource->DirectGainHF;
for(i = 0;i < NumSends;i++)
{
WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);
WetGain[i] *= ALSource->Send[i].Gain * ListenerGain;
WetGainHF[i] = ALSource->Send[i].GainHF;
}
switch(Channels)
{
case FmtMono:
chans = MonoMap;
num_channels = 1;
break;
case FmtStereo:
if(!(Device->Flags&DEVICE_WIDE_STEREO))
{
/* HACK: Place the stereo channels at +/-90 degrees when using non-
* HRTF stereo output. This helps reduce the "monoization" caused
* by them panning towards the center. */
if(Device->FmtChans == DevFmtStereo && !Device->Hrtf)
chans = StereoWideMap;
else
chans = StereoMap;
}
else
{
chans = StereoWideMap;
hwidth = DEG2RAD(60.0f);
}
num_channels = 2;
break;
case FmtRear:
chans = RearMap;
num_channels = 2;
break;
case FmtQuad:
chans = QuadMap;
num_channels = 4;
break;
case FmtX51:
chans = X51Map;
num_channels = 6;
break;
case FmtX61:
chans = X61Map;
num_channels = 7;
break;
case FmtX71:
chans = X71Map;
num_channels = 8;
break;
}
if(DirectChannels != AL_FALSE)
{
ALfloat (*Matrix)[MaxChannels] = src->Direct.Mix.Gains.Target;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(c = 0;c < MaxChannels;c++)
Matrix[i][c] = 0.0f;
}
for(c = 0;c < num_channels;c++)
{
for(i = 0;i < (ALint)Device->NumChan;i++)
{
enum Channel chan = Device->Speaker2Chan[i];
if(chan == chans[c].channel)
{
Matrix[c][chan] = DryGain;
break;
}
}
}
if(src->Direct.Moving)
{
ALfloat (*restrict Current)[MaxChannels] = src->Direct.Mix.Gains.Current;
ALfloat (*restrict Step)[MaxChannels] = src->Direct.Mix.Gains.Step;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(j = 0;j < MaxChannels;j++)
{
ALfloat cur = maxf(Current[i][j], GAIN_SILENCE_THRESHOLD);
ALfloat trg = maxf(Matrix[i][j], GAIN_SILENCE_THRESHOLD);
if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD)
Step[i][j] = powf(trg/cur, 1.0f/64.0f);
else
Step[i][j] = 1.0f;
Current[i][j] = cur;
}
}
src->Direct.Counter = 64;
}
else
{
ALfloat (*restrict Current)[MaxChannels] = src->Direct.Mix.Gains.Current;
ALfloat (*restrict Step)[MaxChannels] = src->Direct.Mix.Gains.Step;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(j = 0;j < MaxChannels;j++)
{
Current[i][j] = Matrix[i][j];
Step[i][j] = 1.0f;
}
}
src->Direct.Counter = 0;
src->Direct.Moving = AL_TRUE;
}
src->DryMix = SelectDirectMixer();
}
else if(Device->Hrtf)
{
for(c = 0;c < num_channels;c++)
{
if(chans[c].channel == LFE)
{
/* Skip LFE */
src->Direct.Mix.Hrtf.Params.Delay[c][0] = 0;
src->Direct.Mix.Hrtf.Params.Delay[c][1] = 0;
for(i = 0;i < HRIR_LENGTH;i++)
{
src->Direct.Mix.Hrtf.Params.Coeffs[c][i][0] = 0.0f;
src->Direct.Mix.Hrtf.Params.Coeffs[c][i][1] = 0.0f;
}
}
else
{
/* Get the static HRIR coefficients and delays for this
* channel. */
GetLerpedHrtfCoeffs(Device->Hrtf,
0.0f, chans[c].angle, DryGain,
src->Direct.Mix.Hrtf.Params.Coeffs[c],
src->Direct.Mix.Hrtf.Params.Delay[c]);
}
}
src->Direct.Counter = 0;
src->Direct.Moving = AL_TRUE;
src->Direct.Mix.Hrtf.Params.IrSize = GetHrtfIrSize(Device->Hrtf);
src->DryMix = SelectHrtfMixer();
}
else
{
ALfloat (*Matrix)[MaxChannels] = src->Direct.Mix.Gains.Target;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(c = 0;c < MaxChannels;c++)
Matrix[i][c] = 0.0f;
}
DryGain *= lerp(1.0f, 1.0f/sqrtf((float)Device->NumChan), hwidth/F_PI);
for(c = 0;c < num_channels;c++)
{
/* Special-case LFE */
if(chans[c].channel == LFE)
{
Matrix[c][chans[c].channel] = DryGain;
continue;
}
ComputeAngleGains(Device, chans[c].angle, hwidth, DryGain,
Matrix[c]);
}
if(src->Direct.Moving)
{
ALfloat (*restrict Current)[MaxChannels] = src->Direct.Mix.Gains.Current;
ALfloat (*restrict Step)[MaxChannels] = src->Direct.Mix.Gains.Step;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(j = 0;j < MaxChannels;j++)
{
ALfloat trg = maxf(Matrix[i][j], GAIN_SILENCE_THRESHOLD);
ALfloat cur = maxf(Current[i][j], GAIN_SILENCE_THRESHOLD);
if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD)
Step[i][j] = powf(trg/cur, 1.0f/64.0f);
else
Step[i][j] = 1.0f;
Current[i][j] = cur;
}
}
src->Direct.Counter = 64;
}
else
{
ALfloat (*restrict Current)[MaxChannels] = src->Direct.Mix.Gains.Current;
ALfloat (*restrict Step)[MaxChannels] = src->Direct.Mix.Gains.Step;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(j = 0;j < MaxChannels;j++)
{
Current[i][j] = Matrix[i][j];
Step[i][j] = 1.0f;
}
}
src->Direct.Counter = 0;
src->Direct.Moving = AL_TRUE;
}
src->DryMix = SelectDirectMixer();
}
for(i = 0;i < NumSends;i++)
src->Send[i].Gain = WetGain[i];
src->WetMix = SelectSendMixer();
{
ALfloat gain = maxf(0.01f, DryGainHF);
for(c = 0;c < num_channels;c++)
ALfilterState_setParams(&src->Direct.LpFilter[c],
ALfilterType_HighShelf, gain,
(ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
}
for(i = 0;i < NumSends;i++)
{
ALfloat gain = maxf(0.01f, WetGainHF[i]);
for(c = 0;c < num_channels;c++)
ALfilterState_setParams(&src->Send[i].LpFilter[c],
ALfilterType_HighShelf, gain,
(ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
}
}
ALvoid CalcSourceParams(ALactivesource *src, const ALCcontext *ALContext)
{
ALCdevice *Device = ALContext->Device;
ALsource *ALSource = src->Source;
ALfloat Velocity[3],Direction[3],Position[3],SourceToListener[3];
ALfloat InnerAngle,OuterAngle,Angle,Distance,ClampedDist;
ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;
ALfloat ConeVolume,ConeHF,SourceVolume,ListenerGain;
ALfloat DopplerFactor, SpeedOfSound;
ALfloat AirAbsorptionFactor;
ALfloat RoomAirAbsorption[MAX_SENDS];
ALbufferlistitem *BufferListItem;
ALfloat Attenuation;
ALfloat RoomAttenuation[MAX_SENDS];
ALfloat MetersPerUnit;
ALfloat RoomRolloffBase;
ALfloat RoomRolloff[MAX_SENDS];
ALfloat DecayDistance[MAX_SENDS];
ALfloat DryGain;
ALfloat DryGainHF;
ALboolean DryGainHFAuto;
ALfloat WetGain[MAX_SENDS];
ALfloat WetGainHF[MAX_SENDS];
ALboolean WetGainAuto;
ALboolean WetGainHFAuto;
enum Resampler Resampler;
ALfloat Pitch;
ALuint Frequency;
ALint NumSends;
ALint i, j;
DryGainHF = 1.0f;
for(i = 0;i < MAX_SENDS;i++)
WetGainHF[i] = 1.0f;
/* Get context/device properties */
DopplerFactor = ALContext->DopplerFactor * ALSource->DopplerFactor;
SpeedOfSound = ALContext->SpeedOfSound * ALContext->DopplerVelocity;
NumSends = Device->NumAuxSends;
Frequency = Device->Frequency;
/* Get listener properties */
ListenerGain = ALContext->Listener->Gain;
MetersPerUnit = ALContext->Listener->MetersPerUnit;
/* Get source properties */
SourceVolume = ALSource->Gain;
MinVolume = ALSource->MinGain;
MaxVolume = ALSource->MaxGain;
Pitch = ALSource->Pitch;
Resampler = ALSource->Resampler;
Position[0] = ALSource->Position[0];
Position[1] = ALSource->Position[1];
Position[2] = ALSource->Position[2];
Direction[0] = ALSource->Orientation[0];
Direction[1] = ALSource->Orientation[1];
Direction[2] = ALSource->Orientation[2];
Velocity[0] = ALSource->Velocity[0];
Velocity[1] = ALSource->Velocity[1];
Velocity[2] = ALSource->Velocity[2];
MinDist = ALSource->RefDistance;
MaxDist = ALSource->MaxDistance;
Rolloff = ALSource->RollOffFactor;
InnerAngle = ALSource->InnerAngle;
OuterAngle = ALSource->OuterAngle;
AirAbsorptionFactor = ALSource->AirAbsorptionFactor;
DryGainHFAuto = ALSource->DryGainHFAuto;
WetGainAuto = ALSource->WetGainAuto;
WetGainHFAuto = ALSource->WetGainHFAuto;
RoomRolloffBase = ALSource->RoomRolloffFactor;
src->Direct.OutBuffer = Device->DryBuffer;
for(i = 0;i < NumSends;i++)
{
ALeffectslot *Slot = ALSource->Send[i].Slot;
if(!Slot && i == 0)
Slot = Device->DefaultSlot;
if(!Slot || Slot->EffectType == AL_EFFECT_NULL)
{
Slot = NULL;
RoomRolloff[i] = 0.0f;
DecayDistance[i] = 0.0f;
RoomAirAbsorption[i] = 1.0f;
}
else if(Slot->AuxSendAuto)
{
RoomRolloff[i] = RoomRolloffBase;
if(IsReverbEffect(Slot->EffectType))
{
RoomRolloff[i] += Slot->EffectProps.Reverb.RoomRolloffFactor;
DecayDistance[i] = Slot->EffectProps.Reverb.DecayTime *
SPEEDOFSOUNDMETRESPERSEC;
RoomAirAbsorption[i] = Slot->EffectProps.Reverb.AirAbsorptionGainHF;
}
else
{
DecayDistance[i] = 0.0f;
RoomAirAbsorption[i] = 1.0f;
}
}
else
{
/* If the slot's auxiliary send auto is off, the data sent to the
* effect slot is the same as the dry path, sans filter effects */
RoomRolloff[i] = Rolloff;
DecayDistance[i] = 0.0f;
RoomAirAbsorption[i] = AIRABSORBGAINHF;
}
if(!Slot || Slot->EffectType == AL_EFFECT_NULL)
{
src->Send[i].OutBuffer = NULL;
src->Send[i].ClickRemoval = NULL;
src->Send[i].PendingClicks = NULL;
}
else
{
src->Send[i].OutBuffer = Slot->WetBuffer;
src->Send[i].ClickRemoval = Slot->ClickRemoval;
src->Send[i].PendingClicks = Slot->PendingClicks;
}
}
/* Transform source to listener space (convert to head relative) */
if(ALSource->HeadRelative == AL_FALSE)
{
ALfloat (*restrict Matrix)[4] = ALContext->Listener->Params.Matrix;
/* Transform source vectors */
aluMatrixVector(Position, 1.0f, Matrix);
aluMatrixVector(Direction, 0.0f, Matrix);
aluMatrixVector(Velocity, 0.0f, Matrix);
}
else
{
const ALfloat *ListenerVel = ALContext->Listener->Params.Velocity;
/* Offset the source velocity to be relative of the listener velocity */
Velocity[0] += ListenerVel[0];
Velocity[1] += ListenerVel[1];
Velocity[2] += ListenerVel[2];
}
SourceToListener[0] = -Position[0];
SourceToListener[1] = -Position[1];
SourceToListener[2] = -Position[2];
aluNormalize(SourceToListener);
aluNormalize(Direction);
/* Calculate distance attenuation */
Distance = sqrtf(aluDotproduct(Position, Position));
ClampedDist = Distance;
Attenuation = 1.0f;
for(i = 0;i < NumSends;i++)
RoomAttenuation[i] = 1.0f;
switch(ALContext->SourceDistanceModel ? ALSource->DistanceModel :
ALContext->DistanceModel)
{
case InverseDistanceClamped:
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
if(MaxDist < MinDist)
break;
/*fall-through*/
case InverseDistance:
if(MinDist > 0.0f)
{
if((MinDist + (Rolloff * (ClampedDist - MinDist))) > 0.0f)
Attenuation = MinDist / (MinDist + (Rolloff * (ClampedDist - MinDist)));
for(i = 0;i < NumSends;i++)
{
if((MinDist + (RoomRolloff[i] * (ClampedDist - MinDist))) > 0.0f)
RoomAttenuation[i] = MinDist / (MinDist + (RoomRolloff[i] * (ClampedDist - MinDist)));
}
}
break;
case LinearDistanceClamped:
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
if(MaxDist < MinDist)
break;
/*fall-through*/
case LinearDistance:
if(MaxDist != MinDist)
{
Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));
Attenuation = maxf(Attenuation, 0.0f);
for(i = 0;i < NumSends;i++)
{
RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));
RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);
}
}
break;
case ExponentDistanceClamped:
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
if(MaxDist < MinDist)
break;
/*fall-through*/
case ExponentDistance:
if(ClampedDist > 0.0f && MinDist > 0.0f)
{
Attenuation = powf(ClampedDist/MinDist, -Rolloff);
for(i = 0;i < NumSends;i++)
RoomAttenuation[i] = powf(ClampedDist/MinDist, -RoomRolloff[i]);
}
break;
case DisableDistance:
ClampedDist = MinDist;
break;
}
/* Source Gain + Attenuation */
DryGain = SourceVolume * Attenuation;
for(i = 0;i < NumSends;i++)
WetGain[i] = SourceVolume * RoomAttenuation[i];
/* Distance-based air absorption */
if(AirAbsorptionFactor > 0.0f && ClampedDist > MinDist)
{
ALfloat meters = maxf(ClampedDist-MinDist, 0.0f) * MetersPerUnit;
DryGainHF *= powf(AIRABSORBGAINHF, AirAbsorptionFactor*meters);
for(i = 0;i < NumSends;i++)
WetGainHF[i] *= powf(RoomAirAbsorption[i], AirAbsorptionFactor*meters);
}
if(WetGainAuto)
{
ALfloat ApparentDist = 1.0f/maxf(Attenuation, 0.00001f) - 1.0f;
/* Apply a decay-time transformation to the wet path, based on the
* attenuation of the dry path.
*
* Using the apparent distance, based on the distance attenuation, the
* initial decay of the reverb effect is calculated and applied to the
* wet path.
*/
for(i = 0;i < NumSends;i++)
{
if(DecayDistance[i] > 0.0f)
WetGain[i] *= powf(0.001f/*-60dB*/, ApparentDist/DecayDistance[i]);
}
}
/* Calculate directional soundcones */
Angle = RAD2DEG(acosf(aluDotproduct(Direction,SourceToListener)) * ConeScale) * 2.0f;
if(Angle > InnerAngle && Angle <= OuterAngle)
{
ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
ConeVolume = lerp(1.0f, ALSource->OuterGain, scale);
ConeHF = lerp(1.0f, ALSource->OuterGainHF, scale);
}
else if(Angle > OuterAngle)
{
ConeVolume = ALSource->OuterGain;
ConeHF = ALSource->OuterGainHF;
}
else
{
ConeVolume = 1.0f;
ConeHF = 1.0f;
}
DryGain *= ConeVolume;
if(WetGainAuto)
{
for(i = 0;i < NumSends;i++)
WetGain[i] *= ConeVolume;
}
if(DryGainHFAuto)
DryGainHF *= ConeHF;
if(WetGainHFAuto)
{
for(i = 0;i < NumSends;i++)
WetGainHF[i] *= ConeHF;
}
/* Clamp to Min/Max Gain */
DryGain = clampf(DryGain, MinVolume, MaxVolume);
for(i = 0;i < NumSends;i++)
WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);
/* Apply gain and frequency filters */
DryGain *= ALSource->DirectGain * ListenerGain;
DryGainHF *= ALSource->DirectGainHF;
for(i = 0;i < NumSends;i++)
{
WetGain[i] *= ALSource->Send[i].Gain * ListenerGain;
WetGainHF[i] *= ALSource->Send[i].GainHF;
}
/* Calculate velocity-based doppler effect */
if(DopplerFactor > 0.0f)
{
const ALfloat *ListenerVel = ALContext->Listener->Params.Velocity;
ALfloat VSS, VLS;
if(SpeedOfSound < 1.0f)
{
DopplerFactor *= 1.0f/SpeedOfSound;
SpeedOfSound = 1.0f;
}
VSS = aluDotproduct(Velocity, SourceToListener) * DopplerFactor;
VLS = aluDotproduct(ListenerVel, SourceToListener) * DopplerFactor;
Pitch *= clampf(SpeedOfSound-VLS, 1.0f, SpeedOfSound*2.0f - 1.0f) /
clampf(SpeedOfSound-VSS, 1.0f, SpeedOfSound*2.0f - 1.0f);
}
BufferListItem = ALSource->queue;
while(BufferListItem != NULL)
{
ALbuffer *ALBuffer;
if((ALBuffer=BufferListItem->buffer) != NULL)
{
/* Calculate fixed-point stepping value, based on the pitch, buffer
* frequency, and output frequency. */
Pitch = Pitch * ALBuffer->Frequency / Frequency;
if(Pitch > 10.0f)
src->Step = 10<<FRACTIONBITS;
else
{
src->Step = fastf2i(Pitch*FRACTIONONE);
if(src->Step == 0)
src->Step = 1;
}
src->Resample = SelectResampler(Resampler, src->Step);
break;
}
BufferListItem = BufferListItem->next;
}
if(Device->Hrtf)
{
/* Use a binaural HRTF algorithm for stereo headphone playback */
ALfloat delta, ev = 0.0f, az = 0.0f;
if(Distance > FLT_EPSILON)
{
ALfloat invlen = 1.0f/Distance;
Position[0] *= invlen;
Position[1] *= invlen;
Position[2] *= invlen;
/* Calculate elevation and azimuth only when the source is not at
* the listener. This prevents +0 and -0 Z from producing
* inconsistent panning. Also, clamp Y in case FP precision errors
* cause it to land outside of -1..+1. */
ev = asinf(clampf(Position[1], -1.0f, 1.0f));
az = atan2f(Position[0], -Position[2]*ZScale);
}
/* Check to see if the HRIR is already moving. */
if(src->Direct.Moving)
{
/* Calculate the normalized HRTF transition factor (delta). */
delta = CalcHrtfDelta(src->Direct.Mix.Hrtf.Params.Gain, DryGain,
src->Direct.Mix.Hrtf.Params.Dir, Position);
/* If the delta is large enough, get the moving HRIR target
* coefficients, target delays, steppping values, and counter. */
if(delta > 0.001f)
{
ALuint counter = GetMovingHrtfCoeffs(Device->Hrtf,
ev, az, DryGain, delta,
src->Direct.Counter,
src->Direct.Mix.Hrtf.Params.Coeffs[0],
src->Direct.Mix.Hrtf.Params.Delay[0],
src->Direct.Mix.Hrtf.Params.CoeffStep,
src->Direct.Mix.Hrtf.Params.DelayStep);
src->Direct.Counter = counter;
src->Direct.Mix.Hrtf.Params.Gain = DryGain;
src->Direct.Mix.Hrtf.Params.Dir[0] = Position[0];
src->Direct.Mix.Hrtf.Params.Dir[1] = Position[1];
src->Direct.Mix.Hrtf.Params.Dir[2] = Position[2];
}
}
else
{
/* Get the initial (static) HRIR coefficients and delays. */
GetLerpedHrtfCoeffs(Device->Hrtf, ev, az, DryGain,
src->Direct.Mix.Hrtf.Params.Coeffs[0],
src->Direct.Mix.Hrtf.Params.Delay[0]);
src->Direct.Counter = 0;
src->Direct.Moving = AL_TRUE;
src->Direct.Mix.Hrtf.Params.Gain = DryGain;
src->Direct.Mix.Hrtf.Params.Dir[0] = Position[0];
src->Direct.Mix.Hrtf.Params.Dir[1] = Position[1];
src->Direct.Mix.Hrtf.Params.Dir[2] = Position[2];
}
src->Direct.Mix.Hrtf.Params.IrSize = GetHrtfIrSize(Device->Hrtf);
src->DryMix = SelectHrtfMixer();
}
else
{
ALfloat (*Matrix)[MaxChannels] = src->Direct.Mix.Gains.Target;
ALfloat DirGain = 0.0f;
ALfloat AmbientGain;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(j = 0;j < MaxChannels;j++)
Matrix[i][j] = 0.0f;
}
/* Normalize the length, and compute panned gains. */
if(Distance > FLT_EPSILON)
{
ALfloat invlen = 1.0f/Distance;
Position[0] *= invlen;
Position[1] *= invlen;
Position[2] *= invlen;
DirGain = sqrtf(Position[0]*Position[0] + Position[2]*Position[2]);
ComputeAngleGains(Device, atan2f(Position[0], -Position[2]*ZScale), 0.0f,
DryGain*DirGain, Matrix[0]);
}
/* Adjustment for vertical offsets. Not the greatest, but simple
* enough. */
AmbientGain = DryGain * sqrtf(1.0f/Device->NumChan) * (1.0f-DirGain);
for(i = 0;i < (ALint)Device->NumChan;i++)
{
enum Channel chan = Device->Speaker2Chan[i];
Matrix[0][chan] = maxf(Matrix[0][chan], AmbientGain);
}
if(src->Direct.Moving)
{
ALfloat (*restrict Current)[MaxChannels] = src->Direct.Mix.Gains.Current;
ALfloat (*restrict Step)[MaxChannels] = src->Direct.Mix.Gains.Step;
for(j = 0;j < MaxChannels;j++)
{
ALfloat cur = maxf(Current[0][j], GAIN_SILENCE_THRESHOLD);
ALfloat trg = maxf(Matrix[0][j], GAIN_SILENCE_THRESHOLD);
if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD)
Step[0][j] = powf(trg/cur, 1.0f/64.0f);
else
Step[0][j] = 1.0f;
Current[0][j] = cur;
}
src->Direct.Counter = 64;
}
else
{
ALfloat (*restrict Current)[MaxChannels] = src->Direct.Mix.Gains.Current;
ALfloat (*restrict Step)[MaxChannels] = src->Direct.Mix.Gains.Step;
for(i = 0;i < MAX_INPUT_CHANNELS;i++)
{
for(j = 0;j < MaxChannels;j++)
{
Current[i][j] = Matrix[i][j];
Step[i][j] = 1.0f;
}
}
src->Direct.Counter = 0;
src->Direct.Moving = AL_TRUE;
}
src->DryMix = SelectDirectMixer();
}
for(i = 0;i < NumSends;i++)
src->Send[i].Gain = WetGain[i];
src->WetMix = SelectSendMixer();
{
ALfloat gain = maxf(0.01f, DryGainHF);
ALfilterState_setParams(&src->Direct.LpFilter[0],
ALfilterType_HighShelf, gain,
(ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
}
for(i = 0;i < NumSends;i++)
{
ALfloat gain = maxf(0.01f, WetGainHF[i]);
ALfilterState_setParams(&src->Send[i].LpFilter[0],
ALfilterType_HighShelf, gain,
(ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
}
}
static inline ALint aluF2I25(ALfloat val)
{
/* Clamp the value between -1 and +1. This handles that with only a single branch. */
if(fabsf(val) > 1.0f)
val = (ALfloat)((0.0f < val) - (val < 0.0f));
/* Convert to a signed integer, between -16777215 and +16777215. */
return fastf2i(val*16777215.0f);
}
static inline ALfloat aluF2F(ALfloat val)
{ return val; }
static inline ALint aluF2I(ALfloat val)
{ return aluF2I25(val)<<7; }
static inline ALuint aluF2UI(ALfloat val)
{ return aluF2I(val)+2147483648u; }
static inline ALshort aluF2S(ALfloat val)
{ return aluF2I25(val)>>9; }
static inline ALushort aluF2US(ALfloat val)
{ return aluF2S(val)+32768; }
static inline ALbyte aluF2B(ALfloat val)
{ return aluF2I25(val)>>17; }
static inline ALubyte aluF2UB(ALfloat val)
{ return aluF2B(val)+128; }
#define DECL_TEMPLATE(T, func) \
static int Write_##T(ALCdevice *device, T *restrict buffer, \
ALuint SamplesToDo) \
{ \
ALfloat (*restrict DryBuffer)[BUFFERSIZE] = device->DryBuffer; \
ALuint numchans = ChannelsFromDevFmt(device->FmtChans); \
const ALuint *offsets = device->ChannelOffsets; \
ALuint i, j; \
\
for(j = 0;j < MaxChannels;j++) \
{ \
T *restrict out; \
\
if(offsets[j] == INVALID_OFFSET) \
continue; \
\
out = buffer + offsets[j]; \
for(i = 0;i < SamplesToDo;i++) \
out[i*numchans] = func(DryBuffer[j][i]); \
} \
return SamplesToDo*numchans*sizeof(T); \
}
DECL_TEMPLATE(ALfloat, aluF2F)
DECL_TEMPLATE(ALuint, aluF2UI)
DECL_TEMPLATE(ALint, aluF2I)
DECL_TEMPLATE(ALushort, aluF2US)
DECL_TEMPLATE(ALshort, aluF2S)
DECL_TEMPLATE(ALubyte, aluF2UB)
DECL_TEMPLATE(ALbyte, aluF2B)
#undef DECL_TEMPLATE
ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
{
ALuint SamplesToDo;
ALeffectslot **slot, **slot_end;
ALactivesource **src, **src_end;
ALCcontext *ctx;
FPUCtl oldMode;
ALuint i, c;
SetMixerFPUMode(&oldMode);
while(size > 0)
{
IncrementRef(&device->MixCount);
SamplesToDo = minu(size, BUFFERSIZE);
for(c = 0;c < MaxChannels;c++)
memset(device->DryBuffer[c], 0, SamplesToDo*sizeof(ALfloat));
ALCdevice_Lock(device);
V(device->Synth,process)(SamplesToDo, device->DryBuffer);
ctx = device->ContextList;
while(ctx)
{
ALenum DeferUpdates = ctx->DeferUpdates;
ALenum UpdateSources = AL_FALSE;
if(!DeferUpdates)
UpdateSources = ExchangeInt(&ctx->UpdateSources, AL_FALSE);
if(UpdateSources)
CalcListenerParams(ctx->Listener);
/* source processing */
src = ctx->ActiveSources;
src_end = src + ctx->ActiveSourceCount;
while(src != src_end)
{
ALsource *source = (*src)->Source;
if(source->state != AL_PLAYING && source->state != AL_PAUSED)
{
ALactivesource *temp = *(--src_end);
*src_end = *src;
*src = temp;
--(ctx->ActiveSourceCount);
continue;
}
if(!DeferUpdates && (ExchangeInt(&source->NeedsUpdate, AL_FALSE) ||
UpdateSources))
(*src)->Update(*src, ctx);
if(source->state != AL_PAUSED)
MixSource(*src, device, SamplesToDo);
src++;
}
/* effect slot processing */
slot = VECTOR_ITER_BEGIN(ctx->ActiveAuxSlots);
slot_end = VECTOR_ITER_END(ctx->ActiveAuxSlots);
while(slot != slot_end)
{
ALfloat offset = (*slot)->ClickRemoval[0];
if(offset < (1.0f/32768.0f))
offset = 0.0f;
else for(i = 0;i < SamplesToDo;i++)
{
(*slot)->WetBuffer[0][i] += offset;
offset -= offset * (1.0f/256.0f);
}
(*slot)->ClickRemoval[0] = offset + (*slot)->PendingClicks[0];
(*slot)->PendingClicks[0] = 0.0f;
if(!DeferUpdates && ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
V((*slot)->EffectState,update)(device, *slot);
V((*slot)->EffectState,process)(SamplesToDo, (*slot)->WetBuffer[0],
device->DryBuffer);
for(i = 0;i < SamplesToDo;i++)
(*slot)->WetBuffer[0][i] = 0.0f;
slot++;
}
ctx = ctx->next;
}
slot = &device->DefaultSlot;
if(*slot != NULL)
{
ALfloat offset = (*slot)->ClickRemoval[0];
if(offset < (1.0f/32768.0f))
offset = 0.0f;
else for(i = 0;i < SamplesToDo;i++)
{
(*slot)->WetBuffer[0][i] += offset;
offset -= offset * (1.0f/256.0f);
}
(*slot)->ClickRemoval[0] = offset + (*slot)->PendingClicks[0];
(*slot)->PendingClicks[0] = 0.0f;
if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
V((*slot)->EffectState,update)(device, *slot);
V((*slot)->EffectState,process)(SamplesToDo, (*slot)->WetBuffer[0],
device->DryBuffer);
for(i = 0;i < SamplesToDo;i++)
(*slot)->WetBuffer[0][i] = 0.0f;
}
/* Increment the clock time. Every second's worth of samples is
* converted and added to clock base so that large sample counts don't
* overflow during conversion. This also guarantees an exact, stable
* conversion. */
device->SamplesDone += SamplesToDo;
device->ClockBase += (device->SamplesDone/device->Frequency) * DEVICE_CLOCK_RES;
device->SamplesDone %= device->Frequency;
ALCdevice_Unlock(device);
if(device->Bs2b)
{
/* Apply binaural/crossfeed filter */
for(i = 0;i < SamplesToDo;i++)
{
float samples[2];
samples[0] = device->DryBuffer[FrontLeft][i];
samples[1] = device->DryBuffer[FrontRight][i];
bs2b_cross_feed(device->Bs2b, samples);
device->DryBuffer[FrontLeft][i] = samples[0];
device->DryBuffer[FrontRight][i] = samples[1];
}
}
if(buffer)
{
int bytes = 0;
switch(device->FmtType)
{
case DevFmtByte:
bytes = Write_ALbyte(device, buffer, SamplesToDo);
break;
case DevFmtUByte:
bytes = Write_ALubyte(device, buffer, SamplesToDo);
break;
case DevFmtShort:
bytes = Write_ALshort(device, buffer, SamplesToDo);
break;
case DevFmtUShort:
bytes = Write_ALushort(device, buffer, SamplesToDo);
break;
case DevFmtInt:
bytes = Write_ALint(device, buffer, SamplesToDo);
break;
case DevFmtUInt:
bytes = Write_ALuint(device, buffer, SamplesToDo);
break;
case DevFmtFloat:
bytes = Write_ALfloat(device, buffer, SamplesToDo);
break;
}
buffer = (ALubyte*)buffer + bytes;
}
size -= SamplesToDo;
IncrementRef(&device->MixCount);
}
RestoreFPUMode(&oldMode);
}
ALvoid aluHandleDisconnect(ALCdevice *device)
{
ALCcontext *Context;
device->Connected = ALC_FALSE;
Context = device->ContextList;
while(Context)
{
ALactivesource **src, **src_end;
src = Context->ActiveSources;
src_end = src + Context->ActiveSourceCount;
while(src != src_end)
{
ALsource *source = (*src)->Source;
if(source->state == AL_PLAYING)
{
source->state = AL_STOPPED;
source->BuffersPlayed = source->BuffersInQueue;
source->position = 0;
source->position_fraction = 0;
}
src++;
}
Context->ActiveSourceCount = 0;
Context = Context->next;
}
}
Reference in New Issue View Git Blame Copy Permalink