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 "AL/al.h"
  31 #include "AL/alc.h"
  32 #include "alSource.h"
  33 #include "alBuffer.h"
  34 #include "alThunk.h"
  35 #include "alListener.h"
  36 #include "alAuxEffectSlot.h"
  37 #include "alu.h"
  38 #include "bs2b.h"
  39
  40 #if defined(HAVE_STDINT_H)
  41 #include <stdint.h>
  42 typedef int64_t ALint64;
  43 #elif defined(HAVE___INT64)
  44 typedef __int64 ALint64;
  45 #elif (SIZEOF_LONG == 8)
  46 typedef long ALint64;
  47 #elif (SIZEOF_LONG_LONG == 8)
  48 typedef long long ALint64;
  49 #endif
  50
  51 #define FRACTIONBITS 14
  52 #define FRACTIONMASK ((1L<<FRACTIONBITS)-1)
  53 #define MAX_PITCH 65536
  54
  55 /* Minimum ramp length in milliseconds. The value below was chosen to
  56  * adequately reduce clicks and pops from harsh gain changes. */
  57 #define MIN_RAMP_LENGTH  16
  58
  59 ALboolean DuplicateStereo = AL_FALSE;
  60
  61
  62 static __inline ALfloat aluF2F(ALfloat Value)
  63 {
  64     return Value;
  65 }
  66
  67 static __inline ALshort aluF2S(ALfloat Value)
  68 {
  69     ALint i;
  70
  71     if(Value < 0.0f)
  72     {
  73         i = (ALint)(Value*32768.0f);
  74         i = max(-32768, i);
  75     }
  76     else
  77     {
  78         i = (ALint)(Value*32767.0f);
  79         i = min( 32767, i);
  80     }
  81     return ((ALshort)i);
  82 }
  83
  84 static __inline ALubyte aluF2UB(ALfloat Value)
  85 {
  86     ALshort i = aluF2S(Value);
  87     return (i>>8)+128;
  88 }
  89
  90
  91 static __inline ALvoid aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
  92 {
  93     outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
  94     outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
  95     outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
  96 }
  97
  98 static __inline ALfloat aluDotproduct(const ALfloat *inVector1, const ALfloat *inVector2)
  99 {
 100     return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
 101            inVector1[2]*inVector2[2];
 102 }
 103
 104 static __inline ALvoid aluNormalize(ALfloat *inVector)
 105 {
 106     ALfloat length, inverse_length;
 107
 108     length = aluSqrt(aluDotproduct(inVector, inVector));
 109     if(length != 0.0f)
 110     {
 111         inverse_length = 1.0f/length;
 112         inVector[0] *= inverse_length;
 113         inVector[1] *= inverse_length;
 114         inVector[2] *= inverse_length;
 115     }
 116 }
 117
 118 static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat w,ALfloat matrix[4][4])
 119 {
 120     ALfloat temp[4] = {
 121         vector[0], vector[1], vector[2], w
 122     };
 123
 124     vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
 125     vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
 126     vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
 127 }
 128
 129 static ALvoid SetSpeakerArrangement(const char *name, ALfloat SpeakerAngle[OUTPUTCHANNELS],
 130                                     ALint Speaker2Chan[OUTPUTCHANNELS], ALint chans)
 131 {
 132     const char *confkey;
 133     const char *next;
 134     const char *sep;
 135     const char *end;
 136     int i, val;
 137
 138     confkey = GetConfigValue(NULL, name, "");
 139     next = confkey;
 140     while(next && *next)
 141     {
 142         confkey = next;
 143         next = strchr(confkey, ',');
 144         if(next)
 145         {
 146             do {
 147                 next++;
 148             } while(isspace(*next));
 149         }
 150
 151         sep = strchr(confkey, '=');
 152         if(!sep || confkey == sep)
 153             continue;
 154
 155         end = sep - 1;
 156         while(isspace(*end) && end != confkey)
 157             end--;
 158         end++;
 159
 160         if(strncmp(confkey, "fl", end-confkey) == 0)
 161             val = FRONT_LEFT;
 162         else if(strncmp(confkey, "fr", end-confkey) == 0)
 163             val = FRONT_RIGHT;
 164         else if(strncmp(confkey, "fc", end-confkey) == 0)
 165             val = FRONT_CENTER;
 166         else if(strncmp(confkey, "bl", end-confkey) == 0)
 167             val = BACK_LEFT;
 168         else if(strncmp(confkey, "br", end-confkey) == 0)
 169             val = BACK_RIGHT;
 170         else if(strncmp(confkey, "bc", end-confkey) == 0)
 171             val = BACK_CENTER;
 172         else if(strncmp(confkey, "sl", end-confkey) == 0)
 173             val = SIDE_LEFT;
 174         else if(strncmp(confkey, "sr", end-confkey) == 0)
 175             val = SIDE_RIGHT;
 176         else
 177         {
 178             AL_PRINT("Unknown speaker for %s: \"%c%c\"\n", name, confkey[0], confkey[1]);
 179             continue;
 180         }
 181
 182         sep++;
 183         while(isspace(*sep))
 184             sep++;
 185
 186         for(i = 0;i < chans;i++)
 187         {
 188             if(Speaker2Chan[i] == val)
 189             {
 190                 val = strtol(sep, NULL, 10);
 191                 if(val >= -180 && val <= 180)
 192                     SpeakerAngle[i] = val * M_PI/180.0f;
 193                 else
 194                     AL_PRINT("Invalid angle for speaker \"%c%c\": %d\n", confkey[0], confkey[1], val);
 195                 break;
 196             }
 197         }
 198     }
 199
 200     for(i = 1;i < chans;i++)
 201     {
 202         if(SpeakerAngle[i] <= SpeakerAngle[i-1])
 203         {
 204             AL_PRINT("Speaker %d of %d does not follow previous: %f > %f\n", i, chans,
 205                      SpeakerAngle[i-1] * 180.0f/M_PI, SpeakerAngle[i] * 180.0f/M_PI);
 206             SpeakerAngle[i] = SpeakerAngle[i-1] + 1 * 180.0f/M_PI;
 207         }
 208     }
 209 }
 210
 211 static __inline ALfloat aluLUTpos2Angle(ALint pos)
 212 {
 213     if(pos < QUADRANT_NUM)
 214         return aluAtan((ALfloat)pos / (ALfloat)(QUADRANT_NUM - pos));
 215     if(pos < 2 * QUADRANT_NUM)
 216         return M_PI_2 + aluAtan((ALfloat)(pos - QUADRANT_NUM) / (ALfloat)(2 * QUADRANT_NUM - pos));
 217     if(pos < 3 * QUADRANT_NUM)
 218         return aluAtan((ALfloat)(pos - 2 * QUADRANT_NUM) / (ALfloat)(3 * QUADRANT_NUM - pos)) - M_PI;
 219     return aluAtan((ALfloat)(pos - 3 * QUADRANT_NUM) / (ALfloat)(4 * QUADRANT_NUM - pos)) - M_PI_2;
 220 }
 221
 222 ALvoid aluInitPanning(ALCcontext *Context)
 223 {
 224     ALint pos, offset, s;
 225     ALfloat Alpha, Theta;
 226     ALfloat SpeakerAngle[OUTPUTCHANNELS];
 227     ALint Speaker2Chan[OUTPUTCHANNELS];
 228
 229     for(s = 0;s < OUTPUTCHANNELS;s++)
 230     {
 231         int s2;
 232         for(s2 = 0;s2 < OUTPUTCHANNELS;s2++)
 233             Context->ChannelMatrix[s][s2] = ((s==s2) ? 1.0f : 0.0f);
 234     }
 235
 236     switch(Context->Device->Format)
 237     {
 238         case AL_FORMAT_MONO8:
 239         case AL_FORMAT_MONO16:
 240         case AL_FORMAT_MONO_FLOAT32:
 241             Context->ChannelMatrix[FRONT_LEFT][FRONT_CENTER]  = aluSqrt(0.5);
 242             Context->ChannelMatrix[FRONT_RIGHT][FRONT_CENTER] = aluSqrt(0.5);
 243             Context->ChannelMatrix[SIDE_LEFT][FRONT_CENTER]   = aluSqrt(0.5);
 244             Context->ChannelMatrix[SIDE_RIGHT][FRONT_CENTER]  = aluSqrt(0.5);
 245             Context->ChannelMatrix[BACK_LEFT][FRONT_CENTER]   = aluSqrt(0.5);
 246             Context->ChannelMatrix[BACK_RIGHT][FRONT_CENTER]  = aluSqrt(0.5);
 247             Context->ChannelMatrix[BACK_CENTER][FRONT_CENTER] = 1.0f;
 248             Context->NumChan = 1;
 249             Speaker2Chan[0] = FRONT_CENTER;
 250             SpeakerAngle[0] = 0.0f * M_PI/180.0f;
 251             break;
 252
 253         case AL_FORMAT_STEREO8:
 254         case AL_FORMAT_STEREO16:
 255         case AL_FORMAT_STEREO_FLOAT32:
 256             Context->ChannelMatrix[FRONT_CENTER][FRONT_LEFT]  = aluSqrt(0.5);
 257             Context->ChannelMatrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5);
 258             Context->ChannelMatrix[SIDE_LEFT][FRONT_LEFT]     = 1.0f;
 259             Context->ChannelMatrix[SIDE_RIGHT][FRONT_RIGHT]   = 1.0f;
 260             Context->ChannelMatrix[BACK_LEFT][FRONT_LEFT]     = 1.0f;
 261             Context->ChannelMatrix[BACK_RIGHT][FRONT_RIGHT]   = 1.0f;
 262             Context->ChannelMatrix[BACK_CENTER][FRONT_LEFT]   = aluSqrt(0.5);
 263             Context->ChannelMatrix[BACK_CENTER][FRONT_RIGHT]  = aluSqrt(0.5);
 264             Context->NumChan = 2;
 265             Speaker2Chan[0] = FRONT_LEFT;
 266             Speaker2Chan[1] = FRONT_RIGHT;
 267             SpeakerAngle[0] = -90.0f * M_PI/180.0f;
 268             SpeakerAngle[1] =  90.0f * M_PI/180.0f;
 269             SetSpeakerArrangement("layout_STEREO", SpeakerAngle, Speaker2Chan, Context->NumChan);
 270             break;
 271
 272         case AL_FORMAT_QUAD8:
 273         case AL_FORMAT_QUAD16:
 274         case AL_FORMAT_QUAD32:
 275             Context->ChannelMatrix[FRONT_CENTER][FRONT_LEFT]  = aluSqrt(0.5);
 276             Context->ChannelMatrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5);
 277             Context->ChannelMatrix[SIDE_LEFT][FRONT_LEFT]     = aluSqrt(0.5);
 278             Context->ChannelMatrix[SIDE_LEFT][BACK_LEFT]      = aluSqrt(0.5);
 279             Context->ChannelMatrix[SIDE_RIGHT][FRONT_RIGHT]   = aluSqrt(0.5);
 280             Context->ChannelMatrix[SIDE_RIGHT][BACK_RIGHT]    = aluSqrt(0.5);
 281             Context->ChannelMatrix[BACK_CENTER][BACK_LEFT]    = aluSqrt(0.5);
 282             Context->ChannelMatrix[BACK_CENTER][BACK_RIGHT]   = aluSqrt(0.5);
 283             Context->NumChan = 4;
 284             Speaker2Chan[0] = BACK_LEFT;
 285             Speaker2Chan[1] = FRONT_LEFT;
 286             Speaker2Chan[2] = FRONT_RIGHT;
 287             Speaker2Chan[3] = BACK_RIGHT;
 288             SpeakerAngle[0] = -135.0f * M_PI/180.0f;
 289             SpeakerAngle[1] =  -45.0f * M_PI/180.0f;
 290             SpeakerAngle[2] =   45.0f * M_PI/180.0f;
 291             SpeakerAngle[3] =  135.0f * M_PI/180.0f;
 292             SetSpeakerArrangement("layout_QUAD", SpeakerAngle, Speaker2Chan, Context->NumChan);
 293             break;
 294
 295         case AL_FORMAT_51CHN8:
 296         case AL_FORMAT_51CHN16:
 297         case AL_FORMAT_51CHN32:
 298             Context->ChannelMatrix[SIDE_LEFT][FRONT_LEFT]   = aluSqrt(0.5);
 299             Context->ChannelMatrix[SIDE_LEFT][BACK_LEFT]    = aluSqrt(0.5);
 300             Context->ChannelMatrix[SIDE_RIGHT][FRONT_RIGHT] = aluSqrt(0.5);
 301             Context->ChannelMatrix[SIDE_RIGHT][BACK_RIGHT]  = aluSqrt(0.5);
 302             Context->ChannelMatrix[BACK_CENTER][BACK_LEFT]  = aluSqrt(0.5);
 303             Context->ChannelMatrix[BACK_CENTER][BACK_RIGHT] = aluSqrt(0.5);
 304             Context->NumChan = 5;
 305             Speaker2Chan[0] = BACK_LEFT;
 306             Speaker2Chan[1] = FRONT_LEFT;
 307             Speaker2Chan[2] = FRONT_CENTER;
 308             Speaker2Chan[3] = FRONT_RIGHT;
 309             Speaker2Chan[4] = BACK_RIGHT;
 310             SpeakerAngle[0] = -110.0f * M_PI/180.0f;
 311             SpeakerAngle[1] =  -30.0f * M_PI/180.0f;
 312             SpeakerAngle[2] =    0.0f * M_PI/180.0f;
 313             SpeakerAngle[3] =   30.0f * M_PI/180.0f;
 314             SpeakerAngle[4] =  110.0f * M_PI/180.0f;
 315             SetSpeakerArrangement("layout_51CHN", SpeakerAngle, Speaker2Chan, Context->NumChan);
 316             break;
 317
 318         case AL_FORMAT_61CHN8:
 319         case AL_FORMAT_61CHN16:
 320         case AL_FORMAT_61CHN32:
 321             Context->ChannelMatrix[BACK_LEFT][BACK_CENTER]  = aluSqrt(0.5);
 322             Context->ChannelMatrix[BACK_LEFT][SIDE_LEFT]    = aluSqrt(0.5);
 323             Context->ChannelMatrix[BACK_RIGHT][BACK_CENTER] = aluSqrt(0.5);
 324             Context->ChannelMatrix[BACK_RIGHT][SIDE_RIGHT]  = aluSqrt(0.5);
 325             Context->NumChan = 6;
 326             Speaker2Chan[0] = SIDE_LEFT;
 327             Speaker2Chan[1] = FRONT_LEFT;
 328             Speaker2Chan[2] = FRONT_CENTER;
 329             Speaker2Chan[3] = FRONT_RIGHT;
 330             Speaker2Chan[4] = SIDE_RIGHT;
 331             Speaker2Chan[5] = BACK_CENTER;
 332             SpeakerAngle[0] = -90.0f * M_PI/180.0f;
 333             SpeakerAngle[1] = -30.0f * M_PI/180.0f;
 334             SpeakerAngle[2] =   0.0f * M_PI/180.0f;
 335             SpeakerAngle[3] =  30.0f * M_PI/180.0f;
 336             SpeakerAngle[4] =  90.0f * M_PI/180.0f;
 337             SpeakerAngle[5] = 180.0f * M_PI/180.0f;
 338             SetSpeakerArrangement("layout_61CHN", SpeakerAngle, Speaker2Chan, Context->NumChan);
 339             break;
 340
 341         case AL_FORMAT_71CHN8:
 342         case AL_FORMAT_71CHN16:
 343         case AL_FORMAT_71CHN32:
 344             Context->ChannelMatrix[BACK_CENTER][BACK_LEFT]  = aluSqrt(0.5);
 345             Context->ChannelMatrix[BACK_CENTER][BACK_RIGHT] = aluSqrt(0.5);
 346             Context->NumChan = 7;
 347             Speaker2Chan[0] = BACK_LEFT;
 348             Speaker2Chan[1] = SIDE_LEFT;
 349             Speaker2Chan[2] = FRONT_LEFT;
 350             Speaker2Chan[3] = FRONT_CENTER;
 351             Speaker2Chan[4] = FRONT_RIGHT;
 352             Speaker2Chan[5] = SIDE_RIGHT;
 353             Speaker2Chan[6] = BACK_RIGHT;
 354             SpeakerAngle[0] = -150.0f * M_PI/180.0f;
 355             SpeakerAngle[1] =  -90.0f * M_PI/180.0f;
 356             SpeakerAngle[2] =  -30.0f * M_PI/180.0f;
 357             SpeakerAngle[3] =    0.0f * M_PI/180.0f;
 358             SpeakerAngle[4] =   30.0f * M_PI/180.0f;
 359             SpeakerAngle[5] =   90.0f * M_PI/180.0f;
 360             SpeakerAngle[6] =  150.0f * M_PI/180.0f;
 361             SetSpeakerArrangement("layout_71CHN", SpeakerAngle, Speaker2Chan, Context->NumChan);
 362             break;
 363
 364         default:
 365             assert(0);
 366     }
 367
 368     for(pos = 0; pos < LUT_NUM; pos++)
 369     {
 370         /* clear all values */
 371         offset = OUTPUTCHANNELS * pos;
 372         for(s = 0; s < OUTPUTCHANNELS; s++)
 373             Context->PanningLUT[offset+s] = 0.0f;
 374
 375         if(Context->NumChan == 1)
 376         {
 377             Context->PanningLUT[offset + Speaker2Chan[0]] = 1.0f;
 378             continue;
 379         }
 380
 381         /* source angle */
 382         Theta = aluLUTpos2Angle(pos);
 383
 384         /* set panning values */
 385         for(s = 0; s < Context->NumChan - 1; s++)
 386         {
 387             if(Theta >= SpeakerAngle[s] && Theta < SpeakerAngle[s+1])
 388             {
 389                 /* source between speaker s and speaker s+1 */
 390                 Alpha = M_PI_2 * (Theta-SpeakerAngle[s]) /
 391                                  (SpeakerAngle[s+1]-SpeakerAngle[s]);
 392                 Context->PanningLUT[offset + Speaker2Chan[s]]   = cos(Alpha);
 393                 Context->PanningLUT[offset + Speaker2Chan[s+1]] = sin(Alpha);
 394                 break;
 395             }
 396         }
 397         if(s == Context->NumChan - 1)
 398         {
 399             /* source between last and first speaker */
 400             if(Theta < SpeakerAngle[0])
 401                 Theta += 2.0f * M_PI;
 402             Alpha = M_PI_2 * (Theta-SpeakerAngle[s]) /
 403                              (2.0f * M_PI + SpeakerAngle[0]-SpeakerAngle[s]);
 404             Context->PanningLUT[offset + Speaker2Chan[s]] = cos(Alpha);
 405             Context->PanningLUT[offset + Speaker2Chan[0]] = sin(Alpha);
 406         }
 407     }
 408 }
 409
 410 static ALvoid CalcNonAttnSourceParams(const ALCcontext *ALContext, ALsource *ALSource)
 411 {
 412     ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
 413     ALfloat DryGain, DryGainHF;
 414     ALfloat WetGain[MAX_SENDS];
 415     ALfloat WetGainHF[MAX_SENDS];
 416     ALint NumSends, Frequency;
 417     ALfloat cw;
 418     ALint i;
 419
 420     //Get context properties
 421     NumSends  = ALContext->Device->NumAuxSends;
 422     Frequency = ALContext->Device->Frequency;
 423
 424     //Get listener properties
 425     ListenerGain = ALContext->Listener.Gain;
 426
 427     //Get source properties
 428     SourceVolume = ALSource->flGain;
 429     MinVolume    = ALSource->flMinGain;
 430     MaxVolume    = ALSource->flMaxGain;
 431
 432     //1. Multi-channel buffers always play "normal"
 433     ALSource->Params.Pitch = ALSource->flPitch;
 434
 435     DryGain = SourceVolume;
 436     DryGain = __min(DryGain,MaxVolume);
 437     DryGain = __max(DryGain,MinVolume);
 438     DryGainHF = 1.0f;
 439
 440     switch(ALSource->DirectFilter.type)
 441     {
 442         case AL_FILTER_LOWPASS:
 443             DryGain *= ALSource->DirectFilter.Gain;
 444             DryGainHF *= ALSource->DirectFilter.GainHF;
 445             break;
 446     }
 447
 448     ALSource->Params.DryGains[FRONT_LEFT]   = DryGain * ListenerGain;
 449     ALSource->Params.DryGains[FRONT_RIGHT]  = DryGain * ListenerGain;
 450     ALSource->Params.DryGains[SIDE_LEFT]    = DryGain * ListenerGain;
 451     ALSource->Params.DryGains[SIDE_RIGHT]   = DryGain * ListenerGain;
 452     ALSource->Params.DryGains[BACK_LEFT]    = DryGain * ListenerGain;
 453     ALSource->Params.DryGains[BACK_RIGHT]   = DryGain * ListenerGain;
 454     ALSource->Params.DryGains[FRONT_CENTER] = DryGain * ListenerGain;
 455     ALSource->Params.DryGains[BACK_CENTER]  = DryGain * ListenerGain;
 456     ALSource->Params.DryGains[LFE]          = DryGain * ListenerGain;
 457
 458     for(i = 0;i < NumSends;i++)
 459     {
 460         WetGain[i] = SourceVolume;
 461         WetGain[i] = __min(WetGain[i],MaxVolume);
 462         WetGain[i] = __max(WetGain[i],MinVolume);
 463         WetGainHF[i] = 1.0f;
 464
 465         switch(ALSource->Send[i].WetFilter.type)
 466         {
 467             case AL_FILTER_LOWPASS:
 468                 WetGain[i] *= ALSource->Send[i].WetFilter.Gain;
 469                 WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;
 470                 break;
 471         }
 472
 473         ALSource->Params.WetGains[i] = WetGain[i] * ListenerGain;
 474     }
 475     for(i = NumSends;i < MAX_SENDS;i++)
 476     {
 477         ALSource->Params.WetGains[i] = 0.0f;
 478         WetGainHF[i] = 1.0f;
 479     }
 480
 481     /* Update filter coefficients. Calculations based on the I3DL2
 482      * spec. */
 483     cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);
 484
 485     /* We use two chained one-pole filters, so we need to take the
 486      * square root of the squared gain, which is the same as the base
 487      * gain. */
 488     ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
 489
 490     for(i = 0;i < NumSends;i++)
 491     {
 492         /* We use a one-pole filter, so we need to take the squared gain */
 493         ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
 494         ALSource->Params.Send[i].iirFilter.coeff = a;
 495     }
 496 }
 497
 498 static ALvoid CalcSourceParams(const ALCcontext *ALContext, ALsource *ALSource)
 499 {
 500     ALfloat InnerAngle,OuterAngle,Angle,Distance,DryMix,OrigDist;
 501     ALfloat Direction[3],Position[3],SourceToListener[3];
 502     ALfloat Velocity[3],ListenerVel[3];
 503     ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff,OuterGainHF;
 504     ALfloat ConeVolume,ConeHF,SourceVolume,ListenerGain;
 505     ALfloat DopplerFactor, DopplerVelocity, flSpeedOfSound;
 506     ALfloat Matrix[4][4];
 507     ALfloat flAttenuation, effectiveDist;
 508     ALfloat RoomAttenuation[MAX_SENDS];
 509     ALfloat MetersPerUnit;
 510     ALfloat RoomRolloff[MAX_SENDS];
 511     ALfloat DryGainHF = 1.0f;
 512     ALfloat WetGain[MAX_SENDS];
 513     ALfloat WetGainHF[MAX_SENDS];
 514     ALfloat DirGain, AmbientGain;
 515     ALfloat length;
 516     const ALfloat *SpeakerGain;
 517     ALuint Frequency;
 518     ALint NumSends;
 519     ALint pos, s, i;
 520     ALfloat cw;
 521
 522     for(i = 0;i < MAX_SENDS;i++)
 523         WetGainHF[i] = 1.0f;
 524
 525     //Get context properties
 526     DopplerFactor   = ALContext->DopplerFactor * ALSource->DopplerFactor;
 527     DopplerVelocity = ALContext->DopplerVelocity;
 528     flSpeedOfSound  = ALContext->flSpeedOfSound;
 529     NumSends        = ALContext->Device->NumAuxSends;
 530     Frequency       = ALContext->Device->Frequency;
 531
 532     //Get listener properties
 533     ListenerGain = ALContext->Listener.Gain;
 534     MetersPerUnit = ALContext->Listener.MetersPerUnit;
 535     memcpy(ListenerVel, ALContext->Listener.Velocity, sizeof(ALContext->Listener.Velocity));
 536
 537     //Get source properties
 538     SourceVolume = ALSource->flGain;
 539     memcpy(Position,  ALSource->vPosition,    sizeof(ALSource->vPosition));
 540     memcpy(Direction, ALSource->vOrientation, sizeof(ALSource->vOrientation));
 541     memcpy(Velocity,  ALSource->vVelocity,    sizeof(ALSource->vVelocity));
 542     MinVolume    = ALSource->flMinGain;
 543     MaxVolume    = ALSource->flMaxGain;
 544     MinDist      = ALSource->flRefDistance;
 545     MaxDist      = ALSource->flMaxDistance;
 546     Rolloff      = ALSource->flRollOffFactor;
 547     InnerAngle   = ALSource->flInnerAngle;
 548     OuterAngle   = ALSource->flOuterAngle;
 549     OuterGainHF  = ALSource->OuterGainHF;
 550
 551     //1. Translate Listener to origin (convert to head relative)
 552     if(ALSource->bHeadRelative==AL_FALSE)
 553     {
 554         ALfloat U[3],V[3],N[3],P[3];
 555
 556         // Build transform matrix
 557         memcpy(N, ALContext->Listener.Forward, sizeof(N));  // At-vector
 558         aluNormalize(N);  // Normalized At-vector
 559         memcpy(V, ALContext->Listener.Up, sizeof(V));  // Up-vector
 560         aluNormalize(V);  // Normalized Up-vector
 561         aluCrossproduct(N, V, U); // Right-vector
 562         aluNormalize(U);  // Normalized Right-vector
 563         P[0] = -(ALContext->Listener.Position[0]*U[0] + // Translation
 564                  ALContext->Listener.Position[1]*U[1] +
 565                  ALContext->Listener.Position[2]*U[2]);
 566         P[1] = -(ALContext->Listener.Position[0]*V[0] +
 567                  ALContext->Listener.Position[1]*V[1] +
 568                  ALContext->Listener.Position[2]*V[2]);
 569         P[2] = -(ALContext->Listener.Position[0]*-N[0] +
 570                  ALContext->Listener.Position[1]*-N[1] +
 571                  ALContext->Listener.Position[2]*-N[2]);
 572         Matrix[0][0] = U[0]; Matrix[0][1] = V[0]; Matrix[0][2] = -N[0]; Matrix[0][3] = 0.0f;
 573         Matrix[1][0] = U[1]; Matrix[1][1] = V[1]; Matrix[1][2] = -N[1]; Matrix[1][3] = 0.0f;
 574         Matrix[2][0] = U[2]; Matrix[2][1] = V[2]; Matrix[2][2] = -N[2]; Matrix[2][3] = 0.0f;
 575         Matrix[3][0] = P[0]; Matrix[3][1] = P[1]; Matrix[3][2] =  P[2]; Matrix[3][3] = 1.0f;
 576
 577         // Transform source position and direction into listener space
 578         aluMatrixVector(Position, 1.0f, Matrix);
 579         aluMatrixVector(Direction, 0.0f, Matrix);
 580         // Transform source and listener velocity into listener space
 581         aluMatrixVector(Velocity, 0.0f, Matrix);
 582         aluMatrixVector(ListenerVel, 0.0f, Matrix);
 583     }
 584     else
 585         ListenerVel[0] = ListenerVel[1] = ListenerVel[2] = 0.0f;
 586
 587     SourceToListener[0] = -Position[0];
 588     SourceToListener[1] = -Position[1];
 589     SourceToListener[2] = -Position[2];
 590     aluNormalize(SourceToListener);
 591     aluNormalize(Direction);
 592
 593     //2. Calculate distance attenuation
 594     Distance = aluSqrt(aluDotproduct(Position, Position));
 595     OrigDist = Distance;
 596
 597     flAttenuation = 1.0f;
 598     for(i = 0;i < NumSends;i++)
 599     {
 600         RoomAttenuation[i] = 1.0f;
 601
 602         RoomRolloff[i] = ALSource->RoomRolloffFactor;
 603         if(ALSource->Send[i].Slot &&
 604            (ALSource->Send[i].Slot->effect.type == AL_EFFECT_REVERB ||
 605             ALSource->Send[i].Slot->effect.type == AL_EFFECT_EAXREVERB))
 606             RoomRolloff[i] += ALSource->Send[i].Slot->effect.Reverb.RoomRolloffFactor;
 607     }
 608
 609     switch(ALContext->SourceDistanceModel ? ALSource->DistanceModel :
 610                                             ALContext->DistanceModel)
 611     {
 612         case AL_INVERSE_DISTANCE_CLAMPED:
 613             Distance=__max(Distance,MinDist);
 614             Distance=__min(Distance,MaxDist);
 615             if(MaxDist < MinDist)
 616                 break;
 617             //fall-through
 618         case AL_INVERSE_DISTANCE:
 619             if(MinDist > 0.0f)
 620             {
 621                 if((MinDist + (Rolloff * (Distance - MinDist))) > 0.0f)
 622                     flAttenuation = MinDist / (MinDist + (Rolloff * (Distance - MinDist)));
 623                 for(i = 0;i < NumSends;i++)
 624                 {
 625                     if((MinDist + (RoomRolloff[i] * (Distance - MinDist))) > 0.0f)
 626                         RoomAttenuation[i] = MinDist / (MinDist + (RoomRolloff[i] * (Distance - MinDist)));
 627                 }
 628             }
 629             break;
 630
 631         case AL_LINEAR_DISTANCE_CLAMPED:
 632             Distance=__max(Distance,MinDist);
 633             Distance=__min(Distance,MaxDist);
 634             if(MaxDist < MinDist)
 635                 break;
 636             //fall-through
 637         case AL_LINEAR_DISTANCE:
 638             Distance=__min(Distance,MaxDist);
 639             if(MaxDist != MinDist)
 640             {
 641                 flAttenuation = 1.0f - (Rolloff*(Distance-MinDist)/(MaxDist - MinDist));
 642                 for(i = 0;i < NumSends;i++)
 643                     RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(Distance-MinDist)/(MaxDist - MinDist));
 644             }
 645             break;
 646
 647         case AL_EXPONENT_DISTANCE_CLAMPED:
 648             Distance=__max(Distance,MinDist);
 649             Distance=__min(Distance,MaxDist);
 650             if(MaxDist < MinDist)
 651                 break;
 652             //fall-through
 653         case AL_EXPONENT_DISTANCE:
 654             if(Distance > 0.0f && MinDist > 0.0f)
 655             {
 656                 flAttenuation = (ALfloat)pow(Distance/MinDist, -Rolloff);
 657                 for(i = 0;i < NumSends;i++)
 658                     RoomAttenuation[i] = (ALfloat)pow(Distance/MinDist, -RoomRolloff[i]);
 659             }
 660             break;
 661
 662         case AL_NONE:
 663             break;
 664     }
 665
 666     // Source Gain + Attenuation
 667     DryMix = SourceVolume * flAttenuation;
 668     for(i = 0;i < NumSends;i++)
 669         WetGain[i] = SourceVolume * RoomAttenuation[i];
 670
 671     effectiveDist = 0.0f;
 672     if(MinDist > 0.0f)
 673         effectiveDist = (MinDist/flAttenuation - MinDist)*MetersPerUnit;
 674
 675     // Distance-based air absorption
 676     if(ALSource->AirAbsorptionFactor > 0.0f && effectiveDist > 0.0f)
 677     {
 678         ALfloat absorb;
 679
 680         // Absorption calculation is done in dB
 681         absorb = (ALSource->AirAbsorptionFactor*AIRABSORBGAINDBHF) *
 682                  effectiveDist;
 683         // Convert dB to linear gain before applying
 684         absorb = pow(10.0, absorb/20.0);
 685
 686         DryGainHF *= absorb;
 687     }
 688
 689     //3. Apply directional soundcones
 690     Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * 180.0f/M_PI;
 691     if(Angle >= InnerAngle && Angle <= OuterAngle)
 692     {
 693         ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
 694         ConeVolume = (1.0f+(ALSource->flOuterGain-1.0f)*scale);
 695         ConeHF = (1.0f+(OuterGainHF-1.0f)*scale);
 696     }
 697     else if(Angle > OuterAngle)
 698     {
 699         ConeVolume = (1.0f+(ALSource->flOuterGain-1.0f));
 700         ConeHF = (1.0f+(OuterGainHF-1.0f));
 701     }
 702     else
 703     {
 704         ConeVolume = 1.0f;
 705         ConeHF = 1.0f;
 706     }
 707
 708     // Apply some high-frequency attenuation for sources behind the listener
 709     // NOTE: This should be aluDotproduct({0,0,-1}, ListenerToSource), however
 710     // that is equivalent to aluDotproduct({0,0,1}, SourceToListener), which is
 711     // the same as SourceToListener[2]
 712     Angle = aluAcos(SourceToListener[2]) * 180.0f/M_PI;
 713     // Sources within the minimum distance attenuate less
 714     if(OrigDist < MinDist)
 715         Angle *= OrigDist/MinDist;
 716     if(Angle > 90.0f)
 717     {
 718         ALfloat scale = (Angle-90.0f) / (180.1f-90.0f); // .1 to account for fp errors
 719         ConeHF *= 1.0f - (ALContext->Device->HeadDampen*scale);
 720     }
 721
 722     DryMix *= ConeVolume;
 723     if(ALSource->DryGainHFAuto)
 724         DryGainHF *= ConeHF;
 725
 726     // Clamp to Min/Max Gain
 727     DryMix = __min(DryMix,MaxVolume);
 728     DryMix = __max(DryMix,MinVolume);
 729
 730     for(i = 0;i < NumSends;i++)
 731     {
 732         ALeffectslot *Slot = ALSource->Send[i].Slot;
 733
 734         if(Slot && Slot->effect.type != AL_EFFECT_NULL)
 735         {
 736             if(Slot->AuxSendAuto)
 737             {
 738                 if(ALSource->WetGainAuto)
 739                     WetGain[i] *= ConeVolume;
 740                 if(ALSource->WetGainHFAuto)
 741                     WetGainHF[i] *= ConeHF;
 742
 743                 // Clamp to Min/Max Gain
 744                 WetGain[i] = __min(WetGain[i],MaxVolume);
 745                 WetGain[i] = __max(WetGain[i],MinVolume);
 746
 747                 if(Slot->effect.type == AL_EFFECT_REVERB ||
 748                    Slot->effect.type == AL_EFFECT_EAXREVERB)
 749                 {
 750                     /* Apply a decay-time transformation to the wet path,
 751                      * based on the attenuation of the dry path.
 752                      *
 753                      * Using the approximate (effective) source to listener
 754                      * distance, the initial decay of the reverb effect is
 755                      * calculated and applied to the wet path.
 756                      */
 757                     WetGain[i] *= pow(10.0, effectiveDist /
 758                                             (SPEEDOFSOUNDMETRESPERSEC *
 759                                              Slot->effect.Reverb.DecayTime) *
 760                                             -60.0 / 20.0);
 761
 762                     WetGainHF[i] *= pow(10.0,
 763                                         log10(Slot->effect.Reverb.AirAbsorptionGainHF) *
 764                                         ALSource->AirAbsorptionFactor * effectiveDist);
 765                 }
 766             }
 767             else
 768             {
 769                 // If the slot's auxiliary send auto is off, the data sent to
 770                 // the effect slot is the same as the dry path, sans filter
 771                 // effects
 772                 WetGain[i] = DryMix;
 773                 WetGainHF[i] = DryGainHF;
 774             }
 775
 776             switch(ALSource->Send[i].WetFilter.type)
 777             {
 778                 case AL_FILTER_LOWPASS:
 779                     WetGain[i] *= ALSource->Send[i].WetFilter.Gain;
 780                     WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;
 781                     break;
 782             }
 783             ALSource->Params.WetGains[i] = WetGain[i] * ListenerGain;
 784         }
 785         else
 786         {
 787             ALSource->Params.WetGains[i] = 0.0f;
 788             WetGainHF[i] = 1.0f;
 789         }
 790     }
 791     for(i = NumSends;i < MAX_SENDS;i++)
 792     {
 793         ALSource->Params.WetGains[i] = 0.0f;
 794         WetGainHF[i] = 1.0f;
 795     }
 796
 797     // Apply filter gains and filters
 798     switch(ALSource->DirectFilter.type)
 799     {
 800         case AL_FILTER_LOWPASS:
 801             DryMix *= ALSource->DirectFilter.Gain;
 802             DryGainHF *= ALSource->DirectFilter.GainHF;
 803             break;
 804     }
 805     DryMix *= ListenerGain;
 806
 807     // Calculate Velocity
 808     if(DopplerFactor != 0.0f)
 809     {
 810         ALfloat flVSS, flVLS;
 811         ALfloat flMaxVelocity = (DopplerVelocity * flSpeedOfSound) /
 812                                 DopplerFactor;
 813
 814         flVSS = aluDotproduct(Velocity, SourceToListener);
 815         if(flVSS >= flMaxVelocity)
 816             flVSS = (flMaxVelocity - 1.0f);
 817         else if(flVSS <= -flMaxVelocity)
 818             flVSS = -flMaxVelocity + 1.0f;
 819
 820         flVLS = aluDotproduct(ListenerVel, SourceToListener);
 821         if(flVLS >= flMaxVelocity)
 822             flVLS = (flMaxVelocity - 1.0f);
 823         else if(flVLS <= -flMaxVelocity)
 824             flVLS = -flMaxVelocity + 1.0f;
 825
 826         ALSource->Params.Pitch = ALSource->flPitch *
 827             ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVLS)) /
 828             ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVSS));
 829     }
 830     else
 831         ALSource->Params.Pitch = ALSource->flPitch;
 832
 833     // Use energy-preserving panning algorithm for multi-speaker playback
 834     length = __max(OrigDist, MinDist);
 835     if(length > 0.0f)
 836     {
 837         ALfloat invlen = 1.0f/length;
 838         Position[0] *= invlen;
 839         Position[1] *= invlen;
 840         Position[2] *= invlen;
 841     }
 842
 843     pos = aluCart2LUTpos(-Position[2], Position[0]);
 844     SpeakerGain = &ALContext->PanningLUT[OUTPUTCHANNELS * pos];
 845
 846     DirGain = aluSqrt(Position[0]*Position[0] + Position[2]*Position[2]);
 847     // elevation adjustment for directional gain. this sucks, but
 848     // has low complexity
 849     AmbientGain = 1.0/aluSqrt(ALContext->NumChan) * (1.0-DirGain);
 850     for(s = 0; s < OUTPUTCHANNELS; s++)
 851     {
 852         ALfloat gain = SpeakerGain[s]*DirGain + AmbientGain;
 853         ALSource->Params.DryGains[s] = DryMix * gain;
 854     }
 855
 856     /* Update filter coefficients. */
 857     cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);
 858
 859     /* Spatialized sources use four chained one-pole filters, so we need to
 860      * take the fourth root of the squared gain, which is the same as the
 861      * square root of the base gain. */
 862     ALSource->Params.iirFilter.coeff = lpCoeffCalc(aluSqrt(DryGainHF), cw);
 863
 864     for(i = 0;i < NumSends;i++)
 865     {
 866         /* The wet path uses two chained one-pole filters, so take the
 867          * base gain (square root of the squared gain) */
 868         ALSource->Params.Send[i].iirFilter.coeff = lpCoeffCalc(WetGainHF[i], cw);
 869     }
 870 }
 871
 872 static __inline ALfloat lerp(ALfloat val1, ALfloat val2, ALint frac)
 873 {
 874     return val1 + ((val2-val1)*(frac * (1.0f/(1<<FRACTIONBITS))));
 875 }
 876
 877 static void MixSomeSources(ALCcontext *ALContext, float (*DryBuffer)[OUTPUTCHANNELS], ALuint SamplesToDo)
 878 {
 879     static float DummyBuffer[BUFFERSIZE];
 880     ALfloat *WetBuffer[MAX_SENDS];
 881     ALfloat (*Matrix)[OUTPUTCHANNELS] = ALContext->ChannelMatrix;
 882     ALfloat DrySend[OUTPUTCHANNELS];
 883     ALfloat dryGainStep[OUTPUTCHANNELS];
 884     ALfloat wetGainStep[MAX_SENDS];
 885     ALuint i, j, k, out;
 886     ALsource *ALSource;
 887     ALfloat value, outsamp;
 888     ALbufferlistitem *BufferListItem;
 889     ALint64 DataSize64,DataPos64;
 890     FILTER *DryFilter, *WetFilter[MAX_SENDS];
 891     ALfloat WetSend[MAX_SENDS];
 892     ALuint rampLength;
 893     ALuint DeviceFreq;
 894     ALint increment;
 895     ALuint DataPosInt, DataPosFrac;
 896     ALuint Channels, Bytes;
 897     ALuint Frequency;
 898     ALuint BuffersPlayed;
 899     ALfloat Pitch;
 900     ALenum State;
 901
 902     if(!(ALSource=ALContext->Source))
 903         return;
 904
 905     DeviceFreq = ALContext->Device->Frequency;
 906
 907     rampLength = DeviceFreq * MIN_RAMP_LENGTH / 1000;
 908     rampLength = max(rampLength, SamplesToDo);
 909
 910 another_source:
 911     if(ALSource->state != AL_PLAYING)
 912     {
 913         if((ALSource=ALSource->next) != NULL)
 914             goto another_source;
 915         return;
 916     }
 917     j = 0;
 918
 919     /* Find buffer format */
 920     Frequency = 0;
 921     Channels = 0;
 922     Bytes = 0;
 923     BufferListItem = ALSource->queue;
 924     while(BufferListItem != NULL)
 925     {
 926         ALbuffer *ALBuffer;
 927         if((ALBuffer=BufferListItem->buffer) != NULL)
 928         {
 929             Channels  = aluChannelsFromFormat(ALBuffer->format);
 930             Bytes     = aluBytesFromFormat(ALBuffer->format);
 931             Frequency = ALBuffer->frequency;
 932             break;
 933         }
 934         BufferListItem = BufferListItem->next;
 935     }
 936
 937     if(ALSource->NeedsUpdate)
 938     {
 939         //Only apply 3D calculations for mono buffers
 940         if(Channels == 1)
 941             CalcSourceParams(ALContext, ALSource);
 942         else
 943             CalcNonAttnSourceParams(ALContext, ALSource);
 944         ALSource->NeedsUpdate = AL_FALSE;
 945     }
 946
 947     /* Get source info */
 948     State         = ALSource->state;
 949     BuffersPlayed = ALSource->BuffersPlayed;
 950     DataPosInt    = ALSource->position;
 951     DataPosFrac   = ALSource->position_fraction;
 952
 953     /* Compute 18.14 fixed point step */
 954     Pitch = (ALSource->Params.Pitch*Frequency) / DeviceFreq;
 955     if(Pitch > (float)MAX_PITCH)  Pitch = (float)MAX_PITCH;
 956     increment = (ALint)(Pitch*(ALfloat)(1L<<FRACTIONBITS));
 957     if(increment <= 0)  increment = (1<<FRACTIONBITS);
 958
 959     /* Compute the gain steps for each output channel */
 960     if(ALSource->FirstStart)
 961     {
 962         for(i = 0;i < OUTPUTCHANNELS;i++)
 963             DrySend[i] = ALSource->Params.DryGains[i];
 964         for(i = 0;i < MAX_SENDS;i++)
 965             WetSend[i] = ALSource->Params.WetGains[i];
 966     }
 967     else
 968     {
 969         for(i = 0;i < OUTPUTCHANNELS;i++)
 970             DrySend[i] = ALSource->DryGains[i];
 971         for(i = 0;i < MAX_SENDS;i++)
 972             WetSend[i] = ALSource->WetGains[i];
 973     }
 974
 975     DryFilter = &ALSource->Params.iirFilter;
 976     for(i = 0;i < MAX_SENDS;i++)
 977     {
 978         WetFilter[i] = &ALSource->Params.Send[i].iirFilter;
 979         WetBuffer[i] = (ALSource->Send[i].Slot ?
 980                         ALSource->Send[i].Slot->WetBuffer :
 981                         DummyBuffer);
 982     }
 983
 984     if(DuplicateStereo && Channels == 2)
 985     {
 986         Matrix[FRONT_LEFT][SIDE_LEFT]   = 1.0f;
 987         Matrix[FRONT_RIGHT][SIDE_RIGHT] = 1.0f;
 988         Matrix[FRONT_LEFT][BACK_LEFT]   = 1.0f;
 989         Matrix[FRONT_RIGHT][BACK_RIGHT] = 1.0f;
 990     }
 991     else if(DuplicateStereo)
 992     {
 993         Matrix[FRONT_LEFT][SIDE_LEFT]   = 0.0f;
 994         Matrix[FRONT_RIGHT][SIDE_RIGHT] = 0.0f;
 995         Matrix[FRONT_LEFT][BACK_LEFT]   = 0.0f;
 996         Matrix[FRONT_RIGHT][BACK_RIGHT] = 0.0f;
 997     }
 998
 999     /* Get current buffer queue item */
1000     BufferListItem = ALSource->queue;
1001     for(i = 0;i < BuffersPlayed && BufferListItem;i++)
1002         BufferListItem = BufferListItem->next;
1003
1004     while(State == AL_PLAYING && j < SamplesToDo)
1005     {
1006         ALuint DataSize = 0;
1007         ALbuffer *ALBuffer;
1008         ALfloat *Data;
1009         ALuint BufferSize;
1010
1011         /* Get buffer info */
1012         if((ALBuffer=BufferListItem->buffer) != NULL)
1013         {
1014             Data      = ALBuffer->data;
1015             DataSize  = ALBuffer->size;
1016             DataSize /= Channels * Bytes;
1017         }
1018         if(DataPosInt >= DataSize)
1019             goto skipmix;
1020
1021         if(BufferListItem->next)
1022         {
1023             ALbuffer *NextBuf = BufferListItem->next->buffer;
1024             if(NextBuf && NextBuf->data)
1025             {
1026                 ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
1027                 ulExtraSamples = min(NextBuf->size, ulExtraSamples);
1028                 memcpy(&Data[DataSize*Channels], NextBuf->data, ulExtraSamples);
1029             }
1030         }
1031         else if(ALSource->bLooping)
1032         {
1033             ALbuffer *NextBuf = ALSource->queue->buffer;
1034             if(NextBuf && NextBuf->data)
1035             {
1036                 ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
1037                 ulExtraSamples = min(NextBuf->size, ulExtraSamples);
1038                 memcpy(&Data[DataSize*Channels], NextBuf->data, ulExtraSamples);
1039             }
1040         }
1041         else
1042             memset(&Data[DataSize*Channels], 0, (BUFFER_PADDING*Channels*Bytes));
1043
1044         /* Compute the gain steps for each output channel */
1045         for(i = 0;i < OUTPUTCHANNELS;i++)
1046             dryGainStep[i] = (ALSource->Params.DryGains[i]-DrySend[i]) /
1047                              rampLength;
1048         for(i = 0;i < MAX_SENDS;i++)
1049             wetGainStep[i] = (ALSource->Params.WetGains[i]-WetSend[i]) /
1050                              rampLength;
1051
1052         /* Figure out how many samples we can mix. */
1053         DataSize64 = DataSize;
1054         DataSize64 <<= FRACTIONBITS;
1055         DataPos64 = DataPosInt;
1056         DataPos64 <<= FRACTIONBITS;
1057         DataPos64 += DataPosFrac;
1058         BufferSize = (ALuint)((DataSize64-DataPos64+(increment-1)) / increment);
1059
1060         BufferSize = min(BufferSize, (SamplesToDo-j));
1061
1062         /* Actual sample mixing loop */
1063         k = 0;
1064         Data += DataPosInt*Channels;
1065
1066         if(Channels == 1) /* Mono */
1067         {
1068             while(BufferSize--)
1069             {
1070                 for(i = 0;i < OUTPUTCHANNELS;i++)
1071                     DrySend[i] += dryGainStep[i];
1072                 for(i = 0;i < MAX_SENDS;i++)
1073                     WetSend[i] += wetGainStep[i];
1074
1075                 /* First order interpolator */
1076                 value = lerp(Data[k], Data[k+1], DataPosFrac);
1077
1078                 /* Direct path final mix buffer and panning */
1079                 outsamp = lpFilter4P(DryFilter, 0, value);
1080                 DryBuffer[j][FRONT_LEFT]   += outsamp*DrySend[FRONT_LEFT];
1081                 DryBuffer[j][FRONT_RIGHT]  += outsamp*DrySend[FRONT_RIGHT];
1082                 DryBuffer[j][SIDE_LEFT]    += outsamp*DrySend[SIDE_LEFT];
1083                 DryBuffer[j][SIDE_RIGHT]   += outsamp*DrySend[SIDE_RIGHT];
1084                 DryBuffer[j][BACK_LEFT]    += outsamp*DrySend[BACK_LEFT];
1085                 DryBuffer[j][BACK_RIGHT]   += outsamp*DrySend[BACK_RIGHT];
1086                 DryBuffer[j][FRONT_CENTER] += outsamp*DrySend[FRONT_CENTER];
1087                 DryBuffer[j][BACK_CENTER]  += outsamp*DrySend[BACK_CENTER];
1088
1089                 /* Room path final mix buffer and panning */
1090                 for(i = 0;i < MAX_SENDS;i++)
1091                 {
1092                     outsamp = lpFilter2P(WetFilter[i], 0, value);
1093                     WetBuffer[i][j] += outsamp*WetSend[i];
1094                 }
1095
1096                 DataPosFrac += increment;
1097                 k += DataPosFrac>>FRACTIONBITS;
1098                 DataPosFrac &= FRACTIONMASK;
1099                 j++;
1100             }
1101         }
1102         else if(Channels == 2) /* Stereo */
1103         {
1104             const int chans[] = {
1105                 FRONT_LEFT, FRONT_RIGHT
1106             };
1107             const ALfloat scaler = aluSqrt(1.0f/Channels);
1108
1109 #define DO_MIX() do { \
1110     while(BufferSize--) \
1111     { \
1112         for(i = 0;i < OUTPUTCHANNELS;i++) \
1113             DrySend[i] += dryGainStep[i]; \
1114         for(i = 0;i < MAX_SENDS;i++) \
1115             WetSend[i] += wetGainStep[i]; \
1116  \
1117         for(i = 0;i < Channels;i++) \
1118         { \
1119             value = lerp(Data[k*Channels + i], Data[(k+1)*Channels + i], DataPosFrac); \
1120             outsamp = lpFilter2P(DryFilter, chans[i]*2, value)*DrySend[chans[i]]; \
1121             for(out = 0;out < OUTPUTCHANNELS;out++) \
1122                 DryBuffer[j][out] += outsamp*Matrix[chans[i]][out]; \
1123             for(out = 0;out < MAX_SENDS;out++) \
1124             { \
1125                 outsamp = lpFilter1P(WetFilter[out], chans[i], value); \
1126                 WetBuffer[out][j] += outsamp*WetSend[out]*scaler; \
1127             } \
1128         } \
1129  \
1130         DataPosFrac += increment; \
1131         k += DataPosFrac>>FRACTIONBITS; \
1132         DataPosFrac &= FRACTIONMASK; \
1133         j++; \
1134     } \
1135 } while(0)
1136
1137             DO_MIX();
1138         }
1139         else if(Channels == 4) /* Quad */
1140         {
1141             const int chans[] = {
1142                 FRONT_LEFT, FRONT_RIGHT,
1143                 BACK_LEFT,  BACK_RIGHT
1144             };
1145             const ALfloat scaler = aluSqrt(1.0f/Channels);
1146
1147             DO_MIX();
1148         }
1149         else if(Channels == 6) /* 5.1 */
1150         {
1151             const int chans[] = {
1152                 FRONT_LEFT,   FRONT_RIGHT,
1153                 FRONT_CENTER, LFE,
1154                 BACK_LEFT,    BACK_RIGHT
1155             };
1156             const ALfloat scaler = aluSqrt(1.0f/Channels);
1157
1158             DO_MIX();
1159         }
1160         else if(Channels == 7) /* 6.1 */
1161         {
1162             const int chans[] = {
1163                 FRONT_LEFT,   FRONT_RIGHT,
1164                 FRONT_CENTER, LFE,
1165                 BACK_CENTER,
1166                 SIDE_LEFT,    SIDE_RIGHT
1167             };
1168             const ALfloat scaler = aluSqrt(1.0f/Channels);
1169
1170             DO_MIX();
1171         }
1172         else if(Channels == 8) /* 7.1 */
1173         {
1174             const int chans[] = {
1175                 FRONT_LEFT,   FRONT_RIGHT,
1176                 FRONT_CENTER, LFE,
1177                 BACK_LEFT,    BACK_RIGHT,
1178                 SIDE_LEFT,    SIDE_RIGHT
1179             };
1180             const ALfloat scaler = aluSqrt(1.0f/Channels);
1181
1182             DO_MIX();
1183 #undef DO_MIX
1184         }
1185         else /* Unknown? */
1186         {
1187             for(i = 0;i < OUTPUTCHANNELS;i++)
1188                 DrySend[i] += dryGainStep[i]*BufferSize;
1189             for(i = 0;i < MAX_SENDS;i++)
1190                 WetSend[i] += wetGainStep[i]*BufferSize;
1191             while(BufferSize--)
1192             {
1193                 DataPosFrac += increment;
1194                 k += DataPosFrac>>FRACTIONBITS;
1195                 DataPosFrac &= FRACTIONMASK;
1196                 j++;
1197             }
1198         }
1199         DataPosInt += k;
1200
1201     skipmix:
1202         /* Handle looping sources */
1203         if(DataPosInt >= DataSize)
1204         {
1205             if(BuffersPlayed < (ALSource->BuffersInQueue-1))
1206             {
1207                 BufferListItem = BufferListItem->next;
1208                 BuffersPlayed++;
1209                 DataPosInt -= DataSize;
1210             }
1211             else if(ALSource->bLooping)
1212             {
1213                 BufferListItem = ALSource->queue;
1214                 BuffersPlayed = 0;
1215                 if(ALSource->BuffersInQueue == 1)
1216                     DataPosInt %= DataSize;
1217                 else
1218                     DataPosInt -= DataSize;
1219             }
1220             else
1221             {
1222                 State = AL_STOPPED;
1223                 BufferListItem = ALSource->queue;
1224                 BuffersPlayed = ALSource->BuffersInQueue;
1225                 DataPosInt = 0;
1226                 DataPosFrac = 0;
1227             }
1228         }
1229     }
1230
1231     /* Update source info */
1232     ALSource->state             = State;
1233     ALSource->BuffersPlayed     = BuffersPlayed;
1234     ALSource->position          = DataPosInt;
1235     ALSource->position_fraction = DataPosFrac;
1236     ALSource->Buffer            = BufferListItem->buffer;
1237
1238     for(i = 0;i < OUTPUTCHANNELS;i++)
1239         ALSource->DryGains[i] = DrySend[i];
1240     for(i = 0;i < MAX_SENDS;i++)
1241         ALSource->WetGains[i] = WetSend[i];
1242
1243     ALSource->FirstStart = AL_FALSE;
1244
1245     if((ALSource=ALSource->next) != NULL)
1246         goto another_source;
1247 }
1248
1249 ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
1250 {
1251     float (*DryBuffer)[OUTPUTCHANNELS];
1252     const Channel *ChanMap;
1253     ALuint SamplesToDo;
1254     ALeffectslot *ALEffectSlot;
1255     ALCcontext *ALContext;
1256     int fpuState;
1257     ALuint i, c;
1258
1259     SuspendContext(NULL);
1260
1261 #if defined(HAVE_FESETROUND)
1262     fpuState = fegetround();
1263     fesetround(FE_TOWARDZERO);
1264 #elif defined(HAVE__CONTROLFP)
1265     fpuState = _controlfp(0, 0);
1266     _controlfp(_RC_CHOP, _MCW_RC);
1267 #else
1268     (void)fpuState;
1269 #endif
1270
1271     DryBuffer = device->DryBuffer;
1272     while(size > 0)
1273     {
1274         /* Setup variables */
1275         SamplesToDo = min(size, BUFFERSIZE);
1276
1277         /* Clear mixing buffer */
1278         memset(DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
1279
1280         for(c = 0;c < device->NumContexts;c++)
1281         {
1282             ALContext = device->Contexts[c];
1283             SuspendContext(ALContext);
1284
1285             MixSomeSources(ALContext, DryBuffer, SamplesToDo);
1286
1287             /* effect slot processing */
1288             ALEffectSlot = ALContext->AuxiliaryEffectSlot;
1289             while(ALEffectSlot)
1290             {
1291                 if(ALEffectSlot->EffectState)
1292                     ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot, SamplesToDo, ALEffectSlot->WetBuffer, DryBuffer);
1293
1294                 for(i = 0;i < SamplesToDo;i++)
1295                     ALEffectSlot->WetBuffer[i] = 0.0f;
1296                 ALEffectSlot = ALEffectSlot->next;
1297             }
1298             ProcessContext(ALContext);
1299         }
1300
1301         //Post processing loop
1302         ChanMap = device->DevChannels;
1303         switch(device->Format)
1304         {
1305 #define CHECK_WRITE_FORMAT(bits, type, func)                                  \
1306         case AL_FORMAT_MONO##bits:                                            \
1307             for(i = 0;i < SamplesToDo;i++)                                    \
1308             {                                                                 \
1309                 ((type*)buffer)[0] = (func)(DryBuffer[i][ChanMap[0]]);        \
1310                 buffer = ((type*)buffer) + 1;                                 \
1311             }                                                                 \
1312             break;                                                            \
1313         case AL_FORMAT_STEREO##bits:                                          \
1314             if(device->Bs2b)                                                  \
1315             {                                                                 \
1316                 for(i = 0;i < SamplesToDo;i++)                                \
1317                 {                                                             \
1318                     float samples[2];                                         \
1319                     samples[0] = DryBuffer[i][ChanMap[0]];                    \
1320                     samples[1] = DryBuffer[i][ChanMap[1]];                    \
1321                     bs2b_cross_feed(device->Bs2b, samples);                   \
1322                     ((type*)buffer)[0] = (func)(samples[0]);                  \
1323                     ((type*)buffer)[1] = (func)(samples[1]);                  \
1324                     buffer = ((type*)buffer) + 2;                             \
1325                 }                                                             \
1326             }                                                                 \
1327             else                                                              \
1328             {                                                                 \
1329                 for(i = 0;i < SamplesToDo;i++)                                \
1330                 {                                                             \
1331                     ((type*)buffer)[0] = (func)(DryBuffer[i][ChanMap[0]]);    \
1332                     ((type*)buffer)[1] = (func)(DryBuffer[i][ChanMap[1]]);    \
1333                     buffer = ((type*)buffer) + 2;                             \
1334                 }                                                             \
1335             }                                                                 \
1336             break;                                                            \
1337         case AL_FORMAT_QUAD##bits:                                            \
1338             for(i = 0;i < SamplesToDo;i++)                                    \
1339             {                                                                 \
1340                 ((type*)buffer)[0] = (func)(DryBuffer[i][ChanMap[0]]);        \
1341                 ((type*)buffer)[1] = (func)(DryBuffer[i][ChanMap[1]]);        \
1342                 ((type*)buffer)[2] = (func)(DryBuffer[i][ChanMap[2]]);        \
1343                 ((type*)buffer)[3] = (func)(DryBuffer[i][ChanMap[3]]);        \
1344                 buffer = ((type*)buffer) + 4;                                 \
1345             }                                                                 \
1346             break;                                                            \
1347         case AL_FORMAT_51CHN##bits:                                           \
1348             for(i = 0;i < SamplesToDo;i++)                                    \
1349             {                                                                 \
1350                 ((type*)buffer)[0] = (func)(DryBuffer[i][ChanMap[0]]);        \
1351                 ((type*)buffer)[1] = (func)(DryBuffer[i][ChanMap[1]]);        \
1352                 ((type*)buffer)[2] = (func)(DryBuffer[i][ChanMap[2]]);        \
1353                 ((type*)buffer)[3] = (func)(DryBuffer[i][ChanMap[3]]);        \
1354                 ((type*)buffer)[4] = (func)(DryBuffer[i][ChanMap[4]]);        \
1355                 ((type*)buffer)[5] = (func)(DryBuffer[i][ChanMap[5]]);        \
1356                 buffer = ((type*)buffer) + 6;                                 \
1357             }                                                                 \
1358             break;                                                            \
1359         case AL_FORMAT_61CHN##bits:                                           \
1360             for(i = 0;i < SamplesToDo;i++)                                    \
1361             {                                                                 \
1362                 ((type*)buffer)[0] = (func)(DryBuffer[i][ChanMap[0]]);        \
1363                 ((type*)buffer)[1] = (func)(DryBuffer[i][ChanMap[1]]);        \
1364                 ((type*)buffer)[2] = (func)(DryBuffer[i][ChanMap[2]]);        \
1365                 ((type*)buffer)[3] = (func)(DryBuffer[i][ChanMap[3]]);        \
1366                 ((type*)buffer)[4] = (func)(DryBuffer[i][ChanMap[4]]);        \
1367                 ((type*)buffer)[5] = (func)(DryBuffer[i][ChanMap[5]]);        \
1368                 ((type*)buffer)[6] = (func)(DryBuffer[i][ChanMap[6]]);        \
1369                 buffer = ((type*)buffer) + 7;                                 \
1370             }                                                                 \
1371             break;                                                            \
1372         case AL_FORMAT_71CHN##bits:                                           \
1373             for(i = 0;i < SamplesToDo;i++)                                    \
1374             {                                                                 \
1375                 ((type*)buffer)[0] = (func)(DryBuffer[i][ChanMap[0]]);        \
1376                 ((type*)buffer)[1] = (func)(DryBuffer[i][ChanMap[1]]);        \
1377                 ((type*)buffer)[2] = (func)(DryBuffer[i][ChanMap[2]]);        \
1378                 ((type*)buffer)[3] = (func)(DryBuffer[i][ChanMap[3]]);        \
1379                 ((type*)buffer)[4] = (func)(DryBuffer[i][ChanMap[4]]);        \
1380                 ((type*)buffer)[5] = (func)(DryBuffer[i][ChanMap[5]]);        \
1381                 ((type*)buffer)[6] = (func)(DryBuffer[i][ChanMap[6]]);        \
1382                 ((type*)buffer)[7] = (func)(DryBuffer[i][ChanMap[7]]);        \
1383                 buffer = ((type*)buffer) + 8;                                 \
1384             }                                                                 \
1385             break;
1386
1387 #define AL_FORMAT_MONO32 AL_FORMAT_MONO_FLOAT32
1388 #define AL_FORMAT_STEREO32 AL_FORMAT_STEREO_FLOAT32
1389             CHECK_WRITE_FORMAT(8,  ALubyte, aluF2UB)
1390             CHECK_WRITE_FORMAT(16, ALshort, aluF2S)
1391             CHECK_WRITE_FORMAT(32, ALfloat, aluF2F)
1392 #undef AL_FORMAT_STEREO32
1393 #undef AL_FORMAT_MONO32
1394 #undef CHECK_WRITE_FORMAT
1395
1396             default:
1397                 break;
1398         }
1399
1400         size -= SamplesToDo;
1401     }
1402
1403 #if defined(HAVE_FESETROUND)
1404     fesetround(fpuState);
1405 #elif defined(HAVE__CONTROLFP)
1406     _controlfp(fpuState, 0xfffff);
1407 #endif
1408
1409     ProcessContext(NULL);
1410 }
1411
1412 ALvoid aluHandleDisconnect(ALCdevice *device)
1413 {
1414     ALuint i;
1415
1416     SuspendContext(NULL);
1417     for(i = 0;i < device->NumContexts;i++)
1418     {
1419         ALsource *source;
1420
1421         SuspendContext(device->Contexts[i]);
1422
1423         source = device->Contexts[i]->Source;
1424         while(source)
1425         {
1426             if(source->state == AL_PLAYING)
1427             {
1428                 source->state = AL_STOPPED;
1429                 source->BuffersPlayed = source->BuffersInQueue;
1430                 source->position = 0;
1431                 source->position_fraction = 0;
1432             }
1433             source = source->next;
1434         }
1435         ProcessContext(device->Contexts[i]);
1436     }
1437
1438     device->Connected = ALC_FALSE;
1439     ProcessContext(NULL);
1440 }