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