/** * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * Or go to http://www.gnu.org/copyleft/lgpl.html */ #include "config.h" #include #include #include #include #include #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 "static_assert.h" #include "midi/base.h" static_assert((INT_MAX>>FRACTIONBITS)/MAX_PITCH > BUFFERSIZE, "MAX_PITCH and/or BUFFERSIZE are too large for FRACTIONBITS!"); 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 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 ALsource *ALSource, 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; ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume; ALbufferlistitem *BufferListItem; enum FmtChannels Channels; ALfloat DryGain, DryGainHF, DryGainLF; ALfloat WetGain[MAX_SENDS]; ALfloat WetGainHF[MAX_SENDS]; ALfloat WetGainLF[MAX_SENDS]; ALint NumSends, Frequency; const struct ChanMap *chans = NULL; 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; 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; else src->Send[i].OutBuffer = Slot->WetBuffer; } /* Calculate the stepping value */ Channels = FmtMono; BufferListItem = ATOMIC_LOAD(&ALSource->queue); while(BufferListItem != NULL) { ALbuffer *ALBuffer; if((ALBuffer=BufferListItem->buffer) != NULL) { Pitch = Pitch * ALBuffer->Frequency / Frequency; if(Pitch > (ALfloat)MAX_PITCH) src->Step = MAX_PITCH<Step = fastf2i(Pitch*FRACTIONONE); if(src->Step == 0) src->Step = 1; } Channels = ALBuffer->FmtChannels; break; } BufferListItem = BufferListItem->next; } /* Calculate gains */ DryGain = clampf(SourceVolume, MinVolume, MaxVolume); DryGain *= ALSource->Direct.Gain * ListenerGain; DryGainHF = ALSource->Direct.GainHF; DryGainLF = ALSource->Direct.GainLF; 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; WetGainLF[i] = ALSource->Send[i].GainLF; } 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) { for(c = 0;c < num_channels;c++) { MixGains *gains = src->Direct.Mix.Gains[c]; for(j = 0;j < MaxChannels;j++) gains[j].Target = 0.0f; } for(c = 0;c < num_channels;c++) { MixGains *gains = src->Direct.Mix.Gains[c]; for(i = 0;i < (ALint)Device->NumChan;i++) { enum Channel chan = Device->Speaker2Chan[i]; if(chan == chans[c].channel) { gains[chan].Target = DryGain; break; } } } if(!src->Direct.Moving) { for(i = 0;i < num_channels;i++) { MixGains *gains = src->Direct.Mix.Gains[i]; for(j = 0;j < MaxChannels;j++) { gains[j].Current = gains[j].Target; gains[j].Step = 1.0f; } } src->Direct.Counter = 0; src->Direct.Moving = AL_TRUE; } else { for(i = 0;i < num_channels;i++) { MixGains *gains = src->Direct.Mix.Gains[i]; for(j = 0;j < MaxChannels;j++) { ALfloat cur = maxf(gains[j].Current, FLT_EPSILON); ALfloat trg = maxf(gains[j].Target, FLT_EPSILON); if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD) gains[j].Step = powf(trg/cur, 1.0f/64.0f); else gains[j].Step = 1.0f; gains[j].Current = cur; } } src->Direct.Counter = 64; } src->IsHrtf = AL_FALSE; } else if(Device->Hrtf) { for(c = 0;c < num_channels;c++) { if(chans[c].channel == LFE) { /* Skip LFE */ src->Direct.Mix.Hrtf.Params[c].Delay[0] = 0; src->Direct.Mix.Hrtf.Params[c].Delay[1] = 0; for(i = 0;i < HRIR_LENGTH;i++) { src->Direct.Mix.Hrtf.Params[c].Coeffs[i][0] = 0.0f; src->Direct.Mix.Hrtf.Params[c].Coeffs[i][1] = 0.0f; } } else { /* Get the static HRIR coefficients and delays for this * channel. */ GetLerpedHrtfCoeffs(Device->Hrtf, 0.0f, chans[c].angle, 1.0f, DryGain, src->Direct.Mix.Hrtf.Params[c].Coeffs, src->Direct.Mix.Hrtf.Params[c].Delay); } } src->Direct.Counter = 0; src->Direct.Moving = AL_TRUE; src->Direct.Mix.Hrtf.IrSize = GetHrtfIrSize(Device->Hrtf); src->IsHrtf = AL_TRUE; } else { for(i = 0;i < num_channels;i++) { MixGains *gains = src->Direct.Mix.Gains[i]; for(j = 0;j < MaxChannels;j++) gains[j].Target = 0.0f; } DryGain *= lerp(1.0f, 1.0f/sqrtf((float)Device->NumChan), hwidth/F_PI); for(c = 0;c < num_channels;c++) { MixGains *gains = src->Direct.Mix.Gains[c]; ALfloat Target[MaxChannels]; /* Special-case LFE */ if(chans[c].channel == LFE) { gains[chans[c].channel].Target = DryGain; continue; } ComputeAngleGains(Device, chans[c].angle, hwidth, DryGain, Target); for(i = 0;i < MaxChannels;i++) gains[i].Target = Target[i]; } if(!src->Direct.Moving) { for(i = 0;i < num_channels;i++) { MixGains *gains = src->Direct.Mix.Gains[i]; for(j = 0;j < MaxChannels;j++) { gains[j].Current = gains[j].Target; gains[j].Step = 1.0f; } } src->Direct.Counter = 0; src->Direct.Moving = AL_TRUE; } else { for(i = 0;i < num_channels;i++) { MixGains *gains = src->Direct.Mix.Gains[i]; for(j = 0;j < MaxChannels;j++) { ALfloat trg = maxf(gains[j].Target, FLT_EPSILON); ALfloat cur = maxf(gains[j].Current, FLT_EPSILON); if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD) gains[j].Step = powf(trg/cur, 1.0f/64.0f); else gains[j].Step = 1.0f; gains[j].Current = cur; } } src->Direct.Counter = 64; } src->IsHrtf = AL_FALSE; } for(i = 0;i < NumSends;i++) { src->Send[i].Gain.Target = WetGain[i]; if(!src->Send[i].Moving) { src->Send[i].Gain.Current = src->Send[i].Gain.Target; src->Send[i].Gain.Step = 1.0f; src->Send[i].Counter = 0; src->Send[i].Moving = AL_TRUE; } else { ALfloat cur = maxf(src->Send[i].Gain.Current, FLT_EPSILON); ALfloat trg = maxf(src->Send[i].Gain.Target, FLT_EPSILON); if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD) src->Send[i].Gain.Step = powf(trg/cur, 1.0f/64.0f); else src->Send[i].Gain.Step = 1.0f; src->Send[i].Gain.Current = cur; src->Send[i].Counter = 64; } } { ALfloat gainhf = maxf(0.01f, DryGainHF); ALfloat gainlf = maxf(0.01f, DryGainLF); ALfloat hfscale = ALSource->Direct.HFReference / Frequency; ALfloat lfscale = ALSource->Direct.LFReference / Frequency; for(c = 0;c < num_channels;c++) { src->Direct.Filters[c].ActiveType = AF_None; if(gainhf != 1.0f) src->Direct.Filters[c].ActiveType |= AF_LowPass; if(gainlf != 1.0f) src->Direct.Filters[c].ActiveType |= AF_HighPass; ALfilterState_setParams( &src->Direct.Filters[c].LowPass, ALfilterType_HighShelf, gainhf, hfscale, 0.0f ); ALfilterState_setParams( &src->Direct.Filters[c].HighPass, ALfilterType_LowShelf, gainlf, lfscale, 0.0f ); } } for(i = 0;i < NumSends;i++) { ALfloat gainhf = maxf(0.01f, WetGainHF[i]); ALfloat gainlf = maxf(0.01f, WetGainLF[i]); ALfloat hfscale = ALSource->Send[i].HFReference / Frequency; ALfloat lfscale = ALSource->Send[i].LFReference / Frequency; for(c = 0;c < num_channels;c++) { src->Send[i].Filters[c].ActiveType = AF_None; if(gainhf != 1.0f) src->Send[i].Filters[c].ActiveType |= AF_LowPass; if(gainlf != 1.0f) src->Send[i].Filters[c].ActiveType |= AF_HighPass; ALfilterState_setParams( &src->Send[i].Filters[c].LowPass, ALfilterType_HighShelf, gainhf, hfscale, 0.0f ); ALfilterState_setParams( &src->Send[i].Filters[c].HighPass, ALfilterType_LowShelf, gainlf, lfscale, 0.0f ); } } } ALvoid CalcSourceParams(ALactivesource *src, const ALsource *ALSource, const ALCcontext *ALContext) { ALCdevice *Device = ALContext->Device; 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; ALfloat DryGainLF; ALboolean DryGainHFAuto; ALfloat WetGain[MAX_SENDS]; ALfloat WetGainHF[MAX_SENDS]; ALfloat WetGainLF[MAX_SENDS]; ALboolean WetGainAuto; ALboolean WetGainHFAuto; ALfloat Pitch; ALuint Frequency; ALint NumSends; ALint i, j; DryGainHF = 1.0f; DryGainLF = 1.0f; for(i = 0;i < MAX_SENDS;i++) { WetGainHF[i] = 1.0f; WetGainLF[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; 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; else src->Send[i].OutBuffer = Slot->WetBuffer; } /* 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->Direct.Gain * ListenerGain; DryGainHF *= ALSource->Direct.GainHF; DryGainLF *= ALSource->Direct.GainLF; for(i = 0;i < NumSends;i++) { WetGain[i] *= ALSource->Send[i].Gain * ListenerGain; WetGainHF[i] *= ALSource->Send[i].GainHF; WetGainLF[i] *= ALSource->Send[i].GainLF; } /* 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 = ATOMIC_LOAD(&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 > (ALfloat)MAX_PITCH) src->Step = MAX_PITCH<Step = fastf2i(Pitch*FRACTIONONE); if(src->Step == 0) src->Step = 1; } break; } BufferListItem = BufferListItem->next; } if(Device->Hrtf) { /* Use a binaural HRTF algorithm for stereo headphone playback */ ALfloat delta, ev = 0.0f, az = 0.0f; ALfloat radius = ALSource->Radius; ALfloat dirfact = 1.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); } if(radius > Distance) dirfact *= Distance / radius; /* 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.Gain, DryGain, src->Direct.Mix.Hrtf.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, dirfact, DryGain, delta, src->Direct.Counter, src->Direct.Mix.Hrtf.Params[0].Coeffs, src->Direct.Mix.Hrtf.Params[0].Delay, src->Direct.Mix.Hrtf.Params[0].CoeffStep, src->Direct.Mix.Hrtf.Params[0].DelayStep ); src->Direct.Counter = counter; src->Direct.Mix.Hrtf.Gain = DryGain; src->Direct.Mix.Hrtf.Dir[0] = Position[0]; src->Direct.Mix.Hrtf.Dir[1] = Position[1]; src->Direct.Mix.Hrtf.Dir[2] = Position[2]; } } else { /* Get the initial (static) HRIR coefficients and delays. */ GetLerpedHrtfCoeffs(Device->Hrtf, ev, az, dirfact, DryGain, src->Direct.Mix.Hrtf.Params[0].Coeffs, src->Direct.Mix.Hrtf.Params[0].Delay); src->Direct.Counter = 0; src->Direct.Moving = AL_TRUE; src->Direct.Mix.Hrtf.Gain = DryGain; src->Direct.Mix.Hrtf.Dir[0] = Position[0]; src->Direct.Mix.Hrtf.Dir[1] = Position[1]; src->Direct.Mix.Hrtf.Dir[2] = Position[2]; } src->Direct.Mix.Hrtf.IrSize = GetHrtfIrSize(Device->Hrtf); src->IsHrtf = AL_TRUE; } else { MixGains *gains = src->Direct.Mix.Gains[0]; ALfloat DirGain = 0.0f; ALfloat AmbientGain; for(j = 0;j < MaxChannels;j++) gains[j].Target = 0.0f; /* Normalize the length, and compute panned gains. */ if(Distance > FLT_EPSILON) { ALfloat radius = ALSource->Radius; ALfloat Target[MaxChannels]; ALfloat invlen = 1.0f/maxf(Distance, radius); 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, Target); for(j = 0;j < MaxChannels;j++) gains[j].Target = Target[j]; } /* 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]; gains[chan].Target = maxf(gains[chan].Target, AmbientGain); } if(!src->Direct.Moving) { for(j = 0;j < MaxChannels;j++) { gains[j].Current = gains[j].Target; gains[j].Step = 1.0f; } src->Direct.Counter = 0; src->Direct.Moving = AL_TRUE; } else { for(j = 0;j < MaxChannels;j++) { ALfloat cur = maxf(gains[j].Current, FLT_EPSILON); ALfloat trg = maxf(gains[j].Target, FLT_EPSILON); if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD) gains[j].Step = powf(trg/cur, 1.0f/64.0f); else gains[j].Step = 1.0f; gains[j].Current = cur; } src->Direct.Counter = 64; } src->IsHrtf = AL_FALSE; } for(i = 0;i < NumSends;i++) { src->Send[i].Gain.Target = WetGain[i]; if(!src->Send[i].Moving) { src->Send[i].Gain.Current = src->Send[i].Gain.Target; src->Send[i].Gain.Step = 1.0f; src->Send[i].Counter = 0; src->Send[i].Moving = AL_TRUE; } else { ALfloat cur = maxf(src->Send[i].Gain.Current, FLT_EPSILON); ALfloat trg = maxf(src->Send[i].Gain.Target, FLT_EPSILON); if(fabs(trg - cur) >= GAIN_SILENCE_THRESHOLD) src->Send[i].Gain.Step = powf(trg/cur, 1.0f/64.0f); else src->Send[i].Gain.Step = 1.0f; src->Send[i].Gain.Current = cur; src->Send[i].Counter = 64; } } { ALfloat gainhf = maxf(0.01f, DryGainHF); ALfloat gainlf = maxf(0.01f, DryGainLF); ALfloat hfscale = ALSource->Direct.HFReference / Frequency; ALfloat lfscale = ALSource->Direct.LFReference / Frequency; src->Direct.Filters[0].ActiveType = AF_None; if(gainhf != 1.0f) src->Direct.Filters[0].ActiveType |= AF_LowPass; if(gainlf != 1.0f) src->Direct.Filters[0].ActiveType |= AF_HighPass; ALfilterState_setParams( &src->Direct.Filters[0].LowPass, ALfilterType_HighShelf, gainhf, hfscale, 0.0f ); ALfilterState_setParams( &src->Direct.Filters[0].HighPass, ALfilterType_LowShelf, gainlf, lfscale, 0.0f ); } for(i = 0;i < NumSends;i++) { ALfloat gainhf = maxf(0.01f, WetGainHF[i]); ALfloat gainlf = maxf(0.01f, WetGainLF[i]); ALfloat hfscale = ALSource->Send[i].HFReference / Frequency; ALfloat lfscale = ALSource->Send[i].LFReference / Frequency; src->Send[i].Filters[0].ActiveType = AF_None; if(gainhf != 1.0f) src->Send[i].Filters[0].ActiveType |= AF_LowPass; if(gainlf != 1.0f) src->Send[i].Filters[0].ActiveType |= AF_HighPass; ALfilterState_setParams( &src->Send[i].Filters[0].LowPass, ALfilterType_HighShelf, gainhf, hfscale, 0.0f ); ALfilterState_setParams( &src->Send[i].Filters[0].HighPass, ALfilterType_LowShelf, gainlf, lfscale, 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 void Write_##T(ALCdevice *device, ALvoid **buffer, ALuint SamplesToDo) \ { \ ALfloat (*restrict DryBuffer)[BUFFERSIZE] = device->DryBuffer; \ const 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 = (T*)(*buffer) + offsets[j]; \ for(i = 0;i < SamplesToDo;i++) \ out[i*numchans] = func(DryBuffer[j][i]); \ } \ *buffer = (char*)(*buffer) + 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 = ATOMIC_LOAD(&device->ContextList); while(ctx) { ALenum DeferUpdates = ctx->DeferUpdates; ALenum UpdateSources = AL_FALSE; if(!DeferUpdates) UpdateSources = ATOMIC_EXCHANGE(ALenum, &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) goto next; if(source->state != AL_PLAYING && source->state != AL_PAUSED) { src->Source = NULL; goto next; } if(!DeferUpdates && (ATOMIC_EXCHANGE(ALenum, &source->NeedsUpdate, AL_FALSE) || UpdateSources)) src->Update(src, source, ctx); if(source->state != AL_PAUSED) MixSource(src, source, device, SamplesToDo); next: src++; } /* effect slot processing */ slot = VECTOR_ITER_BEGIN(ctx->ActiveAuxSlots); slot_end = VECTOR_ITER_END(ctx->ActiveAuxSlots); while(slot != slot_end) { if(!DeferUpdates && ATOMIC_EXCHANGE(ALenum, &(*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) { if(ATOMIC_EXCHANGE(ALenum, &(*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) { switch(device->FmtType) { case DevFmtByte: Write_ALbyte(device, &buffer, SamplesToDo); break; case DevFmtUByte: Write_ALubyte(device, &buffer, SamplesToDo); break; case DevFmtShort: Write_ALshort(device, &buffer, SamplesToDo); break; case DevFmtUShort: Write_ALushort(device, &buffer, SamplesToDo); break; case DevFmtInt: Write_ALint(device, &buffer, SamplesToDo); break; case DevFmtUInt: Write_ALuint(device, &buffer, SamplesToDo); break; case DevFmtFloat: Write_ALfloat(device, &buffer, SamplesToDo); break; } } size -= SamplesToDo; IncrementRef(&device->MixCount); } RestoreFPUMode(&oldMode); } ALvoid aluHandleDisconnect(ALCdevice *device) { ALCcontext *Context; device->Connected = ALC_FALSE; Context = ATOMIC_LOAD(&device->ContextList); while(Context) { ALactivesource *src, *src_end; src = Context->ActiveSources; src_end = src + Context->ActiveSourceCount; while(src != src_end) { ALsource *source = src->Source; src->Source = NULL; if(source && source->state == AL_PLAYING) { source->state = AL_STOPPED; ATOMIC_STORE(&source->current_buffer, NULL); source->position = 0; source->position_fraction = 0; } src++; } Context->ActiveSourceCount = 0; Context = Context->next; } }