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

731 lines
45 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"
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
{
Avoid temporary float variables
2010-11-21 11:58:37 +00:00
val1 += ((val2-val1) * (frac * (1.0/(1<<FRACTIONBITS))));
return val1;
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
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
{
Avoid temporary float variables
2010-11-21 11:58:37 +00:00
val1 += ((val2-val1) * ((1.0-cos(frac * (1.0/(1<<FRACTIONBITS)) * M_PI)) * 0.5));
return val1;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
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)
{
Avoid temporary float variables
2010-11-21 11:58:37 +00:00
val1 += (val2-val1) * (frac * (1.0/(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)
{
Avoid temporary float variables
2010-11-21 11:58:37 +00:00
val1 += (val2-val1) * ((1.0-cos(frac * (1.0/(1<<FRACTIONBITS)) * M_PI)) * 0.5);
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
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
#define DO_MIX_MONO(data,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
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos], data[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 */ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos], data[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; \
} \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[p], data[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 the number of sends the device is configured for in more places
2010-11-06 21:27:33 +00:00
for(out = 0;out < Device->NumAuxSends;out++) \
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
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
WetBuffer = Source->Send[out].Slot->WetBuffer; \
WetClickRemoval = Source->Send[out].Slot->ClickRemoval; \
WetPendingClicks = Source->Send[out].Slot->PendingClicks; \
WetFilter = &Source->Params.Send[out].iirFilter; \
Reorder some stored source params
2010-11-24 18:01:50 +00:00
WetSend = Source->Params.Send[out].WetGain; \
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
pos = DataPosInt; \
frac = DataPosFrac; \
j -= BufferSize; \
\
if(j == 0) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos], data[pos+1], frac); \
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 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 */ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos], data[pos+1], frac); \
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
\
/* 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; \
} \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[p], data[p+1], f); \
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 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)
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
#define DO_MIX_STEREO(data,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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[p*Channels + i], \
data[(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 the number of sends the device is configured for in more places
2010-11-06 21:27:33 +00:00
for(out = 0;out < Device->NumAuxSends;out++) \
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
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
WetBuffer = Source->Send[out].Slot->WetBuffer; \
WetClickRemoval = Source->Send[out].Slot->ClickRemoval; \
WetPendingClicks = Source->Send[out].Slot->PendingClicks; \
WetFilter = &Source->Params.Send[out].iirFilter; \
Reorder some stored source params
2010-11-24 18:01:50 +00:00
WetSend = Source->Params.Send[out].WetGain; \
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
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
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(pos+1)*Channels + i], frac); \
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 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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(pos+1)*Channels + i], frac); \
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 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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[p*Channels + i], \
data[(p+1)*Channels + i], f); \
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 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)
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
#define DO_MIX_MC(data,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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[p*Channels + i], \
data[(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 the number of sends the device is configured for in more places
2010-11-06 21:27:33 +00:00
for(out = 0;out < Device->NumAuxSends;out++) \
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
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
WetBuffer = Source->Send[out].Slot->WetBuffer; \
WetClickRemoval = Source->Send[out].Slot->ClickRemoval; \
WetPendingClicks = Source->Send[out].Slot->PendingClicks; \
WetFilter = &Source->Params.Send[out].iirFilter; \
Reorder some stored source params
2010-11-24 18:01:50 +00:00
WetSend = Source->Params.Send[out].WetGain; \
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
pos = DataPosInt; \
frac = DataPosFrac; \
j -= BufferSize; \
\
if(j == 0) \
{ \
for(i = 0;i < Channels;i++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(pos+1)*Channels + i], frac); \
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 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++) \
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[pos*Channels + i], \
data[(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
{ \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
value = sampler(data[p*Channels + i], \
data[(p+1)*Channels + i], f); \
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 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
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
#define MIX_MONO(sampler) do { \
if(Bytes == 4) \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
DO_MIX_MONO(Data.p32,sampler##32); \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
else if(Bytes == 2) \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
DO_MIX_MONO(Data.p16,sampler##16); \
Compact some reused code
2010-09-23 01:49:46 +00:00
} while(0)
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
#define MIX_STEREO(sampler) 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 \
}; \
\
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
if(Bytes == 4) \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
DO_MIX_STEREO(Data.p32,sampler##32); \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
else if(Bytes == 2) \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
DO_MIX_STEREO(Data.p16,sampler##16); \
Compact some reused code
2010-09-23 01:49:46 +00:00
} while(0)
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
#define MIX_MC(sampler,...) do { \
Compact some reused code
2010-09-23 01:49:46 +00:00
const int chans[] = { __VA_ARGS__ }; \
\
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
if(Bytes == 4) \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
DO_MIX_MC(Data.p32,sampler##32); \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
else if(Bytes == 2) \
Pass the data pointer and proper sampler to the mixer macro
2010-11-21 11:33:33 +00:00
DO_MIX_MC(Data.p16,sampler##16); \
Compact some reused code
2010-09-23 01:49:46 +00:00
} while(0)
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
#define MIX(sampler) do { \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
switch(Channels) \
{ \
case 1: /* Mono */ \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
MIX_MONO(sampler); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 2: /* Stereo */ \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
MIX_STEREO(sampler); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 4: /* Quad */ \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
MIX_MC(sampler, FRONT_LEFT, FRONT_RIGHT, \
BACK_LEFT, BACK_RIGHT); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 6: /* 5.1 */ \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
MIX_MC(sampler, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_LEFT, BACK_RIGHT); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 7: /* 6.1 */ \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
MIX_MC(sampler, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_CENTER, \
SIDE_LEFT, SIDE_RIGHT); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 8: /* 7.1 */ \
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
MIX_MC(sampler, FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_LEFT, BACK_RIGHT, \
SIDE_LEFT, SIDE_RIGHT); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
} \
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
} 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 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;
Make sure the buffer padding is always cleared before looking for the next buffer
2010-11-24 15:20:41 +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
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
}
}
/* Figure out how many samples we can mix. */
Get a variable where it's needed
2010-09-26 20:30:46 +00:00
increment = Source->Params.Step;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
DataSize64 = LoopEnd;
DataSize64 <<= FRACTIONBITS;
DataPos64 = DataPosInt;
DataPos64 <<= FRACTIONBITS;
DataPos64 += DataPosFrac;
BufferSize = (ALuint)((DataSize64-DataPos64+(increment-1)) / increment);
BufferSize = min(BufferSize, (SamplesToDo-j));
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
switch(Source->Resampler)
{
case POINT_RESAMPLER:
MIX(point); break;
case LINEAR_RESAMPLER:
MIX(lerp); break;
case COSINE_RESAMPLER:
MIX(cos_lerp); break;
case RESAMPLER_MIN:
case RESAMPLER_MAX:
break;
}
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
}
Reference in New Issue Copy Permalink