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

1003 lines
58 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;
else i = (ALint)(Value*32767.5f - 0.5f);
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)
{
return (val1+0.5f) / 32767.5f;
(void)val2;
(void)frac;
}
static __inline ALfloat lerp16(ALfloat val1, ALfloat val2, ALint frac)
{
val1 += ((val2-val1)*(frac * (1.0f/(1<<FRACTIONBITS))));
return (val1+0.5f) / 32767.5f;
}
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);
return (val1+0.5f) / 32767.5f;
}
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 { \
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 BufferIdx; \
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; \
\
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
\
Use click removal to handle harsh panning/volume changes
2010-08-15 07:19:38 +00:00
outsamp = lpFilter4PC(DryFilter, 0, value); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
ClickRemoval[FRONT_LEFT] -= outsamp*DrySend[FRONT_LEFT]; \
ClickRemoval[FRONT_RIGHT] -= outsamp*DrySend[FRONT_RIGHT]; \
ClickRemoval[SIDE_LEFT] -= outsamp*DrySend[SIDE_LEFT]; \
ClickRemoval[SIDE_RIGHT] -= outsamp*DrySend[SIDE_RIGHT]; \
ClickRemoval[BACK_LEFT] -= outsamp*DrySend[BACK_LEFT]; \
ClickRemoval[BACK_RIGHT] -= outsamp*DrySend[BACK_RIGHT]; \
ClickRemoval[FRONT_CENTER] -= outsamp*DrySend[FRONT_CENTER]; \
ClickRemoval[BACK_CENTER] -= outsamp*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 */ \
outsamp = lpFilter4P(DryFilter, 0, value); \
DryBuffer[j][FRONT_LEFT] += outsamp*DrySend[FRONT_LEFT]; \
DryBuffer[j][FRONT_RIGHT] += outsamp*DrySend[FRONT_RIGHT]; \
DryBuffer[j][SIDE_LEFT] += outsamp*DrySend[SIDE_LEFT]; \
DryBuffer[j][SIDE_RIGHT] += outsamp*DrySend[SIDE_RIGHT]; \
DryBuffer[j][BACK_LEFT] += outsamp*DrySend[BACK_LEFT]; \
DryBuffer[j][BACK_RIGHT] += outsamp*DrySend[BACK_RIGHT]; \
DryBuffer[j][FRONT_CENTER] += outsamp*DrySend[FRONT_CENTER]; \
DryBuffer[j][BACK_CENTER] += outsamp*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
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
\
outsamp = lpFilter4PC(DryFilter, 0, value); \
PendingClicks[FRONT_LEFT] += outsamp*DrySend[FRONT_LEFT]; \
PendingClicks[FRONT_RIGHT] += outsamp*DrySend[FRONT_RIGHT]; \
PendingClicks[SIDE_LEFT] += outsamp*DrySend[SIDE_LEFT]; \
PendingClicks[SIDE_RIGHT] += outsamp*DrySend[SIDE_RIGHT]; \
PendingClicks[BACK_LEFT] += outsamp*DrySend[BACK_LEFT]; \
PendingClicks[BACK_RIGHT] += outsamp*DrySend[BACK_RIGHT]; \
PendingClicks[FRONT_CENTER] += outsamp*DrySend[FRONT_CENTER]; \
PendingClicks[BACK_CENTER] += outsamp*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 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
outsamp = lpFilter2PC(WetFilter, 0, value); \
WetClickRemoval[0] -= outsamp*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 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
outsamp = lpFilter2P(WetFilter, 0, value); \
WetBuffer[j] += outsamp*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 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
outsamp = lpFilter2PC(WetFilter, 0, value); \
WetPendingClicks[0] += outsamp*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; \
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 BufferIdx; \
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; \
\
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
\
Use click removal to handle harsh panning/volume changes
2010-08-15 07:19:38 +00:00
outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
Combine two arrays into one
2010-08-16 23:07:44 +00:00
ClickRemoval[chans[i+0]] -= outsamp*DrySend[chans[i+0]]; \
ClickRemoval[chans[i+2]] -= outsamp*DrySend[chans[i+2]]; \
ClickRemoval[chans[i+4]] -= outsamp*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
\
Combine stereo and stereo-duplicate mixers Use a separate update method for stereo sources to the set appropriate channel gains
2010-08-05 08:07:20 +00:00
outsamp = lpFilter2P(DryFilter, chans[i]*2, value); \
Combine two arrays into one
2010-08-16 23:07:44 +00:00
DryBuffer[j][chans[i+0]] += outsamp*DrySend[chans[i+0]]; \
DryBuffer[j][chans[i+2]] += outsamp*DrySend[chans[i+2]]; \
DryBuffer[j][chans[i+4]] += outsamp*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
\
outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
Combine two arrays into one
2010-08-16 23:07:44 +00:00
PendingClicks[chans[i+0]] += outsamp*DrySend[chans[i+0]]; \
PendingClicks[chans[i+2]] += outsamp*DrySend[chans[i+2]]; \
PendingClicks[chans[i+4]] += outsamp*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 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
outsamp = lpFilter1PC(WetFilter, chans[i], value); \
WetClickRemoval[0] -= outsamp*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 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
outsamp = lpFilter1P(WetFilter, chans[i], value); \
WetBuffer[j] += outsamp*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 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
outsamp = lpFilter1PC(WetFilter, chans[i], value); \
WetPendingClicks[0] += outsamp*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; \
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 BufferIdx; \
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; \
\
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
\
Use click removal to handle harsh panning/volume changes
2010-08-15 07:19:38 +00:00
outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
ClickRemoval[chans[i]] -= outsamp*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
\
outsamp = lpFilter2P(DryFilter, chans[i]*2, value); \
DryBuffer[j][chans[i]] += outsamp*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
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
\
outsamp = lpFilter2PC(DryFilter, chans[i]*2, value); \
PendingClicks[chans[i]] += outsamp*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 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
outsamp = lpFilter1PC(WetFilter, chans[i], value); \
WetClickRemoval[0] -= outsamp*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 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
outsamp = lpFilter1P(WetFilter, chans[i], value); \
WetBuffer[j] += outsamp*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 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
outsamp = lpFilter1PC(WetFilter, chans[i], value); \
WetPendingClicks[0] += outsamp*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)
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
static void MixSource(ALsource *Source, ALCcontext *Context,
Use ALfloat for the dry mix buffer
2010-09-24 00:44:02 +00:00
ALfloat (*DryBuffer)[OUTPUTCHANNELS], ALuint SamplesToDo,
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
ALfloat *ClickRemoval, ALfloat *PendingClicks)
{
ALuint i, j, out;
ALfloat value, outsamp;
ALbufferlistitem *BufferListItem;
ALint64 DataSize64,DataPos64;
ALint increment;
ALuint DataPosInt, DataPosFrac;
ALuint BuffersPlayed;
ALboolean Looping;
ALenum State;
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
if(Source->NeedsUpdate)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
ALsource_Update(Source, Context);
Source->NeedsUpdate = AL_FALSE;
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)
{
Rename some variables to be less confusing
2010-09-23 23:49:33 +00:00
if(BuffersPlayed < (Source->BuffersInQueue-1))
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
#undef DO_MIX_MC
#undef DO_MIX_STEREO
#undef DO_MIX_MONO
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)
{
Use ALfloat for the dry mix buffer
2010-09-24 00:44:02 +00:00
ALfloat (*DryBuffer)[OUTPUTCHANNELS];
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
ALfloat (*Matrix)[OUTPUTCHANNELS];
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
ALfloat *ClickRemoval;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
const ALuint *ChanMap;
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
DryBuffer = device->DryBuffer;
while(size > 0)
{
/* Setup variables */
SamplesToDo = min(size, BUFFERSIZE);
/* Clear mixing buffer */
memset(DryBuffer, 0, SamplesToDo*OUTPUTCHANNELS*sizeof(ALfloat));
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;
}
Pass dry-path click buffers as parameters to MixSource
2010-09-12 06:43:12 +00:00
MixSource(*src, *ctx, DryBuffer, SamplesToDo,
device->ClickRemoval, device->PendingClicks);
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
ClickRemoval = ALEffectSlot->ClickRemoval;
for(i = 0;i < SamplesToDo;i++)
{
ClickRemoval[0] -= ClickRemoval[0] / 256.0f;
ALEffectSlot->WetBuffer[i] += ClickRemoval[0];
}
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
Effectslot's Effectstate should never be NULL
2010-08-06 11:52:34 +00:00
ALEffect_Process(ALEffectSlot->EffectState, ALEffectSlot, SamplesToDo, ALEffectSlot->WetBuffer, 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
ClickRemoval = device->ClickRemoval;
for(i = 0;i < SamplesToDo;i++)
{
for(c = 0;c < OUTPUTCHANNELS;c++)
{
ClickRemoval[c] -= ClickRemoval[c] / 256.0f;
DryBuffer[i][c] += ClickRemoval[c];
}
}
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
ChanMap = device->DevChannels;
Matrix = device->ChannelMatrix;
switch(device->Format)
{
#define CHECK_WRITE_FORMAT(bits, type, func) \
case AL_FORMAT_MONO##bits: \
for(i = 0;i < SamplesToDo;i++) \
{ \
samp = 0.0f; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
samp += DryBuffer[i][c] * Matrix[c][FRONT_CENTER]; \
((type*)buffer)[ChanMap[FRONT_CENTER]] = (func)(samp); \
buffer = ((type*)buffer) + 1; \
} \
break; \
case AL_FORMAT_STEREO##bits: \
if(device->Bs2b) \
{ \
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); \
((type*)buffer)[ChanMap[FRONT_LEFT]] = (func)(samples[0]);\
((type*)buffer)[ChanMap[FRONT_RIGHT]]= (func)(samples[1]);\
buffer = ((type*)buffer) + 2; \
} \
} \
else \
{ \
for(i = 0;i < SamplesToDo;i++) \
{ \
static const Channel chans[] = { \
FRONT_LEFT, FRONT_RIGHT \
}; \
for(j = 0;j < 2;j++) \
{ \
samp = 0.0f; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
} \
buffer = ((type*)buffer) + 2; \
} \
} \
break; \
case AL_FORMAT_QUAD##bits: \
for(i = 0;i < SamplesToDo;i++) \
{ \
static const Channel chans[] = { \
FRONT_LEFT, FRONT_RIGHT, \
BACK_LEFT, BACK_RIGHT, \
}; \
for(j = 0;j < 4;j++) \
{ \
samp = 0.0f; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
} \
buffer = ((type*)buffer) + 4; \
} \
break; \
case AL_FORMAT_51CHN##bits: \
for(i = 0;i < SamplesToDo;i++) \
{ \
static const Channel chans[] = { \
FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_LEFT, BACK_RIGHT, \
}; \
for(j = 0;j < 6;j++) \
{ \
samp = 0.0f; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
} \
buffer = ((type*)buffer) + 6; \
} \
break; \
case AL_FORMAT_61CHN##bits: \
for(i = 0;i < SamplesToDo;i++) \
{ \
static const Channel chans[] = { \
FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, BACK_CENTER, \
SIDE_LEFT, SIDE_RIGHT, \
}; \
for(j = 0;j < 7;j++) \
{ \
samp = 0.0f; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
} \
buffer = ((type*)buffer) + 7; \
} \
break; \
case AL_FORMAT_71CHN##bits: \
for(i = 0;i < SamplesToDo;i++) \
{ \
static const Channel chans[] = { \
FRONT_LEFT, FRONT_RIGHT, \
FRONT_CENTER, LFE, \
BACK_LEFT, BACK_RIGHT, \
SIDE_LEFT, SIDE_RIGHT \
}; \
for(j = 0;j < 8;j++) \
{ \
samp = 0.0f; \
for(c = 0;c < OUTPUTCHANNELS;c++) \
samp += DryBuffer[i][c] * Matrix[c][chans[j]]; \
((type*)buffer)[ChanMap[chans[j]]] = (func)(samp); \
} \
buffer = ((type*)buffer) + 8; \
} \
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
default:
break;
}
size -= SamplesToDo;
}
#if defined(HAVE_FESETROUND)
fesetround(fpuState);
#elif defined(HAVE__CONTROLFP)
_controlfp(fpuState, 0xfffff);
#endif
}
Reference in New Issue Copy Permalink