?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Clamp the upper and lower bound of the doppler velocity scale more like the original
[openal-soft/openal-hmr.git] / Alc / ALu.c
blob223928bb6122153d423428658cc57c5ef6706c1c
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 struct ChanMap {
41 enum Channel channel;
42 ALfloat angle;
43 };
44
45 /* Cone scalar */
46 ALfloat ConeScale = 0.5f;
47
48 /* Localized Z scalar for mono sources */
49 ALfloat ZScale = 1.0f;
50
51
52 static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat w,ALfloat matrix[4][4])
53 {
54 ALfloat temp[4] = {
55 vector[0], vector[1], vector[2], w
56 };
57
58 vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
59 vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
60 vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
61 }
62
63
64 ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
65 {
66 static const struct ChanMap MonoMap[1] = { { FRONT_CENTER, 0.0f } };
67 static const struct ChanMap StereoMap[2] = {
68 { FRONT_LEFT, -30.0f * F_PI/180.0f },
69 { FRONT_RIGHT, 30.0f * F_PI/180.0f }
70 };
71 static const struct ChanMap RearMap[2] = {
72 { BACK_LEFT, -150.0f * F_PI/180.0f },
73 { BACK_RIGHT, 150.0f * F_PI/180.0f }
74 };
75 static const struct ChanMap QuadMap[4] = {
76 { FRONT_LEFT, -45.0f * F_PI/180.0f },
77 { FRONT_RIGHT, 45.0f * F_PI/180.0f },
78 { BACK_LEFT, -135.0f * F_PI/180.0f },
79 { BACK_RIGHT, 135.0f * F_PI/180.0f }
80 };
81 static const struct ChanMap X51Map[6] = {
82 { FRONT_LEFT, -30.0f * F_PI/180.0f },
83 { FRONT_RIGHT, 30.0f * F_PI/180.0f },
84 { FRONT_CENTER, 0.0f * F_PI/180.0f },
85 { LFE, 0.0f },
86 { BACK_LEFT, -110.0f * F_PI/180.0f },
87 { BACK_RIGHT, 110.0f * F_PI/180.0f }
88 };
89 static const struct ChanMap X61Map[7] = {
90 { FRONT_LEFT, -30.0f * F_PI/180.0f },
91 { FRONT_RIGHT, 30.0f * F_PI/180.0f },
92 { FRONT_CENTER, 0.0f * F_PI/180.0f },
93 { LFE, 0.0f },
94 { BACK_CENTER, 180.0f * F_PI/180.0f },
95 { SIDE_LEFT, -90.0f * F_PI/180.0f },
96 { SIDE_RIGHT, 90.0f * F_PI/180.0f }
97 };
98 static const struct ChanMap X71Map[8] = {
99 { FRONT_LEFT, -30.0f * F_PI/180.0f },
100 { FRONT_RIGHT, 30.0f * F_PI/180.0f },
101 { FRONT_CENTER, 0.0f * F_PI/180.0f },
102 { LFE, 0.0f },
103 { BACK_LEFT, -150.0f * F_PI/180.0f },
104 { BACK_RIGHT, 150.0f * F_PI/180.0f },
105 { SIDE_LEFT, -90.0f * F_PI/180.0f },
106 { SIDE_RIGHT, 90.0f * F_PI/180.0f }
107 };
108
109 ALCdevice *Device = ALContext->Device;
110 ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
111 ALbufferlistitem *BufferListItem;
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 *ChannelGain;
119 const struct ChanMap *chans = NULL;
120 enum Resampler Resampler;
121 ALint num_channels = 0;
122 ALboolean DirectChannels;
123 ALfloat Pitch;
124 ALfloat cw;
125 ALuint pos;
126 ALint i, c;
127
128 /* Get device properties */
129 NumSends = Device->NumAuxSends;
130 Frequency = Device->Frequency;
131
132 /* Get listener properties */
133 ListenerGain = ALContext->Listener.Gain;
134
135 /* Get source properties */
136 SourceVolume = ALSource->flGain;
137 MinVolume = ALSource->flMinGain;
138 MaxVolume = ALSource->flMaxGain;
139 Pitch = ALSource->flPitch;
140 Resampler = ALSource->Resampler;
141 DirectChannels = ALSource->DirectChannels;
142
143 /* Calculate the stepping value */
144 Channels = FmtMono;
145 BufferListItem = ALSource->queue;
146 while(BufferListItem != NULL)
147 {
148 ALbuffer *ALBuffer;
149 if((ALBuffer=BufferListItem->buffer) != NULL)
150 {
151 ALsizei maxstep = STACK_DATA_SIZE/sizeof(ALfloat) /
152 ALSource->NumChannels;
153 maxstep -= ResamplerPadding[Resampler] +
154 ResamplerPrePadding[Resampler] + 1;
155 maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
156
157 Pitch = Pitch * ALBuffer->Frequency / Frequency;
158 if(Pitch > (ALfloat)maxstep)
159 ALSource->Params.Step = maxstep<<FRACTIONBITS;
160 else
161 {
162 ALSource->Params.Step = fastf2i(Pitch*FRACTIONONE);
163 if(ALSource->Params.Step == 0)
164 ALSource->Params.Step = 1;
165 }
166 if(ALSource->Params.Step == FRACTIONONE)
167 Resampler = PointResampler;
168
169 Channels = ALBuffer->FmtChannels;
170 break;
171 }
172 BufferListItem = BufferListItem->next;
173 }
174 if(!DirectChannels && Device->Hrtf)
175 ALSource->Params.DoMix = SelectHrtfMixer(Resampler);
176 else
177 ALSource->Params.DoMix = SelectMixer(Resampler);
178
179 /* Calculate gains */
180 DryGain = clampf(SourceVolume, MinVolume, MaxVolume);
181 DryGain *= ALSource->DirectGain;
182 DryGainHF = ALSource->DirectGainHF;
183 for(i = 0;i < NumSends;i++)
184 {
185 WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);
186 WetGain[i] *= ALSource->Send[i].WetGain;
187 WetGainHF[i] = ALSource->Send[i].WetGainHF;
188 }
189
190 SrcMatrix = ALSource->Params.DryGains;
191 for(i = 0;i < MAXCHANNELS;i++)
192 {
193 for(c = 0;c < MAXCHANNELS;c++)
194 SrcMatrix[i][c] = 0.0f;
195 }
196 switch(Channels)
197 {
198 case FmtMono:
199 chans = MonoMap;
200 num_channels = 1;
201 break;
202 case FmtStereo:
203 if(!DirectChannels && (Device->Flags&DEVICE_DUPLICATE_STEREO))
204 {
205 DryGain *= aluSqrt(2.0f/4.0f);
206 for(c = 0;c < 2;c++)
207 {
208 pos = aluCart2LUTpos(aluCos(RearMap[c].angle),
209 aluSin(RearMap[c].angle));
210 ChannelGain = Device->PanningLUT[pos];
211
212 for(i = 0;i < (ALint)Device->NumChan;i++)
213 {
214 enum Channel chan = Device->Speaker2Chan[i];
215 SrcMatrix[c][chan] += DryGain * ListenerGain *
216 ChannelGain[chan];
217 }
218 }
219 }
220 chans = StereoMap;
221 num_channels = 2;
222 break;
223
224 case FmtRear:
225 chans = RearMap;
226 num_channels = 2;
227 break;
228
229 case FmtQuad:
230 chans = QuadMap;
231 num_channels = 4;
232 break;
233
234 case FmtX51:
235 chans = X51Map;
236 num_channels = 6;
237 break;
238
239 case FmtX61:
240 chans = X61Map;
241 num_channels = 7;
242 break;
243
244 case FmtX71:
245 chans = X71Map;
246 num_channels = 8;
247 break;
248 }
249
250 if(DirectChannels != AL_FALSE)
251 {
252 for(c = 0;c < num_channels;c++)
253 SrcMatrix[c][chans[c].channel] += DryGain * ListenerGain;
254 }
255 else if(Device->Hrtf)
256 {
257 for(c = 0;c < num_channels;c++)
258 {
259 if(chans[c].channel == LFE)
260 {
261 /* Skip LFE */
262 ALSource->Params.HrtfDelay[c][0] = 0;
263 ALSource->Params.HrtfDelay[c][1] = 0;
264 for(i = 0;i < HRIR_LENGTH;i++)
265 {
266 ALSource->Params.HrtfCoeffs[c][i][0] = 0.0f;
267 ALSource->Params.HrtfCoeffs[c][i][1] = 0.0f;
268 }
269 }
270 else
271 {
272 /* Get the static HRIR coefficients and delays for this
273 * channel. */
274 GetLerpedHrtfCoeffs(Device->Hrtf,
275 0.0f, F_PI/180.0f * chans[c].angle,
276 DryGain*ListenerGain,
277 ALSource->Params.HrtfCoeffs[c],
278 ALSource->Params.HrtfDelay[c]);
279 }
280 ALSource->HrtfCounter = 0;
281 }
282 }
283 else
284 {
285 for(c = 0;c < num_channels;c++)
286 {
287 if(chans[c].channel == LFE) /* Special-case LFE */
288 {
289 SrcMatrix[c][LFE] += DryGain * ListenerGain;
290 continue;
291 }
292 pos = aluCart2LUTpos(aluCos(chans[c].angle), aluSin(chans[c].angle));
293 ChannelGain = Device->PanningLUT[pos];
294
295 for(i = 0;i < (ALint)Device->NumChan;i++)
296 {
297 enum Channel chan = Device->Speaker2Chan[i];
298 SrcMatrix[c][chan] += DryGain * ListenerGain *
299 ChannelGain[chan];
300 }
301 }
302 }
303 for(i = 0;i < NumSends;i++)
304 {
305 ALeffectslot *Slot = ALSource->Send[i].Slot;
306
307 if(!Slot && i == 0)
308 Slot = Device->DefaultSlot;
309 if(Slot && Slot->effect.type == AL_EFFECT_NULL)
310 Slot = NULL;
311 ALSource->Params.Send[i].Slot = Slot;
312 ALSource->Params.Send[i].WetGain = WetGain[i] * ListenerGain;
313 }
314
315 /* Update filter coefficients. Calculations based on the I3DL2
316 * spec. */
317 cw = aluCos(F_PI*2.0f * LOWPASSFREQREF / Frequency);
318
319 /* We use two chained one-pole filters, so we need to take the
320 * square root of the squared gain, which is the same as the base
321 * gain. */
322 ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
323 for(i = 0;i < NumSends;i++)
324 {
325 /* We use a one-pole filter, so we need to take the squared gain */
326 ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
327 ALSource->Params.Send[i].iirFilter.coeff = a;
328 }
329 }
330
331 ALvoid CalcSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
332 {
333 const ALCdevice *Device = ALContext->Device;
334 ALfloat InnerAngle,OuterAngle,Angle,Distance,ClampedDist;
335 ALfloat Direction[3],Position[3],SourceToListener[3];
336 ALfloat Velocity[3],ListenerVel[3];
337 ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;
338 ALfloat ConeVolume,ConeHF,SourceVolume,ListenerGain;
339 ALfloat DopplerFactor, SpeedOfSound;
340 ALfloat AirAbsorptionFactor;
341 ALfloat RoomAirAbsorption[MAX_SENDS];
342 ALbufferlistitem *BufferListItem;
343 ALfloat Attenuation, EffectiveDist;
344 ALfloat RoomAttenuation[MAX_SENDS];
345 ALfloat MetersPerUnit;
346 ALfloat RoomRolloffBase;
347 ALfloat RoomRolloff[MAX_SENDS];
348 ALfloat DecayDistance[MAX_SENDS];
349 ALfloat DryGain;
350 ALfloat DryGainHF;
351 ALboolean DryGainHFAuto;
352 ALfloat WetGain[MAX_SENDS];
353 ALfloat WetGainHF[MAX_SENDS];
354 ALboolean WetGainAuto;
355 ALboolean WetGainHFAuto;
356 enum Resampler Resampler;
357 ALfloat Pitch;
358 ALuint Frequency;
359 ALint NumSends;
360 ALfloat cw;
361 ALint i;
362
363 DryGainHF = 1.0f;
364 for(i = 0;i < MAX_SENDS;i++)
365 WetGainHF[i] = 1.0f;
366
367 //Get context properties
368 DopplerFactor = ALContext->DopplerFactor * ALSource->DopplerFactor;
369 SpeedOfSound = ALContext->flSpeedOfSound * ALContext->DopplerVelocity;
370 NumSends = Device->NumAuxSends;
371 Frequency = Device->Frequency;
372
373 //Get listener properties
374 ListenerGain = ALContext->Listener.Gain;
375 MetersPerUnit = ALContext->Listener.MetersPerUnit;
376 ListenerVel[0] = ALContext->Listener.Velocity[0];
377 ListenerVel[1] = ALContext->Listener.Velocity[1];
378 ListenerVel[2] = ALContext->Listener.Velocity[2];
379
380 //Get source properties
381 SourceVolume = ALSource->flGain;
382 MinVolume = ALSource->flMinGain;
383 MaxVolume = ALSource->flMaxGain;
384 Pitch = ALSource->flPitch;
385 Resampler = ALSource->Resampler;
386 Position[0] = ALSource->vPosition[0];
387 Position[1] = ALSource->vPosition[1];
388 Position[2] = ALSource->vPosition[2];
389 Direction[0] = ALSource->vOrientation[0];
390 Direction[1] = ALSource->vOrientation[1];
391 Direction[2] = ALSource->vOrientation[2];
392 Velocity[0] = ALSource->vVelocity[0];
393 Velocity[1] = ALSource->vVelocity[1];
394 Velocity[2] = ALSource->vVelocity[2];
395 MinDist = ALSource->flRefDistance;
396 MaxDist = ALSource->flMaxDistance;
397 Rolloff = ALSource->flRollOffFactor;
398 InnerAngle = ALSource->flInnerAngle * ConeScale;
399 OuterAngle = ALSource->flOuterAngle * ConeScale;
400 AirAbsorptionFactor = ALSource->AirAbsorptionFactor;
401 DryGainHFAuto = ALSource->DryGainHFAuto;
402 WetGainAuto = ALSource->WetGainAuto;
403 WetGainHFAuto = ALSource->WetGainHFAuto;
404 RoomRolloffBase = ALSource->RoomRolloffFactor;
405 for(i = 0;i < NumSends;i++)
406 {
407 ALeffectslot *Slot = ALSource->Send[i].Slot;
408
409 if(!Slot && i == 0)
410 Slot = Device->DefaultSlot;
411 if(!Slot || Slot->effect.type == AL_EFFECT_NULL)
412 {
413 Slot = NULL;
414 RoomRolloff[i] = 0.0f;
415 DecayDistance[i] = 0.0f;
416 RoomAirAbsorption[i] = 1.0f;
417 }
418 else if(Slot->AuxSendAuto)
419 {
420 RoomRolloff[i] = RoomRolloffBase;
421 if(IsReverbEffect(Slot->effect.type))
422 {
423 RoomRolloff[i] += Slot->effect.Reverb.RoomRolloffFactor;
424 DecayDistance[i] = Slot->effect.Reverb.DecayTime *
425 SPEEDOFSOUNDMETRESPERSEC;
426 RoomAirAbsorption[i] = Slot->effect.Reverb.AirAbsorptionGainHF;
427 }
428 else
429 {
430 DecayDistance[i] = 0.0f;
431 RoomAirAbsorption[i] = 1.0f;
432 }
433 }
434 else
435 {
436 /* If the slot's auxiliary send auto is off, the data sent to the
437 * effect slot is the same as the dry path, sans filter effects */
438 RoomRolloff[i] = Rolloff;
439 DecayDistance[i] = 0.0f;
440 RoomAirAbsorption[i] = AIRABSORBGAINHF;
441 }
442
443 ALSource->Params.Send[i].Slot = Slot;
444 }
445
446 //1. Translate Listener to origin (convert to head relative)
447 if(ALSource->bHeadRelative == AL_FALSE)
448 {
449 ALfloat Matrix[4][4];
450 for(i = 0;i < 4;i++)
451 {
452 ALint i2;
453 for(i2 = 0;i2 < 4;i2++)
454 Matrix[i][i2] = ALContext->Listener.Matrix[i][i2];
455 }
456
457 /* Translate position */
458 Position[0] -= ALContext->Listener.Position[0];
459 Position[1] -= ALContext->Listener.Position[1];
460 Position[2] -= ALContext->Listener.Position[2];
461
462 /* Transform source vectors into listener space */
463 aluMatrixVector(Position, 1.0f, Matrix);
464 aluMatrixVector(Direction, 0.0f, Matrix);
465 aluMatrixVector(Velocity, 0.0f, Matrix);
466 /* Transform listener vectors into listener space */
467 aluMatrixVector(ListenerVel, 0.0f, Matrix);
468 }
469 else
470 {
471 ListenerVel[0] = 0.0f;
472 ListenerVel[1] = 0.0f;
473 ListenerVel[2] = 0.0f;
474 }
475
476 SourceToListener[0] = -Position[0];
477 SourceToListener[1] = -Position[1];
478 SourceToListener[2] = -Position[2];
479 aluNormalize(SourceToListener);
480 aluNormalize(Direction);
481
482 //2. Calculate distance attenuation
483 Distance = aluSqrt(aluDotproduct(Position, Position));
484 ClampedDist = Distance;
485
486 Attenuation = 1.0f;
487 for(i = 0;i < NumSends;i++)
488 RoomAttenuation[i] = 1.0f;
489 switch(ALContext->SourceDistanceModel ? ALSource->DistanceModel :
490 ALContext->DistanceModel)
491 {
492 case InverseDistanceClamped:
493 ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
494 if(MaxDist < MinDist)
495 break;
496 //fall-through
497 case InverseDistance:
498 if(MinDist > 0.0f)
499 {
500 if((MinDist + (Rolloff * (ClampedDist - MinDist))) > 0.0f)
501 Attenuation = MinDist / (MinDist + (Rolloff * (ClampedDist - MinDist)));
502 for(i = 0;i < NumSends;i++)
503 {
504 if((MinDist + (RoomRolloff[i] * (ClampedDist - MinDist))) > 0.0f)
505 RoomAttenuation[i] = MinDist / (MinDist + (RoomRolloff[i] * (ClampedDist - MinDist)));
506 }
507 }
508 break;
509
510 case LinearDistanceClamped:
511 ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
512 if(MaxDist < MinDist)
513 break;
514 //fall-through
515 case LinearDistance:
516 if(MaxDist != MinDist)
517 {
518 Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));
519 Attenuation = maxf(Attenuation, 0.0f);
520 for(i = 0;i < NumSends;i++)
521 {
522 RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));
523 RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);
524 }
525 }
526 break;
527
528 case ExponentDistanceClamped:
529 ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
530 if(MaxDist < MinDist)
531 break;
532 //fall-through
533 case ExponentDistance:
534 if(ClampedDist > 0.0f && MinDist > 0.0f)
535 {
536 Attenuation = aluPow(ClampedDist/MinDist, -Rolloff);
537 for(i = 0;i < NumSends;i++)
538 RoomAttenuation[i] = aluPow(ClampedDist/MinDist, -RoomRolloff[i]);
539 }
540 break;
541
542 case DisableDistance:
543 break;
544 }
545
546 // Source Gain + Attenuation
547 DryGain = SourceVolume * Attenuation;
548 for(i = 0;i < NumSends;i++)
549 WetGain[i] = SourceVolume * RoomAttenuation[i];
550
551 // Distance-based air absorption
552 EffectiveDist = 0.0f;
553 if(MinDist > 0.0f && Attenuation < 1.0f)
554 EffectiveDist = (MinDist/Attenuation - MinDist)*MetersPerUnit;
555 if(AirAbsorptionFactor > 0.0f && EffectiveDist > 0.0f)
556 {
557 DryGainHF *= aluPow(AIRABSORBGAINHF, AirAbsorptionFactor*EffectiveDist);
558 for(i = 0;i < NumSends;i++)
559 WetGainHF[i] *= aluPow(RoomAirAbsorption[i],
560 AirAbsorptionFactor*EffectiveDist);
561 }
562
563 if(WetGainAuto)
564 {
565 /* Apply a decay-time transformation to the wet path, based on the
566 * attenuation of the dry path.
567 *
568 * Using the approximate (effective) source to listener distance, the
569 * initial decay of the reverb effect is calculated and applied to the
570 * wet path.
571 */
572 for(i = 0;i < NumSends;i++)
573 {
574 if(DecayDistance[i] > 0.0f)
575 WetGain[i] *= aluPow(0.001f /* -60dB */,
576 EffectiveDist / DecayDistance[i]);
577 }
578 }
579
580 /* Calculate directional soundcones */
581 Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * (180.0f/F_PI);
582 if(Angle >= InnerAngle && Angle <= OuterAngle)
583 {
584 ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
585 ConeVolume = lerp(1.0f, ALSource->flOuterGain, scale);
586 ConeHF = lerp(1.0f, ALSource->OuterGainHF, scale);
587 }
588 else if(Angle > OuterAngle)
589 {
590 ConeVolume = ALSource->flOuterGain;
591 ConeHF = ALSource->OuterGainHF;
592 }
593 else
594 {
595 ConeVolume = 1.0f;
596 ConeHF = 1.0f;
597 }
598
599 DryGain *= ConeVolume;
600 if(WetGainAuto)
601 {
602 for(i = 0;i < NumSends;i++)
603 WetGain[i] *= ConeVolume;
604 }
605 if(DryGainHFAuto)
606 DryGainHF *= ConeHF;
607 if(WetGainHFAuto)
608 {
609 for(i = 0;i < NumSends;i++)
610 WetGainHF[i] *= ConeHF;
611 }
612
613 // Clamp to Min/Max Gain
614 DryGain = clampf(DryGain, MinVolume, MaxVolume);
615 for(i = 0;i < NumSends;i++)
616 WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);
617
618 // Apply filter gains and filters
619 DryGain *= ALSource->DirectGain * ListenerGain;
620 DryGainHF *= ALSource->DirectGainHF;
621 for(i = 0;i < NumSends;i++)
622 {
623 WetGain[i] *= ALSource->Send[i].WetGain * ListenerGain;
624 WetGainHF[i] *= ALSource->Send[i].WetGainHF;
625 }
626
627 // Calculate Velocity
628 if(DopplerFactor > 0.0f && SpeedOfSound > 0.5f)
629 {
630 ALfloat VSS, VLS;
631
632 VSS = aluDotproduct(Velocity, SourceToListener) * DopplerFactor;
633 VLS = aluDotproduct(ListenerVel, SourceToListener) * DopplerFactor;
634
635 Pitch *= clampf(SpeedOfSound-VLS, 1.0f, SpeedOfSound*2.0f - 1.0f) /
636 clampf(SpeedOfSound-VSS, 1.0f, SpeedOfSound*2.0f - 1.0f);
637 }
638
639 BufferListItem = ALSource->queue;
640 while(BufferListItem != NULL)
641 {
642 ALbuffer *ALBuffer;
643 if((ALBuffer=BufferListItem->buffer) != NULL)
644 {
645 ALsizei maxstep = STACK_DATA_SIZE/sizeof(ALfloat) /
646 ALSource->NumChannels;
647 maxstep -= ResamplerPadding[Resampler] +
648 ResamplerPrePadding[Resampler] + 1;
649 maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
650
651 Pitch = Pitch * ALBuffer->Frequency / Frequency;
652 if(Pitch > (ALfloat)maxstep)
653 ALSource->Params.Step = maxstep<<FRACTIONBITS;
654 else
655 {
656 ALSource->Params.Step = fastf2i(Pitch*FRACTIONONE);
657 if(ALSource->Params.Step == 0)
658 ALSource->Params.Step = 1;
659 }
660 if(ALSource->Params.Step == FRACTIONONE)
661 Resampler = PointResampler;
662
663 break;
664 }
665 BufferListItem = BufferListItem->next;
666 }
667 if(Device->Hrtf)
668 ALSource->Params.DoMix = SelectHrtfMixer(Resampler);
669 else
670 ALSource->Params.DoMix = SelectMixer(Resampler);
671
672 if(Device->Hrtf)
673 {
674 // Use a binaural HRTF algorithm for stereo headphone playback
675 ALfloat delta, ev = 0.0f, az = 0.0f;
676
677 if(Distance > 0.0f)
678 {
679 ALfloat invlen = 1.0f/Distance;
680 Position[0] *= invlen;
681 Position[1] *= invlen;
682 Position[2] *= invlen;
683
684 // Calculate elevation and azimuth only when the source is not at
685 // the listener. This prevents +0 and -0 Z from producing
686 // inconsistent panning.
687 ev = aluAsin(Position[1]);
688 az = aluAtan2(Position[0], -Position[2]*ZScale);
689 }
690
691 // Check to see if the HRIR is already moving.
692 if(ALSource->HrtfMoving)
693 {
694 // Calculate the normalized HRTF transition factor (delta).
695 delta = CalcHrtfDelta(ALSource->Params.HrtfGain, DryGain,
696 ALSource->Params.HrtfDir, Position);
697 // If the delta is large enough, get the moving HRIR target
698 // coefficients, target delays, steppping values, and counter.
699 if(delta > 0.001f)
700 {
701 ALSource->HrtfCounter = GetMovingHrtfCoeffs(Device->Hrtf,
702 ev, az, DryGain, delta,
703 ALSource->HrtfCounter,
704 ALSource->Params.HrtfCoeffs[0],
705 ALSource->Params.HrtfDelay[0],
706 ALSource->Params.HrtfCoeffStep,
707 ALSource->Params.HrtfDelayStep);
708 ALSource->Params.HrtfGain = DryGain;
709 ALSource->Params.HrtfDir[0] = Position[0];
710 ALSource->Params.HrtfDir[1] = Position[1];
711 ALSource->Params.HrtfDir[2] = Position[2];
712 }
713 }
714 else
715 {
716 // Get the initial (static) HRIR coefficients and delays.
717 GetLerpedHrtfCoeffs(Device->Hrtf, ev, az, DryGain,
718 ALSource->Params.HrtfCoeffs[0],
719 ALSource->Params.HrtfDelay[0]);
720 ALSource->HrtfCounter = 0;
721 ALSource->Params.HrtfGain = DryGain;
722 ALSource->Params.HrtfDir[0] = Position[0];
723 ALSource->Params.HrtfDir[1] = Position[1];
724 ALSource->Params.HrtfDir[2] = Position[2];
725 }
726 }
727 else
728 {
729 // Use energy-preserving panning algorithm for multi-speaker playback
730 ALfloat DirGain, AmbientGain;
731 const ALfloat *ChannelGain;
732 ALfloat length;
733 ALint pos;
734
735 length = maxf(Distance, MinDist);
736 if(length > 0.0f)
737 {
738 ALfloat invlen = 1.0f/length;
739 Position[0] *= invlen;
740 Position[1] *= invlen;
741 Position[2] *= invlen;
742 }
743
744 pos = aluCart2LUTpos(-Position[2]*ZScale, Position[0]);
745 ChannelGain = Device->PanningLUT[pos];
746
747 DirGain = aluSqrt(Position[0]*Position[0] + Position[2]*Position[2]);
748 // elevation adjustment for directional gain. this sucks, but
749 // has low complexity
750 AmbientGain = aluSqrt(1.0f/Device->NumChan);
751 for(i = 0;i < MAXCHANNELS;i++)
752 {
753 ALuint i2;
754 for(i2 = 0;i2 < MAXCHANNELS;i2++)
755 ALSource->Params.DryGains[i][i2] = 0.0f;
756 }
757 for(i = 0;i < (ALint)Device->NumChan;i++)
758 {
759 enum Channel chan = Device->Speaker2Chan[i];
760 ALfloat gain = lerp(AmbientGain, ChannelGain[chan], DirGain);
761 ALSource->Params.DryGains[0][chan] = DryGain * gain;
762 }
763 }
764 for(i = 0;i < NumSends;i++)
765 ALSource->Params.Send[i].WetGain = WetGain[i];
766
767 /* Update filter coefficients. */
768 cw = aluCos(F_PI*2.0f * LOWPASSFREQREF / Frequency);
769
770 ALSource->Params.iirFilter.coeff = lpCoeffCalc(DryGainHF, cw);
771 for(i = 0;i < NumSends;i++)
772 {
773 ALfloat a = lpCoeffCalc(WetGainHF[i]*WetGainHF[i], cw);
774 ALSource->Params.Send[i].iirFilter.coeff = a;
775 }
776 }
777
778
779 static __inline ALfloat aluF2F(ALfloat val)
780 { return val; }
781 static __inline ALint aluF2I(ALfloat val)
782 {
783 if(val > 1.0f) return 2147483647;
784 if(val < -1.0f) return -2147483647-1;
785 return fastf2i((ALfloat)(val*2147483647.0));
786 }
787 static __inline ALuint aluF2UI(ALfloat val)
788 { return aluF2I(val)+2147483648u; }
789 static __inline ALshort aluF2S(ALfloat val)
790 { return aluF2I(val)>>16; }
791 static __inline ALushort aluF2US(ALfloat val)
792 { return aluF2S(val)+32768; }
793 static __inline ALbyte aluF2B(ALfloat val)
794 { return aluF2I(val)>>24; }
795 static __inline ALubyte aluF2UB(ALfloat val)
796 { return aluF2B(val)+128; }
797
798 #define DECL_TEMPLATE(T, N, func) \
799 static void Write_##T##_##N(ALCdevice *device, T *RESTRICT buffer, \
800 ALuint SamplesToDo) \
801 { \
802 ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS] = device->DryBuffer; \
803 const enum Channel *ChanMap = device->DevChannels; \
804 ALuint i, j; \
805 \
806 for(j = 0;j < N;j++) \
807 { \
808 T *RESTRICT out = buffer + j; \
809 enum Channel chan = ChanMap[j]; \
810 \
811 for(i = 0;i < SamplesToDo;i++) \
812 out[i*N] = func(DryBuffer[i][chan]); \
813 } \
814 }
815
816 DECL_TEMPLATE(ALfloat, 1, aluF2F)
817 DECL_TEMPLATE(ALfloat, 2, aluF2F)
818 DECL_TEMPLATE(ALfloat, 4, aluF2F)
819 DECL_TEMPLATE(ALfloat, 6, aluF2F)
820 DECL_TEMPLATE(ALfloat, 7, aluF2F)
821 DECL_TEMPLATE(ALfloat, 8, aluF2F)
822
823 DECL_TEMPLATE(ALuint, 1, aluF2UI)
824 DECL_TEMPLATE(ALuint, 2, aluF2UI)
825 DECL_TEMPLATE(ALuint, 4, aluF2UI)
826 DECL_TEMPLATE(ALuint, 6, aluF2UI)
827 DECL_TEMPLATE(ALuint, 7, aluF2UI)
828 DECL_TEMPLATE(ALuint, 8, aluF2UI)
829
830 DECL_TEMPLATE(ALint, 1, aluF2I)
831 DECL_TEMPLATE(ALint, 2, aluF2I)
832 DECL_TEMPLATE(ALint, 4, aluF2I)
833 DECL_TEMPLATE(ALint, 6, aluF2I)
834 DECL_TEMPLATE(ALint, 7, aluF2I)
835 DECL_TEMPLATE(ALint, 8, aluF2I)
836
837 DECL_TEMPLATE(ALushort, 1, aluF2US)
838 DECL_TEMPLATE(ALushort, 2, aluF2US)
839 DECL_TEMPLATE(ALushort, 4, aluF2US)
840 DECL_TEMPLATE(ALushort, 6, aluF2US)
841 DECL_TEMPLATE(ALushort, 7, aluF2US)
842 DECL_TEMPLATE(ALushort, 8, aluF2US)
843
844 DECL_TEMPLATE(ALshort, 1, aluF2S)
845 DECL_TEMPLATE(ALshort, 2, aluF2S)
846 DECL_TEMPLATE(ALshort, 4, aluF2S)
847 DECL_TEMPLATE(ALshort, 6, aluF2S)
848 DECL_TEMPLATE(ALshort, 7, aluF2S)
849 DECL_TEMPLATE(ALshort, 8, aluF2S)
850
851 DECL_TEMPLATE(ALubyte, 1, aluF2UB)
852 DECL_TEMPLATE(ALubyte, 2, aluF2UB)
853 DECL_TEMPLATE(ALubyte, 4, aluF2UB)
854 DECL_TEMPLATE(ALubyte, 6, aluF2UB)
855 DECL_TEMPLATE(ALubyte, 7, aluF2UB)
856 DECL_TEMPLATE(ALubyte, 8, aluF2UB)
857
858 DECL_TEMPLATE(ALbyte, 1, aluF2B)
859 DECL_TEMPLATE(ALbyte, 2, aluF2B)
860 DECL_TEMPLATE(ALbyte, 4, aluF2B)
861 DECL_TEMPLATE(ALbyte, 6, aluF2B)
862 DECL_TEMPLATE(ALbyte, 7, aluF2B)
863 DECL_TEMPLATE(ALbyte, 8, aluF2B)
864
865 #undef DECL_TEMPLATE
866
867 #define DECL_TEMPLATE(T) \
868 static void Write_##T(ALCdevice *device, T *buffer, ALuint SamplesToDo) \
869 { \
870 switch(device->FmtChans) \
871 { \
872 case DevFmtMono: \
873 Write_##T##_1(device, buffer, SamplesToDo); \
874 break; \
875 case DevFmtStereo: \
876 Write_##T##_2(device, buffer, SamplesToDo); \
877 break; \
878 case DevFmtQuad: \
879 Write_##T##_4(device, buffer, SamplesToDo); \
880 break; \
881 case DevFmtX51: \
882 case DevFmtX51Side: \
883 Write_##T##_6(device, buffer, SamplesToDo); \
884 break; \
885 case DevFmtX61: \
886 Write_##T##_7(device, buffer, SamplesToDo); \
887 break; \
888 case DevFmtX71: \
889 Write_##T##_8(device, buffer, SamplesToDo); \
890 break; \
891 } \
892 }
893
894 DECL_TEMPLATE(ALfloat)
895 DECL_TEMPLATE(ALuint)
896 DECL_TEMPLATE(ALint)
897 DECL_TEMPLATE(ALushort)
898 DECL_TEMPLATE(ALshort)
899 DECL_TEMPLATE(ALubyte)
900 DECL_TEMPLATE(ALbyte)
901
902 #undef DECL_TEMPLATE
903
904 ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
905 {
906 ALuint SamplesToDo;
907 ALeffectslot **slot, **slot_end;
908 ALsource **src, **src_end;
909 ALCcontext *ctx;
910 int fpuState;
911 ALuint i, c;
912
913 fpuState = SetMixerFPUMode();
914
915 while(size > 0)
916 {
917 /* Setup variables */
918 SamplesToDo = minu(size, BUFFERSIZE);
919
920 /* Clear mixing buffer */
921 memset(device->DryBuffer, 0, SamplesToDo*MAXCHANNELS*sizeof(ALfloat));
922
923 LockDevice(device);
924 ctx = device->ContextList;
925 while(ctx)
926 {
927 ALenum DeferUpdates = ctx->DeferUpdates;
928 ALenum UpdateSources = AL_FALSE;
929
930 if(!DeferUpdates)
931 UpdateSources = ExchangeInt(&ctx->UpdateSources, AL_FALSE);
932
933 src = ctx->ActiveSources;
934 src_end = src + ctx->ActiveSourceCount;
935 while(src != src_end)
936 {
937 if((*src)->state != AL_PLAYING)
938 {
939 --(ctx->ActiveSourceCount);
940 *src = *(--src_end);
941 continue;
942 }
943
944 if(!DeferUpdates && (ExchangeInt(&(*src)->NeedsUpdate, AL_FALSE) ||
945 UpdateSources))
946 ALsource_Update(*src, ctx);
947
948 MixSource(*src, device, SamplesToDo);
949 src++;
950 }
951
952 /* effect slot processing */
953 slot = ctx->ActiveEffectSlots;
954 slot_end = slot + ctx->ActiveEffectSlotCount;
955 while(slot != slot_end)
956 {
957 for(c = 0;c < SamplesToDo;c++)
958 {
959 (*slot)->WetBuffer[c] += (*slot)->ClickRemoval[0];
960 (*slot)->ClickRemoval[0] -= (*slot)->ClickRemoval[0] * (1.0f/256.0f);
961 }
962 (*slot)->ClickRemoval[0] += (*slot)->PendingClicks[0];
963 (*slot)->PendingClicks[0] = 0.0f;
964
965 if(!DeferUpdates && ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
966 ALeffectState_Update((*slot)->EffectState, ctx, *slot);
967
968 ALeffectState_Process((*slot)->EffectState, SamplesToDo,
969 (*slot)->WetBuffer, device->DryBuffer);
970
971 for(i = 0;i < SamplesToDo;i++)
972 (*slot)->WetBuffer[i] = 0.0f;
973
974 slot++;
975 }
976
977 ctx = ctx->next;
978 }
979
980 slot = &device->DefaultSlot;
981 if(*slot != NULL)
982 {
983 for(c = 0;c < SamplesToDo;c++)
984 {
985 (*slot)->WetBuffer[c] += (*slot)->ClickRemoval[0];
986 (*slot)->ClickRemoval[0] -= (*slot)->ClickRemoval[0] * (1.0f/256.0f);
987 }
988 (*slot)->ClickRemoval[0] += (*slot)->PendingClicks[0];
989 (*slot)->PendingClicks[0] = 0.0f;
990
991 if(ExchangeInt(&(*slot)->NeedsUpdate, AL_FALSE))
992 ALeffectState_Update((*slot)->EffectState, ctx, *slot);
993
994 ALeffectState_Process((*slot)->EffectState, SamplesToDo,
995 (*slot)->WetBuffer, device->DryBuffer);
996
997 for(i = 0;i < SamplesToDo;i++)
998 (*slot)->WetBuffer[i] = 0.0f;
999 }
1000 UnlockDevice(device);
1001
1002 //Post processing loop
1003 if(device->FmtChans == DevFmtMono)
1004 {
1005 for(i = 0;i < SamplesToDo;i++)
1006 {
1007 device->DryBuffer[i][FRONT_CENTER] += device->ClickRemoval[FRONT_CENTER];
1008 device->ClickRemoval[FRONT_CENTER] -= device->ClickRemoval[FRONT_CENTER] * (1.0f/256.0f);
1009 }
1010 device->ClickRemoval[FRONT_CENTER] += device->PendingClicks[FRONT_CENTER];
1011 device->PendingClicks[FRONT_CENTER] = 0.0f;
1012 }
1013 else if(device->FmtChans == DevFmtStereo)
1014 {
1015 /* Assumes the first two channels are FRONT_LEFT and FRONT_RIGHT */
1016 for(i = 0;i < SamplesToDo;i++)
1017 {
1018 for(c = 0;c < 2;c++)
1019 {
1020 device->DryBuffer[i][c] += device->ClickRemoval[c];
1021 device->ClickRemoval[c] -= device->ClickRemoval[c] * (1.0f/256.0f);
1022 }
1023 }
1024 for(c = 0;c < 2;c++)
1025 {
1026 device->ClickRemoval[c] += device->PendingClicks[c];
1027 device->PendingClicks[c] = 0.0f;
1028 }
1029 if(device->Bs2b)
1030 {
1031 for(i = 0;i < SamplesToDo;i++)
1032 bs2b_cross_feed(device->Bs2b, &device->DryBuffer[i][0]);
1033 }
1034 }
1035 else
1036 {
1037 for(i = 0;i < SamplesToDo;i++)
1038 {
1039 for(c = 0;c < MAXCHANNELS;c++)
1040 {
1041 device->DryBuffer[i][c] += device->ClickRemoval[c];
1042 device->ClickRemoval[c] -= device->ClickRemoval[c] * (1.0f/256.0f);
1043 }
1044 }
1045 for(c = 0;c < MAXCHANNELS;c++)
1046 {
1047 device->ClickRemoval[c] += device->PendingClicks[c];
1048 device->PendingClicks[c] = 0.0f;
1049 }
1050 }
1051
1052 if(buffer)
1053 {
1054 switch(device->FmtType)
1055 {
1056 case DevFmtByte:
1057 Write_ALbyte(device, buffer, SamplesToDo);
1058 break;
1059 case DevFmtUByte:
1060 Write_ALubyte(device, buffer, SamplesToDo);
1061 break;
1062 case DevFmtShort:
1063 Write_ALshort(device, buffer, SamplesToDo);
1064 break;
1065 case DevFmtUShort:
1066 Write_ALushort(device, buffer, SamplesToDo);
1067 break;
1068 case DevFmtInt:
1069 Write_ALint(device, buffer, SamplesToDo);
1070 break;
1071 case DevFmtUInt:
1072 Write_ALuint(device, buffer, SamplesToDo);
1073 break;
1074 case DevFmtFloat:
1075 Write_ALfloat(device, buffer, SamplesToDo);
1076 break;
1077 }
1078 }
1079
1080 size -= SamplesToDo;
1081 }
1082
1083 RestoreFPUMode(fpuState);
1084 }
1085
1086
1087 ALvoid aluHandleDisconnect(ALCdevice *device)
1088 {
1089 ALCcontext *Context;
1090
1091 LockDevice(device);
1092 device->Connected = ALC_FALSE;
1093
1094 Context = device->ContextList;
1095 while(Context)
1096 {
1097 ALsource **src, **src_end;
1098
1099 src = Context->ActiveSources;
1100 src_end = src + Context->ActiveSourceCount;
1101 while(src != src_end)
1102 {
1103 if((*src)->state == AL_PLAYING)
1104 {
1105 (*src)->state = AL_STOPPED;
1106 (*src)->BuffersPlayed = (*src)->BuffersInQueue;
1107 (*src)->position = 0;
1108 (*src)->position_fraction = 0;
1109 }
1110 src++;
1111 }
1112 Context->ActiveSourceCount = 0;
1113
1114 Context = Context->next;
1115 }
1116 UnlockDevice(device);
1117 }
fork of openal-soft for dark-hammer project