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

984 lines
53 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"
Double-up the interpolation functions (and make them use doubles)
2010-11-25 21:45:35 +00:00
static __inline ALdouble lerp(ALdouble val1, ALdouble 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
}
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble cubic(ALdouble val0, ALdouble val1, ALdouble val2, ALdouble val3, ALint frac)
{
ALdouble mu = frac * (1.0/(1<<FRACTIONBITS));
ALdouble mu2 = mu*mu;
ALdouble a0 = -0.5*val0 + 1.5*val1 + -1.5*val2 + 0.5*val3;
ALdouble a1 = val0 + -2.5*val1 + 2.0*val2 + -0.5*val3;
ALdouble a2 = -0.5*val0 + 0.5*val2;
ALdouble a3 = val1;
return a0*mu*mu2 + a1*mu2 + a2*mu + a3;
}
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble point32(const ALfloat *vals, ALint step, ALint frac)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
{ return vals[0]; (void)step; (void)frac; }
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble lerp32(const ALfloat *vals, ALint step, ALint frac)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
{ return lerp(vals[0], vals[step], frac); }
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble cubic32(const ALfloat *vals, ALint step, ALint frac)
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step], frac); }
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble point16(const ALshort *vals, ALint step, ALint frac)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
{ return vals[0] / 32767.0; (void)step; (void)frac; }
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble lerp16(const ALshort *vals, ALint step, ALint frac)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
{ return lerp(vals[0], vals[step], frac) / 32767.0; }
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble cubic16(const ALshort *vals, ALint step, ALint frac)
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step], frac) / 32767.0; }
Double-up the interpolation functions (and make them use doubles)
2010-11-25 21:45:35 +00:00
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble point8(const ALubyte *vals, ALint step, ALint frac)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
{ return (vals[0]-128.0) / 127.0; (void)step; (void)frac; }
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble lerp8(const ALubyte *vals, ALint step, ALint frac)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
{ return (lerp(vals[0], vals[step], frac)-128.0) / 127.0; }
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble cubic8(const ALubyte *vals, ALint step, ALint frac)
{ return (cubic(vals[-step], vals[0], vals[step], vals[step+step], frac)-128.0) / 127.0; }
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#define DECL_TEMPLATE(T, sampler) \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
static void Mix_##T##_Mono_##sampler(ALsource *Source, ALCdevice *Device, \
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
const T *data, ALuint *DataPosInt, ALuint *DataPosFrac, \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
ALuint j, ALuint SamplesToDo, ALuint BufferSize) \
{ \
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; \
Set mixer sample pos and frac when needed
2010-11-24 22:54:46 +00:00
ALuint pos, 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
ALfloat DrySend[OUTPUTCHANNELS]; \
FILTER *DryFilter; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint BufferIdx; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
ALuint increment; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
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
\
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
increment = Source->Params.Step; \
\
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]; \
\
Use 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
pos = 0; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
frac = *DataPosFrac; \
Set mixer sample pos and frac when needed
2010-11-24 22:54:46 +00:00
\
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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(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) \
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(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); \
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 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
pos = 0; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
frac = *DataPosFrac; \
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
j -= BufferSize; \
\
if(j == 0) \
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(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
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(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); \
WetPendingClicks[0] += value*WetSend; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
} \
} \
Use 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
*DataPosInt += pos; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
*DataPosFrac = frac; \
}
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
DECL_TEMPLATE(ALfloat, point32)
DECL_TEMPLATE(ALfloat, lerp32)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALfloat, cubic32)
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALshort, point16)
DECL_TEMPLATE(ALshort, lerp16)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALshort, cubic16)
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALubyte, point8)
DECL_TEMPLATE(ALubyte, lerp8)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALubyte, cubic8)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#undef DECL_TEMPLATE
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#define DECL_TEMPLATE(T, sampler) \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
static void Mix_##T##_Stereo_##sampler(ALsource *Source, ALCdevice *Device, \
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
const T *data, ALuint *DataPosInt, ALuint *DataPosFrac, \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
ALuint j, ALuint SamplesToDo, ALuint BufferSize) \
{ \
static const ALuint Channels = 2; \
static const Channel chans[] = { \
FRONT_LEFT, FRONT_RIGHT, \
SIDE_LEFT, SIDE_RIGHT, \
BACK_LEFT, BACK_RIGHT \
}; \
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; \
Set mixer sample pos and frac when needed
2010-11-24 22:54:46 +00:00
ALuint pos, 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
ALfloat DrySend[OUTPUTCHANNELS]; \
FILTER *DryFilter; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint BufferIdx; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
ALuint increment; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
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
\
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
increment = Source->Params.Step; \
\
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]; \
\
Use 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
pos = 0; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
frac = *DataPosFrac; \
Set mixer sample pos and frac when needed
2010-11-24 22:54:46 +00:00
\
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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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) \
{ \
for(i = 0;i < Channels;i++) \
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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 = 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 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
pos = 0; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
frac = *DataPosFrac; \
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
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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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) \
{ \
for(i = 0;i < Channels;i++) \
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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); \
WetPendingClicks[0] += value*WetSend * scaler; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
} \
} \
} \
Use 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
*DataPosInt += pos; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
*DataPosFrac = frac; \
}
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
DECL_TEMPLATE(ALfloat, point32)
DECL_TEMPLATE(ALfloat, lerp32)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALfloat, cubic32)
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALshort, point16)
DECL_TEMPLATE(ALshort, lerp16)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALshort, cubic16)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALubyte, point8)
DECL_TEMPLATE(ALubyte, lerp8)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALubyte, cubic8)
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#undef DECL_TEMPLATE
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#define DECL_TEMPLATE(T, chans, sampler) \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
static void Mix_##T##_##chans##_##sampler(ALsource *Source, ALCdevice *Device,\
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
const T *data, ALuint *DataPosInt, ALuint *DataPosFrac, \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
ALuint j, ALuint SamplesToDo, ALuint BufferSize) \
{ \
static const ALuint Channels = sizeof(chans)/sizeof(chans[0]); \
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; \
Set mixer sample pos and frac when needed
2010-11-24 22:54:46 +00:00
ALuint pos, 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
ALfloat DrySend[OUTPUTCHANNELS]; \
FILTER *DryFilter; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint BufferIdx; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
ALuint increment; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
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
\
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
increment = Source->Params.Step; \
\
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]; \
\
Use 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
pos = 0; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
frac = *DataPosFrac; \
Set mixer sample pos and frac when needed
2010-11-24 22:54:46 +00:00
\
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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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) \
{ \
for(i = 0;i < Channels;i++) \
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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 = 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 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
pos = 0; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
frac = *DataPosFrac; \
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
j -= BufferSize; \
\
if(j == 0) \
{ \
for(i = 0;i < Channels;i++) \
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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 a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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) \
{ \
for(i = 0;i < Channels;i++) \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
{ \
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
value = sampler(data + pos*Channels + i, Channels, 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); \
WetPendingClicks[0] += value*WetSend * scaler; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
} \
} \
} \
Use 0-based access for the buffer data
2010-11-25 04:44:21 +00:00
*DataPosInt += pos; \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
*DataPosFrac = frac; \
}
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
static const Channel QuadChans[] = { FRONT_LEFT, FRONT_RIGHT,
BACK_LEFT, BACK_RIGHT };
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
DECL_TEMPLATE(ALfloat, QuadChans, point32)
DECL_TEMPLATE(ALfloat, QuadChans, lerp32)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALfloat, QuadChans, cubic32)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALshort, QuadChans, point16)
DECL_TEMPLATE(ALshort, QuadChans, lerp16)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALshort, QuadChans, cubic16)
Compact some reused code
2010-09-23 01:49:46 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALubyte, QuadChans, point8)
DECL_TEMPLATE(ALubyte, QuadChans, lerp8)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALubyte, QuadChans, cubic8)
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Compact some reused code
2010-09-23 01:49:46 +00:00
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
static const Channel X51Chans[] = { FRONT_LEFT, FRONT_RIGHT,
FRONT_CENTER, LFE,
BACK_LEFT, BACK_RIGHT };
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
DECL_TEMPLATE(ALfloat, X51Chans, point32)
DECL_TEMPLATE(ALfloat, X51Chans, lerp32)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALfloat, X51Chans, cubic32)
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALshort, X51Chans, point16)
DECL_TEMPLATE(ALshort, X51Chans, lerp16)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALshort, X51Chans, cubic16)
Compact some reused code
2010-09-23 01:49:46 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALubyte, X51Chans, point8)
DECL_TEMPLATE(ALubyte, X51Chans, lerp8)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALubyte, X51Chans, cubic8)
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Compact some reused code
2010-09-23 01:49:46 +00:00
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
static const Channel X61Chans[] = { FRONT_LEFT, FRONT_RIGHT,
FRONT_CENTER, LFE,
BACK_CENTER,
SIDE_LEFT, SIDE_RIGHT };
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
DECL_TEMPLATE(ALfloat, X61Chans, point32)
DECL_TEMPLATE(ALfloat, X61Chans, lerp32)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALfloat, X61Chans, cubic32)
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALshort, X61Chans, point16)
DECL_TEMPLATE(ALshort, X61Chans, lerp16)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALshort, X61Chans, cubic16)
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALubyte, X61Chans, point8)
DECL_TEMPLATE(ALubyte, X61Chans, lerp8)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALubyte, X61Chans, cubic8)
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
static const Channel X71Chans[] = { FRONT_LEFT, FRONT_RIGHT,
FRONT_CENTER, LFE,
BACK_LEFT, BACK_RIGHT,
SIDE_LEFT, SIDE_RIGHT };
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
DECL_TEMPLATE(ALfloat, X71Chans, point32)
DECL_TEMPLATE(ALfloat, X71Chans, lerp32)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALfloat, X71Chans, cubic32)
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALshort, X71Chans, point16)
DECL_TEMPLATE(ALshort, X71Chans, lerp16)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALshort, X71Chans, cubic16)
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALubyte, X71Chans, point8)
DECL_TEMPLATE(ALubyte, X71Chans, lerp8)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALubyte, X71Chans, cubic8)
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#undef DECL_TEMPLATE
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#define DECL_TEMPLATE(T, sampler) \
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
static void Mix_##T##_##sampler(ALsource *Source, ALCdevice *Device, ALuint Channels, \
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
const ALvoid *Data, ALuint *DataPosInt, ALuint *DataPosFrac, \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
ALuint j, ALuint SamplesToDo, ALuint BufferSize) \
{ \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
switch(Channels) \
{ \
case 1: /* Mono */ \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
Mix_##T##_Mono_##sampler(Source, Device, \
Data, DataPosInt, DataPosFrac, \
j, SamplesToDo, BufferSize); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 2: /* Stereo */ \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
Mix_##T##_Stereo_##sampler(Source, Device, \
Data, DataPosInt, DataPosFrac, \
j, SamplesToDo, BufferSize); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 4: /* Quad */ \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
Mix_##T##_QuadChans_##sampler(Source, Device, \
Data, DataPosInt, DataPosFrac, \
j, SamplesToDo, BufferSize); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 6: /* 5.1 */ \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
Mix_##T##_X51Chans_##sampler(Source, Device, \
Data, DataPosInt, DataPosFrac, \
j, SamplesToDo, BufferSize); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 7: /* 6.1 */ \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
Mix_##T##_X61Chans_##sampler(Source, Device, \
Data, DataPosInt, DataPosFrac, \
j, SamplesToDo, BufferSize); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
case 8: /* 7.1 */ \
Rename some "template" functions
2010-11-25 21:22:54 +00:00
Mix_##T##_X71Chans_##sampler(Source, Device, \
Data, DataPosInt, DataPosFrac, \
j, SamplesToDo, BufferSize); \
Use a switch to select the appropriate channel-count mixer
2010-11-06 19:21:46 +00:00
break; \
} \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
}
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
DECL_TEMPLATE(ALfloat, point32)
DECL_TEMPLATE(ALfloat, lerp32)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALfloat, cubic32)
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALshort, point16)
DECL_TEMPLATE(ALshort, lerp16)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALshort, cubic16)
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
DECL_TEMPLATE(ALubyte, point8)
DECL_TEMPLATE(ALubyte, lerp8)
Add a cubic resampler
2010-11-26 07:05:44 +00:00
DECL_TEMPLATE(ALubyte, cubic8)
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
Minor rework of the template macros
2010-11-25 22:07:52 +00:00
#undef DECL_TEMPLATE
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
/* Stack data size can be whatever. Larger values need more stack, while
* smaller values may need more iterations */
#ifndef STACK_DATA_SIZE
#define STACK_DATA_SIZE 16384
#endif
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;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
ALuint FrameSize, Channels, Bytes;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
ALuint DataPosInt, DataPosFrac;
ALuint BuffersPlayed;
ALboolean Looping;
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
ALuint increment;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
ALenum State;
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
ALuint i, j;
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
ALint64 DataSize64;
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 a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
increment = Source->Params.Step;
/* Get buffer info */
FrameSize = Channels = Bytes = 0;
BufferListItem = Source->queue;
for(i = 0;i < Source->BuffersInQueue;i++)
{
const ALbuffer *ALBuffer;
if((ALBuffer=BufferListItem->buffer) != NULL)
{
FrameSize = aluFrameSizeFromFormat(ALBuffer->format);
Channels = aluChannelsFromFormat(ALBuffer->format);
Bytes = aluBytesFromFormat(ALBuffer->format);
break;
}
BufferListItem = BufferListItem->next;
}
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 {
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
ALubyte StackData[STACK_DATA_SIZE];
ALubyte *SrcData = StackData;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
ALuint SrcDataSize = 0;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
ALuint BufferSize;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
/* Figure out how many buffer bytes will be needed */
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
DataSize64 = SamplesToDo-j+1;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
DataSize64 *= increment;
DataSize64 += DataPosFrac+FRACTIONMASK;
DataSize64 >>= FRACTIONBITS;
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
DataSize64 += BUFFER_PADDING+BUFFER_PREPADDING;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
DataSize64 *= FrameSize;
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
BufferSize = min(DataSize64, STACK_DATA_SIZE);
Make sure the target buffer size is frame aligned
2010-11-25 22:23:03 +00:00
BufferSize -= BufferSize%FrameSize;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
if(Source->lSourceType == AL_STATIC)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
const ALbuffer *ALBuffer = Source->Buffer;
const ALubyte *Data = ALBuffer->data;
ALuint DataSize;
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
ALuint pos;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
/* If current pos is beyond the loop range, do not loop */
if(Looping == AL_FALSE || DataPosInt >= (ALuint)ALBuffer->LoopEnd)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
Looping = AL_FALSE;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
if(DataPosInt >= BUFFER_PREPADDING)
pos = (DataPosInt-BUFFER_PREPADDING)*FrameSize;
else
{
DataSize = (BUFFER_PREPADDING-DataPosInt)*FrameSize;
DataSize = min(BufferSize, DataSize);
memset(&SrcData[SrcDataSize], (Bytes==1)?0x80:0, DataSize);
SrcDataSize += DataSize;
BufferSize -= DataSize;
pos = 0;
}
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
/* Copy what's left to play in the source buffer, and clear the
* rest of the temp buffer */
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
DataSize = ALBuffer->size - pos;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
DataSize = min(BufferSize, DataSize);
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
memcpy(&SrcData[SrcDataSize], &Data[pos], DataSize);
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
SrcDataSize += DataSize;
BufferSize -= DataSize;
memset(&SrcData[SrcDataSize], (Bytes==1)?0x80:0, BufferSize);
SrcDataSize += BufferSize;
BufferSize -= BufferSize;
}
else
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
ALuint LoopStart = ALBuffer->LoopStart;
ALuint LoopEnd = ALBuffer->LoopEnd;
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
if(DataPosInt >= LoopStart)
{
pos = DataPosInt-LoopStart;
while(pos < BUFFER_PREPADDING)
pos += LoopEnd-LoopStart;
pos -= BUFFER_PREPADDING;
pos += LoopStart;
pos *= FrameSize;
}
else if(DataPosInt >= BUFFER_PREPADDING)
pos = (DataPosInt-BUFFER_PREPADDING)*FrameSize;
else
{
DataSize = (BUFFER_PREPADDING-DataPosInt)*FrameSize;
DataSize = min(BufferSize, DataSize);
memset(&SrcData[SrcDataSize], (Bytes==1)?0x80:0, DataSize);
SrcDataSize += DataSize;
BufferSize -= DataSize;
pos = 0;
}
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
/* Copy what's left of this loop iteration, then copy repeats
* of the loop section */
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
DataSize = LoopEnd*FrameSize - pos;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
DataSize = min(BufferSize, DataSize);
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
memcpy(&SrcData[SrcDataSize], &Data[pos], DataSize);
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
SrcDataSize += DataSize;
BufferSize -= DataSize;
DataSize = (LoopEnd-LoopStart) * FrameSize;
while(BufferSize > 0)
{
DataSize = min(BufferSize, DataSize);
memcpy(&SrcData[SrcDataSize], &Data[LoopStart*FrameSize], DataSize);
SrcDataSize += DataSize;
BufferSize -= DataSize;
}
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
}
}
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
else
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
/* Crawl the buffer queue to fill in the temp buffer */
ALbufferlistitem *BufferListIter = BufferListItem;
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
ALuint pos;
if(DataPosInt >= BUFFER_PREPADDING)
pos = (DataPosInt-BUFFER_PREPADDING)*FrameSize;
else
{
pos = (BUFFER_PREPADDING-DataPosInt)*FrameSize;
while(pos > 0)
{
if(!BufferListIter->prev && !Looping)
{
ALuint DataSize = min(BufferSize, pos);
memset(&SrcData[SrcDataSize], (Bytes==1)?0x80:0, DataSize);
SrcDataSize += DataSize;
BufferSize -= DataSize;
pos = 0;
break;
}
if(Looping)
{
while(BufferListIter->next)
BufferListIter = BufferListIter->next;
}
else
BufferListIter = BufferListIter->prev;
if(BufferListIter->buffer)
{
if((ALuint)BufferListIter->buffer->size > pos)
{
pos = BufferListIter->buffer->size - pos;
break;
}
pos -= BufferListIter->buffer->size;
}
}
}
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
while(BufferListIter && BufferSize > 0)
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
{
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
const ALbuffer *ALBuffer;
if((ALBuffer=BufferListIter->buffer) != NULL)
{
const ALubyte *Data = ALBuffer->data;
ALuint DataSize = ALBuffer->size;
/* Skip the data already played */
if(DataSize <= pos)
pos -= DataSize;
else
{
Data += pos;
DataSize -= pos;
pos -= pos;
DataSize = min(BufferSize, DataSize);
memcpy(&SrcData[SrcDataSize], Data, DataSize);
SrcDataSize += DataSize;
BufferSize -= DataSize;
}
}
BufferListIter = BufferListIter->next;
if(!BufferListIter && Looping)
BufferListIter = Source->queue;
else if(!BufferListIter)
{
memset(&SrcData[SrcDataSize], (Bytes==1)?0x80:0, BufferSize);
SrcDataSize += BufferSize;
BufferSize -= BufferSize;
}
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
}
}
/* Figure out how many samples we can mix. */
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
DataSize64 = SrcDataSize / FrameSize;
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
DataSize64 -= BUFFER_PADDING+BUFFER_PREPADDING;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
DataSize64 <<= FRACTIONBITS;
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
DataSize64 -= increment;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
BufferSize = (ALuint)((DataSize64-DataPosFrac+(increment-1)) / increment);
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
BufferSize = min(BufferSize, (SamplesToDo-j));
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
if(BufferSize == 0)
{
AL_PRINT("No samples to mix! Pitch too high (%u, %g)?\n",
increment, increment/(double)(1<<FRACTIONBITS));
State = AL_STOPPED;
BufferListItem = Source->queue;
BuffersPlayed = Source->BuffersInQueue;
DataPosInt = 0;
DataPosFrac = 0;
break;
}
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Add "pre-padding" to the temp buffer This will help to implement resamplers that want previous samples
2010-11-26 05:42:15 +00:00
SrcData += BUFFER_PREPADDING*FrameSize;
Force the point resampler when the source plays at normal speed
2010-11-26 06:15:38 +00:00
switch((increment != (1<<FRACTIONBITS)) ? Source->Resampler : POINT_RESAMPLER)
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
{
case POINT_RESAMPLER:
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
if(Bytes == 4)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
Mix_ALfloat_point32(Source, Device, Channels,
SrcData, &DataPosInt, &DataPosFrac,
j, SamplesToDo, BufferSize);
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
else if(Bytes == 2)
Mix_ALshort_point16(Source, Device, Channels,
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
SrcData, &DataPosInt, &DataPosFrac,
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
j, SamplesToDo, BufferSize);
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
else if(Bytes == 1)
Mix_ALubyte_point8(Source, Device, Channels,
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
SrcData, &DataPosInt, &DataPosFrac,
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
j, SamplesToDo, BufferSize);
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
break;
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
case LINEAR_RESAMPLER:
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
if(Bytes == 4)
Pass a pointer to the samplers so they can read just the samples they need
2010-11-26 06:04:17 +00:00
Mix_ALfloat_lerp32(Source, Device, Channels,
SrcData, &DataPosInt, &DataPosFrac,
j, SamplesToDo, BufferSize);
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
else if(Bytes == 2)
Mix_ALshort_lerp16(Source, Device, Channels,
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
SrcData, &DataPosInt, &DataPosFrac,
Check the sample byte size after the resampler
2010-11-25 01:23:09 +00:00
j, SamplesToDo, BufferSize);
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
else if(Bytes == 1)
Mix_ALubyte_lerp8(Source, Device, Channels,
Always make sure there's a sample available to mix, for pending click removal
2010-11-25 21:17:51 +00:00
SrcData, &DataPosInt, &DataPosFrac,
Support 8-bit sample data in the mixer
2010-11-25 03:41:25 +00:00
j, SamplesToDo, BufferSize);
Add a missing break statement
2010-11-26 07:13:50 +00:00
break;
Add a cubic resampler
2010-11-26 07:05:44 +00:00
case CUBIC_RESAMPLER:
if(Bytes == 4)
Mix_ALfloat_cubic32(Source, Device, Channels,
SrcData, &DataPosInt, &DataPosFrac,
j, SamplesToDo, BufferSize);
else if(Bytes == 2)
Mix_ALshort_cubic16(Source, Device, Channels,
SrcData, &DataPosInt, &DataPosFrac,
j, SamplesToDo, BufferSize);
else if(Bytes == 1)
Mix_ALubyte_cubic8(Source, Device, Channels,
SrcData, &DataPosInt, &DataPosFrac,
j, SamplesToDo, BufferSize);
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
break;
Check resampler mode first when selecting the mixer
2010-09-26 20:53:02 +00:00
case RESAMPLER_MIN:
case RESAMPLER_MAX:
break;
}
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
j += BufferSize;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
/* Handle looping sources */
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
while(1)
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
{
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
const ALbuffer *ALBuffer;
ALuint DataSize = 0;
ALuint LoopStart = 0;
ALuint LoopEnd = 0;
if((ALBuffer=BufferListItem->buffer) != NULL)
{
DataSize = ALBuffer->size / FrameSize;
if(DataSize > DataPosInt)
break;
LoopStart = ALBuffer->LoopStart;
LoopEnd = ALBuffer->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++;
}
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)
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
{
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
break;
}
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
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;
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
break;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
Use a temporary stack buffer to store the source buffer data to be mixed This makes it much easier to pack the playable buffer data so that it's a continuous data stream. This could normally be broken up otherwise, such as when using loop points or small queued buffers. Currently it defaults to a 16KB stack buffer, but this can be overridden at compile time.
2010-11-25 19:16:19 +00:00
DataPosInt -= DataSize;
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
} 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