AuroraMiddleware/AuroraOpenALSoft
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
92d8d2f8a4
AuroraOpenALSoft/Alc/mixer.c

963 lines
55 KiB
C
Raw Normal View History

Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
* Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#include "config.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include "alMain.h"
#include "AL/al.h"
#include "AL/alc.h"
#include "alSource.h"
#include "alBuffer.h"
#include "alListener.h"
#include "alAuxEffectSlot.h"
#include "alu.h"
#include "bs2b.h"
static __inline ALfloat aluF2F(ALfloat Value)
{
return Value;
}
static __inline ALshort aluF2S(ALfloat Value)
{
Convert float to short similar to short to float
2010-09-23 15:43:39 +00:00
ALint i;
Better protect against sample overflow when converting float to short
2010-09-08 23:26:19 +00:00
Convert float to short similar to short to float
2010-09-23 15:43:39 +00:00
if(Value <= -1.0f) i = -32768;
else if(Value >= 1.0f) i = 32767;
Convert shorts so that 0 remains 0
2010-09-26 04:13:40 +00:00
else i = (ALint)(Value*32767.0f);
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
return ((ALshort)i);
}
static __inline ALubyte aluF2UB(ALfloat Value)
{
ALshort i = aluF2S(Value);
return (i>>8)+128;
}
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
static __inline ALfloat point32(ALfloat val1, ALfloat val2, ALint frac)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
return val1;
(void)val2;
(void)frac;
}
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
static __inline ALfloat lerp32(ALfloat val1, ALfloat val2, ALint frac)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
return val1 + ((val2-val1)*(frac * (1.0f/(1<<FRACTIONBITS))));
}
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
static __inline ALfloat cos_lerp32(ALfloat val1, ALfloat val2, ALint frac)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
ALfloat mult = (1.0f-cos(frac * (1.0f/(1<<FRACTIONBITS)) * M_PI)) * 0.5f;
return val1 + ((val2-val1)*mult);
}
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
static __inline ALfloat point16(ALfloat val1, ALfloat val2, ALint frac)
{
Convert shorts so that 0 remains 0
2010-09-26 04:13:40 +00:00
return val1 / 32767.0f;
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
(void)val2;
(void)frac;
}
static __inline ALfloat lerp16(ALfloat val1, ALfloat val2, ALint frac)
{
val1 += ((val2-val1)*(frac * (1.0f/(1<<FRACTIONBITS))));
Convert shorts so that 0 remains 0
2010-09-26 04:13:40 +00:00
return val1 / 32767.0f;
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
}
static __inline ALfloat cos_lerp16(ALfloat val1, ALfloat val2, ALint frac)
{
ALfloat mult = (1.0f-cos(frac * (1.0f/(1<<FRACTIONBITS)) * M_PI)) * 0.5f;
val1 += ((val2-val1)*mult);
Convert shorts so that 0 remains 0
2010-09-26 04:13:40 +00:00
return val1 / 32767.0f;
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
}
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
#define DO_MIX_MONO(S,sampler) do { \
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALfloat (*DryBuffer)[OUTPUTCHANNELS]; \
ALfloat *ClickRemoval, *PendingClicks; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
ALuint pos = DataPosInt; \
ALuint frac = DataPosFrac; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
ALfloat DrySend[OUTPUTCHANNELS]; \
FILTER *DryFilter; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint BufferIdx; \
ALuint i, out; \
ALfloat value; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
\
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
DryBuffer = Device->DryBuffer; \
ClickRemoval = Device->ClickRemoval; \
PendingClicks = Device->PendingClicks; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
DryFilter = &Source->Params.iirFilter; \
for(i = 0;i < OUTPUTCHANNELS;i++) \
DrySend[i] = Source->Params.DryGains[i]; \
\
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
if(j == 0) \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[pos], Data.p##S[pos+1], frac); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter4PC(DryFilter, 0, value); \
ClickRemoval[FRONT_LEFT] -= value*DrySend[FRONT_LEFT]; \
ClickRemoval[FRONT_RIGHT] -= value*DrySend[FRONT_RIGHT]; \
ClickRemoval[SIDE_LEFT] -= value*DrySend[SIDE_LEFT]; \
ClickRemoval[SIDE_RIGHT] -= value*DrySend[SIDE_RIGHT]; \
ClickRemoval[BACK_LEFT] -= value*DrySend[BACK_LEFT]; \
ClickRemoval[BACK_RIGHT] -= value*DrySend[BACK_RIGHT]; \
ClickRemoval[FRONT_CENTER] -= value*DrySend[FRONT_CENTER]; \
ClickRemoval[BACK_CENTER] -= value*DrySend[BACK_CENTER]; \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
} \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{ \
/* First order interpolator */ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[pos], Data.p##S[pos+1], frac); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
\
/* Direct path final mix buffer and panning */ \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter4P(DryFilter, 0, value); \
DryBuffer[j][FRONT_LEFT] += value*DrySend[FRONT_LEFT]; \
DryBuffer[j][FRONT_RIGHT] += value*DrySend[FRONT_RIGHT]; \
DryBuffer[j][SIDE_LEFT] += value*DrySend[SIDE_LEFT]; \
DryBuffer[j][SIDE_RIGHT] += value*DrySend[SIDE_RIGHT]; \
DryBuffer[j][BACK_LEFT] += value*DrySend[BACK_LEFT]; \
DryBuffer[j][BACK_RIGHT] += value*DrySend[BACK_RIGHT]; \
DryBuffer[j][FRONT_CENTER] += value*DrySend[FRONT_CENTER]; \
DryBuffer[j][BACK_CENTER] += value*DrySend[BACK_CENTER]; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
j++; \
} \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
if(j == SamplesToDo) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
ALuint p = pos; \
ALuint f = frac; \
Avoid sampling beyond the end of the loop
2010-09-25 06:32:50 +00:00
if(p >= LoopEnd) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
{ \
ALuint64 pos64 = pos; \
pos64 <<= FRACTIONBITS; \
pos64 += frac; \
pos64 -= increment; \
p = pos64>>FRACTIONBITS; \
f = pos64&FRACTIONMASK; \
} \
value = sampler##S(Data.p##S[p], Data.p##S[p+1], f); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter4PC(DryFilter, 0, value); \
PendingClicks[FRONT_LEFT] += value*DrySend[FRONT_LEFT]; \
PendingClicks[FRONT_RIGHT] += value*DrySend[FRONT_RIGHT]; \
PendingClicks[SIDE_LEFT] += value*DrySend[SIDE_LEFT]; \
PendingClicks[SIDE_RIGHT] += value*DrySend[SIDE_RIGHT]; \
PendingClicks[BACK_LEFT] += value*DrySend[BACK_LEFT]; \
PendingClicks[BACK_RIGHT] += value*DrySend[BACK_RIGHT]; \
PendingClicks[FRONT_CENTER] += value*DrySend[FRONT_CENTER]; \
PendingClicks[BACK_CENTER] += value*DrySend[BACK_CENTER]; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
for(out = 0;out < MAX_SENDS;out++) \
{ \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
ALfloat WetSend; \
ALfloat *WetBuffer; \
ALfloat *WetClickRemoval; \
ALfloat *WetPendingClicks; \
FILTER *WetFilter; \
\
if(!Source->Send[out].Slot || \
Source->Send[out].Slot->effect.type == AL_EFFECT_NULL) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
continue; \
\
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
WetSend = Source->Params.WetGains[out]; \
WetBuffer = Source->Send[out].Slot->WetBuffer; \
WetClickRemoval = Source->Send[out].Slot->ClickRemoval; \
WetPendingClicks = Source->Send[out].Slot->PendingClicks; \
WetFilter = &Source->Params.Send[out].iirFilter; \
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
pos = DataPosInt; \
frac = DataPosFrac; \
j -= BufferSize; \
\
if(j == 0) \
{ \
value = sampler##S(Data.p##S[pos], Data.p##S[pos+1], frac); \
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2PC(WetFilter, 0, value); \
WetClickRemoval[0] -= value*WetSend; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
{ \
/* First order interpolator */ \
value = sampler##S(Data.p##S[pos], Data.p##S[pos+1], frac); \
\
/* Room path final mix buffer and panning */ \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2P(WetFilter, 0, value); \
WetBuffer[j] += value*WetSend; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
j++; \
} \
if(j == SamplesToDo) \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
ALuint p = pos; \
ALuint f = frac; \
Avoid sampling beyond the end of the loop
2010-09-25 06:32:50 +00:00
if(p >= LoopEnd) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
{ \
ALuint64 pos64 = pos; \
pos64 <<= FRACTIONBITS; \
pos64 += frac; \
pos64 -= increment; \
p = pos64>>FRACTIONBITS; \
f = pos64&FRACTIONMASK; \
} \
value = sampler##S(Data.p##S[p], Data.p##S[p+1], f); \
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2PC(WetFilter, 0, value); \
WetPendingClicks[0] += value*WetSend; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
} \
} \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
DataPosInt = pos; \
DataPosFrac = frac; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
} while(0)
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
#define DO_MIX_STEREO(S,sampler) do { \
Add click removal for wet sends
2010-08-15 21:52:12 +00:00
const ALfloat scaler = 1.0f/Channels; \
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALfloat (*DryBuffer)[OUTPUTCHANNELS]; \
ALfloat *ClickRemoval, *PendingClicks; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
ALuint pos = DataPosInt; \
ALuint frac = DataPosFrac; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
ALfloat DrySend[OUTPUTCHANNELS]; \
FILTER *DryFilter; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint BufferIdx; \
ALuint i, out; \
ALfloat value; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
\
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
DryBuffer = Device->DryBuffer; \
ClickRemoval = Device->ClickRemoval; \
PendingClicks = Device->PendingClicks; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
DryFilter = &Source->Params.iirFilter; \
for(i = 0;i < OUTPUTCHANNELS;i++) \
DrySend[i] = Source->Params.DryGains[i]; \
\
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
if(j == 0) \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
{ \
for(i = 0;i < Channels;i++) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2PC(DryFilter, chans[i]*2, value); \
ClickRemoval[chans[i+0]] -= value*DrySend[chans[i+0]]; \
ClickRemoval[chans[i+2]] -= value*DrySend[chans[i+2]]; \
ClickRemoval[chans[i+4]] -= value*DrySend[chans[i+4]]; \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
} \
} \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{ \
for(i = 0;i < Channels;i++) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2P(DryFilter, chans[i]*2, value); \
DryBuffer[j][chans[i+0]] += value*DrySend[chans[i+0]]; \
DryBuffer[j][chans[i+2]] += value*DrySend[chans[i+2]]; \
DryBuffer[j][chans[i+4]] += value*DrySend[chans[i+4]]; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
} \
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
j++; \
} \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
if(j == SamplesToDo) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
ALuint p = pos; \
ALuint f = frac; \
Avoid sampling beyond the end of the loop
2010-09-25 06:32:50 +00:00
if(p >= LoopEnd) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
{ \
ALuint64 pos64 = pos; \
pos64 <<= FRACTIONBITS; \
pos64 += frac; \
pos64 -= increment; \
p = pos64>>FRACTIONBITS; \
f = pos64&FRACTIONMASK; \
} \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
for(i = 0;i < Channels;i++) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[p*Channels + i], \
Data.p##S[(p+1)*Channels + i], f); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2PC(DryFilter, chans[i]*2, value); \
PendingClicks[chans[i+0]] += value*DrySend[chans[i+0]]; \
PendingClicks[chans[i+2]] += value*DrySend[chans[i+2]]; \
PendingClicks[chans[i+4]] += value*DrySend[chans[i+4]]; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
} \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
for(out = 0;out < MAX_SENDS;out++) \
{ \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
ALfloat WetSend; \
ALfloat *WetBuffer; \
ALfloat *WetClickRemoval; \
ALfloat *WetPendingClicks; \
FILTER *WetFilter; \
\
if(!Source->Send[out].Slot || \
Source->Send[out].Slot->effect.type == AL_EFFECT_NULL) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
continue; \
\
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
WetSend = Source->Params.WetGains[out]; \
WetBuffer = Source->Send[out].Slot->WetBuffer; \
WetClickRemoval = Source->Send[out].Slot->ClickRemoval; \
WetPendingClicks = Source->Send[out].Slot->PendingClicks; \
WetFilter = &Source->Params.Send[out].iirFilter; \
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
pos = DataPosInt; \
frac = DataPosFrac; \
j -= BufferSize; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
if(j == 0) \
{ \
for(i = 0;i < Channels;i++) \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter1PC(WetFilter, chans[i], value); \
WetClickRemoval[0] -= value*WetSend * scaler; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
} \
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
{ \
for(i = 0;i < Channels;i++) \
{ \
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter1P(WetFilter, chans[i], value); \
WetBuffer[j] += value*WetSend * scaler; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
\
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
j++; \
} \
if(j == SamplesToDo) \
{ \
ALuint p = pos; \
ALuint f = frac; \
Avoid sampling beyond the end of the loop
2010-09-25 06:32:50 +00:00
if(p >= LoopEnd) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
{ \
ALuint64 pos64 = pos; \
pos64 <<= FRACTIONBITS; \
pos64 += frac; \
pos64 -= increment; \
p = pos64>>FRACTIONBITS; \
f = pos64&FRACTIONMASK; \
} \
for(i = 0;i < Channels;i++) \
{ \
value = sampler##S(Data.p##S[p*Channels + i], \
Data.p##S[(p+1)*Channels + i], f); \
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter1PC(WetFilter, chans[i], value); \
WetPendingClicks[0] += value*WetSend * scaler; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
} \
} \
} \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
DataPosInt = pos; \
DataPosFrac = frac; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
} while(0)
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
#define DO_MIX_MC(S,sampler) do { \
Add click removal for wet sends
2010-08-15 21:52:12 +00:00
const ALfloat scaler = 1.0f/Channels; \
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALfloat (*DryBuffer)[OUTPUTCHANNELS]; \
ALfloat *ClickRemoval, *PendingClicks; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
ALuint pos = DataPosInt; \
ALuint frac = DataPosFrac; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
ALfloat DrySend[OUTPUTCHANNELS]; \
FILTER *DryFilter; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint BufferIdx; \
ALuint i, out; \
ALfloat value; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
\
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
DryBuffer = Device->DryBuffer; \
ClickRemoval = Device->ClickRemoval; \
PendingClicks = Device->PendingClicks; \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
DryFilter = &Source->Params.iirFilter; \
for(i = 0;i < OUTPUTCHANNELS;i++) \
DrySend[i] = Source->Params.DryGains[i]; \
\
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
if(j == 0) \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
{ \
for(i = 0;i < Channels;i++) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2PC(DryFilter, chans[i]*2, value); \
ClickRemoval[chans[i]] -= value*DrySend[chans[i]]; \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
} \
} \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{ \
for(i = 0;i < Channels;i++) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2P(DryFilter, chans[i]*2, value); \
DryBuffer[j][chans[i]] += value*DrySend[chans[i]]; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
} \
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
j++; \
} \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
if(j == SamplesToDo) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
ALuint p = pos; \
ALuint f = frac; \
Avoid sampling beyond the end of the loop
2010-09-25 06:32:50 +00:00
if(p >= LoopEnd) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
{ \
ALuint64 pos64 = pos; \
pos64 <<= FRACTIONBITS; \
pos64 += frac; \
pos64 -= increment; \
p = pos64>>FRACTIONBITS; \
f = pos64&FRACTIONMASK; \
} \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
for(i = 0;i < Channels;i++) \
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[p*Channels + i], \
Data.p##S[(p+1)*Channels + i], f); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter2PC(DryFilter, chans[i]*2, value); \
PendingClicks[chans[i]] += value*DrySend[chans[i]]; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
} \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
for(out = 0;out < MAX_SENDS;out++) \
{ \
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
ALfloat WetSend; \
ALfloat *WetBuffer; \
ALfloat *WetClickRemoval; \
ALfloat *WetPendingClicks; \
FILTER *WetFilter; \
\
if(!Source->Send[out].Slot || \
Source->Send[out].Slot->effect.type == AL_EFFECT_NULL) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
continue; \
\
Localize some variables to the mixer macros The hope here is to help break the mixer loops into separate functions, so the macro expansion doesn't cause the MixSource function to explode in size and kill compilation speed.
2010-09-25 06:24:01 +00:00
WetSend = Source->Params.WetGains[out]; \
WetBuffer = Source->Send[out].Slot->WetBuffer; \
WetClickRemoval = Source->Send[out].Slot->ClickRemoval; \
WetPendingClicks = Source->Send[out].Slot->PendingClicks; \
WetFilter = &Source->Params.Send[out].iirFilter; \
\
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
pos = DataPosInt; \
frac = DataPosFrac; \
j -= BufferSize; \
\
if(j == 0) \
{ \
for(i = 0;i < Channels;i++) \
{ \
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter1PC(WetFilter, chans[i], value); \
WetClickRemoval[0] -= value*WetSend * scaler; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
} \
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
{ \
for(i = 0;i < Channels;i++) \
{ \
value = sampler##S(Data.p##S[pos*Channels + i], \
Data.p##S[(pos+1)*Channels + i], frac); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter1P(WetFilter, chans[i], value); \
WetBuffer[j] += value*WetSend * scaler; \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
} \
\
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
j++; \
} \
if(j == SamplesToDo) \
{ \
ALuint p = pos; \
ALuint f = frac; \
Avoid sampling beyond the end of the loop
2010-09-25 06:32:50 +00:00
if(p >= LoopEnd) \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
{ \
ALuint64 pos64 = pos; \
pos64 <<= FRACTIONBITS; \
pos64 += frac; \
pos64 -= increment; \
p = pos64>>FRACTIONBITS; \
f = pos64&FRACTIONMASK; \
} \
for(i = 0;i < Channels;i++) \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
{ \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
value = sampler##S(Data.p##S[p*Channels + i], \
Data.p##S[(p+1)*Channels + i], f); \
\
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
value = lpFilter1PC(WetFilter, chans[i], value); \
WetPendingClicks[0] += value*WetSend * scaler; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
} \
} \
} \
Use separate mixing loops for the dry path and wet paths This will increase CPU use a bit for sources that use auxiliary sends (particularly with the cosine resampler), but it makes it more scalable when adding more sends per source. Additionally, it will improve performance of sources that don't use auxiliary sends. The cosine resampler can probably be improved by using a lookup table instead of calling cos() as there are 14 bits of fractional precision, so a 16384- element float array would cover it all. This can also be reduced to a half or quarter size if the precision loss is found to be acceptable.
2010-09-25 01:29:49 +00:00
DataPosInt = pos; \
DataPosFrac = frac; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
} while(0)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
#define MIX_MONO(S) do { \
Remove an unnecessary variable
2010-09-23 23:51:30 +00:00
switch(Source->Resampler) \
Compact some reused code
2010-09-23 01:49:46 +00:00
{ \
case POINT_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_MONO(S,point); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case LINEAR_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_MONO(S,lerp); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case COSINE_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_MONO(S,cos_lerp); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case RESAMPLER_MIN: \
case RESAMPLER_MAX: \
break; \
} \
} while(0)
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
#define MIX_STEREO(S) do { \
Compact some reused code
2010-09-23 01:49:46 +00:00
const int chans[] = { \
FRONT_LEFT, FRONT_RIGHT, \
SIDE_LEFT, SIDE_RIGHT, \
BACK_LEFT, BACK_RIGHT \
}; \
\
Remove an unnecessary variable
2010-09-23 23:51:30 +00:00
switch(Source->Resampler) \
Compact some reused code
2010-09-23 01:49:46 +00:00
{ \
case POINT_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_STEREO(S,point); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case LINEAR_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_STEREO(S,lerp); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case COSINE_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_STEREO(S,cos_lerp); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case RESAMPLER_MIN: \
case RESAMPLER_MAX: \
break; \
} \
} while(0)
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
#define MIX_MC(S,...) do { \
Compact some reused code
2010-09-23 01:49:46 +00:00
const int chans[] = { __VA_ARGS__ }; \
\
Remove an unnecessary variable
2010-09-23 23:51:30 +00:00
switch(Source->Resampler) \
Compact some reused code
2010-09-23 01:49:46 +00:00
{ \
case POINT_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_MC(S,point); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case LINEAR_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_MC(S,lerp); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case COSINE_RESAMPLER: \
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
DO_MIX_MC(S,cos_lerp); break; \
Compact some reused code
2010-09-23 01:49:46 +00:00
case RESAMPLER_MIN: \
case RESAMPLER_MAX: \
break; \
} \
} while(0)
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
#define MIX(S) do { \
if(Channels == 1) /* Mono */ \
MIX_MONO(S); \
else if(Channels == 2) /* Stereo */ \
MIX_STEREO(S); \
else if(Channels == 4) /* Quad */ \
MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
BACK_LEFT, BACK_RIGHT); \
else if(Channels == 6) /* 5.1 */ \
MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
Fix line indentation
2010-09-23 22:08:30 +00:00
BACK_LEFT, BACK_RIGHT); \
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
else if(Channels == 7) /* 6.1 */ \
MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_CENTER, \
SIDE_LEFT, SIDE_RIGHT); \
else if(Channels == 8) /* 7.1 */ \
MIX_MC(S, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_LEFT, BACK_RIGHT, \
SIDE_LEFT, SIDE_RIGHT); \
} while(0)
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALvoid MixSource(ALsource *Source, ALCdevice *Device, ALuint SamplesToDo)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
ALbufferlistitem *BufferListItem;
ALint64 DataSize64,DataPos64;
ALint increment;
ALuint DataPosInt, DataPosFrac;
ALuint BuffersPlayed;
ALboolean Looping;
ALenum State;
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint i, j;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
/* Get source info */
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
State = Source->state;
BuffersPlayed = Source->BuffersPlayed;
DataPosInt = Source->position;
DataPosFrac = Source->position_fraction;
Looping = Source->bLooping;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
/* Get fixed point step */
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
increment = Source->Params.Step;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
/* Get current buffer queue item */
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
BufferListItem = Source->queue;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
for(i = 0;i < BuffersPlayed;i++)
BufferListItem = BufferListItem->next;
j = 0;
do {
const ALbuffer *ALBuffer;
Allow accessing the buffer data as multiple data types in the mixer Also reduces a bunch of indentation
2010-09-23 00:19:35 +00:00
union {
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
ALfloat *p32;
ALshort *p16;
ALubyte *p8;
Allow accessing the buffer data as multiple data types in the mixer Also reduces a bunch of indentation
2010-09-23 00:19:35 +00:00
} Data = { NULL };
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
ALuint DataSize = 0;
ALuint LoopStart = 0;
ALuint LoopEnd = 0;
ALuint Channels, Bytes;
ALuint BufferSize;
/* Get buffer info */
if((ALBuffer=BufferListItem->buffer) != NULL)
{
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
Data.p8 = ALBuffer->data;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
DataSize = ALBuffer->size;
DataSize /= aluFrameSizeFromFormat(ALBuffer->format);
Channels = aluChannelsFromFormat(ALBuffer->format);
Bytes = aluBytesFromFormat(ALBuffer->format);
LoopStart = 0;
LoopEnd = DataSize;
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
if(Looping && Source->lSourceType == AL_STATIC)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
/* If current pos is beyond the loop range, do not loop */
if(DataPosInt >= LoopEnd)
Looping = AL_FALSE;
else
{
LoopStart = ALBuffer->LoopStart;
LoopEnd = ALBuffer->LoopEnd;
}
}
}
if(DataPosInt >= DataSize)
goto skipmix;
if(BufferListItem->next)
{
ALbuffer *NextBuf = BufferListItem->next->buffer;
if(NextBuf && NextBuf->size)
{
ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
ulExtraSamples = min(NextBuf->size, ulExtraSamples);
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
memcpy(&Data.p8[DataSize*Channels*Bytes],
Allow accessing the buffer data as multiple data types in the mixer Also reduces a bunch of indentation
2010-09-23 00:19:35 +00:00
NextBuf->data, ulExtraSamples);
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
}
}
else if(Looping)
{
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
ALbuffer *NextBuf = Source->queue->buffer;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
if(NextBuf && NextBuf->size)
{
ALint ulExtraSamples = BUFFER_PADDING*Channels*Bytes;
ulExtraSamples = min(NextBuf->size, ulExtraSamples);
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
memcpy(&Data.p8[DataSize*Channels*Bytes],
Allow accessing the buffer data as multiple data types in the mixer Also reduces a bunch of indentation
2010-09-23 00:19:35 +00:00
&((ALubyte*)NextBuf->data)[LoopStart*Channels*Bytes],
ulExtraSamples);
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
}
}
else
Allow the mixing loop to access the different sample formats
2010-09-23 03:53:04 +00:00
memset(&Data.p8[DataSize*Channels*Bytes], 0, (BUFFER_PADDING*Channels*Bytes));
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
/* Figure out how many samples we can mix. */
DataSize64 = LoopEnd;
DataSize64 <<= FRACTIONBITS;
DataPos64 = DataPosInt;
DataPos64 <<= FRACTIONBITS;
DataPos64 += DataPosFrac;
BufferSize = (ALuint)((DataSize64-DataPos64+(increment-1)) / increment);
BufferSize = min(BufferSize, (SamplesToDo-j));
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
if(Bytes == 4) /* 32-bit float */
MIX(32);
else if(Bytes == 2) /* signed 16-bit */
MIX(16);
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
skipmix:
/* Handle looping sources */
if(DataPosInt >= LoopEnd)
{
Clarify a check
2010-09-26 08:29:28 +00:00
if(BufferListItem->next)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
BufferListItem = BufferListItem->next;
BuffersPlayed++;
DataPosInt -= DataSize;
}
else if(Looping)
{
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
BufferListItem = Source->queue;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
BuffersPlayed = 0;
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
if(Source->lSourceType == AL_STATIC)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
else
DataPosInt -= DataSize;
}
else
{
State = AL_STOPPED;
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
BufferListItem = Source->queue;
BuffersPlayed = Source->BuffersInQueue;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
DataPosInt = 0;
DataPosFrac = 0;
}
}
} while(State == AL_PLAYING && j < SamplesToDo);
/* Update source info */
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
Source->state = State;
Source->BuffersPlayed = BuffersPlayed;
Source->position = DataPosInt;
Source->position_fraction = DataPosFrac;
Source->Buffer = BufferListItem->buffer;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
{
ALuint SamplesToDo;
ALeffectslot *ALEffectSlot;
Avoid using a single-letter iterator value
2010-09-09 21:53:14 +00:00
ALCcontext **ctx, **ctx_end;
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
ALsource **src, **src_end;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
ALfloat samp;
int fpuState;
ALuint i, j, c;
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
ALsizei e;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
#if defined(HAVE_FESETROUND)
fpuState = fegetround();
fesetround(FE_TOWARDZERO);
#elif defined(HAVE__CONTROLFP)
fpuState = _controlfp(0, 0);
_controlfp(_RC_CHOP, _MCW_RC);
#else
(void)fpuState;
#endif
while(size > 0)
{
/* Setup variables */
SamplesToDo = min(size, BUFFERSIZE);
/* Clear mixing buffer */
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
memset(device->DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
SuspendContext(NULL);
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
ctx = device->Contexts;
ctx_end = ctx + device->NumContexts;
while(ctx != ctx_end)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
Avoid using a single-letter iterator value
2010-09-09 21:53:14 +00:00
SuspendContext(*ctx);
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
src = (*ctx)->ActiveSources;
src_end = src + (*ctx)->ActiveSourceCount;
while(src != src_end)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
if((*src)->state != AL_PLAYING)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
--((*ctx)->ActiveSourceCount);
*src = *(--src_end);
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
continue;
}
Avoid updating the source in MixSource
2010-09-26 06:49:57 +00:00
if((*src)->NeedsUpdate)
{
ALsource_Update(*src, *ctx);
(*src)->NeedsUpdate = AL_FALSE;
}
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALsource_Mix(*src, device, SamplesToDo);
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
src++;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
/* effect slot processing */
Avoid using a single-letter iterator value
2010-09-09 21:53:14 +00:00
for(e = 0;e < (*ctx)->EffectSlotMap.size;e++)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
Avoid using a single-letter iterator value
2010-09-09 21:53:14 +00:00
ALEffectSlot = (*ctx)->EffectSlotMap.array[e].value;
Add click removal for wet sends
2010-08-15 21:52:12 +00:00
for(i = 0;i < SamplesToDo;i++)
{
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALEffectSlot->ClickRemoval[0] -= ALEffectSlot->ClickRemoval[0] / 256.0f;
ALEffectSlot->WetBuffer[i] += ALEffectSlot->ClickRemoval[0];
Add click removal for wet sends
2010-08-15 21:52:12 +00:00
}
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
for(i = 0;i < 1;i++)
{
ALEffectSlot->ClickRemoval[i] += ALEffectSlot->PendingClicks[i];
ALEffectSlot->PendingClicks[i] = 0.0f;
}
Add click removal for wet sends
2010-08-15 21:52:12 +00:00
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot,
SamplesToDo, ALEffectSlot->WetBuffer,
device->DryBuffer);
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
for(i = 0;i < SamplesToDo;i++)
ALEffectSlot->WetBuffer[i] = 0.0f;
}
Avoid using a single-letter iterator value
2010-09-09 21:53:14 +00:00
ProcessContext(*ctx);
Avoid another non-descript incrementing variable
2010-09-09 23:47:54 +00:00
ctx++;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
device->SamplesPlayed += SamplesToDo;
ProcessContext(NULL);
//Post processing loop
Add a corrective, click-remval sample value offset This will hopefully be more effective and rebust at removing clicks and pops, particularly from starts and stops in the middle of a sound. Based on an idea by Ben Davis.
2010-08-15 04:30:14 +00:00
for(i = 0;i < SamplesToDo;i++)
{
for(c = 0;c < OUTPUTCHANNELS;c++)
{
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
device->ClickRemoval[c] -= device->ClickRemoval[c] / 256.0f;
device->DryBuffer[i][c] += device->ClickRemoval[c];
Add a corrective, click-remval sample value offset This will hopefully be more effective and rebust at removing clicks and pops, particularly from starts and stops in the middle of a sound. Based on an idea by Ben Davis.
2010-08-15 04:30:14 +00:00
}
}
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
for(i = 0;i < OUTPUTCHANNELS;i++)
{
device->ClickRemoval[i] += device->PendingClicks[i];
device->PendingClicks[i] = 0.0f;
}
Add a corrective, click-remval sample value offset This will hopefully be more effective and rebust at removing clicks and pops, particularly from starts and stops in the middle of a sound. Based on an idea by Ben Davis.
2010-08-15 04:30:14 +00:00
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
switch(device->Format)
{
Avoid some code duplication
2010-09-26 03:18:07 +00:00
#define DO_WRITE(T, func, N, ...) do { \
const Channel chans[] = { \
__VA_ARGS__ \
}; \
ALfloat (*DryBuffer)[OUTPUTCHANNELS] = device->DryBuffer; \
ALfloat (*Matrix)[OUTPUTCHANNELS] = device->ChannelMatrix; \
const ALuint *ChanMap = device->DevChannels; \
\
for(i = 0;i < SamplesToDo;i++) \
{ \
for(j = 0;j < N;j++) \
{ \
samp = 0.0f; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
((T*)buffer)[ChanMap[chans[j]]] = func(samp); \
} \
buffer = ((T*)buffer) + N; \
} \
} while(0)
#define CHECK_WRITE_FORMAT(bits, T, func) \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
case AL_FORMAT_MONO##bits: \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
DO_WRITE(T, func, 1, FRONT_CENTER); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
break; \
case AL_FORMAT_STEREO##bits: \
if(device->Bs2b) \
{ \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
ALfloat (*DryBuffer)[OUTPUTCHANNELS] = device->DryBuffer; \
ALfloat (*Matrix)[OUTPUTCHANNELS] = device->ChannelMatrix; \
const ALuint *ChanMap = device->DevChannels; \
\
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
for(i = 0;i < SamplesToDo;i++) \
{ \
float samples[2] = { 0.0f, 0.0f }; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
{ \
samples[0] += DryBuffer[i][c]*Matrix[c][FRONT_LEFT]; \
samples[1] += DryBuffer[i][c]*Matrix[c][FRONT_RIGHT]; \
} \
bs2b_cross_feed(device->Bs2b, samples); \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
((T*)buffer)[ChanMap[FRONT_LEFT]] = func(samples[0]); \
((T*)buffer)[ChanMap[FRONT_RIGHT]] = func(samples[1]); \
buffer = ((T*)buffer) + 2; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
} \
} \
else \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
DO_WRITE(T, func, 2, FRONT_LEFT, FRONT_RIGHT); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
break; \
case AL_FORMAT_QUAD##bits: \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
DO_WRITE(T, func, 4, FRONT_LEFT, FRONT_RIGHT, \
BACK_LEFT, BACK_RIGHT); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
break; \
case AL_FORMAT_51CHN##bits: \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
DO_WRITE(T, func, 6, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_LEFT, BACK_RIGHT); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
break; \
case AL_FORMAT_61CHN##bits: \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
DO_WRITE(T, func, 7, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, BACK_CENTER, \
SIDE_LEFT, SIDE_RIGHT); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
break; \
case AL_FORMAT_71CHN##bits: \
Avoid some code duplication
2010-09-26 03:18:07 +00:00
DO_WRITE(T, func, 8, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_LEFT, BACK_RIGHT, \
SIDE_LEFT, SIDE_RIGHT); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
break;
#define AL_FORMAT_MONO32 AL_FORMAT_MONO_FLOAT32
#define AL_FORMAT_STEREO32 AL_FORMAT_STEREO_FLOAT32
CHECK_WRITE_FORMAT(8, ALubyte, aluF2UB)
CHECK_WRITE_FORMAT(16, ALshort, aluF2S)
CHECK_WRITE_FORMAT(32, ALfloat, aluF2F)
#undef AL_FORMAT_STEREO32
#undef AL_FORMAT_MONO32
#undef CHECK_WRITE_FORMAT
Avoid some code duplication
2010-09-26 03:18:07 +00:00
#undef DO_WRITE
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
default:
break;
}
size -= SamplesToDo;
}
#if defined(HAVE_FESETROUND)
fesetround(fpuState);
#elif defined(HAVE__CONTROLFP)
_controlfp(fpuState, 0xfffff);
#endif
}
Reference in New Issue Copy Permalink