1642 lines
61 KiB
C
1642 lines
61 KiB
C
/**
|
|
* 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.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 "alSource.h"
|
|
#include "alBuffer.h"
|
|
#include "alListener.h"
|
|
#include "alAuxEffectSlot.h"
|
|
#include "alu.h"
|
|
#include "bs2b.h"
|
|
#include "hrtf.h"
|
|
#include "uhjfilter.h"
|
|
#include "bformatdec.h"
|
|
#include "static_assert.h"
|
|
|
|
#include "mixer_defs.h"
|
|
|
|
#include "backends/base.h"
|
|
|
|
|
|
struct ChanMap {
|
|
enum Channel channel;
|
|
ALfloat angle;
|
|
ALfloat elevation;
|
|
};
|
|
|
|
/* Cone scalar */
|
|
ALfloat ConeScale = 1.0f;
|
|
|
|
/* Localized Z scalar for mono sources */
|
|
ALfloat ZScale = 1.0f;
|
|
|
|
extern inline ALfloat minf(ALfloat a, ALfloat b);
|
|
extern inline ALfloat maxf(ALfloat a, ALfloat b);
|
|
extern inline ALfloat clampf(ALfloat val, ALfloat min, ALfloat max);
|
|
|
|
extern inline ALdouble mind(ALdouble a, ALdouble b);
|
|
extern inline ALdouble maxd(ALdouble a, ALdouble b);
|
|
extern inline ALdouble clampd(ALdouble val, ALdouble min, ALdouble max);
|
|
|
|
extern inline ALuint minu(ALuint a, ALuint b);
|
|
extern inline ALuint maxu(ALuint a, ALuint b);
|
|
extern inline ALuint clampu(ALuint val, ALuint min, ALuint max);
|
|
|
|
extern inline ALint mini(ALint a, ALint b);
|
|
extern inline ALint maxi(ALint a, ALint b);
|
|
extern inline ALint clampi(ALint val, ALint min, ALint max);
|
|
|
|
extern inline ALint64 mini64(ALint64 a, ALint64 b);
|
|
extern inline ALint64 maxi64(ALint64 a, ALint64 b);
|
|
extern inline ALint64 clampi64(ALint64 val, ALint64 min, ALint64 max);
|
|
|
|
extern inline ALuint64 minu64(ALuint64 a, ALuint64 b);
|
|
extern inline ALuint64 maxu64(ALuint64 a, ALuint64 b);
|
|
extern inline ALuint64 clampu64(ALuint64 val, ALuint64 min, ALuint64 max);
|
|
|
|
extern inline ALfloat lerp(ALfloat val1, ALfloat val2, ALfloat mu);
|
|
extern inline ALfloat resample_fir4(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat val3, ALuint frac);
|
|
extern inline ALfloat resample_fir8(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat val3, ALfloat val4, ALfloat val5, ALfloat val6, ALfloat val7, ALuint frac);
|
|
|
|
extern inline void aluVectorSet(aluVector *restrict vector, ALfloat x, ALfloat y, ALfloat z, ALfloat w);
|
|
|
|
extern inline void aluMatrixfSetRow(aluMatrixf *matrix, ALuint row,
|
|
ALfloat m0, ALfloat m1, ALfloat m2, ALfloat m3);
|
|
extern inline void aluMatrixfSet(aluMatrixf *matrix,
|
|
ALfloat m00, ALfloat m01, ALfloat m02, ALfloat m03,
|
|
ALfloat m10, ALfloat m11, ALfloat m12, ALfloat m13,
|
|
ALfloat m20, ALfloat m21, ALfloat m22, ALfloat m23,
|
|
ALfloat m30, ALfloat m31, ALfloat m32, ALfloat m33);
|
|
|
|
|
|
static inline HrtfMixerFunc SelectHrtfMixer(void)
|
|
{
|
|
#ifdef HAVE_SSE
|
|
if((CPUCapFlags&CPU_CAP_SSE))
|
|
return MixHrtf_SSE;
|
|
#endif
|
|
#ifdef HAVE_NEON
|
|
if((CPUCapFlags&CPU_CAP_NEON))
|
|
return MixHrtf_Neon;
|
|
#endif
|
|
|
|
return MixHrtf_C;
|
|
}
|
|
|
|
|
|
static inline void aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
|
|
{
|
|
outVector[0] = inVector1[1]*inVector2[2] - inVector1[2]*inVector2[1];
|
|
outVector[1] = inVector1[2]*inVector2[0] - inVector1[0]*inVector2[2];
|
|
outVector[2] = inVector1[0]*inVector2[1] - inVector1[1]*inVector2[0];
|
|
}
|
|
|
|
static inline ALfloat aluDotproduct(const aluVector *vec1, const aluVector *vec2)
|
|
{
|
|
return vec1->v[0]*vec2->v[0] + vec1->v[1]*vec2->v[1] + vec1->v[2]*vec2->v[2];
|
|
}
|
|
|
|
static ALfloat aluNormalize(ALfloat *vec)
|
|
{
|
|
ALfloat length = sqrtf(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
|
|
if(length > 0.0f)
|
|
{
|
|
ALfloat inv_length = 1.0f/length;
|
|
vec[0] *= inv_length;
|
|
vec[1] *= inv_length;
|
|
vec[2] *= inv_length;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
static void aluMatrixfFloat3(ALfloat *vec, ALfloat w, const aluMatrixf *mtx)
|
|
{
|
|
ALfloat v[4] = { vec[0], vec[1], vec[2], w };
|
|
|
|
vec[0] = v[0]*mtx->m[0][0] + v[1]*mtx->m[1][0] + v[2]*mtx->m[2][0] + v[3]*mtx->m[3][0];
|
|
vec[1] = v[0]*mtx->m[0][1] + v[1]*mtx->m[1][1] + v[2]*mtx->m[2][1] + v[3]*mtx->m[3][1];
|
|
vec[2] = v[0]*mtx->m[0][2] + v[1]*mtx->m[1][2] + v[2]*mtx->m[2][2] + v[3]*mtx->m[3][2];
|
|
}
|
|
|
|
static aluVector aluMatrixfVector(const aluMatrixf *mtx, const aluVector *vec)
|
|
{
|
|
aluVector v;
|
|
v.v[0] = vec->v[0]*mtx->m[0][0] + vec->v[1]*mtx->m[1][0] + vec->v[2]*mtx->m[2][0] + vec->v[3]*mtx->m[3][0];
|
|
v.v[1] = vec->v[0]*mtx->m[0][1] + vec->v[1]*mtx->m[1][1] + vec->v[2]*mtx->m[2][1] + vec->v[3]*mtx->m[3][1];
|
|
v.v[2] = vec->v[0]*mtx->m[0][2] + vec->v[1]*mtx->m[1][2] + vec->v[2]*mtx->m[2][2] + vec->v[3]*mtx->m[3][2];
|
|
v.v[3] = vec->v[0]*mtx->m[0][3] + vec->v[1]*mtx->m[1][3] + vec->v[2]*mtx->m[2][3] + vec->v[3]*mtx->m[3][3];
|
|
return v;
|
|
}
|
|
|
|
|
|
/* Prepares the interpolator for a given rate (determined by increment). A
|
|
* result of AL_FALSE indicates that the filter output will completely cut
|
|
* the input signal.
|
|
*
|
|
* With a bit of work, and a trade of memory for CPU cost, this could be
|
|
* modified for use with an interpolated increment for buttery-smooth pitch
|
|
* changes.
|
|
*/
|
|
static ALboolean BsincPrepare(const ALuint increment, BsincState *state)
|
|
{
|
|
static const ALfloat scaleBase = 1.510578918e-01f, scaleRange = 1.177936623e+00f;
|
|
static const ALuint m[BSINC_SCALE_COUNT] = { 24, 24, 24, 24, 24, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 12 };
|
|
static const ALuint to[4][BSINC_SCALE_COUNT] =
|
|
{
|
|
{ 0, 24, 408, 792, 1176, 1560, 1944, 2328, 2648, 2968, 3288, 3544, 3800, 4056, 4248, 4440 },
|
|
{ 4632, 5016, 5400, 5784, 6168, 6552, 6936, 7320, 7640, 7960, 8280, 8536, 8792, 9048, 9240, 0 },
|
|
{ 0, 9432, 9816, 10200, 10584, 10968, 11352, 11736, 12056, 12376, 12696, 12952, 13208, 13464, 13656, 13848 },
|
|
{ 14040, 14424, 14808, 15192, 15576, 15960, 16344, 16728, 17048, 17368, 17688, 17944, 18200, 18456, 18648, 0 }
|
|
};
|
|
static const ALuint tm[2][BSINC_SCALE_COUNT] =
|
|
{
|
|
{ 0, 24, 24, 24, 24, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 12 },
|
|
{ 24, 24, 24, 24, 24, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 0 }
|
|
};
|
|
ALfloat sf;
|
|
ALuint si, pi;
|
|
ALboolean uncut = AL_TRUE;
|
|
|
|
if(increment > FRACTIONONE)
|
|
{
|
|
sf = (ALfloat)FRACTIONONE / increment;
|
|
if(sf < scaleBase)
|
|
{
|
|
/* Signal has been completely cut. The return result can be used
|
|
* to skip the filter (and output zeros) as an optimization.
|
|
*/
|
|
sf = 0.0f;
|
|
si = 0;
|
|
uncut = AL_FALSE;
|
|
}
|
|
else
|
|
{
|
|
sf = (BSINC_SCALE_COUNT - 1) * (sf - scaleBase) * scaleRange;
|
|
si = fastf2u(sf);
|
|
/* The interpolation factor is fit to this diagonally-symmetric
|
|
* curve to reduce the transition ripple caused by interpolating
|
|
* different scales of the sinc function.
|
|
*/
|
|
sf = 1.0f - cosf(asinf(sf - si));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sf = 0.0f;
|
|
si = BSINC_SCALE_COUNT - 1;
|
|
}
|
|
|
|
state->sf = sf;
|
|
state->m = m[si];
|
|
state->l = -(ALint)((m[si] / 2) - 1);
|
|
/* The CPU cost of this table re-mapping could be traded for the memory
|
|
* cost of a complete table map (1024 elements large).
|
|
*/
|
|
for(pi = 0;pi < BSINC_PHASE_COUNT;pi++)
|
|
{
|
|
state->coeffs[pi].filter = &bsincTab[to[0][si] + tm[0][si]*pi];
|
|
state->coeffs[pi].scDelta = &bsincTab[to[1][si] + tm[1][si]*pi];
|
|
state->coeffs[pi].phDelta = &bsincTab[to[2][si] + tm[0][si]*pi];
|
|
state->coeffs[pi].spDelta = &bsincTab[to[3][si] + tm[1][si]*pi];
|
|
}
|
|
return uncut;
|
|
}
|
|
|
|
|
|
static void CalcListenerParams(ALCcontext *Context)
|
|
{
|
|
ALlistener *Listener = Context->Listener;
|
|
ALfloat N[3], V[3], U[3], P[3];
|
|
struct ALlistenerProps *first;
|
|
struct ALlistenerProps *props;
|
|
aluVector vel;
|
|
|
|
props = ATOMIC_EXCHANGE(struct ALlistenerProps*, &Listener->Update, NULL, almemory_order_acq_rel);
|
|
if(!props) return;
|
|
|
|
/* AT then UP */
|
|
N[0] = ATOMIC_LOAD(&props->Forward[0], almemory_order_relaxed);
|
|
N[1] = ATOMIC_LOAD(&props->Forward[1], almemory_order_relaxed);
|
|
N[2] = ATOMIC_LOAD(&props->Forward[2], almemory_order_relaxed);
|
|
aluNormalize(N);
|
|
V[0] = ATOMIC_LOAD(&props->Up[0], almemory_order_relaxed);
|
|
V[1] = ATOMIC_LOAD(&props->Up[1], almemory_order_relaxed);
|
|
V[2] = ATOMIC_LOAD(&props->Up[2], almemory_order_relaxed);
|
|
aluNormalize(V);
|
|
/* Build and normalize right-vector */
|
|
aluCrossproduct(N, V, U);
|
|
aluNormalize(U);
|
|
|
|
aluMatrixfSet(&Listener->Params.Matrix,
|
|
U[0], V[0], -N[0], 0.0,
|
|
U[1], V[1], -N[1], 0.0,
|
|
U[2], V[2], -N[2], 0.0,
|
|
0.0, 0.0, 0.0, 1.0
|
|
);
|
|
|
|
P[0] = ATOMIC_LOAD(&props->Position[0], almemory_order_relaxed);
|
|
P[1] = ATOMIC_LOAD(&props->Position[1], almemory_order_relaxed);
|
|
P[2] = ATOMIC_LOAD(&props->Position[2], almemory_order_relaxed);
|
|
aluMatrixfFloat3(P, 1.0, &Listener->Params.Matrix);
|
|
aluMatrixfSetRow(&Listener->Params.Matrix, 3, -P[0], -P[1], -P[2], 1.0f);
|
|
|
|
aluVectorSet(&vel, ATOMIC_LOAD(&props->Velocity[0], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Velocity[1], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Velocity[2], almemory_order_relaxed),
|
|
0.0f);
|
|
Listener->Params.Velocity = aluMatrixfVector(&Listener->Params.Matrix, &vel);
|
|
|
|
Listener->Params.Gain = ATOMIC_LOAD(&props->Gain, almemory_order_relaxed);
|
|
Listener->Params.MetersPerUnit = ATOMIC_LOAD(&props->MetersPerUnit, almemory_order_relaxed);
|
|
|
|
Listener->Params.DopplerFactor = ATOMIC_LOAD(&props->DopplerFactor, almemory_order_relaxed);
|
|
Listener->Params.SpeedOfSound = ATOMIC_LOAD(&props->SpeedOfSound, almemory_order_relaxed) *
|
|
ATOMIC_LOAD(&props->DopplerVelocity, almemory_order_relaxed);
|
|
|
|
/* WARNING: A livelock is theoretically possible if another thread keeps
|
|
* changing the freelist head without giving this a chance to actually swap
|
|
* in the old container (practically impossible with this little code,
|
|
* but...).
|
|
*/
|
|
first = ATOMIC_LOAD(&Listener->FreeList);
|
|
do {
|
|
ATOMIC_STORE(&props->next, first, almemory_order_relaxed);
|
|
} while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALlistenerProps*,
|
|
&Listener->FreeList, &first, props) == 0);
|
|
}
|
|
|
|
static void CalcEffectSlotParams(ALeffectslot *slot, ALCdevice *device)
|
|
{
|
|
struct ALeffectslotProps *first;
|
|
struct ALeffectslotProps *props;
|
|
ALeffectState *state;
|
|
|
|
props = ATOMIC_EXCHANGE(struct ALeffectslotProps*, &slot->Update, NULL, almemory_order_acq_rel);
|
|
if(!props) return;
|
|
|
|
slot->Params.Gain = ATOMIC_LOAD(&props->Gain, almemory_order_relaxed);
|
|
slot->Params.AuxSendAuto = ATOMIC_LOAD(&props->AuxSendAuto, almemory_order_relaxed);
|
|
slot->Params.EffectType = ATOMIC_LOAD(&props->Type, almemory_order_relaxed);
|
|
if(IsReverbEffect(slot->Params.EffectType))
|
|
{
|
|
slot->Params.RoomRolloff = props->Props.Reverb.RoomRolloffFactor;
|
|
slot->Params.DecayTime = props->Props.Reverb.DecayTime;
|
|
slot->Params.AirAbsorptionGainHF = props->Props.Reverb.AirAbsorptionGainHF;
|
|
}
|
|
else
|
|
{
|
|
slot->Params.RoomRolloff = 0.0f;
|
|
slot->Params.DecayTime = 0.0f;
|
|
slot->Params.AirAbsorptionGainHF = 1.0f;
|
|
}
|
|
state = ATOMIC_EXCHANGE(ALeffectState*, &props->State, NULL, almemory_order_relaxed);
|
|
|
|
/* If the state object is changed, exchange it with the current one so it
|
|
* remains in the freelist and isn't leaked.
|
|
*/
|
|
if(state != slot->Params.EffectState)
|
|
{
|
|
ATOMIC_STORE(&props->State, slot->Params.EffectState, almemory_order_relaxed);
|
|
slot->Params.EffectState = state;
|
|
}
|
|
|
|
V(slot->Params.EffectState,update)(device, slot, &props->Props);
|
|
|
|
/* WARNING: A livelock is theoretically possible if another thread keeps
|
|
* changing the freelist head without giving this a chance to actually swap
|
|
* in the old container (practically impossible with this little code,
|
|
* but...).
|
|
*/
|
|
first = ATOMIC_LOAD(&slot->FreeList);
|
|
do {
|
|
ATOMIC_STORE(&props->next, first, almemory_order_relaxed);
|
|
} while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALeffectslotProps*,
|
|
&slot->FreeList, &first, props) == 0);
|
|
}
|
|
|
|
|
|
static void CalcNonAttnSourceParams(ALvoice *voice, const struct ALsourceProps *props, const ALbuffer *ALBuffer, const ALCcontext *ALContext)
|
|
{
|
|
static const struct ChanMap MonoMap[1] = {
|
|
{ FrontCenter, 0.0f, 0.0f }
|
|
}, RearMap[2] = {
|
|
{ BackLeft, DEG2RAD(-150.0f), DEG2RAD(0.0f) },
|
|
{ BackRight, DEG2RAD( 150.0f), DEG2RAD(0.0f) }
|
|
}, QuadMap[4] = {
|
|
{ FrontLeft, DEG2RAD( -45.0f), DEG2RAD(0.0f) },
|
|
{ FrontRight, DEG2RAD( 45.0f), DEG2RAD(0.0f) },
|
|
{ BackLeft, DEG2RAD(-135.0f), DEG2RAD(0.0f) },
|
|
{ BackRight, DEG2RAD( 135.0f), DEG2RAD(0.0f) }
|
|
}, X51Map[6] = {
|
|
{ FrontLeft, DEG2RAD( -30.0f), DEG2RAD(0.0f) },
|
|
{ FrontRight, DEG2RAD( 30.0f), DEG2RAD(0.0f) },
|
|
{ FrontCenter, DEG2RAD( 0.0f), DEG2RAD(0.0f) },
|
|
{ LFE, 0.0f, 0.0f },
|
|
{ SideLeft, DEG2RAD(-110.0f), DEG2RAD(0.0f) },
|
|
{ SideRight, DEG2RAD( 110.0f), DEG2RAD(0.0f) }
|
|
}, X61Map[7] = {
|
|
{ FrontLeft, DEG2RAD(-30.0f), DEG2RAD(0.0f) },
|
|
{ FrontRight, DEG2RAD( 30.0f), DEG2RAD(0.0f) },
|
|
{ FrontCenter, DEG2RAD( 0.0f), DEG2RAD(0.0f) },
|
|
{ LFE, 0.0f, 0.0f },
|
|
{ BackCenter, DEG2RAD(180.0f), DEG2RAD(0.0f) },
|
|
{ SideLeft, DEG2RAD(-90.0f), DEG2RAD(0.0f) },
|
|
{ SideRight, DEG2RAD( 90.0f), DEG2RAD(0.0f) }
|
|
}, X71Map[8] = {
|
|
{ FrontLeft, DEG2RAD( -30.0f), DEG2RAD(0.0f) },
|
|
{ FrontRight, DEG2RAD( 30.0f), DEG2RAD(0.0f) },
|
|
{ FrontCenter, DEG2RAD( 0.0f), DEG2RAD(0.0f) },
|
|
{ LFE, 0.0f, 0.0f },
|
|
{ BackLeft, DEG2RAD(-150.0f), DEG2RAD(0.0f) },
|
|
{ BackRight, DEG2RAD( 150.0f), DEG2RAD(0.0f) },
|
|
{ SideLeft, DEG2RAD( -90.0f), DEG2RAD(0.0f) },
|
|
{ SideRight, DEG2RAD( 90.0f), DEG2RAD(0.0f) }
|
|
};
|
|
|
|
const ALCdevice *Device = ALContext->Device;
|
|
const ALlistener *Listener = ALContext->Listener;
|
|
ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
|
|
ALfloat DryGain, DryGainHF, DryGainLF;
|
|
ALfloat WetGain[MAX_SENDS];
|
|
ALfloat WetGainHF[MAX_SENDS];
|
|
ALfloat WetGainLF[MAX_SENDS];
|
|
ALeffectslot *SendSlots[MAX_SENDS];
|
|
ALuint NumSends, Frequency;
|
|
ALboolean Relative;
|
|
const struct ChanMap *chans = NULL;
|
|
struct ChanMap StereoMap[2] = {
|
|
{ FrontLeft, DEG2RAD(-30.0f), DEG2RAD(0.0f) },
|
|
{ FrontRight, DEG2RAD( 30.0f), DEG2RAD(0.0f) }
|
|
};
|
|
ALuint num_channels = 0;
|
|
ALboolean DirectChannels;
|
|
ALboolean isbformat = AL_FALSE;
|
|
ALfloat Pitch;
|
|
ALuint i, j, c;
|
|
|
|
/* Get device properties */
|
|
NumSends = Device->NumAuxSends;
|
|
Frequency = Device->Frequency;
|
|
|
|
/* Get listener properties */
|
|
ListenerGain = Listener->Params.Gain;
|
|
|
|
/* Get source properties */
|
|
SourceVolume = ATOMIC_LOAD(&props->Gain, almemory_order_relaxed);
|
|
MinVolume = ATOMIC_LOAD(&props->MinGain, almemory_order_relaxed);
|
|
MaxVolume = ATOMIC_LOAD(&props->MaxGain, almemory_order_relaxed);
|
|
Pitch = ATOMIC_LOAD(&props->Pitch, almemory_order_relaxed);
|
|
Relative = ATOMIC_LOAD(&props->HeadRelative, almemory_order_relaxed);
|
|
DirectChannels = ATOMIC_LOAD(&props->DirectChannels, almemory_order_relaxed);
|
|
|
|
/* Convert counter-clockwise to clockwise. */
|
|
StereoMap[0].angle = -ATOMIC_LOAD(&props->StereoPan[0], almemory_order_relaxed);
|
|
StereoMap[1].angle = -ATOMIC_LOAD(&props->StereoPan[1], almemory_order_relaxed);
|
|
|
|
voice->Direct.OutBuffer = Device->Dry.Buffer;
|
|
voice->Direct.OutChannels = Device->Dry.NumChannels;
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
SendSlots[i] = ATOMIC_LOAD(&props->Send[i].Slot, almemory_order_relaxed);
|
|
if(!SendSlots[i] && i == 0)
|
|
SendSlots[i] = Device->DefaultSlot;
|
|
if(!SendSlots[i] || SendSlots[i]->Params.EffectType == AL_EFFECT_NULL)
|
|
{
|
|
SendSlots[i] = NULL;
|
|
voice->Send[i].OutBuffer = NULL;
|
|
voice->Send[i].OutChannels = 0;
|
|
}
|
|
else
|
|
{
|
|
voice->Send[i].OutBuffer = SendSlots[i]->WetBuffer;
|
|
voice->Send[i].OutChannels = SendSlots[i]->NumChannels;
|
|
}
|
|
}
|
|
voice->Looping = ATOMIC_LOAD(&props->Looping, almemory_order_relaxed);
|
|
|
|
/* Calculate the stepping value */
|
|
Pitch *= (ALfloat)ALBuffer->Frequency / Frequency;
|
|
if(Pitch > (ALfloat)MAX_PITCH)
|
|
voice->Step = MAX_PITCH<<FRACTIONBITS;
|
|
else
|
|
voice->Step = maxi(fastf2i(Pitch*FRACTIONONE + 0.5f), 1);
|
|
BsincPrepare(voice->Step, &voice->SincState);
|
|
|
|
/* Calculate gains */
|
|
DryGain = clampf(SourceVolume, MinVolume, MaxVolume);
|
|
DryGain *= ATOMIC_LOAD(&props->Direct.Gain, almemory_order_relaxed) * ListenerGain;
|
|
DryGainHF = ATOMIC_LOAD(&props->Direct.GainHF, almemory_order_relaxed);
|
|
DryGainLF = ATOMIC_LOAD(&props->Direct.GainLF, almemory_order_relaxed);
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);
|
|
WetGain[i] *= ATOMIC_LOAD(&props->Send[i].Gain, almemory_order_relaxed) * ListenerGain;
|
|
WetGainHF[i] = ATOMIC_LOAD(&props->Send[i].GainHF, almemory_order_relaxed);
|
|
WetGainLF[i] = ATOMIC_LOAD(&props->Send[i].GainLF, almemory_order_relaxed);
|
|
}
|
|
|
|
switch(ALBuffer->FmtChannels)
|
|
{
|
|
case FmtMono:
|
|
chans = MonoMap;
|
|
num_channels = 1;
|
|
break;
|
|
|
|
case FmtStereo:
|
|
chans = StereoMap;
|
|
num_channels = 2;
|
|
break;
|
|
|
|
case FmtRear:
|
|
chans = RearMap;
|
|
num_channels = 2;
|
|
break;
|
|
|
|
case FmtQuad:
|
|
chans = QuadMap;
|
|
num_channels = 4;
|
|
break;
|
|
|
|
case FmtX51:
|
|
chans = X51Map;
|
|
num_channels = 6;
|
|
break;
|
|
|
|
case FmtX61:
|
|
chans = X61Map;
|
|
num_channels = 7;
|
|
break;
|
|
|
|
case FmtX71:
|
|
chans = X71Map;
|
|
num_channels = 8;
|
|
break;
|
|
|
|
case FmtBFormat2D:
|
|
num_channels = 3;
|
|
isbformat = AL_TRUE;
|
|
DirectChannels = AL_FALSE;
|
|
break;
|
|
|
|
case FmtBFormat3D:
|
|
num_channels = 4;
|
|
isbformat = AL_TRUE;
|
|
DirectChannels = AL_FALSE;
|
|
break;
|
|
}
|
|
|
|
if(isbformat)
|
|
{
|
|
ALfloat N[3], V[3], U[3];
|
|
aluMatrixf matrix;
|
|
ALfloat scale;
|
|
|
|
/* AT then UP */
|
|
N[0] = ATOMIC_LOAD(&props->Orientation[0][0], almemory_order_relaxed);
|
|
N[1] = ATOMIC_LOAD(&props->Orientation[0][1], almemory_order_relaxed);
|
|
N[2] = ATOMIC_LOAD(&props->Orientation[0][2], almemory_order_relaxed);
|
|
aluNormalize(N);
|
|
V[0] = ATOMIC_LOAD(&props->Orientation[1][0], almemory_order_relaxed);
|
|
V[1] = ATOMIC_LOAD(&props->Orientation[1][1], almemory_order_relaxed);
|
|
V[2] = ATOMIC_LOAD(&props->Orientation[1][2], almemory_order_relaxed);
|
|
aluNormalize(V);
|
|
if(!Relative)
|
|
{
|
|
const aluMatrixf *lmatrix = &Listener->Params.Matrix;
|
|
aluMatrixfFloat3(N, 0.0f, lmatrix);
|
|
aluMatrixfFloat3(V, 0.0f, lmatrix);
|
|
}
|
|
/* Build and normalize right-vector */
|
|
aluCrossproduct(N, V, U);
|
|
aluNormalize(U);
|
|
|
|
/* Build a rotate + conversion matrix (B-Format -> N3D). */
|
|
scale = 1.732050808f;
|
|
aluMatrixfSet(&matrix,
|
|
1.414213562f, 0.0f, 0.0f, 0.0f,
|
|
0.0f, -N[0]*scale, N[1]*scale, -N[2]*scale,
|
|
0.0f, U[0]*scale, -U[1]*scale, U[2]*scale,
|
|
0.0f, -V[0]*scale, V[1]*scale, -V[2]*scale
|
|
);
|
|
|
|
voice->Direct.OutBuffer = Device->FOAOut.Buffer;
|
|
voice->Direct.OutChannels = Device->FOAOut.NumChannels;
|
|
for(c = 0;c < num_channels;c++)
|
|
ComputeFirstOrderGains(Device->FOAOut, matrix.m[c], DryGain,
|
|
voice->Direct.Gains[c].Target);
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
if(!SendSlots[i])
|
|
{
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[c].Target[j] = 0.0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
ComputeFirstOrderGainsBF(Slot->ChanMap, Slot->NumChannels, matrix.m[c],
|
|
WetGain[i], voice->Send[i].Gains[c].Target);
|
|
}
|
|
}
|
|
}
|
|
|
|
voice->IsHrtf = AL_FALSE;
|
|
}
|
|
else
|
|
{
|
|
ALfloat coeffs[MAX_AMBI_COEFFS];
|
|
|
|
if(DirectChannels)
|
|
{
|
|
/* Skip the virtual channels and write inputs to the real output. */
|
|
voice->Direct.OutBuffer = Device->RealOut.Buffer;
|
|
voice->Direct.OutChannels = Device->RealOut.NumChannels;
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
int idx;
|
|
for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
|
|
voice->Direct.Gains[c].Target[j] = 0.0f;
|
|
if((idx=GetChannelIdxByName(Device->RealOut, chans[c].channel)) != -1)
|
|
voice->Direct.Gains[c].Target[idx] = DryGain;
|
|
}
|
|
|
|
/* Auxiliary sends still use normal panning since they mix to B-Format, which can't
|
|
* channel-match. */
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
if(!SendSlots[i])
|
|
{
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[c].Target[j] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels, coeffs,
|
|
WetGain[i], voice->Send[i].Gains[c].Target);
|
|
}
|
|
}
|
|
}
|
|
|
|
voice->IsHrtf = AL_FALSE;
|
|
}
|
|
else if(Device->Render_Mode == HrtfRender)
|
|
{
|
|
/* Full HRTF rendering. Skip the virtual channels and render each
|
|
* input channel to the real outputs.
|
|
*/
|
|
voice->Direct.OutBuffer = Device->RealOut.Buffer;
|
|
voice->Direct.OutChannels = Device->RealOut.NumChannels;
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
if(chans[c].channel == LFE)
|
|
{
|
|
/* Skip LFE */
|
|
voice->Direct.Hrtf[c].Target.Delay[0] = 0;
|
|
voice->Direct.Hrtf[c].Target.Delay[1] = 0;
|
|
for(i = 0;i < HRIR_LENGTH;i++)
|
|
{
|
|
voice->Direct.Hrtf[c].Target.Coeffs[i][0] = 0.0f;
|
|
voice->Direct.Hrtf[c].Target.Coeffs[i][1] = 0.0f;
|
|
}
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[c].Target[j] = 0.0f;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
/* Get the static HRIR coefficients and delays for this channel. */
|
|
GetLerpedHrtfCoeffs(Device->Hrtf,
|
|
chans[c].elevation, chans[c].angle, 0.0f, DryGain,
|
|
voice->Direct.Hrtf[c].Target.Coeffs,
|
|
voice->Direct.Hrtf[c].Target.Delay
|
|
);
|
|
|
|
/* Normal panning for auxiliary sends. */
|
|
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
if(!SendSlots[i])
|
|
{
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[c].Target[j] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels, coeffs,
|
|
WetGain[i], voice->Send[i].Gains[c].Target);
|
|
}
|
|
}
|
|
}
|
|
|
|
voice->IsHrtf = AL_TRUE;
|
|
}
|
|
else
|
|
{
|
|
/* Non-HRTF rendering. Use normal panning to the output. */
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
/* Special-case LFE */
|
|
if(chans[c].channel == LFE)
|
|
{
|
|
for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
|
|
voice->Direct.Gains[c].Target[j] = 0.0f;
|
|
if(Device->Dry.Buffer == Device->RealOut.Buffer)
|
|
{
|
|
int idx;
|
|
if((idx=GetChannelIdxByName(Device->RealOut, chans[c].channel)) != -1)
|
|
voice->Direct.Gains[c].Target[idx] = DryGain;
|
|
}
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
ALuint j;
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[c].Target[j] = 0.0f;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if(Device->Render_Mode == StereoPair)
|
|
{
|
|
/* Clamp X so it remains within 30 degrees of 0 or 180 degree azimuth. */
|
|
ALfloat x = sinf(chans[c].angle) * cosf(chans[c].elevation);
|
|
coeffs[0] = clampf(-x, -0.5f, 0.5f) + 0.5f;
|
|
voice->Direct.Gains[c].Target[0] = coeffs[0] * DryGain;
|
|
voice->Direct.Gains[c].Target[1] = (1.0f-coeffs[0]) * DryGain;
|
|
for(j = 2;j < MAX_OUTPUT_CHANNELS;j++)
|
|
voice->Direct.Gains[c].Target[j] = 0.0f;
|
|
|
|
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
|
}
|
|
else
|
|
{
|
|
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
|
ComputePanningGains(Device->Dry, coeffs, DryGain,
|
|
voice->Direct.Gains[c].Target);
|
|
}
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
if(!SendSlots[i])
|
|
{
|
|
ALuint j;
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[c].Target[j] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels, coeffs,
|
|
WetGain[i], voice->Send[i].Gains[c].Target);
|
|
}
|
|
}
|
|
}
|
|
|
|
voice->IsHrtf = AL_FALSE;
|
|
}
|
|
}
|
|
|
|
{
|
|
ALfloat hfscale = ATOMIC_LOAD(&props->Direct.HFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
ALfloat lfscale = ATOMIC_LOAD(&props->Direct.LFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
DryGainHF = maxf(DryGainHF, 0.0001f);
|
|
DryGainLF = maxf(DryGainLF, 0.0001f);
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
voice->Direct.Filters[c].ActiveType = AF_None;
|
|
if(DryGainHF != 1.0f) voice->Direct.Filters[c].ActiveType |= AF_LowPass;
|
|
if(DryGainLF != 1.0f) voice->Direct.Filters[c].ActiveType |= AF_HighPass;
|
|
ALfilterState_setParams(
|
|
&voice->Direct.Filters[c].LowPass, ALfilterType_HighShelf,
|
|
DryGainHF, hfscale, calc_rcpQ_from_slope(DryGainHF, 0.75f)
|
|
);
|
|
ALfilterState_setParams(
|
|
&voice->Direct.Filters[c].HighPass, ALfilterType_LowShelf,
|
|
DryGainLF, lfscale, calc_rcpQ_from_slope(DryGainLF, 0.75f)
|
|
);
|
|
}
|
|
}
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
ALfloat hfscale = ATOMIC_LOAD(&props->Send[i].HFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
ALfloat lfscale = ATOMIC_LOAD(&props->Send[i].LFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
WetGainHF[i] = maxf(WetGainHF[i], 0.0001f);
|
|
WetGainLF[i] = maxf(WetGainLF[i], 0.0001f);
|
|
for(c = 0;c < num_channels;c++)
|
|
{
|
|
voice->Send[i].Filters[c].ActiveType = AF_None;
|
|
if(WetGainHF[i] != 1.0f) voice->Send[i].Filters[c].ActiveType |= AF_LowPass;
|
|
if(WetGainLF[i] != 1.0f) voice->Send[i].Filters[c].ActiveType |= AF_HighPass;
|
|
ALfilterState_setParams(
|
|
&voice->Send[i].Filters[c].LowPass, ALfilterType_HighShelf,
|
|
WetGainHF[i], hfscale, calc_rcpQ_from_slope(WetGainHF[i], 0.75f)
|
|
);
|
|
ALfilterState_setParams(
|
|
&voice->Send[i].Filters[c].HighPass, ALfilterType_LowShelf,
|
|
WetGainLF[i], lfscale, calc_rcpQ_from_slope(WetGainLF[i], 0.75f)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void CalcAttnSourceParams(ALvoice *voice, const struct ALsourceProps *props, const ALbuffer *ALBuffer, const ALCcontext *ALContext)
|
|
{
|
|
const ALCdevice *Device = ALContext->Device;
|
|
const ALlistener *Listener = ALContext->Listener;
|
|
aluVector Position, Velocity, Direction, SourceToListener;
|
|
ALfloat InnerAngle,OuterAngle,Distance,ClampedDist;
|
|
ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;
|
|
ALfloat SourceVolume,ListenerGain;
|
|
ALfloat DopplerFactor, SpeedOfSound;
|
|
ALfloat AirAbsorptionFactor;
|
|
ALfloat RoomAirAbsorption[MAX_SENDS];
|
|
ALeffectslot *SendSlots[MAX_SENDS];
|
|
ALfloat Attenuation;
|
|
ALfloat RoomAttenuation[MAX_SENDS];
|
|
ALfloat MetersPerUnit;
|
|
ALfloat RoomRolloffBase;
|
|
ALfloat RoomRolloff[MAX_SENDS];
|
|
ALfloat DecayDistance[MAX_SENDS];
|
|
ALfloat DryGain;
|
|
ALfloat DryGainHF;
|
|
ALfloat DryGainLF;
|
|
ALboolean DryGainHFAuto;
|
|
ALfloat WetGain[MAX_SENDS];
|
|
ALfloat WetGainHF[MAX_SENDS];
|
|
ALfloat WetGainLF[MAX_SENDS];
|
|
ALboolean WetGainAuto;
|
|
ALboolean WetGainHFAuto;
|
|
ALfloat Pitch;
|
|
ALuint Frequency;
|
|
ALint NumSends;
|
|
ALint i;
|
|
|
|
DryGainHF = 1.0f;
|
|
DryGainLF = 1.0f;
|
|
for(i = 0;i < MAX_SENDS;i++)
|
|
{
|
|
WetGainHF[i] = 1.0f;
|
|
WetGainLF[i] = 1.0f;
|
|
}
|
|
|
|
/* Get context/device properties */
|
|
DopplerFactor = Listener->Params.DopplerFactor;
|
|
SpeedOfSound = Listener->Params.SpeedOfSound;
|
|
NumSends = Device->NumAuxSends;
|
|
Frequency = Device->Frequency;
|
|
|
|
/* Get listener properties */
|
|
ListenerGain = Listener->Params.Gain;
|
|
MetersPerUnit = Listener->Params.MetersPerUnit;
|
|
|
|
/* Get source properties */
|
|
SourceVolume = ATOMIC_LOAD(&props->Gain, almemory_order_relaxed);
|
|
MinVolume = ATOMIC_LOAD(&props->MinGain, almemory_order_relaxed);
|
|
MaxVolume = ATOMIC_LOAD(&props->MaxGain, almemory_order_relaxed);
|
|
Pitch = ATOMIC_LOAD(&props->Pitch, almemory_order_relaxed);
|
|
aluVectorSet(&Position, ATOMIC_LOAD(&props->Position[0], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Position[1], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Position[2], almemory_order_relaxed),
|
|
1.0f);
|
|
aluVectorSet(&Direction, ATOMIC_LOAD(&props->Direction[0], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Direction[1], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Direction[2], almemory_order_relaxed),
|
|
0.0f);
|
|
aluVectorSet(&Velocity, ATOMIC_LOAD(&props->Velocity[0], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Velocity[1], almemory_order_relaxed),
|
|
ATOMIC_LOAD(&props->Velocity[2], almemory_order_relaxed),
|
|
0.0f);
|
|
MinDist = ATOMIC_LOAD(&props->RefDistance, almemory_order_relaxed);
|
|
MaxDist = ATOMIC_LOAD(&props->MaxDistance, almemory_order_relaxed);
|
|
Rolloff = ATOMIC_LOAD(&props->RollOffFactor, almemory_order_relaxed);
|
|
DopplerFactor *= ATOMIC_LOAD(&props->DopplerFactor, almemory_order_relaxed);
|
|
InnerAngle = ATOMIC_LOAD(&props->InnerAngle, almemory_order_relaxed);
|
|
OuterAngle = ATOMIC_LOAD(&props->OuterAngle, almemory_order_relaxed);
|
|
AirAbsorptionFactor = ATOMIC_LOAD(&props->AirAbsorptionFactor, almemory_order_relaxed);
|
|
DryGainHFAuto = ATOMIC_LOAD(&props->DryGainHFAuto, almemory_order_relaxed);
|
|
WetGainAuto = ATOMIC_LOAD(&props->WetGainAuto, almemory_order_relaxed);
|
|
WetGainHFAuto = ATOMIC_LOAD(&props->WetGainHFAuto, almemory_order_relaxed);
|
|
RoomRolloffBase = ATOMIC_LOAD(&props->RoomRolloffFactor, almemory_order_relaxed);
|
|
|
|
voice->Direct.OutBuffer = Device->Dry.Buffer;
|
|
voice->Direct.OutChannels = Device->Dry.NumChannels;
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
SendSlots[i] = ATOMIC_LOAD(&props->Send[i].Slot, almemory_order_relaxed);
|
|
|
|
if(!SendSlots[i] && i == 0)
|
|
SendSlots[i] = Device->DefaultSlot;
|
|
if(!SendSlots[i] || SendSlots[i]->Params.EffectType == AL_EFFECT_NULL)
|
|
{
|
|
SendSlots[i] = NULL;
|
|
RoomRolloff[i] = 0.0f;
|
|
DecayDistance[i] = 0.0f;
|
|
RoomAirAbsorption[i] = 1.0f;
|
|
}
|
|
else if(SendSlots[i]->Params.AuxSendAuto)
|
|
{
|
|
RoomRolloff[i] = SendSlots[i]->Params.RoomRolloff + RoomRolloffBase;
|
|
DecayDistance[i] = SendSlots[i]->Params.DecayTime *
|
|
SPEEDOFSOUNDMETRESPERSEC;
|
|
RoomAirAbsorption[i] = SendSlots[i]->Params.AirAbsorptionGainHF;
|
|
}
|
|
else
|
|
{
|
|
/* If the slot's auxiliary send auto is off, the data sent to the
|
|
* effect slot is the same as the dry path, sans filter effects */
|
|
RoomRolloff[i] = Rolloff;
|
|
DecayDistance[i] = 0.0f;
|
|
RoomAirAbsorption[i] = AIRABSORBGAINHF;
|
|
}
|
|
|
|
if(!SendSlots[i])
|
|
{
|
|
voice->Send[i].OutBuffer = NULL;
|
|
voice->Send[i].OutChannels = 0;
|
|
}
|
|
else
|
|
{
|
|
voice->Send[i].OutBuffer = SendSlots[i]->WetBuffer;
|
|
voice->Send[i].OutChannels = SendSlots[i]->NumChannels;
|
|
}
|
|
}
|
|
voice->Looping = ATOMIC_LOAD(&props->Looping, almemory_order_relaxed);
|
|
|
|
/* Transform source to listener space (convert to head relative) */
|
|
if(ATOMIC_LOAD(&props->HeadRelative, almemory_order_relaxed) == AL_FALSE)
|
|
{
|
|
const aluMatrixf *Matrix = &Listener->Params.Matrix;
|
|
/* Transform source vectors */
|
|
Position = aluMatrixfVector(Matrix, &Position);
|
|
Velocity = aluMatrixfVector(Matrix, &Velocity);
|
|
Direction = aluMatrixfVector(Matrix, &Direction);
|
|
}
|
|
else
|
|
{
|
|
const aluVector *lvelocity = &Listener->Params.Velocity;
|
|
/* Offset the source velocity to be relative of the listener velocity */
|
|
Velocity.v[0] += lvelocity->v[0];
|
|
Velocity.v[1] += lvelocity->v[1];
|
|
Velocity.v[2] += lvelocity->v[2];
|
|
}
|
|
|
|
aluNormalize(Direction.v);
|
|
SourceToListener.v[0] = -Position.v[0];
|
|
SourceToListener.v[1] = -Position.v[1];
|
|
SourceToListener.v[2] = -Position.v[2];
|
|
SourceToListener.v[3] = 0.0f;
|
|
Distance = aluNormalize(SourceToListener.v);
|
|
|
|
/* Calculate distance attenuation */
|
|
ClampedDist = Distance;
|
|
|
|
Attenuation = 1.0f;
|
|
for(i = 0;i < NumSends;i++)
|
|
RoomAttenuation[i] = 1.0f;
|
|
switch(ATOMIC_LOAD(&props->DistanceModel, almemory_order_relaxed))
|
|
{
|
|
case InverseDistanceClamped:
|
|
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
|
|
if(MaxDist < MinDist)
|
|
break;
|
|
/*fall-through*/
|
|
case InverseDistance:
|
|
if(MinDist > 0.0f)
|
|
{
|
|
ALfloat dist = lerp(MinDist, ClampedDist, Rolloff);
|
|
if(dist > 0.0f) Attenuation = MinDist / dist;
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
dist = lerp(MinDist, ClampedDist, RoomRolloff[i]);
|
|
if(dist > 0.0f) RoomAttenuation[i] = MinDist / dist;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LinearDistanceClamped:
|
|
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
|
|
if(MaxDist < MinDist)
|
|
break;
|
|
/*fall-through*/
|
|
case LinearDistance:
|
|
if(MaxDist != MinDist)
|
|
{
|
|
Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));
|
|
Attenuation = maxf(Attenuation, 0.0f);
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));
|
|
RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ExponentDistanceClamped:
|
|
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
|
|
if(MaxDist < MinDist)
|
|
break;
|
|
/*fall-through*/
|
|
case ExponentDistance:
|
|
if(ClampedDist > 0.0f && MinDist > 0.0f)
|
|
{
|
|
Attenuation = powf(ClampedDist/MinDist, -Rolloff);
|
|
for(i = 0;i < NumSends;i++)
|
|
RoomAttenuation[i] = powf(ClampedDist/MinDist, -RoomRolloff[i]);
|
|
}
|
|
break;
|
|
|
|
case DisableDistance:
|
|
ClampedDist = MinDist;
|
|
break;
|
|
}
|
|
|
|
/* Source Gain + Attenuation */
|
|
DryGain = SourceVolume * Attenuation;
|
|
for(i = 0;i < NumSends;i++)
|
|
WetGain[i] = SourceVolume * RoomAttenuation[i];
|
|
|
|
/* Distance-based air absorption */
|
|
if(AirAbsorptionFactor > 0.0f && ClampedDist > MinDist)
|
|
{
|
|
ALfloat meters = (ClampedDist-MinDist) * MetersPerUnit;
|
|
DryGainHF *= powf(AIRABSORBGAINHF, AirAbsorptionFactor*meters);
|
|
for(i = 0;i < NumSends;i++)
|
|
WetGainHF[i] *= powf(RoomAirAbsorption[i], AirAbsorptionFactor*meters);
|
|
}
|
|
|
|
if(WetGainAuto)
|
|
{
|
|
ALfloat ApparentDist = 1.0f/maxf(Attenuation, 0.00001f) - 1.0f;
|
|
|
|
/* Apply a decay-time transformation to the wet path, based on the
|
|
* attenuation of the dry path.
|
|
*
|
|
* Using the apparent distance, based on the distance attenuation, the
|
|
* initial decay of the reverb effect is calculated and applied to the
|
|
* wet path.
|
|
*/
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
if(DecayDistance[i] > 0.0f)
|
|
WetGain[i] *= powf(0.001f/*-60dB*/, ApparentDist/DecayDistance[i]);
|
|
}
|
|
}
|
|
|
|
/* Calculate directional soundcones */
|
|
if(InnerAngle < 360.0f)
|
|
{
|
|
ALfloat ConeVolume;
|
|
ALfloat ConeHF;
|
|
ALfloat Angle;
|
|
ALfloat scale;
|
|
|
|
Angle = RAD2DEG(acosf(aluDotproduct(&Direction, &SourceToListener)) * ConeScale) * 2.0f;
|
|
if(Angle > InnerAngle)
|
|
{
|
|
if(Angle < OuterAngle)
|
|
{
|
|
scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
|
|
ConeVolume = lerp(
|
|
1.0f, ATOMIC_LOAD(&props->OuterGain, almemory_order_relaxed), scale
|
|
);
|
|
ConeHF = lerp(
|
|
1.0f, ATOMIC_LOAD(&props->OuterGainHF, almemory_order_relaxed), scale
|
|
);
|
|
}
|
|
else
|
|
{
|
|
ConeVolume = ATOMIC_LOAD(&props->OuterGain, almemory_order_relaxed);
|
|
ConeHF = ATOMIC_LOAD(&props->OuterGainHF, almemory_order_relaxed);
|
|
}
|
|
DryGain *= ConeVolume;
|
|
if(DryGainHFAuto)
|
|
DryGainHF *= ConeHF;
|
|
}
|
|
|
|
/* Wet path uses the total area of the cone emitter (the room will
|
|
* receive the same amount of sound regardless of its direction).
|
|
*/
|
|
scale = (asinf(maxf((OuterAngle-InnerAngle)/360.0f, 0.0f)) / F_PI) +
|
|
(InnerAngle/360.0f);
|
|
if(WetGainAuto)
|
|
{
|
|
ConeVolume = lerp(
|
|
1.0f, ATOMIC_LOAD(&props->OuterGain, almemory_order_relaxed), scale
|
|
);
|
|
for(i = 0;i < NumSends;i++)
|
|
WetGain[i] *= ConeVolume;
|
|
}
|
|
if(WetGainHFAuto)
|
|
{
|
|
ConeHF = lerp(
|
|
1.0f, ATOMIC_LOAD(&props->OuterGainHF, almemory_order_relaxed), scale
|
|
);
|
|
for(i = 0;i < NumSends;i++)
|
|
WetGainHF[i] *= ConeHF;
|
|
}
|
|
}
|
|
|
|
/* Clamp to Min/Max Gain */
|
|
DryGain = clampf(DryGain, MinVolume, MaxVolume);
|
|
for(i = 0;i < NumSends;i++)
|
|
WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);
|
|
|
|
/* Apply gain and frequency filters */
|
|
DryGain *= ATOMIC_LOAD(&props->Direct.Gain, almemory_order_relaxed) * ListenerGain;
|
|
DryGainHF *= ATOMIC_LOAD(&props->Direct.GainHF, almemory_order_relaxed);
|
|
DryGainLF *= ATOMIC_LOAD(&props->Direct.GainLF, almemory_order_relaxed);
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
WetGain[i] *= ATOMIC_LOAD(&props->Send[i].Gain, almemory_order_relaxed) * ListenerGain;
|
|
WetGainHF[i] *= ATOMIC_LOAD(&props->Send[i].GainHF, almemory_order_relaxed);
|
|
WetGainLF[i] *= ATOMIC_LOAD(&props->Send[i].GainLF, almemory_order_relaxed);
|
|
}
|
|
|
|
/* Calculate velocity-based doppler effect */
|
|
if(DopplerFactor > 0.0f)
|
|
{
|
|
const aluVector *lvelocity = &Listener->Params.Velocity;
|
|
ALfloat VSS, VLS;
|
|
|
|
if(SpeedOfSound < 1.0f)
|
|
{
|
|
DopplerFactor *= 1.0f/SpeedOfSound;
|
|
SpeedOfSound = 1.0f;
|
|
}
|
|
|
|
VSS = aluDotproduct(&Velocity, &SourceToListener) * DopplerFactor;
|
|
VLS = aluDotproduct(lvelocity, &SourceToListener) * DopplerFactor;
|
|
|
|
Pitch *= clampf(SpeedOfSound-VLS, 1.0f, SpeedOfSound*2.0f - 1.0f) /
|
|
clampf(SpeedOfSound-VSS, 1.0f, SpeedOfSound*2.0f - 1.0f);
|
|
}
|
|
|
|
/* Calculate fixed-point stepping value, based on the pitch, buffer
|
|
* frequency, and output frequency.
|
|
*/
|
|
Pitch *= (ALfloat)ALBuffer->Frequency / Frequency;
|
|
if(Pitch > (ALfloat)MAX_PITCH)
|
|
voice->Step = MAX_PITCH<<FRACTIONBITS;
|
|
else
|
|
voice->Step = maxi(fastf2i(Pitch*FRACTIONONE + 0.5f), 1);
|
|
BsincPrepare(voice->Step, &voice->SincState);
|
|
|
|
if(Device->Render_Mode == HrtfRender)
|
|
{
|
|
/* Full HRTF rendering. Skip the virtual channels and render to the
|
|
* real outputs.
|
|
*/
|
|
ALfloat dir[3] = { 0.0f, 0.0f, -1.0f };
|
|
ALfloat ev = 0.0f, az = 0.0f;
|
|
ALfloat radius = ATOMIC_LOAD(&props->Radius, almemory_order_relaxed);
|
|
ALfloat coeffs[MAX_AMBI_COEFFS];
|
|
ALfloat spread = 0.0f;
|
|
|
|
voice->Direct.OutBuffer = Device->RealOut.Buffer;
|
|
voice->Direct.OutChannels = Device->RealOut.NumChannels;
|
|
|
|
if(Distance > FLT_EPSILON)
|
|
{
|
|
dir[0] = -SourceToListener.v[0];
|
|
dir[1] = -SourceToListener.v[1];
|
|
dir[2] = -SourceToListener.v[2] * ZScale;
|
|
|
|
/* Calculate elevation and azimuth only when the source is not at
|
|
* the listener. This prevents +0 and -0 Z from producing
|
|
* inconsistent panning. Also, clamp Y in case FP precision errors
|
|
* cause it to land outside of -1..+1. */
|
|
ev = asinf(clampf(dir[1], -1.0f, 1.0f));
|
|
az = atan2f(dir[0], -dir[2]);
|
|
}
|
|
if(radius > Distance)
|
|
spread = F_TAU - Distance/radius*F_PI;
|
|
else if(Distance > FLT_EPSILON)
|
|
spread = asinf(radius / Distance) * 2.0f;
|
|
|
|
/* Get the HRIR coefficients and delays. */
|
|
GetLerpedHrtfCoeffs(Device->Hrtf, ev, az, spread, DryGain,
|
|
voice->Direct.Hrtf[0].Target.Coeffs,
|
|
voice->Direct.Hrtf[0].Target.Delay);
|
|
|
|
CalcDirectionCoeffs(dir, spread, coeffs);
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
if(!SendSlots[i])
|
|
{
|
|
ALuint j;
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[0].Target[j] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels, coeffs,
|
|
WetGain[i], voice->Send[i].Gains[0].Target);
|
|
}
|
|
}
|
|
|
|
voice->IsHrtf = AL_TRUE;
|
|
}
|
|
else
|
|
{
|
|
/* Non-HRTF rendering. */
|
|
ALfloat dir[3] = { 0.0f, 0.0f, -1.0f };
|
|
ALfloat radius = ATOMIC_LOAD(&props->Radius, almemory_order_relaxed);
|
|
ALfloat coeffs[MAX_AMBI_COEFFS];
|
|
ALfloat spread = 0.0f;
|
|
|
|
/* Get the localized direction, and compute panned gains. */
|
|
if(Distance > FLT_EPSILON)
|
|
{
|
|
dir[0] = -SourceToListener.v[0];
|
|
dir[1] = -SourceToListener.v[1];
|
|
dir[2] = -SourceToListener.v[2] * ZScale;
|
|
}
|
|
if(radius > Distance)
|
|
spread = F_TAU - Distance/radius*F_PI;
|
|
else if(Distance > FLT_EPSILON)
|
|
spread = asinf(radius / Distance) * 2.0f;
|
|
|
|
if(Device->Render_Mode == StereoPair)
|
|
{
|
|
/* Clamp X so it remains within 30 degrees of 0 or 180 degree azimuth. */
|
|
ALfloat x = -dir[0] * (0.5f * (cosf(spread*0.5f) + 1.0f));
|
|
x = clampf(x, -0.5f, 0.5f) + 0.5f;
|
|
voice->Direct.Gains[0].Target[0] = x * DryGain;
|
|
voice->Direct.Gains[0].Target[1] = (1.0f-x) * DryGain;
|
|
for(i = 2;i < MAX_OUTPUT_CHANNELS;i++)
|
|
voice->Direct.Gains[0].Target[i] = 0.0f;
|
|
|
|
CalcDirectionCoeffs(dir, spread, coeffs);
|
|
}
|
|
else
|
|
{
|
|
CalcDirectionCoeffs(dir, spread, coeffs);
|
|
ComputePanningGains(Device->Dry, coeffs, DryGain, voice->Direct.Gains[0].Target);
|
|
}
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
if(!SendSlots[i])
|
|
{
|
|
ALuint j;
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
voice->Send[i].Gains[0].Target[j] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels, coeffs,
|
|
WetGain[i], voice->Send[i].Gains[0].Target);
|
|
}
|
|
}
|
|
|
|
voice->IsHrtf = AL_FALSE;
|
|
}
|
|
|
|
{
|
|
ALfloat hfscale = ATOMIC_LOAD(&props->Direct.HFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
ALfloat lfscale = ATOMIC_LOAD(&props->Direct.LFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
DryGainHF = maxf(DryGainHF, 0.0001f);
|
|
DryGainLF = maxf(DryGainLF, 0.0001f);
|
|
voice->Direct.Filters[0].ActiveType = AF_None;
|
|
if(DryGainHF != 1.0f) voice->Direct.Filters[0].ActiveType |= AF_LowPass;
|
|
if(DryGainLF != 1.0f) voice->Direct.Filters[0].ActiveType |= AF_HighPass;
|
|
ALfilterState_setParams(
|
|
&voice->Direct.Filters[0].LowPass, ALfilterType_HighShelf,
|
|
DryGainHF, hfscale, calc_rcpQ_from_slope(DryGainHF, 0.75f)
|
|
);
|
|
ALfilterState_setParams(
|
|
&voice->Direct.Filters[0].HighPass, ALfilterType_LowShelf,
|
|
DryGainLF, lfscale, calc_rcpQ_from_slope(DryGainLF, 0.75f)
|
|
);
|
|
}
|
|
for(i = 0;i < NumSends;i++)
|
|
{
|
|
ALfloat hfscale = ATOMIC_LOAD(&props->Send[i].HFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
ALfloat lfscale = ATOMIC_LOAD(&props->Send[i].LFReference, almemory_order_relaxed) /
|
|
Frequency;
|
|
WetGainHF[i] = maxf(WetGainHF[i], 0.0001f);
|
|
WetGainLF[i] = maxf(WetGainLF[i], 0.0001f);
|
|
voice->Send[i].Filters[0].ActiveType = AF_None;
|
|
if(WetGainHF[i] != 1.0f) voice->Send[i].Filters[0].ActiveType |= AF_LowPass;
|
|
if(WetGainLF[i] != 1.0f) voice->Send[i].Filters[0].ActiveType |= AF_HighPass;
|
|
ALfilterState_setParams(
|
|
&voice->Send[i].Filters[0].LowPass, ALfilterType_HighShelf,
|
|
WetGainHF[i], hfscale, calc_rcpQ_from_slope(WetGainHF[i], 0.75f)
|
|
);
|
|
ALfilterState_setParams(
|
|
&voice->Send[i].Filters[0].HighPass, ALfilterType_LowShelf,
|
|
WetGainLF[i], lfscale, calc_rcpQ_from_slope(WetGainLF[i], 0.75f)
|
|
);
|
|
}
|
|
}
|
|
|
|
static void CalcSourceParams(ALvoice *voice, ALCcontext *context)
|
|
{
|
|
ALsource *source = voice->Source;
|
|
ALbufferlistitem *BufferListItem;
|
|
struct ALsourceProps *first;
|
|
struct ALsourceProps *props;
|
|
|
|
props = ATOMIC_EXCHANGE(struct ALsourceProps*, &source->Update, NULL, almemory_order_acq_rel);
|
|
if(!props) return;
|
|
|
|
BufferListItem = ATOMIC_LOAD(&source->queue, almemory_order_relaxed);
|
|
while(BufferListItem != NULL)
|
|
{
|
|
ALbuffer *buffer;
|
|
if((buffer=BufferListItem->buffer) != NULL)
|
|
{
|
|
if(buffer->FmtChannels == FmtMono)
|
|
CalcAttnSourceParams(voice, props, buffer, context);
|
|
else
|
|
CalcNonAttnSourceParams(voice, props, buffer, context);
|
|
break;
|
|
}
|
|
BufferListItem = BufferListItem->next;
|
|
}
|
|
|
|
/* WARNING: A livelock is theoretically possible if another thread keeps
|
|
* changing the freelist head without giving this a chance to actually swap
|
|
* in the old container (practically impossible with this little code,
|
|
* but...).
|
|
*/
|
|
first = ATOMIC_LOAD(&source->FreeList);
|
|
do {
|
|
ATOMIC_STORE(&props->next, first, almemory_order_relaxed);
|
|
} while(ATOMIC_COMPARE_EXCHANGE_WEAK(struct ALsourceProps*,
|
|
&source->FreeList, &first, props) == 0);
|
|
}
|
|
|
|
|
|
static void UpdateContextSources(ALCcontext *ctx, ALeffectslot *slot)
|
|
{
|
|
ALvoice *voice, *voice_end;
|
|
ALsource *source;
|
|
|
|
IncrementRef(&ctx->UpdateCount);
|
|
if(!ATOMIC_LOAD(&ctx->HoldUpdates))
|
|
{
|
|
CalcListenerParams(ctx);
|
|
while(slot)
|
|
{
|
|
CalcEffectSlotParams(slot, ctx->Device);
|
|
slot = ATOMIC_LOAD(&slot->next, almemory_order_relaxed);
|
|
}
|
|
|
|
voice = ctx->Voices;
|
|
voice_end = voice + ctx->VoiceCount;
|
|
for(;voice != voice_end;++voice)
|
|
{
|
|
if(!(source=voice->Source)) continue;
|
|
if(source->state != AL_PLAYING && source->state != AL_PAUSED)
|
|
voice->Source = NULL;
|
|
else
|
|
CalcSourceParams(voice, ctx);
|
|
}
|
|
}
|
|
IncrementRef(&ctx->UpdateCount);
|
|
}
|
|
|
|
|
|
/* Specialized function to clamp to [-1, +1] with only one branch. This also
|
|
* converts NaN to 0. */
|
|
static inline ALfloat aluClampf(ALfloat val)
|
|
{
|
|
if(fabsf(val) <= 1.0f) return val;
|
|
return (ALfloat)((0.0f < val) - (val < 0.0f));
|
|
}
|
|
|
|
static inline ALfloat aluF2F(ALfloat val)
|
|
{ return val; }
|
|
|
|
static inline ALint aluF2I(ALfloat val)
|
|
{
|
|
/* Floats only have a 24-bit mantissa, so [-16777215, +16777215] is the max
|
|
* integer range normalized floats can be safely converted to.
|
|
*/
|
|
return fastf2i(aluClampf(val)*16777215.0f)<<7;
|
|
}
|
|
static inline ALuint aluF2UI(ALfloat val)
|
|
{ return aluF2I(val)+2147483648u; }
|
|
|
|
static inline ALshort aluF2S(ALfloat val)
|
|
{ return fastf2i(aluClampf(val)*32767.0f); }
|
|
static inline ALushort aluF2US(ALfloat val)
|
|
{ return aluF2S(val)+32768; }
|
|
|
|
static inline ALbyte aluF2B(ALfloat val)
|
|
{ return fastf2i(aluClampf(val)*127.0f); }
|
|
static inline ALubyte aluF2UB(ALfloat val)
|
|
{ return aluF2B(val)+128; }
|
|
|
|
#define DECL_TEMPLATE(T, func) \
|
|
static void Write_##T(ALfloatBUFFERSIZE *InBuffer, ALvoid *OutBuffer, \
|
|
ALuint SamplesToDo, ALuint numchans) \
|
|
{ \
|
|
ALuint i, j; \
|
|
for(j = 0;j < numchans;j++) \
|
|
{ \
|
|
const ALfloat *in = InBuffer[j]; \
|
|
T *restrict out = (T*)OutBuffer + j; \
|
|
for(i = 0;i < SamplesToDo;i++) \
|
|
out[i*numchans] = func(in[i]); \
|
|
} \
|
|
}
|
|
|
|
DECL_TEMPLATE(ALfloat, aluF2F)
|
|
DECL_TEMPLATE(ALuint, aluF2UI)
|
|
DECL_TEMPLATE(ALint, aluF2I)
|
|
DECL_TEMPLATE(ALushort, aluF2US)
|
|
DECL_TEMPLATE(ALshort, aluF2S)
|
|
DECL_TEMPLATE(ALubyte, aluF2UB)
|
|
DECL_TEMPLATE(ALbyte, aluF2B)
|
|
|
|
#undef DECL_TEMPLATE
|
|
|
|
|
|
ALvoid aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
|
|
{
|
|
ALuint SamplesToDo;
|
|
ALvoice *voice, *voice_end;
|
|
ALeffectslot *slot;
|
|
ALsource *source;
|
|
ALCcontext *ctx;
|
|
FPUCtl oldMode;
|
|
ALuint i, c;
|
|
|
|
SetMixerFPUMode(&oldMode);
|
|
|
|
while(size > 0)
|
|
{
|
|
SamplesToDo = minu(size, BUFFERSIZE);
|
|
for(c = 0;c < device->Dry.NumChannels;c++)
|
|
memset(device->Dry.Buffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
|
if(device->Dry.Buffer != device->RealOut.Buffer)
|
|
for(c = 0;c < device->RealOut.NumChannels;c++)
|
|
memset(device->RealOut.Buffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
|
if(device->Dry.Buffer != device->FOAOut.Buffer)
|
|
for(c = 0;c < device->FOAOut.NumChannels;c++)
|
|
memset(device->FOAOut.Buffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
|
|
|
IncrementRef(&device->MixCount);
|
|
V0(device->Backend,lock)();
|
|
|
|
if((slot=device->DefaultSlot) != NULL)
|
|
{
|
|
CalcEffectSlotParams(device->DefaultSlot, device);
|
|
for(i = 0;i < slot->NumChannels;i++)
|
|
memset(slot->WetBuffer[i], 0, SamplesToDo*sizeof(ALfloat));
|
|
}
|
|
|
|
ctx = ATOMIC_LOAD(&device->ContextList);
|
|
while(ctx)
|
|
{
|
|
ALeffectslot *slotroot;
|
|
|
|
slotroot = ATOMIC_LOAD(&ctx->ActiveAuxSlotList);
|
|
UpdateContextSources(ctx, slotroot);
|
|
|
|
slot = slotroot;
|
|
while(slot)
|
|
{
|
|
for(i = 0;i < slot->NumChannels;i++)
|
|
memset(slot->WetBuffer[i], 0, SamplesToDo*sizeof(ALfloat));
|
|
slot = ATOMIC_LOAD(&slot->next, almemory_order_relaxed);
|
|
}
|
|
|
|
/* source processing */
|
|
voice = ctx->Voices;
|
|
voice_end = voice + ctx->VoiceCount;
|
|
for(;voice != voice_end;++voice)
|
|
{
|
|
ALboolean IsVoiceInit = (voice->Step > 0);
|
|
source = voice->Source;
|
|
if(source && source->state == AL_PLAYING && IsVoiceInit)
|
|
MixSource(voice, source, device, SamplesToDo);
|
|
}
|
|
|
|
/* effect slot processing */
|
|
slot = slotroot;
|
|
while(slot)
|
|
{
|
|
const ALeffectslot *cslot = slot;
|
|
ALeffectState *state = cslot->Params.EffectState;
|
|
V(state,process)(SamplesToDo, cslot->WetBuffer, state->OutBuffer,
|
|
state->OutChannels);
|
|
slot = ATOMIC_LOAD(&slot->next, almemory_order_relaxed);
|
|
}
|
|
|
|
ctx = ctx->next;
|
|
}
|
|
|
|
if(device->DefaultSlot != NULL)
|
|
{
|
|
const ALeffectslot *slot = device->DefaultSlot;
|
|
ALeffectState *state = slot->Params.EffectState;
|
|
V(state,process)(SamplesToDo, slot->WetBuffer, state->OutBuffer,
|
|
state->OutChannels);
|
|
}
|
|
|
|
/* Increment the clock time. Every second's worth of samples is
|
|
* converted and added to clock base so that large sample counts don't
|
|
* overflow during conversion. This also guarantees an exact, stable
|
|
* conversion. */
|
|
device->SamplesDone += SamplesToDo;
|
|
device->ClockBase += (device->SamplesDone/device->Frequency) * DEVICE_CLOCK_RES;
|
|
device->SamplesDone %= device->Frequency;
|
|
V0(device->Backend,unlock)();
|
|
IncrementRef(&device->MixCount);
|
|
|
|
if(device->Hrtf)
|
|
{
|
|
int lidx = GetChannelIdxByName(device->RealOut, FrontLeft);
|
|
int ridx = GetChannelIdxByName(device->RealOut, FrontRight);
|
|
if(lidx != -1 && ridx != -1)
|
|
{
|
|
HrtfMixerFunc HrtfMix = SelectHrtfMixer();
|
|
ALuint irsize = device->Hrtf->irSize;
|
|
MixHrtfParams hrtfparams;
|
|
memset(&hrtfparams, 0, sizeof(hrtfparams));
|
|
for(c = 0;c < device->Dry.NumChannels;c++)
|
|
{
|
|
hrtfparams.Current = &device->Hrtf_Params[c];
|
|
hrtfparams.Target = &device->Hrtf_Params[c];
|
|
HrtfMix(device->RealOut.Buffer, lidx, ridx,
|
|
device->Dry.Buffer[c], 0, device->Hrtf_Offset, 0,
|
|
irsize, &hrtfparams, &device->Hrtf_State[c], SamplesToDo
|
|
);
|
|
}
|
|
device->Hrtf_Offset += SamplesToDo;
|
|
}
|
|
}
|
|
else if(device->AmbiDecoder)
|
|
{
|
|
if(device->Dry.Buffer != device->FOAOut.Buffer)
|
|
bformatdec_upSample(device->AmbiDecoder,
|
|
device->Dry.Buffer, device->FOAOut.Buffer,
|
|
device->FOAOut.NumChannels, SamplesToDo
|
|
);
|
|
bformatdec_process(device->AmbiDecoder,
|
|
device->RealOut.Buffer, device->RealOut.NumChannels,
|
|
device->Dry.Buffer, SamplesToDo
|
|
);
|
|
}
|
|
else
|
|
{
|
|
if(device->Uhj_Encoder)
|
|
{
|
|
int lidx = GetChannelIdxByName(device->RealOut, FrontLeft);
|
|
int ridx = GetChannelIdxByName(device->RealOut, FrontRight);
|
|
if(lidx != -1 && ridx != -1)
|
|
{
|
|
/* Encode to stereo-compatible 2-channel UHJ output. */
|
|
EncodeUhj2(device->Uhj_Encoder,
|
|
device->RealOut.Buffer[lidx], device->RealOut.Buffer[ridx],
|
|
device->Dry.Buffer, SamplesToDo
|
|
);
|
|
}
|
|
}
|
|
if(device->Bs2b)
|
|
{
|
|
/* Apply binaural/crossfeed filter */
|
|
for(i = 0;i < SamplesToDo;i++)
|
|
{
|
|
float samples[2];
|
|
samples[0] = device->RealOut.Buffer[0][i];
|
|
samples[1] = device->RealOut.Buffer[1][i];
|
|
bs2b_cross_feed(device->Bs2b, samples);
|
|
device->RealOut.Buffer[0][i] = samples[0];
|
|
device->RealOut.Buffer[1][i] = samples[1];
|
|
}
|
|
}
|
|
}
|
|
|
|
if(buffer)
|
|
{
|
|
ALfloat (*OutBuffer)[BUFFERSIZE] = device->RealOut.Buffer;
|
|
ALuint OutChannels = device->RealOut.NumChannels;
|
|
|
|
#define WRITE(T, a, b, c, d) do { \
|
|
Write_##T((a), (b), (c), (d)); \
|
|
buffer = (T*)buffer + (c)*(d); \
|
|
} while(0)
|
|
switch(device->FmtType)
|
|
{
|
|
case DevFmtByte:
|
|
WRITE(ALbyte, OutBuffer, buffer, SamplesToDo, OutChannels);
|
|
break;
|
|
case DevFmtUByte:
|
|
WRITE(ALubyte, OutBuffer, buffer, SamplesToDo, OutChannels);
|
|
break;
|
|
case DevFmtShort:
|
|
WRITE(ALshort, OutBuffer, buffer, SamplesToDo, OutChannels);
|
|
break;
|
|
case DevFmtUShort:
|
|
WRITE(ALushort, OutBuffer, buffer, SamplesToDo, OutChannels);
|
|
break;
|
|
case DevFmtInt:
|
|
WRITE(ALint, OutBuffer, buffer, SamplesToDo, OutChannels);
|
|
break;
|
|
case DevFmtUInt:
|
|
WRITE(ALuint, OutBuffer, buffer, SamplesToDo, OutChannels);
|
|
break;
|
|
case DevFmtFloat:
|
|
WRITE(ALfloat, OutBuffer, buffer, SamplesToDo, OutChannels);
|
|
break;
|
|
}
|
|
#undef WRITE
|
|
}
|
|
|
|
size -= SamplesToDo;
|
|
}
|
|
|
|
RestoreFPUMode(&oldMode);
|
|
}
|
|
|
|
|
|
ALvoid aluHandleDisconnect(ALCdevice *device)
|
|
{
|
|
ALCcontext *Context;
|
|
|
|
device->Connected = ALC_FALSE;
|
|
|
|
Context = ATOMIC_LOAD(&device->ContextList);
|
|
while(Context)
|
|
{
|
|
ALvoice *voice, *voice_end;
|
|
|
|
voice = Context->Voices;
|
|
voice_end = voice + Context->VoiceCount;
|
|
while(voice != voice_end)
|
|
{
|
|
ALsource *source = voice->Source;
|
|
voice->Source = NULL;
|
|
|
|
if(source && source->state == AL_PLAYING)
|
|
{
|
|
source->state = AL_STOPPED;
|
|
ATOMIC_STORE(&source->current_buffer, NULL);
|
|
ATOMIC_STORE(&source->position, 0);
|
|
ATOMIC_STORE(&source->position_fraction, 0);
|
|
}
|
|
|
|
voice++;
|
|
}
|
|
Context->VoiceCount = 0;
|
|
|
|
Context = Context->next;
|
|
}
|
|
}
|