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
  30 #if defined(HAVE_STDINT_H)
  31 #include <stdint.h>
  32 typedef int64_t ALint64;
  33 #elif defined(HAVE___INT64)
  34 typedef __int64 ALint64;
  35 #elif (SIZEOF_LONG == 8)
  36 typedef long ALint64;
  37 #elif (SIZEOF_LONG_LONG == 8)
  38 typedef long long ALint64;
  39 #endif
  40
  41 #ifdef HAVE_SQRTF
  42 #define aluSqrt(x) ((ALfloat)sqrtf((float)(x)))
  43 #else
  44 #define aluSqrt(x) ((ALfloat)sqrt((double)(x)))
  45 #endif
  46
  47 // fixes for mingw32.
  48 #if defined(max) && !defined(__max)
  49 #define __max max
  50 #endif
  51 #if defined(min) && !defined(__min)
  52 #define __min min
  53 #endif
  54
  55 __inline ALuint aluBytesFromFormat(ALenum format)
  56 {
  57     switch(format)
  58     {
  59         case AL_FORMAT_MONO8:
  60         case AL_FORMAT_STEREO8:
  61         case AL_FORMAT_QUAD8:
  62             return 1;
  63
  64         case AL_FORMAT_MONO16:
  65         case AL_FORMAT_STEREO16:
  66         case AL_FORMAT_QUAD16:
  67             return 2;
  68
  69         default:
  70             return 0;
  71     }
  72 }
  73
  74 __inline ALuint aluChannelsFromFormat(ALenum format)
  75 {
  76     switch(format)
  77     {
  78         case AL_FORMAT_MONO8:
  79         case AL_FORMAT_MONO16:
  80             return 1;
  81
  82         case AL_FORMAT_STEREO8:
  83         case AL_FORMAT_STEREO16:
  84             return 2;
  85
  86         case AL_FORMAT_QUAD8:
  87         case AL_FORMAT_QUAD16:
  88             return 4;
  89
  90         default:
  91             return 0;
  92     }
  93 }
  94
  95 static __inline ALint aluF2L(ALfloat Value)
  96 {
  97     if(sizeof(ALint) == 4 && sizeof(double) == 8)
  98     {
  99         double temp;
 100         temp = Value + (((65536.0*65536.0*16.0)+(65536.0*65536.0*8.0))*65536.0);
 101         return *((ALint*)&temp);
 102     }
 103     return (ALint)Value;
 104 }
 105
 106 static __inline ALshort aluF2S(ALfloat Value)
 107 {
 108     ALint i;
 109
 110     i = aluF2L(Value);
 111     i = __min( 32767, i);
 112     i = __max(-32768, i);
 113     return ((ALshort)i);
 114 }
 115
 116 static __inline ALvoid aluCrossproduct(ALfloat *inVector1,ALfloat *inVector2,ALfloat *outVector)
 117 {
 118     outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
 119     outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
 120     outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
 121 }
 122
 123 static __inline ALfloat aluDotproduct(ALfloat *inVector1,ALfloat *inVector2)
 124 {
 125     return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
 126            inVector1[2]*inVector2[2];
 127 }
 128
 129 static __inline ALvoid aluNormalize(ALfloat *inVector)
 130 {
 131     ALfloat length, inverse_length;
 132
 133     length = (ALfloat)aluSqrt(aluDotproduct(inVector, inVector));
 134     if(length != 0)
 135     {
 136         inverse_length = 1.0f/length;
 137         inVector[0] *= inverse_length;
 138         inVector[1] *= inverse_length;
 139         inVector[2] *= inverse_length;
 140     }
 141 }
 142
 143 static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat matrix[3][3])
 144 {
 145     ALfloat result[3];
 146
 147     result[0] = vector[0]*matrix[0][0] + vector[1]*matrix[1][0] + vector[2]*matrix[2][0];
 148     result[1] = vector[0]*matrix[0][1] + vector[1]*matrix[1][1] + vector[2]*matrix[2][1];
 149     result[2] = vector[0]*matrix[0][2] + vector[1]*matrix[1][2] + vector[2]*matrix[2][2];
 150     memcpy(vector, result, sizeof(result));
 151 }
 152
 153 static __inline ALfloat aluComputeDrySample(ALsource *source, ALfloat DryGainHF, ALfloat sample)
 154 {
 155     if(DryGainHF < 1.0f)
 156     {
 157         sample *= DryGainHF;
 158         sample += source->LastDrySample * (1.0f - DryGainHF);
 159     }
 160
 161     source->LastDrySample = sample;
 162     return sample;
 163 }
 164
 165 static __inline ALfloat aluComputeWetSample(ALsource *source, ALfloat WetGainHF, ALfloat sample)
 166 {
 167     if(WetGainHF < 1.0f)
 168     {
 169         sample *= WetGainHF;
 170         sample += source->LastWetSample * (1.0f - WetGainHF);
 171     }
 172
 173     source->LastWetSample = sample;
 174     return sample;
 175 }
 176
 177 static ALvoid CalcSourceParams(ALCcontext *ALContext, ALsource *ALSource,
 178                                ALenum isMono, ALenum OutputFormat,
 179                                ALfloat *drysend, ALfloat *wetsend,
 180                                ALfloat *pitch, ALfloat *drygainhf,
 181                                ALfloat *wetgainhf)
 182 {
 183     ALfloat ListenerOrientation[6],ListenerPosition[3],ListenerVelocity[3];
 184     ALfloat InnerAngle,OuterAngle,OuterGain,Angle,Distance,DryMix,WetMix;
 185     ALfloat Direction[3],Position[3],Velocity[3],SourceToListener[3];
 186     ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff,OuterGainHF;
 187     ALfloat Pitch,ConeVolume,SourceVolume,PanningFB,PanningLR,ListenerGain;
 188     ALfloat U[3],V[3],N[3];
 189     ALfloat DopplerFactor, DopplerVelocity, flSpeedOfSound, flMaxVelocity;
 190     ALfloat flVSS, flVLS;
 191     ALint DistanceModel;
 192     ALfloat Matrix[3][3];
 193     ALint HeadRelative;
 194     ALfloat flAttenuation;
 195     ALfloat RoomAttenuation;
 196     ALfloat MetersPerUnit;
 197     ALfloat RoomRolloff;
 198     ALfloat DryGainHF = 1.0f;
 199     ALfloat WetGainHF = 1.0f;
 200
 201     //Get context properties
 202     DopplerFactor   = ALContext->DopplerFactor;
 203     DistanceModel   = ALContext->DistanceModel;
 204     DopplerVelocity = ALContext->DopplerVelocity;
 205     flSpeedOfSound  = ALContext->flSpeedOfSound;
 206
 207     //Get listener properties
 208     ListenerGain = ALContext->Listener.Gain;
 209     MetersPerUnit = ALContext->Listener.MetersPerUnit;
 210     memcpy(ListenerPosition, ALContext->Listener.Position, sizeof(ALContext->Listener.Position));
 211     memcpy(ListenerVelocity, ALContext->Listener.Velocity, sizeof(ALContext->Listener.Velocity));
 212     memcpy(&ListenerOrientation[0], ALContext->Listener.Forward, sizeof(ALContext->Listener.Forward));
 213     memcpy(&ListenerOrientation[3], ALContext->Listener.Up, sizeof(ALContext->Listener.Up));
 214
 215     //Get source properties
 216     Pitch        = ALSource->flPitch;
 217     SourceVolume = ALSource->flGain;
 218     memcpy(Position,  ALSource->vPosition,    sizeof(ALSource->vPosition));
 219     memcpy(Velocity,  ALSource->vVelocity,    sizeof(ALSource->vVelocity));
 220     memcpy(Direction, ALSource->vOrientation, sizeof(ALSource->vOrientation));
 221     MinVolume    = ALSource->flMinGain;
 222     MaxVolume    = ALSource->flMaxGain;
 223     MinDist      = ALSource->flRefDistance;
 224     MaxDist      = ALSource->flMaxDistance;
 225     Rolloff      = ALSource->flRollOffFactor;
 226     OuterGain    = ALSource->flOuterGain;
 227     InnerAngle   = ALSource->flInnerAngle;
 228     OuterAngle   = ALSource->flOuterAngle;
 229     HeadRelative = ALSource->bHeadRelative;
 230     OuterGainHF  = ALSource->OuterGainHF;
 231     RoomRolloff  = ALSource->RoomRolloffFactor;
 232
 233     //Only apply 3D calculations for mono buffers
 234     if(isMono != AL_FALSE)
 235     {
 236         //1. Translate Listener to origin (convert to head relative)
 237         if(HeadRelative==AL_FALSE)
 238         {
 239             Position[0] -= ListenerPosition[0];
 240             Position[1] -= ListenerPosition[1];
 241             Position[2] -= ListenerPosition[2];
 242         }
 243
 244         //2. Calculate distance attenuation
 245         Distance = aluSqrt(aluDotproduct(Position, Position));
 246
 247         flAttenuation = 1.0f;
 248         RoomAttenuation = 1.0f;
 249         switch (DistanceModel)
 250         {
 251             case AL_INVERSE_DISTANCE_CLAMPED:
 252                 Distance=__max(Distance,MinDist);
 253                 Distance=__min(Distance,MaxDist);
 254                 if (MaxDist < MinDist)
 255                     break;
 256                 //fall-through
 257             case AL_INVERSE_DISTANCE:
 258                 if (MinDist > 0.0f)
 259                 {
 260                     if ((MinDist + (Rolloff * (Distance - MinDist))) > 0.0f)
 261                         flAttenuation = MinDist / (MinDist + (Rolloff * (Distance - MinDist)));
 262                     if ((MinDist + (RoomRolloff * (Distance - MinDist))) > 0.0f)
 263                         RoomAttenuation = MinDist / (MinDist + (RoomRolloff * (Distance - MinDist)));
 264                 }
 265                 break;
 266
 267             case AL_LINEAR_DISTANCE_CLAMPED:
 268                 Distance=__max(Distance,MinDist);
 269                 Distance=__min(Distance,MaxDist);
 270                 if (MaxDist < MinDist)
 271                     break;
 272                 //fall-through
 273             case AL_LINEAR_DISTANCE:
 274                 Distance=__min(Distance,MaxDist);
 275                 if (MaxDist != MinDist)
 276                 {
 277                     flAttenuation = 1.0f - (Rolloff*(Distance-MinDist)/(MaxDist - MinDist));
 278                     RoomAttenuation = 1.0f - (RoomRolloff*(Distance-MinDist)/(MaxDist - MinDist));
 279                 }
 280                 break;
 281
 282             case AL_EXPONENT_DISTANCE_CLAMPED:
 283                 Distance=__max(Distance,MinDist);
 284                 Distance=__min(Distance,MaxDist);
 285                 if (MaxDist < MinDist)
 286                     break;
 287                 //fall-through
 288             case AL_EXPONENT_DISTANCE:
 289                 if ((Distance > 0.0f) && (MinDist > 0.0f))
 290                 {
 291                     flAttenuation = (ALfloat)pow(Distance/MinDist, -Rolloff);
 292                     RoomAttenuation = (ALfloat)pow(Distance/MinDist, -RoomRolloff);
 293                 }
 294                 break;
 295
 296             case AL_NONE:
 297             default:
 298                 flAttenuation = 1.0f;
 299                 RoomAttenuation = 1.0f;
 300                 break;
 301         }
 302
 303         // Source Gain + Attenuation
 304         DryMix = SourceVolume * flAttenuation;
 305         WetMix = SourceVolume * ((ALSource->WetGainAuto &&
 306                                   ALSource->Send[0].Slot.AuxSendAuto) ?
 307                                  RoomAttenuation : 1.0f);
 308
 309         // Clamp to Min/Max Gain
 310         DryMix = __min(DryMix,MaxVolume);
 311         DryMix = __max(DryMix,MinVolume);
 312         WetMix = __min(WetMix,MaxVolume);
 313         WetMix = __max(WetMix,MinVolume);
 314         //3. Apply directional soundcones
 315         SourceToListener[0] = -Position[0];
 316         SourceToListener[1] = -Position[1];
 317         SourceToListener[2] = -Position[2];
 318         aluNormalize(Direction);
 319         aluNormalize(SourceToListener);
 320         Angle = (ALfloat)(180.0*acos(aluDotproduct(Direction,SourceToListener))/3.141592654f);
 321         if(Angle >= InnerAngle && Angle <= OuterAngle)
 322         {
 323             ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
 324             ConeVolume = (1.0f+(OuterGain-1.0f)*scale);
 325             if(ALSource->WetGainAuto)
 326                 WetMix *= ConeVolume;
 327             if(ALSource->DryGainHFAuto)
 328                 DryGainHF *= (1.0f+(OuterGainHF-1.0f)*scale);
 329             if(ALSource->WetGainHFAuto)
 330                 WetGainHF *= (1.0f+(OuterGainHF-1.0f)*scale);
 331         }
 332         else if(Angle > OuterAngle)
 333         {
 334             ConeVolume = (1.0f+(OuterGain-1.0f));
 335             if(ALSource->WetGainAuto)
 336                 WetMix *= ConeVolume;
 337             if(ALSource->DryGainHFAuto)
 338                 DryGainHF *= (1.0f+(OuterGainHF-1.0f));
 339             if(ALSource->WetGainHFAuto)
 340                 WetGainHF *= (1.0f+(OuterGainHF-1.0f));
 341         }
 342         else
 343             ConeVolume = 1.0f;
 344
 345         //4. Calculate Velocity
 346         if(DopplerFactor != 0.0f)
 347         {
 348             flVLS = aluDotproduct(ListenerVelocity, SourceToListener);
 349             flVSS = aluDotproduct(Velocity, SourceToListener);
 350
 351             flMaxVelocity = (DopplerVelocity * flSpeedOfSound) / DopplerFactor;
 352
 353             if (flVSS >= flMaxVelocity)
 354                 flVSS = (flMaxVelocity - 1.0f);
 355             else if (flVSS <= -flMaxVelocity)
 356                 flVSS = -flMaxVelocity + 1.0f;
 357
 358             if (flVLS >= flMaxVelocity)
 359                 flVLS = (flMaxVelocity - 1.0f);
 360             else if (flVLS <= -flMaxVelocity)
 361                 flVLS = -flMaxVelocity + 1.0f;
 362
 363             pitch[0] = Pitch * ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVLS)) /
 364                                ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVSS));
 365         }
 366         else
 367             pitch[0] = Pitch;
 368
 369         //5. Align coordinate system axes
 370         aluCrossproduct(&ListenerOrientation[0], &ListenerOrientation[3], U); // Right-vector
 371         aluNormalize(U);                                // Normalized Right-vector
 372         memcpy(V, &ListenerOrientation[3], sizeof(V));  // Up-vector
 373         aluNormalize(V);                                // Normalized Up-vector
 374         memcpy(N, &ListenerOrientation[0], sizeof(N));  // At-vector
 375         aluNormalize(N);                                // Normalized At-vector
 376         Matrix[0][0] = U[0]; Matrix[0][1] = V[0]; Matrix[0][2] = -N[0];
 377         Matrix[1][0] = U[1]; Matrix[1][1] = V[1]; Matrix[1][2] = -N[1];
 378         Matrix[2][0] = U[2]; Matrix[2][1] = V[2]; Matrix[2][2] = -N[2];
 379         aluMatrixVector(Position, Matrix);
 380
 381         //6. Apply filter gains and filters
 382         switch(ALSource->DirectFilter.filter)
 383         {
 384             case AL_FILTER_LOWPASS:
 385                 DryMix *= ALSource->DirectFilter.Gain;
 386                 DryGainHF *= ALSource->DirectFilter.GainHF;
 387                 break;
 388         }
 389
 390         switch(ALSource->Send[0].WetFilter.filter)
 391         {
 392             case AL_FILTER_LOWPASS:
 393                 WetMix *= ALSource->Send[0].WetFilter.Gain;
 394                 WetGainHF *= ALSource->Send[0].WetFilter.GainHF;
 395                 break;
 396         }
 397
 398         if(ALSource->AirAbsorptionFactor > 0.0f)
 399             DryGainHF *= pow(ALSource->AirAbsorptionFactor * AIRABSORBGAINHF,
 400                              Distance * MetersPerUnit);
 401
 402         *drygainhf = DryGainHF;
 403         *wetgainhf = WetGainHF;
 404
 405         //7. Convert normalized position into pannings, then into channel volumes
 406         aluNormalize(Position);
 407         WetMix *= ALSource->Send[0].Slot.Gain;
 408         switch(OutputFormat)
 409         {
 410             case AL_FORMAT_MONO8:
 411             case AL_FORMAT_MONO16:
 412                 drysend[0] = ConeVolume * ListenerGain * DryMix * aluSqrt(1.0f); //Direct
 413                 drysend[1] = ConeVolume * ListenerGain * DryMix * aluSqrt(1.0f); //Direct
 414                 wetsend[0] =              ListenerGain * WetMix * aluSqrt(1.0f); //Room
 415                 wetsend[1] =              ListenerGain * WetMix * aluSqrt(1.0f); //Room
 416                 break;
 417             case AL_FORMAT_STEREO8:
 418             case AL_FORMAT_STEREO16:
 419                 PanningLR = 0.5f + 0.5f*Position[0];
 420                 drysend[0] = ConeVolume * ListenerGain * DryMix * aluSqrt(1.0f-PanningLR); //L Direct
 421                 drysend[1] = ConeVolume * ListenerGain * DryMix * aluSqrt(     PanningLR); //R Direct
 422                 wetsend[0] =              ListenerGain * WetMix * aluSqrt(1.0f-PanningLR); //L Room
 423                 wetsend[1] =              ListenerGain * WetMix * aluSqrt(     PanningLR); //R Room
 424                 break;
 425             case AL_FORMAT_QUAD8:
 426             case AL_FORMAT_QUAD16:
 427                 // Apply a scalar so each individual speaker has more weight
 428                 PanningLR = 0.5f + (0.5f*Position[0]*1.41421356f);
 429                 PanningLR = __min(1.0f, PanningLR);
 430                 PanningLR = __max(0.0f, PanningLR);
 431                 PanningFB = 0.5f + (0.5f*Position[2]*1.41421356f);
 432                 PanningFB = __min(1.0f, PanningFB);
 433                 PanningFB = __max(0.0f, PanningFB);
 434                 drysend[0] = ConeVolume * ListenerGain * DryMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB)); //FL Direct
 435                 drysend[1] = ConeVolume * ListenerGain * DryMix * aluSqrt((     PanningLR)*(1.0f-PanningFB)); //FR Direct
 436                 drysend[2] = ConeVolume * ListenerGain * DryMix * aluSqrt((1.0f-PanningLR)*(     PanningFB)); //BL Direct
 437                 drysend[3] = ConeVolume * ListenerGain * DryMix * aluSqrt((     PanningLR)*(     PanningFB)); //BR Direct
 438                 wetsend[0] =              ListenerGain * WetMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB)); //FL Room
 439                 wetsend[1] =              ListenerGain * WetMix * aluSqrt((     PanningLR)*(1.0f-PanningFB)); //FR Room
 440                 wetsend[2] =              ListenerGain * WetMix * aluSqrt((1.0f-PanningLR)*(     PanningFB)); //BL Room
 441                 wetsend[3] =              ListenerGain * WetMix * aluSqrt((     PanningLR)*(     PanningFB)); //BR Room
 442                 break;
 443             default:
 444                 break;
 445         }
 446     }
 447     else
 448     {
 449         //1. Multi-channel buffers always play "normal"
 450         drysend[0] = SourceVolume * 1.0f * ListenerGain;
 451         drysend[1] = SourceVolume * 1.0f * ListenerGain;
 452         drysend[2] = SourceVolume * 1.0f * ListenerGain;
 453         drysend[3] = SourceVolume * 1.0f * ListenerGain;
 454         wetsend[0] = SourceVolume * 0.0f * ListenerGain;
 455         wetsend[1] = SourceVolume * 0.0f * ListenerGain;
 456         wetsend[2] = SourceVolume * 0.0f * ListenerGain;
 457         wetsend[3] = SourceVolume * 0.0f * ListenerGain;
 458
 459         pitch[0] = Pitch;
 460
 461         *drygainhf = DryGainHF;
 462         *wetgainhf = WetGainHF;
 463     }
 464 }
 465
 466 ALvoid aluMixData(ALCcontext *ALContext,ALvoid *buffer,ALsizei size,ALenum format)
 467 {
 468     static float DryBuffer[BUFFERSIZE][OUTPUTCHANNELS];
 469     static float WetBuffer[BUFFERSIZE][OUTPUTCHANNELS];
 470     ALfloat DrySend[OUTPUTCHANNELS] = { 0.0f, 0.0f, 0.0f, 0.0f };
 471     ALfloat WetSend[OUTPUTCHANNELS] = { 0.0f, 0.0f, 0.0f, 0.0f };
 472     ALfloat DryGainHF = 0.0f;
 473     ALfloat WetGainHF = 0.0f;
 474     ALuint BlockAlign,BufferSize;
 475     ALuint DataSize=0,DataPosInt=0,DataPosFrac=0;
 476     ALuint Channels,Bits,Frequency,ulExtraSamples;
 477     ALfloat Pitch;
 478     ALint Looping,increment,State;
 479     ALuint Buffer,fraction;
 480     ALuint SamplesToDo;
 481     ALsource *ALSource;
 482     ALbuffer *ALBuffer;
 483     ALfloat value;
 484     ALshort *Data;
 485     ALuint i,j,k;
 486     ALbufferlistitem *BufferListItem;
 487     ALuint loop;
 488     ALint64 DataSize64,DataPos64;
 489
 490     SuspendContext(ALContext);
 491
 492     if(buffer)
 493     {
 494         //Figure output format variables
 495         BlockAlign  = aluChannelsFromFormat(format);
 496         BlockAlign *= aluBytesFromFormat(format);
 497
 498         size /= BlockAlign;
 499         while(size > 0)
 500         {
 501             //Setup variables
 502             ALSource = (ALContext ? ALContext->Source : NULL);
 503             SamplesToDo = min(size, BUFFERSIZE);
 504
 505             //Clear mixing buffer
 506             memset(DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
 507             memset(WetBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
 508
 509             //Actual mixing loop
 510             while(ALSource)
 511             {
 512                 j = 0;
 513                 State = ALSource->state;
 514                 while(State == AL_PLAYING && j < SamplesToDo)
 515                 {
 516                     DataSize = 0;
 517                     DataPosInt = 0;
 518                     DataPosFrac = 0;
 519
 520                     //Get buffer info
 521                     if((Buffer = ALSource->ulBufferID))
 522                     {
 523                         ALBuffer = (ALbuffer*)ALTHUNK_LOOKUPENTRY(Buffer);
 524
 525                         Data      = ALBuffer->data;
 526                         Bits      = aluBytesFromFormat(ALBuffer->format) * 8;
 527                         Channels  = aluChannelsFromFormat(ALBuffer->format);
 528                         DataSize  = ALBuffer->size;
 529                         Frequency = ALBuffer->frequency;
 530
 531                         CalcSourceParams(ALContext, ALSource,
 532                                          (Channels==1) ? AL_TRUE : AL_FALSE,
 533                                          format, DrySend, WetSend, &Pitch,
 534                                          &DryGainHF, &WetGainHF);
 535
 536
 537                         Pitch = (Pitch*Frequency) / ALContext->Frequency;
 538                         DataSize = DataSize / (Bits*Channels/8);
 539
 540                         //Get source info
 541                         DataPosInt = ALSource->position;
 542                         DataPosFrac = ALSource->position_fraction;
 543
 544                         //Compute 18.14 fixed point step
 545                         increment = aluF2L(Pitch*(1L<<FRACTIONBITS));
 546                         if(increment > (MAX_PITCH<<FRACTIONBITS))
 547                             increment = (MAX_PITCH<<FRACTIONBITS);
 548
 549                         //Figure out how many samples we can mix.
 550                         //Pitch must be <= 4 (the number below !)
 551                         DataSize64 = DataSize+MAX_PITCH;
 552                         DataSize64 <<= FRACTIONBITS;
 553                         DataPos64 = DataPosInt;
 554                         DataPos64 <<= FRACTIONBITS;
 555                         DataPos64 += DataPosFrac;
 556                         BufferSize = (ALuint)((DataSize64-DataPos64) / increment);
 557                         BufferListItem = ALSource->queue;
 558                         for(loop = 0; loop < ALSource->BuffersPlayed; loop++)
 559                         {
 560                             if(BufferListItem)
 561                                 BufferListItem = BufferListItem->next;
 562                         }
 563                         if (BufferListItem)
 564                         {
 565                             if (BufferListItem->next)
 566                             {
 567                                 if(BufferListItem->next->buffer &&
 568                                    ((ALbuffer*)ALTHUNK_LOOKUPENTRY(BufferListItem->next->buffer))->data)
 569                                 {
 570                                     ulExtraSamples = min(((ALbuffer*)ALTHUNK_LOOKUPENTRY(BufferListItem->next->buffer))->size, (ALint)(16*Channels));
 571                                     memcpy(&Data[DataSize*Channels], ((ALbuffer*)ALTHUNK_LOOKUPENTRY(BufferListItem->next->buffer))->data, ulExtraSamples);
 572                                 }
 573                             }
 574                             else if (ALSource->bLooping)
 575                             {
 576                                 if (ALSource->queue->buffer)
 577                                 {
 578                                     if(((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALSource->queue->buffer))->data)
 579                                     {
 580                                         ulExtraSamples = min(((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALSource->queue->buffer))->size, (ALint)(16*Channels));
 581                                         memcpy(&Data[DataSize*Channels], ((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALSource->queue->buffer))->data, ulExtraSamples);
 582                                     }
 583                                 }
 584                             }
 585                         }
 586                         BufferSize = min(BufferSize, (SamplesToDo-j));
 587
 588                         //Actual sample mixing loop
 589                         Data += DataPosInt*Channels;
 590                         while(BufferSize--)
 591                         {
 592                             k = DataPosFrac>>FRACTIONBITS;
 593                             fraction = DataPosFrac&FRACTIONMASK;
 594                             if(Channels==1)
 595                             {
 596                                 //First order interpolator
 597                                 ALfloat sample = (ALfloat)((ALshort)(((Data[k]*((1L<<FRACTIONBITS)-fraction))+(Data[k+1]*(fraction)))>>FRACTIONBITS));
 598
 599                                 //Direct path final mix buffer and panning
 600                                 value = aluComputeDrySample(ALSource, DryGainHF, sample);
 601                                 DryBuffer[j][0] += value*DrySend[0];
 602                                 DryBuffer[j][1] += value*DrySend[1];
 603                                 DryBuffer[j][2] += value*DrySend[2];
 604                                 DryBuffer[j][3] += value*DrySend[3];
 605
 606                                 if(ALSource->Send[0].Slot.effectslot)
 607                                 {
 608                                     //Room path final mix buffer and panning
 609                                     value = aluComputeWetSample(ALSource, WetGainHF, sample);
 610                                     WetBuffer[j][0] += value*WetSend[0];
 611                                     WetBuffer[j][1] += value*WetSend[1];
 612                                     WetBuffer[j][2] += value*WetSend[2];
 613                                     WetBuffer[j][3] += value*WetSend[3];
 614                                 }
 615                             }
 616                             else
 617                             {
 618                                 ALfloat value2;
 619
 620                                 //First order interpolator (left)
 621                                 value = (ALfloat)((ALshort)(((Data[k*2  ]*((1L<<FRACTIONBITS)-fraction))+(Data[k*2+2]*(fraction)))>>FRACTIONBITS));
 622                                 //First order interpolator (right)
 623                                 value2 = (ALfloat)((ALshort)(((Data[k*2+1]*((1L<<FRACTIONBITS)-fraction))+(Data[k*2+3]*(fraction)))>>FRACTIONBITS));
 624
 625                                 //Direct path final mix buffer and panning (left)
 626                                 DryBuffer[j][0] += value*DrySend[0];
 627                                 //Direct path final mix buffer and panning (right)
 628                                 DryBuffer[j][1] += value2*DrySend[1];
 629
 630                                 if(ALSource->Send[0].Slot.effectslot)
 631                                 {
 632                                     //Room path final mix buffer and panning (left)
 633                                     WetBuffer[j][0] += value*WetSend[0];
 634                                     //Room path final mix buffer and panning (right)
 635                                     WetBuffer[j][1] += value2*WetSend[1];
 636                                 }
 637                             }
 638                             DataPosFrac += increment;
 639                             j++;
 640                         }
 641                         DataPosInt += (DataPosFrac>>FRACTIONBITS);
 642                         DataPosFrac = (DataPosFrac&FRACTIONMASK);
 643
 644                         //Update source info
 645                         ALSource->position = DataPosInt;
 646                         ALSource->position_fraction = DataPosFrac;
 647                     }
 648
 649                     //Handle looping sources
 650                     if(!Buffer || DataPosInt >= DataSize)
 651                     {
 652                         //queueing
 653                         if(ALSource->queue)
 654                         {
 655                             Looping = ALSource->bLooping;
 656                             if(ALSource->BuffersPlayed < (ALSource->BuffersInQueue-1))
 657                             {
 658                                 BufferListItem = ALSource->queue;
 659                                 for(loop = 0; loop <= ALSource->BuffersPlayed; loop++)
 660                                 {
 661                                     if(BufferListItem)
 662                                     {
 663                                         if(!Looping)
 664                                             BufferListItem->bufferstate = PROCESSED;
 665                                         BufferListItem = BufferListItem->next;
 666                                     }
 667                                 }
 668                                 if(!Looping)
 669                                     ALSource->BuffersProcessed++;
 670                                 if(BufferListItem)
 671                                     ALSource->ulBufferID = BufferListItem->buffer;
 672                                 ALSource->position = DataPosInt-DataSize;
 673                                 ALSource->position_fraction = DataPosFrac;
 674                                 ALSource->BuffersPlayed++;
 675                             }
 676                             else
 677                             {
 678                                 if(!Looping)
 679                                 {
 680                                     /* alSourceStop */
 681                                     ALSource->state = AL_STOPPED;
 682                                     ALSource->inuse = AL_FALSE;
 683                                     ALSource->BuffersPlayed = ALSource->BuffersProcessed = ALSource->BuffersInQueue;
 684                                     BufferListItem = ALSource->queue;
 685                                     while(BufferListItem != NULL)
 686                                     {
 687                                         BufferListItem->bufferstate = PROCESSED;
 688                                         BufferListItem = BufferListItem->next;
 689                                     }
 690                                 }
 691                                 else
 692                                 {
 693                                     /* alSourceRewind */
 694                                     /* alSourcePlay */
 695                                     ALSource->state = AL_PLAYING;
 696                                     ALSource->inuse = AL_TRUE;
 697                                     ALSource->play = AL_TRUE;
 698                                     ALSource->BuffersPlayed = 0;
 699                                     ALSource->BufferPosition = 0;
 700                                     ALSource->lBytesPlayed = 0;
 701                                     ALSource->BuffersProcessed = 0;
 702                                     BufferListItem = ALSource->queue;
 703                                     while(BufferListItem != NULL)
 704                                     {
 705                                         BufferListItem->bufferstate = PENDING;
 706                                         BufferListItem = BufferListItem->next;
 707                                     }
 708                                     ALSource->ulBufferID = ALSource->queue->buffer;
 709
 710                                     ALSource->position = DataPosInt-DataSize;
 711                                     ALSource->position_fraction = DataPosFrac;
 712                                 }
 713                             }
 714                         }
 715                     }
 716
 717                     //Get source state
 718                     State = ALSource->state;
 719                 }
 720
 721                 ALSource = ALSource->next;
 722             }
 723
 724             //Post processing loop
 725             switch(format)
 726             {
 727                 case AL_FORMAT_MONO8:
 728                     for(i = 0;i < SamplesToDo;i++)
 729                     {
 730                         *((ALubyte*)buffer) = (ALubyte)((aluF2S(DryBuffer[i][0]+DryBuffer[i][1]+WetBuffer[i][0]+WetBuffer[i][1])>>8)+128);
 731                         buffer = ((ALubyte*)buffer) + 1;
 732                     }
 733                     break;
 734                 case AL_FORMAT_STEREO8:
 735                     for(i = 0;i < SamplesToDo*2;i++)
 736                     {
 737                         *((ALubyte*)buffer) = (ALubyte)((aluF2S(DryBuffer[i>>1][i&1]+WetBuffer[i>>1][i&1])>>8)+128);
 738                         buffer = ((ALubyte*)buffer) + 1;
 739                     }
 740                     break;
 741                 case AL_FORMAT_QUAD8:
 742                     for(i = 0;i < SamplesToDo*4;i++)
 743                     {
 744                         *((ALubyte*)buffer) = (ALubyte)((aluF2S(DryBuffer[i>>2][i&3]+WetBuffer[i>>2][i&3])>>8)+128);
 745                         buffer = ((ALubyte*)buffer) + 1;
 746                     }
 747                     break;
 748                 case AL_FORMAT_MONO16:
 749                     for(i = 0;i < SamplesToDo;i++)
 750                     {
 751                         *((ALshort*)buffer) = aluF2S(DryBuffer[i][0]+DryBuffer[i][1]+WetBuffer[i][0]+WetBuffer[i][1]);
 752                         buffer = ((ALshort*)buffer) + 1;
 753                     }
 754                     break;
 755                 case AL_FORMAT_STEREO16:
 756                 default:
 757                     for(i = 0;i < SamplesToDo*2;i++)
 758                     {
 759                         *((ALshort*)buffer) = aluF2S(DryBuffer[i>>1][i&1]+WetBuffer[i>>1][i&1]);
 760                         buffer = ((ALshort*)buffer) + 1;
 761                     }
 762                     break;
 763                 case AL_FORMAT_QUAD16:
 764                     for(i = 0;i < SamplesToDo*4;i++)
 765                     {
 766                         *((ALshort*)buffer) = aluF2S(DryBuffer[i>>2][i&3]+WetBuffer[i>>2][i&3]);
 767                         buffer = ((ALshort*)buffer) + 1;
 768                     }
 769                     break;
 770             }
 771
 772             size -= SamplesToDo;
 773         }
 774     }
 775
 776     ProcessContext(ALContext);
 777 }