?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
The wet path should be silent if no effect is set on the slot
[openal-soft.git] / Alc / ALu.c
blobadf8fd5e8169435ddd77f74a2a721774b1a2e145
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
22
23 #include "config.h"
24
25 #include <math.h>
26 #include "alMain.h"
27 #include "AL/al.h"
28 #include "AL/alc.h"
29 #include "alSource.h"
30 #include "alBuffer.h"
31 #include "alThunk.h"
32 #include "alListener.h"
33 #include "alAuxEffectSlot.h"
34 #include "alu.h"
35 #include "bs2b.h"
36
37 #if defined(HAVE_STDINT_H)
38 #include <stdint.h>
39 typedef int64_t ALint64;
40 #elif defined(HAVE___INT64)
41 typedef __int64 ALint64;
42 #elif (SIZEOF_LONG == 8)
43 typedef long ALint64;
44 #elif (SIZEOF_LONG_LONG == 8)
45 typedef long long ALint64;
46 #endif
47
48 #ifdef HAVE_SQRTF
49 #define aluSqrt(x) ((ALfloat)sqrtf((float)(x)))
50 #else
51 #define aluSqrt(x) ((ALfloat)sqrt((double)(x)))
52 #endif
53
54 #ifdef HAVE_ACOSF
55 #define aluAcos(x) ((ALfloat)acosf((float)(x)))
56 #else
57 #define aluAcos(x) ((ALfloat)acos((double)(x)))
58 #endif
59
60 // fixes for mingw32.
61 #if defined(max) && !defined(__max)
62 #define __max max
63 #endif
64 #if defined(min) && !defined(__min)
65 #define __min min
66 #endif
67
68 #define BUFFERSIZE 24000
69 #define FRACTIONBITS 14
70 #define FRACTIONMASK ((1L<<FRACTIONBITS)-1)
71 #define MAX_PITCH 4
72
73 /* Minimum ramp length in milliseconds. The value below was chosen to
74 * adequately reduce clicks and pops from harsh gain changes. */
75 #define MIN_RAMP_LENGTH 16
76
77 ALboolean DuplicateStereo = AL_FALSE;
78
79 /* NOTE: The AL_FORMAT_REAR* enums aren't handled here be cause they're
80 * converted to AL_FORMAT_QUAD* when loaded */
81 __inline ALuint aluBytesFromFormat(ALenum format)
82 {
83 switch(format)
84 {
85 case AL_FORMAT_MONO8:
86 case AL_FORMAT_STEREO8:
87 case AL_FORMAT_QUAD8_LOKI:
88 case AL_FORMAT_QUAD8:
89 case AL_FORMAT_51CHN8:
90 case AL_FORMAT_61CHN8:
91 case AL_FORMAT_71CHN8:
92 return 1;
93
94 case AL_FORMAT_MONO16:
95 case AL_FORMAT_STEREO16:
96 case AL_FORMAT_QUAD16_LOKI:
97 case AL_FORMAT_QUAD16:
98 case AL_FORMAT_51CHN16:
99 case AL_FORMAT_61CHN16:
100 case AL_FORMAT_71CHN16:
101 return 2;
102
103 case AL_FORMAT_MONO_FLOAT32:
104 case AL_FORMAT_STEREO_FLOAT32:
105 case AL_FORMAT_QUAD32:
106 case AL_FORMAT_51CHN32:
107 case AL_FORMAT_61CHN32:
108 case AL_FORMAT_71CHN32:
109 return 4;
110
111 default:
112 return 0;
113 }
114 }
115
116 __inline ALuint aluChannelsFromFormat(ALenum format)
117 {
118 switch(format)
119 {
120 case AL_FORMAT_MONO8:
121 case AL_FORMAT_MONO16:
122 case AL_FORMAT_MONO_FLOAT32:
123 return 1;
124
125 case AL_FORMAT_STEREO8:
126 case AL_FORMAT_STEREO16:
127 case AL_FORMAT_STEREO_FLOAT32:
128 return 2;
129
130 case AL_FORMAT_QUAD8_LOKI:
131 case AL_FORMAT_QUAD16_LOKI:
132 case AL_FORMAT_QUAD8:
133 case AL_FORMAT_QUAD16:
134 case AL_FORMAT_QUAD32:
135 return 4;
136
137 case AL_FORMAT_51CHN8:
138 case AL_FORMAT_51CHN16:
139 case AL_FORMAT_51CHN32:
140 return 6;
141
142 case AL_FORMAT_61CHN8:
143 case AL_FORMAT_61CHN16:
144 case AL_FORMAT_61CHN32:
145 return 7;
146
147 case AL_FORMAT_71CHN8:
148 case AL_FORMAT_71CHN16:
149 case AL_FORMAT_71CHN32:
150 return 8;
151
152 default:
153 return 0;
154 }
155 }
156
157
158 static __inline ALfloat lpFilter(FILTER *iir, ALfloat input)
159 {
160 ALfloat *history = iir->history;
161 ALfloat a = iir->coeff;
162 ALfloat output = input;
163
164 output = output + (history[0]-output)*a;
165 history[0] = output;
166 output = output + (history[1]-output)*a;
167 history[1] = output;
168 output = output + (history[2]-output)*a;
169 history[2] = output;
170 output = output + (history[3]-output)*a;
171 history[3] = output;
172
173 return output;
174 }
175
176
177 static __inline ALshort aluF2S(ALfloat Value)
178 {
179 ALint i;
180
181 i = (ALint)Value;
182 i = __min( 32767, i);
183 i = __max(-32768, i);
184 return ((ALshort)i);
185 }
186
187 static __inline ALvoid aluCrossproduct(ALfloat *inVector1,ALfloat *inVector2,ALfloat *outVector)
188 {
189 outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
190 outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
191 outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
192 }
193
194 static __inline ALfloat aluDotproduct(ALfloat *inVector1,ALfloat *inVector2)
195 {
196 return inVector1[0]*inVector2[0] + inVector1[1]*inVector2[1] +
197 inVector1[2]*inVector2[2];
198 }
199
200 static __inline ALvoid aluNormalize(ALfloat *inVector)
201 {
202 ALfloat length, inverse_length;
203
204 length = aluSqrt(aluDotproduct(inVector, inVector));
205 if(length != 0.0f)
206 {
207 inverse_length = 1.0f/length;
208 inVector[0] *= inverse_length;
209 inVector[1] *= inverse_length;
210 inVector[2] *= inverse_length;
211 }
212 }
213
214 static __inline ALvoid aluMatrixVector(ALfloat *vector,ALfloat matrix[3][3])
215 {
216 ALfloat result[3];
217
218 result[0] = vector[0]*matrix[0][0] + vector[1]*matrix[1][0] + vector[2]*matrix[2][0];
219 result[1] = vector[0]*matrix[0][1] + vector[1]*matrix[1][1] + vector[2]*matrix[2][1];
220 result[2] = vector[0]*matrix[0][2] + vector[1]*matrix[1][2] + vector[2]*matrix[2][2];
221 memcpy(vector, result, sizeof(result));
222 }
223
224
225 static ALvoid CalcSourceParams(ALCcontext *ALContext, ALsource *ALSource,
226 ALenum isMono, ALenum OutputFormat,
227 ALfloat *drysend, ALfloat *wetsend,
228 ALfloat *pitch, ALfloat *drygainhf,
229 ALfloat *wetgainhf)
230 {
231 ALfloat InnerAngle,OuterAngle,Angle,Distance,DryMix,WetMix=0.0f;
232 ALfloat Direction[3],Position[3],SourceToListener[3];
233 ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff,OuterGainHF;
234 ALfloat ConeVolume,SourceVolume,PanningFB,PanningLR,ListenerGain;
235 ALfloat U[3],V[3],N[3];
236 ALfloat DopplerFactor, DopplerVelocity, flSpeedOfSound, flMaxVelocity;
237 ALfloat Matrix[3][3];
238 ALfloat flAttenuation;
239 ALfloat RoomAttenuation;
240 ALfloat MetersPerUnit;
241 ALfloat RoomRolloff;
242 ALfloat DryGainHF = 1.0f;
243 ALfloat WetGainHF = 1.0f;
244 ALfloat cw, a, g;
245
246 //Get context properties
247 DopplerFactor = ALContext->DopplerFactor * ALSource->DopplerFactor;
248 DopplerVelocity = ALContext->DopplerVelocity;
249 flSpeedOfSound = ALContext->flSpeedOfSound;
250
251 //Get listener properties
252 ListenerGain = ALContext->Listener.Gain;
253 MetersPerUnit = ALContext->Listener.MetersPerUnit;
254
255 //Get source properties
256 SourceVolume = ALSource->flGain;
257 memcpy(Position, ALSource->vPosition, sizeof(ALSource->vPosition));
258 memcpy(Direction, ALSource->vOrientation, sizeof(ALSource->vOrientation));
259 MinVolume = ALSource->flMinGain;
260 MaxVolume = ALSource->flMaxGain;
261 MinDist = ALSource->flRefDistance;
262 MaxDist = ALSource->flMaxDistance;
263 Rolloff = ALSource->flRollOffFactor;
264 InnerAngle = ALSource->flInnerAngle;
265 OuterAngle = ALSource->flOuterAngle;
266 OuterGainHF = ALSource->OuterGainHF;
267 RoomRolloff = ALSource->RoomRolloffFactor;
268
269 //Only apply 3D calculations for mono buffers
270 if(isMono != AL_FALSE)
271 {
272 //1. Translate Listener to origin (convert to head relative)
273 // Note that Direction and SourceToListener are *not* transformed.
274 // SourceToListener is used with the source and listener velocities,
275 // which are untransformed, and Direction is used with SourceToListener
276 // for the sound cone
277 if(ALSource->bHeadRelative==AL_FALSE)
278 {
279 // Build transform matrix
280 aluCrossproduct(ALContext->Listener.Forward, ALContext->Listener.Up, U); // Right-vector
281 aluNormalize(U); // Normalized Right-vector
282 memcpy(V, ALContext->Listener.Up, sizeof(V)); // Up-vector
283 aluNormalize(V); // Normalized Up-vector
284 memcpy(N, ALContext->Listener.Forward, sizeof(N)); // At-vector
285 aluNormalize(N); // Normalized At-vector
286 Matrix[0][0] = U[0]; Matrix[0][1] = V[0]; Matrix[0][2] = -N[0];
287 Matrix[1][0] = U[1]; Matrix[1][1] = V[1]; Matrix[1][2] = -N[1];
288 Matrix[2][0] = U[2]; Matrix[2][1] = V[2]; Matrix[2][2] = -N[2];
289
290 // Translate source position into listener space
291 Position[0] -= ALContext->Listener.Position[0];
292 Position[1] -= ALContext->Listener.Position[1];
293 Position[2] -= ALContext->Listener.Position[2];
294
295 SourceToListener[0] = -Position[0];
296 SourceToListener[1] = -Position[1];
297 SourceToListener[2] = -Position[2];
298
299 // Transform source position and direction into listener space
300 aluMatrixVector(Position, Matrix);
301 }
302 else
303 {
304 SourceToListener[0] = -Position[0];
305 SourceToListener[1] = -Position[1];
306 SourceToListener[2] = -Position[2];
307 }
308 aluNormalize(SourceToListener);
309 aluNormalize(Direction);
310
311 //2. Calculate distance attenuation
312 Distance = aluSqrt(aluDotproduct(Position, Position));
313
314 if(ALSource->Send[0].Slot)
315 {
316 if(ALSource->Send[0].Slot->effect.type == AL_EFFECT_REVERB)
317 RoomRolloff += ALSource->Send[0].Slot->effect.Reverb.RoomRolloffFactor;
318 }
319
320 flAttenuation = 1.0f;
321 RoomAttenuation = 1.0f;
322 switch (ALContext->DistanceModel)
323 {
324 case AL_INVERSE_DISTANCE_CLAMPED:
325 Distance=__max(Distance,MinDist);
326 Distance=__min(Distance,MaxDist);
327 if (MaxDist < MinDist)
328 break;
329 //fall-through
330 case AL_INVERSE_DISTANCE:
331 if (MinDist > 0.0f)
332 {
333 if ((MinDist + (Rolloff * (Distance - MinDist))) > 0.0f)
334 flAttenuation = MinDist / (MinDist + (Rolloff * (Distance - MinDist)));
335 if ((MinDist + (RoomRolloff * (Distance - MinDist))) > 0.0f)
336 RoomAttenuation = MinDist / (MinDist + (RoomRolloff * (Distance - MinDist)));
337 }
338 break;
339
340 case AL_LINEAR_DISTANCE_CLAMPED:
341 Distance=__max(Distance,MinDist);
342 Distance=__min(Distance,MaxDist);
343 if (MaxDist < MinDist)
344 break;
345 //fall-through
346 case AL_LINEAR_DISTANCE:
347 Distance=__min(Distance,MaxDist);
348 if (MaxDist != MinDist)
349 {
350 flAttenuation = 1.0f - (Rolloff*(Distance-MinDist)/(MaxDist - MinDist));
351 RoomAttenuation = 1.0f - (RoomRolloff*(Distance-MinDist)/(MaxDist - MinDist));
352 }
353 break;
354
355 case AL_EXPONENT_DISTANCE_CLAMPED:
356 Distance=__max(Distance,MinDist);
357 Distance=__min(Distance,MaxDist);
358 if (MaxDist < MinDist)
359 break;
360 //fall-through
361 case AL_EXPONENT_DISTANCE:
362 if ((Distance > 0.0f) && (MinDist > 0.0f))
363 {
364 flAttenuation = (ALfloat)pow(Distance/MinDist, -Rolloff);
365 RoomAttenuation = (ALfloat)pow(Distance/MinDist, -RoomRolloff);
366 }
367 break;
368
369 case AL_NONE:
370 flAttenuation = 1.0f;
371 RoomAttenuation = 1.0f;
372 break;
373 }
374
375 // Distance-based air absorption
376 if(ALSource->AirAbsorptionFactor > 0.0f && ALContext->DistanceModel != AL_NONE)
377 {
378 ALfloat dist = Distance-MinDist;
379 ALfloat absorb;
380
381 if(dist < 0.0f) dist = 0.0f;
382 // Absorption calculation is done in dB
383 absorb = (ALSource->AirAbsorptionFactor*AIRABSORBGAINDBHF) *
384 (Distance*MetersPerUnit);
385 // Convert dB to linear gain before applying
386 absorb = pow(0.5, absorb/-6.0);
387 DryGainHF *= absorb;
388 WetGainHF *= absorb;
389 }
390
391 // Source Gain + Attenuation and clamp to Min/Max Gain
392 DryMix = SourceVolume * flAttenuation;
393 DryMix = __min(DryMix,MaxVolume);
394 DryMix = __max(DryMix,MinVolume);
395
396 WetMix = SourceVolume * RoomAttenuation;
397 WetMix = __min(WetMix,MaxVolume);
398 WetMix = __max(WetMix,MinVolume);
399
400 //3. Apply directional soundcones
401 Angle = aluAcos(aluDotproduct(Direction,SourceToListener)) * 180.0f /
402 3.141592654f;
403 if(Angle >= InnerAngle && Angle <= OuterAngle)
404 {
405 ALfloat scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
406 ConeVolume = (1.0f+(ALSource->flOuterGain-1.0f)*scale);
407 DryMix *= ConeVolume;
408 if(ALSource->WetGainAuto)
409 WetMix *= ConeVolume;
410 if(ALSource->DryGainHFAuto)
411 DryGainHF *= (1.0f+(OuterGainHF-1.0f)*scale);
412 if(ALSource->WetGainHFAuto)
413 WetGainHF *= (1.0f+(OuterGainHF-1.0f)*scale);
414 }
415 else if(Angle > OuterAngle)
416 {
417 ConeVolume = (1.0f+(ALSource->flOuterGain-1.0f));
418 DryMix *= ConeVolume;
419 if(ALSource->WetGainAuto)
420 WetMix *= ConeVolume;
421 if(ALSource->DryGainHFAuto)
422 DryGainHF *= (1.0f+(OuterGainHF-1.0f));
423 if(ALSource->WetGainHFAuto)
424 WetGainHF *= (1.0f+(OuterGainHF-1.0f));
425 }
426
427 //4. Calculate Velocity
428 if(DopplerFactor != 0.0f)
429 {
430 ALfloat flVSS, flVLS = 0.0f;
431
432 if(ALSource->bHeadRelative==AL_FALSE)
433 flVLS = aluDotproduct(ALContext->Listener.Velocity, SourceToListener);
434 flVSS = aluDotproduct(ALSource->vVelocity, SourceToListener);
435
436 flMaxVelocity = (DopplerVelocity * flSpeedOfSound) / DopplerFactor;
437
438 if (flVSS >= flMaxVelocity)
439 flVSS = (flMaxVelocity - 1.0f);
440 else if (flVSS <= -flMaxVelocity)
441 flVSS = -flMaxVelocity + 1.0f;
442
443 if (flVLS >= flMaxVelocity)
444 flVLS = (flMaxVelocity - 1.0f);
445 else if (flVLS <= -flMaxVelocity)
446 flVLS = -flMaxVelocity + 1.0f;
447
448 pitch[0] = ALSource->flPitch *
449 ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVLS)) /
450 ((flSpeedOfSound * DopplerVelocity) - (DopplerFactor * flVSS));
451 }
452 else
453 pitch[0] = ALSource->flPitch;
454
455 if(ALSource->Send[0].Slot &&
456 ALSource->Send[0].Slot->effect.type != AL_EFFECT_NULL)
457 {
458 // If the slot's auxilliary send auto is off, the data sent to the
459 // effect slot is the same as the dry path, sans filter effects
460 if(!ALSource->Send[0].Slot->AuxSendAuto)
461 {
462 WetMix = DryMix;
463 WetGainHF = DryGainHF;
464 }
465
466 // Note that these are really applied by the effect slot. However,
467 // it's easier to handle them here (particularly the lowpass
468 // filter). Applying the gain to the individual sources going to
469 // the effect slot should have the same effect as applying the gain
470 // to the accumulated sources in the effect slot.
471 // vol1*g + vol2*g + ... voln*g = (vol1+vol2+...voln)*g
472 WetMix *= ALSource->Send[0].Slot->Gain;
473 if(ALSource->Send[0].Slot->effect.type == AL_EFFECT_REVERB)
474 {
475 WetMix *= ALSource->Send[0].Slot->effect.Reverb.Gain;
476 WetGainHF *= ALSource->Send[0].Slot->effect.Reverb.GainHF;
477 WetGainHF *= pow(ALSource->Send[0].Slot->effect.Reverb.AirAbsorptionGainHF,
478 Distance * MetersPerUnit);
479 }
480 }
481 else
482 {
483 WetMix = 0.0f;
484 WetGainHF = 1.0f;
485 }
486
487 //5. Apply filter gains and filters
488 switch(ALSource->DirectFilter.type)
489 {
490 case AL_FILTER_LOWPASS:
491 DryMix *= ALSource->DirectFilter.Gain;
492 DryGainHF *= ALSource->DirectFilter.GainHF;
493 break;
494 }
495
496 switch(ALSource->Send[0].WetFilter.type)
497 {
498 case AL_FILTER_LOWPASS:
499 WetMix *= ALSource->Send[0].WetFilter.Gain;
500 WetGainHF *= ALSource->Send[0].WetFilter.GainHF;
501 break;
502 }
503
504 DryMix *= ListenerGain;
505 WetMix *= ListenerGain;
506
507 //6. Convert normalized position into pannings, then into channel volumes
508 aluNormalize(Position);
509 switch(aluChannelsFromFormat(OutputFormat))
510 {
511 case 1:
512 case 2:
513 PanningLR = 0.5f + 0.5f*Position[0];
514 drysend[FRONT_LEFT] = DryMix * aluSqrt(1.0f-PanningLR); //L Direct
515 drysend[FRONT_RIGHT] = DryMix * aluSqrt( PanningLR); //R Direct
516 drysend[BACK_LEFT] = drysend[FRONT_LEFT];
517 drysend[BACK_RIGHT] = drysend[FRONT_RIGHT];
518 drysend[SIDE_LEFT] = drysend[FRONT_LEFT];
519 drysend[SIDE_RIGHT] = drysend[FRONT_RIGHT];
520 wetsend[FRONT_LEFT] = WetMix * aluSqrt(1.0f-PanningLR); //L Room
521 wetsend[FRONT_RIGHT] = WetMix * aluSqrt( PanningLR); //R Room
522 wetsend[BACK_LEFT] = wetsend[FRONT_LEFT];
523 wetsend[BACK_RIGHT] = wetsend[FRONT_RIGHT];
524 wetsend[SIDE_LEFT] = wetsend[FRONT_LEFT];
525 wetsend[SIDE_RIGHT] = wetsend[FRONT_RIGHT];
526 break;
527 case 4:
528 /* TODO: Add center/lfe channel in spatial calculations? */
529 case 6:
530 // Apply a scalar so each individual speaker has more weight
531 PanningLR = 0.5f + (0.5f*Position[0]*1.41421356f);
532 PanningLR = __min(1.0f, PanningLR);
533 PanningLR = __max(0.0f, PanningLR);
534 PanningFB = 0.5f + (0.5f*Position[2]*1.41421356f);
535 PanningFB = __min(1.0f, PanningFB);
536 PanningFB = __max(0.0f, PanningFB);
537 drysend[FRONT_LEFT] = DryMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
538 drysend[FRONT_RIGHT] = DryMix * aluSqrt(( PanningLR)*(1.0f-PanningFB));
539 drysend[BACK_LEFT] = DryMix * aluSqrt((1.0f-PanningLR)*( PanningFB));
540 drysend[BACK_RIGHT] = DryMix * aluSqrt(( PanningLR)*( PanningFB));
541 drysend[SIDE_LEFT] = (drysend[FRONT_LEFT] +drysend[BACK_LEFT]) * 0.5f;
542 drysend[SIDE_RIGHT] = (drysend[FRONT_RIGHT]+drysend[BACK_RIGHT]) * 0.5f;
543 wetsend[FRONT_LEFT] = WetMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
544 wetsend[FRONT_RIGHT] = WetMix * aluSqrt(( PanningLR)*(1.0f-PanningFB));
545 wetsend[BACK_LEFT] = WetMix * aluSqrt((1.0f-PanningLR)*( PanningFB));
546 wetsend[BACK_RIGHT] = WetMix * aluSqrt(( PanningLR)*( PanningFB));
547 wetsend[SIDE_LEFT] = (wetsend[FRONT_LEFT] +wetsend[BACK_LEFT]) * 0.5f;
548 wetsend[SIDE_RIGHT] = (wetsend[FRONT_RIGHT]+wetsend[BACK_RIGHT]) * 0.5f;
549 break;
550 case 7:
551 case 8:
552 PanningFB = 1.0f - fabs(Position[2]*1.15470054f);
553 PanningFB = __min(1.0f, PanningFB);
554 PanningFB = __max(0.0f, PanningFB);
555 PanningLR = 0.5f + (0.5*Position[0]*((1.0f-PanningFB)*2.0f));
556 PanningLR = __min(1.0f, PanningLR);
557 PanningLR = __max(0.0f, PanningLR);
558 if(Position[2] > 0.0f)
559 {
560 drysend[BACK_LEFT] = DryMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
561 drysend[BACK_RIGHT] = DryMix * aluSqrt(( PanningLR)*(1.0f-PanningFB));
562 drysend[SIDE_LEFT] = DryMix * aluSqrt((1.0f-PanningLR)*( PanningFB));
563 drysend[SIDE_RIGHT] = DryMix * aluSqrt(( PanningLR)*( PanningFB));
564 drysend[FRONT_LEFT] = 0.0f;
565 drysend[FRONT_RIGHT] = 0.0f;
566 wetsend[BACK_LEFT] = WetMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
567 wetsend[BACK_RIGHT] = WetMix * aluSqrt(( PanningLR)*(1.0f-PanningFB));
568 wetsend[SIDE_LEFT] = WetMix * aluSqrt((1.0f-PanningLR)*( PanningFB));
569 wetsend[SIDE_RIGHT] = WetMix * aluSqrt(( PanningLR)*( PanningFB));
570 wetsend[FRONT_LEFT] = 0.0f;
571 wetsend[FRONT_RIGHT] = 0.0f;
572 }
573 else
574 {
575 drysend[FRONT_LEFT] = DryMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
576 drysend[FRONT_RIGHT] = DryMix * aluSqrt(( PanningLR)*(1.0f-PanningFB));
577 drysend[SIDE_LEFT] = DryMix * aluSqrt((1.0f-PanningLR)*( PanningFB));
578 drysend[SIDE_RIGHT] = DryMix * aluSqrt(( PanningLR)*( PanningFB));
579 drysend[BACK_LEFT] = 0.0f;
580 drysend[BACK_RIGHT] = 0.0f;
581 wetsend[FRONT_LEFT] = WetMix * aluSqrt((1.0f-PanningLR)*(1.0f-PanningFB));
582 wetsend[FRONT_RIGHT] = WetMix * aluSqrt(( PanningLR)*(1.0f-PanningFB));
583 wetsend[SIDE_LEFT] = WetMix * aluSqrt((1.0f-PanningLR)*( PanningFB));
584 wetsend[SIDE_RIGHT] = WetMix * aluSqrt(( PanningLR)*( PanningFB));
585 wetsend[BACK_LEFT] = 0.0f;
586 wetsend[BACK_RIGHT] = 0.0f;
587 }
588 default:
589 break;
590 }
591
592 // Update filter coefficients. Calculations based on the I3DL2 spec.
593 cw = cos(2.0f*3.141592654f * LOWPASSFREQCUTOFF / ALContext->Frequency);
594 // We use four chained one-pole filters, so we need to take the fourth
595 // root of the squared gain, which is the same as the square root of
596 // the base gain.
597 // Be careful with gains < 0.0001, as that causes the coefficient to
598 // head towards 1, which will flatten the signal
599 g = aluSqrt(__max(DryGainHF, 0.0001f));
600 a = 0.0f;
601 if(g < 0.9999f) // 1-epsilon
602 a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) / (1 - g);
603 ALSource->iirFilter.coeff = a;
604
605 g = aluSqrt(__max(WetGainHF, 0.0001f));
606 a = 0.0f;
607 if(g < 0.9999f) // 1-epsilon
608 a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) / (1 - g);
609 ALSource->Send[0].iirFilter.coeff = a;
610
611 *drygainhf = DryGainHF;
612 *wetgainhf = WetGainHF;
613 }
614 else
615 {
616 //1. Multi-channel buffers always play "normal"
617 pitch[0] = ALSource->flPitch;
618
619 drysend[FRONT_LEFT] = SourceVolume * ListenerGain;
620 drysend[FRONT_RIGHT] = SourceVolume * ListenerGain;
621 drysend[SIDE_LEFT] = SourceVolume * ListenerGain;
622 drysend[SIDE_RIGHT] = SourceVolume * ListenerGain;
623 drysend[BACK_LEFT] = SourceVolume * ListenerGain;
624 drysend[BACK_RIGHT] = SourceVolume * ListenerGain;
625 drysend[CENTER] = SourceVolume * ListenerGain;
626 drysend[LFE] = SourceVolume * ListenerGain;
627 wetsend[FRONT_LEFT] = 0.0f;
628 wetsend[FRONT_RIGHT] = 0.0f;
629 wetsend[SIDE_LEFT] = 0.0f;
630 wetsend[SIDE_RIGHT] = 0.0f;
631 wetsend[BACK_LEFT] = 0.0f;
632 wetsend[BACK_RIGHT] = 0.0f;
633 wetsend[CENTER] = 0.0f;
634 wetsend[LFE] = 0.0f;
635 WetGainHF = 1.0f;
636
637 *drygainhf = DryGainHF;
638 *wetgainhf = WetGainHF;
639 }
640 }
641
642 static __inline ALshort lerp(ALshort val1, ALshort val2, ALint frac)
643 {
644 return (val1*((1<<FRACTIONBITS)-frac) + val2*frac) >> FRACTIONBITS;
645 }
646
647 ALvoid aluMixData(ALCcontext *ALContext,ALvoid *buffer,ALsizei size,ALenum format)
648 {
649 static float DryBuffer[BUFFERSIZE][OUTPUTCHANNELS];
650 static float WetBuffer[BUFFERSIZE][OUTPUTCHANNELS];
651 ALfloat newDrySend[OUTPUTCHANNELS] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
652 ALfloat newWetSend[OUTPUTCHANNELS] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
653 ALfloat DryGainHF = 0.0f;
654 ALfloat WetGainHF = 0.0f;
655 ALfloat *DrySend;
656 ALfloat *WetSend;
657 ALuint rampLength;
658 ALfloat dryGainStep[OUTPUTCHANNELS];
659 ALfloat wetGainStep[OUTPUTCHANNELS];
660 ALuint BlockAlign,BufferSize;
661 ALuint DataSize=0,DataPosInt=0,DataPosFrac=0;
662 ALuint Channels,Frequency,ulExtraSamples;
663 ALfloat Pitch;
664 ALint Looping,State;
665 ALint increment;
666 ALuint Buffer;
667 ALuint SamplesToDo;
668 ALsource *ALSource;
669 ALbuffer *ALBuffer;
670 ALeffectslot *ALEffectSlot;
671 ALfloat value;
672 ALshort *Data;
673 ALuint i,j,k;
674 ALbufferlistitem *BufferListItem;
675 ALuint loop;
676 ALint64 DataSize64,DataPos64;
677 FILTER *DryFilter, *WetFilter;
678 int fpuState;
679
680 SuspendContext(ALContext);
681
682 #if defined(HAVE_FESETROUND)
683 fpuState = fegetround();
684 fesetround(FE_TOWARDZERO);
685 #elif defined(HAVE__CONTROLFP)
686 fpuState = _controlfp(0, 0);
687 _controlfp(_RC_CHOP, _MCW_RC);
688 #else
689 (void)fpuState;
690 #endif
691
692 //Figure output format variables
693 BlockAlign = aluChannelsFromFormat(format);
694 BlockAlign *= aluBytesFromFormat(format);
695
696 size /= BlockAlign;
697 while(size > 0)
698 {
699 //Setup variables
700 SamplesToDo = min(size, BUFFERSIZE);
701 if(ALContext)
702 {
703 ALEffectSlot = ALContext->AuxiliaryEffectSlot;
704 ALSource = ALContext->Source;
705 rampLength = ALContext->Frequency * MIN_RAMP_LENGTH / 1000;
706 }
707 else
708 {
709 ALEffectSlot = NULL;
710 ALSource = NULL;
711 rampLength = 0;
712 }
713 rampLength = max(rampLength, SamplesToDo);
714
715 //Clear mixing buffer
716 memset(DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
717 memset(WetBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
718
719 //Actual mixing loop
720 while(ALSource)
721 {
722 j = 0;
723 State = ALSource->state;
724
725 while(State == AL_PLAYING && j < SamplesToDo)
726 {
727 DataSize = 0;
728 DataPosInt = 0;
729 DataPosFrac = 0;
730
731 //Get buffer info
732 if((Buffer = ALSource->ulBufferID))
733 {
734 ALBuffer = (ALbuffer*)ALTHUNK_LOOKUPENTRY(Buffer);
735
736 Data = ALBuffer->data;
737 Channels = aluChannelsFromFormat(ALBuffer->format);
738 DataSize = ALBuffer->size;
739 Frequency = ALBuffer->frequency;
740
741 CalcSourceParams(ALContext, ALSource,
742 (Channels==1) ? AL_TRUE : AL_FALSE,
743 format, newDrySend, newWetSend, &Pitch,
744 &DryGainHF, &WetGainHF);
745
746 Pitch = (Pitch*Frequency) / ALContext->Frequency;
747 DataSize /= Channels * aluBytesFromFormat(ALBuffer->format);
748
749 //Get source info
750 DataPosInt = ALSource->position;
751 DataPosFrac = ALSource->position_fraction;
752 DryFilter = &ALSource->iirFilter;
753 WetFilter = &ALSource->Send[0].iirFilter;
754 DrySend = ALSource->DryGains;
755 WetSend = ALSource->WetGains;
756
757 //Compute the gain steps for each output channel
758 for(i = 0;i < OUTPUTCHANNELS;i++)
759 {
760 dryGainStep[i] = (newDrySend[i]-DrySend[i]) / rampLength;
761 wetGainStep[i] = (newWetSend[i]-WetSend[i]) / rampLength;
762 }
763
764 //Compute 18.14 fixed point step
765 increment = (ALint)(Pitch*(ALfloat)(1L<<FRACTIONBITS));
766 if(increment > (MAX_PITCH<<FRACTIONBITS))
767 increment = (MAX_PITCH<<FRACTIONBITS);
768 else if(increment <= 0)
769 increment = (1<<FRACTIONBITS);
770
771 //Figure out how many samples we can mix.
772 DataSize64 = DataSize;
773 DataSize64 <<= FRACTIONBITS;
774 DataPos64 = DataPosInt;
775 DataPos64 <<= FRACTIONBITS;
776 DataPos64 += DataPosFrac;
777 BufferSize = (ALuint)((DataSize64-DataPos64+(increment-1)) / increment);
778
779 BufferListItem = ALSource->queue;
780 for(loop = 0; loop < ALSource->BuffersPlayed; loop++)
781 {
782 if(BufferListItem)
783 BufferListItem = BufferListItem->next;
784 }
785 if (BufferListItem)
786 {
787 if (BufferListItem->next)
788 {
789 ALbuffer *NextBuf = (ALbuffer*)ALTHUNK_LOOKUPENTRY(BufferListItem->next->buffer);
790 if(NextBuf && NextBuf->data)
791 {
792 ulExtraSamples = min(NextBuf->size, (ALint)(ALBuffer->padding*Channels*2));
793 memcpy(&Data[DataSize*Channels], NextBuf->data, ulExtraSamples);
794 }
795 }
796 else if (ALSource->bLooping)
797 {
798 ALbuffer *NextBuf = (ALbuffer*)ALTHUNK_LOOKUPENTRY(ALSource->queue->buffer);
799 if (NextBuf && NextBuf->data)
800 {
801 ulExtraSamples = min(NextBuf->size, (ALint)(ALBuffer->padding*Channels*2));
802 memcpy(&Data[DataSize*Channels], NextBuf->data, ulExtraSamples);
803 }
804 }
805 else
806 memset(&Data[DataSize*Channels], 0, (ALBuffer->padding*Channels*2));
807 }
808 BufferSize = min(BufferSize, (SamplesToDo-j));
809
810 //Actual sample mixing loop
811 k = 0;
812 Data += DataPosInt*Channels;
813 while(BufferSize--)
814 {
815 for(i = 0;i < OUTPUTCHANNELS;i++)
816 {
817 DrySend[i] += dryGainStep[i];
818 WetSend[i] += wetGainStep[i];
819 }
820
821 if(Channels==1)
822 {
823 ALfloat sample, outsamp;
824 //First order interpolator
825 sample = lerp(Data[k], Data[k+1], DataPosFrac);
826
827 //Direct path final mix buffer and panning
828 outsamp = lpFilter(DryFilter, sample);
829 DryBuffer[j][FRONT_LEFT] += outsamp*DrySend[FRONT_LEFT];
830 DryBuffer[j][FRONT_RIGHT] += outsamp*DrySend[FRONT_RIGHT];
831 DryBuffer[j][SIDE_LEFT] += outsamp*DrySend[SIDE_LEFT];
832 DryBuffer[j][SIDE_RIGHT] += outsamp*DrySend[SIDE_RIGHT];
833 DryBuffer[j][BACK_LEFT] += outsamp*DrySend[BACK_LEFT];
834 DryBuffer[j][BACK_RIGHT] += outsamp*DrySend[BACK_RIGHT];
835 //Room path final mix buffer and panning
836 outsamp = lpFilter(WetFilter, sample);
837 WetBuffer[j][FRONT_LEFT] += outsamp*WetSend[FRONT_LEFT];
838 WetBuffer[j][FRONT_RIGHT] += outsamp*WetSend[FRONT_RIGHT];
839 WetBuffer[j][SIDE_LEFT] += outsamp*WetSend[SIDE_LEFT];
840 WetBuffer[j][SIDE_RIGHT] += outsamp*WetSend[SIDE_RIGHT];
841 WetBuffer[j][BACK_LEFT] += outsamp*WetSend[BACK_LEFT];
842 WetBuffer[j][BACK_RIGHT] += outsamp*WetSend[BACK_RIGHT];
843 }
844 else
845 {
846 ALfloat samp1, samp2;
847 //First order interpolator (front left)
848 samp1 = lerp(Data[k*Channels], Data[(k+1)*Channels], DataPosFrac);
849 DryBuffer[j][FRONT_LEFT] += samp1*DrySend[FRONT_LEFT];
850 WetBuffer[j][FRONT_LEFT] += samp1*WetSend[FRONT_LEFT];
851 //First order interpolator (front right)
852 samp2 = lerp(Data[k*Channels+1], Data[(k+1)*Channels+1], DataPosFrac);
853 DryBuffer[j][FRONT_RIGHT] += samp2*DrySend[FRONT_RIGHT];
854 WetBuffer[j][FRONT_RIGHT] += samp2*WetSend[FRONT_RIGHT];
855 if(Channels >= 4)
856 {
857 int i = 2;
858 if(Channels >= 6)
859 {
860 if(Channels != 7)
861 {
862 //First order interpolator (center)
863 value = lerp(Data[k*Channels+i], Data[(k+1)*Channels+i], DataPosFrac);
864 DryBuffer[j][CENTER] += value*DrySend[CENTER];
865 WetBuffer[j][CENTER] += value*WetSend[CENTER];
866 i++;
867 }
868 //First order interpolator (lfe)
869 value = lerp(Data[k*Channels+i], Data[(k+1)*Channels+i], DataPosFrac);
870 DryBuffer[j][LFE] += value*DrySend[LFE];
871 WetBuffer[j][LFE] += value*WetSend[LFE];
872 i++;
873 }
874 //First order interpolator (back left)
875 value = lerp(Data[k*Channels+i], Data[(k+1)*Channels+i], DataPosFrac);
876 DryBuffer[j][BACK_LEFT] += value*DrySend[BACK_LEFT];
877 WetBuffer[j][BACK_LEFT] += value*WetSend[BACK_LEFT];
878 i++;
879 //First order interpolator (back right)
880 value = lerp(Data[k*Channels+i], Data[(k+1)*Channels+i], DataPosFrac);
881 DryBuffer[j][BACK_RIGHT] += value*DrySend[BACK_RIGHT];
882 WetBuffer[j][BACK_RIGHT] += value*WetSend[BACK_RIGHT];
883 i++;
884 if(Channels >= 7)
885 {
886 //First order interpolator (side left)
887 value = lerp(Data[k*Channels+i], Data[(k+1)*Channels+i], DataPosFrac);
888 DryBuffer[j][SIDE_LEFT] += value*DrySend[SIDE_LEFT];
889 WetBuffer[j][SIDE_LEFT] += value*WetSend[SIDE_LEFT];
890 i++;
891 //First order interpolator (side right)
892 value = lerp(Data[k*Channels+i], Data[(k+1)*Channels+i], DataPosFrac);
893 DryBuffer[j][SIDE_RIGHT] += value*DrySend[SIDE_RIGHT];
894 WetBuffer[j][SIDE_RIGHT] += value*WetSend[SIDE_RIGHT];
895 i++;
896 }
897 }
898 else if(DuplicateStereo)
899 {
900 //Duplicate stereo channels on the back speakers
901 DryBuffer[j][BACK_LEFT] += samp1*DrySend[BACK_LEFT];
902 WetBuffer[j][BACK_LEFT] += samp1*WetSend[BACK_LEFT];
903 DryBuffer[j][BACK_RIGHT] += samp2*DrySend[BACK_RIGHT];
904 WetBuffer[j][BACK_RIGHT] += samp2*WetSend[BACK_RIGHT];
905 }
906 }
907 DataPosFrac += increment;
908 k += DataPosFrac>>FRACTIONBITS;
909 DataPosFrac &= FRACTIONMASK;
910 j++;
911 }
912 DataPosInt += k;
913
914 //Update source info
915 ALSource->position = DataPosInt;
916 ALSource->position_fraction = DataPosFrac;
917 }
918
919 //Handle looping sources
920 if(!Buffer || DataPosInt >= DataSize)
921 {
922 //queueing
923 if(ALSource->queue)
924 {
925 Looping = ALSource->bLooping;
926 if(ALSource->BuffersPlayed < (ALSource->BuffersInQueue-1))
927 {
928 BufferListItem = ALSource->queue;
929 for(loop = 0; loop <= ALSource->BuffersPlayed; loop++)
930 {
931 if(BufferListItem)
932 {
933 if(!Looping)
934 BufferListItem->bufferstate = PROCESSED;
935 BufferListItem = BufferListItem->next;
936 }
937 }
938 if(BufferListItem)
939 ALSource->ulBufferID = BufferListItem->buffer;
940 ALSource->position = DataPosInt-DataSize;
941 ALSource->position_fraction = DataPosFrac;
942 ALSource->BuffersPlayed++;
943 }
944 else
945 {
946 if(!Looping)
947 {
948 /* alSourceStop */
949 ALSource->state = AL_STOPPED;
950 ALSource->inuse = AL_FALSE;
951 ALSource->BuffersPlayed = ALSource->BuffersInQueue;
952 BufferListItem = ALSource->queue;
953 while(BufferListItem != NULL)
954 {
955 BufferListItem->bufferstate = PROCESSED;
956 BufferListItem = BufferListItem->next;
957 }
958 }
959 else
960 {
961 /* alSourceRewind */
962 /* alSourcePlay */
963 ALSource->state = AL_PLAYING;
964 ALSource->inuse = AL_TRUE;
965 ALSource->play = AL_TRUE;
966 ALSource->BuffersPlayed = 0;
967 ALSource->BufferPosition = 0;
968 ALSource->lBytesPlayed = 0;
969 BufferListItem = ALSource->queue;
970 while(BufferListItem != NULL)
971 {
972 BufferListItem->bufferstate = PENDING;
973 BufferListItem = BufferListItem->next;
974 }
975 ALSource->ulBufferID = ALSource->queue->buffer;
976
977 ALSource->position = DataPosInt-DataSize;
978 ALSource->position_fraction = DataPosFrac;
979 }
980 }
981 }
982 }
983
984 //Get source state
985 State = ALSource->state;
986 }
987
988 ALSource = ALSource->next;
989 }
990
991 // effect slot processing
992 while(ALEffectSlot)
993 {
994 if(ALEffectSlot->effect.type == AL_EFFECT_REVERB)
995 {
996 ALfloat *DelayBuffer = ALEffectSlot->ReverbBuffer;
997 ALuint Pos = ALEffectSlot->ReverbPos;
998 ALuint LatePos = ALEffectSlot->ReverbLatePos;
999 ALuint ReflectPos = ALEffectSlot->ReverbReflectPos;
1000 ALuint Length = ALEffectSlot->ReverbLength;
1001 ALfloat DecayGain = ALEffectSlot->ReverbDecayGain;
1002 ALfloat DecayHFRatio = ALEffectSlot->effect.Reverb.DecayHFRatio;
1003 ALfloat ReflectGain = ALEffectSlot->effect.Reverb.ReflectionsGain;
1004 ALfloat LateReverbGain = ALEffectSlot->effect.Reverb.LateReverbGain;
1005 ALfloat sample, lowsample;
1006
1007 WetFilter = &ALEffectSlot->iirFilter;
1008 for(i = 0;i < SamplesToDo;i++)
1009 {
1010 sample = WetBuffer[i][FRONT_LEFT] +WetBuffer[i][SIDE_LEFT] +WetBuffer[i][BACK_LEFT];
1011 sample += WetBuffer[i][FRONT_RIGHT]+WetBuffer[i][SIDE_RIGHT]+WetBuffer[i][BACK_RIGHT];
1012 DelayBuffer[Pos] = sample / 6.0f;
1013
1014 sample = DelayBuffer[ReflectPos] * ReflectGain;
1015
1016 DelayBuffer[LatePos] *= LateReverbGain;
1017
1018 Pos = (Pos+1) % Length;
1019 lowsample = lpFilter(WetFilter, DelayBuffer[Pos]);
1020 lowsample += (DelayBuffer[Pos]-lowsample) * DecayHFRatio;
1021
1022 DelayBuffer[LatePos] += lowsample * DecayGain;
1023
1024 sample += DelayBuffer[LatePos];
1025
1026 WetBuffer[i][FRONT_LEFT] = sample;
1027 WetBuffer[i][FRONT_RIGHT] = sample;
1028 WetBuffer[i][SIDE_LEFT] = sample;
1029 WetBuffer[i][SIDE_RIGHT] = sample;
1030 WetBuffer[i][BACK_LEFT] = sample;
1031 WetBuffer[i][BACK_RIGHT] = sample;
1032
1033 LatePos = (LatePos+1) % Length;
1034 ReflectPos = (ReflectPos+1) % Length;
1035 }
1036
1037 ALEffectSlot->ReverbPos = Pos;
1038 ALEffectSlot->ReverbLatePos = LatePos;
1039 ALEffectSlot->ReverbReflectPos = ReflectPos;
1040 }
1041
1042 ALEffectSlot = ALEffectSlot->next;
1043 }
1044
1045 //Post processing loop
1046 switch(format)
1047 {
1048 case AL_FORMAT_MONO8:
1049 for(i = 0;i < SamplesToDo;i++)
1050 {
1051 ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT]+DryBuffer[i][FRONT_RIGHT]+
1052 WetBuffer[i][FRONT_LEFT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1053 buffer = ((ALubyte*)buffer) + 1;
1054 }
1055 break;
1056 case AL_FORMAT_STEREO8:
1057 if(ALContext && ALContext->bs2b)
1058 {
1059 for(i = 0;i < SamplesToDo;i++)
1060 {
1061 float samples[2];
1062 samples[0] = DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT];
1063 samples[1] = DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT];
1064 bs2b_cross_feed(ALContext->bs2b, samples);
1065 ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(samples[0])>>8)+128);
1066 ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(samples[1])>>8)+128);
1067 buffer = ((ALubyte*)buffer) + 2;
1068 }
1069 }
1070 else
1071 {
1072 for(i = 0;i < SamplesToDo;i++)
1073 {
1074 ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1075 ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1076 buffer = ((ALubyte*)buffer) + 2;
1077 }
1078 }
1079 break;
1080 case AL_FORMAT_QUAD8:
1081 for(i = 0;i < SamplesToDo;i++)
1082 {
1083 ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1084 ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1085 ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT])>>8)+128);
1086 ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1087 buffer = ((ALubyte*)buffer) + 4;
1088 }
1089 break;
1090 case AL_FORMAT_51CHN8:
1091 for(i = 0;i < SamplesToDo;i++)
1092 {
1093 ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1094 ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1095 #ifdef _WIN32 /* Of course, Windows can't use the same ordering... */
1096 ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER])>>8)+128);
1097 ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE])>>8)+128);
1098 ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT])>>8)+128);
1099 ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1100 #else
1101 ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT])>>8)+128);
1102 ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1103 ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER])>>8)+128);
1104 ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE])>>8)+128);
1105 #endif
1106 buffer = ((ALubyte*)buffer) + 6;
1107 }
1108 break;
1109 case AL_FORMAT_61CHN8:
1110 for(i = 0;i < SamplesToDo;i++)
1111 {
1112 ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1113 ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1114 #ifdef _WIN32
1115 ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE])>>8)+128);
1116 ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT])>>8)+128);
1117 ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1118 #else
1119 ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT])>>8)+128);
1120 ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1121 ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE])>>8)+128);
1122 #endif
1123 ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_LEFT] +WetBuffer[i][SIDE_LEFT])>>8)+128);
1124 ((ALubyte*)buffer)[6] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT])>>8)+128);
1125 buffer = ((ALubyte*)buffer) + 7;
1126 }
1127 break;
1128 case AL_FORMAT_71CHN8:
1129 for(i = 0;i < SamplesToDo;i++)
1130 {
1131 ((ALubyte*)buffer)[0] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT])>>8)+128);
1132 ((ALubyte*)buffer)[1] = (ALubyte)((aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT])>>8)+128);
1133 #ifdef _WIN32
1134 ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER])>>8)+128);
1135 ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE])>>8)+128);
1136 ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT])>>8)+128);
1137 ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1138 #else
1139 ((ALubyte*)buffer)[2] = (ALubyte)((aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT])>>8)+128);
1140 ((ALubyte*)buffer)[3] = (ALubyte)((aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT])>>8)+128);
1141 ((ALubyte*)buffer)[4] = (ALubyte)((aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER])>>8)+128);
1142 ((ALubyte*)buffer)[5] = (ALubyte)((aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE])>>8)+128);
1143 #endif
1144 ((ALubyte*)buffer)[6] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_LEFT] +WetBuffer[i][SIDE_LEFT])>>8)+128);
1145 ((ALubyte*)buffer)[7] = (ALubyte)((aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT])>>8)+128);
1146 buffer = ((ALubyte*)buffer) + 8;
1147 }
1148 break;
1149
1150 case AL_FORMAT_MONO16:
1151 for(i = 0;i < SamplesToDo;i++)
1152 {
1153 ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT]+DryBuffer[i][FRONT_RIGHT]+
1154 WetBuffer[i][FRONT_LEFT]+WetBuffer[i][FRONT_RIGHT]);
1155 buffer = ((ALshort*)buffer) + 1;
1156 }
1157 break;
1158 case AL_FORMAT_STEREO16:
1159 if(ALContext && ALContext->bs2b)
1160 {
1161 for(i = 0;i < SamplesToDo;i++)
1162 {
1163 float samples[2];
1164 samples[0] = DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT];
1165 samples[1] = DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT];
1166 bs2b_cross_feed(ALContext->bs2b, samples);
1167 ((ALshort*)buffer)[0] = aluF2S(samples[0]);
1168 ((ALshort*)buffer)[1] = aluF2S(samples[1]);
1169 buffer = ((ALshort*)buffer) + 2;
1170 }
1171 }
1172 else
1173 {
1174 for(i = 0;i < SamplesToDo;i++)
1175 {
1176 ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1177 ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1178 buffer = ((ALshort*)buffer) + 2;
1179 }
1180 }
1181 break;
1182 case AL_FORMAT_QUAD16:
1183 for(i = 0;i < SamplesToDo;i++)
1184 {
1185 ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1186 ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1187 ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT]);
1188 ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1189 buffer = ((ALshort*)buffer) + 4;
1190 }
1191 break;
1192 case AL_FORMAT_51CHN16:
1193 for(i = 0;i < SamplesToDo;i++)
1194 {
1195 ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1196 ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1197 #ifdef _WIN32
1198 ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER]);
1199 ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE]);
1200 ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT]);
1201 ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1202 #else
1203 ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT]);
1204 ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1205 ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER]);
1206 ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE]);
1207 #endif
1208 buffer = ((ALshort*)buffer) + 6;
1209 }
1210 break;
1211 case AL_FORMAT_61CHN16:
1212 for(i = 0;i < SamplesToDo;i++)
1213 {
1214 ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1215 ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1216 #ifdef _WIN32
1217 ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE]);
1218 ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT]);
1219 ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1220 #else
1221 ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT]);
1222 ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1223 ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE]);
1224 #endif
1225 ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][SIDE_LEFT] +WetBuffer[i][SIDE_LEFT]);
1226 ((ALshort*)buffer)[6] = aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT]);
1227 buffer = ((ALshort*)buffer) + 7;
1228 }
1229 break;
1230 case AL_FORMAT_71CHN16:
1231 for(i = 0;i < SamplesToDo;i++)
1232 {
1233 ((ALshort*)buffer)[0] = aluF2S(DryBuffer[i][FRONT_LEFT] +WetBuffer[i][FRONT_LEFT]);
1234 ((ALshort*)buffer)[1] = aluF2S(DryBuffer[i][FRONT_RIGHT]+WetBuffer[i][FRONT_RIGHT]);
1235 #ifdef _WIN32
1236 ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER]);
1237 ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE]);
1238 ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT]);
1239 ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1240 #else
1241 ((ALshort*)buffer)[2] = aluF2S(DryBuffer[i][BACK_LEFT] +WetBuffer[i][BACK_LEFT]);
1242 ((ALshort*)buffer)[3] = aluF2S(DryBuffer[i][BACK_RIGHT] +WetBuffer[i][BACK_RIGHT]);
1243 ((ALshort*)buffer)[4] = aluF2S(DryBuffer[i][CENTER] +WetBuffer[i][CENTER]);
1244 ((ALshort*)buffer)[5] = aluF2S(DryBuffer[i][LFE] +WetBuffer[i][LFE]);
1245 #endif
1246 ((ALshort*)buffer)[6] = aluF2S(DryBuffer[i][SIDE_LEFT] +WetBuffer[i][SIDE_LEFT]);
1247 ((ALshort*)buffer)[7] = aluF2S(DryBuffer[i][SIDE_RIGHT] +WetBuffer[i][SIDE_RIGHT]);
1248 buffer = ((ALshort*)buffer) + 8;
1249 }
1250 break;
1251
1252 default:
1253 break;
1254 }
1255
1256 size -= SamplesToDo;
1257 }
1258
1259 #if defined(HAVE_FESETROUND)
1260 fesetround(fpuState);
1261 #elif defined(HAVE__CONTROLFP)
1262 _controlfp(fpuState, 0xfffff);
1263 #endif
1264
1265 ProcessContext(ALContext);
1266 }
Software OpenAL implementation