?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Better protect against negative attenuation
[openal-soft.git] / Alc / mixer.c
blobecb60aadd152f850c745cf483abad61927d63f98
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 #include "config.h"
22
23 #include <math.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <assert.h>
28
29 #include "alMain.h"
30 #include "AL/al.h"
31 #include "AL/alc.h"
32 #include "alSource.h"
33 #include "alBuffer.h"
34 #include "alListener.h"
35 #include "alAuxEffectSlot.h"
36 #include "alu.h"
37 #include "bs2b.h"
38
39
40 static __inline ALfloat aluF2F(ALfloat Value)
41 {
42 return Value;
43 }
44
45 static __inline ALshort aluF2S(ALfloat Value)
46 {
47 ALint i;
48
49 if(Value <= -1.0f) i = -32768;
50 else if(Value >= 1.0f) i = 32767;
51 else i = (ALint)(Value*32767.5f - 0.5f);
52
53 return ((ALshort)i);
54 }
55
56 static __inline ALubyte aluF2UB(ALfloat Value)
57 {
58 ALshort i = aluF2S(Value);
59 return (i>>8)+128;
60 }
61
62
63 static __inline ALfloat point32(ALfloat val1, ALfloat val2, ALint frac)
64 {
65 return val1;
66 (void)val2;
67 (void)frac;
68 }
69 static __inline ALfloat lerp32(ALfloat val1, ALfloat val2, ALint frac)
70 {
71 return val1 + ((val2-val1)*(frac * (1.0f/(1<<FRACTIONBITS))));
72 }
73 static __inline ALfloat cos_lerp32(ALfloat val1, ALfloat val2, ALint frac)
74 {
75 ALfloat mult = (1.0f-cos(frac * (1.0f/(1<<FRACTIONBITS)) * M_PI)) * 0.5f;
76 return val1 + ((val2-val1)*mult);
77 }
78
79 static __inline ALfloat point16(ALfloat val1, ALfloat val2, ALint frac)
80 {
81 return (val1+0.5f) / 32767.5f;
82 (void)val2;
83 (void)frac;
84 }
85 static __inline ALfloat lerp16(ALfloat val1, ALfloat val2, ALint frac)
86 {
87 val1 += ((val2-val1)*(frac * (1.0f/(1<<FRACTIONBITS))));
88 return (val1+0.5f) / 32767.5f;
89 }
90 static __inline ALfloat cos_lerp16(ALfloat val1, ALfloat val2, ALint frac)
91 {
92 ALfloat mult = (1.0f-cos(frac * (1.0f/(1<<FRACTIONBITS)) * M_PI)) * 0.5f;
93 val1 += ((val2-val1)*mult);
94 return (val1+0.5f) / 32767.5f;
95 }
96
97
98 #define DO_MIX_MONO(S,sampler) do { \
99 if(j == 0) \
100 { \
101 value = sampler##S(Data.p##S[DataPosInt], Data.p##S[DataPosInt+1], \
102 DataPosFrac); \
103 \
104 outsamp = lpFilter4PC(DryFilter, 0, value); \
105 ClickRemoval[FRONT_LEFT] -= outsamp*DrySend[FRONT_LEFT]; \
106 ClickRemoval[FRONT_RIGHT] -= outsamp*DrySend[FRONT_RIGHT]; \
107 ClickRemoval[SIDE_LEFT] -= outsamp*DrySend[SIDE_LEFT]; \
108 ClickRemoval[SIDE_RIGHT] -= outsamp*DrySend[SIDE_RIGHT]; \
109 ClickRemoval[BACK_LEFT] -= outsamp*DrySend[BACK_LEFT]; \
110 ClickRemoval[BACK_RIGHT] -= outsamp*DrySend[BACK_RIGHT]; \
111 ClickRemoval[FRONT_CENTER] -= outsamp*DrySend[FRONT_CENTER]; \
112 ClickRemoval[BACK_CENTER] -= outsamp*DrySend[BACK_CENTER]; \
113 \
114 for(out = 0;out < MAX_SENDS;out++) \
115 { \
116 outsamp = lpFilter2PC(WetFilter[out], 0, value); \
117 WetClickRemoval[out][0] -= outsamp*WetSend[out]; \
118 } \
119 } \
120 while(BufferSize--) \
121 { \
122 /* First order interpolator */ \
123 value = sampler##S(Data.p##S[DataPosInt], Data.p##S[DataPosInt+1], \
124 DataPosFrac); \
125 \
126 /* Direct path final mix buffer and panning */ \
127 outsamp = lpFilter4P(DryFilter, 0, value); \
128 DryBuffer[j][FRONT_LEFT] += outsamp*DrySend[FRONT_LEFT]; \
129 DryBuffer[j][FRONT_RIGHT] += outsamp*DrySend[FRONT_RIGHT]; \
130 DryBuffer[j][SIDE_LEFT] += outsamp*DrySend[SIDE_LEFT]; \
131 DryBuffer[j][SIDE_RIGHT] += outsamp*DrySend[SIDE_RIGHT]; \
132 DryBuffer[j][BACK_LEFT] += outsamp*DrySend[BACK_LEFT]; \
133 DryBuffer[j][BACK_RIGHT] += outsamp*DrySend[BACK_RIGHT]; \
134 DryBuffer[j][FRONT_CENTER] += outsamp*DrySend[FRONT_CENTER]; \
135 DryBuffer[j][BACK_CENTER] += outsamp*DrySend[BACK_CENTER]; \
136 \
137 /* Room path final mix buffer and panning */ \
138 for(out = 0;out < MAX_SENDS;out++) \
139 { \
140 outsamp = lpFilter2P(WetFilter[out], 0, value); \
141 WetBuffer[out][j] += outsamp*WetSend[out]; \
142 } \
143 \
144 DataPosFrac += increment; \
145 DataPosInt += DataPosFrac>>FRACTIONBITS; \
146 DataPosFrac &= FRACTIONMASK; \
147 j++; \
148 } \
149 if(j == SamplesToDo) \
150 { \
151 ALuint pos = ((DataPosInt < DataSize) ? DataPosInt : (DataPosInt-1)); \
152 ALuint frac = ((DataPosInt < DataSize) ? DataPosFrac : \
153 ((DataPosFrac-increment)&FRACTIONMASK)); \
154 value = sampler##S(Data.p##S[pos], Data.p##S[pos+1], frac); \
155 \
156 outsamp = lpFilter4PC(DryFilter, 0, value); \
157 PendingClicks[FRONT_LEFT] += outsamp*DrySend[FRONT_LEFT]; \
158 PendingClicks[FRONT_RIGHT] += outsamp*DrySend[FRONT_RIGHT]; \
159 PendingClicks[SIDE_LEFT] += outsamp*DrySend[SIDE_LEFT]; \
160 PendingClicks[SIDE_RIGHT] += outsamp*DrySend[SIDE_RIGHT]; \
161 PendingClicks[BACK_LEFT] += outsamp*DrySend[BACK_LEFT]; \
162 PendingClicks[BACK_RIGHT] += outsamp*DrySend[BACK_RIGHT]; \
163 PendingClicks[FRONT_CENTER] += outsamp*DrySend[FRONT_CENTER]; \
164 PendingClicks[BACK_CENTER] += outsamp*DrySend[BACK_CENTER]; \
165 \
166 for(out = 0;out < MAX_SENDS;out++) \
167 { \
168 outsamp = lpFilter2PC(WetFilter[out], 0, value); \
169 WetPendingClicks[out][0] += outsamp*WetSend[out]; \
170 } \
171 } \
172 } while(0)
173
174 #define DO_MIX_STEREO(S,sampler) do { \
175 const ALfloat scaler = 1.0f/Channels; \
176 if(j == 0) \
177 { \
178 for(i = 0;i < Channels;i++) \
179 { \
180 value = sampler##S(Data.p##S[DataPosInt*Channels + i], \
181 Data.p##S[(DataPosInt+1)*Channels + i], \
182 DataPosFrac); \
183 \
184 outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
185 ClickRemoval[chans[i+0]] -= outsamp*DrySend[chans[i+0]]; \
186 ClickRemoval[chans[i+2]] -= outsamp*DrySend[chans[i+2]]; \
187 ClickRemoval[chans[i+4]] -= outsamp*DrySend[chans[i+4]]; \
188 \
189 for(out = 0;out < MAX_SENDS;out++) \
190 { \
191 outsamp = lpFilter1PC(WetFilter[out], chans[i], value); \
192 WetClickRemoval[out][0] -= outsamp*WetSend[out] * scaler; \
193 } \
194 } \
195 } \
196 while(BufferSize--) \
197 { \
198 for(i = 0;i < Channels;i++) \
199 { \
200 value = sampler##S(Data.p##S[DataPosInt*Channels + i], \
201 Data.p##S[(DataPosInt+1)*Channels + i], \
202 DataPosFrac); \
203 \
204 outsamp = lpFilter2P(DryFilter, chans[i]*2, value); \
205 DryBuffer[j][chans[i+0]] += outsamp*DrySend[chans[i+0]]; \
206 DryBuffer[j][chans[i+2]] += outsamp*DrySend[chans[i+2]]; \
207 DryBuffer[j][chans[i+4]] += outsamp*DrySend[chans[i+4]]; \
208 \
209 for(out = 0;out < MAX_SENDS;out++) \
210 { \
211 outsamp = lpFilter1P(WetFilter[out], chans[i], value); \
212 WetBuffer[out][j] += outsamp*WetSend[out] * scaler; \
213 } \
214 } \
215 \
216 DataPosFrac += increment; \
217 DataPosInt += DataPosFrac>>FRACTIONBITS; \
218 DataPosFrac &= FRACTIONMASK; \
219 j++; \
220 } \
221 if(j == SamplesToDo) \
222 { \
223 ALuint pos = ((DataPosInt < DataSize) ? DataPosInt : (DataPosInt-1)); \
224 ALuint frac = ((DataPosInt < DataSize) ? DataPosFrac : \
225 ((DataPosFrac-increment)&FRACTIONMASK)); \
226 for(i = 0;i < Channels;i++) \
227 { \
228 value = sampler##S(Data.p##S[pos*Channels + i], \
229 Data.p##S[(pos+1)*Channels + i], \
230 frac); \
231 \
232 outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
233 PendingClicks[chans[i+0]] += outsamp*DrySend[chans[i+0]]; \
234 PendingClicks[chans[i+2]] += outsamp*DrySend[chans[i+2]]; \
235 PendingClicks[chans[i+4]] += outsamp*DrySend[chans[i+4]]; \
236 \
237 for(out = 0;out < MAX_SENDS;out++) \
238 { \
239 outsamp = lpFilter1PC(WetFilter[out], chans[i], value); \
240 WetPendingClicks[out][0] += outsamp*WetSend[out] * scaler; \
241 } \
242 } \
243 } \
244 } while(0)
245
246 #define DO_MIX_MC(S,sampler) do { \
247 const ALfloat scaler = 1.0f/Channels; \
248 if(j == 0) \
249 { \
250 for(i = 0;i < Channels;i++) \
251 { \
252 value = sampler##S(Data.p##S[DataPosInt*Channels + i], \
253 Data.p##S[(DataPosInt+1)*Channels + i], \
254 DataPosFrac); \
255 \
256 outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
257 ClickRemoval[chans[i]] -= outsamp*DrySend[chans[i]]; \
258 \
259 for(out = 0;out < MAX_SENDS;out++) \
260 { \
261 outsamp = lpFilter1PC(WetFilter[out], chans[out], value) * scaler;\
262 WetClickRemoval[out][0] -= outsamp*WetSend[out]; \
263 } \
264 } \
265 } \
266 while(BufferSize--) \
267 { \
268 for(i = 0;i < Channels;i++) \
269 { \
270 value = sampler##S(Data.p##S[DataPosInt*Channels + i], \
271 Data.p##S[(DataPosInt+1)*Channels + i], \
272 DataPosFrac); \
273 \
274 outsamp = lpFilter2P(DryFilter, chans[i]*2, value); \
275 DryBuffer[j][chans[i]] += outsamp*DrySend[chans[i]]; \
276 \
277 for(out = 0;out < MAX_SENDS;out++) \
278 { \
279 outsamp = lpFilter1P(WetFilter[out], chans[i], value); \
280 WetBuffer[out][j] += outsamp*WetSend[out]*scaler; \
281 } \
282 } \
283 \
284 DataPosFrac += increment; \
285 DataPosInt += DataPosFrac>>FRACTIONBITS; \
286 DataPosFrac &= FRACTIONMASK; \
287 j++; \
288 } \
289 if(j == SamplesToDo) \
290 { \
291 ALuint pos = ((DataPosInt < DataSize) ? DataPosInt : (DataPosInt-1)); \
292 ALuint frac = ((DataPosInt < DataSize) ? DataPosFrac : \
293 ((DataPosFrac-increment)&FRACTIONMASK)); \
294 for(i = 0;i < Channels;i++) \
295 { \
296 value = sampler##S(Data.p##S[pos*Channels + i], \
297 Data.p##S[(pos+1)*Channels + i], \
298 frac); \
299 \
300 outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
301 PendingClicks[chans[i]] += outsamp*DrySend[chans[i]]; \
302 \
303 for(out = 0;out < MAX_SENDS;out++) \
304 { \
305 outsamp = lpFilter1PC(WetFilter[out], chans[out], value) * scaler;\
306 WetPendingClicks[out][0] += outsamp*WetSend[out]; \
307 } \
308 } \
309 } \
310 } while(0)
311
312
313 #define MIX_MONO(S) do { \
314 switch(Source->Resampler) \
315 { \
316 case POINT_RESAMPLER: \
317 DO_MIX_MONO(S,point); break; \
318 case LINEAR_RESAMPLER: \
319 DO_MIX_MONO(S,lerp); break; \
320 case COSINE_RESAMPLER: \
321 DO_MIX_MONO(S,cos_lerp); break; \
322 case RESAMPLER_MIN: \
323 case RESAMPLER_MAX: \
324 break; \
325 } \
326 } while(0)
327
328 #define MIX_STEREO(S) do { \
329 const int chans[] = { \
330 FRONT_LEFT, FRONT_RIGHT, \
331 SIDE_LEFT, SIDE_RIGHT, \
332 BACK_LEFT, BACK_RIGHT \
333 }; \
334 \
335 switch(Source->Resampler) \
336 { \
337 case POINT_RESAMPLER: \
338 DO_MIX_STEREO(S,point); break; \
339 case LINEAR_RESAMPLER: \
340 DO_MIX_STEREO(S,lerp); break; \
341 case COSINE_RESAMPLER: \
342 DO_MIX_STEREO(S,cos_lerp); break; \
343 case RESAMPLER_MIN: \
344 case RESAMPLER_MAX: \
345 break; \
346 } \
347 } while(0)
348
349 #define MIX_MC(S,...) do { \
350 const int chans[] = { __VA_ARGS__ }; \
351 \
352 switch(Source->Resampler) \
353 { \
354 case POINT_RESAMPLER: \
355 DO_MIX_MC(S,point); break; \
356 case LINEAR_RESAMPLER: \
357 DO_MIX_MC(S,lerp); break; \
358 case COSINE_RESAMPLER: \
359 DO_MIX_MC(S,cos_lerp); break; \
360 case RESAMPLER_MIN: \
361 case RESAMPLER_MAX: \
362 break; \
363 } \
364 } while(0)
365
366
367 #define MIX(S) do { \
368 if(Channels == 1) /* Mono */ \
369 MIX_MONO(S); \
370 else if(Channels == 2) /* Stereo */ \
371 MIX_STEREO(S); \
372 else if(Channels == 4) /* Quad */ \
373 MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
374 BACK_LEFT, BACK_RIGHT); \
375 else if(Channels == 6) /* 5.1 */ \
376 MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
377 FRONT_CENTER, LFE, \
378 BACK_LEFT, BACK_RIGHT); \
379 else if(Channels == 7) /* 6.1 */ \
380 MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
381 FRONT_CENTER, LFE, \
382 BACK_CENTER, \
383 SIDE_LEFT, SIDE_RIGHT); \
384 else if(Channels == 8) /* 7.1 */ \
385 MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
386 FRONT_CENTER, LFE, \
387 BACK_LEFT, BACK_RIGHT, \
388 SIDE_LEFT, SIDE_RIGHT); \
389 } while(0)
390
391
392 static void MixSource(ALsource *Source, ALCcontext *Context,
393 ALfloat (*DryBuffer)[OUTPUTCHANNELS], ALuint SamplesToDo,
394 ALfloat *ClickRemoval, ALfloat *PendingClicks)
395 {
396 static ALfloat DummyBuffer[BUFFERSIZE];
397 static ALfloat DummyClickRemoval[OUTPUTCHANNELS];
398 ALfloat *WetBuffer[MAX_SENDS];
399 ALfloat DrySend[OUTPUTCHANNELS];
400 ALfloat *WetClickRemoval[MAX_SENDS];
401 ALfloat *WetPendingClicks[MAX_SENDS];
402 ALuint i, j, out;
403 ALfloat value, outsamp;
404 ALbufferlistitem *BufferListItem;
405 ALint64 DataSize64,DataPos64;
406 FILTER *DryFilter, *WetFilter[MAX_SENDS];
407 ALfloat WetSend[MAX_SENDS];
408 ALint increment;
409 ALuint DataPosInt, DataPosFrac;
410 ALuint BuffersPlayed;
411 ALboolean Looping;
412 ALenum State;
413
414 if(Source->NeedsUpdate)
415 {
416 ALsource_Update(Source, Context);
417 Source->NeedsUpdate = AL_FALSE;
418 }
419
420 /* Get source info */
421 State = Source->state;
422 BuffersPlayed = Source->BuffersPlayed;
423 DataPosInt = Source->position;
424 DataPosFrac = Source->position_fraction;
425 Looping = Source->bLooping;
426
427 for(i = 0;i < OUTPUTCHANNELS;i++)
428 DrySend[i] = Source->Params.DryGains[i];
429 for(i = 0;i < MAX_SENDS;i++)
430 WetSend[i] = Source->Params.WetGains[i];
431
432 /* Get fixed point step */
433 increment = Source->Params.Step;
434
435 DryFilter = &Source->Params.iirFilter;
436 for(i = 0;i < MAX_SENDS;i++)
437 {
438 WetFilter[i] = &Source->Params.Send[i].iirFilter;
439 if(Source->Send[i].Slot)
440 {
441 WetBuffer[i] = Source->Send[i].Slot->WetBuffer;
442 WetClickRemoval[i] = Source->Send[i].Slot->ClickRemoval;
443 WetPendingClicks[i] = Source->Send[i].Slot->PendingClicks;
444 }
445 else
446 {
447 WetBuffer[i] = DummyBuffer;
448 WetClickRemoval[i] = DummyClickRemoval;
449 WetPendingClicks[i] = DummyClickRemoval;
450 }
451 }
452
453 /* Get current buffer queue item */
454 BufferListItem = Source->queue;
455 for(i = 0;i < BuffersPlayed;i++)
456 BufferListItem = BufferListItem->next;
457
458 j = 0;
459 do {
460 const ALbuffer *ALBuffer;
461 union {
462 ALfloat *p32;
463 ALshort *p16;
464 ALubyte *p8;
465 } Data = { NULL };
466 ALuint DataSize = 0;
467 ALuint LoopStart = 0;
468 ALuint LoopEnd = 0;
469 ALuint Channels, Bytes;
470 ALuint BufferSize;
471
472 /* Get buffer info */
473 if((ALBuffer=BufferListItem->buffer) != NULL)
474 {
475 Data.p8 = ALBuffer->data;
476 DataSize = ALBuffer->size;
477 DataSize /= aluFrameSizeFromFormat(ALBuffer->format);
478 Channels = aluChannelsFromFormat(ALBuffer->format);
479 Bytes = aluBytesFromFormat(ALBuffer->format);
480
481 LoopStart = 0;
482 LoopEnd = DataSize;
483 if(Looping && Source->lSourceType == AL_STATIC)
484 {
485 /* If current pos is beyond the loop range, do not loop */
486 if(DataPosInt >= LoopEnd)
487 Looping = AL_FALSE;
488 else
489 {
490 LoopStart = ALBuffer->LoopStart;
491 LoopEnd = ALBuffer->LoopEnd;
492 }
493 }
494 }
495
496 if(DataPosInt >= DataSize)
497 goto skipmix;
498
499 if(BufferListItem->next)
500 {
501 ALbuffer *NextBuf = BufferListItem->next->buffer;
502 if(NextBuf && NextBuf->size)
503 {
504 ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
505 ulExtraSamples = min(NextBuf->size, ulExtraSamples);
506 memcpy(&Data.p8[DataSize*Channels*Bytes],
507 NextBuf->data, ulExtraSamples);
508 }
509 }
510 else if(Looping)
511 {
512 ALbuffer *NextBuf = Source->queue->buffer;
513 if(NextBuf && NextBuf->size)
514 {
515 ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
516 ulExtraSamples = min(NextBuf->size, ulExtraSamples);
517 memcpy(&Data.p8[DataSize*Channels*Bytes],
518 &((ALubyte*)NextBuf->data)[LoopStart*Channels*Bytes],
519 ulExtraSamples);
520 }
521 }
522 else
523 memset(&Data.p8[DataSize*Channels*Bytes], 0, (BUFFER_PADDING*Channels*Bytes));
524
525 /* Figure out how many samples we can mix. */
526 DataSize64 = LoopEnd;
527 DataSize64 <<= FRACTIONBITS;
528 DataPos64 = DataPosInt;
529 DataPos64 <<= FRACTIONBITS;
530 DataPos64 += DataPosFrac;
531 BufferSize = (ALuint)((DataSize64-DataPos64+(increment-1)) / increment);
532
533 BufferSize = min(BufferSize, (SamplesToDo-j));
534
535 if(Bytes == 4) /* 32-bit float */
536 MIX(32);
537 else if(Bytes == 2) /* signed 16-bit */
538 MIX(16);
539
540 skipmix:
541 /* Handle looping sources */
542 if(DataPosInt >= LoopEnd)
543 {
544 if(BuffersPlayed < (Source->BuffersInQueue-1))
545 {
546 BufferListItem = BufferListItem->next;
547 BuffersPlayed++;
548 DataPosInt -= DataSize;
549 }
550 else if(Looping)
551 {
552 BufferListItem = Source->queue;
553 BuffersPlayed = 0;
554 if(Source->lSourceType == AL_STATIC)
555 DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
556 else
557 DataPosInt -= DataSize;
558 }
559 else
560 {
561 State = AL_STOPPED;
562 BufferListItem = Source->queue;
563 BuffersPlayed = Source->BuffersInQueue;
564 DataPosInt = 0;
565 DataPosFrac = 0;
566 }
567 }
568 } while(State == AL_PLAYING && j < SamplesToDo);
569
570 /* Update source info */
571 Source->state = State;
572 Source->BuffersPlayed = BuffersPlayed;
573 Source->position = DataPosInt;
574 Source->position_fraction = DataPosFrac;
575 Source->Buffer = BufferListItem->buffer;
576 }
577
578 #undef DO_MIX_MC
579 #undef DO_MIX_STEREO
580 #undef DO_MIX_MONO
581
582 ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
583 {
584 ALfloat (*DryBuffer)[OUTPUTCHANNELS];
585 ALfloat (*Matrix)[OUTPUTCHANNELS];
586 ALfloat *ClickRemoval;
587 const ALuint *ChanMap;
588 ALuint SamplesToDo;
589 ALeffectslot *ALEffectSlot;
590 ALCcontext **ctx, **ctx_end;
591 ALsource **src, **src_end;
592 ALfloat samp;
593 int fpuState;
594 ALuint i, j, c;
595 ALsizei e;
596
597 #if defined(HAVE_FESETROUND)
598 fpuState = fegetround();
599 fesetround(FE_TOWARDZERO);
600 #elif defined(HAVE__CONTROLFP)
601 fpuState = _controlfp(0, 0);
602 _controlfp(_RC_CHOP, _MCW_RC);
603 #else
604 (void)fpuState;
605 #endif
606
607 DryBuffer = device->DryBuffer;
608 while(size > 0)
609 {
610 /* Setup variables */
611 SamplesToDo = min(size, BUFFERSIZE);
612
613 /* Clear mixing buffer */
614 memset(DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
615
616 SuspendContext(NULL);
617 ctx = device->Contexts;
618 ctx_end = ctx + device->NumContexts;
619 while(ctx != ctx_end)
620 {
621 SuspendContext(*ctx);
622
623 src = (*ctx)->ActiveSources;
624 src_end = src + (*ctx)->ActiveSourceCount;
625 while(src != src_end)
626 {
627 if((*src)->state != AL_PLAYING)
628 {
629 --((*ctx)->ActiveSourceCount);
630 *src = *(--src_end);
631 continue;
632 }
633 MixSource(*src, *ctx, DryBuffer, SamplesToDo,
634 device->ClickRemoval, device->PendingClicks);
635 src++;
636 }
637
638 /* effect slot processing */
639 for(e = 0;e < (*ctx)->EffectSlotMap.size;e++)
640 {
641 ALEffectSlot = (*ctx)->EffectSlotMap.array[e].value;
642
643 ClickRemoval = ALEffectSlot->ClickRemoval;
644 for(i = 0;i < SamplesToDo;i++)
645 {
646 ClickRemoval[0] -= ClickRemoval[0] / 256.0f;
647 ALEffectSlot->WetBuffer[i] += ClickRemoval[0];
648 }
649 for(i = 0;i < 1;i++)
650 {
651 ALEffectSlot->ClickRemoval[i] += ALEffectSlot->PendingClicks[i];
652 ALEffectSlot->PendingClicks[i] = 0.0f;
653 }
654
655 ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot, SamplesToDo, ALEffectSlot->WetBuffer, DryBuffer);
656
657 for(i = 0;i < SamplesToDo;i++)
658 ALEffectSlot->WetBuffer[i] = 0.0f;
659 }
660
661 ProcessContext(*ctx);
662 ctx++;
663 }
664 device->SamplesPlayed += SamplesToDo;
665 ProcessContext(NULL);
666
667 //Post processing loop
668 ClickRemoval = device->ClickRemoval;
669 for(i = 0;i < SamplesToDo;i++)
670 {
671 for(c = 0;c < OUTPUTCHANNELS;c++)
672 {
673 ClickRemoval[c] -= ClickRemoval[c] / 256.0f;
674 DryBuffer[i][c] += ClickRemoval[c];
675 }
676 }
677 for(i = 0;i < OUTPUTCHANNELS;i++)
678 {
679 device->ClickRemoval[i] += device->PendingClicks[i];
680 device->PendingClicks[i] = 0.0f;
681 }
682
683 ChanMap = device->DevChannels;
684 Matrix = device->ChannelMatrix;
685 switch(device->Format)
686 {
687 #define CHECK_WRITE_FORMAT(bits, type, func) \
688 case AL_FORMAT_MONO##bits: \
689 for(i = 0;i < SamplesToDo;i++) \
690 { \
691 samp = 0.0f; \
692 for(c = 0;c < OUTPUTCHANNELS;c++) \
693 samp += DryBuffer[i][c] * Matrix[c][FRONT_CENTER]; \
694 ((type*)buffer)[ChanMap[FRONT_CENTER]] = (func)(samp); \
695 buffer = ((type*)buffer) + 1; \
696 } \
697 break; \
698 case AL_FORMAT_STEREO##bits: \
699 if(device->Bs2b) \
700 { \
701 for(i = 0;i < SamplesToDo;i++) \
702 { \
703 float samples[2] = { 0.0f, 0.0f }; \
704 for(c = 0;c < OUTPUTCHANNELS;c++) \
705 { \
706 samples[0] += DryBuffer[i][c]*Matrix[c][FRONT_LEFT]; \
707 samples[1] += DryBuffer[i][c]*Matrix[c][FRONT_RIGHT]; \
708 } \
709 bs2b_cross_feed(device->Bs2b, samples); \
710 ((type*)buffer)[ChanMap[FRONT_LEFT]] = (func)(samples[0]);\
711 ((type*)buffer)[ChanMap[FRONT_RIGHT]]= (func)(samples[1]);\
712 buffer = ((type*)buffer) + 2; \
713 } \
714 } \
715 else \
716 { \
717 for(i = 0;i < SamplesToDo;i++) \
718 { \
719 static const Channel chans[] = { \
720 FRONT_LEFT, FRONT_RIGHT \
721 }; \
722 for(j = 0;j < 2;j++) \
723 { \
724 samp = 0.0f; \
725 for(c = 0;c < OUTPUTCHANNELS;c++) \
726 samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
727 ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
728 } \
729 buffer = ((type*)buffer) + 2; \
730 } \
731 } \
732 break; \
733 case AL_FORMAT_QUAD##bits: \
734 for(i = 0;i < SamplesToDo;i++) \
735 { \
736 static const Channel chans[] = { \
737 FRONT_LEFT, FRONT_RIGHT, \
738 BACK_LEFT, BACK_RIGHT, \
739 }; \
740 for(j = 0;j < 4;j++) \
741 { \
742 samp = 0.0f; \
743 for(c = 0;c < OUTPUTCHANNELS;c++) \
744 samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
745 ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
746 } \
747 buffer = ((type*)buffer) + 4; \
748 } \
749 break; \
750 case AL_FORMAT_51CHN##bits: \
751 for(i = 0;i < SamplesToDo;i++) \
752 { \
753 static const Channel chans[] = { \
754 FRONT_LEFT, FRONT_RIGHT, \
755 FRONT_CENTER, LFE, \
756 BACK_LEFT, BACK_RIGHT, \
757 }; \
758 for(j = 0;j < 6;j++) \
759 { \
760 samp = 0.0f; \
761 for(c = 0;c < OUTPUTCHANNELS;c++) \
762 samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
763 ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
764 } \
765 buffer = ((type*)buffer) + 6; \
766 } \
767 break; \
768 case AL_FORMAT_61CHN##bits: \
769 for(i = 0;i < SamplesToDo;i++) \
770 { \
771 static const Channel chans[] = { \
772 FRONT_LEFT, FRONT_RIGHT, \
773 FRONT_CENTER, LFE, BACK_CENTER, \
774 SIDE_LEFT, SIDE_RIGHT, \
775 }; \
776 for(j = 0;j < 7;j++) \
777 { \
778 samp = 0.0f; \
779 for(c = 0;c < OUTPUTCHANNELS;c++) \
780 samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
781 ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
782 } \
783 buffer = ((type*)buffer) + 7; \
784 } \
785 break; \
786 case AL_FORMAT_71CHN##bits: \
787 for(i = 0;i < SamplesToDo;i++) \
788 { \
789 static const Channel chans[] = { \
790 FRONT_LEFT, FRONT_RIGHT, \
791 FRONT_CENTER, LFE, \
792 BACK_LEFT, BACK_RIGHT, \
793 SIDE_LEFT, SIDE_RIGHT \
794 }; \
795 for(j = 0;j < 8;j++) \
796 { \
797 samp = 0.0f; \
798 for(c = 0;c < OUTPUTCHANNELS;c++) \
799 samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
800 ((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
801 } \
802 buffer = ((type*)buffer) + 8; \
803 } \
804 break;
805
806 #define AL_FORMAT_MONO32 AL_FORMAT_MONO_FLOAT32
807 #define AL_FORMAT_STEREO32 AL_FORMAT_STEREO_FLOAT32
808 CHECK_WRITE_FORMAT(8, ALubyte, aluF2UB)
809 CHECK_WRITE_FORMAT(16, ALshort, aluF2S)
810 CHECK_WRITE_FORMAT(32, ALfloat, aluF2F)
811 #undef AL_FORMAT_STEREO32
812 #undef AL_FORMAT_MONO32
813 #undef CHECK_WRITE_FORMAT
814
815 default:
816 break;
817 }
818
819 size -= SamplesToDo;
820 }
821
822 #if defined(HAVE_FESETROUND)
823 fesetround(fpuState);
824 #elif defined(HAVE__CONTROLFP)
825 _controlfp(fpuState, 0xfffff);
826 #endif
827 }
Software OpenAL implementation