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

808 lines
42 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"
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)
Make a FRACTIONONE macro, and use it
2010-11-26 09:21:46 +00:00
{ return lerp(vals[0], vals[step], frac * (1.0/FRACTIONONE)); }
Add a cubic resampler
2010-11-26 07:05:44 +00:00
static __inline ALdouble cubic32(const ALfloat *vals, ALint step, ALint frac)
Share the interpolation functions and use them in the reverb effect
2010-11-26 09:07:54 +00:00
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step],
Make a FRACTIONONE macro, and use it
2010-11-26 09:21:46 +00:00
frac * (1.0/FRACTIONONE)); }
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)
Convert a few divisions to multiplications
2010-11-26 09:35:40 +00:00
{ return vals[0] * (1.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)
Convert a few divisions to multiplications
2010-11-26 09:35:40 +00:00
{ return lerp(vals[0], vals[step], frac * (1.0/FRACTIONONE)) * (1.0/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)
Share the interpolation functions and use them in the reverb effect
2010-11-26 09:07:54 +00:00
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step],
Convert a few divisions to multiplications
2010-11-26 09:35:40 +00:00
frac * (1.0/FRACTIONONE)) * (1.0/32767.0); }
Double-up the interpolation functions (and make them use doubles)
2010-11-25 21:45:35 +00:00
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
static __inline ALdouble point8(const ALbyte *vals, ALint step, ALint frac)
{ return vals[0] * (1.0/127.0); (void)step; (void)frac; }
static __inline ALdouble lerp8(const ALbyte *vals, ALint step, ALint frac)
{ return lerp(vals[0], vals[step], frac * (1.0/FRACTIONONE)) * (1.0/127.0); }
static __inline ALdouble cubic8(const ALbyte *vals, ALint step, ALint frac)
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step],
frac * (1.0/FRACTIONONE)) * (1.0/127.0); }
Store and mix signed 16-bit samples
2010-09-23 06:38:06 +00:00
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
#ifdef __GNUC__
#define LIKELY(x) __builtin_expect(!!(x), 1)
#define UNLIKELY(x) __builtin_expect(!!(x), 0)
#else
#define LIKELY(x) (x)
#define UNLIKELY(x) (x)
#endif
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
#define DECL_TEMPLATE(T, sampler) \
static void Mix_Hrtf_##T##_##sampler(ALsource *Source, ALCdevice *Device, \
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
const ALvoid *srcdata, ALuint *DataPosInt, ALuint *DataPosFrac, \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
ALuint OutPos, ALuint SamplesToDo, ALuint BufferSize) \
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
const ALuint NumChannels = Source->NumChannels; \
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
const T *RESTRICT data = srcdata; \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
const ALint *RESTRICT DelayStep = Source->Params.HrtfDelayStep; \
Mark some mixer pointers as restricted
2011-05-03 00:14:57 +00:00
ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS]; \
ALfloat *RESTRICT ClickRemoval, *RESTRICT PendingClicks; \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
ALfloat (*RESTRICT CoeffStep)[2] = Source->Params.HrtfCoeffStep; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
ALuint pos, frac; \
FILTER *DryFilter; \
ALuint BufferIdx; \
ALuint increment; \
ALuint i, out, c; \
ALfloat value; \
\
increment = Source->Params.Step; \
\
DryBuffer = Device->DryBuffer; \
ClickRemoval = Device->ClickRemoval; \
PendingClicks = Device->PendingClicks; \
DryFilter = &Source->Params.iirFilter; \
\
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
pos = 0; \
frac = *DataPosFrac; \
\
for(i = 0;i < NumChannels;i++) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
ALfloat (*RESTRICT TargetCoeffs)[2] = Source->Params.HrtfCoeffs[i]; \
ALuint *RESTRICT TargetDelay = Source->Params.HrtfDelay[i]; \
Use separate lines for HRTF history and values
2011-06-17 23:22:39 +00:00
ALfloat *RESTRICT History = Source->HrtfHistory[i]; \
ALfloat (*RESTRICT Values)[2] = Source->HrtfValues[i]; \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
ALint Counter = __max(Source->HrtfCounter, OutPos) - OutPos; \
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
ALuint Offset = Source->HrtfOffset + OutPos; \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
ALfloat Coeffs[HRIR_LENGTH][2]; \
ALuint Delay[2]; \
Properly handle input samples for changes with the FIR coefficients This makes sure previously processed samples are not changed due to changes in the FIR filter. It also applies the coefficients in ascending order with the values, to improve caching.
2011-07-03 09:14:33 +00:00
ALfloat left, right; \
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
\
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
pos = 0; \
frac = *DataPosFrac; \
\
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
for(c = 0;c < HRIR_LENGTH;c++) \
{ \
Coeffs[c][0] = TargetCoeffs[c][0] - (CoeffStep[c][0]*Counter); \
Coeffs[c][1] = TargetCoeffs[c][1] - (CoeffStep[c][1]*Counter); \
} \
\
Delay[0] = TargetDelay[0] - (DelayStep[0]*Counter) + 32768; \
Delay[1] = TargetDelay[1] - (DelayStep[1]*Counter) + 32768; \
\
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
if(LIKELY(OutPos == 0)) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels, frac); \
Multiply the history offset in the filtering funcitons
2011-05-19 01:52:47 +00:00
value = lpFilter2PC(DryFilter, i, value); \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
\
Use separate lines for HRTF history and values
2011-06-17 23:22:39 +00:00
History[Offset&SRC_HISTORY_MASK] = value; \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
left = History[(Offset-(Delay[0]>>16))&SRC_HISTORY_MASK]; \
right = History[(Offset-(Delay[1]>>16))&SRC_HISTORY_MASK]; \
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
\
Properly handle input samples for changes with the FIR coefficients This makes sure previously processed samples are not changed due to changes in the FIR filter. It also applies the coefficients in ascending order with the values, to improve caching.
2011-07-03 09:14:33 +00:00
ClickRemoval[FRONT_LEFT] -= Values[(Offset+1)&HRIR_MASK][0] + \
Coeffs[0][0] * left; \
ClickRemoval[FRONT_RIGHT] -= Values[(Offset+1)&HRIR_MASK][1] + \
Coeffs[0][1] * right; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
} \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
for(BufferIdx = 0;BufferIdx < BufferSize && Counter > 0;BufferIdx++) \
{ \
value = sampler(data + pos*NumChannels + i, NumChannels, frac); \
value = lpFilter2P(DryFilter, i, value); \
\
History[Offset&SRC_HISTORY_MASK] = value; \
left = History[(Offset-(Delay[0]>>16))&SRC_HISTORY_MASK]; \
right = History[(Offset-(Delay[1]>>16))&SRC_HISTORY_MASK]; \
\
Delay[0] += DelayStep[0]; \
Delay[1] += DelayStep[1]; \
\
Values[Offset&HRIR_MASK][0] = 0.0f; \
Values[Offset&HRIR_MASK][1] = 0.0f; \
Offset++; \
\
for(c = 0;c < HRIR_LENGTH;c++) \
{ \
const ALuint off = (Offset+c)&HRIR_MASK; \
Values[off][0] += Coeffs[c][0] * left; \
Values[off][1] += Coeffs[c][1] * right; \
Coeffs[c][0] += CoeffStep[c][0]; \
Coeffs[c][1] += CoeffStep[c][1]; \
} \
\
DryBuffer[OutPos][FRONT_LEFT] += Values[Offset&HRIR_MASK][0]; \
DryBuffer[OutPos][FRONT_RIGHT] += Values[Offset&HRIR_MASK][1]; \
\
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
OutPos++; \
Counter--; \
} \
\
Scale the delay down once for the post-stepping mix loop
2011-07-17 09:34:35 +00:00
Delay[0] >>= 16; \
Delay[1] >>= 16; \
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
for(;BufferIdx < BufferSize;BufferIdx++) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels, frac); \
Multiply the history offset in the filtering funcitons
2011-05-19 01:52:47 +00:00
value = lpFilter2P(DryFilter, i, value); \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
\
Use separate lines for HRTF history and values
2011-06-17 23:22:39 +00:00
History[Offset&SRC_HISTORY_MASK] = value; \
Scale the delay down once for the post-stepping mix loop
2011-07-17 09:34:35 +00:00
left = History[(Offset-Delay[0])&SRC_HISTORY_MASK]; \
right = History[(Offset-Delay[1])&SRC_HISTORY_MASK]; \
Properly handle input samples for changes with the FIR coefficients This makes sure previously processed samples are not changed due to changes in the FIR filter. It also applies the coefficients in ascending order with the values, to improve caching.
2011-07-03 09:14:33 +00:00
\
Values[Offset&HRIR_MASK][0] = 0.0f; \
Values[Offset&HRIR_MASK][1] = 0.0f; \
Offset++; \
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
\
for(c = 0;c < HRIR_LENGTH;c++) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Properly handle input samples for changes with the FIR coefficients This makes sure previously processed samples are not changed due to changes in the FIR filter. It also applies the coefficients in ascending order with the values, to improve caching.
2011-07-03 09:14:33 +00:00
const ALuint off = (Offset+c)&HRIR_MASK; \
Values[off][0] += Coeffs[c][0] * left; \
Values[off][1] += Coeffs[c][1] * right; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
} \
Properly handle input samples for changes with the FIR coefficients This makes sure previously processed samples are not changed due to changes in the FIR filter. It also applies the coefficients in ascending order with the values, to improve caching.
2011-07-03 09:14:33 +00:00
\
DryBuffer[OutPos][FRONT_LEFT] += Values[Offset&HRIR_MASK][0]; \
DryBuffer[OutPos][FRONT_RIGHT] += Values[Offset&HRIR_MASK][1]; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
\
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
OutPos++; \
} \
if(LIKELY(OutPos == SamplesToDo)) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels, frac); \
Multiply the history offset in the filtering funcitons
2011-05-19 01:52:47 +00:00
value = lpFilter2PC(DryFilter, i, value); \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
\
Use separate lines for HRTF history and values
2011-06-17 23:22:39 +00:00
History[Offset&SRC_HISTORY_MASK] = value; \
Scale the delay down once for the post-stepping mix loop
2011-07-17 09:34:35 +00:00
left = History[(Offset-Delay[0])&SRC_HISTORY_MASK]; \
right = History[(Offset-Delay[1])&SRC_HISTORY_MASK]; \
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
\
Properly handle input samples for changes with the FIR coefficients This makes sure previously processed samples are not changed due to changes in the FIR filter. It also applies the coefficients in ascending order with the values, to improve caching.
2011-07-03 09:14:33 +00:00
PendingClicks[FRONT_LEFT] += Values[(Offset+1)&HRIR_MASK][0] + \
Coeffs[0][0] * left; \
PendingClicks[FRONT_RIGHT] += Values[(Offset+1)&HRIR_MASK][1] + \
Coeffs[0][1] * right; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
} \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
OutPos -= BufferSize; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
} \
\
for(out = 0;out < Device->NumAuxSends;out++) \
{ \
Use the correct send slot when mixing
2011-07-12 05:32:27 +00:00
ALeffectslot *Slot = Source->Params.Send[out].Slot; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
ALfloat WetSend; \
Mark some mixer pointers as restricted
2011-05-03 00:14:57 +00:00
ALfloat *RESTRICT WetBuffer; \
ALfloat *RESTRICT WetClickRemoval; \
ALfloat *RESTRICT WetPendingClicks; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
FILTER *WetFilter; \
\
Store and use the send slot in the source params
2011-07-05 21:14:20 +00:00
if(!Slot || Slot->effect.type == AL_EFFECT_NULL) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
continue; \
\
Store and use the send slot in the source params
2011-07-05 21:14:20 +00:00
WetBuffer = Slot->WetBuffer; \
WetClickRemoval = Slot->ClickRemoval; \
WetPendingClicks = Slot->PendingClicks; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
WetFilter = &Source->Params.Send[out].iirFilter; \
WetSend = Source->Params.Send[out].WetGain; \
\
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
for(i = 0;i < NumChannels;i++) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
pos = 0; \
frac = *DataPosFrac; \
\
if(LIKELY(OutPos == 0)) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
value = lpFilter1PC(WetFilter, i, value); \
\
Scale the WetGain parameter directly instead of on each application
2011-07-05 21:00:11 +00:00
WetClickRemoval[0] -= value * WetSend; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
} \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
value = lpFilter1P(WetFilter, i, value); \
\
Scale the WetGain parameter directly instead of on each application
2011-07-05 21:00:11 +00:00
WetBuffer[OutPos] += value * WetSend; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
\
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
OutPos++; \
} \
if(LIKELY(OutPos == SamplesToDo)) \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
value = lpFilter1PC(WetFilter, i, value); \
\
Scale the WetGain parameter directly instead of on each application
2011-07-05 21:00:11 +00:00
WetPendingClicks[0] += value * WetSend; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
} \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
OutPos -= BufferSize; \
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
} \
} \
*DataPosInt += pos; \
*DataPosFrac = frac; \
}
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
DECL_TEMPLATE(ALfloat, point32)
DECL_TEMPLATE(ALfloat, lerp32)
DECL_TEMPLATE(ALfloat, cubic32)
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
DECL_TEMPLATE(ALshort, point16)
DECL_TEMPLATE(ALshort, lerp16)
DECL_TEMPLATE(ALshort, cubic16)
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
DECL_TEMPLATE(ALbyte, point8)
DECL_TEMPLATE(ALbyte, lerp8)
DECL_TEMPLATE(ALbyte, cubic8)
Implement HRTF mixers for multi-channel sources
2011-05-02 09:22:30 +00:00
#undef DECL_TEMPLATE
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
#define DECL_TEMPLATE(T, sampler) \
static void Mix_##T##_##sampler(ALsource *Source, ALCdevice *Device, \
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
const ALvoid *srcdata, ALuint *DataPosInt, ALuint *DataPosFrac, \
Rename some variables to be clearer
2010-11-26 20:59:45 +00:00
ALuint OutPos, ALuint SamplesToDo, ALuint BufferSize) \
Change the mixer macros to declare functions
2010-11-25 01:07:50 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
const ALuint NumChannels = Source->NumChannels; \
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
const T *RESTRICT data = srcdata; \
Rename OUTPUTCHANNELS to something more descriptive
2010-12-02 02:33:17 +00:00
ALfloat (*DryBuffer)[MAXCHANNELS]; \
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
ALfloat *ClickRemoval, *PendingClicks; \
Set mixer sample pos and frac when needed
2010-11-24 22:54:46 +00:00
ALuint pos, frac; \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
ALfloat DrySend[MAXCHANNELS][MAXCHANNELS]; \
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
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; \
Use a matrix when rendering to the dry buffer
2010-12-10 00:37:23 +00:00
ALuint i, out, c; \
Localize more variables and remove unnecessary ones
2010-09-25 21:19:36 +00:00
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; \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
for(i = 0;i < NumChannels;i++) \
Use a matrix when rendering to the dry buffer
2010-12-10 00:37:23 +00:00
{ \
for(c = 0;c < MAXCHANNELS;c++) \
DrySend[i][c] = Source->Params.DryGains[i][c]; \
} \
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
\
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
pos = 0; \
frac = *DataPosFrac; \
\
for(i = 0;i < NumChannels;i++) \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
{ \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
pos = 0; \
frac = *DataPosFrac; \
\
if(OutPos == 0) \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels, frac); \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
\
Multiply the history offset in the filtering funcitons
2011-05-19 01:52:47 +00:00
value = lpFilter2PC(DryFilter, i, value); \
Use a matrix when rendering to the dry buffer
2010-12-10 00:37:23 +00:00
for(c = 0;c < MAXCHANNELS;c++) \
ClickRemoval[c] -= value*DrySend[i][c]; \
Use click removal when starting a source
2010-08-15 05:59:55 +00:00
} \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +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
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels, frac); \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
\
Multiply the history offset in the filtering funcitons
2011-05-19 01:52:47 +00:00
value = lpFilter2P(DryFilter, i, value); \
Use a matrix when rendering to the dry buffer
2010-12-10 00:37:23 +00:00
for(c = 0;c < MAXCHANNELS;c++) \
DryBuffer[OutPos][c] += value*DrySend[i][c]; \
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
\
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
OutPos++; \
} \
if(OutPos == SamplesToDo) \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels, frac); \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Multiply the history offset in the filtering funcitons
2011-05-19 01:52:47 +00:00
value = lpFilter2PC(DryFilter, i, value); \
Use a matrix when rendering to the dry buffer
2010-12-10 00:37:23 +00:00
for(c = 0;c < MAXCHANNELS;c++) \
PendingClicks[c] += value*DrySend[i][c]; \
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
} \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
OutPos -= BufferSize; \
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
{ \
Use the correct send slot when mixing
2011-07-12 05:32:27 +00:00
ALeffectslot *Slot = Source->Params.Send[out].Slot; \
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; \
\
Store and use the send slot in the source params
2011-07-05 21:14:20 +00:00
if(!Slot || 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; \
\
Store and use the send slot in the source params
2011-07-05 21:14:20 +00:00
WetBuffer = Slot->WetBuffer; \
WetClickRemoval = Slot->ClickRemoval; \
WetPendingClicks = Slot->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
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
\
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
for(i = 0;i < NumChannels;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
{ \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
pos = 0; \
frac = *DataPosFrac; \
\
if(OutPos == 0) \
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
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels,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
\
Combine stereo and multi-channel templates
2010-12-10 01:14:12 +00:00
value = lpFilter1PC(WetFilter, i, value); \
Scale the WetGain parameter directly instead of on each application
2011-07-05 21:00:11 +00:00
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
} \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++) \
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
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
\
Combine stereo and multi-channel templates
2010-12-10 01:14:12 +00:00
value = lpFilter1P(WetFilter, i, value); \
Scale the WetGain parameter directly instead of on each application
2011-07-05 21:00:11 +00:00
WetBuffer[OutPos] += 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
\
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
frac += increment; \
pos += frac>>FRACTIONBITS; \
frac &= FRACTIONMASK; \
OutPos++; \
} \
if(OutPos == SamplesToDo) \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
{ \
Make mixers channel-count agnostic As a result, this combines/removes a bunch of mixers
2011-05-17 20:25:15 +00:00
value = sampler(data + pos*NumChannels + i, NumChannels,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
\
Combine stereo and multi-channel templates
2010-12-10 01:14:12 +00:00
value = lpFilter1PC(WetFilter, i, value); \
Scale the WetGain parameter directly instead of on each application
2011-07-05 21:00:11 +00:00
WetPendingClicks[0] += value * WetSend; \
Handle clicks by watching changes between updates
2010-08-16 21:53:21 +00:00
} \
Move the channel loop to the outside of the sample mixing loop
2011-05-17 19:49:26 +00:00
OutPos -= BufferSize; \
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
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
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
DECL_TEMPLATE(ALbyte, point8)
DECL_TEMPLATE(ALbyte, lerp8)
DECL_TEMPLATE(ALbyte, 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
Avoid some more code duplication
2010-11-27 04:22:14 +00:00
#define DECL_TEMPLATE(sampler) \
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
static MixerFunc Select_##sampler(enum FmtType FmtType) \
Avoid some more code duplication
2010-11-27 04:22:14 +00:00
{ \
Use enums when selecting the mixer
2010-11-27 07:42:30 +00:00
switch(FmtType) \
Avoid some more code duplication
2010-11-27 04:22:14 +00:00
{ \
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
case FmtByte: \
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return Mix_ALbyte_##sampler##8; \
Use enums when selecting the mixer
2010-11-27 07:42:30 +00:00
case FmtShort: \
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return Mix_ALshort_##sampler##16; \
Use enums when selecting the mixer
2010-11-27 07:42:30 +00:00
case FmtFloat: \
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return Mix_ALfloat_##sampler##32; \
Avoid some more code duplication
2010-11-27 04:22:14 +00:00
} \
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return NULL; \
Avoid some more code duplication
2010-11-27 04:22:14 +00:00
}
DECL_TEMPLATE(point)
DECL_TEMPLATE(lerp)
DECL_TEMPLATE(cubic)
#undef DECL_TEMPLATE
Get rid of a couple typedefs
2011-07-03 04:33:53 +00:00
MixerFunc SelectMixer(ALbuffer *Buffer, enum Resampler Resampler)
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
{
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
switch(Resampler)
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
{
case POINT_RESAMPLER:
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return Select_point(Buffer->FmtType);
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
case LINEAR_RESAMPLER:
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return Select_lerp(Buffer->FmtType);
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
case CUBIC_RESAMPLER:
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return Select_cubic(Buffer->FmtType);
case RESAMPLER_MIN:
case RESAMPLER_MAX:
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
break;
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
}
return NULL;
}
#define DECL_TEMPLATE(sampler) \
static MixerFunc Select_Hrtf_##sampler(enum FmtType FmtType) \
{ \
switch(FmtType) \
{ \
case FmtByte: \
return Mix_Hrtf_ALbyte_##sampler##8; \
case FmtShort: \
return Mix_Hrtf_ALshort_##sampler##16; \
case FmtFloat: \
return Mix_Hrtf_ALfloat_##sampler##32; \
} \
return NULL; \
}
DECL_TEMPLATE(point)
DECL_TEMPLATE(lerp)
DECL_TEMPLATE(cubic)
#undef DECL_TEMPLATE
Get rid of a couple typedefs
2011-07-03 04:33:53 +00:00
MixerFunc SelectHrtfMixer(ALbuffer *Buffer, enum Resampler Resampler)
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
{
switch(Resampler)
{
case POINT_RESAMPLER:
return Select_Hrtf_point(Buffer->FmtType);
case LINEAR_RESAMPLER:
return Select_Hrtf_lerp(Buffer->FmtType);
case CUBIC_RESAMPLER:
return Select_Hrtf_cubic(Buffer->FmtType);
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
case RESAMPLER_MIN:
case RESAMPLER_MAX:
break;
}
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
return NULL;
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
}
Pass the device to the mix function and localize the dry mix and click buffers
2010-09-26 19:23:22 +00:00
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;
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;
Get rid of a couple typedefs
2011-07-03 04:33:53 +00:00
enum Resampler Resampler;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
ALenum State;
Rename some variables to be clearer
2010-11-26 20:59:45 +00:00
ALuint OutPos;
Use enums when selecting the mixer
2010-11-27 07:42:30 +00:00
ALuint FrameSize;
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 enums when selecting the mixer
2010-11-27 07:42:30 +00:00
ALuint i;
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;
Use function pointers to call the source mixer
2011-05-06 07:20:40 +00:00
Resampler = Source->Resampler;
Avoid looking in the buffer queue to find the frame size
2011-05-19 00:02:18 +00:00
FrameSize = Source->NumChannels * Source->SampleSize;
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;
Rename some variables to be clearer
2010-11-26 20:59:45 +00:00
OutPos = 0;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
do {
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
const ALuint BufferPrePadding = ResamplerPrePadding[Resampler];
const ALuint BufferPadding = ResamplerPadding[Resampler];
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 */
Rename some variables to be clearer
2010-11-26 20:59:45 +00:00
DataSize64 = SamplesToDo-OutPos+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;
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
DataSize64 += BufferPadding+BufferPrePadding;
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
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
if(DataPosInt >= BufferPrePadding)
pos = (DataPosInt-BufferPrePadding)*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
else
{
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
DataSize = (BufferPrePadding-DataPosInt)*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
DataSize = min(BufferSize, DataSize);
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
memset(&SrcData[SrcDataSize], 0, 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
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;
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
memset(&SrcData[SrcDataSize], 0, 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
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;
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
while(pos < BufferPrePadding)
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
pos += LoopEnd-LoopStart;
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
pos -= BufferPrePadding;
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
pos += LoopStart;
pos *= FrameSize;
}
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
else if(DataPosInt >= BufferPrePadding)
pos = (DataPosInt-BufferPrePadding)*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
else
{
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
DataSize = (BufferPrePadding-DataPosInt)*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
DataSize = min(BufferSize, DataSize);
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
memset(&SrcData[SrcDataSize], 0, 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
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;
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
if(DataPosInt >= BufferPrePadding)
pos = (DataPosInt-BufferPrePadding)*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
else
{
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
pos = (BufferPrePadding-DataPosInt)*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
while(pos > 0)
{
if(!BufferListIter->prev && !Looping)
{
ALuint DataSize = min(BufferSize, pos);
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
memset(&SrcData[SrcDataSize], 0, 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
SrcDataSize += DataSize;
BufferSize -= DataSize;
pos = 0;
break;
}
Fix loop handling when traversing the buffer queue backwards
2011-01-23 23:04:42 +00:00
if(BufferListIter->prev)
BufferListIter = BufferListIter->prev;
else
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
{
while(BufferListIter->next)
BufferListIter = BufferListIter->next;
}
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)
{
Use signed samples for 8-bit storage
2011-05-06 01:54:10 +00:00
memset(&SrcData[SrcDataSize], 0, 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
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;
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
DataSize64 -= BufferPadding+BufferPrePadding;
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;
Subtract the fractional position separately
2010-11-26 23:51:13 +00:00
DataSize64 -= DataPosFrac;
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Subtract the fractional position separately
2010-11-26 23:51:13 +00:00
BufferSize = (ALuint)((DataSize64+(increment-1)) / increment);
Rename some variables to be clearer
2010-11-26 20:59:45 +00:00
BufferSize = min(BufferSize, (SamplesToDo-OutPos));
Use separate macros for the different mixing loops
2010-09-22 16:38:24 +00:00
Make the buffer padding size dependent on the resampler
2010-11-26 10:53:15 +00:00
SrcData += BufferPrePadding*FrameSize;
Select the mixer during a source update
2011-06-25 07:08:05 +00:00
Source->Params.DoMix(Source, Device, SrcData, &DataPosInt, &DataPosFrac,
OutPos, SamplesToDo, BufferSize);
Rename some variables to be clearer
2010-11-26 20:59:45 +00:00
OutPos += 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;
LoopStart = ALBuffer->LoopStart;
LoopEnd = ALBuffer->LoopEnd;
Fix looping on loop points
2011-02-06 09:07:37 +00:00
if(LoopEnd > DataPosInt)
break;
}
if(Looping && Source->lSourceType == AL_STATIC)
{
BufferListItem = Source->queue;
DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
break;
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
}
Fix looping on loop points
2011-02-06 09:07:37 +00:00
if(DataSize > DataPosInt)
break;
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;
}
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
}
Rename some variables to be clearer
2010-11-26 20:59:45 +00:00
} while(State == AL_PLAYING && OutPos < SamplesToDo);
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
/* 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;
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
Source->HrtfOffset += OutPos;
Fade between HRTF coefficients, to reduce noise from sudden changes
2011-07-16 23:24:01 +00:00
if(State == AL_PLAYING)
{
Source->HrtfCounter = __max(Source->HrtfCounter, OutPos) - OutPos;
Source->HrtfMoving = AL_TRUE;
}
else
{
Source->HrtfCounter = 0;
Source->HrtfMoving = AL_FALSE;
}
Move the core mixer functions to a separate source file
2010-08-04 06:19:36 +00:00
}
Reference in New Issue Copy Permalink