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