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