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 #define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
  22
  23 #include "config.h"
  24
  25 #include <math.h>
  26 #include "alMain.h"
  27 #include "AL/al.h"
  28 #include "AL/alc.h"
  29 #include "alSource.h"
  30 #include "alBuffer.h"
  31 #include "alThunk.h"
  32 #include "alListener.h"
  33 #include "alAuxEffectSlot.h"
  34 #include "bs2b.h"
  35
  36 #if defined(HAVE_STDINT_H)
  37 #include <stdint.h>
  38 typedef int64_t ALint64;
  39 #elif defined(HAVE___INT64)
  40 typedef __int64 ALint64;
  41 #elif (SIZEOF_LONG == 8)
  42 typedef long ALint64;
  43 #elif (SIZEOF_LONG_LONG == 8)
  44 typedef long long ALint64;
  45 #endif
  46
  47 #ifdef HAVE_SQRTF
  48 #define aluSqrt(x) ((ALfloat)sqrtf((float)(x)))
  49 #else
  50 #define aluSqrt(x) ((ALfloat)sqrt((double)(x)))
  51 #endif
  52
  53 #ifdef HAVE_ACOSF
  54 #define aluAcos(x) ((ALfloat)acosf((float)(x)))
  55 #else
  56 #define aluAcos(x) ((ALfloat)acos((double)(x)))
  57 #endif
  58
  59 // fixes for mingw32.
  60 #if defined(max) && !defined(__max)
  61 #define __max max
  62 #endif
  63 #if defined(min) && !defined(__min)
  64 #define __min min
  65 #endif
  66
  67 #define BUFFERSIZE 48000
  68 #define FRACTIONBITS 14
  69 #define FRACTIONMASK ((1L<<FRACTIONBITS)-1)
  70 #define MAX_PITCH 4
  71
  72 enum {
  73     FRONT_LEFT = 0,
  74     FRONT_RIGHT,
  75     SIDE_LEFT,
  76     SIDE_RIGHT,
  77     BACK_LEFT,
  78     BACK_RIGHT,
  79     CENTER,
  80     LFE,
  81
  82     OUTPUTCHANNELS
  83 };
  84
  85 ALboolean DuplicateStereo = AL_FALSE;
  86
  87 /* NOTE: The AL_FORMAT_REAR* enums aren't handled here be cause they're
  88  *       converted to AL_FORMAT_QUAD* when loaded */
  89 __inline ALuint aluBytesFromFormat(ALenum format)
  90 {
  91     switch(format)
  92     {
  93         case AL_FORMAT_MONO8:
  94         case AL_FORMAT_STEREO8:
  95         case AL_FORMAT_QUAD8_LOKI:
  96         case AL_FORMAT_QUAD8:
  97         case AL_FORMAT_51CHN8:
  98         case AL_FORMAT_61CHN8:
  99         case AL_FORMAT_71CHN8:
 100             return 1;
 101
 102         case AL_FORMAT_MONO16:
 103         case AL_FORMAT_STEREO16:
 104         case AL_FORMAT_QUAD16_LOKI:
 105         case AL_FORMAT_QUAD16:
 106         case AL_FORMAT_51CHN16:
 107         case AL_FORMAT_61CHN16:
 108         case AL_FORMAT_71CHN16:
 109             return 2;
 110
 111         case AL_FORMAT_MONO_FLOAT32:
 112         case AL_FORMAT_STEREO_FLOAT32:
 113         case AL_FORMAT_QUAD32:
 114         case AL_FORMAT_51CHN32:
 115         case AL_FORMAT_61CHN32:
 116         case AL_FORMAT_71CHN32:
 117             return 4;
 118
 119         default:
 120             return 0;
 121     }
 122 }
 123
 124 __inline ALuint aluChannelsFromFormat(ALenum format)
 125 {
 126     switch(format)
 127     {
 128         case AL_FORMAT_MONO8:
 129         case AL_FORMAT_MONO16:
 130         case AL_FORMAT_MONO_FLOAT32:
 131             return 1;
 132
 133         case AL_FORMAT_STEREO8:
 134         case AL_FORMAT_STEREO16:
 135         case AL_FORMAT_STEREO_FLOAT32:
 136             return 2;
 137
 138         case AL_FORMAT_QUAD8_LOKI:
 139         case AL_FORMAT_QUAD16_LOKI:
 140         case AL_FORMAT_QUAD8:
 141         case AL_FORMAT_QUAD16:
 142         case AL_FORMAT_QUAD32:
 143             return 4;
 144
 145         case AL_FORMAT_51CHN8:
 146         case AL_FORMAT_51CHN16:
 147         case AL_FORMAT_51CHN32:
 148             return 6;
 149
 150         case AL_FORMAT_61CHN8:
 151         case AL_FORMAT_61CHN16:
 152         case AL_FORMAT_61CHN32:
 153             return 7;
 154
 155         case AL_FORMAT_71CHN8:
 156         case AL_FORMAT_71CHN16:
 157         case AL_FORMAT_71CHN32:
 158             return 8;
 159
 160         default:
 161             return 0;
 162     }
 163 }
 164
 165
 166 static __inline ALshort aluF2S(ALfloat Value)
 167 {
 168     ALint i;
 169
 170     i = (ALint)Value;
 171     i = __min( 32767, i);
 172     i = __max(-32768, i);
 173     return ((ALshort)i);
 174 }
 175
 176 static __inline ALvoid aluCrossproduct(ALfloat *inVector1,ALfloat *inVector2,ALfloat *outVector)
 177 {
 178     outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
 179     outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
 180     outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
 181 }
 182
 183 static __inline ALfloat aluDotproduct(ALfloat *inVector1,ALfloat *inVector2)
 184 {
 185     return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
 186            inVector1[2]*inVector2[2];
 187 }
 188
 189 static __inline ALvoid aluNormalize(ALfloat *inVector)
 190 {
 191     ALfloat length, inverse_length;
 192
 193     length = aluSqrt(aluDotproduct(inVector, inVector));
 194     if(length != 0.0f)
 195     {
 196         inverse_length = 1.0f/length;
 197         inVector[0] *= inverse_length;
 198         inVector[1] *= inverse_length;
 199         inVector[2] *= inverse_length;
 200     }
 201 }
 202
 203 static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat matrix[3][3])
 204 {
 205     ALfloat result[3];
 206
 207     result[0] = vector[0]*matrix[0][0] + vector[1]*matrix[1][0] + vector[2]*matrix[2][0];
 208     result[1] = vector[0]*matrix[0][1] + vector[1]*matrix[1][1] + vector[2]*matrix[2][1];
 209     result[2] = vector[0]*matrix[0][2] + vector[1]*matrix[1][2] + vector[2]*matrix[2][2];
 210     memcpy(vector, result, sizeof(result));
 211 }
 212
 213 static __inline ALfloat aluComputeSample(ALfloat GainHF, ALfloat sample, ALfloat LastSample)
 214 {
 215     if(GainHF < 1.0f)
 216     {
 217         if(GainHF > 0.0f)
 218         {
 219             sample *= GainHF;
 220             sample += LastSample * (1.0f-GainHF);
 221         }
 222         else
 223             sample = 0.0f;
 224     }
 225
 226     return sample;
 227 }
 228
 229 static ALvoid CalcSourceParams(ALCcontext *ALContext, ALsource *ALSource,
 230                                ALenum isMono, ALenum OutputFormat,
 231                                ALfloat *drysend, ALfloat *wetsend,
 232                                ALfloat *pitch, ALfloat *drygainhf,
 233                                ALfloat *wetgainhf)
 234 {
 235     ALfloat InnerAngle,OuterAngle,Angle,Distance,DryMix,WetMix=0.0f;
 236     ALfloat Direction[3],Position[3],SourceToListener[3];
 237     ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff,OuterGainHF;
 238     ALfloat ConeVolume,SourceVolume,PanningFB,PanningLR,ListenerGain;
 239     ALfloat U[3],V[3],N[3];
 240     ALfloat DopplerFactor, DopplerVelocity, flSpeedOfSound, flMaxVelocity;
 241     ALfloat Matrix[3][3];
 242     ALfloat flAttenuation;
 243     ALfloat RoomAttenuation;
 244     ALfloat MetersPerUnit;
 245     ALfloat RoomRolloff;
 246     ALfloat DryGainHF = 1.0f;
 247     ALfloat WetGainHF = 1.0f;
 248
 249     //Get context properties
 250     DopplerFactor   = ALContext->DopplerFactor;
 251     DopplerVelocity = ALContext->DopplerVelocity;
 252     flSpeedOfSound  = ALContext->flSpeedOfSound;
 253
 254     //Get listener properties
 255     ListenerGain = ALContext->Listener.Gain;
 256     MetersPerUnit = ALContext->Listener.MetersPerUnit;
 257
 258     //Get source properties
 259     SourceVolume = ALSource->flGain;
 260     memcpy(Position,  ALSource->vPosition,    sizeof(ALSource->vPosition));
 261     memcpy(Direction, ALSource->vOrientation, sizeof(ALSource->vOrientation));
 262     MinVolume    = ALSource->flMinGain;
 263     MaxVolume    = ALSource->flMaxGain;
 264     MinDist      = ALSource->flRefDistance;
 265     MaxDist      = ALSource->flMaxDistance;
 266     Rolloff      = ALSource->flRollOffFactor;
 267     InnerAngle   = ALSource->flInnerAngle;
 268     OuterAngle   = ALSource->flOuterAngle;
 269     OuterGainHF  = ALSource->OuterGainHF;
 270     RoomRolloff  = ALSource->RoomRolloffFactor;
 271
 272     //Only apply 3D calculations for mono buffers
 273     if(isMono != AL_FALSE)
 274     {
 275         //1. Translate Listener to origin (convert to head relative)
 276         // Note that Direction and SourceToListener are *not* transformed.
 277         // SourceToListener is used with the source and listener velocities,
 278         // which are untransformed, and Direction is used with SourceToListener
 279         // for the sound cone
 280         if(ALSource->bHeadRelative==AL_FALSE)
 281         {
 282             // Build transform matrix
 283             aluCrossproduct(ALContext->Listener.Forward, ALContext->Listener.Up, U); // Right-vector
 284             aluNormalize(U);  // Normalized Right-vector
 285             memcpy(V, ALContext->Listener.Up, sizeof(V));   // Up-vector
 286             aluNormalize(V);  // Normalized Up-vector
 287             memcpy(N, ALContext->Listener.Forward, sizeof(N));  // At-vector
 288             aluNormalize(N);  // Normalized At-vector
 289             Matrix[0][0] = U[0]; Matrix[0][1] = V[0]; Matrix[0][2] = -N[0];
 290             Matrix[1][0] = U[1]; Matrix[1][1] = V[1]; Matrix[1][2] = -N[1];
 291             Matrix[2][0] = U[2]; Matrix[2][1] = V[2]; Matrix[2][2] = -N[2];
 292
 293             // Translate source position into listener space
 294             Position[0] -= ALContext->Listener.Position[0];
 295             Position[1] -= ALContext->Listener.Position[1];
 296             Position[2] -= ALContext->Listener.Position[2];
 297
 298             SourceToListener[0] = -Position[0];
 299             SourceToListener[1] = -Position[1];
 300             SourceToListener[2] = -Position[2];
 301
 302             // Transform source position and direction into listener space
 303             aluMatrixVector(Position, Matrix);
 304         }
 305         else
 306         {
 307             SourceToListener[0] = -Position[0];
 308             SourceToListener[1] = -Position[1];
 309             SourceToListener[2] = -Position[2];
 310         }
 311         aluNormalize(SourceToListener);
 312         aluNormalize(Direction);
 313
 314         //2. Calculate distance attenuation
 315         Distance = aluSqrt(aluDotproduct(Position, Position));
 316
 317         if(ALSource->Send[0].Slot && !ALSource->Send[0].Slot->AuxSendAuto)
 318         {
 319             if(ALSource->Send[0].Slot->effect.type == AL_EFFECT_REVERB)
 320                 RoomRolloff = ALSource->Send[0].Slot->effect.Reverb.RoomRolloffFactor;
 321         }
 322
 323         flAttenuation = 1.0f;
 324         RoomAttenuation = 1.0f;
 325         switch (ALContext->DistanceModel)
 326         {
 327             case AL_INVERSE_DISTANCE_CLAMPED:
 328                 Distance=__max(Distance,MinDist);
 329                 Distance=__min(Distance,MaxDist);
 330                 if (MaxDist < MinDist)
 331                     break;
 332                 //fall-through
 333             case AL_INVERSE_DISTANCE:
 334                 if (MinDist > 0.0f)
 335                 {
 336                     if ((MinDist + (Rolloff * (Distance - MinDist))) > 0.0f)
 337                         flAttenuation = MinDist / (MinDist + (Rolloff * (Distance - MinDist)));
 338                     if ((MinDist + (RoomRolloff * (Distance - MinDist))) > 0.0f)
 339                         RoomAttenuation = MinDist / (MinDist + (RoomRolloff * (Distance - MinDist)));
 340                 }
 341                 break;
 342
 343             case AL_LINEAR_DISTANCE_CLAMPED:
 344                 Distance=__max(Distance,MinDist);
 345                 Distance=__min(Distance,MaxDist);
 346                 if (MaxDist < MinDist)
 347                     break;
 348                 //fall-through
 349             case AL_LINEAR_DISTANCE:
 350                 Distance=__min(Distance,MaxDist);
 351                 if (MaxDist != MinDist)
 352                 {
 353                     flAttenuation = 1.0f - (Rolloff*(Distance-MinDist)/(MaxDist - MinDist));
 354                     RoomAttenuation = 1.0f - (RoomRolloff*(Distance-MinDist)/(MaxDist - MinDist));
 355                 }
 356                 break;
 357
 358             case AL_EXPONENT_DISTANCE_CLAMPED:
 359                 Distance=__max(Distance,MinDist);
 360                 Distance=__min(Distance,MaxDist);
 361                 if (MaxDist < MinDist)
 362                     break;
 363                 //fall-through
 364             case AL_EXPONENT_DISTANCE:
 365                 if ((Distance > 0.0f) && (MinDist > 0.0f))
 366                 {
 367                     flAttenuation = (ALfloat)pow(Distance/MinDist, -Rolloff);
 368                     RoomAttenuation = (ALfloat)pow(Distance/MinDist, -RoomRolloff);
 369                 }
 370                 break;
 371
 372             case AL_NONE:
 373             default:
 374                 flAttenuation = 1.0f;
 375                 RoomAttenuation = 1.0f;
 376                 break;
 377         }
 378
 379         // Source Gain + Attenuation and clamp to Min/Max Gain
 380         DryMix = SourceVolume * flAttenuation;
 381         DryMix = __min(DryMix,MaxVolume);
 382         DryMix = __max(DryMix,MinVolume);
 383
 384         WetMix = SourceVolume * (ALSource->WetGainAuto ?
 385                                  RoomAttenuation : 1.0f);
 386         WetMix = __min(WetMix,MaxVolume);
 387         WetMix = __max(WetMix,MinVolume);
 388
 389         //3. Apply directional soundcones
 390         Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * 180.0f /
 391                 3.141592654f;
 392         if(Angle >= InnerAngle && Angle <= OuterAngle)
 393         {
 394             ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
 395             ConeVolume = (1.0f+(ALSource->flOuterGain-1.0f)*scale);
 396             if(ALSource->WetGainAuto)
 397                 WetMix *= ConeVolume;
 398             if(ALSource->DryGainHFAuto)
 399                 DryGainHF *= (1.0f+(OuterGainHF-1.0f)*scale);
 400             if(ALSource->WetGainHFAuto)
 401                 WetGainHF *= (1.0f+(OuterGainHF-1.0f)*scale);
 402         }
 403         else if(Angle > OuterAngle)
 404         {
 405             ConeVolume = (1.0f+(ALSource->flOuterGain-1.0f));
 406             if(ALSource->WetGainAuto)
 407                 WetMix *= ConeVolume;
 408             if(ALSource->DryGainHFAuto)
 409                 DryGainHF *= (1.0f+(OuterGainHF-1.0f));
 410             if(ALSource->WetGainHFAuto)
 411                 WetGainHF *= (1.0f+(OuterGainHF-1.0f));
 412         }
 413         else
 414             ConeVolume = 1.0f;
 415
 416         //4. Calculate Velocity
 417         if(DopplerFactor != 0.0f)
 418         {
 419             ALfloat flVSS, flVLS = 0.0f;
 420
 421             if(ALSource->bHeadRelative==AL_FALSE)
 422                 flVLS = aluDotproduct(ALContext->Listener.Velocity, SourceToListener);
 423             flVSS = aluDotproduct(ALSource->vVelocity, SourceToListener);
 424
 425             flMaxVelocity = (DopplerVelocity * flSpeedOfSound) / DopplerFactor;
 426
 427             if (flVSS >= flMaxVelocity)
 428                 flVSS = (flMaxVelocity - 1.0f);
 429             else if (flVSS <= -flMaxVelocity)
 430                 flVSS = -flMaxVelocity + 1.0f;
 431
 432             if (flVLS >= flMaxVelocity)
 433                 flVLS = (flMaxVelocity - 1.0f);
 434             else if (flVLS <= -flMaxVelocity)
 435                 flVLS = -flMaxVelocity + 1.0f;
 436
 437             pitch[0] = ALSource->flPitch *
 438                        ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVLS)) /
 439                        ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVSS));
 440         }
 441         else
 442             pitch[0] = ALSource->flPitch;
 443
 444         //5. Apply filter gains and filters
 445         switch(ALSource->DirectFilter.type)
 446         {
 447             case AL_FILTER_LOWPASS:
 448                 DryMix *= ALSource->DirectFilter.Gain;
 449                 DryGainHF *= ALSource->DirectFilter.GainHF;
 450                 break;
 451         }
 452
 453         switch(ALSource->Send[0].WetFilter.type)
 454         {
 455             case AL_FILTER_LOWPASS:
 456                 WetMix *= ALSource->Send[0].WetFilter.Gain;
 457                 WetGainHF *= ALSource->Send[0].WetFilter.GainHF;
 458                 break;
 459         }
 460
 461         if(ALSource->AirAbsorptionFactor > 0.0f)
 462             DryGainHF *= pow(ALSource->AirAbsorptionFactor * AIRABSORBGAINHF,
 463                              Distance * MetersPerUnit);
 464
 465         if(ALSource->Send[0].Slot)
 466         {
 467             WetMix *= ALSource->Send[0].Slot->Gain;
 468
 469             if(ALSource->Send[0].Slot->effect.type == AL_EFFECT_REVERB)
 470             {
 471                 WetGainHF *= ALSource->Send[0].Slot->effect.Reverb.GainHF;
 472                 WetGainHF *= pow(ALSource->Send[0].Slot->effect.Reverb.AirAbsorptionGainHF,
 473                                  Distance * MetersPerUnit);
 474             }
 475         }
 476         else
 477         {
 478             WetMix = 0.0f;
 479             WetGainHF = 1.0f;
 480         }
 481
 482         DryMix *= ListenerGain * ConeVolume;
 483         WetMix *= ListenerGain;
 484
 485         //6. Convert normalized position into pannings, then into channel volumes
 486         aluNormalize(Position);
 487         switch(aluChannelsFromFormat(OutputFormat))
 488         {
 489             case 1:
 490                 drysend[FRONT_LEFT]  = DryMix * aluSqrt(1.0f); //Direct
 491                 drysend[FRONT_RIGHT] = DryMix * aluSqrt(1.0f); //Direct
 492                 wetsend[FRONT_LEFT]  = WetMix * aluSqrt(1.0f); //Room
 493                 wetsend[FRONT_RIGHT] = WetMix * aluSqrt(1.0f); //Room
 494                 break;
 495             case 2:
 496                 PanningLR = 0.5f + 0.5f*Position[0];
 497                 drysend[FRONT_LEFT]  = DryMix * aluSqrt(1.0f-PanningLR); //L Direct
 498                 drysend[FRONT_RIGHT] = DryMix * aluSqrt(     PanningLR); //R Direct
 499                 wetsend[FRONT_LEFT]  = WetMix * aluSqrt(1.0f-PanningLR); //L Room
 500                 wetsend[FRONT_RIGHT] = WetMix * aluSqrt(     PanningLR); //R Room
 501                 break;
 502             case 4:
 503             /* TODO: Add center/lfe channel in spatial calculations? */
 504             case 6:
 505                 // Apply a scalar so each individual speaker has more weight
 506                 PanningLR = 0.5f + (0.5f*Position[0]*1.41421356f);
 507                 PanningLR = __min(1.0f, PanningLR);
 508                 PanningLR = __max(0.0f, PanningLR);
 509                 PanningFB = 0.5f + (0.5f*Position[2]*1.41421356f);
 510                 PanningFB = __min(1.0f, PanningFB);
 511                 PanningFB = __max(0.0f, PanningFB);
 512                 drysend[FRONT_LEFT]  = DryMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
 513                 drysend[FRONT_RIGHT] = DryMix * aluSqrt((     PanningLR)*(1.0f-PanningFB));
 514                 drysend[BACK_LEFT]   = DryMix * aluSqrt((1.0f-PanningLR)*(     PanningFB));
 515                 drysend[BACK_RIGHT]  = DryMix * aluSqrt((     PanningLR)*(     PanningFB));
 516                 wetsend[FRONT_LEFT]  = WetMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
 517                 wetsend[FRONT_RIGHT] = WetMix * aluSqrt((     PanningLR)*(1.0f-PanningFB));
 518                 wetsend[BACK_LEFT]   = WetMix * aluSqrt((1.0f-PanningLR)*(     PanningFB));
 519                 wetsend[BACK_RIGHT]  = WetMix * aluSqrt((     PanningLR)*(     PanningFB));
 520                 break;
 521             case 7:
 522             case 8:
 523                 PanningFB = 1.0f - fabs(Position[2]*1.15470054f);
 524                 PanningFB = __min(1.0f, PanningFB);
 525                 PanningFB = __max(0.0f, PanningFB);
 526                 PanningLR = 0.5f + (0.5*Position[0]*((1.0f-PanningFB)*2.0f));
 527                 PanningLR = __min(1.0f, PanningLR);
 528                 PanningLR = __max(0.0f, PanningLR);
 529                 if(Position[2] > 0.0f)
 530                 {
 531                     drysend[BACK_LEFT]   = DryMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
 532                     drysend[BACK_RIGHT]  = DryMix * aluSqrt((     PanningLR)*(1.0f-PanningFB));
 533                     drysend[SIDE_LEFT]   = DryMix * aluSqrt((1.0f-PanningLR)*(     PanningFB));
 534                     drysend[SIDE_RIGHT]  = DryMix * aluSqrt((     PanningLR)*(     PanningFB));
 535                     drysend[FRONT_LEFT]  = 0.0f;
 536                     drysend[FRONT_RIGHT] = 0.0f;
 537                     wetsend[BACK_LEFT]   = WetMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
 538                     wetsend[BACK_RIGHT]  = WetMix * aluSqrt((     PanningLR)*(1.0f-PanningFB));
 539                     wetsend[SIDE_LEFT]   = WetMix * aluSqrt((1.0f-PanningLR)*(     PanningFB));
 540                     wetsend[SIDE_RIGHT]  = WetMix * aluSqrt((     PanningLR)*(     PanningFB));
 541                     wetsend[FRONT_LEFT]  = 0.0f;
 542                     wetsend[FRONT_RIGHT] = 0.0f;
 543                 }
 544                 else
 545                 {
 546                     drysend[FRONT_LEFT]  = DryMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
 547                     drysend[FRONT_RIGHT] = DryMix * aluSqrt((     PanningLR)*(1.0f-PanningFB));
 548                     drysend[SIDE_LEFT]   = DryMix * aluSqrt((1.0f-PanningLR)*(     PanningFB));
 549                     drysend[SIDE_RIGHT]  = DryMix * aluSqrt((     PanningLR)*(     PanningFB));
 550                     drysend[BACK_LEFT]   = 0.0f;
 551                     drysend[BACK_RIGHT]  = 0.0f;
 552                     wetsend[FRONT_LEFT]  = WetMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
 553                     wetsend[FRONT_RIGHT] = WetMix * aluSqrt((     PanningLR)*(1.0f-PanningFB));
 554                     wetsend[SIDE_LEFT]   = WetMix * aluSqrt((1.0f-PanningLR)*(     PanningFB));
 555                     wetsend[SIDE_RIGHT]  = WetMix * aluSqrt((     PanningLR)*(     PanningFB));
 556                     wetsend[BACK_LEFT]   = 0.0f;
 557                     wetsend[BACK_RIGHT]  = 0.0f;
 558                 }
 559             default:
 560                 break;
 561         }
 562
 563         *drygainhf = DryGainHF;
 564         *wetgainhf = WetGainHF;
 565     }
 566     else
 567     {
 568         //1. Multi-channel buffers always play "normal"
 569         pitch[0] = ALSource->flPitch;
 570
 571         drysend[FRONT_LEFT]  = SourceVolume * ListenerGain;
 572         drysend[FRONT_RIGHT] = SourceVolume * ListenerGain;
 573         drysend[SIDE_LEFT]   = SourceVolume * ListenerGain;
 574         drysend[SIDE_RIGHT]  = SourceVolume * ListenerGain;
 575         drysend[BACK_LEFT]   = SourceVolume * ListenerGain;
 576         drysend[BACK_RIGHT]  = SourceVolume * ListenerGain;
 577         drysend[CENTER]      = SourceVolume * ListenerGain;
 578         drysend[LFE]         = SourceVolume * ListenerGain;
 579         wetsend[FRONT_LEFT]  = 0.0f;
 580         wetsend[FRONT_RIGHT] = 0.0f;
 581         wetsend[SIDE_LEFT]   = 0.0f;
 582         wetsend[SIDE_RIGHT]  = 0.0f;
 583         wetsend[BACK_LEFT]   = 0.0f;
 584         wetsend[BACK_RIGHT]  = 0.0f;
 585         wetsend[CENTER]      = 0.0f;
 586         wetsend[LFE]         = 0.0f;
 587         WetGainHF = 1.0f;
 588
 589         *drygainhf = DryGainHF;
 590         *wetgainhf = WetGainHF;
 591     }
 592 }
 593
 594 ALvoid aluMixData(ALCcontext *ALContext,ALvoid *buffer,ALsizei size,ALenum format)
 595 {
 596     static float DryBuffer[BUFFERSIZE][OUTPUTCHANNELS];
 597     static float WetBuffer[BUFFERSIZE][OUTPUTCHANNELS];
 598     static float ReverbBuffer[BUFFERSIZE];
 599     ALfloat DrySend[OUTPUTCHANNELS] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
 600     ALfloat WetSend[OUTPUTCHANNELS] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
 601     ALfloat DryGainHF = 0.0f;
 602     ALfloat WetGainHF = 0.0f;
 603     ALuint BlockAlign,BufferSize;
 604     ALuint DataSize=0,DataPosInt=0,DataPosFrac=0;
 605     ALuint Channels,Frequency,ulExtraSamples;
 606     ALfloat DrySample, WetSample;
 607     ALboolean doReverb;
 608     ALfloat Pitch;
 609     ALint Looping,increment,State;
 610     ALuint Buffer,fraction;
 611     ALuint SamplesToDo;
 612     ALsource *ALSource;
 613     ALbuffer *ALBuffer;
 614     ALeffectslot *ALEffectSlot;
 615     ALfloat value;
 616     ALshort *Data;
 617     ALuint i,j,k;
 618     ALbufferlistitem *BufferListItem;
 619     ALuint loop;
 620     ALint64 DataSize64,DataPos64;
 621
 622     SuspendContext(ALContext);
 623
 624     //Figure output format variables
 625     BlockAlign  = aluChannelsFromFormat(format);
 626     BlockAlign *= aluBytesFromFormat(format);
 627
 628     size /= BlockAlign;
 629     while(size > 0)
 630     {
 631         //Setup variables
 632         ALEffectSlot = (ALContext ? ALContext->AuxiliaryEffectSlot : NULL);
 633         ALSource = (ALContext ? ALContext->Source : NULL);
 634         SamplesToDo = min(size, BUFFERSIZE);
 635
 636         //Clear mixing buffer
 637         memset(DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
 638         memset(WetBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
 639         memset(ReverbBuffer, 0, SamplesToDo*sizeof(ALfloat));
 640
 641         //Actual mixing loop
 642         while(ALSource)
 643         {
 644             j = 0;
 645             State = ALSource->state;
 646
 647             doReverb = ((ALSource->Send[0].Slot &&
 648                             ALSource->Send[0].Slot->effect.type == AL_EFFECT_REVERB) ?
 649                         AL_TRUE : AL_FALSE);
 650
 651             while(State == AL_PLAYING && j < SamplesToDo)
 652             {
 653                 DataSize = 0;
 654                 DataPosInt = 0;
 655                 DataPosFrac = 0;
 656
 657                 //Get buffer info
 658                 if((Buffer = ALSource->ulBufferID))
 659                 {
 660                     ALBuffer = (ALbuffer*)ALTHUNK_LOOKUPENTRY(Buffer);
 661
 662                     Data      = ALBuffer->data;
 663                     Channels  = aluChannelsFromFormat(ALBuffer->format);
 664                     DataSize  = ALBuffer->size;
 665                     Frequency = ALBuffer->frequency;
 666
 667                     CalcSourceParams(ALContext, ALSource,
 668                                         (Channels==1) ? AL_TRUE : AL_FALSE,
 669                                         format, DrySend, WetSend, &Pitch,
 670                                         &DryGainHF, &WetGainHF);
 671
 672
 673                     Pitch = (Pitch*Frequency) / ALContext->Frequency;
 674                     DataSize /= Channels * aluBytesFromFormat(ALBuffer->format);
 675
 676                     //Get source info
 677                     DataPosInt = ALSource->position;
 678                     DataPosFrac = ALSource->position_fraction;
 679                     DrySample = ALSource->LastDrySample;
 680                     WetSample = ALSource->LastWetSample;
 681
 682                     //Compute 18.14 fixed point step
 683                     increment = (ALint)(Pitch*(ALfloat)(1L<<FRACTIONBITS));
 684                     if(increment > (MAX_PITCH<<FRACTIONBITS))
 685                         increment = (MAX_PITCH<<FRACTIONBITS);
 686
 687                     //Figure out how many samples we can mix.
 688                     //Pitch must be <= 4 (the number below !)
 689                     DataSize64 = DataSize+MAX_PITCH;
 690                     DataSize64 <<= FRACTIONBITS;
 691                     DataPos64 = DataPosInt;
 692                     DataPos64 <<= FRACTIONBITS;
 693                     DataPos64 += DataPosFrac;
 694                     BufferSize = (ALuint)((DataSize64-DataPos64) / increment);
 695                     BufferListItem = ALSource->queue;
 696                     for(loop = 0; loop < ALSource->BuffersPlayed; loop++)
 697                     {
 698                         if(BufferListItem)
 699                             BufferListItem = BufferListItem->next;
 700                     }
 701                     if (BufferListItem)
 702                     {
 703                         if (BufferListItem->next)
 704                         {
 705                             ALbuffer *NextBuf = (ALbuffer*)ALTHUNK_LOOKUPENTRY(BufferListItem->next->buffer);
 706                             if(NextBuf && NextBuf->data)
 707                             {
 708                                 ulExtraSamples = min(NextBuf->size, (ALint)(16*Channels));
 709                                 memcpy(&Data[DataSize*Channels], NextBuf->data, ulExtraSamples);
 710                             }
 711                         }
 712                         else if (ALSource->bLooping)
 713                         {
 714                             ALbuffer *NextBuf = (ALbuffer*)ALTHUNK_LOOKUPENTRY(ALSource->queue->buffer);
 715                             if (NextBuf && NextBuf->data)
 716                             {
 717                                 ulExtraSamples = min(NextBuf->size, (ALint)(16*Channels));
 718                                 memcpy(&Data[DataSize*Channels], NextBuf->data, ulExtraSamples);
 719                             }
 720                         }
 721                     }
 722                     BufferSize = min(BufferSize, (SamplesToDo-j));
 723
 724                     //Actual sample mixing loop
 725                     Data += DataPosInt*Channels;
 726                     while(BufferSize--)
 727                     {
 728                         k = DataPosFrac>>FRACTIONBITS;
 729                         fraction = DataPosFrac&FRACTIONMASK;
 730                         if(Channels==1)
 731                         {
 732                             //First order interpolator
 733                             ALfloat sample = (ALfloat)((ALshort)(((Data[k]*((1L<<FRACTIONBITS)-fraction))+(Data[k+1]*(fraction)))>>FRACTIONBITS));
 734
 735                             //Direct path final mix buffer and panning
 736                             DrySample = aluComputeSample(DryGainHF, sample, DrySample);
 737                             DryBuffer[j][FRONT_LEFT]  += DrySample*DrySend[FRONT_LEFT];
 738                             DryBuffer[j][FRONT_RIGHT] += DrySample*DrySend[FRONT_RIGHT];
 739                             DryBuffer[j][SIDE_LEFT]   += DrySample*DrySend[SIDE_LEFT];
 740                             DryBuffer[j][SIDE_RIGHT]  += DrySample*DrySend[SIDE_RIGHT];
 741                             DryBuffer[j][BACK_LEFT]   += DrySample*DrySend[BACK_LEFT];
 742                             DryBuffer[j][BACK_RIGHT]  += DrySample*DrySend[BACK_RIGHT];
 743                             //Room path final mix buffer and panning
 744                             WetSample = aluComputeSample(WetGainHF, sample, WetSample);
 745                             if(doReverb)
 746                                 ReverbBuffer[j] += WetSample;
 747                             else
 748                             {
 749                                 WetBuffer[j][FRONT_LEFT]  += WetSample*WetSend[FRONT_LEFT];
 750                                 WetBuffer[j][FRONT_RIGHT] += WetSample*WetSend[FRONT_RIGHT];
 751                                 WetBuffer[j][SIDE_LEFT]   += WetSample*WetSend[SIDE_LEFT];
 752                                 WetBuffer[j][SIDE_RIGHT]  += WetSample*WetSend[SIDE_RIGHT];
 753                                 WetBuffer[j][BACK_LEFT]   += WetSample*WetSend[BACK_LEFT];
 754                                 WetBuffer[j][BACK_RIGHT]  += WetSample*WetSend[BACK_RIGHT];
 755                             }
 756                         }
 757                         else
 758                         {
 759                             ALfloat samp1, samp2;
 760                             //First order interpolator (front left)
 761                             samp1 = (ALfloat)((ALshort)(((Data[k*Channels  ]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels  ]*(fraction)))>>FRACTIONBITS));
 762                             DryBuffer[j][FRONT_LEFT] += samp1*DrySend[FRONT_LEFT];
 763                             WetBuffer[j][FRONT_LEFT] += samp1*WetSend[FRONT_LEFT];
 764                             //First order interpolator (front right)
 765                             samp2 = (ALfloat)((ALshort)(((Data[k*Channels+1]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels+1]*(fraction)))>>FRACTIONBITS));
 766                             DryBuffer[j][FRONT_RIGHT] += samp2*DrySend[FRONT_RIGHT];
 767                             WetBuffer[j][FRONT_RIGHT] += samp2*WetSend[FRONT_RIGHT];
 768                             if(Channels >= 4)
 769                             {
 770                                 int i = 2;
 771                                 if(Channels >= 6)
 772                                 {
 773                                     if(Channels != 7)
 774                                     {
 775                                         //First order interpolator (center)
 776                                         value = (ALfloat)((ALshort)(((Data[k*Channels+i]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels+i]*(fraction)))>>FRACTIONBITS));
 777                                         DryBuffer[j][CENTER] += value*DrySend[CENTER];
 778                                         WetBuffer[j][CENTER] += value*WetSend[CENTER];
 779                                         i++;
 780                                     }
 781                                     //First order interpolator (lfe)
 782                                     value = (ALfloat)((ALshort)(((Data[k*Channels+i]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels+i]*(fraction)))>>FRACTIONBITS));
 783                                     DryBuffer[j][LFE] += value*DrySend[LFE];
 784                                     WetBuffer[j][LFE] += value*WetSend[LFE];
 785                                     i++;
 786                                 }
 787                                 //First order interpolator (back left)
 788                                 value = (ALfloat)((ALshort)(((Data[k*Channels+i]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels+i]*(fraction)))>>FRACTIONBITS));
 789                                 DryBuffer[j][BACK_LEFT] += value*DrySend[BACK_LEFT];
 790                                 WetBuffer[j][BACK_LEFT] += value*WetSend[BACK_LEFT];
 791                                 i++;
 792                                 //First order interpolator (back right)
 793                                 value = (ALfloat)((ALshort)(((Data[k*Channels+i]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels+i]*(fraction)))>>FRACTIONBITS));
 794                                 DryBuffer[j][BACK_RIGHT] += value*DrySend[BACK_RIGHT];
 795                                 WetBuffer[j][BACK_RIGHT] += value*WetSend[BACK_RIGHT];
 796                                 i++;
 797                                 if(Channels >= 7)
 798                                 {
 799                                     //First order interpolator (side left)
 800                                     value = (ALfloat)((ALshort)(((Data[k*Channels+i]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels+i]*(fraction)))>>FRACTIONBITS));
 801                                     DryBuffer[j][SIDE_LEFT] += value*DrySend[SIDE_LEFT];
 802                                     WetBuffer[j][SIDE_LEFT] += value*WetSend[SIDE_LEFT];
 803                                     i++;
 804                                     //First order interpolator (side right)
 805                                     value = (ALfloat)((ALshort)(((Data[k*Channels+i]*((1L<<FRACTIONBITS)-fraction))+(Data[(k+1)*Channels+i]*(fraction)))>>FRACTIONBITS));
 806                                     DryBuffer[j][SIDE_RIGHT] += value*DrySend[SIDE_RIGHT];
 807                                     WetBuffer[j][SIDE_RIGHT] += value*WetSend[SIDE_RIGHT];
 808                                     i++;
 809                                 }
 810                             }
 811                             else if(DuplicateStereo)
 812                             {
 813                                 //Duplicate stereo channels on the back speakers
 814                                 DryBuffer[j][BACK_LEFT] += samp1*DrySend[BACK_LEFT];
 815                                 WetBuffer[j][BACK_LEFT] += samp1*WetSend[BACK_LEFT];
 816                                 DryBuffer[j][BACK_RIGHT] += samp2*DrySend[BACK_RIGHT];
 817                                 WetBuffer[j][BACK_RIGHT] += samp2*WetSend[BACK_RIGHT];
 818                             }
 819                         }
 820                         DataPosFrac += increment;
 821                         j++;
 822                     }
 823                     DataPosInt += (DataPosFrac>>FRACTIONBITS);
 824                     DataPosFrac = (DataPosFrac&FRACTIONMASK);
 825
 826                     //Update source info
 827                     ALSource->position = DataPosInt;
 828                     ALSource->position_fraction = DataPosFrac;
 829                     ALSource->LastDrySample = DrySample;
 830                     ALSource->LastWetSample = WetSample;
 831                 }
 832
 833                 //Handle looping sources
 834                 if(!Buffer || DataPosInt >= DataSize)
 835                 {
 836                     //queueing
 837                     if(ALSource->queue)
 838                     {
 839                         Looping = ALSource->bLooping;
 840                         if(ALSource->BuffersPlayed < (ALSource->BuffersInQueue-1))
 841                         {
 842                             BufferListItem = ALSource->queue;
 843                             for(loop = 0; loop <= ALSource->BuffersPlayed; loop++)
 844                             {
 845                                 if(BufferListItem)
 846                                 {
 847                                     if(!Looping)
 848                                         BufferListItem->bufferstate = PROCESSED;
 849                                     BufferListItem = BufferListItem->next;
 850                                 }
 851                             }
 852                             if(!Looping)
 853                                 ALSource->BuffersProcessed++;
 854                             if(BufferListItem)
 855                                 ALSource->ulBufferID = BufferListItem->buffer;
 856                             ALSource->position = DataPosInt-DataSize;
 857                             ALSource->position_fraction = DataPosFrac;
 858                             ALSource->BuffersPlayed++;
 859                         }
 860                         else
 861                         {
 862                             if(!Looping)
 863                             {
 864                                 /* alSourceStop */
 865                                 ALSource->state = AL_STOPPED;
 866                                 ALSource->inuse = AL_FALSE;
 867                                 ALSource->BuffersPlayed = ALSource->BuffersProcessed = ALSource->BuffersInQueue;
 868                                 BufferListItem = ALSource->queue;
 869                                 while(BufferListItem != NULL)
 870                                 {
 871                                     BufferListItem->bufferstate = PROCESSED;
 872                                     BufferListItem = BufferListItem->next;
 873                                 }
 874                             }
 875                             else
 876                             {
 877                                 /* alSourceRewind */
 878                                 /* alSourcePlay */
 879                                 ALSource->state = AL_PLAYING;
 880                                 ALSource->inuse = AL_TRUE;
 881                                 ALSource->play = AL_TRUE;
 882                                 ALSource->BuffersPlayed = 0;
 883                                 ALSource->BufferPosition = 0;
 884                                 ALSource->lBytesPlayed = 0;
 885                                 ALSource->BuffersProcessed = 0;
 886                                 BufferListItem = ALSource->queue;
 887                                 while(BufferListItem != NULL)
 888                                 {
 889                                     BufferListItem->bufferstate = PENDING;
 890                                     BufferListItem = BufferListItem->next;
 891                                 }
 892                                 ALSource->ulBufferID = ALSource->queue->buffer;
 893
 894                                 ALSource->position = DataPosInt-DataSize;
 895                                 ALSource->position_fraction = DataPosFrac;
 896                             }
 897                         }
 898                     }
 899                 }
 900
 901                 //Get source state
 902                 State = ALSource->state;
 903             }
 904
 905             ALSource = ALSource->next;
 906         }
 907
 908         // effect slot processing
 909         while(ALEffectSlot)
 910         {
 911             if(ALEffectSlot->effect.type == AL_EFFECT_REVERB)
 912             {
 913                 ALfloat *DelayBuffer = ALEffectSlot->ReverbBuffer;
 914                 ALuint Pos = ALEffectSlot->ReverbPos;
 915                 ALuint LatePos = ALEffectSlot->ReverbLatePos;
 916                 ALuint ReflectPos = ALEffectSlot->ReverbReflectPos;
 917                 ALuint Length = ALEffectSlot->ReverbLength;
 918                 ALfloat DecayGain = ALEffectSlot->ReverbDecayGain;
 919                 ALfloat DecayHFRatio = ALEffectSlot->effect.Reverb.DecayHFRatio;
 920                 ALfloat Gain = ALEffectSlot->effect.Reverb.Gain;
 921                 ALfloat ReflectGain = ALEffectSlot->effect.Reverb.ReflectionsGain;
 922                 ALfloat LateReverbGain = ALEffectSlot->effect.Reverb.LateReverbGain;
 923                 ALfloat LastDecaySample = ALEffectSlot->LastDecaySample;
 924                 ALfloat sample;
 925
 926                 for(i = 0;i < SamplesToDo;i++)
 927                 {
 928                     DelayBuffer[Pos] = ReverbBuffer[i] * Gain;
 929
 930                     sample = DelayBuffer[ReflectPos] * ReflectGain;
 931
 932                     DelayBuffer[LatePos] *= LateReverbGain;
 933
 934                     Pos = (Pos+1) % Length;
 935                     DelayBuffer[Pos] *= DecayHFRatio;
 936                     DelayBuffer[Pos] += LastDecaySample * (1.0f-DecayHFRatio);
 937                     LastDecaySample = DelayBuffer[Pos];
 938                     DelayBuffer[Pos] *= DecayGain;
 939
 940                     DelayBuffer[LatePos] += DelayBuffer[Pos];
 941
 942                     sample += DelayBuffer[LatePos];
 943
 944                     WetBuffer[i][FRONT_LEFT]  += sample;
 945                     WetBuffer[i][FRONT_RIGHT] += sample;
 946                     WetBuffer[i][SIDE_LEFT]   += sample;
 947                     WetBuffer[i][SIDE_RIGHT]  += sample;
 948                     WetBuffer[i][BACK_LEFT]   += sample;
 949                     WetBuffer[i][BACK_RIGHT]  += sample;
 950
 951                     LatePos = (LatePos+1) % Length;
 952                     ReflectPos = (ReflectPos+1) % Length;
 953                 }
 954
 955                 ALEffectSlot->ReverbPos = Pos;
 956                 ALEffectSlot->ReverbLatePos = LatePos;
 957                 ALEffectSlot->ReverbReflectPos = ReflectPos;
 958                 ALEffectSlot->LastDecaySample = LastDecaySample;
 959             }
 960
 961             ALEffectSlot = ALEffectSlot->next;
 962         }
 963
 964         //Post processing loop
 965         switch(format)
 966         {
 967             case AL_FORMAT_MONO8:
 968                 for(i = 0;i < SamplesToDo;i++)
 969                 {
 970                     ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT]+DryBuffer[i][FRONT_RIGHT]+
 971                                                                 WetBuffer[i][FRONT_LEFT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
 972                     buffer = ((ALubyte*)buffer) + 1;
 973                 }
 974                 break;
 975             case AL_FORMAT_STEREO8:
 976                 if(ALContext && ALContext->bs2b)
 977                 {
 978                     for(i = 0;i < SamplesToDo;i++)
 979                     {
 980                         float samples[2];
 981                         samples[0] = DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT];
 982                         samples[1] = DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT];
 983                         bs2b_cross_feed(ALContext->bs2b, samples);
 984                         ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(samples[0])>>8)+128);
 985                         ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(samples[1])>>8)+128);
 986                         buffer = ((ALubyte*)buffer) + 2;
 987                     }
 988                 }
 989                 else
 990                 {
 991                     for(i = 0;i < SamplesToDo;i++)
 992                     {
 993                         ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
 994                         ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
 995                         buffer = ((ALubyte*)buffer) + 2;
 996                     }
 997                 }
 998                 break;
 999             case AL_FORMAT_QUAD8:
1000                 for(i = 0;i < SamplesToDo;i++)
1001                 {
1002                     ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1003                     ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1004                     ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT])>>8)+128);
1005                     ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1006                     buffer = ((ALubyte*)buffer) + 4;
1007                 }
1008                 break;
1009             case AL_FORMAT_51CHN8:
1010                 for(i = 0;i < SamplesToDo;i++)
1011                 {
1012                     ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1013                     ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1014 #ifdef _WIN32 /* Of course, Windows can't use the same ordering... */
1015                     ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER])>>8)+128);
1016                     ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE])>>8)+128);
1017                     ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT])>>8)+128);
1018                     ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1019 #else
1020                     ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT])>>8)+128);
1021                     ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1022                     ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER])>>8)+128);
1023                     ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE])>>8)+128);
1024 #endif
1025                     buffer = ((ALubyte*)buffer) + 6;
1026                 }
1027                 break;
1028             case AL_FORMAT_61CHN8:
1029                 for(i = 0;i < SamplesToDo;i++)
1030                 {
1031                     ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1032                     ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1033 #ifdef _WIN32
1034                     ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE])>>8)+128);
1035                     ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT])>>8)+128);
1036                     ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1037 #else
1038                     ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT])>>8)+128);
1039                     ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1040                     ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE])>>8)+128);
1041 #endif
1042                     ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_LEFT]  +WetBuffer[i][SIDE_LEFT])>>8)+128);
1043                     ((ALubyte*)buffer)[6] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT])>>8)+128);
1044                     buffer = ((ALubyte*)buffer) + 7;
1045                 }
1046                 break;
1047             case AL_FORMAT_71CHN8:
1048                 for(i = 0;i < SamplesToDo;i++)
1049                 {
1050                     ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1051                     ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1052 #ifdef _WIN32
1053                     ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER])>>8)+128);
1054                     ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE])>>8)+128);
1055                     ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT])>>8)+128);
1056                     ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1057 #else
1058                     ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT])>>8)+128);
1059                     ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1060                     ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER])>>8)+128);
1061                     ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE])>>8)+128);
1062 #endif
1063                     ((ALubyte*)buffer)[6] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_LEFT]  +WetBuffer[i][SIDE_LEFT])>>8)+128);
1064                     ((ALubyte*)buffer)[7] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT])>>8)+128);
1065                     buffer = ((ALubyte*)buffer) + 8;
1066                 }
1067                 break;
1068
1069             case AL_FORMAT_MONO16:
1070                 for(i = 0;i < SamplesToDo;i++)
1071                 {
1072                     ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT]+DryBuffer[i][FRONT_RIGHT]+
1073                                                     WetBuffer[i][FRONT_LEFT]+WetBuffer[i][FRONT_RIGHT]);
1074                     buffer = ((ALshort*)buffer) + 1;
1075                 }
1076                 break;
1077             case AL_FORMAT_STEREO16:
1078                 if(ALContext && ALContext->bs2b)
1079                 {
1080                     for(i = 0;i < SamplesToDo;i++)
1081                     {
1082                         float samples[2];
1083                         samples[0] = DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT];
1084                         samples[1] = DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT];
1085                         bs2b_cross_feed(ALContext->bs2b, samples);
1086                         ((ALshort*)buffer)[0] = aluF2S(samples[0]);
1087                         ((ALshort*)buffer)[1] = aluF2S(samples[1]);
1088                         buffer = ((ALshort*)buffer) + 2;
1089                     }
1090                 }
1091                 else
1092                 {
1093                     for(i = 0;i < SamplesToDo;i++)
1094                     {
1095                         ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1096                         ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1097                         buffer = ((ALshort*)buffer) + 2;
1098                     }
1099                 }
1100                 break;
1101             case AL_FORMAT_QUAD16:
1102                 for(i = 0;i < SamplesToDo;i++)
1103                 {
1104                     ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1105                     ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1106                     ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT]);
1107                     ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1108                     buffer = ((ALshort*)buffer) + 4;
1109                 }
1110                 break;
1111             case AL_FORMAT_51CHN16:
1112                 for(i = 0;i < SamplesToDo;i++)
1113                 {
1114                     ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1115                     ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1116 #ifdef _WIN32
1117                     ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER]);
1118                     ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE]);
1119                     ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT]);
1120                     ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1121 #else
1122                     ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT]);
1123                     ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1124                     ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER]);
1125                     ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE]);
1126 #endif
1127                     buffer = ((ALshort*)buffer) + 6;
1128                 }
1129                 break;
1130             case AL_FORMAT_61CHN16:
1131                 for(i = 0;i < SamplesToDo;i++)
1132                 {
1133                     ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1134                     ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1135 #ifdef _WIN32
1136                     ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE]);
1137                     ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT]);
1138                     ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1139 #else
1140                     ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT]);
1141                     ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1142                     ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE]);
1143 #endif
1144                     ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][SIDE_LEFT]  +WetBuffer[i][SIDE_LEFT]);
1145                     ((ALshort*)buffer)[6] = aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT]);
1146                     buffer = ((ALshort*)buffer) + 7;
1147                 }
1148                 break;
1149             case AL_FORMAT_71CHN16:
1150                 for(i = 0;i < SamplesToDo;i++)
1151                 {
1152                     ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1153                     ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1154 #ifdef _WIN32
1155                     ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER]);
1156                     ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE]);
1157                     ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT]);
1158                     ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1159 #else
1160                     ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT]  +WetBuffer[i][BACK_LEFT]);
1161                     ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1162                     ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][CENTER]     +WetBuffer[i][CENTER]);
1163                     ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][LFE]        +WetBuffer[i][LFE]);
1164 #endif
1165                     ((ALshort*)buffer)[6] = aluF2S(DryBuffer[i][SIDE_LEFT]  +WetBuffer[i][SIDE_LEFT]);
1166                     ((ALshort*)buffer)[7] = aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT]);
1167                     buffer = ((ALshort*)buffer) + 8;
1168                 }
1169                 break;
1170
1171             default:
1172                 break;
1173         }
1174
1175         size -= SamplesToDo;
1176     }
1177
1178     ProcessContext(ALContext);
1179 }