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