2007-11-14 02:02:18 +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
|
2014-08-18 12:11:03 +00:00
|
|
|
* Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2007-11-14 02:02:18 +00:00
|
|
|
* Or go to http://www.gnu.org/copyleft/lgpl.html
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <math.h>
|
2009-01-24 18:38:04 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2009-01-26 03:20:47 +00:00
|
|
|
#include <ctype.h>
|
2009-02-02 19:18:33 +00:00
|
|
|
#include <assert.h>
|
2009-01-26 03:20:47 +00:00
|
|
|
|
2007-11-14 02:02:18 +00:00
|
|
|
#include "alMain.h"
|
2007-12-31 09:09:57 +00:00
|
|
|
#include "alSource.h"
|
|
|
|
#include "alBuffer.h"
|
|
|
|
#include "alListener.h"
|
2008-01-16 22:01:24 +00:00
|
|
|
#include "alAuxEffectSlot.h"
|
2008-08-14 12:43:52 +00:00
|
|
|
#include "alu.h"
|
2008-01-03 13:36:51 +00:00
|
|
|
#include "bs2b.h"
|
2014-02-24 05:11:01 +00:00
|
|
|
#include "hrtf.h"
|
2016-02-27 00:09:06 +00:00
|
|
|
#include "uhjfilter.h"
|
2016-03-15 12:08:05 +00:00
|
|
|
#include "bformatdec.h"
|
2014-06-03 02:19:22 +00:00
|
|
|
#include "static_assert.h"
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2014-11-22 12:20:17 +00:00
|
|
|
#include "mixer_defs.h"
|
|
|
|
|
2014-11-01 22:55:18 +00:00
|
|
|
#include "backends/base.h"
|
2013-12-18 07:03:34 +00:00
|
|
|
|
2009-08-15 18:33:38 +00:00
|
|
|
|
2011-12-20 09:17:11 +00:00
|
|
|
struct ChanMap {
|
|
|
|
enum Channel channel;
|
|
|
|
ALfloat angle;
|
2014-10-03 01:05:42 +00:00
|
|
|
ALfloat elevation;
|
2011-12-20 09:17:11 +00:00
|
|
|
};
|
|
|
|
|
2011-09-24 05:33:37 +00:00
|
|
|
/* Cone scalar */
|
2012-08-11 13:20:24 +00:00
|
|
|
ALfloat ConeScale = 1.0f;
|
2011-09-24 05:33:37 +00:00
|
|
|
|
|
|
|
/* Localized Z scalar for mono sources */
|
|
|
|
ALfloat ZScale = 1.0f;
|
|
|
|
|
2013-11-04 21:44:46 +00:00
|
|
|
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);
|
|
|
|
|
2013-11-27 08:30:13 +00:00
|
|
|
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);
|
|
|
|
|
2013-11-04 21:44:46 +00:00
|
|
|
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);
|
2015-09-29 19:34:03 +00:00
|
|
|
extern inline ALfloat resample_fir4(ALfloat val0, ALfloat val1, ALfloat val2, ALfloat val3, ALuint frac);
|
2011-09-24 05:33:37 +00:00
|
|
|
|
2014-12-16 14:29:31 +00:00
|
|
|
extern inline void aluVectorSet(aluVector *restrict vector, ALfloat x, ALfloat y, ALfloat z, ALfloat w);
|
|
|
|
|
2015-11-11 16:19:33 +00:00
|
|
|
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);
|
|
|
|
|
2016-09-05 09:02:14 +00:00
|
|
|
const aluMatrixf IdentityMatrixf = {{
|
|
|
|
{ 1.0f, 0.0f, 0.0f, 0.0f },
|
|
|
|
{ 0.0f, 1.0f, 0.0f, 0.0f },
|
|
|
|
{ 0.0f, 0.0f, 1.0f, 0.0f },
|
|
|
|
{ 0.0f, 0.0f, 0.0f, 1.0f },
|
|
|
|
}};
|
|
|
|
|
2014-12-16 14:29:31 +00:00
|
|
|
|
2016-08-12 12:26:36 +00:00
|
|
|
static inline HrtfDirectMixerFunc SelectHrtfMixer(void)
|
2014-11-22 12:20:17 +00:00
|
|
|
{
|
|
|
|
#ifdef HAVE_SSE
|
|
|
|
if((CPUCapFlags&CPU_CAP_SSE))
|
2016-08-12 12:26:36 +00:00
|
|
|
return MixDirectHrtf_SSE;
|
2014-11-22 12:20:17 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NEON
|
|
|
|
if((CPUCapFlags&CPU_CAP_NEON))
|
2016-08-12 12:26:36 +00:00
|
|
|
return MixDirectHrtf_Neon;
|
2014-11-22 12:20:17 +00:00
|
|
|
#endif
|
|
|
|
|
2016-08-12 12:26:36 +00:00
|
|
|
return MixDirectHrtf_C;
|
2014-11-22 12:20:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline void aluCrossproduct(const ALfloat *inVector1, const ALfloat *inVector2, ALfloat *outVector)
|
2012-10-26 00:24:22 +00:00
|
|
|
{
|
|
|
|
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];
|
|
|
|
}
|
|
|
|
|
2014-12-16 18:36:44 +00:00
|
|
|
static inline ALfloat aluDotproduct(const aluVector *vec1, const aluVector *vec2)
|
2012-10-26 00:24:22 +00:00
|
|
|
{
|
2014-12-16 18:36:44 +00:00
|
|
|
return vec1->v[0]*vec2->v[0] + vec1->v[1]*vec2->v[1] + vec1->v[2]*vec2->v[2];
|
2012-10-26 00:24:22 +00:00
|
|
|
}
|
|
|
|
|
2016-05-16 21:46:06 +00:00
|
|
|
static ALfloat aluNormalize(ALfloat *vec)
|
2012-10-26 00:24:22 +00:00
|
|
|
{
|
2015-07-05 15:47:56 +00:00
|
|
|
ALfloat length = sqrtf(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
|
|
|
|
if(length > 0.0f)
|
2012-10-26 00:24:22 +00:00
|
|
|
{
|
2015-07-05 15:47:56 +00:00
|
|
|
ALfloat inv_length = 1.0f/length;
|
2014-12-16 18:36:44 +00:00
|
|
|
vec[0] *= inv_length;
|
|
|
|
vec[1] *= inv_length;
|
|
|
|
vec[2] *= inv_length;
|
2012-10-26 00:24:22 +00:00
|
|
|
}
|
2015-07-05 15:47:56 +00:00
|
|
|
return length;
|
2012-10-26 00:24:22 +00:00
|
|
|
}
|
|
|
|
|
2016-05-17 01:28:46 +00:00
|
|
|
static void aluMatrixfFloat3(ALfloat *vec, ALfloat w, const aluMatrixf *mtx)
|
2015-08-24 10:02:58 +00:00
|
|
|
{
|
2016-05-17 01:28:46 +00:00
|
|
|
ALfloat v[4] = { vec[0], vec[1], vec[2], w };
|
2015-08-24 10:02:58 +00:00
|
|
|
|
2015-11-11 16:19:33 +00:00
|
|
|
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];
|
2015-08-24 10:02:58 +00:00
|
|
|
}
|
|
|
|
|
2016-05-17 01:28:46 +00:00
|
|
|
static aluVector aluMatrixfVector(const aluMatrixf *mtx, const aluVector *vec)
|
2007-11-14 02:02:18 +00:00
|
|
|
{
|
2015-10-23 06:39:56 +00:00
|
|
|
aluVector v;
|
2016-05-17 01:28:46 +00:00
|
|
|
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];
|
2015-10-23 06:39:56 +00:00
|
|
|
return v;
|
2007-11-14 02:02:18 +00:00
|
|
|
}
|
|
|
|
|
2010-08-04 06:19:36 +00:00
|
|
|
|
2015-11-05 17:42:08 +00:00
|
|
|
/* 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)
|
|
|
|
{
|
2015-11-11 02:40:33 +00:00
|
|
|
static const ALfloat scaleBase = 1.510578918e-01f, scaleRange = 1.177936623e+00f;
|
2015-11-05 17:42:08 +00:00
|
|
|
static const ALuint m[BSINC_SCALE_COUNT] = { 24, 24, 24, 24, 24, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 12 };
|
2015-11-11 02:40:33 +00:00
|
|
|
static const ALuint to[4][BSINC_SCALE_COUNT] =
|
|
|
|
{
|
2015-11-05 17:42:08 +00:00
|
|
|
{ 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 }
|
|
|
|
};
|
2015-11-11 02:40:33 +00:00
|
|
|
static const ALuint tm[2][BSINC_SCALE_COUNT] =
|
|
|
|
{
|
2015-11-05 17:42:08 +00:00
|
|
|
{ 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-24 01:56:01 +00:00
|
|
|
static ALboolean CalcListenerParams(ALCcontext *Context)
|
2012-10-12 14:38:29 +00:00
|
|
|
{
|
2016-05-09 18:26:49 +00:00
|
|
|
ALlistener *Listener = Context->Listener;
|
2016-05-17 01:28:46 +00:00
|
|
|
ALfloat N[3], V[3], U[3], P[3];
|
2016-05-12 01:40:17 +00:00
|
|
|
struct ALlistenerProps *props;
|
|
|
|
aluVector vel;
|
|
|
|
|
|
|
|
props = ATOMIC_EXCHANGE(struct ALlistenerProps*, &Listener->Update, NULL, almemory_order_acq_rel);
|
2016-08-24 01:56:01 +00:00
|
|
|
if(!props) return AL_FALSE;
|
2012-10-12 14:38:29 +00:00
|
|
|
|
|
|
|
/* AT then UP */
|
2017-03-08 11:38:28 +00:00
|
|
|
N[0] = props->Forward[0];
|
|
|
|
N[1] = props->Forward[1];
|
|
|
|
N[2] = props->Forward[2];
|
2016-05-17 01:28:46 +00:00
|
|
|
aluNormalize(N);
|
2017-03-08 11:38:28 +00:00
|
|
|
V[0] = props->Up[0];
|
|
|
|
V[1] = props->Up[1];
|
|
|
|
V[2] = props->Up[2];
|
2016-05-17 01:28:46 +00:00
|
|
|
aluNormalize(V);
|
2012-10-12 14:38:29 +00:00
|
|
|
/* Build and normalize right-vector */
|
2016-05-17 01:28:46 +00:00
|
|
|
aluCrossproduct(N, V, U);
|
|
|
|
aluNormalize(U);
|
2015-11-11 16:19:33 +00:00
|
|
|
|
2016-05-17 01:28:46 +00:00
|
|
|
aluMatrixfSet(&Listener->Params.Matrix,
|
2015-11-11 16:19:33 +00:00
|
|
|
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
|
2014-12-16 14:29:31 +00:00
|
|
|
);
|
2015-08-24 10:02:58 +00:00
|
|
|
|
2017-03-08 11:38:28 +00:00
|
|
|
P[0] = props->Position[0];
|
|
|
|
P[1] = props->Position[1];
|
|
|
|
P[2] = props->Position[2];
|
2016-05-17 01:28:46 +00:00
|
|
|
aluMatrixfFloat3(P, 1.0, &Listener->Params.Matrix);
|
|
|
|
aluMatrixfSetRow(&Listener->Params.Matrix, 3, -P[0], -P[1], -P[2], 1.0f);
|
2014-12-16 14:29:31 +00:00
|
|
|
|
2017-03-08 11:38:28 +00:00
|
|
|
aluVectorSet(&vel, props->Velocity[0], props->Velocity[1], props->Velocity[2], 0.0f);
|
2016-05-17 01:28:46 +00:00
|
|
|
Listener->Params.Velocity = aluMatrixfVector(&Listener->Params.Matrix, &vel);
|
2016-05-12 01:40:17 +00:00
|
|
|
|
2017-03-08 11:38:28 +00:00
|
|
|
Listener->Params.Gain = props->Gain * Context->GainBoost;
|
|
|
|
Listener->Params.MetersPerUnit = props->MetersPerUnit;
|
2016-05-09 18:26:49 +00:00
|
|
|
|
2017-03-08 11:38:28 +00:00
|
|
|
Listener->Params.DopplerFactor = props->DopplerFactor;
|
|
|
|
Listener->Params.SpeedOfSound = props->SpeedOfSound * props->DopplerVelocity;
|
2016-05-09 18:26:49 +00:00
|
|
|
|
2017-03-08 11:38:28 +00:00
|
|
|
Listener->Params.SourceDistanceModel = props->SourceDistanceModel;
|
|
|
|
Listener->Params.DistanceModel = props->DistanceModel;
|
2016-08-24 02:17:17 +00:00
|
|
|
|
2016-12-22 03:58:03 +00:00
|
|
|
ATOMIC_REPLACE_HEAD(struct ALlistenerProps*, &Listener->FreeList, props);
|
2016-08-24 01:56:01 +00:00
|
|
|
return AL_TRUE;
|
2012-10-12 14:38:29 +00:00
|
|
|
}
|
|
|
|
|
2016-08-25 13:17:36 +00:00
|
|
|
static ALboolean CalcEffectSlotParams(ALeffectslot *slot, ALCdevice *device)
|
2016-05-13 01:26:33 +00:00
|
|
|
{
|
|
|
|
struct ALeffectslotProps *props;
|
2016-05-15 08:19:05 +00:00
|
|
|
ALeffectState *state;
|
2016-05-13 01:26:33 +00:00
|
|
|
|
|
|
|
props = ATOMIC_EXCHANGE(struct ALeffectslotProps*, &slot->Update, NULL, almemory_order_acq_rel);
|
2016-08-25 13:17:36 +00:00
|
|
|
if(!props) return AL_FALSE;
|
2016-05-13 01:26:33 +00:00
|
|
|
|
2017-03-08 11:38:28 +00:00
|
|
|
slot->Params.Gain = props->Gain;
|
|
|
|
slot->Params.AuxSendAuto = props->AuxSendAuto;
|
|
|
|
slot->Params.EffectType = props->Type;
|
2016-05-13 01:26:33 +00:00
|
|
|
if(IsReverbEffect(slot->Params.EffectType))
|
|
|
|
{
|
2016-05-14 01:28:01 +00:00
|
|
|
slot->Params.RoomRolloff = props->Props.Reverb.RoomRolloffFactor;
|
|
|
|
slot->Params.DecayTime = props->Props.Reverb.DecayTime;
|
|
|
|
slot->Params.AirAbsorptionGainHF = props->Props.Reverb.AirAbsorptionGainHF;
|
2016-05-13 01:26:33 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
slot->Params.RoomRolloff = 0.0f;
|
|
|
|
slot->Params.DecayTime = 0.0f;
|
|
|
|
slot->Params.AirAbsorptionGainHF = 1.0f;
|
|
|
|
}
|
2016-05-15 08:19:05 +00:00
|
|
|
|
2016-08-25 11:57:58 +00:00
|
|
|
/* Swap effect states. No need to play with the ref counts since they keep
|
|
|
|
* the same number of refs.
|
2016-05-13 02:05:06 +00:00
|
|
|
*/
|
2017-03-08 11:38:28 +00:00
|
|
|
state = props->State;
|
|
|
|
props->State = slot->Params.EffectState;
|
2016-08-25 11:57:58 +00:00
|
|
|
slot->Params.EffectState = state;
|
2016-05-13 01:26:33 +00:00
|
|
|
|
2016-08-25 11:57:58 +00:00
|
|
|
V(state,update)(device, slot, &props->Props);
|
2016-05-14 01:28:01 +00:00
|
|
|
|
2016-12-22 03:58:03 +00:00
|
|
|
ATOMIC_REPLACE_HEAD(struct ALeffectslotProps*, &slot->FreeList, props);
|
2016-08-25 13:17:36 +00:00
|
|
|
return AL_TRUE;
|
Provide asynchronous property updates for sources
This necessitates a change in how source updates are handled. Rather than just
being able to update sources when a dependent object state is changed (e.g. a
listener gain change), now all source updates must be proactively provided.
Consequently, apps that do not utilize any deferring (AL_SOFT_defer_updates or
alcSuspendContext/alcProcessContext) may utilize more CPU since it'll be
filling out more update containers for the mixer thread to use.
The upside is that there's less blocking between the app's calling thread and
the mixer thread, particularly for vectors and other multi-value properties
(filters and sends). Deferring behavior when used is also improved, since
updates that shouldn't be applied yet are simply not provided. And when they
are provided, the mixer doesn't have to ignore them, meaning the actual
deferring of a context doesn't have to synchrnously force an update -- the
process call will send any pending updates, which the mixer will apply even if
another deferral occurs before the mixer runs, because it'll still be there
waiting on the next mixer invocation.
There is one slight bug introduced by this commit. When a listener change is
made, or changes to multiple sources while updates are being deferred, it is
possible for the mixer to run while the sources are prepping their updates,
causing some of the source updates to be seen before the other. This will be
fixed in short order.
2016-05-15 06:43:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-05-16 21:46:06 +00:00
|
|
|
static void CalcNonAttnSourceParams(ALvoice *voice, const struct ALsourceProps *props, const ALbuffer *ALBuffer, const ALCcontext *ALContext)
|
2010-08-05 08:07:20 +00:00
|
|
|
{
|
2015-02-10 18:04:59 +00:00
|
|
|
static const struct ChanMap MonoMap[1] = {
|
|
|
|
{ FrontCenter, 0.0f, 0.0f }
|
|
|
|
}, RearMap[2] = {
|
2014-10-03 01:05:42 +00:00
|
|
|
{ BackLeft, DEG2RAD(-150.0f), DEG2RAD(0.0f) },
|
|
|
|
{ BackRight, DEG2RAD( 150.0f), DEG2RAD(0.0f) }
|
2015-02-10 18:04:59 +00:00
|
|
|
}, QuadMap[4] = {
|
2014-10-03 01:05:42 +00:00
|
|
|
{ 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) }
|
2015-02-10 18:04:59 +00:00
|
|
|
}, X51Map[6] = {
|
2014-10-03 01:05:42 +00:00
|
|
|
{ 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 },
|
2014-11-07 08:54:16 +00:00
|
|
|
{ SideLeft, DEG2RAD(-110.0f), DEG2RAD(0.0f) },
|
|
|
|
{ SideRight, DEG2RAD( 110.0f), DEG2RAD(0.0f) }
|
2015-02-10 18:04:59 +00:00
|
|
|
}, X61Map[7] = {
|
2014-10-03 01:05:42 +00:00
|
|
|
{ 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) }
|
2015-02-10 18:04:59 +00:00
|
|
|
}, X71Map[8] = {
|
2014-10-03 01:05:42 +00:00
|
|
|
{ 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) }
|
2012-02-10 07:52:20 +00:00
|
|
|
};
|
2011-06-30 06:18:49 +00:00
|
|
|
|
2016-01-25 14:11:51 +00:00
|
|
|
const ALCdevice *Device = ALContext->Device;
|
2016-05-09 18:26:49 +00:00
|
|
|
const ALlistener *Listener = ALContext->Listener;
|
2010-08-05 08:07:20 +00:00
|
|
|
ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfloat DryGain, DryGainHF, DryGainLF;
|
2010-08-05 08:07:20 +00:00
|
|
|
ALfloat WetGain[MAX_SENDS];
|
|
|
|
ALfloat WetGainHF[MAX_SENDS];
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfloat WetGainLF[MAX_SENDS];
|
2016-01-28 08:02:46 +00:00
|
|
|
ALeffectslot *SendSlots[MAX_SENDS];
|
2017-02-23 02:07:41 +00:00
|
|
|
ALfloat HFScale, LFScale;
|
2014-10-11 16:35:32 +00:00
|
|
|
ALuint NumSends, Frequency;
|
2014-11-01 05:43:13 +00:00
|
|
|
ALboolean Relative;
|
2011-12-20 09:17:11 +00:00
|
|
|
const struct ChanMap *chans = NULL;
|
2016-03-25 21:40:44 +00:00
|
|
|
struct ChanMap StereoMap[2] = {
|
|
|
|
{ FrontLeft, DEG2RAD(-30.0f), DEG2RAD(0.0f) },
|
|
|
|
{ FrontRight, DEG2RAD( 30.0f), DEG2RAD(0.0f) }
|
|
|
|
};
|
2014-10-11 16:35:32 +00:00
|
|
|
ALuint num_channels = 0;
|
2012-02-10 07:35:17 +00:00
|
|
|
ALboolean DirectChannels;
|
2014-11-01 00:18:45 +00:00
|
|
|
ALboolean isbformat = AL_FALSE;
|
2010-08-07 12:43:16 +00:00
|
|
|
ALfloat Pitch;
|
2014-10-11 16:35:32 +00:00
|
|
|
ALuint i, j, c;
|
2010-08-05 08:07:20 +00:00
|
|
|
|
2010-11-27 02:01:29 +00:00
|
|
|
/* Get device properties */
|
2011-10-12 05:30:58 +00:00
|
|
|
NumSends = Device->NumAuxSends;
|
|
|
|
Frequency = Device->Frequency;
|
2010-08-05 08:07:20 +00:00
|
|
|
|
2010-11-27 02:01:29 +00:00
|
|
|
/* Get listener properties */
|
2016-05-09 18:26:49 +00:00
|
|
|
ListenerGain = Listener->Params.Gain;
|
2010-08-05 08:07:20 +00:00
|
|
|
|
2010-11-27 02:01:29 +00:00
|
|
|
/* Get source properties */
|
2017-03-08 11:38:28 +00:00
|
|
|
SourceVolume = props->Gain;
|
|
|
|
MinVolume = props->MinGain;
|
|
|
|
MaxVolume = props->MaxGain;
|
|
|
|
Pitch = props->Pitch;
|
|
|
|
Relative = props->HeadRelative;
|
|
|
|
DirectChannels = props->DirectChannels;
|
2010-08-05 08:07:20 +00:00
|
|
|
|
2016-03-25 21:40:44 +00:00
|
|
|
/* Convert counter-clockwise to clockwise. */
|
2017-03-08 11:38:28 +00:00
|
|
|
StereoMap[0].angle = -props->StereoPan[0];
|
|
|
|
StereoMap[1].angle = -props->StereoPan[1];
|
2016-03-25 21:40:44 +00:00
|
|
|
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Buffer = Device->Dry.Buffer;
|
|
|
|
voice->Direct.Channels = Device->Dry.NumChannels;
|
2014-03-19 23:10:09 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
SendSlots[i] = props->Send[i].Slot;
|
2016-01-28 08:02:46 +00:00
|
|
|
if(!SendSlots[i] && i == 0)
|
|
|
|
SendSlots[i] = Device->DefaultSlot;
|
2016-05-13 01:26:33 +00:00
|
|
|
if(!SendSlots[i] || SendSlots[i]->Params.EffectType == AL_EFFECT_NULL)
|
2016-01-28 08:02:46 +00:00
|
|
|
{
|
|
|
|
SendSlots[i] = NULL;
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Send[i].Buffer = NULL;
|
|
|
|
voice->Send[i].Channels = 0;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
2014-03-19 23:10:09 +00:00
|
|
|
else
|
2016-01-28 08:02:46 +00:00
|
|
|
{
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Send[i].Buffer = SendSlots[i]->WetBuffer;
|
|
|
|
voice->Send[i].Channels = SendSlots[i]->NumChannels;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
2014-03-19 23:10:09 +00:00
|
|
|
}
|
|
|
|
|
2010-11-27 02:01:29 +00:00
|
|
|
/* Calculate the stepping value */
|
2016-05-09 21:22:26 +00:00
|
|
|
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);
|
2017-02-13 19:29:32 +00:00
|
|
|
BsincPrepare(voice->Step, &voice->ResampleState.bsinc);
|
2010-08-05 08:07:20 +00:00
|
|
|
|
2010-11-27 02:01:29 +00:00
|
|
|
/* Calculate gains */
|
2011-08-31 09:18:16 +00:00
|
|
|
DryGain = clampf(SourceVolume, MinVolume, MaxVolume);
|
2017-03-08 11:38:28 +00:00
|
|
|
DryGain *= props->Direct.Gain * ListenerGain;
|
2016-08-27 13:28:04 +00:00
|
|
|
DryGain = minf(DryGain, GAIN_MIX_MAX);
|
2017-03-08 11:38:28 +00:00
|
|
|
DryGainHF = props->Direct.GainHF;
|
|
|
|
DryGainLF = props->Direct.GainLF;
|
2011-07-05 18:00:52 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2016-08-27 13:28:04 +00:00
|
|
|
WetGain[i] = clampf(SourceVolume, MinVolume, MaxVolume);
|
2017-03-08 11:38:28 +00:00
|
|
|
WetGain[i] *= props->Send[i].Gain * ListenerGain;
|
2016-08-27 13:28:04 +00:00
|
|
|
WetGain[i] = minf(WetGain[i], GAIN_MIX_MAX);
|
2017-03-08 11:38:28 +00:00
|
|
|
WetGainHF[i] = props->Send[i].GainHF;
|
|
|
|
WetGainLF[i] = props->Send[i].GainLF;
|
2011-07-05 18:00:52 +00:00
|
|
|
}
|
2010-08-05 08:07:20 +00:00
|
|
|
|
2016-05-09 21:22:26 +00:00
|
|
|
switch(ALBuffer->FmtChannels)
|
2010-12-10 00:37:23 +00:00
|
|
|
{
|
|
|
|
case FmtMono:
|
2011-12-20 09:17:11 +00:00
|
|
|
chans = MonoMap;
|
2011-05-15 09:12:42 +00:00
|
|
|
num_channels = 1;
|
2010-12-10 00:37:23 +00:00
|
|
|
break;
|
2011-05-15 07:18:28 +00:00
|
|
|
|
2012-04-29 11:44:53 +00:00
|
|
|
case FmtStereo:
|
2016-02-27 00:09:06 +00:00
|
|
|
chans = StereoMap;
|
2011-06-17 23:20:18 +00:00
|
|
|
num_channels = 2;
|
2010-12-10 00:37:23 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FmtRear:
|
2011-12-20 09:17:11 +00:00
|
|
|
chans = RearMap;
|
2011-05-15 09:12:42 +00:00
|
|
|
num_channels = 2;
|
2010-12-10 00:37:23 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FmtQuad:
|
2011-12-20 09:17:11 +00:00
|
|
|
chans = QuadMap;
|
2011-05-15 09:12:42 +00:00
|
|
|
num_channels = 4;
|
2010-12-10 00:37:23 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FmtX51:
|
2011-12-20 09:17:11 +00:00
|
|
|
chans = X51Map;
|
2011-05-15 09:12:42 +00:00
|
|
|
num_channels = 6;
|
2010-12-10 00:37:23 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FmtX61:
|
2011-12-20 09:17:11 +00:00
|
|
|
chans = X61Map;
|
2011-05-15 09:12:42 +00:00
|
|
|
num_channels = 7;
|
2010-12-10 00:37:23 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FmtX71:
|
2011-12-20 09:17:11 +00:00
|
|
|
chans = X71Map;
|
2011-05-15 09:12:42 +00:00
|
|
|
num_channels = 8;
|
|
|
|
break;
|
2014-11-01 00:18:45 +00:00
|
|
|
|
|
|
|
case FmtBFormat2D:
|
|
|
|
num_channels = 3;
|
|
|
|
isbformat = AL_TRUE;
|
|
|
|
DirectChannels = AL_FALSE;
|
2014-11-02 10:30:45 +00:00
|
|
|
break;
|
2014-11-01 00:18:45 +00:00
|
|
|
|
|
|
|
case FmtBFormat3D:
|
|
|
|
num_channels = 4;
|
|
|
|
isbformat = AL_TRUE;
|
|
|
|
DirectChannels = AL_FALSE;
|
2014-11-02 10:30:45 +00:00
|
|
|
break;
|
2011-05-15 09:12:42 +00:00
|
|
|
}
|
|
|
|
|
2017-03-10 12:35:32 +00:00
|
|
|
voice->Flags &= ~(VOICE_IS_HRTF | VOICE_HAS_NFC);
|
2014-11-01 00:18:45 +00:00
|
|
|
if(isbformat)
|
|
|
|
{
|
2014-11-01 05:43:13 +00:00
|
|
|
ALfloat N[3], V[3], U[3];
|
2015-11-11 16:19:33 +00:00
|
|
|
aluMatrixf matrix;
|
2015-08-28 17:58:30 +00:00
|
|
|
ALfloat scale;
|
2014-11-01 05:43:13 +00:00
|
|
|
|
|
|
|
/* AT then UP */
|
2017-03-08 11:38:28 +00:00
|
|
|
N[0] = props->Orientation[0][0];
|
|
|
|
N[1] = props->Orientation[0][1];
|
|
|
|
N[2] = props->Orientation[0][2];
|
2014-11-01 05:43:13 +00:00
|
|
|
aluNormalize(N);
|
2017-03-08 11:38:28 +00:00
|
|
|
V[0] = props->Orientation[1][0];
|
|
|
|
V[1] = props->Orientation[1][1];
|
|
|
|
V[2] = props->Orientation[1][2];
|
2014-11-01 05:43:13 +00:00
|
|
|
aluNormalize(V);
|
|
|
|
if(!Relative)
|
|
|
|
{
|
2016-05-17 01:28:46 +00:00
|
|
|
const aluMatrixf *lmatrix = &Listener->Params.Matrix;
|
|
|
|
aluMatrixfFloat3(N, 0.0f, lmatrix);
|
|
|
|
aluMatrixfFloat3(V, 0.0f, lmatrix);
|
2014-11-01 05:43:13 +00:00
|
|
|
}
|
|
|
|
/* Build and normalize right-vector */
|
|
|
|
aluCrossproduct(N, V, U);
|
|
|
|
aluNormalize(U);
|
|
|
|
|
2016-09-05 07:38:41 +00:00
|
|
|
/* Build a rotate + conversion matrix (FuMa -> ACN+N3D). */
|
2016-03-26 06:25:13 +00:00
|
|
|
scale = 1.732050808f;
|
2015-11-11 16:19:33 +00:00
|
|
|
aluMatrixfSet(&matrix,
|
2015-11-06 18:27:28 +00:00
|
|
|
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
|
2014-12-16 18:36:44 +00:00
|
|
|
);
|
2014-11-01 05:43:13 +00:00
|
|
|
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Buffer = Device->FOAOut.Buffer;
|
|
|
|
voice->Direct.Channels = Device->FOAOut.NumChannels;
|
2014-11-01 00:18:45 +00:00
|
|
|
for(c = 0;c < num_channels;c++)
|
2016-04-16 05:05:47 +00:00
|
|
|
ComputeFirstOrderGains(Device->FOAOut, matrix.m[c], DryGain,
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Gains.Target);
|
2017-03-10 12:35:32 +00:00
|
|
|
if(Device->AvgSpeakerDist > 0.0f)
|
|
|
|
{
|
|
|
|
/* NOTE: The NFCtrlFilters were created with a w0 of 0, which is
|
|
|
|
* what we want for FOA input. So there's nothing to adjust.
|
|
|
|
*/
|
|
|
|
voice->Direct.ChannelsPerOrder[0] = 1;
|
|
|
|
voice->Direct.ChannelsPerOrder[1] = mini(voice->Direct.Channels-1, 3);
|
|
|
|
voice->Direct.ChannelsPerOrder[2] = 0;
|
|
|
|
voice->Direct.ChannelsPerOrder[3] = 0;
|
|
|
|
voice->Flags |= VOICE_HAS_NFC;
|
|
|
|
}
|
2014-11-01 00:18:45 +00:00
|
|
|
|
|
|
|
for(i = 0;i < NumSends;i++)
|
2015-10-24 03:16:11 +00:00
|
|
|
{
|
2017-02-22 02:28:09 +00:00
|
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
|
|
if(Slot)
|
2016-01-28 08:02:46 +00:00
|
|
|
{
|
|
|
|
for(c = 0;c < num_channels;c++)
|
2017-02-22 02:28:09 +00:00
|
|
|
ComputeFirstOrderGainsBF(Slot->ChanMap, Slot->NumChannels,
|
|
|
|
matrix.m[c], WetGain[i], voice->Send[i].Params[c].Gains.Target
|
|
|
|
);
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for(c = 0;c < num_channels;c++)
|
2017-02-22 02:28:09 +00:00
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
|
|
voice->Send[i].Params[c].Gains.Target[j] = 0.0f;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
2015-10-24 03:16:11 +00:00
|
|
|
}
|
2014-11-01 00:18:45 +00:00
|
|
|
}
|
2015-10-24 03:16:11 +00:00
|
|
|
else
|
2011-06-30 06:18:49 +00:00
|
|
|
{
|
2016-02-14 09:22:01 +00:00
|
|
|
ALfloat coeffs[MAX_AMBI_COEFFS];
|
|
|
|
|
2015-10-24 03:16:11 +00:00
|
|
|
if(DirectChannels)
|
2014-11-22 21:10:32 +00:00
|
|
|
{
|
2016-04-14 17:44:57 +00:00
|
|
|
/* Skip the virtual channels and write inputs to the real output. */
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Buffer = Device->RealOut.Buffer;
|
|
|
|
voice->Direct.Channels = Device->RealOut.NumChannels;
|
2016-03-15 03:25:36 +00:00
|
|
|
for(c = 0;c < num_channels;c++)
|
2014-11-22 21:10:32 +00:00
|
|
|
{
|
2015-10-24 03:16:11 +00:00
|
|
|
int idx;
|
2014-11-22 21:10:32 +00:00
|
|
|
for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Gains.Target[j] = 0.0f;
|
2016-03-15 03:25:36 +00:00
|
|
|
if((idx=GetChannelIdxByName(Device->RealOut, chans[c].channel)) != -1)
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Gains.Target[idx] = DryGain;
|
2014-11-22 21:10:32 +00:00
|
|
|
}
|
2016-01-28 08:02:46 +00:00
|
|
|
|
|
|
|
/* Auxiliary sends still use normal panning since they mix to B-Format, which can't
|
|
|
|
* channel-match. */
|
|
|
|
for(c = 0;c < num_channels;c++)
|
|
|
|
{
|
2016-04-25 04:42:59 +00:00
|
|
|
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
2016-01-28 08:02:46 +00:00
|
|
|
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-02-22 02:28:09 +00:00
|
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
|
|
if(Slot)
|
2017-02-16 01:40:26 +00:00
|
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels,
|
|
|
|
coeffs, WetGain[i], voice->Send[i].Params[c].Gains.Target
|
|
|
|
);
|
2017-02-22 02:28:09 +00:00
|
|
|
else
|
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
|
|
voice->Send[i].Params[c].Gains.Target[j] = 0.0f;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
|
|
|
}
|
2012-03-13 01:27:25 +00:00
|
|
|
}
|
2016-02-27 05:48:03 +00:00
|
|
|
else if(Device->Render_Mode == HrtfRender)
|
2014-11-23 18:49:54 +00:00
|
|
|
{
|
2015-10-24 03:16:11 +00:00
|
|
|
/* Full HRTF rendering. Skip the virtual channels and render each
|
|
|
|
* input channel to the real outputs.
|
|
|
|
*/
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Buffer = Device->RealOut.Buffer;
|
|
|
|
voice->Direct.Channels = Device->RealOut.NumChannels;
|
2015-10-24 03:16:11 +00:00
|
|
|
for(c = 0;c < num_channels;c++)
|
2014-11-23 18:49:54 +00:00
|
|
|
{
|
2015-10-24 03:16:11 +00:00
|
|
|
if(chans[c].channel == LFE)
|
2014-11-23 18:49:54 +00:00
|
|
|
{
|
2015-10-24 03:16:11 +00:00
|
|
|
/* Skip LFE */
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Hrtf.Target.Delay[0] = 0;
|
|
|
|
voice->Direct.Params[c].Hrtf.Target.Delay[1] = 0;
|
2015-10-24 03:16:11 +00:00
|
|
|
for(i = 0;i < HRIR_LENGTH;i++)
|
|
|
|
{
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Hrtf.Target.Coeffs[i][0] = 0.0f;
|
|
|
|
voice->Direct.Params[c].Hrtf.Target.Coeffs[i][1] = 0.0f;
|
2015-10-24 03:16:11 +00:00
|
|
|
}
|
2016-02-14 09:22:01 +00:00
|
|
|
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Send[i].Params[c].Gains.Target[j] = 0.0f;
|
2016-02-14 09:22:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
continue;
|
2015-10-24 03:16:11 +00:00
|
|
|
}
|
2014-11-23 18:49:54 +00:00
|
|
|
|
2016-02-14 09:22:01 +00:00
|
|
|
/* Get the static HRIR coefficients and delays for this channel. */
|
2017-03-10 18:47:43 +00:00
|
|
|
GetHrtfCoeffs(Device->HrtfHandle,
|
2017-03-12 02:04:06 +00:00
|
|
|
chans[c].elevation, chans[c].angle, 0.0f,
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Hrtf.Target.Coeffs,
|
|
|
|
voice->Direct.Params[c].Hrtf.Target.Delay
|
2016-02-14 09:22:01 +00:00
|
|
|
);
|
2017-03-12 02:04:06 +00:00
|
|
|
voice->Direct.Params[c].Hrtf.Target.Gain = DryGain;
|
2016-01-28 08:02:46 +00:00
|
|
|
|
2016-02-14 09:22:01 +00:00
|
|
|
/* Normal panning for auxiliary sends. */
|
2016-04-25 04:42:59 +00:00
|
|
|
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
2016-01-28 08:02:46 +00:00
|
|
|
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-02-22 02:28:09 +00:00
|
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
|
|
if(Slot)
|
2017-02-16 01:40:26 +00:00
|
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels,
|
|
|
|
coeffs, WetGain[i], voice->Send[i].Params[c].Gains.Target
|
|
|
|
);
|
2017-02-22 02:28:09 +00:00
|
|
|
else
|
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
|
|
voice->Send[i].Params[c].Gains.Target[j] = 0.0f;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-10 12:35:32 +00:00
|
|
|
voice->Flags |= VOICE_IS_HRTF;
|
2015-10-24 03:16:11 +00:00
|
|
|
}
|
|
|
|
else
|
2011-05-02 09:22:30 +00:00
|
|
|
{
|
2016-02-27 05:48:03 +00:00
|
|
|
/* Non-HRTF rendering. Use normal panning to the output. */
|
2015-10-24 03:16:11 +00:00
|
|
|
for(c = 0;c < num_channels;c++)
|
2011-04-15 04:03:37 +00:00
|
|
|
{
|
2015-10-24 03:16:11 +00:00
|
|
|
/* Special-case LFE */
|
|
|
|
if(chans[c].channel == LFE)
|
|
|
|
{
|
2016-02-14 09:22:01 +00:00
|
|
|
for(j = 0;j < MAX_OUTPUT_CHANNELS;j++)
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Gains.Target[j] = 0.0f;
|
2016-04-17 00:21:31 +00:00
|
|
|
if(Device->Dry.Buffer == Device->RealOut.Buffer)
|
|
|
|
{
|
|
|
|
int idx;
|
|
|
|
if((idx=GetChannelIdxByName(Device->RealOut, chans[c].channel)) != -1)
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Gains.Target[idx] = DryGain;
|
2016-04-17 00:21:31 +00:00
|
|
|
}
|
2016-01-30 15:13:07 +00:00
|
|
|
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].Gains.Target[j] = 0.0f;
|
2016-01-30 15:13:07 +00:00
|
|
|
}
|
2015-10-24 03:16:11 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-02-27 05:48:03 +00:00
|
|
|
if(Device->Render_Mode == StereoPair)
|
2017-02-23 08:23:16 +00:00
|
|
|
CalcAnglePairwiseCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
2016-02-27 05:48:03 +00:00
|
|
|
else
|
2016-04-25 04:42:59 +00:00
|
|
|
CalcAngleCoeffs(chans[c].angle, chans[c].elevation, 0.0f, coeffs);
|
2017-02-23 08:23:16 +00:00
|
|
|
ComputePanningGains(Device->Dry,
|
|
|
|
coeffs, DryGain, voice->Direct.Params[c].Gains.Target
|
|
|
|
);
|
2016-01-28 08:02:46 +00:00
|
|
|
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-02-22 02:28:09 +00:00
|
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
|
|
if(Slot)
|
2017-02-16 01:40:26 +00:00
|
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels,
|
|
|
|
coeffs, WetGain[i], voice->Send[i].Params[c].Gains.Target
|
|
|
|
);
|
2017-02-22 02:28:09 +00:00
|
|
|
else
|
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
|
|
voice->Send[i].Params[c].Gains.Target[j] = 0.0f;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
2014-10-03 01:05:42 +00:00
|
|
|
}
|
2015-10-24 03:16:11 +00:00
|
|
|
}
|
2014-03-23 23:11:21 +00:00
|
|
|
}
|
2009-12-09 15:02:26 +00:00
|
|
|
|
2013-05-28 02:14:02 +00:00
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
HFScale = props->Direct.HFReference / Frequency;
|
|
|
|
LFScale = props->Direct.LFReference / Frequency;
|
2017-02-23 02:07:41 +00:00
|
|
|
DryGainHF = maxf(DryGainHF, 0.0625f); /* Limit -24dB */
|
|
|
|
DryGainLF = maxf(DryGainLF, 0.0625f);
|
2013-05-28 02:14:02 +00:00
|
|
|
for(c = 0;c < num_channels;c++)
|
2014-05-17 14:17:48 +00:00
|
|
|
{
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[c].FilterType = AF_None;
|
|
|
|
if(DryGainHF != 1.0f) voice->Direct.Params[c].FilterType |= AF_LowPass;
|
|
|
|
if(DryGainLF != 1.0f) voice->Direct.Params[c].FilterType |= AF_HighPass;
|
2014-05-11 17:07:17 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Direct.Params[c].LowPass, ALfilterType_HighShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
DryGainHF, HFScale, calc_rcpQ_from_slope(DryGainHF, 1.0f)
|
2014-05-11 17:07:17 +00:00
|
|
|
);
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Direct.Params[c].HighPass, ALfilterType_LowShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
DryGainLF, LFScale, calc_rcpQ_from_slope(DryGainLF, 1.0f)
|
2014-05-17 14:54:25 +00:00
|
|
|
);
|
2014-05-17 14:17:48 +00:00
|
|
|
}
|
2013-05-28 02:14:02 +00:00
|
|
|
}
|
2009-12-09 15:02:26 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
HFScale = props->Send[i].HFReference / Frequency;
|
|
|
|
LFScale = props->Send[i].LFReference / Frequency;
|
2017-02-23 02:07:41 +00:00
|
|
|
WetGainHF[i] = maxf(WetGainHF[i], 0.0625f);
|
|
|
|
WetGainLF[i] = maxf(WetGainLF[i], 0.0625f);
|
2013-05-21 14:10:24 +00:00
|
|
|
for(c = 0;c < num_channels;c++)
|
2014-05-17 14:17:48 +00:00
|
|
|
{
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Send[i].Params[c].FilterType = AF_None;
|
|
|
|
if(WetGainHF[i] != 1.0f) voice->Send[i].Params[c].FilterType |= AF_LowPass;
|
|
|
|
if(WetGainLF[i] != 1.0f) voice->Send[i].Params[c].FilterType |= AF_HighPass;
|
2014-05-11 17:07:17 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Send[i].Params[c].LowPass, ALfilterType_HighShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
WetGainHF[i], HFScale, calc_rcpQ_from_slope(WetGainHF[i], 1.0f)
|
2014-05-11 17:07:17 +00:00
|
|
|
);
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Send[i].Params[c].HighPass, ALfilterType_LowShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
WetGainLF[i], LFScale, calc_rcpQ_from_slope(WetGainLF[i], 1.0f)
|
2014-05-17 14:54:25 +00:00
|
|
|
);
|
2014-05-17 14:17:48 +00:00
|
|
|
}
|
2009-12-09 15:02:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-16 21:46:06 +00:00
|
|
|
static void CalcAttnSourceParams(ALvoice *voice, const struct ALsourceProps *props, const ALbuffer *ALBuffer, const ALCcontext *ALContext)
|
2007-11-14 02:02:18 +00:00
|
|
|
{
|
2016-01-25 14:11:51 +00:00
|
|
|
const ALCdevice *Device = ALContext->Device;
|
2016-05-09 18:26:49 +00:00
|
|
|
const ALlistener *Listener = ALContext->Listener;
|
2014-12-16 15:20:27 +00:00
|
|
|
aluVector Position, Velocity, Direction, SourceToListener;
|
2016-05-17 05:42:41 +00:00
|
|
|
ALfloat InnerAngle,OuterAngle,Distance,ClampedDist;
|
2011-05-06 09:53:22 +00:00
|
|
|
ALfloat MinVolume,MaxVolume,MinDist,MaxDist,Rolloff;
|
2016-05-17 05:42:41 +00:00
|
|
|
ALfloat SourceVolume,ListenerGain;
|
2012-03-09 02:19:15 +00:00
|
|
|
ALfloat DopplerFactor, SpeedOfSound;
|
2010-09-12 07:10:33 +00:00
|
|
|
ALfloat AirAbsorptionFactor;
|
2011-07-05 18:00:52 +00:00
|
|
|
ALfloat RoomAirAbsorption[MAX_SENDS];
|
2016-01-28 08:02:46 +00:00
|
|
|
ALeffectslot *SendSlots[MAX_SENDS];
|
2012-03-15 05:45:52 +00:00
|
|
|
ALfloat Attenuation;
|
2009-04-12 03:04:46 +00:00
|
|
|
ALfloat RoomAttenuation[MAX_SENDS];
|
2007-12-18 03:40:43 +00:00
|
|
|
ALfloat MetersPerUnit;
|
2011-07-05 18:00:52 +00:00
|
|
|
ALfloat RoomRolloffBase;
|
2009-04-12 03:04:46 +00:00
|
|
|
ALfloat RoomRolloff[MAX_SENDS];
|
2011-07-05 18:00:52 +00:00
|
|
|
ALfloat DecayDistance[MAX_SENDS];
|
2010-10-10 10:47:57 +00:00
|
|
|
ALfloat DryGain;
|
|
|
|
ALfloat DryGainHF;
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfloat DryGainLF;
|
2011-07-05 18:00:52 +00:00
|
|
|
ALboolean DryGainHFAuto;
|
2009-10-21 22:31:21 +00:00
|
|
|
ALfloat WetGain[MAX_SENDS];
|
2009-10-21 20:08:50 +00:00
|
|
|
ALfloat WetGainHF[MAX_SENDS];
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfloat WetGainLF[MAX_SENDS];
|
2017-02-23 02:07:41 +00:00
|
|
|
ALfloat HFScale, LFScale;
|
2011-07-01 08:46:56 +00:00
|
|
|
ALboolean WetGainAuto;
|
|
|
|
ALboolean WetGainHFAuto;
|
2010-08-07 07:38:02 +00:00
|
|
|
ALfloat Pitch;
|
2009-10-21 20:08:50 +00:00
|
|
|
ALuint Frequency;
|
2009-04-14 03:33:41 +00:00
|
|
|
ALint NumSends;
|
2017-02-22 02:28:09 +00:00
|
|
|
ALint i, j;
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Get context/device properties */
|
Provide asynchronous property updates for sources
This necessitates a change in how source updates are handled. Rather than just
being able to update sources when a dependent object state is changed (e.g. a
listener gain change), now all source updates must be proactively provided.
Consequently, apps that do not utilize any deferring (AL_SOFT_defer_updates or
alcSuspendContext/alcProcessContext) may utilize more CPU since it'll be
filling out more update containers for the mixer thread to use.
The upside is that there's less blocking between the app's calling thread and
the mixer thread, particularly for vectors and other multi-value properties
(filters and sends). Deferring behavior when used is also improved, since
updates that shouldn't be applied yet are simply not provided. And when they
are provided, the mixer doesn't have to ignore them, meaning the actual
deferring of a context doesn't have to synchrnously force an update -- the
process call will send any pending updates, which the mixer will apply even if
another deferral occurs before the mixer runs, because it'll still be there
waiting on the next mixer invocation.
There is one slight bug introduced by this commit. When a listener change is
made, or changes to multiple sources while updates are being deferred, it is
possible for the mixer to run while the sources are prepping their updates,
causing some of the source updates to be seen before the other. This will be
fixed in short order.
2016-05-15 06:43:40 +00:00
|
|
|
DopplerFactor = Listener->Params.DopplerFactor;
|
2016-05-09 18:26:49 +00:00
|
|
|
SpeedOfSound = Listener->Params.SpeedOfSound;
|
2012-03-09 02:19:15 +00:00
|
|
|
NumSends = Device->NumAuxSends;
|
|
|
|
Frequency = Device->Frequency;
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Get listener properties */
|
2016-05-09 18:26:49 +00:00
|
|
|
ListenerGain = Listener->Params.Gain;
|
|
|
|
MetersPerUnit = Listener->Params.MetersPerUnit;
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Get source properties */
|
2017-03-08 11:38:28 +00:00
|
|
|
SourceVolume = props->Gain;
|
|
|
|
MinVolume = props->MinGain;
|
|
|
|
MaxVolume = props->MaxGain;
|
|
|
|
Pitch = props->Pitch;
|
|
|
|
aluVectorSet(&Position, props->Position[0], props->Position[1], props->Position[2], 1.0f);
|
|
|
|
aluVectorSet(&Direction, props->Direction[0], props->Direction[1], props->Direction[2], 0.0f);
|
|
|
|
aluVectorSet(&Velocity, props->Velocity[0], props->Velocity[1], props->Velocity[2], 0.0f);
|
|
|
|
MinDist = props->RefDistance;
|
|
|
|
MaxDist = props->MaxDistance;
|
|
|
|
Rolloff = props->RollOffFactor;
|
|
|
|
DopplerFactor *= props->DopplerFactor;
|
|
|
|
InnerAngle = props->InnerAngle;
|
|
|
|
OuterAngle = props->OuterAngle;
|
|
|
|
AirAbsorptionFactor = props->AirAbsorptionFactor;
|
|
|
|
DryGainHFAuto = props->DryGainHFAuto;
|
|
|
|
WetGainAuto = props->WetGainAuto;
|
|
|
|
WetGainHFAuto = props->WetGainHFAuto;
|
|
|
|
RoomRolloffBase = props->RoomRolloffFactor;
|
2012-10-14 18:21:52 +00:00
|
|
|
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Buffer = Device->Dry.Buffer;
|
|
|
|
voice->Direct.Channels = Device->Dry.NumChannels;
|
2011-07-03 10:34:40 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
SendSlots[i] = props->Send[i].Slot;
|
2016-01-28 08:02:46 +00:00
|
|
|
if(!SendSlots[i] && i == 0)
|
|
|
|
SendSlots[i] = Device->DefaultSlot;
|
2016-05-13 01:26:33 +00:00
|
|
|
if(!SendSlots[i] || SendSlots[i]->Params.EffectType == AL_EFFECT_NULL)
|
2011-07-05 18:00:52 +00:00
|
|
|
{
|
2016-01-28 08:02:46 +00:00
|
|
|
SendSlots[i] = NULL;
|
2011-07-05 18:00:52 +00:00
|
|
|
RoomRolloff[i] = 0.0f;
|
|
|
|
DecayDistance[i] = 0.0f;
|
2011-07-12 05:07:37 +00:00
|
|
|
RoomAirAbsorption[i] = 1.0f;
|
2011-07-05 18:00:52 +00:00
|
|
|
}
|
Provide asynchronous property updates for sources
This necessitates a change in how source updates are handled. Rather than just
being able to update sources when a dependent object state is changed (e.g. a
listener gain change), now all source updates must be proactively provided.
Consequently, apps that do not utilize any deferring (AL_SOFT_defer_updates or
alcSuspendContext/alcProcessContext) may utilize more CPU since it'll be
filling out more update containers for the mixer thread to use.
The upside is that there's less blocking between the app's calling thread and
the mixer thread, particularly for vectors and other multi-value properties
(filters and sends). Deferring behavior when used is also improved, since
updates that shouldn't be applied yet are simply not provided. And when they
are provided, the mixer doesn't have to ignore them, meaning the actual
deferring of a context doesn't have to synchrnously force an update -- the
process call will send any pending updates, which the mixer will apply even if
another deferral occurs before the mixer runs, because it'll still be there
waiting on the next mixer invocation.
There is one slight bug introduced by this commit. When a listener change is
made, or changes to multiple sources while updates are being deferred, it is
possible for the mixer to run while the sources are prepping their updates,
causing some of the source updates to be seen before the other. This will be
fixed in short order.
2016-05-15 06:43:40 +00:00
|
|
|
else if(SendSlots[i]->Params.AuxSendAuto)
|
2011-07-05 18:00:52 +00:00
|
|
|
{
|
2016-05-13 01:26:33 +00:00
|
|
|
RoomRolloff[i] = SendSlots[i]->Params.RoomRolloff + RoomRolloffBase;
|
|
|
|
DecayDistance[i] = SendSlots[i]->Params.DecayTime *
|
|
|
|
SPEEDOFSOUNDMETRESPERSEC;
|
|
|
|
RoomAirAbsorption[i] = SendSlots[i]->Params.AirAbsorptionGainHF;
|
2011-07-05 18:00:52 +00:00
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
2011-07-05 21:14:20 +00:00
|
|
|
|
2016-01-28 08:02:46 +00:00
|
|
|
if(!SendSlots[i])
|
|
|
|
{
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Send[i].Buffer = NULL;
|
|
|
|
voice->Send[i].Channels = 0;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
2013-10-06 17:11:01 +00:00
|
|
|
else
|
2016-01-28 08:02:46 +00:00
|
|
|
{
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Send[i].Buffer = SendSlots[i]->WetBuffer;
|
|
|
|
voice->Send[i].Channels = SendSlots[i]->NumChannels;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
2011-07-03 10:34:40 +00:00
|
|
|
}
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Transform source to listener space (convert to head relative) */
|
2017-03-08 11:38:28 +00:00
|
|
|
if(props->HeadRelative == AL_FALSE)
|
2009-10-19 20:25:40 +00:00
|
|
|
{
|
2016-05-17 01:28:46 +00:00
|
|
|
const aluMatrixf *Matrix = &Listener->Params.Matrix;
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Transform source vectors */
|
2016-05-17 01:28:46 +00:00
|
|
|
Position = aluMatrixfVector(Matrix, &Position);
|
|
|
|
Velocity = aluMatrixfVector(Matrix, &Velocity);
|
|
|
|
Direction = aluMatrixfVector(Matrix, &Direction);
|
2009-10-19 20:25:40 +00:00
|
|
|
}
|
|
|
|
else
|
2011-10-30 12:49:17 +00:00
|
|
|
{
|
2016-05-09 18:26:49 +00:00
|
|
|
const aluVector *lvelocity = &Listener->Params.Velocity;
|
2012-03-10 07:53:45 +00:00
|
|
|
/* Offset the source velocity to be relative of the listener velocity */
|
2014-12-16 15:20:27 +00:00
|
|
|
Velocity.v[0] += lvelocity->v[0];
|
|
|
|
Velocity.v[1] += lvelocity->v[1];
|
|
|
|
Velocity.v[2] += lvelocity->v[2];
|
2011-10-30 12:49:17 +00:00
|
|
|
}
|
2009-11-23 06:36:20 +00:00
|
|
|
|
2015-07-05 15:47:56 +00:00
|
|
|
aluNormalize(Direction.v);
|
2014-12-16 15:20:27 +00:00
|
|
|
SourceToListener.v[0] = -Position.v[0];
|
|
|
|
SourceToListener.v[1] = -Position.v[1];
|
|
|
|
SourceToListener.v[2] = -Position.v[2];
|
2014-12-16 15:42:17 +00:00
|
|
|
SourceToListener.v[3] = 0.0f;
|
2015-07-05 15:47:56 +00:00
|
|
|
Distance = aluNormalize(SourceToListener.v);
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Calculate distance attenuation */
|
2011-06-21 19:55:21 +00:00
|
|
|
ClampedDist = Distance;
|
2009-10-19 20:25:40 +00:00
|
|
|
|
2010-10-10 11:00:50 +00:00
|
|
|
Attenuation = 1.0f;
|
2009-12-06 11:59:12 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
2009-10-19 20:25:40 +00:00
|
|
|
RoomAttenuation[i] = 1.0f;
|
2016-08-24 02:17:17 +00:00
|
|
|
switch(Listener->Params.SourceDistanceModel ?
|
2017-03-08 11:38:28 +00:00
|
|
|
props->DistanceModel : Listener->Params.DistanceModel)
|
2009-10-19 20:25:40 +00:00
|
|
|
{
|
2011-07-04 02:39:19 +00:00
|
|
|
case InverseDistanceClamped:
|
2011-08-17 01:40:21 +00:00
|
|
|
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
|
2009-10-19 20:25:40 +00:00
|
|
|
if(MaxDist < MinDist)
|
|
|
|
break;
|
2012-04-26 07:59:17 +00:00
|
|
|
/*fall-through*/
|
2011-07-04 02:39:19 +00:00
|
|
|
case InverseDistance:
|
2009-10-19 20:25:40 +00:00
|
|
|
if(MinDist > 0.0f)
|
|
|
|
{
|
2014-12-18 15:42:14 +00:00
|
|
|
ALfloat dist = lerp(MinDist, ClampedDist, Rolloff);
|
|
|
|
if(dist > 0.0f) Attenuation = MinDist / dist;
|
2009-10-19 20:25:40 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
2007-12-19 03:03:40 +00:00
|
|
|
{
|
2014-12-18 15:42:14 +00:00
|
|
|
dist = lerp(MinDist, ClampedDist, RoomRolloff[i]);
|
|
|
|
if(dist > 0.0f) RoomAttenuation[i] = MinDist / dist;
|
2007-12-19 03:03:40 +00:00
|
|
|
}
|
2009-10-19 20:25:40 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2011-07-04 02:39:19 +00:00
|
|
|
case LinearDistanceClamped:
|
2011-08-17 01:40:21 +00:00
|
|
|
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
|
2009-10-19 20:25:40 +00:00
|
|
|
if(MaxDist < MinDist)
|
2007-11-14 02:02:18 +00:00
|
|
|
break;
|
2012-04-26 07:59:17 +00:00
|
|
|
/*fall-through*/
|
2011-07-04 02:39:19 +00:00
|
|
|
case LinearDistance:
|
2009-10-19 20:25:40 +00:00
|
|
|
if(MaxDist != MinDist)
|
|
|
|
{
|
2011-06-21 19:55:21 +00:00
|
|
|
Attenuation = 1.0f - (Rolloff*(ClampedDist-MinDist)/(MaxDist - MinDist));
|
2011-08-17 01:40:21 +00:00
|
|
|
Attenuation = maxf(Attenuation, 0.0f);
|
2009-10-19 20:25:40 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
2010-09-24 20:16:09 +00:00
|
|
|
{
|
2011-06-21 19:55:21 +00:00
|
|
|
RoomAttenuation[i] = 1.0f - (RoomRolloff[i]*(ClampedDist-MinDist)/(MaxDist - MinDist));
|
2011-08-17 01:40:21 +00:00
|
|
|
RoomAttenuation[i] = maxf(RoomAttenuation[i], 0.0f);
|
2010-09-24 20:16:09 +00:00
|
|
|
}
|
2009-10-19 20:25:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2011-07-04 02:39:19 +00:00
|
|
|
case ExponentDistanceClamped:
|
2011-08-17 01:40:21 +00:00
|
|
|
ClampedDist = clampf(ClampedDist, MinDist, MaxDist);
|
2009-10-19 20:25:40 +00:00
|
|
|
if(MaxDist < MinDist)
|
2007-11-14 02:02:18 +00:00
|
|
|
break;
|
2012-04-26 07:59:17 +00:00
|
|
|
/*fall-through*/
|
2011-07-04 02:39:19 +00:00
|
|
|
case ExponentDistance:
|
2011-06-21 19:55:21 +00:00
|
|
|
if(ClampedDist > 0.0f && MinDist > 0.0f)
|
2009-10-19 20:25:40 +00:00
|
|
|
{
|
2012-06-29 09:12:36 +00:00
|
|
|
Attenuation = powf(ClampedDist/MinDist, -Rolloff);
|
2009-10-19 20:25:40 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
2012-06-29 09:12:36 +00:00
|
|
|
RoomAttenuation[i] = powf(ClampedDist/MinDist, -RoomRolloff[i]);
|
2009-10-19 20:25:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2011-07-04 02:39:19 +00:00
|
|
|
case DisableDistance:
|
2012-03-15 05:45:52 +00:00
|
|
|
ClampedDist = MinDist;
|
2009-10-19 20:25:40 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-04-12 03:27:55 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Source Gain + Attenuation */
|
2011-06-18 23:45:26 +00:00
|
|
|
DryGain = SourceVolume * Attenuation;
|
2017-02-15 03:59:39 +00:00
|
|
|
DryGainHF = 1.0f;
|
|
|
|
DryGainLF = 1.0f;
|
2011-07-05 18:00:52 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
2017-02-15 03:59:39 +00:00
|
|
|
{
|
2011-07-05 18:00:52 +00:00
|
|
|
WetGain[i] = SourceVolume * RoomAttenuation[i];
|
2017-02-15 03:59:39 +00:00
|
|
|
WetGainHF[i] = 1.0f;
|
|
|
|
WetGainLF[i] = 1.0f;
|
|
|
|
}
|
2011-06-18 23:45:26 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Distance-based air absorption */
|
2012-03-18 15:09:59 +00:00
|
|
|
if(AirAbsorptionFactor > 0.0f && ClampedDist > MinDist)
|
2011-07-05 18:00:52 +00:00
|
|
|
{
|
2014-11-29 10:06:08 +00:00
|
|
|
ALfloat meters = (ClampedDist-MinDist) * MetersPerUnit;
|
2012-06-29 09:12:36 +00:00
|
|
|
DryGainHF *= powf(AIRABSORBGAINHF, AirAbsorptionFactor*meters);
|
2011-07-05 18:00:52 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
2012-06-29 09:12:36 +00:00
|
|
|
WetGainHF[i] *= powf(RoomAirAbsorption[i], AirAbsorptionFactor*meters);
|
2011-07-05 18:00:52 +00:00
|
|
|
}
|
2007-11-14 02:02:18 +00:00
|
|
|
|
2012-03-18 15:06:21 +00:00
|
|
|
if(WetGainAuto)
|
2011-10-01 00:51:21 +00:00
|
|
|
{
|
2012-03-18 15:06:21 +00:00
|
|
|
ALfloat ApparentDist = 1.0f/maxf(Attenuation, 0.00001f) - 1.0f;
|
|
|
|
|
2011-10-01 00:51:21 +00:00
|
|
|
/* Apply a decay-time transformation to the wet path, based on the
|
|
|
|
* attenuation of the dry path.
|
|
|
|
*
|
2012-03-18 15:06:21 +00:00
|
|
|
* Using the apparent distance, based on the distance attenuation, the
|
|
|
|
* initial decay of the reverb effect is calculated and applied to the
|
|
|
|
* wet path.
|
2011-10-01 00:51:21 +00:00
|
|
|
*/
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
|
|
|
if(DecayDistance[i] > 0.0f)
|
2012-06-29 09:12:36 +00:00
|
|
|
WetGain[i] *= powf(0.001f/*-60dB*/, ApparentDist/DecayDistance[i]);
|
2011-10-01 00:51:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate directional soundcones */
|
2016-05-17 05:42:41 +00:00
|
|
|
if(InnerAngle < 360.0f)
|
2009-10-19 20:25:40 +00:00
|
|
|
{
|
2016-05-17 05:42:41 +00:00
|
|
|
ALfloat ConeVolume;
|
|
|
|
ALfloat ConeHF;
|
|
|
|
ALfloat Angle;
|
|
|
|
ALfloat scale;
|
2008-01-16 05:57:50 +00:00
|
|
|
|
2016-05-17 05:42:41 +00:00
|
|
|
Angle = RAD2DEG(acosf(aluDotproduct(&Direction, &SourceToListener)) * ConeScale) * 2.0f;
|
|
|
|
if(Angle > InnerAngle)
|
|
|
|
{
|
|
|
|
if(Angle < OuterAngle)
|
|
|
|
{
|
|
|
|
scale = (Angle-InnerAngle) / (OuterAngle-InnerAngle);
|
2017-03-08 11:38:28 +00:00
|
|
|
ConeVolume = lerp(1.0f, props->OuterGain, scale);
|
|
|
|
ConeHF = lerp(1.0f, props->OuterGainHF, scale);
|
2016-05-17 05:42:41 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
ConeVolume = props->OuterGain;
|
|
|
|
ConeHF = props->OuterGainHF;
|
2016-05-17 05:42:41 +00:00
|
|
|
}
|
|
|
|
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)
|
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
ConeVolume = lerp(1.0f, props->OuterGain, scale);
|
2016-05-17 05:42:41 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
WetGain[i] *= ConeVolume;
|
|
|
|
}
|
|
|
|
if(WetGainHFAuto)
|
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
ConeHF = lerp(1.0f, props->OuterGainHF, scale);
|
2016-05-17 05:42:41 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
WetGainHF[i] *= ConeHF;
|
|
|
|
}
|
2011-07-05 18:00:52 +00:00
|
|
|
}
|
2009-12-08 22:18:07 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Apply gain and frequency filters */
|
2016-08-27 13:28:04 +00:00
|
|
|
DryGain = clampf(DryGain, MinVolume, MaxVolume);
|
2017-03-08 11:38:28 +00:00
|
|
|
DryGain *= props->Direct.Gain * ListenerGain;
|
2016-08-27 13:28:04 +00:00
|
|
|
DryGain = minf(DryGain, GAIN_MIX_MAX);
|
2017-03-08 11:38:28 +00:00
|
|
|
DryGainHF *= props->Direct.GainHF;
|
|
|
|
DryGainLF *= props->Direct.GainLF;
|
2011-07-05 18:00:52 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2016-08-27 13:28:04 +00:00
|
|
|
WetGain[i] = clampf(WetGain[i], MinVolume, MaxVolume);
|
2017-03-08 11:38:28 +00:00
|
|
|
WetGain[i] *= props->Send[i].Gain * ListenerGain;
|
2016-08-27 13:28:04 +00:00
|
|
|
WetGain[i] = minf(WetGain[i], GAIN_MIX_MAX);
|
2017-03-08 11:38:28 +00:00
|
|
|
WetGainHF[i] *= props->Send[i].GainHF;
|
|
|
|
WetGainLF[i] *= props->Send[i].GainLF;
|
2007-11-14 02:02:18 +00:00
|
|
|
}
|
2008-01-19 08:49:05 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* Calculate velocity-based doppler effect */
|
2012-03-18 15:20:08 +00:00
|
|
|
if(DopplerFactor > 0.0f)
|
2009-12-01 11:32:04 +00:00
|
|
|
{
|
2016-05-09 18:26:49 +00:00
|
|
|
const aluVector *lvelocity = &Listener->Params.Velocity;
|
2010-10-10 11:00:50 +00:00
|
|
|
ALfloat VSS, VLS;
|
2012-03-09 02:19:15 +00:00
|
|
|
|
2012-03-18 15:20:08 +00:00
|
|
|
if(SpeedOfSound < 1.0f)
|
|
|
|
{
|
|
|
|
DopplerFactor *= 1.0f/SpeedOfSound;
|
|
|
|
SpeedOfSound = 1.0f;
|
|
|
|
}
|
|
|
|
|
2014-12-16 18:36:44 +00:00
|
|
|
VSS = aluDotproduct(&Velocity, &SourceToListener) * DopplerFactor;
|
|
|
|
VLS = aluDotproduct(lvelocity, &SourceToListener) * DopplerFactor;
|
2012-03-09 02:19:15 +00:00
|
|
|
|
2012-03-10 06:38:26 +00:00
|
|
|
Pitch *= clampf(SpeedOfSound-VLS, 1.0f, SpeedOfSound*2.0f - 1.0f) /
|
|
|
|
clampf(SpeedOfSound-VSS, 1.0f, SpeedOfSound*2.0f - 1.0f);
|
2009-12-01 11:32:04 +00:00
|
|
|
}
|
2010-08-07 07:38:02 +00:00
|
|
|
|
2016-05-09 21:22:26 +00:00
|
|
|
/* 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);
|
2017-02-13 19:29:32 +00:00
|
|
|
BsincPrepare(voice->Step, &voice->ResampleState.bsinc);
|
2009-12-01 11:32:04 +00:00
|
|
|
|
2017-03-10 12:35:32 +00:00
|
|
|
voice->Flags &= ~(VOICE_IS_HRTF | VOICE_HAS_NFC);
|
2016-02-27 05:48:03 +00:00
|
|
|
if(Device->Render_Mode == HrtfRender)
|
2014-11-23 18:49:54 +00:00
|
|
|
{
|
2015-10-24 03:16:11 +00:00
|
|
|
/* Full HRTF rendering. Skip the virtual channels and render to the
|
|
|
|
* real outputs.
|
|
|
|
*/
|
2016-04-25 06:35:11 +00:00
|
|
|
ALfloat dir[3] = { 0.0f, 0.0f, -1.0f };
|
2016-01-28 08:02:46 +00:00
|
|
|
ALfloat coeffs[MAX_AMBI_COEFFS];
|
2017-03-08 11:38:28 +00:00
|
|
|
ALfloat radius = props->Radius;
|
|
|
|
ALfloat ev = 0.0f, az = 0.0f;
|
2016-04-25 04:42:59 +00:00
|
|
|
ALfloat spread = 0.0f;
|
2014-11-23 18:49:54 +00:00
|
|
|
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Buffer = Device->RealOut.Buffer;
|
|
|
|
voice->Direct.Channels = Device->RealOut.NumChannels;
|
2014-11-23 18:49:54 +00:00
|
|
|
|
|
|
|
if(Distance > FLT_EPSILON)
|
|
|
|
{
|
2016-04-25 06:35:11 +00:00
|
|
|
dir[0] = -SourceToListener.v[0];
|
|
|
|
dir[1] = -SourceToListener.v[1];
|
|
|
|
dir[2] = -SourceToListener.v[2] * ZScale;
|
2014-11-23 18:49:54 +00:00
|
|
|
|
|
|
|
/* 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. */
|
2016-04-25 06:35:11 +00:00
|
|
|
ev = asinf(clampf(dir[1], -1.0f, 1.0f));
|
|
|
|
az = atan2f(dir[0], -dir[2]);
|
2014-11-23 18:49:54 +00:00
|
|
|
}
|
2016-04-25 04:42:59 +00:00
|
|
|
if(radius > Distance)
|
|
|
|
spread = F_TAU - Distance/radius*F_PI;
|
|
|
|
else if(Distance > FLT_EPSILON)
|
|
|
|
spread = asinf(radius / Distance) * 2.0f;
|
2014-11-23 18:49:54 +00:00
|
|
|
|
2016-02-14 11:23:06 +00:00
|
|
|
/* Get the HRIR coefficients and delays. */
|
2017-03-12 02:04:06 +00:00
|
|
|
GetHrtfCoeffs(Device->HrtfHandle, ev, az, spread,
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[0].Hrtf.Target.Coeffs,
|
|
|
|
voice->Direct.Params[0].Hrtf.Target.Delay);
|
2017-03-12 02:04:06 +00:00
|
|
|
voice->Direct.Params[0].Hrtf.Target.Gain = DryGain;
|
2014-11-23 18:49:54 +00:00
|
|
|
|
2016-04-25 06:35:11 +00:00
|
|
|
CalcDirectionCoeffs(dir, spread, coeffs);
|
2016-01-28 08:02:46 +00:00
|
|
|
|
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-02-22 02:28:09 +00:00
|
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
|
|
if(Slot)
|
2017-02-16 01:40:26 +00:00
|
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels,
|
|
|
|
coeffs, WetGain[i], voice->Send[i].Params[0].Gains.Target
|
|
|
|
);
|
2017-02-22 02:28:09 +00:00
|
|
|
else
|
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
|
|
voice->Send[i].Params[0].Gains.Target[j] = 0.0f;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
|
|
|
|
2017-03-10 12:35:32 +00:00
|
|
|
voice->Flags |= VOICE_IS_HRTF;
|
2014-11-23 18:49:54 +00:00
|
|
|
}
|
|
|
|
else
|
2009-10-19 20:25:40 +00:00
|
|
|
{
|
2016-02-27 05:48:03 +00:00
|
|
|
/* Non-HRTF rendering. */
|
2014-11-25 09:15:26 +00:00
|
|
|
ALfloat dir[3] = { 0.0f, 0.0f, -1.0f };
|
2016-01-25 14:11:51 +00:00
|
|
|
ALfloat coeffs[MAX_AMBI_COEFFS];
|
2017-03-08 11:38:28 +00:00
|
|
|
ALfloat radius = props->Radius;
|
2016-04-25 04:42:59 +00:00
|
|
|
ALfloat spread = 0.0f;
|
2012-04-28 20:06:16 +00:00
|
|
|
|
2015-07-05 15:47:56 +00:00
|
|
|
/* Get the localized direction, and compute panned gains. */
|
|
|
|
if(Distance > FLT_EPSILON)
|
|
|
|
{
|
2017-03-10 12:35:32 +00:00
|
|
|
if(Device->AvgSpeakerDist > 0.0f && MetersPerUnit > 0.0f)
|
|
|
|
{
|
|
|
|
ALfloat w0 = SPEEDOFSOUNDMETRESPERSEC /
|
|
|
|
(Distance*MetersPerUnit * (ALfloat)Device->Frequency);
|
|
|
|
ALfloat w1 = SPEEDOFSOUNDMETRESPERSEC /
|
|
|
|
(Device->AvgSpeakerDist * (ALfloat)Device->Frequency);
|
|
|
|
/* Clamp w0 for really close distances, to prevent excessive
|
|
|
|
* bass.
|
|
|
|
*/
|
|
|
|
w0 = minf(w0, w1*4.0f);
|
|
|
|
|
|
|
|
NfcFilterAdjust1(&voice->Direct.Params[0].NFCtrlFilter[0], w0);
|
|
|
|
NfcFilterAdjust2(&voice->Direct.Params[0].NFCtrlFilter[1], w0);
|
|
|
|
NfcFilterAdjust3(&voice->Direct.Params[0].NFCtrlFilter[2], w0);
|
|
|
|
|
|
|
|
for(i = 0;i < MAX_AMBI_ORDER+1;i++)
|
|
|
|
voice->Direct.ChannelsPerOrder[i] = Device->Dry.NumChannelsPerOrder[i];
|
|
|
|
voice->Flags |= VOICE_HAS_NFC;
|
|
|
|
}
|
|
|
|
|
2015-07-05 15:47:56 +00:00
|
|
|
dir[0] = -SourceToListener.v[0];
|
|
|
|
dir[1] = -SourceToListener.v[1];
|
|
|
|
dir[2] = -SourceToListener.v[2] * ZScale;
|
|
|
|
}
|
2017-03-10 12:35:32 +00:00
|
|
|
else if(Device->AvgSpeakerDist > 0.0f)
|
|
|
|
{
|
|
|
|
/* If the source distance is 0, set w0 to w1 to act as a pass-
|
|
|
|
* through. We still want to pass the signal through the filters so
|
|
|
|
* they keep an appropriate history, in case the source moves away
|
|
|
|
* from the listener.
|
|
|
|
*/
|
|
|
|
ALfloat w0 = SPEEDOFSOUNDMETRESPERSEC /
|
|
|
|
(Device->AvgSpeakerDist * (ALfloat)Device->Frequency);
|
|
|
|
|
|
|
|
NfcFilterAdjust1(&voice->Direct.Params[0].NFCtrlFilter[0], w0);
|
|
|
|
NfcFilterAdjust2(&voice->Direct.Params[0].NFCtrlFilter[1], w0);
|
|
|
|
NfcFilterAdjust3(&voice->Direct.Params[0].NFCtrlFilter[2], w0);
|
|
|
|
|
|
|
|
for(i = 0;i < MAX_AMBI_ORDER+1;i++)
|
|
|
|
voice->Direct.ChannelsPerOrder[i] = Device->Dry.NumChannelsPerOrder[i];
|
|
|
|
voice->Flags |= VOICE_HAS_NFC;
|
|
|
|
}
|
|
|
|
|
2016-04-25 04:42:59 +00:00
|
|
|
if(radius > Distance)
|
|
|
|
spread = F_TAU - Distance/radius*F_PI;
|
|
|
|
else if(Distance > FLT_EPSILON)
|
|
|
|
spread = asinf(radius / Distance) * 2.0f;
|
2014-10-11 16:35:32 +00:00
|
|
|
|
2016-02-27 05:48:03 +00:00
|
|
|
if(Device->Render_Mode == StereoPair)
|
|
|
|
{
|
2017-02-23 08:23:16 +00:00
|
|
|
ALfloat ev = asinf(clampf(dir[1], -1.0f, 1.0f));
|
|
|
|
ALfloat az = atan2f(dir[0], -dir[2]);
|
|
|
|
CalcAnglePairwiseCoeffs(az, ev, radius, coeffs);
|
2016-02-27 05:48:03 +00:00
|
|
|
}
|
|
|
|
else
|
2016-04-25 04:42:59 +00:00
|
|
|
CalcDirectionCoeffs(dir, spread, coeffs);
|
2017-02-23 08:23:16 +00:00
|
|
|
ComputePanningGains(Device->Dry,
|
|
|
|
coeffs, DryGain, voice->Direct.Params[0].Gains.Target
|
|
|
|
);
|
2014-03-23 10:03:03 +00:00
|
|
|
|
2016-01-28 08:02:46 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
|
|
|
{
|
2017-02-22 02:28:09 +00:00
|
|
|
const ALeffectslot *Slot = SendSlots[i];
|
|
|
|
if(Slot)
|
2017-02-16 01:40:26 +00:00
|
|
|
ComputePanningGainsBF(Slot->ChanMap, Slot->NumChannels,
|
|
|
|
coeffs, WetGain[i], voice->Send[i].Params[0].Gains.Target
|
|
|
|
);
|
2017-02-22 02:28:09 +00:00
|
|
|
else
|
|
|
|
for(j = 0;j < MAX_EFFECT_CHANNELS;j++)
|
|
|
|
voice->Send[i].Params[0].Gains.Target[j] = 0.0f;
|
2016-01-28 08:02:46 +00:00
|
|
|
}
|
2007-11-14 02:02:18 +00:00
|
|
|
}
|
2009-12-09 15:21:59 +00:00
|
|
|
|
2013-05-28 04:57:22 +00:00
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
HFScale = props->Direct.HFReference / Frequency;
|
|
|
|
LFScale = props->Direct.LFReference / Frequency;
|
2017-02-23 02:07:41 +00:00
|
|
|
DryGainHF = maxf(DryGainHF, 0.0625f); /* Limit -24dB */
|
|
|
|
DryGainLF = maxf(DryGainLF, 0.0625f);
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Direct.Params[0].FilterType = AF_None;
|
|
|
|
if(DryGainHF != 1.0f) voice->Direct.Params[0].FilterType |= AF_LowPass;
|
|
|
|
if(DryGainLF != 1.0f) voice->Direct.Params[0].FilterType |= AF_HighPass;
|
2014-05-11 17:07:17 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Direct.Params[0].LowPass, ALfilterType_HighShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
DryGainHF, HFScale, calc_rcpQ_from_slope(DryGainHF, 1.0f)
|
2014-05-11 17:07:17 +00:00
|
|
|
);
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Direct.Params[0].HighPass, ALfilterType_LowShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
DryGainLF, LFScale, calc_rcpQ_from_slope(DryGainLF, 1.0f)
|
2014-05-17 14:54:25 +00:00
|
|
|
);
|
2013-05-28 04:57:22 +00:00
|
|
|
}
|
2009-10-21 20:08:50 +00:00
|
|
|
for(i = 0;i < NumSends;i++)
|
2013-05-28 04:57:22 +00:00
|
|
|
{
|
2017-03-08 11:38:28 +00:00
|
|
|
HFScale = props->Send[i].HFReference / Frequency;
|
|
|
|
LFScale = props->Send[i].LFReference / Frequency;
|
2017-02-23 02:07:41 +00:00
|
|
|
WetGainHF[i] = maxf(WetGainHF[i], 0.0625f);
|
|
|
|
WetGainLF[i] = maxf(WetGainLF[i], 0.0625f);
|
2017-02-16 01:40:26 +00:00
|
|
|
voice->Send[i].Params[0].FilterType = AF_None;
|
|
|
|
if(WetGainHF[i] != 1.0f) voice->Send[i].Params[0].FilterType |= AF_LowPass;
|
|
|
|
if(WetGainLF[i] != 1.0f) voice->Send[i].Params[0].FilterType |= AF_HighPass;
|
2014-05-11 17:07:17 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Send[i].Params[0].LowPass, ALfilterType_HighShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
WetGainHF[i], HFScale, calc_rcpQ_from_slope(WetGainHF[i], 1.0f)
|
2014-05-11 17:07:17 +00:00
|
|
|
);
|
2014-05-17 14:54:25 +00:00
|
|
|
ALfilterState_setParams(
|
2017-02-16 01:40:26 +00:00
|
|
|
&voice->Send[i].Params[0].HighPass, ALfilterType_LowShelf,
|
2017-03-16 18:25:28 +00:00
|
|
|
WetGainLF[i], LFScale, calc_rcpQ_from_slope(WetGainLF[i], 1.0f)
|
2014-05-17 14:54:25 +00:00
|
|
|
);
|
2013-05-28 04:57:22 +00:00
|
|
|
}
|
2007-11-14 02:02:18 +00:00
|
|
|
}
|
|
|
|
|
2017-03-02 08:49:03 +00:00
|
|
|
static void CalcSourceParams(ALvoice *voice, ALsource *source, ALCcontext *context, ALboolean force)
|
2016-05-16 21:46:06 +00:00
|
|
|
{
|
2016-08-05 03:42:25 +00:00
|
|
|
const ALbufferlistitem *BufferListItem;
|
2016-05-16 21:46:06 +00:00
|
|
|
struct ALsourceProps *props;
|
|
|
|
|
|
|
|
props = ATOMIC_EXCHANGE(struct ALsourceProps*, &source->Update, NULL, almemory_order_acq_rel);
|
2016-08-24 09:17:55 +00:00
|
|
|
if(!props && !force) return;
|
|
|
|
|
|
|
|
if(props)
|
2016-08-24 01:56:01 +00:00
|
|
|
{
|
2017-02-15 03:59:39 +00:00
|
|
|
memcpy(voice->Props, props,
|
|
|
|
offsetof(struct ALsourceProps, Send[context->Device->NumAuxSends])
|
|
|
|
);
|
2016-08-24 01:56:01 +00:00
|
|
|
|
2016-12-22 03:58:03 +00:00
|
|
|
ATOMIC_REPLACE_HEAD(struct ALsourceProps*, &source->FreeList, props);
|
2016-08-24 01:56:01 +00:00
|
|
|
}
|
2016-08-24 09:17:55 +00:00
|
|
|
|
|
|
|
BufferListItem = ATOMIC_LOAD(&source->queue, almemory_order_relaxed);
|
|
|
|
while(BufferListItem != NULL)
|
|
|
|
{
|
|
|
|
const ALbuffer *buffer;
|
|
|
|
if((buffer=BufferListItem->buffer) != NULL)
|
|
|
|
{
|
|
|
|
if(buffer->FmtChannels == FmtMono)
|
2017-02-15 03:59:39 +00:00
|
|
|
CalcAttnSourceParams(voice, voice->Props, buffer, context);
|
2016-08-24 09:17:55 +00:00
|
|
|
else
|
2017-02-15 03:59:39 +00:00
|
|
|
CalcNonAttnSourceParams(voice, voice->Props, buffer, context);
|
2016-08-24 09:17:55 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
BufferListItem = BufferListItem->next;
|
|
|
|
}
|
2016-05-16 21:46:06 +00:00
|
|
|
}
|
|
|
|
|
2009-08-27 02:15:17 +00:00
|
|
|
|
2017-03-28 06:16:23 +00:00
|
|
|
static void UpdateContextSources(ALCcontext *ctx, const struct ALeffectslotArray *slots)
|
2015-09-18 07:48:43 +00:00
|
|
|
{
|
2017-02-21 19:17:47 +00:00
|
|
|
ALvoice **voice, **voice_end;
|
2015-09-18 07:48:43 +00:00
|
|
|
ALsource *source;
|
2017-03-28 06:16:23 +00:00
|
|
|
ALsizei i;
|
2015-09-18 07:48:43 +00:00
|
|
|
|
2016-05-16 00:14:58 +00:00
|
|
|
IncrementRef(&ctx->UpdateCount);
|
2016-12-21 04:49:37 +00:00
|
|
|
if(!ATOMIC_LOAD(&ctx->HoldUpdates, almemory_order_acquire))
|
2016-05-16 00:14:58 +00:00
|
|
|
{
|
2016-08-24 01:56:01 +00:00
|
|
|
ALboolean force = CalcListenerParams(ctx);
|
2017-03-28 06:16:23 +00:00
|
|
|
for(i = 0;i < slots->count;i++)
|
|
|
|
force |= CalcEffectSlotParams(slots->slot[i], ctx->Device);
|
2016-05-13 01:26:33 +00:00
|
|
|
|
2016-05-16 00:14:58 +00:00
|
|
|
voice = ctx->Voices;
|
|
|
|
voice_end = voice + ctx->VoiceCount;
|
|
|
|
for(;voice != voice_end;++voice)
|
|
|
|
{
|
2017-03-05 12:50:27 +00:00
|
|
|
source = ATOMIC_LOAD(&(*voice)->Source, almemory_order_acquire);
|
|
|
|
if(source) CalcSourceParams(*voice, source, ctx, force);
|
2016-05-16 00:14:58 +00:00
|
|
|
}
|
2015-09-18 07:48:43 +00:00
|
|
|
}
|
2016-05-16 00:14:58 +00:00
|
|
|
IncrementRef(&ctx->UpdateCount);
|
2015-09-18 07:48:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-09-07 10:27:25 +00:00
|
|
|
/* Specialized function to clamp to [-1, +1] with only one branch. This also
|
|
|
|
* converts NaN to 0. */
|
|
|
|
static inline ALfloat aluClampf(ALfloat val)
|
2010-11-21 10:51:18 +00:00
|
|
|
{
|
2015-09-07 10:27:25 +00:00
|
|
|
if(fabsf(val) <= 1.0f) return val;
|
|
|
|
return (ALfloat)((0.0f < val) - (val < 0.0f));
|
2010-11-21 10:51:18 +00:00
|
|
|
}
|
2013-04-22 07:52:50 +00:00
|
|
|
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline ALfloat aluF2F(ALfloat val)
|
2013-04-22 07:52:50 +00:00
|
|
|
{ return val; }
|
2015-09-07 10:27:25 +00:00
|
|
|
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline ALint aluF2I(ALfloat val)
|
2015-09-07 10:27:25 +00:00
|
|
|
{
|
|
|
|
/* 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;
|
|
|
|
}
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline ALuint aluF2UI(ALfloat val)
|
2012-02-14 19:44:57 +00:00
|
|
|
{ return aluF2I(val)+2147483648u; }
|
2015-09-07 10:27:25 +00:00
|
|
|
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline ALshort aluF2S(ALfloat val)
|
2015-09-07 10:27:25 +00:00
|
|
|
{ return fastf2i(aluClampf(val)*32767.0f); }
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline ALushort aluF2US(ALfloat val)
|
2011-08-17 09:33:25 +00:00
|
|
|
{ return aluF2S(val)+32768; }
|
2015-09-07 10:27:25 +00:00
|
|
|
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline ALbyte aluF2B(ALfloat val)
|
2015-09-07 10:27:25 +00:00
|
|
|
{ return fastf2i(aluClampf(val)*127.0f); }
|
2013-05-29 05:27:07 +00:00
|
|
|
static inline ALubyte aluF2UB(ALfloat val)
|
2012-02-14 19:44:57 +00:00
|
|
|
{ return aluF2B(val)+128; }
|
2010-11-21 10:51:18 +00:00
|
|
|
|
2012-09-11 13:41:24 +00:00
|
|
|
#define DECL_TEMPLATE(T, func) \
|
2017-02-20 06:47:59 +00:00
|
|
|
static void Write_##T(const ALfloatBUFFERSIZE *InBuffer, ALvoid *OutBuffer, \
|
|
|
|
DistanceComp *distcomp, ALsizei SamplesToDo, \
|
|
|
|
ALsizei numchans) \
|
2010-12-02 05:50:49 +00:00
|
|
|
{ \
|
2017-02-10 14:20:16 +00:00
|
|
|
ALsizei i, j; \
|
2014-11-05 10:54:11 +00:00
|
|
|
for(j = 0;j < numchans;j++) \
|
2010-12-02 05:50:49 +00:00
|
|
|
{ \
|
2014-11-08 00:00:07 +00:00
|
|
|
const ALfloat *in = InBuffer[j]; \
|
|
|
|
T *restrict out = (T*)OutBuffer + j; \
|
2017-02-20 06:47:59 +00:00
|
|
|
const ALfloat gain = distcomp[j].Gain; \
|
|
|
|
const ALsizei base = distcomp[j].Length; \
|
2017-03-01 05:01:13 +00:00
|
|
|
ALfloat *restrict distbuf = ASSUME_ALIGNED(distcomp[j].Buffer, 16); \
|
2017-02-20 06:47:59 +00:00
|
|
|
if(base > 0 || gain != 1.0f) \
|
|
|
|
{ \
|
|
|
|
if(SamplesToDo >= base) \
|
|
|
|
{ \
|
|
|
|
for(i = 0;i < base;i++) \
|
2017-03-01 05:01:13 +00:00
|
|
|
out[i*numchans] = func(distbuf[i]*gain); \
|
2017-02-20 06:47:59 +00:00
|
|
|
for(;i < SamplesToDo;i++) \
|
|
|
|
out[i*numchans] = func(in[i-base]*gain); \
|
2017-03-01 05:01:13 +00:00
|
|
|
memcpy(distbuf, &in[SamplesToDo-base], base*sizeof(ALfloat)); \
|
2017-02-20 06:47:59 +00:00
|
|
|
} \
|
|
|
|
else \
|
|
|
|
{ \
|
|
|
|
for(i = 0;i < SamplesToDo;i++) \
|
2017-03-01 05:01:13 +00:00
|
|
|
out[i*numchans] = func(distbuf[i]*gain); \
|
|
|
|
memmove(distbuf, distbuf+SamplesToDo, \
|
2017-02-20 06:47:59 +00:00
|
|
|
(base-SamplesToDo)*sizeof(ALfloat)); \
|
2017-03-01 05:01:13 +00:00
|
|
|
memcpy(distbuf+base-SamplesToDo, in, \
|
2017-02-20 06:47:59 +00:00
|
|
|
SamplesToDo*sizeof(ALfloat)); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
else for(i = 0;i < SamplesToDo;i++) \
|
2014-09-10 23:52:54 +00:00
|
|
|
out[i*numchans] = func(in[i]); \
|
2010-12-02 05:50:49 +00:00
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2012-09-11 13:41:24 +00:00
|
|
|
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)
|
2010-12-03 00:36:37 +00:00
|
|
|
|
2010-12-02 05:50:49 +00:00
|
|
|
#undef DECL_TEMPLATE
|
|
|
|
|
|
|
|
|
2017-01-18 15:19:43 +00:00
|
|
|
void aluMixData(ALCdevice *device, ALvoid *buffer, ALsizei size)
|
2010-11-21 10:51:18 +00:00
|
|
|
{
|
2017-02-10 14:20:16 +00:00
|
|
|
ALsizei SamplesToDo;
|
2017-02-21 19:17:47 +00:00
|
|
|
ALvoice **voice, **voice_end;
|
2015-09-13 06:36:24 +00:00
|
|
|
ALeffectslot *slot;
|
|
|
|
ALsource *source;
|
2011-08-29 02:28:41 +00:00
|
|
|
ALCcontext *ctx;
|
2012-09-16 08:35:16 +00:00
|
|
|
FPUCtl oldMode;
|
2017-01-18 15:13:23 +00:00
|
|
|
ALsizei i, c;
|
2010-11-21 10:51:18 +00:00
|
|
|
|
2012-09-16 08:35:16 +00:00
|
|
|
SetMixerFPUMode(&oldMode);
|
2010-11-21 10:51:18 +00:00
|
|
|
|
|
|
|
while(size > 0)
|
|
|
|
{
|
2017-02-10 14:20:16 +00:00
|
|
|
SamplesToDo = mini(size, BUFFERSIZE);
|
2016-07-05 21:18:17 +00:00
|
|
|
for(c = 0;c < device->Dry.NumChannels;c++)
|
|
|
|
memset(device->Dry.Buffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
2016-03-23 19:53:36 +00:00
|
|
|
if(device->Dry.Buffer != device->FOAOut.Buffer)
|
|
|
|
for(c = 0;c < device->FOAOut.NumChannels;c++)
|
|
|
|
memset(device->FOAOut.Buffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
2017-02-20 01:45:27 +00:00
|
|
|
if(device->Dry.Buffer != device->RealOut.Buffer)
|
|
|
|
for(c = 0;c < device->RealOut.NumChannels;c++)
|
|
|
|
memset(device->RealOut.Buffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
2010-11-21 10:51:18 +00:00
|
|
|
|
2016-05-23 08:03:37 +00:00
|
|
|
IncrementRef(&device->MixCount);
|
2015-09-13 06:36:24 +00:00
|
|
|
|
|
|
|
if((slot=device->DefaultSlot) != NULL)
|
|
|
|
{
|
2016-05-13 01:26:33 +00:00
|
|
|
CalcEffectSlotParams(device->DefaultSlot, device);
|
2017-03-28 06:16:23 +00:00
|
|
|
for(c = 0;c < slot->NumChannels;c++)
|
|
|
|
memset(slot->WetBuffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
2015-09-13 06:36:24 +00:00
|
|
|
}
|
2013-11-28 02:52:56 +00:00
|
|
|
|
2016-12-21 04:49:37 +00:00
|
|
|
ctx = ATOMIC_LOAD(&device->ContextList, almemory_order_acquire);
|
2011-08-29 02:28:41 +00:00
|
|
|
while(ctx)
|
2010-11-21 10:51:18 +00:00
|
|
|
{
|
2017-03-28 06:16:23 +00:00
|
|
|
const struct ALeffectslotArray *auxslots;
|
2016-05-29 08:40:16 +00:00
|
|
|
|
2017-03-28 06:16:23 +00:00
|
|
|
auxslots = ATOMIC_LOAD(&ctx->ActiveAuxSlots, almemory_order_acquire);
|
|
|
|
UpdateContextSources(ctx, auxslots);
|
2016-05-29 08:40:16 +00:00
|
|
|
|
2017-03-28 06:16:23 +00:00
|
|
|
for(i = 0;i < auxslots->count;i++)
|
2016-05-29 08:40:16 +00:00
|
|
|
{
|
2017-03-28 06:16:23 +00:00
|
|
|
ALeffectslot *slot = auxslots->slot[i];
|
|
|
|
for(c = 0;c < slot->NumChannels;c++)
|
|
|
|
memset(slot->WetBuffer[c], 0, SamplesToDo*sizeof(ALfloat));
|
2016-05-29 08:40:16 +00:00
|
|
|
}
|
2012-10-09 13:19:36 +00:00
|
|
|
|
2012-04-26 07:59:17 +00:00
|
|
|
/* source processing */
|
2014-08-21 10:24:48 +00:00
|
|
|
voice = ctx->Voices;
|
|
|
|
voice_end = voice + ctx->VoiceCount;
|
2015-09-13 06:36:24 +00:00
|
|
|
for(;voice != voice_end;++voice)
|
2010-11-21 10:51:18 +00:00
|
|
|
{
|
2017-03-05 12:50:27 +00:00
|
|
|
source = ATOMIC_LOAD(&(*voice)->Source, almemory_order_acquire);
|
2017-03-02 08:49:03 +00:00
|
|
|
if(source && ATOMIC_LOAD(&(*voice)->Playing, almemory_order_relaxed) &&
|
|
|
|
(*voice)->Step > 0)
|
2017-02-26 00:46:30 +00:00
|
|
|
{
|
|
|
|
if(!MixSource(*voice, source, device, SamplesToDo))
|
2017-03-02 08:49:03 +00:00
|
|
|
{
|
2017-03-05 12:50:27 +00:00
|
|
|
ATOMIC_STORE(&(*voice)->Source, NULL, almemory_order_relaxed);
|
2017-03-02 08:49:03 +00:00
|
|
|
ATOMIC_STORE(&(*voice)->Playing, false, almemory_order_release);
|
|
|
|
}
|
2017-02-26 00:46:30 +00:00
|
|
|
}
|
2010-11-21 10:51:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* effect slot processing */
|
2017-03-28 06:16:23 +00:00
|
|
|
for(i = 0;i < auxslots->count;i++)
|
2016-01-27 16:16:47 +00:00
|
|
|
{
|
2017-03-28 06:16:23 +00:00
|
|
|
ALeffectslot *slot = auxslots->slot[i];
|
2016-10-04 23:25:43 +00:00
|
|
|
ALeffectState *state = slot->Params.EffectState;
|
|
|
|
V(state,process)(SamplesToDo, SAFE_CONST(ALfloatBUFFERSIZE*,slot->WetBuffer),
|
|
|
|
state->OutBuffer, state->OutChannels);
|
2016-01-27 16:16:47 +00:00
|
|
|
}
|
2010-11-21 10:51:18 +00:00
|
|
|
|
2011-08-29 02:28:41 +00:00
|
|
|
ctx = ctx->next;
|
2010-11-21 10:51:18 +00:00
|
|
|
}
|
2012-01-20 03:30:03 +00:00
|
|
|
|
2016-01-27 16:16:47 +00:00
|
|
|
if(device->DefaultSlot != NULL)
|
|
|
|
{
|
|
|
|
const ALeffectslot *slot = device->DefaultSlot;
|
2016-05-13 01:26:33 +00:00
|
|
|
ALeffectState *state = slot->Params.EffectState;
|
2016-03-17 17:10:26 +00:00
|
|
|
V(state,process)(SamplesToDo, slot->WetBuffer, state->OutBuffer,
|
|
|
|
state->OutChannels);
|
2016-01-27 16:16:47 +00:00
|
|
|
}
|
2014-02-02 00:37:11 +00:00
|
|
|
|
|
|
|
/* 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;
|
2016-05-23 08:03:37 +00:00
|
|
|
IncrementRef(&device->MixCount);
|
2010-11-21 10:51:18 +00:00
|
|
|
|
2017-03-10 18:47:43 +00:00
|
|
|
if(device->HrtfHandle)
|
2014-11-22 12:20:17 +00:00
|
|
|
{
|
2017-01-18 00:49:26 +00:00
|
|
|
HrtfDirectMixerFunc HrtfMix;
|
2017-03-10 18:47:43 +00:00
|
|
|
DirectHrtfState *state;
|
2017-01-18 00:49:26 +00:00
|
|
|
int lidx, ridx;
|
2017-01-15 21:57:22 +00:00
|
|
|
|
|
|
|
if(device->AmbiUp)
|
|
|
|
ambiup_process(device->AmbiUp,
|
|
|
|
device->Dry.Buffer, device->Dry.NumChannels,
|
|
|
|
SAFE_CONST(ALfloatBUFFERSIZE*,device->FOAOut.Buffer), SamplesToDo
|
|
|
|
);
|
|
|
|
|
2017-01-18 00:49:26 +00:00
|
|
|
lidx = GetChannelIdxByName(device->RealOut, FrontLeft);
|
|
|
|
ridx = GetChannelIdxByName(device->RealOut, FrontRight);
|
|
|
|
assert(lidx != -1 && ridx != -1);
|
|
|
|
|
|
|
|
HrtfMix = SelectHrtfMixer();
|
2017-03-10 18:47:43 +00:00
|
|
|
state = device->Hrtf;
|
2017-01-18 00:49:26 +00:00
|
|
|
for(c = 0;c < device->Dry.NumChannels;c++)
|
2016-02-14 11:23:06 +00:00
|
|
|
{
|
2017-01-18 00:49:26 +00:00
|
|
|
HrtfMix(device->RealOut.Buffer[lidx], device->RealOut.Buffer[ridx],
|
2017-03-10 18:47:43 +00:00
|
|
|
device->Dry.Buffer[c], state->Offset, state->IrSize,
|
2017-03-12 02:04:06 +00:00
|
|
|
SAFE_CONST(ALfloat2*,state->Chan[c].Coeffs),
|
|
|
|
state->Chan[c].Values, SamplesToDo
|
2017-01-18 00:49:26 +00:00
|
|
|
);
|
2016-02-14 11:23:06 +00:00
|
|
|
}
|
2017-03-10 18:47:43 +00:00
|
|
|
state->Offset += SamplesToDo;
|
2014-11-22 12:20:17 +00:00
|
|
|
}
|
2016-03-15 12:08:05 +00:00
|
|
|
else if(device->AmbiDecoder)
|
|
|
|
{
|
2016-07-05 21:18:17 +00:00
|
|
|
if(device->Dry.Buffer != device->FOAOut.Buffer)
|
2016-03-23 19:53:36 +00:00
|
|
|
bformatdec_upSample(device->AmbiDecoder,
|
2016-10-04 23:25:43 +00:00
|
|
|
device->Dry.Buffer, SAFE_CONST(ALfloatBUFFERSIZE*,device->FOAOut.Buffer),
|
2016-03-23 19:53:36 +00:00
|
|
|
device->FOAOut.NumChannels, SamplesToDo
|
|
|
|
);
|
2016-03-15 12:08:05 +00:00
|
|
|
bformatdec_process(device->AmbiDecoder,
|
|
|
|
device->RealOut.Buffer, device->RealOut.NumChannels,
|
2016-10-04 23:25:43 +00:00
|
|
|
SAFE_CONST(ALfloatBUFFERSIZE*,device->Dry.Buffer), SamplesToDo
|
2016-03-15 12:08:05 +00:00
|
|
|
);
|
|
|
|
}
|
2016-07-30 16:29:21 +00:00
|
|
|
else if(device->AmbiUp)
|
|
|
|
{
|
|
|
|
ambiup_process(device->AmbiUp,
|
|
|
|
device->RealOut.Buffer, device->RealOut.NumChannels,
|
2016-10-04 23:25:43 +00:00
|
|
|
SAFE_CONST(ALfloatBUFFERSIZE*,device->FOAOut.Buffer), SamplesToDo
|
2016-07-30 16:29:21 +00:00
|
|
|
);
|
|
|
|
}
|
2016-07-14 06:08:11 +00:00
|
|
|
else if(device->Uhj_Encoder)
|
2010-11-21 10:51:18 +00:00
|
|
|
{
|
2016-07-14 06:08:11 +00:00
|
|
|
int lidx = GetChannelIdxByName(device->RealOut, FrontLeft);
|
|
|
|
int ridx = GetChannelIdxByName(device->RealOut, FrontRight);
|
|
|
|
if(lidx != -1 && ridx != -1)
|
2012-03-03 17:41:16 +00:00
|
|
|
{
|
2016-07-14 06:08:11 +00:00
|
|
|
/* Encode to stereo-compatible 2-channel UHJ output. */
|
|
|
|
EncodeUhj2(device->Uhj_Encoder,
|
|
|
|
device->RealOut.Buffer[lidx], device->RealOut.Buffer[ridx],
|
|
|
|
device->Dry.Buffer, SamplesToDo
|
|
|
|
);
|
2016-02-27 00:09:06 +00:00
|
|
|
}
|
2016-07-14 06:08:11 +00:00
|
|
|
}
|
|
|
|
else if(device->Bs2b)
|
|
|
|
{
|
|
|
|
int lidx = GetChannelIdxByName(device->RealOut, FrontLeft);
|
|
|
|
int ridx = GetChannelIdxByName(device->RealOut, FrontRight);
|
|
|
|
if(lidx != -1 && ridx != -1)
|
2016-02-27 00:09:06 +00:00
|
|
|
{
|
|
|
|
/* Apply binaural/crossfeed filter */
|
2016-07-14 06:08:11 +00:00
|
|
|
bs2b_cross_feed(device->Bs2b, device->RealOut.Buffer[lidx],
|
|
|
|
device->RealOut.Buffer[ridx], SamplesToDo);
|
2011-07-30 12:43:47 +00:00
|
|
|
}
|
2010-11-21 10:51:18 +00:00
|
|
|
}
|
|
|
|
|
2011-08-12 22:42:36 +00:00
|
|
|
if(buffer)
|
2010-11-21 10:51:18 +00:00
|
|
|
{
|
2016-03-10 06:57:38 +00:00
|
|
|
ALfloat (*OutBuffer)[BUFFERSIZE] = device->RealOut.Buffer;
|
2017-02-10 14:20:16 +00:00
|
|
|
ALsizei OutChannels = device->RealOut.NumChannels;
|
2017-02-20 06:47:59 +00:00
|
|
|
DistanceComp *DistComp = device->ChannelDelay;
|
2016-03-10 06:57:38 +00:00
|
|
|
|
2017-02-20 06:47:59 +00:00
|
|
|
#define WRITE(T, a, b, c, d, e) do { \
|
|
|
|
Write_##T(SAFE_CONST(ALfloatBUFFERSIZE*,(a)), (b), (c), (d), (e)); \
|
|
|
|
buffer = (T*)buffer + (d)*(e); \
|
2014-11-24 07:45:30 +00:00
|
|
|
} while(0)
|
2011-08-12 22:42:36 +00:00
|
|
|
switch(device->FmtType)
|
|
|
|
{
|
|
|
|
case DevFmtByte:
|
2017-02-20 06:47:59 +00:00
|
|
|
WRITE(ALbyte, OutBuffer, buffer, DistComp, SamplesToDo, OutChannels);
|
2011-08-12 22:42:36 +00:00
|
|
|
break;
|
|
|
|
case DevFmtUByte:
|
2017-02-20 06:47:59 +00:00
|
|
|
WRITE(ALubyte, OutBuffer, buffer, DistComp, SamplesToDo, OutChannels);
|
2011-08-12 22:42:36 +00:00
|
|
|
break;
|
|
|
|
case DevFmtShort:
|
2017-02-20 06:47:59 +00:00
|
|
|
WRITE(ALshort, OutBuffer, buffer, DistComp, SamplesToDo, OutChannels);
|
2011-08-12 22:42:36 +00:00
|
|
|
break;
|
|
|
|
case DevFmtUShort:
|
2017-02-20 06:47:59 +00:00
|
|
|
WRITE(ALushort, OutBuffer, buffer, DistComp, SamplesToDo, OutChannels);
|
2012-02-14 19:44:57 +00:00
|
|
|
break;
|
|
|
|
case DevFmtInt:
|
2017-02-20 06:47:59 +00:00
|
|
|
WRITE(ALint, OutBuffer, buffer, DistComp, SamplesToDo, OutChannels);
|
2012-02-14 19:44:57 +00:00
|
|
|
break;
|
|
|
|
case DevFmtUInt:
|
2017-02-20 06:47:59 +00:00
|
|
|
WRITE(ALuint, OutBuffer, buffer, DistComp, SamplesToDo, OutChannels);
|
2011-08-12 22:42:36 +00:00
|
|
|
break;
|
|
|
|
case DevFmtFloat:
|
2017-02-20 06:47:59 +00:00
|
|
|
WRITE(ALfloat, OutBuffer, buffer, DistComp, SamplesToDo, OutChannels);
|
2011-08-12 22:42:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-11-24 07:45:30 +00:00
|
|
|
#undef WRITE
|
2010-11-21 10:51:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size -= SamplesToDo;
|
|
|
|
}
|
|
|
|
|
2012-09-16 08:35:16 +00:00
|
|
|
RestoreFPUMode(&oldMode);
|
2010-11-21 10:51:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-18 15:19:43 +00:00
|
|
|
void aluHandleDisconnect(ALCdevice *device)
|
2009-08-27 02:15:17 +00:00
|
|
|
{
|
2011-08-29 02:28:41 +00:00
|
|
|
ALCcontext *Context;
|
2009-10-20 18:54:04 +00:00
|
|
|
|
2011-09-11 02:22:46 +00:00
|
|
|
device->Connected = ALC_FALSE;
|
|
|
|
|
2016-12-21 04:49:37 +00:00
|
|
|
Context = ATOMIC_LOAD_SEQ(&device->ContextList);
|
2011-08-29 02:28:41 +00:00
|
|
|
while(Context)
|
2009-08-27 02:15:17 +00:00
|
|
|
{
|
2017-02-21 19:17:47 +00:00
|
|
|
ALvoice **voice, **voice_end;
|
2009-08-27 02:15:17 +00:00
|
|
|
|
2014-08-21 10:24:48 +00:00
|
|
|
voice = Context->Voices;
|
|
|
|
voice_end = voice + Context->VoiceCount;
|
|
|
|
while(voice != voice_end)
|
2009-08-27 02:15:17 +00:00
|
|
|
{
|
2017-03-05 12:50:27 +00:00
|
|
|
ALsource *source = ATOMIC_EXCHANGE(ALsource*, &(*voice)->Source, NULL,
|
|
|
|
almemory_order_acq_rel);
|
2017-03-02 08:49:03 +00:00
|
|
|
ATOMIC_STORE(&(*voice)->Playing, false, almemory_order_release);
|
2014-08-21 04:35:18 +00:00
|
|
|
|
2017-02-27 23:35:15 +00:00
|
|
|
if(source)
|
2009-08-27 02:15:17 +00:00
|
|
|
{
|
2017-02-27 23:35:15 +00:00
|
|
|
ALenum playing = AL_PLAYING;
|
|
|
|
ATOMIC_COMPARE_EXCHANGE_STRONG_SEQ(ALenum, &source->state, &playing, AL_STOPPED);
|
2009-08-27 02:15:17 +00:00
|
|
|
}
|
2014-08-21 04:35:18 +00:00
|
|
|
|
2014-08-21 10:24:48 +00:00
|
|
|
voice++;
|
2009-08-27 02:15:17 +00:00
|
|
|
}
|
2014-08-21 10:24:48 +00:00
|
|
|
Context->VoiceCount = 0;
|
2011-08-29 02:28:41 +00:00
|
|
|
|
|
|
|
Context = Context->next;
|
2009-08-27 02:15:17 +00:00
|
|
|
}
|
|
|
|
}
|