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