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