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