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