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