194 lines
6.7 KiB
C
194 lines
6.7 KiB
C
/**
|
|
* OpenAL cross platform audio library
|
|
* Copyright (C) 2011 by Chris Robinson
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
* Or go to http://www.gnu.org/copyleft/lgpl.html
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "AL/al.h"
|
|
#include "AL/alc.h"
|
|
#include "alMain.h"
|
|
#include "alSource.h"
|
|
|
|
#define HRIR_COUNT 828
|
|
|
|
static const ALuint sampleRate = 44100;
|
|
static const ALubyte evCount = 19;
|
|
static const ALushort evOffset[19] = { 0, 1, 13, 37, 73, 118, 174, 234, 306, 378, 450, 522, 594, 654, 710, 755, 791, 815, 827 };
|
|
static const ALubyte azCount[19] = { 1, 12, 24, 36, 45, 56, 60, 72, 72, 72, 72, 72, 60, 56, 45, 36, 24, 12, 1 };
|
|
|
|
static struct HRTF {
|
|
ALshort coeffs[HRIR_COUNT][HRIR_LENGTH];
|
|
ALubyte delays[HRIR_COUNT];
|
|
} Hrtf = {
|
|
#include "hrtf_tables.inc"
|
|
};
|
|
|
|
// Calculate the elevation indices given the polar elevation in radians.
|
|
// This will return two indices between 0 and (evCount - 1) and an
|
|
// interpolation factor between 0.0 and 1.0.
|
|
static void CalcEvIndices(ALfloat ev, ALuint *evidx, ALfloat *evmu)
|
|
{
|
|
ev = (M_PI/2.0f + ev) * (evCount-1) / M_PI;
|
|
evidx[0] = (ALuint)ev;
|
|
evidx[1] = __min(evidx[0] + 1, evCount - 1);
|
|
*evmu = ev - evidx[0];
|
|
}
|
|
|
|
// Calculate the azimuth indices given the polar azimuth in radians. This
|
|
// will return two indices between 0 and (azCount [ei] - 1) and an
|
|
// interpolation factor between 0.0 and 1.0.
|
|
static void CalcAzIndices(ALuint evidx, ALfloat az, ALuint *azidx, ALfloat *azmu)
|
|
{
|
|
az = (M_PI*2.0f + az) * azCount[evidx] / (M_PI*2.0f);
|
|
azidx[0] = (ALuint)az % azCount[evidx];
|
|
azidx[1] = (azidx[0] + 1) % azCount[evidx];
|
|
*azmu = az - (ALuint)az;
|
|
}
|
|
|
|
// Calculates static HRIR coefficients and delays for the given polar
|
|
// elevation and azimuth in radians. Linear interpolation is used to
|
|
// increase the apparent resolution of the HRIR dataset. The coefficients
|
|
// are also normalized and attenuated by the specified gain.
|
|
void GetLerpedHrtfCoeffs(ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays)
|
|
{
|
|
ALuint evidx[2], azidx[2];
|
|
ALfloat mu[3];
|
|
ALuint lidx[4], ridx[4];
|
|
ALuint i;
|
|
|
|
// Claculate elevation indices and interpolation factor.
|
|
CalcEvIndices(elevation, evidx, &mu[2]);
|
|
|
|
// Calculate azimuth indices and interpolation factor for the first
|
|
// elevation.
|
|
CalcAzIndices(evidx[0], azimuth, azidx, &mu[0]);
|
|
|
|
// Calculate the first set of linear HRIR indices for left and right
|
|
// channels.
|
|
lidx[0] = evOffset[evidx[0]] + azidx[0];
|
|
lidx[1] = evOffset[evidx[0]] + azidx[1];
|
|
ridx[0] = evOffset[evidx[0]] + ((azCount[evidx[0]]-azidx[0]) % azCount[evidx[0]]);
|
|
ridx[1] = evOffset[evidx[0]] + ((azCount[evidx[0]]-azidx[1]) % azCount[evidx[0]]);
|
|
|
|
// Calculate azimuth indices and interpolation factor for the second
|
|
// elevation.
|
|
CalcAzIndices (evidx[1], azimuth, azidx, &mu[1]);
|
|
|
|
// Calculate the second set of linear HRIR indices for left and right
|
|
// channels.
|
|
lidx[2] = evOffset[evidx[1]] + azidx[0];
|
|
lidx[3] = evOffset[evidx[1]] + azidx[1];
|
|
ridx[2] = evOffset[evidx[1]] + ((azCount[evidx[1]]-azidx[0]) % azCount[evidx[1]]);
|
|
ridx[3] = evOffset[evidx[1]] + ((azCount[evidx[1]]-azidx[1]) % azCount[evidx[1]]);
|
|
|
|
// Calculate the normalized and attenuated HRIR coefficients using linear
|
|
// interpolation when there is enough gain to warrant it. Zero the
|
|
// coefficients if gain is too low.
|
|
if(gain > 0.0001f)
|
|
{
|
|
ALdouble scale = gain * (1.0/32767.0);
|
|
for(i = 0;i < HRIR_LENGTH;i++)
|
|
{
|
|
coeffs[i][0] = lerp(lerp(Hrtf.coeffs[lidx[0]][i], Hrtf.coeffs[lidx[1]][i], mu[0]),
|
|
lerp(Hrtf.coeffs[lidx[2]][i], Hrtf.coeffs[lidx[3]][i], mu[1]),
|
|
mu[2]) * scale;
|
|
coeffs[i][1] = lerp(lerp(Hrtf.coeffs[ridx[0]][i], Hrtf.coeffs[ridx[1]][i], mu[0]),
|
|
lerp(Hrtf.coeffs[ridx[2]][i], Hrtf.coeffs[ridx[3]][i], mu[1]),
|
|
mu[2]) * scale;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i = 0;i < HRIR_LENGTH;i++)
|
|
{
|
|
coeffs[i][0] = 0.0f;
|
|
coeffs[i][1] = 0.0f;
|
|
}
|
|
}
|
|
|
|
// Calculate the HRIR delays using linear interpolation.
|
|
delays[0] = (ALuint)(lerp(lerp(Hrtf.delays[lidx[0]], Hrtf.delays[lidx[1]], mu[0]),
|
|
lerp(Hrtf.delays[lidx[2]], Hrtf.delays[lidx[3]], mu[1]),
|
|
mu[2]) + 0.5f);
|
|
delays[1] = (ALuint)(lerp(lerp(Hrtf.delays[ridx[0]], Hrtf.delays[ridx[1]], mu[0]),
|
|
lerp(Hrtf.delays[ridx[2]], Hrtf.delays[ridx[3]], mu[1]),
|
|
mu[2]) + 0.5f);
|
|
}
|
|
|
|
ALCboolean IsHrtfCompatible(ALCdevice *device)
|
|
{
|
|
if(device->FmtChans == DevFmtStereo && device->Frequency == sampleRate)
|
|
return ALC_TRUE;
|
|
return ALC_FALSE;
|
|
}
|
|
|
|
void InitHrtf(void)
|
|
{
|
|
const char *str;
|
|
FILE *f = NULL;
|
|
|
|
str = GetConfigValue(NULL, "hrtf_tables", "");
|
|
if(str[0] != '\0')
|
|
{
|
|
f = fopen(str, "rb");
|
|
if(f == NULL)
|
|
ERROR("Could not open %s\n", str);
|
|
}
|
|
if(f != NULL)
|
|
{
|
|
const ALubyte maxDelay = SRC_HISTORY_LENGTH;
|
|
ALboolean failed = AL_FALSE;
|
|
struct HRTF newdata;
|
|
size_t i, j;
|
|
|
|
for(i = 0;i < HRIR_COUNT;i++)
|
|
{
|
|
for(j = 0;j < HRIR_LENGTH;j++)
|
|
{
|
|
ALshort val;
|
|
val = fgetc(f);
|
|
val |= fgetc(f)<<8;
|
|
newdata.coeffs[i][j] = val;
|
|
}
|
|
}
|
|
for(i = 0;i < HRIR_COUNT;i++)
|
|
{
|
|
ALubyte val;
|
|
val = fgetc(f);
|
|
newdata.delays[i] = val;
|
|
if(val > maxDelay)
|
|
{
|
|
ERROR("Invalid delay at idx %zu: %u (max: %u), in %s\n", i, val, maxDelay, str);
|
|
failed = AL_TRUE;
|
|
}
|
|
}
|
|
if(feof(f))
|
|
{
|
|
ERROR("Premature end of data while reading %s\n", str);
|
|
failed = AL_TRUE;
|
|
}
|
|
|
|
fclose(f);
|
|
f = NULL;
|
|
|
|
if(!failed)
|
|
Hrtf = newdata;
|
|
}
|
|
}
|