Alc/ALu.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <math.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <assert.h>
  28
  29 #include "alMain.h"
  30 #include "alSource.h"
  31 #include "alBuffer.h"
  32 #include "alListener.h"
  33 #include "alAuxEffectSlot.h"
  34 #include "alu.h"
  35 #include "bs2b.h"
  36
  37 #include "mixer_defs.h"
  38
  39 #include "midi/base.h"
  40
  41
  42 struct ChanMap {
  43     enum Channel channel;
  44     ALfloat angle;
  45 };
  46
  47 /* Cone scalar */
  48 ALfloat ConeScale = 1.0f;
  49
  50 /* Localized Z scalar for mono sources */
  51 ALfloat ZScale = 1.0f;
  52
  53 extern inline ALfloat minf(ALfloat a, ALfloat b);
  54 extern inline ALfloat maxf(ALfloat a, ALfloat b);
  55 extern inline ALfloat clampf(ALfloat val, ALfloat min, ALfloat max);
  56
  57 extern inline ALdouble mind(ALdouble a, ALdouble b);
  58 extern inline ALdouble maxd(ALdouble a, ALdouble b);
  59 extern inline ALdouble clampd(ALdouble val, ALdouble min, ALdouble max);
  60
  61 extern inline ALuint minu(ALuint a, ALuint b);
  62 extern inline ALuint maxu(ALuint a, ALuint b);
  63 extern inline ALuint clampu(ALuint val, ALuint min, ALuint max);
  64
  65 extern inline ALint mini(ALint a, ALint b);
  66 extern inline ALint maxi(ALint a, ALint b);
  67 extern inline ALint clampi(ALint val, ALint min, ALint max);
  68
  69 extern inline ALint64 mini64(ALint64 a, ALint64 b);
  70 extern inline ALint64 maxi64(ALint64 a, ALint64 b);
  71 extern inline ALint64 clampi64(ALint64 val, ALint64 min, ALint64 max);
  72
  73 extern inline ALuint64 minu64(ALuint64 a, ALuint64 b);
  74 extern inline ALuint64 maxu64(ALuint64 a, ALuint64 b);
  75 extern inline ALuint64 clampu64(ALuint64 val, ALuint64 min, ALuint64 max);
  76
  77 extern inline ALfloat lerp(ALfloat val1, ALfloat val2, ALfloat mu);
  78 extern inline ALfloat cubic(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat val3, ALfloat mu);
  79
  80 static ResamplerFunc SelectResampler(enum Resampler Resampler, ALuint increment)
  81 {
  82     if(increment == FRACTIONONE)
  83         return Resample_copy32_C;
  84     switch(Resampler)
  85     {
  86         case PointResampler:
  87             return Resample_point32_C;
  88         case LinearResampler:
  89             return Resample_lerp32_C;
  90         case CubicResampler:
  91             return Resample_cubic32_C;
  92         case ResamplerMax:
  93             /* Shouldn't happen */
  94             break;
  95     }
  96
  97     return Resample_point32_C;
  98 }
  99
 100
 101 static DryMixerFunc SelectHrtfMixer(void)
 102 {
 103 #ifdef HAVE_SSE
 104     if((CPUCapFlags&CPU_CAP_SSE))
 105         return MixDirect_Hrtf_SSE;
 106 #endif
 107 #ifdef HAVE_NEON
 108     if((CPUCapFlags&CPU_CAP_NEON))
 109         return MixDirect_Hrtf_Neon;
 110 #endif
 111
 112     return MixDirect_Hrtf_C;
 113 }
 114
 115 static DryMixerFunc SelectDirectMixer(void)
 116 {
 117 #ifdef HAVE_SSE
 118     if((CPUCapFlags&CPU_CAP_SSE))
 119         return MixDirect_SSE;
 120 #endif
 121
 122     return MixDirect_C;
 123 }
 124
 125 static WetMixerFunc SelectSendMixer(void)
 126 {
 127 #ifdef HAVE_SSE
 128     if((CPUCapFlags&CPU_CAP_SSE))
 129         return MixSend_SSE;
 130 #endif
 131
 132     return MixSend_C;
 133 }
 134
 135
 136 static inline void aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
 137 {
 138     outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
 139     outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
 140     outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
 141 }
 142
 143 static inline ALfloat aluDotproduct(const ALfloat *inVector1, const ALfloat *inVector2)
 144 {
 145     return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
 146            inVector1[2]*inVector2[2];
 147 }
 148
 149 static inline void aluNormalize(ALfloat *inVector)
 150 {
 151     ALfloat lengthsqr = aluDotproduct(inVector, inVector);
 152     if(lengthsqr > 0.0f)
 153     {
 154         ALfloat inv_length = 1.0f/sqrtf(lengthsqr);
 155         inVector[0] *= inv_length;
 156         inVector[1] *= inv_length;
 157         inVector[2] *= inv_length;
 158     }
 159 }
 160
 161 static inline ALvoid aluMatrixVector(ALfloat *vector, ALfloat w, ALfloat (*restrict matrix)[4])
 162 {
 163     ALfloat temp[4] = {
 164         vector[0], vector[1], vector[2], w
 165     };
 166
 167     vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
 168     vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
 169     vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
 170 }
 171
 172
 173 static ALvoid CalcListenerParams(ALlistener *Listener)
 174 {
 175     ALfloat N[3], V[3], U[3], P[3];
 176
 177     /* AT then UP */
 178     N[0] = Listener->Forward[0];
 179     N[1] = Listener->Forward[1];
 180     N[2] = Listener->Forward[2];
 181     aluNormalize(N);
 182     V[0] = Listener->Up[0];
 183     V[1] = Listener->Up[1];
 184     V[2] = Listener->Up[2];
 185     aluNormalize(V);
 186     /* Build and normalize right-vector */
 187     aluCrossproduct(N, V, U);
 188     aluNormalize(U);
 189
 190     Listener->Params.Matrix[0][0] =  U[0];
 191     Listener->Params.Matrix[0][1] =  V[0];
 192     Listener->Params.Matrix[0][2] = -N[0];
 193     Listener->Params.Matrix[0][3] =  0.0f;
 194     Listener->Params.Matrix[1][0] =  U[1];
 195     Listener->Params.Matrix[1][1] =  V[1];
 196     Listener->Params.Matrix[1][2] = -N[1];
 197     Listener->Params.Matrix[1][3] =  0.0f;
 198     Listener->Params.Matrix[2][0] =  U[2];
 199     Listener->Params.Matrix[2][1] =  V[2];
 200     Listener->Params.Matrix[2][2] = -N[2];
 201     Listener->Params.Matrix[2][3] =  0.0f;
 202     Listener->Params.Matrix[3][0] =  0.0f;
 203     Listener->Params.Matrix[3][1] =  0.0f;
 204     Listener->Params.Matrix[3][2] =  0.0f;
 205     Listener->Params.Matrix[3][3] =  1.0f;
 206
 207     P[0] = Listener->Position[0];
 208     P[1] = Listener->Position[1];
 209     P[2] = Listener->Position[2];
 210     aluMatrixVector(P, 1.0f, Listener->Params.Matrix);
 211     Listener->Params.Matrix[3][0] = -P[0];
 212     Listener->Params.Matrix[3][1] = -P[1];
 213     Listener->Params.Matrix[3][2] = -P[2];
 214
 215     Listener->Params.Velocity[0] = Listener->Velocity[0];
 216     Listener->Params.Velocity[1] = Listener->Velocity[1];
 217     Listener->Params.Velocity[2] = Listener->Velocity[2];
 218     aluMatrixVector(Listener->Params.Velocity, 0.0f, Listener->Params.Matrix);
 219 }
 220
 221 ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
 222 {
 223     static const struct ChanMap MonoMap[1] = { { FrontCenter, 0.0f } };
 224     static const struct ChanMap StereoMap[2] = {
 225         { FrontLeft,  DEG2RAD(-30.0f) },
 226         { FrontRight, DEG2RAD( 30.0f) }
 227     };
 228     static const struct ChanMap StereoWideMap[2] = {
 229         { FrontLeft,  DEG2RAD(-90.0f) },
 230         { FrontRight, DEG2RAD( 90.0f) }
 231     };
 232     static const struct ChanMap RearMap[2] = {
 233         { BackLeft,  DEG2RAD(-150.0f) },
 234         { BackRight, DEG2RAD( 150.0f) }
 235     };
 236     static const struct ChanMap QuadMap[4] = {
 237         { FrontLeft,  DEG2RAD( -45.0f) },
 238         { FrontRight, DEG2RAD(  45.0f) },
 239         { BackLeft,   DEG2RAD(-135.0f) },
 240         { BackRight,  DEG2RAD( 135.0f) }
 241     };
 242     static const struct ChanMap X51Map[6] = {
 243         { FrontLeft,   DEG2RAD( -30.0f) },
 244         { FrontRight,  DEG2RAD(  30.0f) },
 245         { FrontCenter, DEG2RAD(   0.0f) },
 246         { LFE, 0.0f },
 247         { BackLeft,    DEG2RAD(-110.0f) },
 248         { BackRight,   DEG2RAD( 110.0f) }
 249     };
 250     static const struct ChanMap X61Map[7] = {
 251         { FrontLeft,    DEG2RAD(-30.0f) },
 252         { FrontRight,   DEG2RAD( 30.0f) },
 253         { FrontCenter,  DEG2RAD(  0.0f) },
 254         { LFE, 0.0f },
 255         { BackCenter,   DEG2RAD(180.0f) },
 256         { SideLeft,     DEG2RAD(-90.0f) },
 257         { SideRight,    DEG2RAD( 90.0f) }
 258     };
 259     static const struct ChanMap X71Map[8] = {
 260         { FrontLeft,   DEG2RAD( -30.0f) },
 261         { FrontRight,  DEG2RAD(  30.0f) },
 262         { FrontCenter, DEG2RAD(   0.0f) },
 263         { LFE, 0.0f },
 264         { BackLeft,    DEG2RAD(-150.0f) },
 265         { BackRight,   DEG2RAD( 150.0f) },
 266         { SideLeft,    DEG2RAD( -90.0f) },
 267         { SideRight,   DEG2RAD(  90.0f) }
 268     };
 269
 270     ALCdevice *Device = ALContext->Device;
 271     ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
 272     ALbufferlistitem *BufferListItem;
 273     enum FmtChannels Channels;
 274     ALfloat (*SrcMatrix)[MaxChannels];
 275     ALfloat DryGain, DryGainHF;
 276     ALfloat WetGain[MAX_SENDS];
 277     ALfloat WetGainHF[MAX_SENDS];
 278     ALint NumSends, Frequency;
 279     const struct ChanMap *chans = NULL;
 280     enum Resampler Resampler;
 281     ALint num_channels = 0;
 282     ALboolean DirectChannels;
 283     ALfloat hwidth = 0.0f;
 284     ALfloat Pitch;
 285     ALint i, c;
 286
 287     /* Get device properties */
 288     NumSends  = Device->NumAuxSends;
 289     Frequency = Device->Frequency;
 290
 291     /* Get listener properties */
 292     ListenerGain = ALContext->Listener->Gain;
 293
 294     /* Get source properties */
 295     SourceVolume    = ALSource->Gain;
 296     MinVolume       = ALSource->MinGain;
 297     MaxVolume       = ALSource->MaxGain;
 298     Pitch           = ALSource->Pitch;
 299     Resampler       = ALSource->Resampler;
 300     DirectChannels  = ALSource->DirectChannels;
 301
 302     /* Calculate the stepping value */
 303     Channels = FmtMono;
 304     BufferListItem = ALSource->queue;
 305     while(BufferListItem != NULL)
 306     {
 307         ALbuffer *ALBuffer;
 308         if((ALBuffer=BufferListItem->buffer) != NULL)
 309         {
 310             Pitch = Pitch * ALBuffer->Frequency / Frequency;
 311             if(Pitch > 10.0f)
 312                 ALSource->Params.Step = 10<<FRACTIONBITS;
 313             else
 314             {
 315                 ALSource->Params.Step = fastf2i(Pitch*FRACTIONONE);
 316                 if(ALSource->Params.Step == 0)
 317                     ALSource->Params.Step = 1;
 318             }
 319             ALSource->Params.Resample = SelectResampler(Resampler, ALSource->Params.Step);
 320
 321             Channels = ALBuffer->FmtChannels;
 322             break;
 323         }
 324         BufferListItem = BufferListItem->next;
 325     }
 326     if(!DirectChannels && Device->Hrtf)
 327         ALSource->Params.DryMix = SelectHrtfMixer();
 328     else
 329         ALSource->Params.DryMix = SelectDirectMixer();
 330     ALSource->Params.WetMix = SelectSendMixer();
 331
 332     /* Calculate gains */
 333     DryGain  = clampf(SourceVolume, MinVolume, MaxVolume);
 334     DryGain *= ALSource->DirectGain * ListenerGain;
 335     DryGainHF = ALSource->DirectGainHF;
 336     for(i = 0;i < NumSends;i++)
 337     {
 338         WetGain[i]  = clampf(SourceVolume, MinVolume, MaxVolume);
 339         WetGain[i] *= ALSource->Send[i].Gain * ListenerGain;
 340         WetGainHF[i] = ALSource->Send[i].GainHF;
 341     }
 342
 343     SrcMatrix = ALSource->Params.Direct.Gains;
 344     for(i = 0;i < MAX_INPUT_CHANNELS;i++)
 345     {
 346         for(c = 0;c < MaxChannels;c++)
 347             SrcMatrix[i][c] = 0.0f;
 348     }
 349     switch(Channels)
 350     {
 351     case FmtMono:
 352         chans = MonoMap;
 353         num_channels = 1;
 354         break;
 355
 356     case FmtStereo:
 357         if(!(Device->Flags&DEVICE_WIDE_STEREO))
 358         {
 359             /* HACK: Place the stereo channels at +/-90 degrees when using non-
 360              * HRTF stereo output. This helps reduce the "monoization" caused
 361              * by them panning towards the center. */
 362             if(Device->FmtChans == DevFmtStereo && !Device->Hrtf)
 363                 chans = StereoWideMap;
 364             else
 365                 chans = StereoMap;
 366         }
 367         else
 368         {
 369             chans = StereoWideMap;
 370             hwidth = DEG2RAD(60.0f);
 371         }
 372         num_channels = 2;
 373         break;
 374
 375     case FmtRear:
 376         chans = RearMap;
 377         num_channels = 2;
 378         break;
 379
 380     case FmtQuad:
 381         chans = QuadMap;
 382         num_channels = 4;
 383         break;
 384
 385     case FmtX51:
 386         chans = X51Map;
 387         num_channels = 6;
 388         break;
 389
 390     case FmtX61:
 391         chans = X61Map;
 392         num_channels = 7;
 393         break;
 394
 395     case FmtX71:
 396         chans = X71Map;
 397         num_channels = 8;
 398         break;
 399     }
 400
 401     if(DirectChannels != AL_FALSE)
 402     {
 403         for(c = 0;c < num_channels;c++)
 404         {
 405             for(i = 0;i < (ALint)Device->NumChan;i++)
 406             {
 407                 enum Channel chan = Device->Speaker2Chan[i];
 408                 if(chan == chans[c].channel)
 409                 {
 410                     SrcMatrix[c][chan] = DryGain;
 411                     break;
 412                 }
 413             }
 414         }
 415     }
 416     else if(Device->Hrtf)
 417     {
 418         for(c = 0;c < num_channels;c++)
 419         {
 420             if(chans[c].channel == LFE)
 421             {
 422                 /* Skip LFE */
 423                 ALSource->Params.Direct.Hrtf.Params.Delay[c][0] = 0;
 424                 ALSource->Params.Direct.Hrtf.Params.Delay[c][1] = 0;
 425                 for(i = 0;i < HRIR_LENGTH;i++)
 426                 {
 427                     ALSource->Params.Direct.Hrtf.Params.Coeffs[c][i][0] = 0.0f;
 428                     ALSource->Params.Direct.Hrtf.Params.Coeffs[c][i][1] = 0.0f;
 429                 }
 430             }
 431             else
 432             {
 433                 /* Get the static HRIR coefficients and delays for this
 434                  * channel. */
 435                 GetLerpedHrtfCoeffs(Device->Hrtf,
 436                                     0.0f, chans[c].angle,  DryGain,
 437                                     ALSource->Params.Direct.Hrtf.Params.Coeffs[c],
 438                                     ALSource->Params.Direct.Hrtf.Params.Delay[c]);
 439             }
 440         }
 441         ALSource->Hrtf.Counter = 0;
 442         ALSource->Params.Direct.Hrtf.Params.IrSize = GetHrtfIrSize(Device->Hrtf);
 443
 444         ALSource->Params.Direct.Hrtf.State = &ALSource->Hrtf;
 445     }
 446     else
 447     {
 448         DryGain *= lerp(1.0f, 1.0f/sqrtf((float)Device->NumChan), hwidth/F_PI);
 449         for(c = 0;c < num_channels;c++)
 450         {
 451             /* Special-case LFE */
 452             if(chans[c].channel == LFE)
 453             {
 454                 SrcMatrix[c][chans[c].channel] = DryGain;
 455                 continue;
 456             }
 457             ComputeAngleGains(Device, chans[c].angle, hwidth, DryGain,
 458                               SrcMatrix[c]);
 459         }
 460     }
 461
 462     ALSource->Params.Direct.OutBuffer = Device->DryBuffer;
 463     ALSource->Params.Direct.ClickRemoval = Device->ClickRemoval;
 464     ALSource->Params.Direct.PendingClicks = Device->PendingClicks;
 465     for(i = 0;i < NumSends;i++)
 466     {
 467         ALeffectslot *Slot = ALSource->Send[i].Slot;
 468         if(!Slot && i == 0)
 469             Slot = Device->DefaultSlot;
 470         if(!Slot || Slot->EffectType == AL_EFFECT_NULL)
 471         {
 472             ALSource->Params.Send[i].OutBuffer = NULL;
 473             ALSource->Params.Send[i].ClickRemoval = NULL;
 474             ALSource->Params.Send[i].PendingClicks = NULL;
 475         }
 476         else
 477         {
 478             ALSource->Params.Send[i].OutBuffer = Slot->WetBuffer;
 479             ALSource->Params.Send[i].ClickRemoval = Slot->ClickRemoval;
 480             ALSource->Params.Send[i].PendingClicks = Slot->PendingClicks;
 481         }
 482         ALSource->Params.Send[i].Gain = WetGain[i];
 483     }
 484
 485     {
 486         ALfloat gain = maxf(0.01f, DryGainHF);
 487         for(c = 0;c < num_channels;c++)
 488             ALfilterState_setParams(&ALSource->Params.Direct.LpFilter[c],
 489                                     ALfilterType_HighShelf, gain,
 490                                     (ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
 491     }
 492     for(i = 0;i < NumSends;i++)
 493     {
 494         ALfloat gain = maxf(0.01f, WetGainHF[i]);
 495         for(c = 0;c < num_channels;c++)
 496             ALfilterState_setParams(&ALSource->Params.Send[i].LpFilter[c],
 497                                     ALfilterType_HighShelf, gain,
 498                                     (ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
 499     }
 500 }
 501
 502 ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
 503 {
 504     ALCdevice *Device = ALContext->Device;
 505     ALfloat Velocity[3],Direction[3],Position[3],SourceToListener[3];
 506     ALfloat InnerAngle,OuterAngle,Angle,Distance,ClampedDist;
 507     ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;
 508     ALfloat ConeVolume,ConeHF,SourceVolume,ListenerGain;
 509     ALfloat DopplerFactor, SpeedOfSound;
 510     ALfloat AirAbsorptionFactor;
 511     ALfloat RoomAirAbsorption[MAX_SENDS];
 512     ALbufferlistitem *BufferListItem;
 513     ALfloat Attenuation;
 514     ALfloat RoomAttenuation[MAX_SENDS];
 515     ALfloat MetersPerUnit;
 516     ALfloat RoomRolloffBase;
 517     ALfloat RoomRolloff[MAX_SENDS];
 518     ALfloat DecayDistance[MAX_SENDS];
 519     ALfloat DryGain;
 520     ALfloat DryGainHF;
 521     ALboolean DryGainHFAuto;
 522     ALfloat WetGain[MAX_SENDS];
 523     ALfloat WetGainHF[MAX_SENDS];
 524     ALboolean WetGainAuto;
 525     ALboolean WetGainHFAuto;
 526     enum Resampler Resampler;
 527     ALfloat Pitch;
 528     ALuint Frequency;
 529     ALint NumSends;
 530     ALint i, j;
 531
 532     DryGainHF = 1.0f;
 533     for(i = 0;i < MAX_SENDS;i++)
 534         WetGainHF[i] = 1.0f;
 535
 536     /* Get context/device properties */
 537     DopplerFactor = ALContext->DopplerFactor * ALSource->DopplerFactor;
 538     SpeedOfSound  = ALContext->SpeedOfSound * ALContext->DopplerVelocity;
 539     NumSends      = Device->NumAuxSends;
 540     Frequency     = Device->Frequency;
 541
 542     /* Get listener properties */
 543     ListenerGain  = ALContext->Listener->Gain;
 544     MetersPerUnit = ALContext->Listener->MetersPerUnit;
 545
 546     /* Get source properties */
 547     SourceVolume   = ALSource->Gain;
 548     MinVolume      = ALSource->MinGain;
 549     MaxVolume      = ALSource->MaxGain;
 550     Pitch          = ALSource->Pitch;
 551     Resampler      = ALSource->Resampler;
 552     Position[0]    = ALSource->Position[0];
 553     Position[1]    = ALSource->Position[1];
 554     Position[2]    = ALSource->Position[2];
 555     Direction[0]   = ALSource->Orientation[0];
 556     Direction[1]   = ALSource->Orientation[1];
 557     Direction[2]   = ALSource->Orientation[2];
 558     Velocity[0]    = ALSource->Velocity[0];
 559     Velocity[1]    = ALSource->Velocity[1];
 560     Velocity[2]    = ALSource->Velocity[2];
 561     MinDist        = ALSource->RefDistance;
 562     MaxDist        = ALSource->MaxDistance;
 563     Rolloff        = ALSource->RollOffFactor;
 564     InnerAngle     = ALSource->InnerAngle;
 565     OuterAngle     = ALSource->OuterAngle;
 566     AirAbsorptionFactor = ALSource->AirAbsorptionFactor;
 567     DryGainHFAuto   = ALSource->DryGainHFAuto;
 568     WetGainAuto     = ALSource->WetGainAuto;
 569     WetGainHFAuto   = ALSource->WetGainHFAuto;
 570     RoomRolloffBase = ALSource->RoomRolloffFactor;
 571
 572     ALSource->Params.Direct.OutBuffer = Device->DryBuffer;
 573     ALSource->Params.Direct.ClickRemoval = Device->ClickRemoval;
 574     ALSource->Params.Direct.PendingClicks = Device->PendingClicks;
 575     for(i = 0;i < NumSends;i++)
 576     {
 577         ALeffectslot *Slot = ALSource->Send[i].Slot;
 578
 579         if(!Slot && i == 0)
 580             Slot = Device->DefaultSlot;
 581         if(!Slot || Slot->EffectType == AL_EFFECT_NULL)
 582         {
 583             Slot = NULL;
 584             RoomRolloff[i] = 0.0f;
 585             DecayDistance[i] = 0.0f;
 586             RoomAirAbsorption[i] = 1.0f;
 587         }
 588         else if(Slot->AuxSendAuto)
 589         {
 590             RoomRolloff[i] = RoomRolloffBase;
 591             if(IsReverbEffect(Slot->EffectType))
 592             {
 593                 RoomRolloff[i] += Slot->EffectProps.Reverb.RoomRolloffFactor;
 594                 DecayDistance[i] = Slot->EffectProps.Reverb.DecayTime *
 595                                    SPEEDOFSOUNDMETRESPERSEC;
 596                 RoomAirAbsorption[i] = Slot->EffectProps.Reverb.AirAbsorptionGainHF;
 597             }
 598             else
 599             {
 600                 DecayDistance[i] = 0.0f;
 601                 RoomAirAbsorption[i] = 1.0f;
 602             }
 603         }
 604         else
 605         {
 606             /* If the slot's auxiliary send auto is off, the data sent to the
 607              * effect slot is the same as the dry path, sans filter effects */
 608             RoomRolloff[i] = Rolloff;
 609             DecayDistance[i] = 0.0f;
 610             RoomAirAbsorption[i] = AIRABSORBGAINHF;
 611         }
 612
 613         if(!Slot || Slot->EffectType == AL_EFFECT_NULL)
 614         {
 615             ALSource->Params.Send[i].OutBuffer = NULL;
 616             ALSource->Params.Send[i].ClickRemoval = NULL;
 617             ALSource->Params.Send[i].PendingClicks = NULL;
 618         }
 619         else
 620         {
 621             ALSource->Params.Send[i].OutBuffer = Slot->WetBuffer;
 622             ALSource->Params.Send[i].ClickRemoval = Slot->ClickRemoval;
 623             ALSource->Params.Send[i].PendingClicks = Slot->PendingClicks;
 624         }
 625     }
 626
 627     /* Transform source to listener space (convert to head relative) */
 628     if(ALSource->HeadRelative == AL_FALSE)
 629     {
 630         ALfloat (*restrict Matrix)[4] = ALContext->Listener->Params.Matrix;
 631         /* Transform source vectors */
 632         aluMatrixVector(Position, 1.0f, Matrix);
 633         aluMatrixVector(Direction, 0.0f, Matrix);
 634         aluMatrixVector(Velocity, 0.0f, Matrix);
 635     }
 636     else
 637     {
 638         const ALfloat *ListenerVel = ALContext->Listener->Params.Velocity;
 639         /* Offset the source velocity to be relative of the listener velocity */
 640         Velocity[0] += ListenerVel[0];
 641         Velocity[1] += ListenerVel[1];
 642         Velocity[2] += ListenerVel[2];
 643     }
 644
 645     SourceToListener[0] = -Position[0];
 646     SourceToListener[1] = -Position[1];
 647     SourceToListener[2] = -Position[2];
 648     aluNormalize(SourceToListener);
 649     aluNormalize(Direction);
 650
 651     /* Calculate distance attenuation */
 652     Distance = sqrtf(aluDotproduct(Position, Position));
 653     ClampedDist = Distance;
 654
 655     Attenuation = 1.0f;
 656     for(i = 0;i < NumSends;i++)
 657         RoomAttenuation[i] = 1.0f;
 658     switch(ALContext->SourceDistanceModel ? ALSource->DistanceModel :
 659                                             ALContext->DistanceModel)
 660     {
 661         case InverseDistanceClamped:
 662             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
 663             if(MaxDist < MinDist)
 664                 break;
 665             /*fall-through*/
 666         case InverseDistance:
 667             if(MinDist > 0.0f)
 668             {
 669                 if((MinDist + (Rolloff * (ClampedDist - MinDist))) > 0.0f)
 670                     Attenuation = MinDist / (MinDist + (Rolloff * (ClampedDist - MinDist)));
 671                 for(i = 0;i < NumSends;i++)
 672                 {
 673                     if((MinDist + (RoomRolloff[i] * (ClampedDist - MinDist))) > 0.0f)
 674                         RoomAttenuation[i] = MinDist / (MinDist + (RoomRolloff[i] * (ClampedDist - MinDist)));
 675                 }
 676             }
 677             break;
 678
 679         case LinearDistanceClamped:
 680             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
 681             if(MaxDist < MinDist)
 682                 break;
 683             /*fall-through*/
 684         case LinearDistance:
 685             if(MaxDist != MinDist)
 686             {
 687                 Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));
 688                 Attenuation = maxf(Attenuation, 0.0f);
 689                 for(i = 0;i < NumSends;i++)
 690                 {
 691                     RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));
 692                     RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);
 693                 }
 694             }
 695             break;
 696
 697         case ExponentDistanceClamped:
 698             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
 699             if(MaxDist < MinDist)
 700                 break;
 701             /*fall-through*/
 702         case ExponentDistance:
 703             if(ClampedDist > 0.0f && MinDist > 0.0f)
 704             {
 705                 Attenuation = powf(ClampedDist/MinDist, -Rolloff);
 706                 for(i = 0;i < NumSends;i++)
 707                     RoomAttenuation[i] = powf(ClampedDist/MinDist, -RoomRolloff[i]);
 708             }
 709             break;
 710
 711         case DisableDistance:
 712             ClampedDist = MinDist;
 713             break;
 714     }
 715
 716     /* Source Gain + Attenuation */
 717     DryGain = SourceVolume * Attenuation;
 718     for(i = 0;i < NumSends;i++)
 719         WetGain[i] = SourceVolume * RoomAttenuation[i];
 720
 721     /* Distance-based air absorption */
 722     if(AirAbsorptionFactor > 0.0f && ClampedDist > MinDist)
 723     {
 724         ALfloat meters = maxf(ClampedDist-MinDist, 0.0f) * MetersPerUnit;
 725         DryGainHF *= powf(AIRABSORBGAINHF, AirAbsorptionFactor*meters);
 726         for(i = 0;i < NumSends;i++)
 727             WetGainHF[i] *= powf(RoomAirAbsorption[i], AirAbsorptionFactor*meters);
 728     }
 729
 730     if(WetGainAuto)
 731     {
 732         ALfloat ApparentDist = 1.0f/maxf(Attenuation, 0.00001f) - 1.0f;
 733
 734         /* Apply a decay-time transformation to the wet path, based on the
 735          * attenuation of the dry path.
 736          *
 737          * Using the apparent distance, based on the distance attenuation, the
 738          * initial decay of the reverb effect is calculated and applied to the
 739          * wet path.
 740          */
 741         for(i = 0;i < NumSends;i++)
 742         {
 743             if(DecayDistance[i] > 0.0f)
 744                 WetGain[i] *= powf(0.001f/*-60dB*/, ApparentDist/DecayDistance[i]);
 745         }
 746     }
 747
 748     /* Calculate directional soundcones */
 749     Angle = RAD2DEG(acosf(aluDotproduct(Direction,SourceToListener)) * ConeScale) * 2.0f;
 750     if(Angle > InnerAngle && Angle <= OuterAngle)
 751     {
 752         ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
 753         ConeVolume = lerp(1.0f, ALSource->OuterGain, scale);
 754         ConeHF = lerp(1.0f, ALSource->OuterGainHF, scale);
 755     }
 756     else if(Angle > OuterAngle)
 757     {
 758         ConeVolume = ALSource->OuterGain;
 759         ConeHF = ALSource->OuterGainHF;
 760     }
 761     else
 762     {
 763         ConeVolume = 1.0f;
 764         ConeHF = 1.0f;
 765     }
 766
 767     DryGain *= ConeVolume;
 768     if(WetGainAuto)
 769     {
 770         for(i = 0;i < NumSends;i++)
 771             WetGain[i] *= ConeVolume;
 772     }
 773     if(DryGainHFAuto)
 774         DryGainHF *= ConeHF;
 775     if(WetGainHFAuto)
 776     {
 777         for(i = 0;i < NumSends;i++)
 778             WetGainHF[i] *= ConeHF;
 779     }
 780
 781     /* Clamp to Min/Max Gain */
 782     DryGain = clampf(DryGain, MinVolume, MaxVolume);
 783     for(i = 0;i < NumSends;i++)
 784         WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);
 785
 786     /* Apply gain and frequency filters */
 787     DryGain   *= ALSource->DirectGain * ListenerGain;
 788     DryGainHF *= ALSource->DirectGainHF;
 789     for(i = 0;i < NumSends;i++)
 790     {
 791         WetGain[i]   *= ALSource->Send[i].Gain * ListenerGain;
 792         WetGainHF[i] *= ALSource->Send[i].GainHF;
 793     }
 794
 795     /* Calculate velocity-based doppler effect */
 796     if(DopplerFactor > 0.0f)
 797     {
 798         const ALfloat *ListenerVel = ALContext->Listener->Params.Velocity;
 799         ALfloat VSS, VLS;
 800
 801         if(SpeedOfSound < 1.0f)
 802         {
 803             DopplerFactor *= 1.0f/SpeedOfSound;
 804             SpeedOfSound   = 1.0f;
 805         }
 806
 807         VSS = aluDotproduct(Velocity, SourceToListener) * DopplerFactor;
 808         VLS = aluDotproduct(ListenerVel, SourceToListener) * DopplerFactor;
 809
 810         Pitch *= clampf(SpeedOfSound-VLS, 1.0f, SpeedOfSound*2.0f - 1.0f) /
 811                  clampf(SpeedOfSound-VSS, 1.0f, SpeedOfSound*2.0f - 1.0f);
 812     }
 813
 814     BufferListItem = ALSource->queue;
 815     while(BufferListItem != NULL)
 816     {
 817         ALbuffer *ALBuffer;
 818         if((ALBuffer=BufferListItem->buffer) != NULL)
 819         {
 820             /* Calculate fixed-point stepping value, based on the pitch, buffer
 821              * frequency, and output frequency. */
 822             Pitch = Pitch * ALBuffer->Frequency / Frequency;
 823             if(Pitch > 10.0f)
 824                 ALSource->Params.Step = 10<<FRACTIONBITS;
 825             else
 826             {
 827                 ALSource->Params.Step = fastf2i(Pitch*FRACTIONONE);
 828                 if(ALSource->Params.Step == 0)
 829                     ALSource->Params.Step = 1;
 830             }
 831             ALSource->Params.Resample = SelectResampler(Resampler, ALSource->Params.Step);
 832
 833             break;
 834         }
 835         BufferListItem = BufferListItem->next;
 836     }
 837     if(Device->Hrtf)
 838         ALSource->Params.DryMix = SelectHrtfMixer();
 839     else
 840         ALSource->Params.DryMix = SelectDirectMixer();
 841     ALSource->Params.WetMix = SelectSendMixer();
 842
 843     if(Device->Hrtf)
 844     {
 845         /* Use a binaural HRTF algorithm for stereo headphone playback */
 846         ALfloat delta, ev = 0.0f, az = 0.0f;
 847
 848         if(Distance > FLT_EPSILON)
 849         {
 850             ALfloat invlen = 1.0f/Distance;
 851             Position[0] *= invlen;
 852             Position[1] *= invlen;
 853             Position[2] *= invlen;
 854
 855             /* Calculate elevation and azimuth only when the source is not at
 856              * the listener. This prevents +0 and -0 Z from producing
 857              * inconsistent panning. Also, clamp Y in case FP precision errors
 858              * cause it to land outside of -1..+1. */
 859             ev = asinf(clampf(Position[1], -1.0f, 1.0f));
 860             az = atan2f(Position[0], -Position[2]*ZScale);
 861         }
 862
 863         /* Check to see if the HRIR is already moving. */
 864         if(ALSource->Hrtf.Moving)
 865         {
 866             /* Calculate the normalized HRTF transition factor (delta). */
 867             delta = CalcHrtfDelta(ALSource->Params.Direct.Hrtf.Params.Gain, DryGain,
 868                                   ALSource->Params.Direct.Hrtf.Params.Dir, Position);
 869             /* If the delta is large enough, get the moving HRIR target
 870              * coefficients, target delays, steppping values, and counter. */
 871             if(delta > 0.001f)
 872             {
 873                 ALSource->Hrtf.Counter = GetMovingHrtfCoeffs(Device->Hrtf,
 874                                            ev, az, DryGain, delta,
 875                                            ALSource->Hrtf.Counter,
 876                                            ALSource->Params.Direct.Hrtf.Params.Coeffs[0],
 877                                            ALSource->Params.Direct.Hrtf.Params.Delay[0],
 878                                            ALSource->Params.Direct.Hrtf.Params.CoeffStep,
 879                                            ALSource->Params.Direct.Hrtf.Params.DelayStep);
 880                 ALSource->Params.Direct.Hrtf.Params.Gain = DryGain;
 881                 ALSource->Params.Direct.Hrtf.Params.Dir[0] = Position[0];
 882                 ALSource->Params.Direct.Hrtf.Params.Dir[1] = Position[1];
 883                 ALSource->Params.Direct.Hrtf.Params.Dir[2] = Position[2];
 884             }
 885         }
 886         else
 887         {
 888             /* Get the initial (static) HRIR coefficients and delays. */
 889             GetLerpedHrtfCoeffs(Device->Hrtf, ev, az, DryGain,
 890                                 ALSource->Params.Direct.Hrtf.Params.Coeffs[0],
 891                                 ALSource->Params.Direct.Hrtf.Params.Delay[0]);
 892             ALSource->Hrtf.Counter = 0;
 893             ALSource->Hrtf.Moving  = AL_TRUE;
 894             ALSource->Params.Direct.Hrtf.Params.Gain = DryGain;
 895             ALSource->Params.Direct.Hrtf.Params.Dir[0] = Position[0];
 896             ALSource->Params.Direct.Hrtf.Params.Dir[1] = Position[1];
 897             ALSource->Params.Direct.Hrtf.Params.Dir[2] = Position[2];
 898         }
 899         ALSource->Params.Direct.Hrtf.Params.IrSize = GetHrtfIrSize(Device->Hrtf);
 900
 901         ALSource->Params.Direct.Hrtf.State = &ALSource->Hrtf;
 902     }
 903     else
 904     {
 905         ALfloat (*Matrix)[MaxChannels] = ALSource->Params.Direct.Gains;
 906         ALfloat DirGain = 0.0f;
 907         ALfloat AmbientGain;
 908
 909         for(i = 0;i < MAX_INPUT_CHANNELS;i++)
 910         {
 911             for(j = 0;j < MaxChannels;j++)
 912                 Matrix[i][j] = 0.0f;
 913         }
 914
 915         /* Normalize the length, and compute panned gains. */
 916         if(Distance > FLT_EPSILON)
 917         {
 918             ALfloat invlen = 1.0f/Distance;
 919             Position[0] *= invlen;
 920             Position[1] *= invlen;
 921             Position[2] *= invlen;
 922
 923             DirGain = sqrtf(Position[0]*Position[0] + Position[2]*Position[2]);
 924             ComputeAngleGains(Device, atan2f(Position[0], -Position[2]*ZScale), 0.0f,
 925                               DryGain*DirGain, Matrix[0]);
 926         }
 927
 928         /* Adjustment for vertical offsets. Not the greatest, but simple
 929          * enough. */
 930         AmbientGain = DryGain * sqrtf(1.0f/Device->NumChan) * (1.0f-DirGain);
 931         for(i = 0;i < (ALint)Device->NumChan;i++)
 932         {
 933             enum Channel chan = Device->Speaker2Chan[i];
 934             Matrix[0][chan] = maxf(Matrix[0][chan], AmbientGain);
 935         }
 936     }
 937     for(i = 0;i < NumSends;i++)
 938         ALSource->Params.Send[i].Gain = WetGain[i];
 939
 940
 941     {
 942         ALfloat gain = maxf(0.01f, DryGainHF);
 943         ALfilterState_setParams(&ALSource->Params.Direct.LpFilter[0],
 944                                 ALfilterType_HighShelf, gain,
 945                                 (ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
 946     }
 947     for(i = 0;i < NumSends;i++)
 948     {
 949         ALfloat gain = maxf(0.01f, WetGainHF[i]);
 950         ALfilterState_setParams(&ALSource->Params.Send[i].LpFilter[0],
 951                                 ALfilterType_HighShelf, gain,
 952                                 (ALfloat)LOWPASSFREQREF/Frequency, 0.0f);
 953     }
 954 }
 955
 956
 957 static inline ALint aluF2I25(ALfloat val)
 958 {
 959     /* Clamp the value between -1 and +1. This handles that with only a single branch. */
 960     if(fabsf(val) > 1.0f)
 961         val = (ALfloat)((0.0f < val) - (val < 0.0f));
 962     /* Convert to a signed integer, between -16777215 and +16777215. */
 963     return fastf2i(val*16777215.0f);
 964 }
 965
 966 static inline ALfloat aluF2F(ALfloat val)
 967 { return val; }
 968 static inline ALint aluF2I(ALfloat val)
 969 { return aluF2I25(val)<<7; }
 970 static inline ALuint aluF2UI(ALfloat val)
 971 { return aluF2I(val)+2147483648u; }
 972 static inline ALshort aluF2S(ALfloat val)
 973 { return aluF2I25(val)>>9; }
 974 static inline ALushort aluF2US(ALfloat val)
 975 { return aluF2S(val)+32768; }
 976 static inline ALbyte aluF2B(ALfloat val)
 977 { return aluF2I25(val)>>17; }
 978 static inline ALubyte aluF2UB(ALfloat val)
 979 { return aluF2B(val)+128; }
 980
 981 #define DECL_TEMPLATE(T, func)                                                \
 982 static int Write_##T(ALCdevice *device, T *restrict buffer,                   \
 983                      ALuint SamplesToDo)                                      \
 984 {                                                                             \
 985     ALfloat (*restrict DryBuffer)[BUFFERSIZE] = device->DryBuffer;            \
 986     ALuint numchans = ChannelsFromDevFmt(device->FmtChans);                   \
 987     const ALuint *offsets = device->ChannelOffsets;                           \
 988     ALuint i, j;                                                              \
 989                                                                               \
 990     for(j = 0;j < MaxChannels;j++)                                            \
 991     {                                                                         \
 992         T *restrict out;                                                      \
 993                                                                               \
 994         if(offsets[j] == INVALID_OFFSET)                                      \
 995             continue;                                                         \
 996                                                                               \
 997         out = buffer + offsets[j];                                            \
 998         for(i = 0;i < SamplesToDo;i++)                                        \
 999             out[i*numchans] = func(DryBuffer[j][i]);                          \
1000     }                                                                         \
1001     return SamplesToDo*numchans*sizeof(T);                                    \
1002 }
1003
1004 DECL_TEMPLATE(ALfloat, aluF2F)
1005 DECL_TEMPLATE(ALuint, aluF2UI)
1006 DECL_TEMPLATE(ALint, aluF2I)
1007 DECL_TEMPLATE(ALushort, aluF2US)
1008 DECL_TEMPLATE(ALshort, aluF2S)
1009 DECL_TEMPLATE(ALubyte, aluF2UB)
1010 DECL_TEMPLATE(ALbyte, aluF2B)
1011
1012 #undef DECL_TEMPLATE
1013
1014
1015 ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
1016 {
1017     ALuint SamplesToDo;
1018     ALeffectslot **slot, **slot_end;
1019     ALsource **src, **src_end;
1020     ALCcontext *ctx;
1021     FPUCtl oldMode;
1022     ALuint i, c;
1023
1024     SetMixerFPUMode(&oldMode);
1025
1026     while(size > 0)
1027     {
1028         SamplesToDo = minu(size, BUFFERSIZE);
1029         for(c = 0;c < MaxChannels;c++)
1030             memset(device->DryBuffer[c], 0, SamplesToDo*sizeof(ALfloat));
1031
1032         ALCdevice_Lock(device);
1033         V(device->Synth,process)(SamplesToDo, device->DryBuffer);
1034
1035         ctx = device->ContextList;
1036         while(ctx)
1037         {
1038             ALenum DeferUpdates = ctx->DeferUpdates;
1039             ALenum UpdateSources = AL_FALSE;
1040
1041             if(!DeferUpdates)
1042                 UpdateSources = ExchangeInt(&ctx->UpdateSources, AL_FALSE);
1043
1044             if(UpdateSources)
1045                 CalcListenerParams(ctx->Listener);
1046
1047             /* source processing */
1048             src = ctx->ActiveSources;
1049             src_end = src + ctx->ActiveSourceCount;
1050             while(src != src_end)
1051             {
1052                 if((*src)->state != AL_PLAYING)
1053                 {
1054                     --(ctx->ActiveSourceCount);
1055                     *src = *(--src_end);
1056                     continue;
1057                 }
1058
1059                 if(!DeferUpdates && (ExchangeInt(&(*src)->NeedsUpdate, AL_FALSE) ||
1060                                      UpdateSources))
1061                     ALsource_Update(*src, ctx);
1062
1063                 MixSource(*src, device, SamplesToDo);
1064                 src++;
1065             }
1066
1067             /* effect slot processing */
1068             slot = ctx->ActiveEffectSlots;
1069             slot_end = slot + ctx->ActiveEffectSlotCount;
1070             while(slot != slot_end)
1071             {
1072                 ALfloat offset = (*slot)->ClickRemoval[0];
1073                 if(offset < (1.0f/32768.0f))
1074                     offset = 0.0f;
1075                 else for(i = 0;i < SamplesToDo;i++)
1076                 {
1077                     (*slot)->WetBuffer[0][i] += offset;
1078                     offset -= offset * (1.0f/256.0f);
1079                 }
1080                 (*slot)->ClickRemoval[0] = offset + (*slot)->PendingClicks[0];
1081                 (*slot)->PendingClicks[0] = 0.0f;
1082
1083                 if(!DeferUpdates && ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
1084                     V((*slot)->EffectState,update)(device, *slot);
1085
1086                 V((*slot)->EffectState,process)(SamplesToDo, (*slot)->WetBuffer[0],
1087                                                 device->DryBuffer);
1088
1089                 for(i = 0;i < SamplesToDo;i++)
1090                     (*slot)->WetBuffer[0][i] = 0.0f;
1091
1092                 slot++;
1093             }
1094
1095             ctx = ctx->next;
1096         }
1097
1098         slot = &device->DefaultSlot;
1099         if(*slot != NULL)
1100         {
1101             ALfloat offset = (*slot)->ClickRemoval[0];
1102             if(offset < (1.0f/32768.0f))
1103                 offset = 0.0f;
1104             else for(i = 0;i < SamplesToDo;i++)
1105             {
1106                 (*slot)->WetBuffer[0][i] += offset;
1107                 offset -= offset * (1.0f/256.0f);
1108             }
1109             (*slot)->ClickRemoval[0] = offset + (*slot)->PendingClicks[0];
1110             (*slot)->PendingClicks[0] = 0.0f;
1111
1112             if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
1113                 V((*slot)->EffectState,update)(device, *slot);
1114
1115             V((*slot)->EffectState,process)(SamplesToDo, (*slot)->WetBuffer[0],
1116                                             device->DryBuffer);
1117
1118             for(i = 0;i < SamplesToDo;i++)
1119                 (*slot)->WetBuffer[0][i] = 0.0f;
1120         }
1121         ALCdevice_Unlock(device);
1122
1123         /* Click-removal. Could do better; this only really handles immediate
1124          * changes between updates where a predictive sample could be
1125          * generated. Delays caused by effects and HRTF aren't caught. */
1126         if(device->FmtChans == DevFmtMono)
1127         {
1128             ALfloat offset = device->ClickRemoval[FrontCenter];
1129             if(offset < (1.0f/32768.0f))
1130                 offset = 0.0f;
1131             else for(i = 0;i < SamplesToDo;i++)
1132             {
1133                 device->DryBuffer[FrontCenter][i] += offset;
1134                 offset -= offset * (1.0f/256.0f);
1135             }
1136             device->ClickRemoval[FrontCenter] = offset + device->PendingClicks[FrontCenter];
1137             device->PendingClicks[FrontCenter] = 0.0f;
1138         }
1139         else if(device->FmtChans == DevFmtStereo)
1140         {
1141             /* Assumes the first two channels are FrontLeft and FrontRight */
1142             for(c = 0;c < 2;c++)
1143             {
1144                 ALfloat offset = device->ClickRemoval[c];
1145                 if(offset < (1.0f/32768.0f))
1146                     offset = 0.0f;
1147                 else for(i = 0;i < SamplesToDo;i++)
1148                 {
1149                     device->DryBuffer[c][i] += offset;
1150                     offset -= offset * (1.0f/256.0f);
1151                 }
1152                 device->ClickRemoval[c] = offset + device->PendingClicks[c];
1153                 device->PendingClicks[c] = 0.0f;
1154             }
1155             if(device->Bs2b)
1156             {
1157                 float samples[2];
1158                 for(i = 0;i < SamplesToDo;i++)
1159                 {
1160                     samples[0] = device->DryBuffer[FrontLeft][i];
1161                     samples[1] = device->DryBuffer[FrontRight][i];
1162                     bs2b_cross_feed(device->Bs2b, samples);
1163                     device->DryBuffer[FrontLeft][i] = samples[0];
1164                     device->DryBuffer[FrontRight][i] = samples[1];
1165                 }
1166             }
1167         }
1168         else
1169         {
1170             for(c = 0;c < MaxChannels;c++)
1171             {
1172                 ALfloat offset = device->ClickRemoval[c];
1173                 if(offset < (1.0f/32768.0f))
1174                     offset = 0.0f;
1175                 else for(i = 0;i < SamplesToDo;i++)
1176                 {
1177                     device->DryBuffer[c][i] += offset;
1178                     offset -= offset * (1.0f/256.0f);
1179                 }
1180                 device->ClickRemoval[c] = offset + device->PendingClicks[c];
1181                 device->PendingClicks[c] = 0.0f;
1182             }
1183         }
1184
1185         if(buffer)
1186         {
1187             int bytes = 0;
1188             switch(device->FmtType)
1189             {
1190                 case DevFmtByte:
1191                     bytes = Write_ALbyte(device, buffer, SamplesToDo);
1192                     break;
1193                 case DevFmtUByte:
1194                     bytes = Write_ALubyte(device, buffer, SamplesToDo);
1195                     break;
1196                 case DevFmtShort:
1197                     bytes = Write_ALshort(device, buffer, SamplesToDo);
1198                     break;
1199                 case DevFmtUShort:
1200                     bytes = Write_ALushort(device, buffer, SamplesToDo);
1201                     break;
1202                 case DevFmtInt:
1203                     bytes = Write_ALint(device, buffer, SamplesToDo);
1204                     break;
1205                 case DevFmtUInt:
1206                     bytes = Write_ALuint(device, buffer, SamplesToDo);
1207                     break;
1208                 case DevFmtFloat:
1209                     bytes = Write_ALfloat(device, buffer, SamplesToDo);
1210                     break;
1211             }
1212
1213             buffer = (ALubyte*)buffer + bytes;
1214         }
1215
1216         size -= SamplesToDo;
1217     }
1218
1219     RestoreFPUMode(&oldMode);
1220 }
1221
1222
1223 ALvoid aluHandleDisconnect(ALCdevice *device)
1224 {
1225     ALCcontext *Context;
1226
1227     device->Connected = ALC_FALSE;
1228
1229     Context = device->ContextList;
1230     while(Context)
1231     {
1232         ALsource **src, **src_end;
1233
1234         src = Context->ActiveSources;
1235         src_end = src + Context->ActiveSourceCount;
1236         while(src != src_end)
1237         {
1238             if((*src)->state == AL_PLAYING)
1239             {
1240                 (*src)->state = AL_STOPPED;
1241                 (*src)->BuffersPlayed = (*src)->BuffersInQueue;
1242                 (*src)->position = 0;
1243                 (*src)->position_fraction = 0;
1244             }
1245             src++;
1246         }
1247         Context->ActiveSourceCount = 0;
1248
1249         Context = Context->next;
1250     }
1251 }