mirror of
https://github.com/QB64Official/qb64.git
synced 2024-09-17 20:24:46 +00:00
1134 lines
39 KiB
C
1134 lines
39 KiB
C
/**
|
|
* 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"
|
|
|
|
|
|
struct ChanMap {
|
|
enum Channel channel;
|
|
ALfloat angle;
|
|
};
|
|
|
|
/* Cone scalar */
|
|
ALfloat ConeScale = 0.5f;
|
|
|
|
/* Localized Z scalar for mono sources */
|
|
ALfloat ZScale = 1.0f;
|
|
|
|
|
|
static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat w,ALfloat matrix[4][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];
|
|
}
|
|
|
|
|
|
ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
|
|
{
|
|
static const struct ChanMap MonoMap[1] = { { FRONT_CENTER, 0.0f } };
|
|
static const struct ChanMap StereoMap[2] = {
|
|
{ FRONT_LEFT, -30.0f * F_PI/180.0f },
|
|
{ FRONT_RIGHT, 30.0f * F_PI/180.0f }
|
|
};
|
|
static const struct ChanMap RearMap[2] = {
|
|
{ BACK_LEFT, -150.0f * F_PI/180.0f },
|
|
{ BACK_RIGHT, 150.0f * F_PI/180.0f }
|
|
};
|
|
static const struct ChanMap QuadMap[4] = {
|
|
{ FRONT_LEFT, -45.0f * F_PI/180.0f },
|
|
{ FRONT_RIGHT, 45.0f * F_PI/180.0f },
|
|
{ BACK_LEFT, -135.0f * F_PI/180.0f },
|
|
{ BACK_RIGHT, 135.0f * F_PI/180.0f }
|
|
};
|
|
static const struct ChanMap X51Map[6] = {
|
|
{ FRONT_LEFT, -30.0f * F_PI/180.0f },
|
|
{ FRONT_RIGHT, 30.0f * F_PI/180.0f },
|
|
{ FRONT_CENTER, 0.0f * F_PI/180.0f },
|
|
{ LFE, 0.0f },
|
|
{ BACK_LEFT, -110.0f * F_PI/180.0f },
|
|
{ BACK_RIGHT, 110.0f * F_PI/180.0f }
|
|
};
|
|
static const struct ChanMap X61Map[7] = {
|
|
{ FRONT_LEFT, -30.0f * F_PI/180.0f },
|
|
{ FRONT_RIGHT, 30.0f * F_PI/180.0f },
|
|
{ FRONT_CENTER, 0.0f * F_PI/180.0f },
|
|
{ LFE, 0.0f },
|
|
{ BACK_CENTER, 180.0f * F_PI/180.0f },
|
|
{ SIDE_LEFT, -90.0f * F_PI/180.0f },
|
|
{ SIDE_RIGHT, 90.0f * F_PI/180.0f }
|
|
};
|
|
static const struct ChanMap X71Map[8] = {
|
|
{ FRONT_LEFT, -30.0f * F_PI/180.0f },
|
|
{ FRONT_RIGHT, 30.0f * F_PI/180.0f },
|
|
{ FRONT_CENTER, 0.0f * F_PI/180.0f },
|
|
{ LFE, 0.0f },
|
|
{ BACK_LEFT, -150.0f * F_PI/180.0f },
|
|
{ BACK_RIGHT, 150.0f * F_PI/180.0f },
|
|
{ SIDE_LEFT, -90.0f * F_PI/180.0f },
|
|
{ SIDE_RIGHT, 90.0f * F_PI/180.0f }
|
|
};
|
|
|
|
ALCdevice *Device = ALContext->Device;
|
|
ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
|
|
ALbufferlistitem *BufferListItem;
|
|
enum FmtChannels Channels;
|
|
ALfloat (*SrcMatrix)[MAXCHANNELS];
|
|
ALfloat DryGain, DryGainHF;
|
|
ALfloat WetGain[MAX_SENDS];
|
|
ALfloat WetGainHF[MAX_SENDS];
|
|
ALint NumSends, Frequency;
|
|
const ALfloat *ChannelGain;
|
|
const struct ChanMap *chans = NULL;
|
|
enum Resampler Resampler;
|
|
ALint num_channels = 0;
|
|
ALboolean DirectChannels;
|
|
ALfloat Pitch;
|
|
ALfloat cw;
|
|
ALuint pos;
|
|
ALint i, c;
|
|
|
|
/* Get device properties */
|
|
NumSends = Device->NumAuxSends;
|
|
Frequency = Device->Frequency;
|
|
|
|
/* Get listener properties */
|
|
ListenerGain = ALContext->Listener.Gain;
|
|
|
|
/* Get source properties */
|
|
SourceVolume = ALSource->flGain;
|
|
MinVolume = ALSource->flMinGain;
|
|
MaxVolume = ALSource->flMaxGain;
|
|
Pitch = ALSource->flPitch;
|
|
Resampler = ALSource->Resampler;
|
|
DirectChannels = ALSource->DirectChannels;
|
|
|
|
/* Calculate the stepping value */
|
|
Channels = FmtMono;
|
|
BufferListItem = ALSource->queue;
|
|
while(BufferListItem != NULL)
|
|
{
|
|
ALbuffer *ALBuffer;
|
|
if((ALBuffer=BufferListItem->buffer) != NULL)
|
|
{
|
|
ALsizei maxstep = STACK_DATA_SIZE/sizeof(ALfloat) /
|
|
ALSource->NumChannels;
|
|
maxstep -= ResamplerPadding[Resampler] +
|
|
ResamplerPrePadding[Resampler] + 1;
|
|
maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
|
|
|
|
Pitch = Pitch * ALBuffer->Frequency / Frequency;
|
|
if(Pitch > (ALfloat)maxstep)
|
|
ALSource->Params.Step = maxstep<<FRACTIONBITS;
|
|
else
|
|
{
|
|
ALSource->Params.Step = fastf2i(Pitch*FRACTIONONE);
|
|
if(ALSource->Params.Step == 0)
|
|
ALSource->Params.Step = 1;
|
|
}
|
|
if(ALSource->Params.Step == FRACTIONONE)
|
|
Resampler = PointResampler;
|
|
|
|
Channels = ALBuffer->FmtChannels;
|
|
break;
|
|
}
|
|
BufferListItem = BufferListItem->next;
|
|
}
|
|
if(!DirectChannels && Device->Hrtf)
|
|
ALSource->Params.DoMix = SelectHrtfMixer(Resampler);
|
|
else
|
|
ALSource->Params.DoMix = SelectMixer(Resampler);
|
|
|
|
/* Calculate gains */
|
|
DryGain = clampf(SourceVolume, MinVolume, MaxVolume);
|
|
DryGain *= ALSource->DirectGain;
|
|
DryGainHF = ALSource->DirectGainHF;
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);
|
|
WetGain[i] *= ALSource->Send[i].WetGain;
|
|
WetGainHF[i] = ALSource->Send[i].WetGainHF;
|
|
}
|
|
|
|
SrcMatrix = ALSource->Params.DryGains;
|
|
for(i = 0;i < MAXCHANNELS;i++)
|
|
{
|
|
for(c = 0;c < MAXCHANNELS;c++)
|
|
SrcMatrix[i][c] = 0.0f;
|
|
}
|
|
switch(Channels)
|
|
{
|
|
case FmtMono:
|
|
chans = MonoMap;
|
|
num_channels = 1;
|
|
break;
|
|
case FmtStereo:
|
|
if(!DirectChannels && (Device->Flags&DEVICE_DUPLICATE_STEREO))
|
|
{
|
|
DryGain *= aluSqrt(2.0f/4.0f);
|
|
for(c = 0;c < 2;c++)
|
|
{
|
|
pos = aluCart2LUTpos(aluCos(RearMap[c].angle),
|
|
aluSin(RearMap[c].angle));
|
|
ChannelGain = Device->PanningLUT[pos];
|
|
|
|
for(i = 0;i < (ALint)Device->NumChan;i++)
|
|
{
|
|
enum Channel chan = Device->Speaker2Chan[i];
|
|
SrcMatrix[c][chan] += DryGain * ListenerGain *
|
|
ChannelGain[chan];
|
|
}
|
|
}
|
|
}
|
|
chans = StereoMap;
|
|
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++)
|
|
{
|
|
for(i = 0;i < (ALint)Device->NumChan;i++)
|
|
{
|
|
enum Channel chan = Device->Speaker2Chan[i];
|
|
if(chan == chans[c].channel)
|
|
{
|
|
SrcMatrix[c][chan] += DryGain * ListenerGain;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(Device->Hrtf)
|
|
{
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
if(chans[c].channel == LFE)
|
|
{
|
|
/* Skip LFE */
|
|
ALSource->Params.HrtfDelay[c][0] = 0;
|
|
ALSource->Params.HrtfDelay[c][1] = 0;
|
|
for(i = 0;i < HRIR_LENGTH;i++)
|
|
{
|
|
ALSource->Params.HrtfCoeffs[c][i][0] = 0.0f;
|
|
ALSource->Params.HrtfCoeffs[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*ListenerGain,
|
|
ALSource->Params.HrtfCoeffs[c],
|
|
ALSource->Params.HrtfDelay[c]);
|
|
}
|
|
ALSource->HrtfCounter = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
if(chans[c].channel == LFE) /* Special-case LFE */
|
|
{
|
|
SrcMatrix[c][LFE] += DryGain * ListenerGain;
|
|
continue;
|
|
}
|
|
pos = aluCart2LUTpos(aluCos(chans[c].angle), aluSin(chans[c].angle));
|
|
ChannelGain = Device->PanningLUT[pos];
|
|
|
|
for(i = 0;i < (ALint)Device->NumChan;i++)
|
|
{
|
|
enum Channel chan = Device->Speaker2Chan[i];
|
|
SrcMatrix[c][chan] += DryGain * ListenerGain *
|
|
ChannelGain[chan];
|
|
}
|
|
}
|
|
}
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
ALeffectslot *Slot = ALSource->Send[i].Slot;
|
|
|
|
if(!Slot && i == 0)
|
|
Slot = Device->DefaultSlot;
|
|
if(Slot && Slot->effect.type == AL_EFFECT_NULL)
|
|
Slot = NULL;
|
|
ALSource->Params.Send[i].Slot = Slot;
|
|
ALSource->Params.Send[i].WetGain = WetGain[i] * ListenerGain;
|
|
}
|
|
|
|
/* Update filter coefficients. Calculations based on the I3DL2
|
|
* spec. */
|
|
cw = aluCos(F_PI*2.0f * LOWPASSFREQREF / Frequency);
|
|
|
|
/* We use two chained one-pole filters, so we need to take the
|
|
* square root of the squared gain, which is the same as the base
|
|
* gain. */
|
|
ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
/* We use a one-pole filter, so we need to take the squared gain */
|
|
ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
|
|
ALSource->Params.Send[i].iirFilter.coeff = a;
|
|
}
|
|
}
|
|
|
|
ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
|
|
{
|
|
const ALCdevice *Device = ALContext->Device;
|
|
ALfloat InnerAngle,OuterAngle,Angle,Distance,ClampedDist;
|
|
ALfloat Direction[3],Position[3],SourceToListener[3];
|
|
ALfloat Velocity[3],ListenerVel[3];
|
|
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 Matrix[4][4];
|
|
ALfloat Pitch;
|
|
ALuint Frequency;
|
|
ALint NumSends;
|
|
ALfloat cw;
|
|
ALint i, j;
|
|
|
|
DryGainHF = 1.0f;
|
|
for(i = 0;i < MAX_SENDS;i++)
|
|
WetGainHF[i] = 1.0f;
|
|
|
|
//Get context properties
|
|
DopplerFactor = ALContext->DopplerFactor * ALSource->DopplerFactor;
|
|
SpeedOfSound = ALContext->flSpeedOfSound * ALContext->DopplerVelocity;
|
|
NumSends = Device->NumAuxSends;
|
|
Frequency = Device->Frequency;
|
|
|
|
//Get listener properties
|
|
ListenerGain = ALContext->Listener.Gain;
|
|
MetersPerUnit = ALContext->Listener.MetersPerUnit;
|
|
ListenerVel[0] = ALContext->Listener.Velocity[0];
|
|
ListenerVel[1] = ALContext->Listener.Velocity[1];
|
|
ListenerVel[2] = ALContext->Listener.Velocity[2];
|
|
|
|
//Get source properties
|
|
SourceVolume = ALSource->flGain;
|
|
MinVolume = ALSource->flMinGain;
|
|
MaxVolume = ALSource->flMaxGain;
|
|
Pitch = ALSource->flPitch;
|
|
Resampler = ALSource->Resampler;
|
|
Position[0] = ALSource->vPosition[0];
|
|
Position[1] = ALSource->vPosition[1];
|
|
Position[2] = ALSource->vPosition[2];
|
|
Direction[0] = ALSource->vOrientation[0];
|
|
Direction[1] = ALSource->vOrientation[1];
|
|
Direction[2] = ALSource->vOrientation[2];
|
|
Velocity[0] = ALSource->vVelocity[0];
|
|
Velocity[1] = ALSource->vVelocity[1];
|
|
Velocity[2] = ALSource->vVelocity[2];
|
|
MinDist = ALSource->flRefDistance;
|
|
MaxDist = ALSource->flMaxDistance;
|
|
Rolloff = ALSource->flRollOffFactor;
|
|
InnerAngle = ALSource->flInnerAngle * ConeScale;
|
|
OuterAngle = ALSource->flOuterAngle * ConeScale;
|
|
AirAbsorptionFactor = ALSource->AirAbsorptionFactor;
|
|
DryGainHFAuto = ALSource->DryGainHFAuto;
|
|
WetGainAuto = ALSource->WetGainAuto;
|
|
WetGainHFAuto = ALSource->WetGainHFAuto;
|
|
RoomRolloffBase = ALSource->RoomRolloffFactor;
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
ALeffectslot *Slot = ALSource->Send[i].Slot;
|
|
|
|
if(!Slot && i == 0)
|
|
Slot = Device->DefaultSlot;
|
|
if(!Slot || Slot->effect.type == 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->effect.type))
|
|
{
|
|
RoomRolloff[i] += Slot->effect.Reverb.RoomRolloffFactor;
|
|
DecayDistance[i] = Slot->effect.Reverb.DecayTime *
|
|
SPEEDOFSOUNDMETRESPERSEC;
|
|
RoomAirAbsorption[i] = Slot->effect.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;
|
|
}
|
|
|
|
ALSource->Params.Send[i].Slot = Slot;
|
|
}
|
|
|
|
for(i = 0;i < 4;i++)
|
|
{
|
|
for(j = 0;j < 4;j++)
|
|
Matrix[i][j] = ALContext->Listener.Matrix[i][j];
|
|
}
|
|
|
|
//1. Translate Listener to origin (convert to head relative)
|
|
if(ALSource->bHeadRelative == AL_FALSE)
|
|
{
|
|
/* Translate position */
|
|
Position[0] -= ALContext->Listener.Position[0];
|
|
Position[1] -= ALContext->Listener.Position[1];
|
|
Position[2] -= ALContext->Listener.Position[2];
|
|
|
|
/* Transform source vectors into listener space */
|
|
aluMatrixVector(Position, 1.0f, Matrix);
|
|
aluMatrixVector(Direction, 0.0f, Matrix);
|
|
aluMatrixVector(Velocity, 0.0f, Matrix);
|
|
/* Transform listener velocity into listener space */
|
|
aluMatrixVector(ListenerVel, 0.0f, Matrix);
|
|
}
|
|
else
|
|
{
|
|
/* Transform listener velocity into listener space */
|
|
aluMatrixVector(ListenerVel, 0.0f, Matrix);
|
|
/* 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);
|
|
|
|
//2. Calculate distance attenuation
|
|
Distance = aluSqrt(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 = aluPow(ClampedDist/MinDist, -Rolloff);
|
|
for(i = 0;i < NumSends;i++)
|
|
RoomAttenuation[i] = aluPow(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 *= aluPow(AIRABSORBGAINHF, AirAbsorptionFactor*meters);
|
|
for(i = 0;i < NumSends;i++)
|
|
WetGainHF[i] *= aluPow(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] *= aluPow(0.001f/*-60dB*/, ApparentDist/DecayDistance[i]);
|
|
}
|
|
}
|
|
|
|
/* Calculate directional soundcones */
|
|
Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * (180.0f/F_PI);
|
|
if(Angle >= InnerAngle && Angle <= OuterAngle)
|
|
{
|
|
ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
|
|
ConeVolume = lerp(1.0f, ALSource->flOuterGain, scale);
|
|
ConeHF = lerp(1.0f, ALSource->OuterGainHF, scale);
|
|
}
|
|
else if(Angle > OuterAngle)
|
|
{
|
|
ConeVolume = ALSource->flOuterGain;
|
|
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 filter gains and filters
|
|
DryGain *= ALSource->DirectGain * ListenerGain;
|
|
DryGainHF *= ALSource->DirectGainHF;
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
WetGain[i] *= ALSource->Send[i].WetGain * ListenerGain;
|
|
WetGainHF[i] *= ALSource->Send[i].WetGainHF;
|
|
}
|
|
|
|
// Calculate Velocity
|
|
if(DopplerFactor > 0.0f)
|
|
{
|
|
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)
|
|
{
|
|
ALsizei maxstep = STACK_DATA_SIZE/sizeof(ALfloat) /
|
|
ALSource->NumChannels;
|
|
maxstep -= ResamplerPadding[Resampler] +
|
|
ResamplerPrePadding[Resampler] + 1;
|
|
maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
|
|
|
|
Pitch = Pitch * ALBuffer->Frequency / Frequency;
|
|
if(Pitch > (ALfloat)maxstep)
|
|
ALSource->Params.Step = maxstep<<FRACTIONBITS;
|
|
else
|
|
{
|
|
ALSource->Params.Step = fastf2i(Pitch*FRACTIONONE);
|
|
if(ALSource->Params.Step == 0)
|
|
ALSource->Params.Step = 1;
|
|
}
|
|
if(ALSource->Params.Step == FRACTIONONE)
|
|
Resampler = PointResampler;
|
|
|
|
break;
|
|
}
|
|
BufferListItem = BufferListItem->next;
|
|
}
|
|
if(Device->Hrtf)
|
|
ALSource->Params.DoMix = SelectHrtfMixer(Resampler);
|
|
else
|
|
ALSource->Params.DoMix = SelectMixer(Resampler);
|
|
|
|
if(Device->Hrtf)
|
|
{
|
|
// Use a binaural HRTF algorithm for stereo headphone playback
|
|
ALfloat delta, ev = 0.0f, az = 0.0f;
|
|
|
|
if(Distance > 0.0f)
|
|
{
|
|
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.
|
|
ev = aluAsin(Position[1]);
|
|
az = aluAtan2(Position[0], -Position[2]*ZScale);
|
|
}
|
|
|
|
// Check to see if the HRIR is already moving.
|
|
if(ALSource->HrtfMoving)
|
|
{
|
|
// Calculate the normalized HRTF transition factor (delta).
|
|
delta = CalcHrtfDelta(ALSource->Params.HrtfGain, DryGain,
|
|
ALSource->Params.HrtfDir, Position);
|
|
// If the delta is large enough, get the moving HRIR target
|
|
// coefficients, target delays, steppping values, and counter.
|
|
if(delta > 0.001f)
|
|
{
|
|
ALSource->HrtfCounter = GetMovingHrtfCoeffs(Device->Hrtf,
|
|
ev, az, DryGain, delta,
|
|
ALSource->HrtfCounter,
|
|
ALSource->Params.HrtfCoeffs[0],
|
|
ALSource->Params.HrtfDelay[0],
|
|
ALSource->Params.HrtfCoeffStep,
|
|
ALSource->Params.HrtfDelayStep);
|
|
ALSource->Params.HrtfGain = DryGain;
|
|
ALSource->Params.HrtfDir[0] = Position[0];
|
|
ALSource->Params.HrtfDir[1] = Position[1];
|
|
ALSource->Params.HrtfDir[2] = Position[2];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Get the initial (static) HRIR coefficients and delays.
|
|
GetLerpedHrtfCoeffs(Device->Hrtf, ev, az, DryGain,
|
|
ALSource->Params.HrtfCoeffs[0],
|
|
ALSource->Params.HrtfDelay[0]);
|
|
ALSource->HrtfCounter = 0;
|
|
ALSource->Params.HrtfGain = DryGain;
|
|
ALSource->Params.HrtfDir[0] = Position[0];
|
|
ALSource->Params.HrtfDir[1] = Position[1];
|
|
ALSource->Params.HrtfDir[2] = Position[2];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Use energy-preserving panning algorithm for multi-speaker playback
|
|
ALfloat DirGain, AmbientGain;
|
|
const ALfloat *ChannelGain;
|
|
ALfloat length;
|
|
ALint pos;
|
|
|
|
length = maxf(Distance, MinDist);
|
|
if(length > 0.0f)
|
|
{
|
|
ALfloat invlen = 1.0f/length;
|
|
Position[0] *= invlen;
|
|
Position[1] *= invlen;
|
|
Position[2] *= invlen;
|
|
}
|
|
|
|
pos = aluCart2LUTpos(-Position[2]*ZScale, Position[0]);
|
|
ChannelGain = Device->PanningLUT[pos];
|
|
|
|
DirGain = aluSqrt(Position[0]*Position[0] + Position[2]*Position[2]);
|
|
// elevation adjustment for directional gain. this sucks, but
|
|
// has low complexity
|
|
AmbientGain = aluSqrt(1.0f/Device->NumChan);
|
|
for(i = 0;i < MAXCHANNELS;i++)
|
|
{
|
|
ALuint i2;
|
|
for(i2 = 0;i2 < MAXCHANNELS;i2++)
|
|
ALSource->Params.DryGains[i][i2] = 0.0f;
|
|
}
|
|
for(i = 0;i < (ALint)Device->NumChan;i++)
|
|
{
|
|
enum Channel chan = Device->Speaker2Chan[i];
|
|
ALfloat gain = lerp(AmbientGain, ChannelGain[chan], DirGain);
|
|
ALSource->Params.DryGains[0][chan] = DryGain * gain;
|
|
}
|
|
}
|
|
for(i = 0;i < NumSends;i++)
|
|
ALSource->Params.Send[i].WetGain = WetGain[i];
|
|
|
|
/* Update filter coefficients. */
|
|
cw = aluCos(F_PI*2.0f * LOWPASSFREQREF / Frequency);
|
|
|
|
ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
|
|
ALSource->Params.Send[i].iirFilter.coeff = a;
|
|
}
|
|
}
|
|
|
|
|
|
static __inline ALfloat aluF2F(ALfloat val)
|
|
{ return val; }
|
|
static __inline ALint aluF2I(ALfloat val)
|
|
{
|
|
if(val > 1.0f) return 2147483647;
|
|
if(val < -1.0f) return -2147483647-1;
|
|
return fastf2i((ALfloat)(val*2147483647.0));
|
|
}
|
|
static __inline ALuint aluF2UI(ALfloat val)
|
|
{ return aluF2I(val)+2147483648u; }
|
|
static __inline ALshort aluF2S(ALfloat val)
|
|
{ return aluF2I(val)>>16; }
|
|
static __inline ALushort aluF2US(ALfloat val)
|
|
{ return aluF2S(val)+32768; }
|
|
static __inline ALbyte aluF2B(ALfloat val)
|
|
{ return aluF2I(val)>>24; }
|
|
static __inline ALubyte aluF2UB(ALfloat val)
|
|
{ return aluF2B(val)+128; }
|
|
|
|
#define DECL_TEMPLATE(T, N, func) \
|
|
static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer, \
|
|
ALuint SamplesToDo) \
|
|
{ \
|
|
ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer; \
|
|
const enum Channel *ChanMap = device->DevChannels; \
|
|
ALuint i, j; \
|
|
\
|
|
for(j = 0;j < N;j++) \
|
|
{ \
|
|
T *RESTRICT out = buffer + j; \
|
|
enum Channel chan = ChanMap[j]; \
|
|
\
|
|
for(i = 0;i < SamplesToDo;i++) \
|
|
out[i*N] = func(DryBuffer[i][chan]); \
|
|
} \
|
|
}
|
|
|
|
DECL_TEMPLATE(ALfloat, 1, aluF2F)
|
|
DECL_TEMPLATE(ALfloat, 2, aluF2F)
|
|
DECL_TEMPLATE(ALfloat, 4, aluF2F)
|
|
DECL_TEMPLATE(ALfloat, 6, aluF2F)
|
|
DECL_TEMPLATE(ALfloat, 7, aluF2F)
|
|
DECL_TEMPLATE(ALfloat, 8, aluF2F)
|
|
|
|
DECL_TEMPLATE(ALuint, 1, aluF2UI)
|
|
DECL_TEMPLATE(ALuint, 2, aluF2UI)
|
|
DECL_TEMPLATE(ALuint, 4, aluF2UI)
|
|
DECL_TEMPLATE(ALuint, 6, aluF2UI)
|
|
DECL_TEMPLATE(ALuint, 7, aluF2UI)
|
|
DECL_TEMPLATE(ALuint, 8, aluF2UI)
|
|
|
|
DECL_TEMPLATE(ALint, 1, aluF2I)
|
|
DECL_TEMPLATE(ALint, 2, aluF2I)
|
|
DECL_TEMPLATE(ALint, 4, aluF2I)
|
|
DECL_TEMPLATE(ALint, 6, aluF2I)
|
|
DECL_TEMPLATE(ALint, 7, aluF2I)
|
|
DECL_TEMPLATE(ALint, 8, aluF2I)
|
|
|
|
DECL_TEMPLATE(ALushort, 1, aluF2US)
|
|
DECL_TEMPLATE(ALushort, 2, aluF2US)
|
|
DECL_TEMPLATE(ALushort, 4, aluF2US)
|
|
DECL_TEMPLATE(ALushort, 6, aluF2US)
|
|
DECL_TEMPLATE(ALushort, 7, aluF2US)
|
|
DECL_TEMPLATE(ALushort, 8, aluF2US)
|
|
|
|
DECL_TEMPLATE(ALshort, 1, aluF2S)
|
|
DECL_TEMPLATE(ALshort, 2, aluF2S)
|
|
DECL_TEMPLATE(ALshort, 4, aluF2S)
|
|
DECL_TEMPLATE(ALshort, 6, aluF2S)
|
|
DECL_TEMPLATE(ALshort, 7, aluF2S)
|
|
DECL_TEMPLATE(ALshort, 8, aluF2S)
|
|
|
|
DECL_TEMPLATE(ALubyte, 1, aluF2UB)
|
|
DECL_TEMPLATE(ALubyte, 2, aluF2UB)
|
|
DECL_TEMPLATE(ALubyte, 4, aluF2UB)
|
|
DECL_TEMPLATE(ALubyte, 6, aluF2UB)
|
|
DECL_TEMPLATE(ALubyte, 7, aluF2UB)
|
|
DECL_TEMPLATE(ALubyte, 8, aluF2UB)
|
|
|
|
DECL_TEMPLATE(ALbyte, 1, aluF2B)
|
|
DECL_TEMPLATE(ALbyte, 2, aluF2B)
|
|
DECL_TEMPLATE(ALbyte, 4, aluF2B)
|
|
DECL_TEMPLATE(ALbyte, 6, aluF2B)
|
|
DECL_TEMPLATE(ALbyte, 7, aluF2B)
|
|
DECL_TEMPLATE(ALbyte, 8, aluF2B)
|
|
|
|
#undef DECL_TEMPLATE
|
|
|
|
#define DECL_TEMPLATE(T) \
|
|
static void Write_##T(ALCdevice *device, T *buffer, ALuint SamplesToDo) \
|
|
{ \
|
|
switch(device->FmtChans) \
|
|
{ \
|
|
case DevFmtMono: \
|
|
Write_##T##_1(device, buffer, SamplesToDo); \
|
|
break; \
|
|
case DevFmtStereo: \
|
|
Write_##T##_2(device, buffer, SamplesToDo); \
|
|
break; \
|
|
case DevFmtQuad: \
|
|
Write_##T##_4(device, buffer, SamplesToDo); \
|
|
break; \
|
|
case DevFmtX51: \
|
|
case DevFmtX51Side: \
|
|
Write_##T##_6(device, buffer, SamplesToDo); \
|
|
break; \
|
|
case DevFmtX61: \
|
|
Write_##T##_7(device, buffer, SamplesToDo); \
|
|
break; \
|
|
case DevFmtX71: \
|
|
Write_##T##_8(device, buffer, SamplesToDo); \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
DECL_TEMPLATE(ALfloat)
|
|
DECL_TEMPLATE(ALuint)
|
|
DECL_TEMPLATE(ALint)
|
|
DECL_TEMPLATE(ALushort)
|
|
DECL_TEMPLATE(ALshort)
|
|
DECL_TEMPLATE(ALubyte)
|
|
DECL_TEMPLATE(ALbyte)
|
|
|
|
#undef DECL_TEMPLATE
|
|
|
|
ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
|
|
{
|
|
ALuint SamplesToDo;
|
|
ALeffectslot **slot, **slot_end;
|
|
ALsource **src, **src_end;
|
|
ALCcontext *ctx;
|
|
int fpuState;
|
|
ALuint i, c;
|
|
|
|
fpuState = SetMixerFPUMode();
|
|
|
|
while(size > 0)
|
|
{
|
|
/* Setup variables */
|
|
SamplesToDo = minu(size, BUFFERSIZE);
|
|
|
|
/* Clear mixing buffer */
|
|
memset(device->DryBuffer, 0, SamplesToDo*MAXCHANNELS*sizeof(ALfloat));
|
|
|
|
LockDevice(device);
|
|
ctx = device->ContextList;
|
|
while(ctx)
|
|
{
|
|
ALenum DeferUpdates = ctx->DeferUpdates;
|
|
ALenum UpdateSources = AL_FALSE;
|
|
|
|
if(!DeferUpdates)
|
|
UpdateSources = ExchangeInt(&ctx->UpdateSources, AL_FALSE);
|
|
|
|
src = ctx->ActiveSources;
|
|
src_end = src + ctx->ActiveSourceCount;
|
|
while(src != src_end)
|
|
{
|
|
if((*src)->state != AL_PLAYING)
|
|
{
|
|
--(ctx->ActiveSourceCount);
|
|
*src = *(--src_end);
|
|
continue;
|
|
}
|
|
|
|
if(!DeferUpdates && (ExchangeInt(&(*src)->NeedsUpdate, AL_FALSE) ||
|
|
UpdateSources))
|
|
ALsource_Update(*src, ctx);
|
|
|
|
MixSource(*src, device, SamplesToDo);
|
|
src++;
|
|
}
|
|
|
|
/* effect slot processing */
|
|
slot = ctx->ActiveEffectSlots;
|
|
slot_end = slot + ctx->ActiveEffectSlotCount;
|
|
while(slot != slot_end)
|
|
{
|
|
for(c = 0;c < SamplesToDo;c++)
|
|
{
|
|
(*slot)->WetBuffer[c] += (*slot)->ClickRemoval[0];
|
|
(*slot)->ClickRemoval[0] -= (*slot)->ClickRemoval[0] * (1.0f/256.0f);
|
|
}
|
|
(*slot)->ClickRemoval[0] += (*slot)->PendingClicks[0];
|
|
(*slot)->PendingClicks[0] = 0.0f;
|
|
|
|
if(!DeferUpdates && ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
|
|
ALeffectState_Update((*slot)->EffectState, device, *slot);
|
|
|
|
ALeffectState_Process((*slot)->EffectState, SamplesToDo,
|
|
(*slot)->WetBuffer, device->DryBuffer);
|
|
|
|
for(i = 0;i < SamplesToDo;i++)
|
|
(*slot)->WetBuffer[i] = 0.0f;
|
|
|
|
slot++;
|
|
}
|
|
|
|
ctx = ctx->next;
|
|
}
|
|
|
|
slot = &device->DefaultSlot;
|
|
if(*slot != NULL)
|
|
{
|
|
for(c = 0;c < SamplesToDo;c++)
|
|
{
|
|
(*slot)->WetBuffer[c] += (*slot)->ClickRemoval[0];
|
|
(*slot)->ClickRemoval[0] -= (*slot)->ClickRemoval[0] * (1.0f/256.0f);
|
|
}
|
|
(*slot)->ClickRemoval[0] += (*slot)->PendingClicks[0];
|
|
(*slot)->PendingClicks[0] = 0.0f;
|
|
|
|
if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
|
|
ALeffectState_Update((*slot)->EffectState, device, *slot);
|
|
|
|
ALeffectState_Process((*slot)->EffectState, SamplesToDo,
|
|
(*slot)->WetBuffer, device->DryBuffer);
|
|
|
|
for(i = 0;i < SamplesToDo;i++)
|
|
(*slot)->WetBuffer[i] = 0.0f;
|
|
}
|
|
UnlockDevice(device);
|
|
|
|
//Post processing loop
|
|
if(device->FmtChans == DevFmtMono)
|
|
{
|
|
for(i = 0;i < SamplesToDo;i++)
|
|
{
|
|
device->DryBuffer[i][FRONT_CENTER] += device->ClickRemoval[FRONT_CENTER];
|
|
device->ClickRemoval[FRONT_CENTER] -= device->ClickRemoval[FRONT_CENTER] * (1.0f/256.0f);
|
|
}
|
|
device->ClickRemoval[FRONT_CENTER] += device->PendingClicks[FRONT_CENTER];
|
|
device->PendingClicks[FRONT_CENTER] = 0.0f;
|
|
}
|
|
else if(device->FmtChans == DevFmtStereo)
|
|
{
|
|
/* Assumes the first two channels are FRONT_LEFT and FRONT_RIGHT */
|
|
for(i = 0;i < SamplesToDo;i++)
|
|
{
|
|
for(c = 0;c < 2;c++)
|
|
{
|
|
device->DryBuffer[i][c] += device->ClickRemoval[c];
|
|
device->ClickRemoval[c] -= device->ClickRemoval[c] * (1.0f/256.0f);
|
|
}
|
|
}
|
|
for(c = 0;c < 2;c++)
|
|
{
|
|
device->ClickRemoval[c] += device->PendingClicks[c];
|
|
device->PendingClicks[c] = 0.0f;
|
|
}
|
|
if(device->Bs2b)
|
|
{
|
|
for(i = 0;i < SamplesToDo;i++)
|
|
bs2b_cross_feed(device->Bs2b, &device->DryBuffer[i][0]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i = 0;i < SamplesToDo;i++)
|
|
{
|
|
for(c = 0;c < MAXCHANNELS;c++)
|
|
{
|
|
device->DryBuffer[i][c] += device->ClickRemoval[c];
|
|
device->ClickRemoval[c] -= device->ClickRemoval[c] * (1.0f/256.0f);
|
|
}
|
|
}
|
|
for(c = 0;c < MAXCHANNELS;c++)
|
|
{
|
|
device->ClickRemoval[c] += device->PendingClicks[c];
|
|
device->PendingClicks[c] = 0.0f;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
RestoreFPUMode(fpuState);
|
|
}
|
|
|
|
|
|
ALvoid aluHandleDisconnect(ALCdevice *device)
|
|
{
|
|
ALCcontext *Context;
|
|
|
|
LockDevice(device);
|
|
device->Connected = ALC_FALSE;
|
|
|
|
Context = device->ContextList;
|
|
while(Context)
|
|
{
|
|
ALsource **src, **src_end;
|
|
|
|
src = Context->ActiveSources;
|
|
src_end = src + Context->ActiveSourceCount;
|
|
while(src != src_end)
|
|
{
|
|
if((*src)->state == AL_PLAYING)
|
|
{
|
|
(*src)->state = AL_STOPPED;
|
|
(*src)->BuffersPlayed = (*src)->BuffersInQueue;
|
|
(*src)->position = 0;
|
|
(*src)->position_fraction = 0;
|
|
}
|
|
src++;
|
|
}
|
|
Context->ActiveSourceCount = 0;
|
|
|
|
Context = Context->next;
|
|
}
|
|
UnlockDevice(device);
|
|
}
|