Mercurial > audio-send

     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 #include "config.h"

    22 

    23 #include <math.h>

    24 #include <stdlib.h>

    25 #include <string.h>

    26 #include <ctype.h>

    27 #include <assert.h>

    28 

    29 #include "alMain.h"

    30 #include "AL/al.h"

    31 #include "AL/alc.h"

    32 #include "alSource.h"

    33 #include "alBuffer.h"

    34 #include "alListener.h"

    35 #include "alAuxEffectSlot.h"

    36 #include "alu.h"

    37 #include "bs2b.h"

    38 

    39 

    40 static __inline ALvoid aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)

    41 {

    42     outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];

    43     outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];

    44     outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];

    45 }

    46 

    47 static __inline ALfloat aluDotproduct(const ALfloat *inVector1, const ALfloat *inVector2)

    48 {

    49     return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +

    50            inVector1[2]*inVector2[2];

    51 }

    52 

    53 static __inline ALvoid aluNormalize(ALfloat *inVector)

    54 {

    55     ALfloat length, inverse_length;

    56 

    57     length = aluSqrt(aluDotproduct(inVector, inVector));

    58     if(length != 0.0f)

    59     {

    60         inverse_length = 1.0f/length;

    61         inVector[0] *= inverse_length;

    62         inVector[1] *= inverse_length;

    63         inVector[2] *= inverse_length;

    64     }

    65 }

    66 

    67 static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat w,ALfloat matrix[4][4])

    68 {

    69     ALfloat temp[4] = {

    70         vector[0], vector[1], vector[2], w

    71     };

    72 

    73     vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];

    74     vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];

    75     vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];

    76 }

    77 

    78 

    79 ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)

    80 {

    81     static const ALfloat angles_Mono[1] = { 0.0f };

    82     static const ALfloat angles_Stereo[2] = { -30.0f, 30.0f };

    83     static const ALfloat angles_Rear[2] = { -150.0f, 150.0f };

    84     static const ALfloat angles_Quad[4] = { -45.0f, 45.0f, -135.0f, 135.0f };

    85     static const ALfloat angles_X51[6] = { -30.0f, 30.0f, 0.0f, 0.0f,

    86                                            -110.0f, 110.0f };

    87     static const ALfloat angles_X61[7] = { -30.0f, 30.0f, 0.0f, 0.0f,

    88                                            180.0f, -90.0f, 90.0f };

    89     static const ALfloat angles_X71[8] = { -30.0f, 30.0f, 0.0f, 0.0f,

    90                                            -110.0f, 110.0f, -90.0f, 90.0f };

    91 

    92     static const enum Channel chans_Mono[1] = { FRONT_CENTER };

    93     static const enum Channel chans_Stereo[2] = { FRONT_LEFT, FRONT_RIGHT };

    94     static const enum Channel chans_Rear[2] = { BACK_LEFT, BACK_RIGHT };

    95     static const enum Channel chans_Quad[4] = { FRONT_LEFT, FRONT_RIGHT,

    96                                                 BACK_LEFT, BACK_RIGHT };

    97     static const enum Channel chans_X51[6] = { FRONT_LEFT, FRONT_RIGHT,

    98                                                FRONT_CENTER, LFE,

    99                                                BACK_LEFT, BACK_RIGHT };

   100     static const enum Channel chans_X61[7] = { FRONT_LEFT, FRONT_RIGHT,

   101                                                FRONT_CENTER, LFE, BACK_CENTER,

   102                                                SIDE_LEFT, SIDE_RIGHT };

   103     static const enum Channel chans_X71[8] = { FRONT_LEFT, FRONT_RIGHT,

   104                                                FRONT_CENTER, LFE,

   105                                                BACK_LEFT, BACK_RIGHT,

   106                                                SIDE_LEFT, SIDE_RIGHT };

   107 

   108     ALCdevice *Device = ALContext->Device;

   109     ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;

   110     ALbufferlistitem *BufferListItem;

   111     enum DevFmtChannels DevChans;

   112     enum FmtChannels Channels;

   113     ALfloat (*SrcMatrix)[MAXCHANNELS];

   114     ALfloat DryGain, DryGainHF;

   115     ALfloat WetGain[MAX_SENDS];

   116     ALfloat WetGainHF[MAX_SENDS];

   117     ALint NumSends, Frequency;

   118     const ALfloat *SpeakerGain;

   119     const ALfloat *angles = NULL;

   120     const enum Channel *chans = NULL;

   121     enum Resampler Resampler;

   122     ALint num_channels = 0;

   123     ALboolean VirtualChannels;

   124     ALfloat Pitch;

   125     ALfloat cw;

   126     ALuint pos;

   127     ALint i, c;

   128 

   129     /* Get device properties */

   130     DevChans  = ALContext->Device->FmtChans;

   131     NumSends  = ALContext->Device->NumAuxSends;

   132     Frequency = ALContext->Device->Frequency;

   133 

   134     /* Get listener properties */

   135     ListenerGain = ALContext->Listener.Gain;

   136 

   137     /* Get source properties */

   138     SourceVolume    = ALSource->flGain;

   139     MinVolume       = ALSource->flMinGain;

   140     MaxVolume       = ALSource->flMaxGain;

   141     Pitch           = ALSource->flPitch;

   142     Resampler       = ALSource->Resampler;

   143     VirtualChannels = ALSource->VirtualChannels;

   144 

   145     /* Calculate the stepping value */

   146     Channels = FmtMono;

   147     BufferListItem = ALSource->queue;

   148     while(BufferListItem != NULL)

   149     {

   150         ALbuffer *ALBuffer;

   151         if((ALBuffer=BufferListItem->buffer) != NULL)

   152         {

   153             ALint maxstep = STACK_DATA_SIZE / ALSource->NumChannels /

   154                                               ALSource->SampleSize;

   155             maxstep -= ResamplerPadding[Resampler] +

   156                        ResamplerPrePadding[Resampler] + 1;

   157             maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);

   158 

   159             Pitch = Pitch * ALBuffer->Frequency / Frequency;

   160             if(Pitch > (ALfloat)maxstep)

   161                 ALSource->Params.Step = maxstep<<FRACTIONBITS;

   162             else

   163             {

   164                 ALSource->Params.Step = Pitch*FRACTIONONE;

   165                 if(ALSource->Params.Step == 0)

   166                     ALSource->Params.Step = 1;

   167             }

   168 

   169             Channels = ALBuffer->FmtChannels;

   170 

   171             if(ALSource->VirtualChannels && (Device->Flags&DEVICE_USE_HRTF))

   172                 ALSource->Params.DoMix = SelectHrtfMixer(ALBuffer,

   173                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :

   174                                                               Resampler);

   175             else

   176                 ALSource->Params.DoMix = SelectMixer(ALBuffer,

   177                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :

   178                                                               Resampler);

   179             break;

   180         }

   181         BufferListItem = BufferListItem->next;

   182     }

   183 

   184     /* Calculate gains */

   185     DryGain = clampf(SourceVolume, MinVolume, MaxVolume);

   186     DryGainHF = 1.0f;

   187     switch(ALSource->DirectFilter.type)

   188     {

   189         case AL_FILTER_LOWPASS:

   190             DryGain *= ALSource->DirectFilter.Gain;

   191             DryGainHF *= ALSource->DirectFilter.GainHF;

   192             break;

   193     }

   194     for(i = 0;i < NumSends;i++)

   195     {

   196         WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);

   197         WetGainHF[i] = 1.0f;

   198         switch(ALSource->Send[i].WetFilter.type)

   199         {

   200             case AL_FILTER_LOWPASS:

   201                 WetGain[i] *= ALSource->Send[i].WetFilter.Gain;

   202                 WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;

   203                 break;

   204         }

   205     }

   206 

   207     SrcMatrix = ALSource->Params.DryGains;

   208     for(i = 0;i < MAXCHANNELS;i++)

   209     {

   210         for(c = 0;c < MAXCHANNELS;c++)

   211             SrcMatrix[i][c] = 0.0f;

   212     }

   213     switch(Channels)

   214     {

   215     case FmtMono:

   216         angles = angles_Mono;

   217         chans = chans_Mono;

   218         num_channels = 1;

   219         break;

   220     case FmtStereo:

   221         if(VirtualChannels && (ALContext->Device->Flags&DEVICE_DUPLICATE_STEREO))

   222         {

   223             DryGain *= aluSqrt(2.0f/4.0f);

   224             for(c = 0;c < 2;c++)

   225             {

   226                 pos = aluCart2LUTpos(cos(angles_Rear[c] * (M_PI/180.0)),

   227                                      sin(angles_Rear[c] * (M_PI/180.0)));

   228                 SpeakerGain = Device->PanningLUT[pos];

   229 

   230                 for(i = 0;i < (ALint)Device->NumChan;i++)

   231                 {

   232                     enum Channel chan = Device->Speaker2Chan[i];

   233                     SrcMatrix[c][chan] += DryGain * ListenerGain *

   234                                           SpeakerGain[chan];

   235                 }

   236             }

   237         }

   238         angles = angles_Stereo;

   239         chans = chans_Stereo;

   240         num_channels = 2;

   241         break;

   242 

   243     case FmtRear:

   244         angles = angles_Rear;

   245         chans = chans_Rear;

   246         num_channels = 2;

   247         break;

   248 

   249     case FmtQuad:

   250         angles = angles_Quad;

   251         chans = chans_Quad;

   252         num_channels = 4;

   253         break;

   254 

   255     case FmtX51:

   256         angles = angles_X51;

   257         chans = chans_X51;

   258         num_channels = 6;

   259         break;

   260 

   261     case FmtX61:

   262         angles = angles_X61;

   263         chans = chans_X61;

   264         num_channels = 7;

   265         break;

   266 

   267     case FmtX71:

   268         angles = angles_X71;

   269         chans = chans_X71;

   270         num_channels = 8;

   271         break;

   272     }

   273 

   274     if(VirtualChannels == AL_FALSE)

   275     {

   276         for(c = 0;c < num_channels;c++)

   277             SrcMatrix[c][chans[c]] += DryGain * ListenerGain;

   278     }

   279     else if((Device->Flags&DEVICE_USE_HRTF))

   280     {

   281         for(c = 0;c < num_channels;c++)

   282         {

   283             if(chans[c] == LFE)

   284             {

   285                 /* Skip LFE */

   286                 ALSource->Params.HrtfDelay[c][0] = 0;

   287                 ALSource->Params.HrtfDelay[c][1] = 0;

   288                 for(i = 0;i < HRIR_LENGTH;i++)

   289                 {

   290                     ALSource->Params.HrtfCoeffs[c][i][0] = 0.0f;

   291                     ALSource->Params.HrtfCoeffs[c][i][1] = 0.0f;

   292                 }

   293             }

   294             else

   295             {

   296                 /* Get the static HRIR coefficients and delays for this

   297                  * channel. */

   298                 GetLerpedHrtfCoeffs(0.0, angles[c] * (M_PI/180.0),

   299                                     DryGain*ListenerGain,

   300                                     ALSource->Params.HrtfCoeffs[c],

   301                                     ALSource->Params.HrtfDelay[c]);

   302             }

   303             ALSource->HrtfCounter = 0;

   304         }

   305     }

   306     else

   307     {

   308         for(c = 0;c < num_channels;c++)

   309         {

   310             if(chans[c] == LFE) /* Special-case LFE */

   311             {

   312                 SrcMatrix[c][LFE] += DryGain * ListenerGain;

   313                 continue;

   314             }

   315             pos = aluCart2LUTpos(cos(angles[c] * (M_PI/180.0)),

   316                                  sin(angles[c] * (M_PI/180.0)));

   317             SpeakerGain = Device->PanningLUT[pos];

   318 

   319             for(i = 0;i < (ALint)Device->NumChan;i++)

   320             {

   321                 enum Channel chan = Device->Speaker2Chan[i];

   322                 SrcMatrix[c][chan] += DryGain * ListenerGain *

   323                                       SpeakerGain[chan];

   324             }

   325         }

   326     }

   327     for(i = 0;i < NumSends;i++)

   328     {

   329         ALSource->Params.Send[i].Slot = ALSource->Send[i].Slot;

   330         ALSource->Params.Send[i].WetGain = WetGain[i] * ListenerGain;

   331     }

   332 

   333     /* Update filter coefficients. Calculations based on the I3DL2

   334      * spec. */

   335     cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);

   336 

   337     /* We use two chained one-pole filters, so we need to take the

   338      * square root of the squared gain, which is the same as the base

   339      * gain. */

   340     ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);

   341     for(i = 0;i < NumSends;i++)

   342     {

   343         /* We use a one-pole filter, so we need to take the squared gain */

   344         ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);

   345         ALSource->Params.Send[i].iirFilter.coeff = a;

   346     }

   347 }

   348 

   349 ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext)

   350 {

   351     const ALCdevice *Device = ALContext->Device;

   352     ALfloat InnerAngle,OuterAngle,Angle,Distance,ClampedDist;

   353     ALfloat Direction[3],Position[3],SourceToListener[3];

   354     ALfloat Velocity[3],ListenerVel[3];

   355     ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;

   356     ALfloat ConeVolume,ConeHF,SourceVolume,ListenerGain;

   357     ALfloat DopplerFactor, DopplerVelocity, SpeedOfSound;

   358     ALfloat AirAbsorptionFactor;

   359     ALfloat RoomAirAbsorption[MAX_SENDS];

   360     ALbufferlistitem *BufferListItem;

   361     ALfloat Attenuation, EffectiveDist;

   362     ALfloat RoomAttenuation[MAX_SENDS];

   363     ALfloat MetersPerUnit;

   364     ALfloat RoomRolloffBase;

   365     ALfloat RoomRolloff[MAX_SENDS];

   366     ALfloat DecayDistance[MAX_SENDS];

   367     ALfloat DryGain;

   368     ALfloat DryGainHF;

   369     ALboolean DryGainHFAuto;

   370     ALfloat WetGain[MAX_SENDS];

   371     ALfloat WetGainHF[MAX_SENDS];

   372     ALboolean WetGainAuto;

   373     ALboolean WetGainHFAuto;

   374     enum Resampler Resampler;

   375     ALfloat Pitch;

   376     ALuint Frequency;

   377     ALint NumSends;

   378     ALfloat cw;

   379     ALint i;

   380 

   381     DryGainHF = 1.0f;

   382     for(i = 0;i < MAX_SENDS;i++)

   383         WetGainHF[i] = 1.0f;

   384 

   385     //Get context properties

   386     DopplerFactor   = ALContext->DopplerFactor * ALSource->DopplerFactor;

   387     DopplerVelocity = ALContext->DopplerVelocity;

   388     SpeedOfSound    = ALContext->flSpeedOfSound;

   389     NumSends        = Device->NumAuxSends;

   390     Frequency       = Device->Frequency;

   391 

   392     //Get listener properties

   393     ListenerGain = ALContext->Listener.Gain;

   394     MetersPerUnit = ALContext->Listener.MetersPerUnit;

   395     memcpy(ListenerVel, ALContext->Listener.Velocity, sizeof(ALContext->Listener.Velocity));

   396 

   397     //Get source properties

   398     SourceVolume = ALSource->flGain;

   399     MinVolume    = ALSource->flMinGain;

   400     MaxVolume    = ALSource->flMaxGain;

   401     Pitch        = ALSource->flPitch;

   402     Resampler    = ALSource->Resampler;

   403     memcpy(Position,  ALSource->vPosition,    sizeof(ALSource->vPosition));

   404     memcpy(Direction, ALSource->vOrientation, sizeof(ALSource->vOrientation));

   405     memcpy(Velocity,  ALSource->vVelocity,    sizeof(ALSource->vVelocity));

   406     MinDist = ALSource->flRefDistance;

   407     MaxDist = ALSource->flMaxDistance;

   408     Rolloff = ALSource->flRollOffFactor;

   409     InnerAngle = ALSource->flInnerAngle * ConeScale;

   410     OuterAngle = ALSource->flOuterAngle * ConeScale;

   411     AirAbsorptionFactor = ALSource->AirAbsorptionFactor;

   412     DryGainHFAuto = ALSource->DryGainHFAuto;

   413     WetGainAuto   = ALSource->WetGainAuto;

   414     WetGainHFAuto = ALSource->WetGainHFAuto;

   415     RoomRolloffBase = ALSource->RoomRolloffFactor;

   416     for(i = 0;i < NumSends;i++)

   417     {

   418         ALeffectslot *Slot = ALSource->Send[i].Slot;

   419 

   420         if(!Slot || Slot->effect.type == AL_EFFECT_NULL)

   421         {

   422             RoomRolloff[i] = 0.0f;

   423             DecayDistance[i] = 0.0f;

   424             RoomAirAbsorption[i] = 1.0f;

   425         }

   426         else if(Slot->AuxSendAuto)

   427         {

   428             RoomRolloff[i] = RoomRolloffBase;

   429             if(IsReverbEffect(Slot->effect.type))

   430             {

   431                 RoomRolloff[i] += Slot->effect.Params.Reverb.RoomRolloffFactor;

   432                 DecayDistance[i] = Slot->effect.Params.Reverb.DecayTime *

   433                                    SPEEDOFSOUNDMETRESPERSEC;

   434                 RoomAirAbsorption[i] = Slot->effect.Params.Reverb.AirAbsorptionGainHF;

   435             }

   436             else

   437             {

   438                 DecayDistance[i] = 0.0f;

   439                 RoomAirAbsorption[i] = 1.0f;

   440             }

   441         }

   442         else

   443         {

   444             /* If the slot's auxiliary send auto is off, the data sent to the

   445              * effect slot is the same as the dry path, sans filter effects */

   446             RoomRolloff[i] = Rolloff;

   447             DecayDistance[i] = 0.0f;

   448             RoomAirAbsorption[i] = AIRABSORBGAINHF;

   449         }

   450 

   451         ALSource->Params.Send[i].Slot = Slot;

   452     }

   453 

   454     //1. Translate Listener to origin (convert to head relative)

   455     if(ALSource->bHeadRelative == AL_FALSE)

   456     {

   457         ALfloat U[3],V[3],N[3];

   458         ALfloat Matrix[4][4];

   459 

   460         // Build transform matrix

   461         memcpy(N, ALContext->Listener.Forward, sizeof(N));  // At-vector

   462         aluNormalize(N);  // Normalized At-vector

   463         memcpy(V, ALContext->Listener.Up, sizeof(V));  // Up-vector

   464         aluNormalize(V);  // Normalized Up-vector

   465         aluCrossproduct(N, V, U); // Right-vector

   466         aluNormalize(U);  // Normalized Right-vector

   467         Matrix[0][0] = U[0]; Matrix[0][1] = V[0]; Matrix[0][2] = -N[0]; Matrix[0][3] = 0.0f;

   468         Matrix[1][0] = U[1]; Matrix[1][1] = V[1]; Matrix[1][2] = -N[1]; Matrix[1][3] = 0.0f;

   469         Matrix[2][0] = U[2]; Matrix[2][1] = V[2]; Matrix[2][2] = -N[2]; Matrix[2][3] = 0.0f;

   470         Matrix[3][0] = 0.0f; Matrix[3][1] = 0.0f; Matrix[3][2] =  0.0f; Matrix[3][3] = 1.0f;

   471 

   472         // Translate position

   473         Position[0] -= ALContext->Listener.Position[0];

   474         Position[1] -= ALContext->Listener.Position[1];

   475         Position[2] -= ALContext->Listener.Position[2];

   476 

   477         // Transform source position and direction into listener space

   478         aluMatrixVector(Position, 1.0f, Matrix);

   479         aluMatrixVector(Direction, 0.0f, Matrix);

   480         // Transform source and listener velocity into listener space

   481         aluMatrixVector(Velocity, 0.0f, Matrix);

   482         aluMatrixVector(ListenerVel, 0.0f, Matrix);

   483     }

   484     else

   485         ListenerVel[0] = ListenerVel[1] = ListenerVel[2] = 0.0f;

   486 

   487     SourceToListener[0] = -Position[0];

   488     SourceToListener[1] = -Position[1];

   489     SourceToListener[2] = -Position[2];

   490     aluNormalize(SourceToListener);

   491     aluNormalize(Direction);

   492 

   493     //2. Calculate distance attenuation

   494     Distance = aluSqrt(aluDotproduct(Position, Position));

   495     ClampedDist = Distance;

   496 

   497     Attenuation = 1.0f;

   498     for(i = 0;i < NumSends;i++)

   499         RoomAttenuation[i] = 1.0f;

   500     switch(ALContext->SourceDistanceModel ? ALSource->DistanceModel :

   501                                             ALContext->DistanceModel)

   502     {

   503         case InverseDistanceClamped:

   504             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);

   505             if(MaxDist < MinDist)

   506                 break;

   507             //fall-through

   508         case InverseDistance:

   509             if(MinDist > 0.0f)

   510             {

   511                 if((MinDist + (Rolloff * (ClampedDist - MinDist))) > 0.0f)

   512                     Attenuation = MinDist / (MinDist + (Rolloff * (ClampedDist - MinDist)));

   513                 for(i = 0;i < NumSends;i++)

   514                 {

   515                     if((MinDist + (RoomRolloff[i] * (ClampedDist - MinDist))) > 0.0f)

   516                         RoomAttenuation[i] = MinDist / (MinDist + (RoomRolloff[i] * (ClampedDist - MinDist)));

   517                 }

   518             }

   519             break;

   520 

   521         case LinearDistanceClamped:

   522             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);

   523             if(MaxDist < MinDist)

   524                 break;

   525             //fall-through

   526         case LinearDistance:

   527             if(MaxDist != MinDist)

   528             {

   529                 Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));

   530                 Attenuation = maxf(Attenuation, 0.0f);

   531                 for(i = 0;i < NumSends;i++)

   532                 {

   533                     RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));

   534                     RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);

   535                 }

   536             }

   537             break;

   538 

   539         case ExponentDistanceClamped:

   540             ClampedDist = clampf(ClampedDist, MinDist, MaxDist);

   541             if(MaxDist < MinDist)

   542                 break;

   543             //fall-through

   544         case ExponentDistance:

   545             if(ClampedDist > 0.0f && MinDist > 0.0f)

   546             {

   547                 Attenuation = aluPow(ClampedDist/MinDist, -Rolloff);

   548                 for(i = 0;i < NumSends;i++)

   549                     RoomAttenuation[i] = aluPow(ClampedDist/MinDist, -RoomRolloff[i]);

   550             }

   551             break;

   552 

   553         case DisableDistance:

   554             break;

   555     }

   556 

   557     // Source Gain + Attenuation

   558     DryGain = SourceVolume * Attenuation;

   559     for(i = 0;i < NumSends;i++)

   560         WetGain[i] = SourceVolume * RoomAttenuation[i];

   561 

   562     // Distance-based air absorption

   563     EffectiveDist = 0.0f;

   564     if(MinDist > 0.0f && Attenuation < 1.0f)

   565         EffectiveDist = (MinDist/Attenuation - MinDist)*MetersPerUnit;

   566     if(AirAbsorptionFactor > 0.0f && EffectiveDist > 0.0f)

   567     {

   568         DryGainHF *= aluPow(AIRABSORBGAINHF, AirAbsorptionFactor*EffectiveDist);

   569         for(i = 0;i < NumSends;i++)

   570             WetGainHF[i] *= aluPow(RoomAirAbsorption[i],

   571                                    AirAbsorptionFactor*EffectiveDist);

   572     }

   573 

   574     //3. Apply directional soundcones

   575     Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * (180.0/M_PI);

   576     if(Angle >= InnerAngle && Angle <= OuterAngle)

   577     {

   578         ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);

   579         ConeVolume = lerp(1.0, ALSource->flOuterGain, scale);

   580         ConeHF = lerp(1.0, ALSource->OuterGainHF, scale);

   581     }

   582     else if(Angle > OuterAngle)

   583     {

   584         ConeVolume = ALSource->flOuterGain;

   585         ConeHF = ALSource->OuterGainHF;

   586     }

   587     else

   588     {

   589         ConeVolume = 1.0f;

   590         ConeHF = 1.0f;

   591     }

   592 

   593     DryGain *= ConeVolume;

   594     if(WetGainAuto)

   595     {

   596         for(i = 0;i < NumSends;i++)

   597             WetGain[i] *= ConeVolume;

   598     }

   599     if(DryGainHFAuto)

   600         DryGainHF *= ConeHF;

   601     if(WetGainHFAuto)

   602     {

   603         for(i = 0;i < NumSends;i++)

   604             WetGainHF[i] *= ConeHF;

   605     }

   606 

   607     // Clamp to Min/Max Gain

   608     DryGain = clampf(DryGain, MinVolume, MaxVolume);

   609     for(i = 0;i < NumSends;i++)

   610         WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);

   611 

   612     // Apply filter gains and filters

   613     switch(ALSource->DirectFilter.type)

   614     {

   615         case AL_FILTER_LOWPASS:

   616             DryGain *= ALSource->DirectFilter.Gain;

   617             DryGainHF *= ALSource->DirectFilter.GainHF;

   618             break;

   619     }

   620     DryGain *= ListenerGain;

   621     for(i = 0;i < NumSends;i++)

   622     {

   623         switch(ALSource->Send[i].WetFilter.type)

   624         {

   625             case AL_FILTER_LOWPASS:

   626                 WetGain[i] *= ALSource->Send[i].WetFilter.Gain;

   627                 WetGainHF[i] *= ALSource->Send[i].WetFilter.GainHF;

   628                 break;

   629         }

   630         WetGain[i] *= ListenerGain;

   631     }

   632 

   633     if(WetGainAuto)

   634     {

   635         /* Apply a decay-time transformation to the wet path, based on the

   636          * attenuation of the dry path.

   637          *

   638          * Using the approximate (effective) source to listener distance, the

   639          * initial decay of the reverb effect is calculated and applied to the

   640          * wet path.

   641          */

   642         for(i = 0;i < NumSends;i++)

   643         {

   644             if(DecayDistance[i] > 0.0f)

   645                 WetGain[i] *= aluPow(0.001f /* -60dB */,

   646                                      EffectiveDist / DecayDistance[i]);

   647         }

   648     }

   649 

   650     // Calculate Velocity

   651     if(DopplerFactor != 0.0f)

   652     {

   653         ALfloat VSS, VLS;

   654         ALfloat MaxVelocity = (SpeedOfSound*DopplerVelocity) /

   655                               DopplerFactor;

   656 

   657         VSS = aluDotproduct(Velocity, SourceToListener);

   658         if(VSS >= MaxVelocity)

   659             VSS = (MaxVelocity - 1.0f);

   660         else if(VSS <= -MaxVelocity)

   661             VSS = -MaxVelocity + 1.0f;

   662 

   663         VLS = aluDotproduct(ListenerVel, SourceToListener);

   664         if(VLS >= MaxVelocity)

   665             VLS = (MaxVelocity - 1.0f);

   666         else if(VLS <= -MaxVelocity)

   667             VLS = -MaxVelocity + 1.0f;

   668 

   669         Pitch *= ((SpeedOfSound*DopplerVelocity) - (DopplerFactor*VLS)) /

   670                  ((SpeedOfSound*DopplerVelocity) - (DopplerFactor*VSS));

   671     }

   672 

   673     BufferListItem = ALSource->queue;

   674     while(BufferListItem != NULL)

   675     {

   676         ALbuffer *ALBuffer;

   677         if((ALBuffer=BufferListItem->buffer) != NULL)

   678         {

   679             ALint maxstep = STACK_DATA_SIZE / ALSource->NumChannels /

   680                                               ALSource->SampleSize;

   681             maxstep -= ResamplerPadding[Resampler] +

   682                        ResamplerPrePadding[Resampler] + 1;

   683             maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);

   684 

   685             Pitch = Pitch * ALBuffer->Frequency / Frequency;

   686             if(Pitch > (ALfloat)maxstep)

   687                 ALSource->Params.Step = maxstep<<FRACTIONBITS;

   688             else

   689             {

   690                 ALSource->Params.Step = Pitch*FRACTIONONE;

   691                 if(ALSource->Params.Step == 0)

   692                     ALSource->Params.Step = 1;

   693             }

   694 

   695             if((Device->Flags&DEVICE_USE_HRTF))

   696                 ALSource->Params.DoMix = SelectHrtfMixer(ALBuffer,

   697                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :

   698                                                               Resampler);

   699             else

   700                 ALSource->Params.DoMix = SelectMixer(ALBuffer,

   701                        (ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :

   702                                                               Resampler);

   703             break;

   704         }

   705         BufferListItem = BufferListItem->next;

   706     }

   707 

   708     if((Device->Flags&DEVICE_USE_HRTF))

   709     {

   710         // Use a binaural HRTF algorithm for stereo headphone playback

   711         ALfloat delta, ev = 0.0f, az = 0.0f;

   712 

   713         if(Distance > 0.0f)

   714         {

   715             ALfloat invlen = 1.0f/Distance;

   716             Position[0] *= invlen;

   717             Position[1] *= invlen;

   718             Position[2] *= invlen;

   719 

   720             // Calculate elevation and azimuth only when the source is not at

   721             // the listener.  This prevents +0 and -0 Z from producing

   722             // inconsistent panning.

   723             ev = asin(Position[1]);

   724             az = atan2(Position[0], -Position[2]*ZScale);

   725         }

   726 

   727         // Check to see if the HRIR is already moving.

   728         if(ALSource->HrtfMoving)

   729         {

   730             // Calculate the normalized HRTF transition factor (delta).

   731             delta = CalcHrtfDelta(ALSource->Params.HrtfGain, DryGain,

   732                                   ALSource->Params.HrtfDir, Position);

   733             // If the delta is large enough, get the moving HRIR target

   734             // coefficients, target delays, steppping values, and counter.

   735             if(delta > 0.001f)

   736             {

   737                 ALSource->HrtfCounter = GetMovingHrtfCoeffs(ev, az, DryGain,

   738                                           delta, ALSource->HrtfCounter,

   739                                           ALSource->Params.HrtfCoeffs[0],

   740                                           ALSource->Params.HrtfDelay[0],

   741                                           ALSource->Params.HrtfCoeffStep,

   742                                           ALSource->Params.HrtfDelayStep);

   743                 ALSource->Params.HrtfGain = DryGain;

   744                 ALSource->Params.HrtfDir[0] = Position[0];

   745                 ALSource->Params.HrtfDir[1] = Position[1];

   746                 ALSource->Params.HrtfDir[2] = Position[2];

   747             }

   748         }

   749         else

   750         {

   751             // Get the initial (static) HRIR coefficients and delays.

   752             GetLerpedHrtfCoeffs(ev, az, DryGain,

   753                                 ALSource->Params.HrtfCoeffs[0],

   754                                 ALSource->Params.HrtfDelay[0]);

   755             ALSource->HrtfCounter = 0;

   756             ALSource->Params.HrtfGain = DryGain;

   757             ALSource->Params.HrtfDir[0] = Position[0];

   758             ALSource->Params.HrtfDir[1] = Position[1];

   759             ALSource->Params.HrtfDir[2] = Position[2];

   760         }

   761     }

   762     else

   763     {

   764         // Use energy-preserving panning algorithm for multi-speaker playback

   765         ALfloat DirGain, AmbientGain;

   766         const ALfloat *SpeakerGain;

   767         ALfloat length;

   768         ALint pos;

   769 

   770         length = maxf(Distance, MinDist);

   771         if(length > 0.0f)

   772         {

   773             ALfloat invlen = 1.0f/length;

   774             Position[0] *= invlen;

   775             Position[1] *= invlen;

   776             Position[2] *= invlen;

   777         }

   778 

   779         pos = aluCart2LUTpos(-Position[2]*ZScale, Position[0]);

   780         SpeakerGain = Device->PanningLUT[pos];

   781 

   782         DirGain = aluSqrt(Position[0]*Position[0] + Position[2]*Position[2]);

   783         // elevation adjustment for directional gain. this sucks, but

   784         // has low complexity

   785         AmbientGain = aluSqrt(1.0/Device->NumChan);

   786         for(i = 0;i < MAXCHANNELS;i++)

   787         {

   788             ALuint i2;

   789             for(i2 = 0;i2 < MAXCHANNELS;i2++)

   790                 ALSource->Params.DryGains[i][i2] = 0.0f;

   791         }

   792         for(i = 0;i < (ALint)Device->NumChan;i++)

   793         {

   794             enum Channel chan = Device->Speaker2Chan[i];

   795             ALfloat gain = lerp(AmbientGain, SpeakerGain[chan], DirGain);

   796             ALSource->Params.DryGains[0][chan] = DryGain * gain;

   797         }

   798     }

   799     for(i = 0;i < NumSends;i++)

   800         ALSource->Params.Send[i].WetGain = WetGain[i];

   801 

   802     /* Update filter coefficients. */

   803     cw = cos(2.0*M_PI * LOWPASSFREQCUTOFF / Frequency);

   804 

   805     ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);

   806     for(i = 0;i < NumSends;i++)

   807     {

   808         ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);

   809         ALSource->Params.Send[i].iirFilter.coeff = a;

   810     }

   811 }

   812 

   813 

   814 static __inline ALfloat aluF2F(ALfloat val)

   815 { return val; }

   816 static __inline ALshort aluF2S(ALfloat val)

   817 {

   818     if(val > 1.0f) return 32767;

   819     if(val < -1.0f) return -32768;

   820     return (ALint)(val*32767.0f);

   821 }

   822 static __inline ALushort aluF2US(ALfloat val)

   823 { return aluF2S(val)+32768; }

   824 static __inline ALbyte aluF2B(ALfloat val)

   825 { return aluF2S(val)>>8; }

   826 static __inline ALubyte aluF2UB(ALfloat val)

   827 { return aluF2US(val)>>8; }

   828 

   829 #define DECL_TEMPLATE(T, N, func)                                             \

   830 static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer,            \

   831                             ALuint SamplesToDo)                               \

   832 {                                                                             \

   833     ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer;           \

   834     const enum Channel *ChanMap = device->DevChannels;                        \

   835     ALuint i, j;                                                              \

   836                                                                               \

   837     for(i = 0;i < SamplesToDo;i++)                                            \

   838     {                                                                         \

   839         for(j = 0;j < N;j++)                                                  \

   840             *(buffer++) = func(DryBuffer[i][ChanMap[j]]);                     \

   841     }                                                                         \

   842 }

   843 

   844 DECL_TEMPLATE(ALfloat, 1, aluF2F)

   845 DECL_TEMPLATE(ALfloat, 4, aluF2F)

   846 DECL_TEMPLATE(ALfloat, 6, aluF2F)

   847 DECL_TEMPLATE(ALfloat, 7, aluF2F)

   848 DECL_TEMPLATE(ALfloat, 8, aluF2F)

   849 

   850 DECL_TEMPLATE(ALushort, 1, aluF2US)

   851 DECL_TEMPLATE(ALushort, 4, aluF2US)

   852 DECL_TEMPLATE(ALushort, 6, aluF2US)

   853 DECL_TEMPLATE(ALushort, 7, aluF2US)

   854 DECL_TEMPLATE(ALushort, 8, aluF2US)

   855 

   856 DECL_TEMPLATE(ALshort, 1, aluF2S)

   857 DECL_TEMPLATE(ALshort, 4, aluF2S)

   858 DECL_TEMPLATE(ALshort, 6, aluF2S)

   859 DECL_TEMPLATE(ALshort, 7, aluF2S)

   860 DECL_TEMPLATE(ALshort, 8, aluF2S)

   861 

   862 DECL_TEMPLATE(ALubyte, 1, aluF2UB)

   863 DECL_TEMPLATE(ALubyte, 4, aluF2UB)

   864 DECL_TEMPLATE(ALubyte, 6, aluF2UB)

   865 DECL_TEMPLATE(ALubyte, 7, aluF2UB)

   866 DECL_TEMPLATE(ALubyte, 8, aluF2UB)

   867 

   868 DECL_TEMPLATE(ALbyte, 1, aluF2B)

   869 DECL_TEMPLATE(ALbyte, 4, aluF2B)

   870 DECL_TEMPLATE(ALbyte, 6, aluF2B)

   871 DECL_TEMPLATE(ALbyte, 7, aluF2B)

   872 DECL_TEMPLATE(ALbyte, 8, aluF2B)

   873 

   874 #undef DECL_TEMPLATE

   875 

   876 #define DECL_TEMPLATE(T, N, func)                                             \

   877 static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer,            \

   878                             ALuint SamplesToDo)                               \

   879 {                                                                             \

   880     ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer;           \

   881     const enum Channel *ChanMap = device->DevChannels;                        \

   882     ALuint i, j;                                                              \

   883                                                                               \

   884     if(device->Bs2b)                                                          \

   885     {                                                                         \

   886         for(i = 0;i < SamplesToDo;i++)                                        \

   887         {                                                                     \

   888             float samples[2];                                                 \

   889             samples[0] = DryBuffer[i][ChanMap[0]];                            \

   890             samples[1] = DryBuffer[i][ChanMap[1]];                            \

   891             bs2b_cross_feed(device->Bs2b, samples);                           \

   892             *(buffer++) = func(samples[0]);                                   \

   893             *(buffer++) = func(samples[1]);                                   \

   894         }                                                                     \

   895     }                                                                         \

   896     else                                                                      \

   897     {                                                                         \

   898         for(i = 0;i < SamplesToDo;i++)                                        \

   899         {                                                                     \

   900             for(j = 0;j < N;j++)                                              \

   901                 *(buffer++) = func(DryBuffer[i][ChanMap[j]]);                 \

   902         }                                                                     \

   903     }                                                                         \

   904 }

   905 

   906 DECL_TEMPLATE(ALfloat, 2, aluF2F)

   907 DECL_TEMPLATE(ALushort, 2, aluF2US)

   908 DECL_TEMPLATE(ALshort, 2, aluF2S)

   909 DECL_TEMPLATE(ALubyte, 2, aluF2UB)

   910 DECL_TEMPLATE(ALbyte, 2, aluF2B)

   911 

   912 #undef DECL_TEMPLATE

   913 

   914 #define DECL_TEMPLATE(T)                                                      \

   915 static void Write_##T(ALCdevice *device, T *buffer, ALuint SamplesToDo)       \

   916 {                                                                             \

   917     switch(device->FmtChans)                                                  \

   918     {                                                                         \

   919         case DevFmtMono:                                                      \

   920             Write_##T##_1(device, buffer, SamplesToDo);                       \

   921             break;                                                            \

   922         case DevFmtStereo:                                                    \

   923             Write_##T##_2(device, buffer, SamplesToDo);                       \

   924             break;                                                            \

   925         case DevFmtQuad:                                                      \

   926             Write_##T##_4(device, buffer, SamplesToDo);                       \

   927             break;                                                            \

   928         case DevFmtX51:                                                       \

   929         case DevFmtX51Side:                                                   \

   930             Write_##T##_6(device, buffer, SamplesToDo);                       \

   931             break;                                                            \

   932         case DevFmtX61:                                                       \

   933             Write_##T##_7(device, buffer, SamplesToDo);                       \

   934             break;                                                            \

   935         case DevFmtX71:                                                       \

   936             Write_##T##_8(device, buffer, SamplesToDo);                       \

   937             break;                                                            \

   938     }                                                                         \

   939 }

   940 

   941 DECL_TEMPLATE(ALfloat)

   942 DECL_TEMPLATE(ALushort)

   943 DECL_TEMPLATE(ALshort)

   944 DECL_TEMPLATE(ALubyte)

   945 DECL_TEMPLATE(ALbyte)

   946 

   947 #undef DECL_TEMPLATE

   948 

   949 ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)

   950 {

   951     ALuint SamplesToDo;

   952     ALeffectslot *ALEffectSlot;

   953     ALCcontext **ctx, **ctx_end;

   954     ALsource **src, **src_end;

   955     int fpuState;

   956     ALuint i, c;

   957     ALsizei e;

   958 

   959 #if defined(HAVE_FESETROUND)

   960     fpuState = fegetround();

   961     fesetround(FE_TOWARDZERO);

   962 #elif defined(HAVE__CONTROLFP)

   963     fpuState = _controlfp(0, 0);

   964     (void)_controlfp(_RC_CHOP, _MCW_RC);

   965 #else

   966     (void)fpuState;

   967 #endif

   968 

   969     while(size > 0)

   970     {

   971         /* Setup variables */

   972         SamplesToDo = minu(size, BUFFERSIZE);

   973 

   974         /* Clear mixing buffer */

   975         memset(device->DryBuffer, 0, SamplesToDo*MAXCHANNELS*sizeof(ALfloat));

   976 

   977         LockDevice(device);

   978         ctx = device->Contexts;

   979         ctx_end = ctx + device->NumContexts;

   980 	//printf("Contexts: %d\n", device->NumContexts);

   981 	int context_number = 0;

   982         while(ctx != ctx_end)

   983 	  {

   984 	    //printf("Context %d:\n", context_number++);

   985             ALboolean DeferUpdates = (*ctx)->DeferUpdates;

   986             ALboolean UpdateSources = AL_FALSE;

   987 

   988             if(!DeferUpdates)

   989             {

   990 	      //printf("NOT deferring updates, whatever that means\n");

   991                 UpdateSources = (*ctx)->UpdateSources;

   992 		//printf("update sources is set to %d\n", UpdateSources);

   993                 (*ctx)->UpdateSources = AL_FALSE;

   994             }

   995 

   996             src = (*ctx)->ActiveSources;

   997             src_end = src + (*ctx)->ActiveSourceCount;

   998 	    //printf("number of active sources are %d\n", (*ctx)->ActiveSourceCount);

   999             while(src != src_end)

  1000             {

  1001  	        

  1002                 if((*src)->state != AL_PLAYING)

  1003                 {

  1004                     --((*ctx)->ActiveSourceCount);

  1005                     *src = *(--src_end);

  1006                     continue;

  1007                 }

  1008 

  1009                 if(!DeferUpdates && ((*src)->NeedsUpdate || UpdateSources))

  1010                 {

  1011                     (*src)->NeedsUpdate = AL_FALSE;

  1012                     ALsource_Update(*src, *ctx);

  1013                 }

  1014 		//printf("calling MixSource!\n");

  1015                 MixSource(*src, device, SamplesToDo);

  1016                 src++;

  1017             }

  1018 

  1019             /* effect slot processing */

  1020             for(e = 0;e < (*ctx)->EffectSlotMap.size;e++)

  1021             {

  1022                 ALEffectSlot = (*ctx)->EffectSlotMap.array[e].value;

  1023 

  1024                 for(i = 0;i < SamplesToDo;i++)

  1025                 {

  1026 		  // RLM: remove click-removal

  1027 		  ALEffectSlot->WetBuffer[i] += ALEffectSlot->ClickRemoval[0];

  1028 		  ALEffectSlot->ClickRemoval[0] -= ALEffectSlot->ClickRemoval[0] / 256.0f;

  1029                 }

  1030                 for(i = 0;i < 1;i++)

  1031                 {

  1032 		  // RLM: remove click-removal

  1033 		  ALEffectSlot->ClickRemoval[i] += ALEffectSlot->PendingClicks[i];

  1034 		  ALEffectSlot->PendingClicks[i] = 0.0f;

  1035                 }

  1036 

  1037                 if(!DeferUpdates && ALEffectSlot->NeedsUpdate)

  1038                 {

  1039                     ALEffectSlot->NeedsUpdate = AL_FALSE;

  1040                     ALEffect_Update(ALEffectSlot->EffectState, *ctx, ALEffectSlot);

  1041                 }

  1042 

  1043                 ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot,

  1044                                  SamplesToDo, ALEffectSlot->WetBuffer,

  1045                                  device->DryBuffer);

  1046 

  1047                 for(i = 0;i < SamplesToDo;i++)

  1048                     ALEffectSlot->WetBuffer[i] = 0.0f;

  1049             }

  1050 

  1051             ctx++;

  1052         }

  1053         UnlockDevice(device);

  1054 

  1055         //Post processing loop

  1056         if(device->FmtChans == DevFmtMono)

  1057         {

  1058             for(i = 0;i < SamplesToDo;i++)

  1059             {

  1060 	      // RLM: remove click-removal

  1061 	      device->DryBuffer[i][FRONT_CENTER] += device->ClickRemoval[FRONT_CENTER];

  1062 	      device->ClickRemoval[FRONT_CENTER] -= device->ClickRemoval[FRONT_CENTER] / 256.0f;

  1063             }

  1064 	    // RLM: remove click-removal

  1065             device->ClickRemoval[FRONT_CENTER] += device->PendingClicks[FRONT_CENTER];

  1066             device->PendingClicks[FRONT_CENTER] = 0.0f;

  1067         }

  1068         else if(device->FmtChans == DevFmtStereo)

  1069         {

  1070             /* Assumes the first two channels are FRONT_LEFT and FRONT_RIGHT */

  1071             for(i = 0;i < SamplesToDo;i++)

  1072             {

  1073                 for(c = 0;c < 2;c++)

  1074                 {

  1075 		  // RLM: remove click-removal

  1076 		  device->DryBuffer[i][c] += device->ClickRemoval[c];

  1077 		  device->ClickRemoval[c] -= device->ClickRemoval[c] / 256.0f;

  1078                 }

  1079             }

  1080             for(c = 0;c < 2;c++)

  1081 	      {

  1082 		// RLM: remove click-removal

  1083 		device->ClickRemoval[c] += device->PendingClicks[c];

  1084 		device->PendingClicks[c] = 0.0f;

  1085 	      }

  1086         }

  1087         else

  1088 	  {

  1089             for(i = 0;i < SamplesToDo;i++)

  1090 	      {

  1091                 for(c = 0;c < MAXCHANNELS;c++)

  1092 		  {

  1093 		    // RLM: remove click-removal

  1094 		    device->DryBuffer[i][c] += device->ClickRemoval[c];

  1095 		    device->ClickRemoval[c] -= device->ClickRemoval[c] / 256.0f;

  1096                 }

  1097             }

  1098             for(c = 0;c < MAXCHANNELS;c++)

  1099             {

  1100 	      // RLM: remove click-removal

  1101 	      device->ClickRemoval[c] += device->PendingClicks[c];

  1102 	      device->PendingClicks[c] = 0.0f;

  1103             }

  1104         }

  1105 

  1106         if(buffer)

  1107         {

  1108             switch(device->FmtType)

  1109             {

  1110                 case DevFmtByte:

  1111                     Write_ALbyte(device, buffer, SamplesToDo);

  1112                     break;

  1113                 case DevFmtUByte:

  1114                     Write_ALubyte(device, buffer, SamplesToDo);

  1115                     break;

  1116                 case DevFmtShort:

  1117                     Write_ALshort(device, buffer, SamplesToDo);

  1118                     break;

  1119                 case DevFmtUShort:

  1120                     Write_ALushort(device, buffer, SamplesToDo);

  1121                     break;

  1122                 case DevFmtFloat:

  1123                     Write_ALfloat(device, buffer, SamplesToDo);

  1124                     break;

  1125             }

  1126         }

  1127 

  1128         size -= SamplesToDo;

  1129     }

  1130 

  1131 #if defined(HAVE_FESETROUND)

  1132     fesetround(fpuState);

  1133 #elif defined(HAVE__CONTROLFP)

  1134     _controlfp(fpuState, _MCW_RC);

  1135 #endif

  1136 }

  1137 

  1138 

  1139 

  1140 

  1141 

  1142 ALvoid aluHandleDisconnect(ALCdevice *device)

  1143 {

  1144     ALuint i;

  1145 

  1146     LockDevice(device);

  1147     for(i = 0;i < device->NumContexts;i++)

  1148     {

  1149         ALCcontext *Context = device->Contexts[i];

  1150         ALsource *source;

  1151         ALsizei pos;

  1152 

  1153         for(pos = 0;pos < Context->SourceMap.size;pos++)

  1154         {

  1155             source = Context->SourceMap.array[pos].value;

  1156             if(source->state == AL_PLAYING)

  1157             {

  1158                 source->state = AL_STOPPED;

  1159                 source->BuffersPlayed = source->BuffersInQueue;

  1160                 source->position = 0;

  1161                 source->position_fraction = 0;

  1162             }

  1163         }

  1164     }

  1165 

  1166     device->Connected = ALC_FALSE;

  1167     UnlockDevice(device);

  1168 }
author	Robert McIntyre <rlm@mit.edu>
date	Tue, 25 Oct 2011 13:02:31 -0700
parents
children