rlm@0: /**
rlm@0:  * OpenAL cross platform audio library
rlm@0:  * Copyright (C) 1999-2007 by authors.
rlm@0:  * This library is free software; you can redistribute it and/or
rlm@0:  *  modify it under the terms of the GNU Library General Public
rlm@0:  *  License as published by the Free Software Foundation; either
rlm@0:  *  version 2 of the License, or (at your option) any later version.
rlm@0:  *
rlm@0:  * This library is distributed in the hope that it will be useful,
rlm@0:  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
rlm@0:  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
rlm@0:  *  Library General Public License for more details.
rlm@0:  *
rlm@0:  * You should have received a copy of the GNU Library General Public
rlm@0:  *  License along with this library; if not, write to the
rlm@0:  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
rlm@0:  *  Boston, MA  02111-1307, USA.
rlm@0:  * Or go to http://www.gnu.org/copyleft/lgpl.html
rlm@0:  */
rlm@0: 
rlm@0: #include "config.h"
rlm@0: 
rlm@0: #include <math.h>
rlm@0: #include <stdlib.h>
rlm@0: #include <string.h>
rlm@0: #include <ctype.h>
rlm@0: #include <assert.h>
rlm@0: 
rlm@0: #include "alMain.h"
rlm@0: #include "AL/al.h"
rlm@0: #include "AL/alc.h"
rlm@0: #include "alSource.h"
rlm@0: #include "alBuffer.h"
rlm@0: #include "alListener.h"
rlm@0: #include "alAuxEffectSlot.h"
rlm@0: #include "alu.h"
rlm@0: #include "bs2b.h"
rlm@0: 
rlm@0: 
rlm@0: static __inline ALvoid aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
rlm@0: {
rlm@0:     outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
rlm@0:     outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
rlm@0:     outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
rlm@0: }
rlm@0: 
rlm@0: static __inline ALfloat aluDotproduct(const ALfloat *inVector1, const ALfloat *inVector2)
rlm@0: {
rlm@0:     return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
rlm@0:            inVector1[2]*inVector2[2];
rlm@0: }
rlm@0: 
rlm@0: static __inline ALvoid aluNormalize(ALfloat *inVector)
rlm@0: {
rlm@0:     ALfloat length, inverse_length;
rlm@0: 
rlm@0:     length = aluSqrt(aluDotproduct(inVector, inVector));
rlm@0:     if(length != 0.0f)
rlm@0:     {
rlm@0:         inverse_length = 1.0f/length;
rlm@0:         inVector[0] *= inverse_length;
rlm@0:         inVector[1] *= inverse_length;
rlm@0:         inVector[2] *= inverse_length;
rlm@0:     }
rlm@0: }
rlm@0: 
rlm@0: static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat w,ALfloat matrix[4][4])
rlm@0: {
rlm@0:     ALfloat temp[4] = {
rlm@0:         vector[0], vector[1], vector[2], w
rlm@0:     };
rlm@0: 
rlm@0:     vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
rlm@0:     vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
rlm@0:     vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
rlm@0: {
rlm@0:     static const ALfloat angles_Mono[1] = { 0.0f };
rlm@0:     static const ALfloat angles_Stereo[2] = { -30.0f, 30.0f };
rlm@0:     static const ALfloat angles_Rear[2] = { -150.0f, 150.0f };
rlm@0:     static const ALfloat angles_Quad[4] = { -45.0f, 45.0f, -135.0f, 135.0f };
rlm@0:     static const ALfloat angles_X51[6] = { -30.0f, 30.0f, 0.0f, 0.0f,
rlm@0:                                            -110.0f, 110.0f };
rlm@0:     static const ALfloat angles_X61[7] = { -30.0f, 30.0f, 0.0f, 0.0f,
rlm@0:                                            180.0f, -90.0f, 90.0f };
rlm@0:     static const ALfloat angles_X71[8] = { -30.0f, 30.0f, 0.0f, 0.0f,
rlm@0:                                            -110.0f, 110.0f, -90.0f, 90.0f };
rlm@0: 
rlm@0:     static const enum Channel chans_Mono[1] = { FRONT_CENTER };
rlm@0:     static const enum Channel chans_Stereo[2] = { FRONT_LEFT, FRONT_RIGHT };
rlm@0:     static const enum Channel chans_Rear[2] = { BACK_LEFT, BACK_RIGHT };
rlm@0:     static const enum Channel chans_Quad[4] = { FRONT_LEFT, FRONT_RIGHT,
rlm@0:                                                 BACK_LEFT, BACK_RIGHT };
rlm@0:     static const enum Channel chans_X51[6] = { FRONT_LEFT, FRONT_RIGHT,
rlm@0:                                                FRONT_CENTER, LFE,
rlm@0:                                                BACK_LEFT, BACK_RIGHT };
rlm@0:     static const enum Channel chans_X61[7] = { FRONT_LEFT, FRONT_RIGHT,
rlm@0:                                                FRONT_CENTER, LFE, BACK_CENTER,
rlm@0:                                                SIDE_LEFT, SIDE_RIGHT };
rlm@0:     static const enum Channel chans_X71[8] = { FRONT_LEFT, FRONT_RIGHT,
rlm@0:                                                FRONT_CENTER, LFE,
rlm@0:                                                BACK_LEFT, BACK_RIGHT,
rlm@0:                                                SIDE_LEFT, SIDE_RIGHT };
rlm@0: 
rlm@0:     ALCdevice *Device = ALContext->Device;
rlm@0:     ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
rlm@0:     ALbufferlistitem *BufferListItem;
rlm@0:     enum DevFmtChannels DevChans;
rlm@0:     enum FmtChannels Channels;
rlm@0:     ALfloat (*SrcMatrix)[MAXCHANNELS];
rlm@0:     ALfloat DryGain, DryGainHF;
rlm@0:     ALfloat WetGain[MAX_SENDS];
rlm@0:     ALfloat WetGainHF[MAX_SENDS];
rlm@0:     ALint NumSends, Frequency;
rlm@0:     const ALfloat *SpeakerGain;
rlm@0:     const ALfloat *angles = NULL;
rlm@0:     const enum Channel *chans = NULL;
rlm@0:     enum Resampler Resampler;
rlm@0:     ALint num_channels = 0;
rlm@0:     ALboolean VirtualChannels;
rlm@0:     ALfloat Pitch;
rlm@0:     ALfloat cw;
rlm@0:     ALuint pos;
rlm@0:     ALint i, c;
rlm@0: 
rlm@0:     /* Get device properties */
rlm@0:     DevChans  = ALContext->Device->FmtChans;
rlm@0:     NumSends  = ALContext->Device->NumAuxSends;
rlm@0:     Frequency = ALContext->Device->Frequency;
rlm@0: 
rlm@0:     /* Get listener properties */
rlm@0:     ListenerGain = ALContext->Listener.Gain;
rlm@0: 
rlm@0:     /* Get source properties */
rlm@0:     SourceVolume    = ALSource->flGain;
rlm@0:     MinVolume       = ALSource->flMinGain;
rlm@0:     MaxVolume       = ALSource->flMaxGain;
rlm@0:     Pitch           = ALSource->flPitch;
rlm@0:     Resampler       = ALSource->Resampler;
rlm@0:     VirtualChannels = ALSource->VirtualChannels;
rlm@0: 
rlm@0:     /* Calculate the stepping value */
rlm@0:     Channels = FmtMono;
rlm@0:     BufferListItem = ALSource->queue;
rlm@0:     while(BufferListItem != NULL)
rlm@0:     {
rlm@0:         ALbuffer *ALBuffer;
rlm@0:         if((ALBuffer=BufferListItem->buffer) != NULL)
rlm@0:         {
rlm@0:             ALint maxstep = STACK_DATA_SIZE / ALSource->NumChannels /
rlm@0:                                               ALSource->SampleSize;
rlm@0:             maxstep -= ResamplerPadding[Resampler] +
rlm@0:                        ResamplerPrePadding[Resampler] + 1;
rlm@0:             maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
rlm@0: 
rlm@0:             Pitch = Pitch * ALBuffer->Frequency / Frequency;
rlm@0:             if(Pitch > (ALfloat)maxstep)
rlm@0:                 ALSource->Params.Step = maxstep<<FRACTIONBITS;
rlm@0:             else
rlm@0:             {
rlm@0:                 ALSource->Params.Step = Pitch*FRACTIONONE;
rlm@0:                 if(ALSource->Params.Step == 0)
rlm@0:                     ALSource->Params.Step = 1;
rlm@0:             }
rlm@0: 
rlm@0:             Channels = ALBuffer->FmtChannels;
rlm@0: 
rlm@0:             if(ALSource->VirtualChannels && (Device->Flags&DEVICE_USE_HRTF))
rlm@0:                 ALSource->Params.DoMix = SelectHrtfMixer(ALBuffer,
rlm@0:                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
rlm@0:                                                               Resampler);
rlm@0:             else
rlm@0:                 ALSource->Params.DoMix = SelectMixer(ALBuffer,
rlm@0:                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
rlm@0:                                                               Resampler);
rlm@0:             break;
rlm@0:         }
rlm@0:         BufferListItem = BufferListItem->next;
rlm@0:     }
rlm@0: 
rlm@0:     /* Calculate gains */
rlm@0:     DryGain = clampf(SourceVolume, MinVolume, MaxVolume);
rlm@0:     DryGainHF = 1.0f;
rlm@0:     switch(ALSource->DirectFilter.type)
rlm@0:     {
rlm@0:         case AL_FILTER_LOWPASS:
rlm@0:             DryGain *= ALSource->DirectFilter.Gain;
rlm@0:             DryGainHF *= ALSource->DirectFilter.GainHF;
rlm@0:             break;
rlm@0:     }
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:     {
rlm@0:         WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);
rlm@0:         WetGainHF[i] = 1.0f;
rlm@0:         switch(ALSource->Send[i].WetFilter.type)
rlm@0:         {
rlm@0:             case AL_FILTER_LOWPASS:
rlm@0:                 WetGain[i] *= ALSource->Send[i].WetFilter.Gain;
rlm@0:                 WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;
rlm@0:                 break;
rlm@0:         }
rlm@0:     }
rlm@0: 
rlm@0:     SrcMatrix = ALSource->Params.DryGains;
rlm@0:     for(i = 0;i < MAXCHANNELS;i++)
rlm@0:     {
rlm@0:         for(c = 0;c < MAXCHANNELS;c++)
rlm@0:             SrcMatrix[i][c] = 0.0f;
rlm@0:     }
rlm@0:     switch(Channels)
rlm@0:     {
rlm@0:     case FmtMono:
rlm@0:         angles = angles_Mono;
rlm@0:         chans = chans_Mono;
rlm@0:         num_channels = 1;
rlm@0:         break;
rlm@0:     case FmtStereo:
rlm@0:         if(VirtualChannels && (ALContext->Device->Flags&DEVICE_DUPLICATE_STEREO))
rlm@0:         {
rlm@0:             DryGain *= aluSqrt(2.0f/4.0f);
rlm@0:             for(c = 0;c < 2;c++)
rlm@0:             {
rlm@0:                 pos = aluCart2LUTpos(cos(angles_Rear[c] * (M_PI/180.0)),
rlm@0:                                      sin(angles_Rear[c] * (M_PI/180.0)));
rlm@0:                 SpeakerGain = Device->PanningLUT[pos];
rlm@0: 
rlm@0:                 for(i = 0;i < (ALint)Device->NumChan;i++)
rlm@0:                 {
rlm@0:                     enum Channel chan = Device->Speaker2Chan[i];
rlm@0:                     SrcMatrix[c][chan] += DryGain * ListenerGain *
rlm@0:                                           SpeakerGain[chan];
rlm@0:                 }
rlm@0:             }
rlm@0:         }
rlm@0:         angles = angles_Stereo;
rlm@0:         chans = chans_Stereo;
rlm@0:         num_channels = 2;
rlm@0:         break;
rlm@0: 
rlm@0:     case FmtRear:
rlm@0:         angles = angles_Rear;
rlm@0:         chans = chans_Rear;
rlm@0:         num_channels = 2;
rlm@0:         break;
rlm@0: 
rlm@0:     case FmtQuad:
rlm@0:         angles = angles_Quad;
rlm@0:         chans = chans_Quad;
rlm@0:         num_channels = 4;
rlm@0:         break;
rlm@0: 
rlm@0:     case FmtX51:
rlm@0:         angles = angles_X51;
rlm@0:         chans = chans_X51;
rlm@0:         num_channels = 6;
rlm@0:         break;
rlm@0: 
rlm@0:     case FmtX61:
rlm@0:         angles = angles_X61;
rlm@0:         chans = chans_X61;
rlm@0:         num_channels = 7;
rlm@0:         break;
rlm@0: 
rlm@0:     case FmtX71:
rlm@0:         angles = angles_X71;
rlm@0:         chans = chans_X71;
rlm@0:         num_channels = 8;
rlm@0:         break;
rlm@0:     }
rlm@0: 
rlm@0:     if(VirtualChannels == AL_FALSE)
rlm@0:     {
rlm@0:         for(c = 0;c < num_channels;c++)
rlm@0:             SrcMatrix[c][chans[c]] += DryGain * ListenerGain;
rlm@0:     }
rlm@0:     else if((Device->Flags&DEVICE_USE_HRTF))
rlm@0:     {
rlm@0:         for(c = 0;c < num_channels;c++)
rlm@0:         {
rlm@0:             if(chans[c] == LFE)
rlm@0:             {
rlm@0:                 /* Skip LFE */
rlm@0:                 ALSource->Params.HrtfDelay[c][0] = 0;
rlm@0:                 ALSource->Params.HrtfDelay[c][1] = 0;
rlm@0:                 for(i = 0;i < HRIR_LENGTH;i++)
rlm@0:                 {
rlm@0:                     ALSource->Params.HrtfCoeffs[c][i][0] = 0.0f;
rlm@0:                     ALSource->Params.HrtfCoeffs[c][i][1] = 0.0f;
rlm@0:                 }
rlm@0:             }
rlm@0:             else
rlm@0:             {
rlm@0:                 /* Get the static HRIR coefficients and delays for this
rlm@0:                  * channel. */
rlm@0:                 GetLerpedHrtfCoeffs(0.0, angles[c] * (M_PI/180.0),
rlm@0:                                     DryGain*ListenerGain,
rlm@0:                                     ALSource->Params.HrtfCoeffs[c],
rlm@0:                                     ALSource->Params.HrtfDelay[c]);
rlm@0:             }
rlm@0:             ALSource->HrtfCounter = 0;
rlm@0:         }
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         for(c = 0;c < num_channels;c++)
rlm@0:         {
rlm@0:             if(chans[c] == LFE) /* Special-case LFE */
rlm@0:             {
rlm@0:                 SrcMatrix[c][LFE] += DryGain * ListenerGain;
rlm@0:                 continue;
rlm@0:             }
rlm@0:             pos = aluCart2LUTpos(cos(angles[c] * (M_PI/180.0)),
rlm@0:                                  sin(angles[c] * (M_PI/180.0)));
rlm@0:             SpeakerGain = Device->PanningLUT[pos];
rlm@0: 
rlm@0:             for(i = 0;i < (ALint)Device->NumChan;i++)
rlm@0:             {
rlm@0:                 enum Channel chan = Device->Speaker2Chan[i];
rlm@0:                 SrcMatrix[c][chan] += DryGain * ListenerGain *
rlm@0:                                       SpeakerGain[chan];
rlm@0:             }
rlm@0:         }
rlm@0:     }
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:     {
rlm@0:         ALSource->Params.Send[i].Slot = ALSource->Send[i].Slot;
rlm@0:         ALSource->Params.Send[i].WetGain = WetGain[i] * ListenerGain;
rlm@0:     }
rlm@0: 
rlm@0:     /* Update filter coefficients. Calculations based on the I3DL2
rlm@0:      * spec. */
rlm@0:     cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);
rlm@0: 
rlm@0:     /* We use two chained one-pole filters, so we need to take the
rlm@0:      * square root of the squared gain, which is the same as the base
rlm@0:      * gain. */
rlm@0:     ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:     {
rlm@0:         /* We use a one-pole filter, so we need to take the squared gain */
rlm@0:         ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
rlm@0:         ALSource->Params.Send[i].iirFilter.coeff = a;
rlm@0:     }
rlm@0: }
rlm@0: 
rlm@0: ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
rlm@0: {
rlm@0:     const ALCdevice *Device = ALContext->Device;
rlm@0:     ALfloat InnerAngle,OuterAngle,Angle,Distance,ClampedDist;
rlm@0:     ALfloat Direction[3],Position[3],SourceToListener[3];
rlm@0:     ALfloat Velocity[3],ListenerVel[3];
rlm@0:     ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;
rlm@0:     ALfloat ConeVolume,ConeHF,SourceVolume,ListenerGain;
rlm@0:     ALfloat DopplerFactor, DopplerVelocity, SpeedOfSound;
rlm@0:     ALfloat AirAbsorptionFactor;
rlm@0:     ALfloat RoomAirAbsorption[MAX_SENDS];
rlm@0:     ALbufferlistitem *BufferListItem;
rlm@0:     ALfloat Attenuation, EffectiveDist;
rlm@0:     ALfloat RoomAttenuation[MAX_SENDS];
rlm@0:     ALfloat MetersPerUnit;
rlm@0:     ALfloat RoomRolloffBase;
rlm@0:     ALfloat RoomRolloff[MAX_SENDS];
rlm@0:     ALfloat DecayDistance[MAX_SENDS];
rlm@0:     ALfloat DryGain;
rlm@0:     ALfloat DryGainHF;
rlm@0:     ALboolean DryGainHFAuto;
rlm@0:     ALfloat WetGain[MAX_SENDS];
rlm@0:     ALfloat WetGainHF[MAX_SENDS];
rlm@0:     ALboolean WetGainAuto;
rlm@0:     ALboolean WetGainHFAuto;
rlm@0:     enum Resampler Resampler;
rlm@0:     ALfloat Pitch;
rlm@0:     ALuint Frequency;
rlm@0:     ALint NumSends;
rlm@0:     ALfloat cw;
rlm@0:     ALint i;
rlm@0: 
rlm@0:     DryGainHF = 1.0f;
rlm@0:     for(i = 0;i < MAX_SENDS;i++)
rlm@0:         WetGainHF[i] = 1.0f;
rlm@0: 
rlm@0:     //Get context properties
rlm@0:     DopplerFactor   = ALContext->DopplerFactor * ALSource->DopplerFactor;
rlm@0:     DopplerVelocity = ALContext->DopplerVelocity;
rlm@0:     SpeedOfSound    = ALContext->flSpeedOfSound;
rlm@0:     NumSends        = Device->NumAuxSends;
rlm@0:     Frequency       = Device->Frequency;
rlm@0: 
rlm@0:     //Get listener properties
rlm@0:     ListenerGain = ALContext->Listener.Gain;
rlm@0:     MetersPerUnit = ALContext->Listener.MetersPerUnit;
rlm@0:     memcpy(ListenerVel, ALContext->Listener.Velocity, sizeof(ALContext->Listener.Velocity));
rlm@0: 
rlm@0:     //Get source properties
rlm@0:     SourceVolume = ALSource->flGain;
rlm@0:     MinVolume    = ALSource->flMinGain;
rlm@0:     MaxVolume    = ALSource->flMaxGain;
rlm@0:     Pitch        = ALSource->flPitch;
rlm@0:     Resampler    = ALSource->Resampler;
rlm@0:     memcpy(Position,  ALSource->vPosition,    sizeof(ALSource->vPosition));
rlm@0:     memcpy(Direction, ALSource->vOrientation, sizeof(ALSource->vOrientation));
rlm@0:     memcpy(Velocity,  ALSource->vVelocity,    sizeof(ALSource->vVelocity));
rlm@0:     MinDist = ALSource->flRefDistance;
rlm@0:     MaxDist = ALSource->flMaxDistance;
rlm@0:     Rolloff = ALSource->flRollOffFactor;
rlm@0:     InnerAngle = ALSource->flInnerAngle * ConeScale;
rlm@0:     OuterAngle = ALSource->flOuterAngle * ConeScale;
rlm@0:     AirAbsorptionFactor = ALSource->AirAbsorptionFactor;
rlm@0:     DryGainHFAuto = ALSource->DryGainHFAuto;
rlm@0:     WetGainAuto   = ALSource->WetGainAuto;
rlm@0:     WetGainHFAuto = ALSource->WetGainHFAuto;
rlm@0:     RoomRolloffBase = ALSource->RoomRolloffFactor;
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:     {
rlm@0:         ALeffectslot *Slot = ALSource->Send[i].Slot;
rlm@0: 
rlm@0:         if(!Slot || Slot->effect.type == AL_EFFECT_NULL)
rlm@0:         {
rlm@0:             RoomRolloff[i] = 0.0f;
rlm@0:             DecayDistance[i] = 0.0f;
rlm@0:             RoomAirAbsorption[i] = 1.0f;
rlm@0:         }
rlm@0:         else if(Slot->AuxSendAuto)
rlm@0:         {
rlm@0:             RoomRolloff[i] = RoomRolloffBase;
rlm@0:             if(IsReverbEffect(Slot->effect.type))
rlm@0:             {
rlm@0:                 RoomRolloff[i] += Slot->effect.Params.Reverb.RoomRolloffFactor;
rlm@0:                 DecayDistance[i] = Slot->effect.Params.Reverb.DecayTime *
rlm@0:                                    SPEEDOFSOUNDMETRESPERSEC;
rlm@0:                 RoomAirAbsorption[i] = Slot->effect.Params.Reverb.AirAbsorptionGainHF;
rlm@0:             }
rlm@0:             else
rlm@0:             {
rlm@0:                 DecayDistance[i] = 0.0f;
rlm@0:                 RoomAirAbsorption[i] = 1.0f;
rlm@0:             }
rlm@0:         }
rlm@0:         else
rlm@0:         {
rlm@0:             /* If the slot's auxiliary send auto is off, the data sent to the
rlm@0:              * effect slot is the same as the dry path, sans filter effects */
rlm@0:             RoomRolloff[i] = Rolloff;
rlm@0:             DecayDistance[i] = 0.0f;
rlm@0:             RoomAirAbsorption[i] = AIRABSORBGAINHF;
rlm@0:         }
rlm@0: 
rlm@0:         ALSource->Params.Send[i].Slot = Slot;
rlm@0:     }
rlm@0: 
rlm@0:     //1. Translate Listener to origin (convert to head relative)
rlm@0:     if(ALSource->bHeadRelative == AL_FALSE)
rlm@0:     {
rlm@0:         ALfloat U[3],V[3],N[3];
rlm@0:         ALfloat Matrix[4][4];
rlm@0: 
rlm@0:         // Build transform matrix
rlm@0:         memcpy(N, ALContext->Listener.Forward, sizeof(N));  // At-vector
rlm@0:         aluNormalize(N);  // Normalized At-vector
rlm@0:         memcpy(V, ALContext->Listener.Up, sizeof(V));  // Up-vector
rlm@0:         aluNormalize(V);  // Normalized Up-vector
rlm@0:         aluCrossproduct(N, V, U); // Right-vector
rlm@0:         aluNormalize(U);  // Normalized Right-vector
rlm@0:         Matrix[0][0] = U[0]; Matrix[0][1] = V[0]; Matrix[0][2] = -N[0]; Matrix[0][3] = 0.0f;
rlm@0:         Matrix[1][0] = U[1]; Matrix[1][1] = V[1]; Matrix[1][2] = -N[1]; Matrix[1][3] = 0.0f;
rlm@0:         Matrix[2][0] = U[2]; Matrix[2][1] = V[2]; Matrix[2][2] = -N[2]; Matrix[2][3] = 0.0f;
rlm@0:         Matrix[3][0] = 0.0f; Matrix[3][1] = 0.0f; Matrix[3][2] =  0.0f; Matrix[3][3] = 1.0f;
rlm@0: 
rlm@0:         // Translate position
rlm@0:         Position[0] -= ALContext->Listener.Position[0];
rlm@0:         Position[1] -= ALContext->Listener.Position[1];
rlm@0:         Position[2] -= ALContext->Listener.Position[2];
rlm@0: 
rlm@0:         // Transform source position and direction into listener space
rlm@0:         aluMatrixVector(Position, 1.0f, Matrix);
rlm@0:         aluMatrixVector(Direction, 0.0f, Matrix);
rlm@0:         // Transform source and listener velocity into listener space
rlm@0:         aluMatrixVector(Velocity, 0.0f, Matrix);
rlm@0:         aluMatrixVector(ListenerVel, 0.0f, Matrix);
rlm@0:     }
rlm@0:     else
rlm@0:         ListenerVel[0] = ListenerVel[1] = ListenerVel[2] = 0.0f;
rlm@0: 
rlm@0:     SourceToListener[0] = -Position[0];
rlm@0:     SourceToListener[1] = -Position[1];
rlm@0:     SourceToListener[2] = -Position[2];
rlm@0:     aluNormalize(SourceToListener);
rlm@0:     aluNormalize(Direction);
rlm@0: 
rlm@0:     //2. Calculate distance attenuation
rlm@0:     Distance = aluSqrt(aluDotproduct(Position, Position));
rlm@0:     ClampedDist = Distance;
rlm@0: 
rlm@0:     Attenuation = 1.0f;
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:         RoomAttenuation[i] = 1.0f;
rlm@0:     switch(ALContext->SourceDistanceModel ? ALSource->DistanceModel :
rlm@0:                                             ALContext->DistanceModel)
rlm@0:     {
rlm@0:         case InverseDistanceClamped:
rlm@0:             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
rlm@0:             if(MaxDist < MinDist)
rlm@0:                 break;
rlm@0:             //fall-through
rlm@0:         case InverseDistance:
rlm@0:             if(MinDist > 0.0f)
rlm@0:             {
rlm@0:                 if((MinDist + (Rolloff * (ClampedDist - MinDist))) > 0.0f)
rlm@0:                     Attenuation = MinDist / (MinDist + (Rolloff * (ClampedDist - MinDist)));
rlm@0:                 for(i = 0;i < NumSends;i++)
rlm@0:                 {
rlm@0:                     if((MinDist + (RoomRolloff[i] * (ClampedDist - MinDist))) > 0.0f)
rlm@0:                         RoomAttenuation[i] = MinDist / (MinDist + (RoomRolloff[i] * (ClampedDist - MinDist)));
rlm@0:                 }
rlm@0:             }
rlm@0:             break;
rlm@0: 
rlm@0:         case LinearDistanceClamped:
rlm@0:             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
rlm@0:             if(MaxDist < MinDist)
rlm@0:                 break;
rlm@0:             //fall-through
rlm@0:         case LinearDistance:
rlm@0:             if(MaxDist != MinDist)
rlm@0:             {
rlm@0:                 Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));
rlm@0:                 Attenuation = maxf(Attenuation, 0.0f);
rlm@0:                 for(i = 0;i < NumSends;i++)
rlm@0:                 {
rlm@0:                     RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));
rlm@0:                     RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);
rlm@0:                 }
rlm@0:             }
rlm@0:             break;
rlm@0: 
rlm@0:         case ExponentDistanceClamped:
rlm@0:             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
rlm@0:             if(MaxDist < MinDist)
rlm@0:                 break;
rlm@0:             //fall-through
rlm@0:         case ExponentDistance:
rlm@0:             if(ClampedDist > 0.0f && MinDist > 0.0f)
rlm@0:             {
rlm@0:                 Attenuation = aluPow(ClampedDist/MinDist, -Rolloff);
rlm@0:                 for(i = 0;i < NumSends;i++)
rlm@0:                     RoomAttenuation[i] = aluPow(ClampedDist/MinDist, -RoomRolloff[i]);
rlm@0:             }
rlm@0:             break;
rlm@0: 
rlm@0:         case DisableDistance:
rlm@0:             break;
rlm@0:     }
rlm@0: 
rlm@0:     // Source Gain + Attenuation
rlm@0:     DryGain = SourceVolume * Attenuation;
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:         WetGain[i] = SourceVolume * RoomAttenuation[i];
rlm@0: 
rlm@0:     // Distance-based air absorption
rlm@0:     EffectiveDist = 0.0f;
rlm@0:     if(MinDist > 0.0f && Attenuation < 1.0f)
rlm@0:         EffectiveDist = (MinDist/Attenuation - MinDist)*MetersPerUnit;
rlm@0:     if(AirAbsorptionFactor > 0.0f && EffectiveDist > 0.0f)
rlm@0:     {
rlm@0:         DryGainHF *= aluPow(AIRABSORBGAINHF, AirAbsorptionFactor*EffectiveDist);
rlm@0:         for(i = 0;i < NumSends;i++)
rlm@0:             WetGainHF[i] *= aluPow(RoomAirAbsorption[i],
rlm@0:                                    AirAbsorptionFactor*EffectiveDist);
rlm@0:     }
rlm@0: 
rlm@0:     //3. Apply directional soundcones
rlm@0:     Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * (180.0/M_PI);
rlm@0:     if(Angle >= InnerAngle && Angle <= OuterAngle)
rlm@0:     {
rlm@0:         ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
rlm@0:         ConeVolume = lerp(1.0, ALSource->flOuterGain, scale);
rlm@0:         ConeHF = lerp(1.0, ALSource->OuterGainHF, scale);
rlm@0:     }
rlm@0:     else if(Angle > OuterAngle)
rlm@0:     {
rlm@0:         ConeVolume = ALSource->flOuterGain;
rlm@0:         ConeHF = ALSource->OuterGainHF;
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         ConeVolume = 1.0f;
rlm@0:         ConeHF = 1.0f;
rlm@0:     }
rlm@0: 
rlm@0:     DryGain *= ConeVolume;
rlm@0:     if(WetGainAuto)
rlm@0:     {
rlm@0:         for(i = 0;i < NumSends;i++)
rlm@0:             WetGain[i] *= ConeVolume;
rlm@0:     }
rlm@0:     if(DryGainHFAuto)
rlm@0:         DryGainHF *= ConeHF;
rlm@0:     if(WetGainHFAuto)
rlm@0:     {
rlm@0:         for(i = 0;i < NumSends;i++)
rlm@0:             WetGainHF[i] *= ConeHF;
rlm@0:     }
rlm@0: 
rlm@0:     // Clamp to Min/Max Gain
rlm@0:     DryGain = clampf(DryGain, MinVolume, MaxVolume);
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:         WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);
rlm@0: 
rlm@0:     // Apply filter gains and filters
rlm@0:     switch(ALSource->DirectFilter.type)
rlm@0:     {
rlm@0:         case AL_FILTER_LOWPASS:
rlm@0:             DryGain *= ALSource->DirectFilter.Gain;
rlm@0:             DryGainHF *= ALSource->DirectFilter.GainHF;
rlm@0:             break;
rlm@0:     }
rlm@0:     DryGain *= ListenerGain;
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:     {
rlm@0:         switch(ALSource->Send[i].WetFilter.type)
rlm@0:         {
rlm@0:             case AL_FILTER_LOWPASS:
rlm@0:                 WetGain[i] *= ALSource->Send[i].WetFilter.Gain;
rlm@0:                 WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;
rlm@0:                 break;
rlm@0:         }
rlm@0:         WetGain[i] *= ListenerGain;
rlm@0:     }
rlm@0: 
rlm@0:     if(WetGainAuto)
rlm@0:     {
rlm@0:         /* Apply a decay-time transformation to the wet path, based on the
rlm@0:          * attenuation of the dry path.
rlm@0:          *
rlm@0:          * Using the approximate (effective) source to listener distance, the
rlm@0:          * initial decay of the reverb effect is calculated and applied to the
rlm@0:          * wet path.
rlm@0:          */
rlm@0:         for(i = 0;i < NumSends;i++)
rlm@0:         {
rlm@0:             if(DecayDistance[i] > 0.0f)
rlm@0:                 WetGain[i] *= aluPow(0.001f /* -60dB */,
rlm@0:                                      EffectiveDist / DecayDistance[i]);
rlm@0:         }
rlm@0:     }
rlm@0: 
rlm@0:     // Calculate Velocity
rlm@0:     if(DopplerFactor != 0.0f)
rlm@0:     {
rlm@0:         ALfloat VSS, VLS;
rlm@0:         ALfloat MaxVelocity = (SpeedOfSound*DopplerVelocity) /
rlm@0:                               DopplerFactor;
rlm@0: 
rlm@0:         VSS = aluDotproduct(Velocity, SourceToListener);
rlm@0:         if(VSS >= MaxVelocity)
rlm@0:             VSS = (MaxVelocity - 1.0f);
rlm@0:         else if(VSS <= -MaxVelocity)
rlm@0:             VSS = -MaxVelocity + 1.0f;
rlm@0: 
rlm@0:         VLS = aluDotproduct(ListenerVel, SourceToListener);
rlm@0:         if(VLS >= MaxVelocity)
rlm@0:             VLS = (MaxVelocity - 1.0f);
rlm@0:         else if(VLS <= -MaxVelocity)
rlm@0:             VLS = -MaxVelocity + 1.0f;
rlm@0: 
rlm@0:         Pitch *= ((SpeedOfSound*DopplerVelocity) - (DopplerFactor*VLS)) /
rlm@0:                  ((SpeedOfSound*DopplerVelocity) - (DopplerFactor*VSS));
rlm@0:     }
rlm@0: 
rlm@0:     BufferListItem = ALSource->queue;
rlm@0:     while(BufferListItem != NULL)
rlm@0:     {
rlm@0:         ALbuffer *ALBuffer;
rlm@0:         if((ALBuffer=BufferListItem->buffer) != NULL)
rlm@0:         {
rlm@0:             ALint maxstep = STACK_DATA_SIZE / ALSource->NumChannels /
rlm@0:                                               ALSource->SampleSize;
rlm@0:             maxstep -= ResamplerPadding[Resampler] +
rlm@0:                        ResamplerPrePadding[Resampler] + 1;
rlm@0:             maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
rlm@0: 
rlm@0:             Pitch = Pitch * ALBuffer->Frequency / Frequency;
rlm@0:             if(Pitch > (ALfloat)maxstep)
rlm@0:                 ALSource->Params.Step = maxstep<<FRACTIONBITS;
rlm@0:             else
rlm@0:             {
rlm@0:                 ALSource->Params.Step = Pitch*FRACTIONONE;
rlm@0:                 if(ALSource->Params.Step == 0)
rlm@0:                     ALSource->Params.Step = 1;
rlm@0:             }
rlm@0: 
rlm@0:             if((Device->Flags&DEVICE_USE_HRTF))
rlm@0:                 ALSource->Params.DoMix = SelectHrtfMixer(ALBuffer,
rlm@0:                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
rlm@0:                                                               Resampler);
rlm@0:             else
rlm@0:                 ALSource->Params.DoMix = SelectMixer(ALBuffer,
rlm@0:                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
rlm@0:                                                               Resampler);
rlm@0:             break;
rlm@0:         }
rlm@0:         BufferListItem = BufferListItem->next;
rlm@0:     }
rlm@0: 
rlm@0:     if((Device->Flags&DEVICE_USE_HRTF))
rlm@0:     {
rlm@0:         // Use a binaural HRTF algorithm for stereo headphone playback
rlm@0:         ALfloat delta, ev = 0.0f, az = 0.0f;
rlm@0: 
rlm@0:         if(Distance > 0.0f)
rlm@0:         {
rlm@0:             ALfloat invlen = 1.0f/Distance;
rlm@0:             Position[0] *= invlen;
rlm@0:             Position[1] *= invlen;
rlm@0:             Position[2] *= invlen;
rlm@0: 
rlm@0:             // Calculate elevation and azimuth only when the source is not at
rlm@0:             // the listener.  This prevents +0 and -0 Z from producing
rlm@0:             // inconsistent panning.
rlm@0:             ev = asin(Position[1]);
rlm@0:             az = atan2(Position[0], -Position[2]*ZScale);
rlm@0:         }
rlm@0: 
rlm@0:         // Check to see if the HRIR is already moving.
rlm@0:         if(ALSource->HrtfMoving)
rlm@0:         {
rlm@0:             // Calculate the normalized HRTF transition factor (delta).
rlm@0:             delta = CalcHrtfDelta(ALSource->Params.HrtfGain, DryGain,
rlm@0:                                   ALSource->Params.HrtfDir, Position);
rlm@0:             // If the delta is large enough, get the moving HRIR target
rlm@0:             // coefficients, target delays, steppping values, and counter.
rlm@0:             if(delta > 0.001f)
rlm@0:             {
rlm@0:                 ALSource->HrtfCounter = GetMovingHrtfCoeffs(ev, az, DryGain,
rlm@0:                                           delta, ALSource->HrtfCounter,
rlm@0:                                           ALSource->Params.HrtfCoeffs[0],
rlm@0:                                           ALSource->Params.HrtfDelay[0],
rlm@0:                                           ALSource->Params.HrtfCoeffStep,
rlm@0:                                           ALSource->Params.HrtfDelayStep);
rlm@0:                 ALSource->Params.HrtfGain = DryGain;
rlm@0:                 ALSource->Params.HrtfDir[0] = Position[0];
rlm@0:                 ALSource->Params.HrtfDir[1] = Position[1];
rlm@0:                 ALSource->Params.HrtfDir[2] = Position[2];
rlm@0:             }
rlm@0:         }
rlm@0:         else
rlm@0:         {
rlm@0:             // Get the initial (static) HRIR coefficients and delays.
rlm@0:             GetLerpedHrtfCoeffs(ev, az, DryGain,
rlm@0:                                 ALSource->Params.HrtfCoeffs[0],
rlm@0:                                 ALSource->Params.HrtfDelay[0]);
rlm@0:             ALSource->HrtfCounter = 0;
rlm@0:             ALSource->Params.HrtfGain = DryGain;
rlm@0:             ALSource->Params.HrtfDir[0] = Position[0];
rlm@0:             ALSource->Params.HrtfDir[1] = Position[1];
rlm@0:             ALSource->Params.HrtfDir[2] = Position[2];
rlm@0:         }
rlm@0:     }
rlm@0:     else
rlm@0:     {
rlm@0:         // Use energy-preserving panning algorithm for multi-speaker playback
rlm@0:         ALfloat DirGain, AmbientGain;
rlm@0:         const ALfloat *SpeakerGain;
rlm@0:         ALfloat length;
rlm@0:         ALint pos;
rlm@0: 
rlm@0:         length = maxf(Distance, MinDist);
rlm@0:         if(length > 0.0f)
rlm@0:         {
rlm@0:             ALfloat invlen = 1.0f/length;
rlm@0:             Position[0] *= invlen;
rlm@0:             Position[1] *= invlen;
rlm@0:             Position[2] *= invlen;
rlm@0:         }
rlm@0: 
rlm@0:         pos = aluCart2LUTpos(-Position[2]*ZScale, Position[0]);
rlm@0:         SpeakerGain = Device->PanningLUT[pos];
rlm@0: 
rlm@0:         DirGain = aluSqrt(Position[0]*Position[0] + Position[2]*Position[2]);
rlm@0:         // elevation adjustment for directional gain. this sucks, but
rlm@0:         // has low complexity
rlm@0:         AmbientGain = aluSqrt(1.0/Device->NumChan);
rlm@0:         for(i = 0;i < MAXCHANNELS;i++)
rlm@0:         {
rlm@0:             ALuint i2;
rlm@0:             for(i2 = 0;i2 < MAXCHANNELS;i2++)
rlm@0:                 ALSource->Params.DryGains[i][i2] = 0.0f;
rlm@0:         }
rlm@0:         for(i = 0;i < (ALint)Device->NumChan;i++)
rlm@0:         {
rlm@0:             enum Channel chan = Device->Speaker2Chan[i];
rlm@0:             ALfloat gain = lerp(AmbientGain, SpeakerGain[chan], DirGain);
rlm@0:             ALSource->Params.DryGains[0][chan] = DryGain * gain;
rlm@0:         }
rlm@0:     }
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:         ALSource->Params.Send[i].WetGain = WetGain[i];
rlm@0: 
rlm@0:     /* Update filter coefficients. */
rlm@0:     cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);
rlm@0: 
rlm@0:     ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
rlm@0:     for(i = 0;i < NumSends;i++)
rlm@0:     {
rlm@0:         ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
rlm@0:         ALSource->Params.Send[i].iirFilter.coeff = a;
rlm@0:     }
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: static __inline ALfloat aluF2F(ALfloat val)
rlm@0: { return val; }
rlm@0: static __inline ALshort aluF2S(ALfloat val)
rlm@0: {
rlm@0:     if(val > 1.0f) return 32767;
rlm@0:     if(val < -1.0f) return -32768;
rlm@0:     return (ALint)(val*32767.0f);
rlm@0: }
rlm@0: static __inline ALushort aluF2US(ALfloat val)
rlm@0: { return aluF2S(val)+32768; }
rlm@0: static __inline ALbyte aluF2B(ALfloat val)
rlm@0: { return aluF2S(val)>>8; }
rlm@0: static __inline ALubyte aluF2UB(ALfloat val)
rlm@0: { return aluF2US(val)>>8; }
rlm@0: 
rlm@0: #define DECL_TEMPLATE(T, N, func)                                             \
rlm@0: static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer,            \
rlm@0:                             ALuint SamplesToDo)                               \
rlm@0: {                                                                             \
rlm@0:     ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer;           \
rlm@0:     const enum Channel *ChanMap = device->DevChannels;                        \
rlm@0:     ALuint i, j;                                                              \
rlm@0:                                                                               \
rlm@0:     for(i = 0;i < SamplesToDo;i++)                                            \
rlm@0:     {                                                                         \
rlm@0:         for(j = 0;j < N;j++)                                                  \
rlm@0:             *(buffer++) = func(DryBuffer[i][ChanMap[j]]);                     \
rlm@0:     }                                                                         \
rlm@0: }
rlm@0: 
rlm@0: DECL_TEMPLATE(ALfloat, 1, aluF2F)
rlm@0: DECL_TEMPLATE(ALfloat, 4, aluF2F)
rlm@0: DECL_TEMPLATE(ALfloat, 6, aluF2F)
rlm@0: DECL_TEMPLATE(ALfloat, 7, aluF2F)
rlm@0: DECL_TEMPLATE(ALfloat, 8, aluF2F)
rlm@0: 
rlm@0: DECL_TEMPLATE(ALushort, 1, aluF2US)
rlm@0: DECL_TEMPLATE(ALushort, 4, aluF2US)
rlm@0: DECL_TEMPLATE(ALushort, 6, aluF2US)
rlm@0: DECL_TEMPLATE(ALushort, 7, aluF2US)
rlm@0: DECL_TEMPLATE(ALushort, 8, aluF2US)
rlm@0: 
rlm@0: DECL_TEMPLATE(ALshort, 1, aluF2S)
rlm@0: DECL_TEMPLATE(ALshort, 4, aluF2S)
rlm@0: DECL_TEMPLATE(ALshort, 6, aluF2S)
rlm@0: DECL_TEMPLATE(ALshort, 7, aluF2S)
rlm@0: DECL_TEMPLATE(ALshort, 8, aluF2S)
rlm@0: 
rlm@0: DECL_TEMPLATE(ALubyte, 1, aluF2UB)
rlm@0: DECL_TEMPLATE(ALubyte, 4, aluF2UB)
rlm@0: DECL_TEMPLATE(ALubyte, 6, aluF2UB)
rlm@0: DECL_TEMPLATE(ALubyte, 7, aluF2UB)
rlm@0: DECL_TEMPLATE(ALubyte, 8, aluF2UB)
rlm@0: 
rlm@0: DECL_TEMPLATE(ALbyte, 1, aluF2B)
rlm@0: DECL_TEMPLATE(ALbyte, 4, aluF2B)
rlm@0: DECL_TEMPLATE(ALbyte, 6, aluF2B)
rlm@0: DECL_TEMPLATE(ALbyte, 7, aluF2B)
rlm@0: DECL_TEMPLATE(ALbyte, 8, aluF2B)
rlm@0: 
rlm@0: #undef DECL_TEMPLATE
rlm@0: 
rlm@0: #define DECL_TEMPLATE(T, N, func)                                             \
rlm@0: static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer,            \
rlm@0:                             ALuint SamplesToDo)                               \
rlm@0: {                                                                             \
rlm@0:     ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer;           \
rlm@0:     const enum Channel *ChanMap = device->DevChannels;                        \
rlm@0:     ALuint i, j;                                                              \
rlm@0:                                                                               \
rlm@0:     if(device->Bs2b)                                                          \
rlm@0:     {                                                                         \
rlm@0:         for(i = 0;i < SamplesToDo;i++)                                        \
rlm@0:         {                                                                     \
rlm@0:             float samples[2];                                                 \
rlm@0:             samples[0] = DryBuffer[i][ChanMap[0]];                            \
rlm@0:             samples[1] = DryBuffer[i][ChanMap[1]];                            \
rlm@0:             bs2b_cross_feed(device->Bs2b, samples);                           \
rlm@0:             *(buffer++) = func(samples[0]);                                   \
rlm@0:             *(buffer++) = func(samples[1]);                                   \
rlm@0:         }                                                                     \
rlm@0:     }                                                                         \
rlm@0:     else                                                                      \
rlm@0:     {                                                                         \
rlm@0:         for(i = 0;i < SamplesToDo;i++)                                        \
rlm@0:         {                                                                     \
rlm@0:             for(j = 0;j < N;j++)                                              \
rlm@0:                 *(buffer++) = func(DryBuffer[i][ChanMap[j]]);                 \
rlm@0:         }                                                                     \
rlm@0:     }                                                                         \
rlm@0: }
rlm@0: 
rlm@0: DECL_TEMPLATE(ALfloat, 2, aluF2F)
rlm@0: DECL_TEMPLATE(ALushort, 2, aluF2US)
rlm@0: DECL_TEMPLATE(ALshort, 2, aluF2S)
rlm@0: DECL_TEMPLATE(ALubyte, 2, aluF2UB)
rlm@0: DECL_TEMPLATE(ALbyte, 2, aluF2B)
rlm@0: 
rlm@0: #undef DECL_TEMPLATE
rlm@0: 
rlm@0: #define DECL_TEMPLATE(T)                                                      \
rlm@0: static void Write_##T(ALCdevice *device, T *buffer, ALuint SamplesToDo)       \
rlm@0: {                                                                             \
rlm@0:     switch(device->FmtChans)                                                  \
rlm@0:     {                                                                         \
rlm@0:         case DevFmtMono:                                                      \
rlm@0:             Write_##T##_1(device, buffer, SamplesToDo);                       \
rlm@0:             break;                                                            \
rlm@0:         case DevFmtStereo:                                                    \
rlm@0:             Write_##T##_2(device, buffer, SamplesToDo);                       \
rlm@0:             break;                                                            \
rlm@0:         case DevFmtQuad:                                                      \
rlm@0:             Write_##T##_4(device, buffer, SamplesToDo);                       \
rlm@0:             break;                                                            \
rlm@0:         case DevFmtX51:                                                       \
rlm@0:         case DevFmtX51Side:                                                   \
rlm@0:             Write_##T##_6(device, buffer, SamplesToDo);                       \
rlm@0:             break;                                                            \
rlm@0:         case DevFmtX61:                                                       \
rlm@0:             Write_##T##_7(device, buffer, SamplesToDo);                       \
rlm@0:             break;                                                            \
rlm@0:         case DevFmtX71:                                                       \
rlm@0:             Write_##T##_8(device, buffer, SamplesToDo);                       \
rlm@0:             break;                                                            \
rlm@0:     }                                                                         \
rlm@0: }
rlm@0: 
rlm@0: DECL_TEMPLATE(ALfloat)
rlm@0: DECL_TEMPLATE(ALushort)
rlm@0: DECL_TEMPLATE(ALshort)
rlm@0: DECL_TEMPLATE(ALubyte)
rlm@0: DECL_TEMPLATE(ALbyte)
rlm@0: 
rlm@0: #undef DECL_TEMPLATE
rlm@0: 
rlm@0: ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
rlm@0: {
rlm@0:     ALuint SamplesToDo;
rlm@0:     ALeffectslot *ALEffectSlot;
rlm@0:     ALCcontext **ctx, **ctx_end;
rlm@0:     ALsource **src, **src_end;
rlm@0:     int fpuState;
rlm@0:     ALuint i, c;
rlm@0:     ALsizei e;
rlm@0: 
rlm@0: #if defined(HAVE_FESETROUND)
rlm@0:     fpuState = fegetround();
rlm@0:     fesetround(FE_TOWARDZERO);
rlm@0: #elif defined(HAVE__CONTROLFP)
rlm@0:     fpuState = _controlfp(0, 0);
rlm@0:     (void)_controlfp(_RC_CHOP, _MCW_RC);
rlm@0: #else
rlm@0:     (void)fpuState;
rlm@0: #endif
rlm@0: 
rlm@0:     while(size > 0)
rlm@0:     {
rlm@0:         /* Setup variables */
rlm@0:         SamplesToDo = minu(size, BUFFERSIZE);
rlm@0: 
rlm@0:         /* Clear mixing buffer */
rlm@0:         memset(device->DryBuffer, 0, SamplesToDo*MAXCHANNELS*sizeof(ALfloat));
rlm@0: 
rlm@0:         LockDevice(device);
rlm@0:         ctx = device->Contexts;
rlm@0:         ctx_end = ctx + device->NumContexts;
rlm@0: 	//printf("Contexts: %d\n", device->NumContexts);
rlm@0: 	int context_number = 0;
rlm@0:         while(ctx != ctx_end)
rlm@0: 	  {
rlm@0: 	    //printf("Context %d:\n", context_number++);
rlm@0:             ALboolean DeferUpdates = (*ctx)->DeferUpdates;
rlm@0:             ALboolean UpdateSources = AL_FALSE;
rlm@0: 
rlm@0:             if(!DeferUpdates)
rlm@0:             {
rlm@0: 	      //printf("NOT deferring updates, whatever that means\n");
rlm@0:                 UpdateSources = (*ctx)->UpdateSources;
rlm@0: 		//printf("update sources is set to %d\n", UpdateSources);
rlm@0:                 (*ctx)->UpdateSources = AL_FALSE;
rlm@0:             }
rlm@0: 
rlm@0:             src = (*ctx)->ActiveSources;
rlm@0:             src_end = src + (*ctx)->ActiveSourceCount;
rlm@0: 	    //printf("number of active sources are %d\n", (*ctx)->ActiveSourceCount);
rlm@0:             while(src != src_end)
rlm@0:             {
rlm@0:  	        
rlm@0:                 if((*src)->state != AL_PLAYING)
rlm@0:                 {
rlm@0:                     --((*ctx)->ActiveSourceCount);
rlm@0:                     *src = *(--src_end);
rlm@0:                     continue;
rlm@0:                 }
rlm@0: 
rlm@0:                 if(!DeferUpdates && ((*src)->NeedsUpdate || UpdateSources))
rlm@0:                 {
rlm@0:                     (*src)->NeedsUpdate = AL_FALSE;
rlm@0:                     ALsource_Update(*src, *ctx);
rlm@0:                 }
rlm@0: 		//printf("calling MixSource!\n");
rlm@0:                 MixSource(*src, device, SamplesToDo);
rlm@0:                 src++;
rlm@0:             }
rlm@0: 
rlm@0:             /* effect slot processing */
rlm@0:             for(e = 0;e < (*ctx)->EffectSlotMap.size;e++)
rlm@0:             {
rlm@0:                 ALEffectSlot = (*ctx)->EffectSlotMap.array[e].value;
rlm@0: 
rlm@0:                 for(i = 0;i < SamplesToDo;i++)
rlm@0:                 {
rlm@0: 		  // RLM: remove click-removal
rlm@0: 		  ALEffectSlot->WetBuffer[i] += ALEffectSlot->ClickRemoval[0];
rlm@0: 		  ALEffectSlot->ClickRemoval[0] -= ALEffectSlot->ClickRemoval[0] / 256.0f;
rlm@0:                 }
rlm@0:                 for(i = 0;i < 1;i++)
rlm@0:                 {
rlm@0: 		  // RLM: remove click-removal
rlm@0: 		  ALEffectSlot->ClickRemoval[i] += ALEffectSlot->PendingClicks[i];
rlm@0: 		  ALEffectSlot->PendingClicks[i] = 0.0f;
rlm@0:                 }
rlm@0: 
rlm@0:                 if(!DeferUpdates && ALEffectSlot->NeedsUpdate)
rlm@0:                 {
rlm@0:                     ALEffectSlot->NeedsUpdate = AL_FALSE;
rlm@0:                     ALEffect_Update(ALEffectSlot->EffectState, *ctx, ALEffectSlot);
rlm@0:                 }
rlm@0: 
rlm@0:                 ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot,
rlm@0:                                  SamplesToDo, ALEffectSlot->WetBuffer,
rlm@0:                                  device->DryBuffer);
rlm@0: 
rlm@0:                 for(i = 0;i < SamplesToDo;i++)
rlm@0:                     ALEffectSlot->WetBuffer[i] = 0.0f;
rlm@0:             }
rlm@0: 
rlm@0:             ctx++;
rlm@0:         }
rlm@0:         UnlockDevice(device);
rlm@0: 
rlm@0:         //Post processing loop
rlm@0:         if(device->FmtChans == DevFmtMono)
rlm@0:         {
rlm@0:             for(i = 0;i < SamplesToDo;i++)
rlm@0:             {
rlm@0: 	      // RLM: remove click-removal
rlm@0: 	      device->DryBuffer[i][FRONT_CENTER] += device->ClickRemoval[FRONT_CENTER];
rlm@0: 	      device->ClickRemoval[FRONT_CENTER] -= device->ClickRemoval[FRONT_CENTER] / 256.0f;
rlm@0:             }
rlm@0: 	    // RLM: remove click-removal
rlm@0:             device->ClickRemoval[FRONT_CENTER] += device->PendingClicks[FRONT_CENTER];
rlm@0:             device->PendingClicks[FRONT_CENTER] = 0.0f;
rlm@0:         }
rlm@0:         else if(device->FmtChans == DevFmtStereo)
rlm@0:         {
rlm@0:             /* Assumes the first two channels are FRONT_LEFT and FRONT_RIGHT */
rlm@0:             for(i = 0;i < SamplesToDo;i++)
rlm@0:             {
rlm@0:                 for(c = 0;c < 2;c++)
rlm@0:                 {
rlm@0: 		  // RLM: remove click-removal
rlm@0: 		  device->DryBuffer[i][c] += device->ClickRemoval[c];
rlm@0: 		  device->ClickRemoval[c] -= device->ClickRemoval[c] / 256.0f;
rlm@0:                 }
rlm@0:             }
rlm@0:             for(c = 0;c < 2;c++)
rlm@0: 	      {
rlm@0: 		// RLM: remove click-removal
rlm@0: 		device->ClickRemoval[c] += device->PendingClicks[c];
rlm@0: 		device->PendingClicks[c] = 0.0f;
rlm@0: 	      }
rlm@0:         }
rlm@0:         else
rlm@0: 	  {
rlm@0:             for(i = 0;i < SamplesToDo;i++)
rlm@0: 	      {
rlm@0:                 for(c = 0;c < MAXCHANNELS;c++)
rlm@0: 		  {
rlm@0: 		    // RLM: remove click-removal
rlm@0: 		    device->DryBuffer[i][c] += device->ClickRemoval[c];
rlm@0: 		    device->ClickRemoval[c] -= device->ClickRemoval[c] / 256.0f;
rlm@0:                 }
rlm@0:             }
rlm@0:             for(c = 0;c < MAXCHANNELS;c++)
rlm@0:             {
rlm@0: 	      // RLM: remove click-removal
rlm@0: 	      device->ClickRemoval[c] += device->PendingClicks[c];
rlm@0: 	      device->PendingClicks[c] = 0.0f;
rlm@0:             }
rlm@0:         }
rlm@0: 
rlm@0:         if(buffer)
rlm@0:         {
rlm@0:             switch(device->FmtType)
rlm@0:             {
rlm@0:                 case DevFmtByte:
rlm@0:                     Write_ALbyte(device, buffer, SamplesToDo);
rlm@0:                     break;
rlm@0:                 case DevFmtUByte:
rlm@0:                     Write_ALubyte(device, buffer, SamplesToDo);
rlm@0:                     break;
rlm@0:                 case DevFmtShort:
rlm@0:                     Write_ALshort(device, buffer, SamplesToDo);
rlm@0:                     break;
rlm@0:                 case DevFmtUShort:
rlm@0:                     Write_ALushort(device, buffer, SamplesToDo);
rlm@0:                     break;
rlm@0:                 case DevFmtFloat:
rlm@0:                     Write_ALfloat(device, buffer, SamplesToDo);
rlm@0:                     break;
rlm@0:             }
rlm@0:         }
rlm@0: 
rlm@0:         size -= SamplesToDo;
rlm@0:     }
rlm@0: 
rlm@0: #if defined(HAVE_FESETROUND)
rlm@0:     fesetround(fpuState);
rlm@0: #elif defined(HAVE__CONTROLFP)
rlm@0:     _controlfp(fpuState, _MCW_RC);
rlm@0: #endif
rlm@0: }
rlm@0: 
rlm@0: 
rlm@0: 
rlm@0: 
rlm@0: 
rlm@0: ALvoid aluHandleDisconnect(ALCdevice *device)
rlm@0: {
rlm@0:     ALuint i;
rlm@0: 
rlm@0:     LockDevice(device);
rlm@0:     for(i = 0;i < device->NumContexts;i++)
rlm@0:     {
rlm@0:         ALCcontext *Context = device->Contexts[i];
rlm@0:         ALsource *source;
rlm@0:         ALsizei pos;
rlm@0: 
rlm@0:         for(pos = 0;pos < Context->SourceMap.size;pos++)
rlm@0:         {
rlm@0:             source = Context->SourceMap.array[pos].value;
rlm@0:             if(source->state == AL_PLAYING)
rlm@0:             {
rlm@0:                 source->state = AL_STOPPED;
rlm@0:                 source->BuffersPlayed = source->BuffersInQueue;
rlm@0:                 source->position = 0;
rlm@0:                 source->position_fraction = 0;
rlm@0:             }
rlm@0:         }
rlm@0:     }
rlm@0: 
rlm@0:     device->Connected = ALC_FALSE;
rlm@0:     UnlockDevice(device);
rlm@0: }