AuroraMiddleware/AuroraOpenALSoft
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
0407285c53
AuroraOpenALSoft/Alc/hrtf.c

1157 lines
34 KiB
C
Raw Normal View History

Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
/**
* 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
Update COPYING to the latest https://www.gnu.org/licenses/old-licenses/lgpl-2.0.txt to fix the FSF' address Fix the FSF' address in the source
2014-08-18 12:11:03 +00:00
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
* Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#include "config.h"
Dynamically allocate space for HRTF tables
2011-09-18 17:09:32 +00:00
#include <stdlib.h>
Allow loading multiple HRTF tables through a comma-separated list
2011-09-18 18:10:32 +00:00
#include <ctype.h>
Dynamically allocate space for HRTF tables
2011-09-18 17:09:32 +00:00
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
#include "AL/al.h"
#include "AL/alc.h"
#include "alMain.h"
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
#include "alSource.h"
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
#include "alu.h"
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
#include "bformatdec.h"
Move HRTF macros and function declarations to a separate header
2014-02-24 05:11:01 +00:00
#include "hrtf.h"
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
#include "compat.h"
Avoid standard malloc/free for Hrtf allocation
2016-07-07 17:31:43 +00:00
#include "almalloc.h"
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
Use PATH_MAX for the fname length
2012-09-12 10:45:26 +00:00
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
/* Current data set limits defined by the makehrtf utility. */
#define MIN_IR_SIZE (8)
#define MAX_IR_SIZE (128)
#define MOD_IR_SIZE (8)
Improve the external HRTF data file format Although more parameters are read from the file, some must currently conform to specific values. In the future, these restrictions may be lifted.
2011-07-16 07:22:01 +00:00
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
#define MIN_EV_COUNT (5)
#define MAX_EV_COUNT (128)
Improve the external HRTF data file format Although more parameters are read from the file, some must currently conform to specific values. In the future, these restrictions may be lifted.
2011-07-16 07:22:01 +00:00
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
#define MIN_AZ_COUNT (1)
#define MAX_AZ_COUNT (128)
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
struct HrtfEntry {
struct HrtfEntry *next;
struct Hrtf *handle;
char filename[];
};
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
static const ALchar magicMarker00[8] = "MinPHR00";
static const ALchar magicMarker01[8] = "MinPHR01";
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
Partially revert "Use a different method for HRTF mixing" The sound localization with virtual channel mixing was just too poor, so while it's more costly to do per-source HRTF mixing, it's unavoidable if you want good localization. This is only partially reverted because having the virtual channel is still beneficial, particularly with B-Format rendering and effect mixing which otherwise skip HRTF processing. As before, the number of virtual channels can potentially be customized, specifying more or less channels depending on the system's needs.
2014-11-23 18:49:54 +00:00
/* First value for pass-through coefficients (remaining are 0), used for omni-
* directional sounds. */
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
static const ALfloat PassthruCoeff = 0.707106781187f/*sqrt(0.5)*/;
Partially revert "Use a different method for HRTF mixing" The sound localization with virtual channel mixing was just too poor, so while it's more costly to do per-source HRTF mixing, it's unavoidable if you want good localization. This is only partially reverted because having the virtual channel is still beneficial, particularly with B-Format rendering and effect mixing which otherwise skip HRTF processing. As before, the number of virtual channels can potentially be customized, specifying more or less channels depending on the system's needs.
2014-11-23 18:49:54 +00:00
Reference count HRTFs and unload them when unused
2017-04-06 20:00:29 +00:00
static ATOMIC_FLAG LoadedHrtfLock = ATOMIC_FLAG_INIT;
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
static struct HrtfEntry *LoadedHrtfs = NULL;
Dynamically allocate space for HRTF tables
2011-09-18 17:09:32 +00:00
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
/* Calculate the elevation index given the polar elevation in radians. This
* will return an index between 0 and (evcount - 1). Assumes the FPU is in
* round-to-zero mode.
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
*/
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
static ALsizei CalcEvIndex(ALsizei evcount, ALfloat ev)
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
{
Cleanup some HRTF code Use loops instead of duplicating code, rewrite some lines to be clearer.
2014-07-16 20:26:47 +00:00
ev = (F_PI_2 + ev) * (evcount-1) / F_PI;
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
return mini(fastf2i(ev + 0.5f), evcount-1);
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
}
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
/* Calculate the azimuth index given the polar azimuth in radians. This will
* return an index between 0 and (azcount - 1). Assumes the FPU is in round-to-
* zero mode.
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
*/
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
static ALsizei CalcAzIndex(ALsizei azcount, ALfloat az)
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
{
Rename F_2PI to F_TAU
2015-09-13 15:46:48 +00:00
az = (F_TAU + az) * azcount / F_TAU;
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
return fastf2i(az + 0.5f) % azcount;
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
}
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
/* Calculates static HRIR coefficients and delays for the given polar elevation
Rework HRTF coefficient fading This improves fading between HRIRs as sources pan around. In particular, it improves the issue with individual coefficients having various rounding errors in the stepping values, as well as issues with interpolating delay values. It does this by doing two mixing passes for each source. First using the last coefficients that fade to silence, and then again using the new coefficients that fade from silence. When added together, it creates a linear fade from one to the other. Additionally, the gain is applied separately so the individual coefficients don't step with rounding errors. Although this does increase CPU cost since it's doing two mixes per source, each mix is a bit cheaper now since the stepping is simplified to a single gain value, and the overall quality is improved.
2017-03-12 02:04:06 +00:00
* and azimuth in radians. The coefficients are normalized.
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
*/
Rework HRTF coefficient fading This improves fading between HRIRs as sources pan around. In particular, it improves the issue with individual coefficients having various rounding errors in the stepping values, as well as issues with interpolating delay values. It does this by doing two mixing passes for each source. First using the last coefficients that fade to silence, and then again using the new coefficients that fade from silence. When added together, it creates a linear fade from one to the other. Additionally, the gain is applied separately so the individual coefficients don't step with rounding errors. Although this does increase CPU cost since it's doing two mixes per source, each mix is a bit cheaper now since the stepping is simplified to a single gain value, and the overall quality is improved.
2017-03-12 02:04:06 +00:00
void GetHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat spread, ALfloat (*coeffs)[2], ALsizei *delays)
Add an HRTF filter for mono sources The data is based on the KEMAR HRTF data provided by MIT, which can be found at <http://sound.media.mit.edu/resources/KEMAR.html>. The compact measurements were used. See hrtf_tables.inc for more information. The filter is only available for stereo output, using a 44100hz playback rate. Note also that it currently only applies to mono sounds, and the cf_level and head_dampen config options are ignored while it is active.
2011-05-01 20:59:44 +00:00
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALsizei evidx, azidx, idx;
ALsizei evoffset;
Improve radius behavior with scaling of ambisonic coefficients
2016-04-25 04:42:59 +00:00
ALfloat dirfact;
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
ALsizei i;
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
Improve radius behavior with scaling of ambisonic coefficients
2016-04-25 04:42:59 +00:00
dirfact = 1.0f - (spread / F_TAU);
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
/* Claculate elevation index. */
evidx = CalcEvIndex(Hrtf->evCount, elevation);
evoffset = Hrtf->evOffset[evidx];
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
/* Calculate azimuth index. */
azidx = CalcAzIndex(Hrtf->azCount[evidx], azimuth);
Implement a lerped lookup of the HRTF coefficients/delays Code supplied by Christopher Fitzgerald
2011-07-04 14:14:45 +00:00
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
/* Calculate the HRIR indices for left and right channels. */
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
idx = evoffset + azidx;
Use a more efficient method to blend HRTF delays and coefficients
2012-08-11 09:16:34 +00:00
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
/* Calculate the HRIR delays. */
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
delays[0] = fastf2i(Hrtf->delays[idx][0]*dirfact + 0.5f);
delays[1] = fastf2i(Hrtf->delays[idx][1]*dirfact + 0.5f);
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
/* Calculate the sample offsets for the HRIR indices. */
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
idx *= Hrtf->irSize;
Don't interpolate between nearest HRIRs It still fades between HRIRs when it changes, but now it selects the nearest one instead of blending the nearest four. Due to the minimum-phase nature of the HRIRs, interpolating between delays lead to some oddities which are exasperated by the fading (and the fading is needed to avoid clicks and pops, and smooth out changes).
2016-10-09 07:37:47 +00:00
Rework HRTF coefficient fading This improves fading between HRIRs as sources pan around. In particular, it improves the issue with individual coefficients having various rounding errors in the stepping values, as well as issues with interpolating delay values. It does this by doing two mixing passes for each source. First using the last coefficients that fade to silence, and then again using the new coefficients that fade from silence. When added together, it creates a linear fade from one to the other. Additionally, the gain is applied separately so the individual coefficients don't step with rounding errors. Although this does increase CPU cost since it's doing two mixes per source, each mix is a bit cheaper now since the stepping is simplified to a single gain value, and the overall quality is improved.
2017-03-12 02:04:06 +00:00
/* Calculate the normalized and attenuated HRIR coefficients. */
i = 0;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
coeffs[i][0] = lerp(PassthruCoeff, Hrtf->coeffs[idx+i][0], dirfact);
coeffs[i][1] = lerp(PassthruCoeff, Hrtf->coeffs[idx+i][1], dirfact);
Rework HRTF coefficient fading This improves fading between HRIRs as sources pan around. In particular, it improves the issue with individual coefficients having various rounding errors in the stepping values, as well as issues with interpolating delay values. It does this by doing two mixing passes for each source. First using the last coefficients that fade to silence, and then again using the new coefficients that fade from silence. When added together, it creates a linear fade from one to the other. Additionally, the gain is applied separately so the individual coefficients don't step with rounding errors. Although this does increase CPU cost since it's doing two mixes per source, each mix is a bit cheaper now since the stepping is simplified to a single gain value, and the overall quality is improved.
2017-03-12 02:04:06 +00:00
for(i = 1;i < Hrtf->irSize;i++)
Implement a lerped lookup of the HRTF coefficients/delays Code supplied by Christopher Fitzgerald
2011-07-04 14:14:45 +00:00
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
coeffs[i][0] = Hrtf->coeffs[idx+i][0] * dirfact;
coeffs[i][1] = Hrtf->coeffs[idx+i][1] * dirfact;
Partially revert "Use a different method for HRTF mixing" The sound localization with virtual channel mixing was just too poor, so while it's more costly to do per-source HRTF mixing, it's unavoidable if you want good localization. This is only partially reverted because having the virtual channel is still beneficial, particularly with B-Format rendering and effect mixing which otherwise skip HRTF processing. As before, the number of virtual channels can potentially be customized, specifying more or less channels depending on the system's needs.
2014-11-23 18:49:54 +00:00
}
}
Use B-Format for HRTF's virtual output format This adds the ability to directly decode B-Format with HRTF, though only first- order (WXYZ) for now. Second- and third-order would be easilly doable, however we'd need to be able to up-mix first-order content (from the BFORMAT2D and BFORMAT3D buffer formats) since it would be inappropriate to decode lower-order content with a higher-order decoder.
2015-02-09 23:59:29 +00:00
Allocate as many channels for DirectHrtfState as needed
2017-03-11 14:20:04 +00:00
ALsizei BuildBFormatHrtf(const struct Hrtf *Hrtf, DirectHrtfState *state, ALsizei NumChannels, const ALfloat (*restrict AmbiPoints)[2], const ALfloat (*restrict AmbiMatrix)[2][MAX_AMBI_COEFFS], ALsizei AmbiCount)
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
{
Use second-order ambisonics for basic HRTF rendering This should improve positional quality for relatively low cost. Full HRTF rendering still only uses first-order since the only use of the dry buffer there is for first-order content (B-Format buffers, effects).
2017-01-15 21:57:22 +00:00
/* Set this to 2 for dual-band HRTF processing. May require a higher quality
Add a compile-time macro to use dual-band ambisonic HRTF processing Use single-band processing for now, to see if dual-band is causing a drop in quality at all.
2016-08-31 05:33:33 +00:00
* band-splitter, or better calculation of the new IR length to deal with the
* tail generated by the filter.
*/
Update the ambisonic coefficients for HRTF This uses an AllRAD-derived decoder matrix for the high frequencies, which seems to improve positioning response. It also switches back to dual-band. The low frequencies appear to be unexpectedly quiet by comparison, but it's not that bad and can be tweaked later.
2016-09-26 18:18:26 +00:00
#define NUM_BANDS 2
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
BandSplitter splitter;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALsizei idx[HRTF_AMBI_MAX_CHANNELS];
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
ALsizei min_delay = HRTF_HISTORY_LENGTH;
Fix a couple hard-coded array sizes
2017-01-16 17:04:58 +00:00
ALfloat temps[3][HRIR_LENGTH];
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
ALsizei max_length = 0;
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
ALsizei i, c, b;
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
Move the B-Format HRTF virtual speaker stuff to InitHrtfPanning This keeps the decoder matrices and coefficient mapping together for if it changes in the future.
2017-01-19 03:16:24 +00:00
for(c = 0;c < AmbiCount;c++)
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
{
Fix HRTF index calculations for B-Format coefficients The CalcEvIndices and CalcAzIndices methods were dependent on the FPU being in round-to-zero mode, which is not the case for panning initialization. And since we just need the closest index and don't need to lerp between them, it's better to just directly calculate the index with rounding.
2016-08-19 06:33:08 +00:00
ALuint evidx, azidx;
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
ALuint evoffset;
ALuint azcount;
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
/* Calculate elevation index. */
Move the B-Format HRTF virtual speaker stuff to InitHrtfPanning This keeps the decoder matrices and coefficient mapping together for if it changes in the future.
2017-01-19 03:16:24 +00:00
evidx = (ALsizei)floorf((F_PI_2 + AmbiPoints[c][0]) *
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
(Hrtf->evCount-1)/F_PI + 0.5f);
evidx = mini(evidx, Hrtf->evCount-1);
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
Fix HRTF index calculations for B-Format coefficients The CalcEvIndices and CalcAzIndices methods were dependent on the FPU being in round-to-zero mode, which is not the case for panning initialization. And since we just need the closest index and don't need to lerp between them, it's better to just directly calculate the index with rounding.
2016-08-19 06:33:08 +00:00
azcount = Hrtf->azCount[evidx];
evoffset = Hrtf->evOffset[evidx];
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
/* Calculate azimuth index for this elevation. */
Move the B-Format HRTF virtual speaker stuff to InitHrtfPanning This keeps the decoder matrices and coefficient mapping together for if it changes in the future.
2017-01-19 03:16:24 +00:00
azidx = (ALsizei)floorf((F_TAU+AmbiPoints[c][1]) *
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
azcount/F_TAU + 0.5f) % azcount;
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
/* Calculate indices for left and right channels. */
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
idx[c] = evoffset + azidx;
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
min_delay = mini(min_delay, mini(Hrtf->delays[idx[c]][0], Hrtf->delays[idx[c]][1]));
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
}
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
memset(temps, 0, sizeof(temps));
bandsplit_init(&splitter, 400.0f / (ALfloat)Hrtf->sampleRate);
Move the B-Format HRTF virtual speaker stuff to InitHrtfPanning This keeps the decoder matrices and coefficient mapping together for if it changes in the future.
2017-01-19 03:16:24 +00:00
for(c = 0;c < AmbiCount;c++)
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
const ALfloat (*fir)[2] = &Hrtf->coeffs[idx[c] * Hrtf->irSize];
Combine a couple loops
2017-04-07 18:49:24 +00:00
ALsizei ldelay = Hrtf->delays[idx[c]][0] - min_delay;
ALsizei rdelay = Hrtf->delays[idx[c]][1] - min_delay;
max_length = maxi(max_length,
mini(maxi(ldelay, rdelay) + Hrtf->irSize, HRIR_LENGTH)
);
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
Add a compile-time macro to use dual-band ambisonic HRTF processing Use single-band processing for now, to see if dual-band is causing a drop in quality at all.
2016-08-31 05:33:33 +00:00
if(NUM_BANDS == 1)
{
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
for(i = 0;i < NumChannels;++i)
{
Combine a couple loops
2017-04-07 18:49:24 +00:00
ALsizei lidx = ldelay, ridx = rdelay;
ALsizei j = 0;
while(lidx < HRIR_LENGTH && ridx < HRIR_LENGTH && j < Hrtf->irSize)
{
state->Chan[i].Coeffs[lidx++][0] += fir[j][0] * AmbiMatrix[c][0][i];
state->Chan[i].Coeffs[ridx++][1] += fir[j][1] * AmbiMatrix[c][0][i];
j++;
}
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
}
Add a compile-time macro to use dual-band ambisonic HRTF processing Use single-band processing for now, to see if dual-band is causing a drop in quality at all.
2016-08-31 05:33:33 +00:00
}
else
{
/* Band-split left HRIR into low and high frequency responses. */
bandsplit_clear(&splitter);
for(i = 0;i < Hrtf->irSize;i++)
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
temps[2][i] = fir[i][0];
Add a compile-time macro to use dual-band ambisonic HRTF processing Use single-band processing for now, to see if dual-band is causing a drop in quality at all.
2016-08-31 05:33:33 +00:00
bandsplit_process(&splitter, temps[0], temps[1], temps[2], HRIR_LENGTH);
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
Combine a couple loops
2017-04-07 18:49:24 +00:00
/* Apply left ear response with delay. */
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
for(i = 0;i < NumChannels;++i)
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
{
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
for(b = 0;b < NUM_BANDS;b++)
{
Combine a couple loops
2017-04-07 18:49:24 +00:00
ALsizei lidx = ldelay;
ALsizei j = 0;
while(lidx < HRIR_LENGTH)
state->Chan[i].Coeffs[lidx++][0] += temps[b][j++] * AmbiMatrix[c][b][i];
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
}
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
}
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
Add a compile-time macro to use dual-band ambisonic HRTF processing Use single-band processing for now, to see if dual-band is causing a drop in quality at all.
2016-08-31 05:33:33 +00:00
/* Band-split right HRIR into low and high frequency responses. */
bandsplit_clear(&splitter);
for(i = 0;i < Hrtf->irSize;i++)
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
temps[2][i] = fir[i][1];
Add a compile-time macro to use dual-band ambisonic HRTF processing Use single-band processing for now, to see if dual-band is causing a drop in quality at all.
2016-08-31 05:33:33 +00:00
bandsplit_process(&splitter, temps[0], temps[1], temps[2], HRIR_LENGTH);
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
Combine a couple loops
2017-04-07 18:49:24 +00:00
/* Apply right ear response with delay. */
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
for(i = 0;i < NumChannels;++i)
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
{
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
for(b = 0;b < NUM_BANDS;b++)
{
Combine a couple loops
2017-04-07 18:49:24 +00:00
ALsizei ridx = rdelay;
ALsizei j = 0;
while(ridx < HRIR_LENGTH)
state->Chan[i].Coeffs[ridx++][1] += temps[b][j++] * AmbiMatrix[c][b][i];
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
}
Band-split the HRIRs when building the ambisonic decoder filters This allows each HRIR to contribute a frequency-dependent response, essentially acting like a dual-band decoder playing over the cube speaker array.
2016-08-21 10:05:42 +00:00
}
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
}
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
}
Use ALsizei for sizes and offsets with the mixer Unsigned 32-bit offsets actually have some potential overhead on 64-bit targets for pointer/array accesses due to rules on integer wrapping. No idea how much impact it has in practice, but it's nice to be correct about it.
2017-01-16 15:45:07 +00:00
TRACE("Skipped min delay: %d, new combined length: %d\n", min_delay, max_length);
Only use the cube points for generating the ambisonic HRTF coefficients Using all the HRIRs seems to have problems with volume balancing, due in part to HRTF data sets not having uniform enough measurements for a simple decoder matrix to work (and generating a proper one that would work better is not that easy). This still maintains the benefits of decoding ambisonics directly to HRTF, namely that it only needs to filter the 4 ambisonic channels and can use more optimized HRTF filtering methods on those channels. It can also be improved further with frequency-dependent processing baked into the generated coefficients, incurring no extra run-time cost for it.
2016-08-17 12:34:09 +00:00
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
return max_length;
Move the B-Format HRTF virtual speaker stuff to InitHrtfPanning This keeps the decoder matrices and coefficient mapping together for if it changes in the future.
2017-01-19 03:16:24 +00:00
#undef NUM_BANDS
Decode directly from B-Format to HRTF instead of a cube Last time this attempted to average the HRIRs according to their contribution to a given B-Format channel as if they were loudspeakers, as well as averaging the HRIR delays. The latter part resulted in the loss of the ITD (inter-aural time delay), a key component of HRTF. This time, the HRIRs are averaged similar to above, except instead of averaging the delays, they're applied to the resulting coefficients (for example, a delay of 8 would apply the HRIR starting at the 8th sample of the target HRIR). This does roughly double the IR length, as the largest delay is about 35 samples while the filter is normally 32 samples. However, this is still smaller the original data set IR (which was 256 samples), it also only needs to be applied to 4 channels for first-order ambisonics, rather than the 8-channel cube. So it's doing twice as much work per sample, but only working on half the number of samples. Additionally, since the resulting HRIRs no longer rely on an extra delay line, a more efficient HRTF mixing function can be made that doesn't use one. Such a function can also avoid the per-sample stepping parameters the original uses.
2016-08-12 06:20:35 +00:00
}
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
static struct Hrtf *CreateHrtfStore(ALuint rate, ALsizei irSize, ALsizei evCount, ALsizei irCount,
const ALubyte *azCount, const ALushort *evOffset,
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
const ALfloat (*coeffs)[2], const ALubyte (*delays)[2],
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
const char *filename)
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
{
struct Hrtf *Hrtf;
size_t total;
total = sizeof(struct Hrtf);
total += sizeof(Hrtf->azCount[0])*evCount;
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
total = RoundUp(total, sizeof(ALushort)); /* Align for ushort fields */
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
total += sizeof(Hrtf->evOffset[0])*evCount;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
total = RoundUp(total, 16); /* Align for coefficients using SIMD */
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
total += sizeof(Hrtf->coeffs[0])*irSize*irCount;
total += sizeof(Hrtf->delays[0])*irCount;
Hrtf = al_calloc(16, total);
if(Hrtf == NULL)
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
ERR("Out of memory allocating storage for %s.\n", filename);
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
else
{
uintptr_t offset = sizeof(struct Hrtf);
char *base = (char*)Hrtf;
ALushort *_evOffset;
ALubyte *_azCount;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALubyte (*_delays)[2];
ALfloat (*_coeffs)[2];
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
ALsizei i;
Reference count HRTFs and unload them when unused
2017-04-06 20:00:29 +00:00
InitRef(&Hrtf->ref, 0);
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
Hrtf->sampleRate = rate;
Hrtf->irSize = irSize;
Hrtf->evCount = evCount;
/* Set up pointers to storage following the main HRTF struct. */
_azCount = (ALubyte*)(base + offset); Hrtf->azCount = _azCount;
offset += sizeof(_azCount[0])*evCount;
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
offset = RoundUp(offset, sizeof(ALushort)); /* Align for ushort fields */
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
_evOffset = (ALushort*)(base + offset); Hrtf->evOffset = _evOffset;
offset += sizeof(_evOffset[0])*evCount;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
offset = RoundUp(offset, 16); /* Align for coefficients using SIMD */
_coeffs = (ALfloat(*)[2])(base + offset); Hrtf->coeffs = _coeffs;
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
offset += sizeof(_coeffs[0])*irSize*irCount;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
_delays = (ALubyte(*)[2])(base + offset); Hrtf->delays = _delays;
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
offset += sizeof(_delays[0])*irCount;
/* Copy input data to storage. */
for(i = 0;i < evCount;i++) _azCount[i] = azCount[i];
for(i = 0;i < evCount;i++) _evOffset[i] = evOffset[i];
Load HRTF coefficients as pre-normalized floats
2017-03-31 11:25:22 +00:00
for(i = 0;i < irSize*irCount;i++)
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
{
_coeffs[i][0] = coeffs[i][0];
_coeffs[i][1] = coeffs[i][1];
}
for(i = 0;i < irCount;i++)
{
_delays[i][0] = delays[i][0];
_delays[i][1] = delays[i][1];
}
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
assert(offset == total);
}
return Hrtf;
}
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
static struct Hrtf *LoadHrtf00(const ALubyte *data, size_t datalen, const char *filename)
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
{
Use a different method for HRTF mixing This new method mixes sources normally into a 14-channel buffer with the channels placed all around the listener. HRTF is then applied to the channels given their positions and written to a 2-channel buffer, which gets written out to the device. This method has the benefit that HRTF processing becomes more scalable. The costly HRTF filters are applied to the 14-channel buffer after the mix is done, turning it into a post-process with a fixed overhead. Mixing sources is done with normal non-HRTF methods, so increasing the number of playing sources only incurs normal mixing costs. Another benefit is that it improves B-Format playback since the soundfield gets mixed into speakers covering all three dimensions, which then get filtered based on their locations. The main downside to this is that the spatial resolution of the HRTF dataset does not play a big role anymore. However, the hope is that with ambisonics- based panning, the perceptual position of panned sounds will still be good. It is also an option to increase the number of virtual channels for systems that can handle it, or maybe even decrease it for weaker systems.
2014-11-22 12:20:17 +00:00
const ALubyte maxDelay = HRTF_HISTORY_LENGTH-1;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
struct Hrtf *Hrtf = NULL;
ALboolean failed = AL_FALSE;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALuint rate = 0;
ALushort irCount = 0;
Fix a type mismatch
2012-10-07 15:19:09 +00:00
ALushort irSize = 0;
ALubyte evCount = 0;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
ALubyte *azCount = NULL;
ALushort *evOffset = NULL;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALfloat (*coeffs)[2] = NULL;
ALubyte (*delays)[2] = NULL;
ALsizei i, j;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
if(datalen < 9)
{
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
ERR("Unexpected end of %s data (req %d, rem "SZFMT")\n", filename, 9, datalen);
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
return NULL;
}
rate = *(data++);
rate |= *(data++)<<8;
rate |= *(data++)<<16;
rate |= *(data++)<<24;
datalen -= 4;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
irCount = *(data++);
irCount |= *(data++)<<8;
datalen -= 2;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
irSize = *(data++);
irSize |= *(data++)<<8;
datalen -= 2;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
evCount = *(data++);
datalen -= 1;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
{
ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
failed = AL_TRUE;
}
if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
{
ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
evCount, MIN_EV_COUNT, MAX_EV_COUNT);
failed = AL_TRUE;
}
if(failed)
return NULL;
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
if(datalen < evCount*2)
{
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
ERR("Unexpected end of %s data (req %d, rem "SZFMT")\n", filename, evCount*2, datalen);
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
return NULL;
}
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
azCount = malloc(sizeof(azCount[0])*evCount);
evOffset = malloc(sizeof(evOffset[0])*evCount);
if(azCount == NULL || evOffset == NULL)
{
ERR("Out of memory.\n");
failed = AL_TRUE;
}
if(!failed)
{
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
evOffset[0] = *(data++);
evOffset[0] |= *(data++)<<8;
datalen -= 2;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
for(i = 1;i < evCount;i++)
{
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
evOffset[i] = *(data++);
evOffset[i] |= *(data++)<<8;
datalen -= 2;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
if(evOffset[i] <= evOffset[i-1])
{
ERR("Invalid evOffset: evOffset[%d]=%d (last=%d)\n",
i, evOffset[i], evOffset[i-1]);
failed = AL_TRUE;
}
azCount[i-1] = evOffset[i] - evOffset[i-1];
if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
{
ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
failed = AL_TRUE;
}
}
if(irCount <= evOffset[i-1])
{
ERR("Invalid evOffset: evOffset[%d]=%d (irCount=%d)\n",
i-1, evOffset[i-1], irCount);
failed = AL_TRUE;
}
azCount[i-1] = irCount - evOffset[i-1];
if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
{
ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
failed = AL_TRUE;
}
}
if(!failed)
{
coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
Allocate temp storage for delays when loading HRTFs
2017-04-07 13:40:42 +00:00
delays = malloc(sizeof(delays[0])*irCount);
Make sure malloc succeeded for 'delays'
2017-04-07 16:49:06 +00:00
if(coeffs == NULL || delays == NULL)
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
{
ERR("Out of memory.\n");
failed = AL_TRUE;
}
}
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
if(!failed)
{
size_t reqsize = 2*irSize*irCount + irCount;
if(datalen < reqsize)
{
ERR("Unexpected end of %s data (req "SZFMT", rem "SZFMT")\n",
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
filename, reqsize, datalen);
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
failed = AL_TRUE;
}
}
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
if(!failed)
{
for(i = 0;i < irCount*irSize;i+=irSize)
{
for(j = 0;j < irSize;j++)
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALshort coeff;
coeff = *(data++);
coeff |= *(data++)<<8;
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
datalen -= 2;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
coeffs[i+j][0] = coeff / 32768.0f;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
}
}
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
for(i = 0;i < irCount;i++)
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
delays[i][0] = *(data++);
Allocate temp storage for delays when loading HRTFs
2017-04-07 13:40:42 +00:00
datalen -= 1;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
if(delays[i][0] > maxDelay)
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i][0], maxDelay);
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
failed = AL_TRUE;
}
}
}
if(!failed)
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
{
/* Mirror the left ear responses to the right ear. */
for(i = 0;i < evCount;i++)
{
ALushort evoffset = evOffset[i];
ALubyte azcount = azCount[i];
for(j = 0;j < azcount;j++)
{
ALsizei lidx = evoffset + j;
ALsizei ridx = evoffset + ((azcount-j) % azcount);
ALsizei k;
for(k = 0;k < irSize;k++)
coeffs[ridx*irSize + k][1] = coeffs[lidx*irSize + k][0];
delays[ridx][1] = delays[lidx][0];
}
}
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
Hrtf = CreateHrtfStore(rate, irSize, evCount, irCount, azCount,
evOffset, coeffs, delays, filename);
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
}
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
free(azCount);
free(evOffset);
free(coeffs);
Allocate temp storage for delays when loading HRTFs
2017-04-07 13:40:42 +00:00
free(delays);
Allocate each HRTF as a single chunk
2016-02-17 03:56:44 +00:00
return Hrtf;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
}
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
static struct Hrtf *LoadHrtf01(const ALubyte *data, size_t datalen, const char *filename)
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
{
Use a different method for HRTF mixing This new method mixes sources normally into a 14-channel buffer with the channels placed all around the listener. HRTF is then applied to the channels given their positions and written to a 2-channel buffer, which gets written out to the device. This method has the benefit that HRTF processing becomes more scalable. The costly HRTF filters are applied to the 14-channel buffer after the mix is done, turning it into a post-process with a fixed overhead. Mixing sources is done with normal non-HRTF methods, so increasing the number of playing sources only incurs normal mixing costs. Another benefit is that it improves B-Format playback since the soundfield gets mixed into speakers covering all three dimensions, which then get filtered based on their locations. The main downside to this is that the spatial resolution of the HRTF dataset does not play a big role anymore. However, the hope is that with ambisonics- based panning, the perceptual position of panned sounds will still be good. It is also an option to increase the number of virtual channels for systems that can handle it, or maybe even decrease it for weaker systems.
2014-11-22 12:20:17 +00:00
const ALubyte maxDelay = HRTF_HISTORY_LENGTH-1;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
struct Hrtf *Hrtf = NULL;
ALboolean failed = AL_FALSE;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALuint rate = 0;
ALushort irCount = 0;
ALushort irSize = 0;
ALubyte evCount = 0;
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
const ALubyte *azCount = NULL;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
ALushort *evOffset = NULL;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ALfloat (*coeffs)[2] = NULL;
ALubyte (*delays)[2] = NULL;
ALsizei i, j;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
if(datalen < 6)
{
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
ERR("Unexpected end of %s data (req %d, rem "SZFMT"\n", filename, 6, datalen);
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
return NULL;
}
rate = *(data++);
rate |= *(data++)<<8;
rate |= *(data++)<<16;
rate |= *(data++)<<24;
datalen -= 4;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
irSize = *(data++);
datalen -= 1;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
evCount = *(data++);
datalen -= 1;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
{
ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
failed = AL_TRUE;
}
if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
{
ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
evCount, MIN_EV_COUNT, MAX_EV_COUNT);
failed = AL_TRUE;
}
if(failed)
return NULL;
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
if(datalen < evCount)
{
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
ERR("Unexpected end of %s data (req %d, rem "SZFMT"\n", filename, evCount, datalen);
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
return NULL;
}
azCount = data;
data += evCount;
datalen -= evCount;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
evOffset = malloc(sizeof(evOffset[0])*evCount);
if(azCount == NULL || evOffset == NULL)
{
ERR("Out of memory.\n");
failed = AL_TRUE;
}
if(!failed)
{
for(i = 0;i < evCount;i++)
{
if(azCount[i] < MIN_AZ_COUNT || azCount[i] > MAX_AZ_COUNT)
{
ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
i, azCount[i], MIN_AZ_COUNT, MAX_AZ_COUNT);
failed = AL_TRUE;
}
}
}
if(!failed)
{
evOffset[0] = 0;
irCount = azCount[0];
for(i = 1;i < evCount;i++)
{
evOffset[i] = evOffset[i-1] + azCount[i-1];
irCount += azCount[i];
}
coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
Allocate temp storage for delays when loading HRTFs
2017-04-07 13:40:42 +00:00
delays = malloc(sizeof(delays[0])*irCount);
Make sure malloc succeeded for 'delays'
2017-04-07 16:49:06 +00:00
if(coeffs == NULL || delays == NULL)
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
{
ERR("Out of memory.\n");
failed = AL_TRUE;
}
}
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
if(!failed)
{
size_t reqsize = 2*irSize*irCount + irCount;
if(datalen < reqsize)
{
ERR("Unexpected end of %s data (req "SZFMT", rem "SZFMT"\n",
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
filename, reqsize, datalen);
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
failed = AL_TRUE;
}
}
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
if(!failed)
{
for(i = 0;i < irCount*irSize;i+=irSize)
{
for(j = 0;j < irSize;j++)
{
ALshort coeff;
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
coeff = *(data++);
coeff |= *(data++)<<8;
datalen -= 2;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
coeffs[i+j][0] = coeff / 32768.0f;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
}
}
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
for(i = 0;i < irCount;i++)
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
delays[i][0] = *(data++);
Allocate temp storage for delays when loading HRTFs
2017-04-07 13:40:42 +00:00
datalen -= 1;
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
if(delays[i][0] > maxDelay)
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
{
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i][0], maxDelay);
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
failed = AL_TRUE;
}
}
}
if(!failed)
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
{
/* Mirror the left ear responses to the right ear. */
for(i = 0;i < evCount;i++)
{
ALushort evoffset = evOffset[i];
ALubyte azcount = azCount[i];
for(j = 0;j < azcount;j++)
{
ALsizei lidx = evoffset + j;
ALsizei ridx = evoffset + ((azcount-j) % azcount);
ALsizei k;
for(k = 0;k < irSize;k++)
coeffs[ridx*irSize + k][1] = coeffs[lidx*irSize + k][0];
delays[ridx][1] = delays[lidx][0];
}
}
Combine some HRTF loading code
2017-03-31 10:45:26 +00:00
Hrtf = CreateHrtfStore(rate, irSize, evCount, irCount, azCount,
evOffset, coeffs, delays, filename);
Store the HRTF coeffs as a stereo pair This will make it easier to handle HRTF data sets that have separate left and right ear responses. Will need an mhr version update to take advantage of that.
2017-04-07 15:46:50 +00:00
}
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
free(evOffset);
free(coeffs);
Allocate temp storage for delays when loading HRTFs
2017-04-07 13:40:42 +00:00
free(delays);
Allocate each HRTF as a single chunk
2016-02-17 03:56:44 +00:00
return Hrtf;
Restore support for the previous mhr format
2012-09-12 14:25:05 +00:00
}
Allocate temp storage for delays when loading HRTFs
2017-04-07 13:40:42 +00:00
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
static void AddFileEntry(vector_EnumeratedHrtf *list, const_al_string filename)
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
EnumeratedHrtf entry = { AL_STRING_INIT_STATIC(), NULL };
struct HrtfEntry *loaded_entry;
const EnumeratedHrtf *iter;
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
const char *name;
Exclude the file extension from the HRTF name
2016-02-24 12:21:03 +00:00
const char *ext;
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
int i;
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
/* Check if this file has already been loaded globally. */
loaded_entry = LoadedHrtfs;
while(loaded_entry)
Properly skip loading of already-loaded HRTF data sets Previously, if an HRTF file was loaded it would not only skip loading it, but it would also skip adding it to the output enumeration list. Now it properly skips loading it when it's already loaded, but still adds it to the enumeration list if it's not already in it.
2016-07-25 04:59:02 +00:00
{
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
if(alstr_cmp_cstr(filename, loaded_entry->filename) == 0)
{
/* Check if this entry has already been added to the list. */
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
#define MATCH_ENTRY(i) (loaded_entry == (i)->hrtf)
VECTOR_FIND_IF(iter, const EnumeratedHrtf, *list, MATCH_ENTRY);
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
if(iter != VECTOR_END(*list))
{
TRACE("Skipping duplicate file entry %s\n", alstr_get_cstr(filename));
return;
}
Properly skip loading of already-loaded HRTF data sets Previously, if an HRTF file was loaded it would not only skip loading it, but it would also skip adding it to the output enumeration list. Now it properly skips loading it when it's already loaded, but still adds it to the enumeration list if it's not already in it.
2016-07-25 04:59:02 +00:00
#undef MATCH_FNAME
Fix an incorrect message
2017-04-05 19:46:02 +00:00
break;
Avoid enumerating the same HRTF file twice
2016-02-21 12:46:14 +00:00
}
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
loaded_entry = loaded_entry->next;
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
}
Fix an incorrect message
2017-04-05 19:46:02 +00:00
if(!loaded_entry)
{
TRACE("Got new file \"%s\"\n", alstr_get_cstr(filename));
loaded_entry = al_calloc(DEF_ALIGN,
Use a different way to get the size of structs with flexible array members
2017-04-18 21:11:15 +00:00
FAM_SIZE(struct HrtfEntry, filename, alstr_length(filename)+1)
Fix an incorrect message
2017-04-05 19:46:02 +00:00
);
loaded_entry->next = LoadedHrtfs;
loaded_entry->handle = NULL;
strcpy(loaded_entry->filename, alstr_get_cstr(filename));
LoadedHrtfs = loaded_entry;
}
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
/* TODO: Get a human-readable name from the HRTF data (possibly coming in a
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
* format update). */
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
name = strrchr(alstr_get_cstr(filename), '/');
if(!name) name = strrchr(alstr_get_cstr(filename), '\\');
if(!name) name = alstr_get_cstr(filename);
Calculate a variable closer to where it's used
2016-09-02 04:05:24 +00:00
else ++name;
Exclude the file extension from the HRTF name
2016-02-24 12:21:03 +00:00
ext = strrchr(name, '.');
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
i = 0;
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
do {
Exclude the file extension from the HRTF name
2016-02-24 12:21:03 +00:00
if(!ext)
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_copy_cstr(&entry.name, name);
Exclude the file extension from the HRTF name
2016-02-24 12:21:03 +00:00
else
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_copy_range(&entry.name, name, ext);
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
if(i != 0)
{
char str[64];
snprintf(str, sizeof(str), " #%d", i+1);
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_append_cstr(&entry.name, str);
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
}
++i;
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
#define MATCH_NAME(i) (alstr_cmp(entry.name, (i)->name) == 0)
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
VECTOR_FIND_IF(iter, const EnumeratedHrtf, *list, MATCH_NAME);
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
#undef MATCH_NAME
Shorten VECTOR_ITER_ macros to VECTOR_
2016-04-15 19:22:54 +00:00
} while(iter != VECTOR_END(*list));
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
entry.hrtf = loaded_entry;
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
TRACE("Adding entry \"%s\" from file \"%s\"\n", alstr_get_cstr(entry.name),
alstr_get_cstr(filename));
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
VECTOR_PUSH_BACK(*list, entry);
}
Always load HRTF files through memory pointers
2016-08-31 15:16:49 +00:00
/* Unfortunate that we have to duplicate AddFileEntry to take a memory buffer
* for input instead of opening the given filename.
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
*/
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
static void AddBuiltInEntry(vector_EnumeratedHrtf *list, const_al_string filename, size_t residx)
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
EnumeratedHrtf entry = { AL_STRING_INIT_STATIC(), NULL };
struct HrtfEntry *loaded_entry;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
struct Hrtf *hrtf = NULL;
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
const EnumeratedHrtf *iter;
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
const char *name;
const char *ext;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
int i;
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
loaded_entry = LoadedHrtfs;
while(loaded_entry)
Properly skip loading of already-loaded HRTF data sets Previously, if an HRTF file was loaded it would not only skip loading it, but it would also skip adding it to the output enumeration list. Now it properly skips loading it when it's already loaded, but still adds it to the enumeration list if it's not already in it.
2016-07-25 04:59:02 +00:00
{
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
if(alstr_cmp_cstr(filename, loaded_entry->filename) == 0)
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
#define MATCH_ENTRY(i) (loaded_entry == (i)->hrtf)
VECTOR_FIND_IF(iter, const EnumeratedHrtf, *list, MATCH_ENTRY);
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
if(iter != VECTOR_END(*list))
{
TRACE("Skipping duplicate file entry %s\n", alstr_get_cstr(filename));
return;
}
Properly skip loading of already-loaded HRTF data sets Previously, if an HRTF file was loaded it would not only skip loading it, but it would also skip adding it to the output enumeration list. Now it properly skips loading it when it's already loaded, but still adds it to the enumeration list if it's not already in it.
2016-07-25 04:59:02 +00:00
#undef MATCH_FNAME
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
break;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
}
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
loaded_entry = loaded_entry->next;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
}
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
if(!loaded_entry)
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
{
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
size_t namelen = alstr_length(filename)+32;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
TRACE("Got new file \"%s\"\n", alstr_get_cstr(filename));
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
loaded_entry = al_calloc(DEF_ALIGN,
Use a different way to get the size of structs with flexible array members
2017-04-18 21:11:15 +00:00
FAM_SIZE(struct HrtfEntry, filename, namelen)
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
);
loaded_entry->next = LoadedHrtfs;
loaded_entry->handle = hrtf;
snprintf(loaded_entry->filename, namelen, "!"SZFMT"_%s",
residx, alstr_get_cstr(filename));
LoadedHrtfs = loaded_entry;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
}
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
/* TODO: Get a human-readable name from the HRTF data (possibly coming in a
* format update). */
name = strrchr(alstr_get_cstr(filename), '/');
if(!name) name = strrchr(alstr_get_cstr(filename), '\\');
if(!name) name = alstr_get_cstr(filename);
else ++name;
ext = strrchr(name, '.');
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
i = 0;
do {
Store the HRTF's filename separate from the entry storage
2017-04-05 14:09:16 +00:00
if(!ext)
alstr_copy_cstr(&entry.name, name);
else
alstr_copy_range(&entry.name, name, ext);
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
if(i != 0)
{
char str[64];
snprintf(str, sizeof(str), " #%d", i+1);
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_append_cstr(&entry.name, str);
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
}
++i;
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
#define MATCH_NAME(i) (alstr_cmp(entry.name, (i)->name) == 0)
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
VECTOR_FIND_IF(iter, const EnumeratedHrtf, *list, MATCH_NAME);
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
#undef MATCH_NAME
} while(iter != VECTOR_END(*list));
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
entry.hrtf = loaded_entry;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
TRACE("Adding built-in entry \"%s\"\n", alstr_get_cstr(entry.name));
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
VECTOR_PUSH_BACK(*list, entry);
}
#ifndef ALSOFT_EMBED_HRTF_DATA
Don't use 0 for a resource ID
2016-11-10 20:37:07 +00:00
#define IDR_DEFAULT_44100_MHR 1
#define IDR_DEFAULT_48000_MHR 2
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
static const ALubyte *GetResource(int UNUSED(name), size_t *size)
{
*size = 0;
return NULL;
}
#else
#include "hrtf_res.h"
#ifdef _WIN32
static const ALubyte *GetResource(int name, size_t *size)
{
HMODULE handle;
HGLOBAL res;
HRSRC rc;
GetModuleHandleExW(
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
(LPCWSTR)GetResource, &handle
);
rc = FindResourceW(handle, MAKEINTRESOURCEW(name), MAKEINTRESOURCEW(MHRTYPE));
res = LoadResource(handle, rc);
*size = SizeofResource(handle, rc);
return LockResource(res);
}
Try to make embedded HRTF data sets work on OSX
2016-11-11 05:51:45 +00:00
#elif defined(__APPLE__)
#include <Availability.h>
#include <mach-o/getsect.h>
Fixes for embedded HRTFs on OSX Use an empty source file to build a stub object file, instead of /dev/null. Use _mh_dylib_header to retrieve the data on 10.7+, instead of _mh_execute_header. And shorten the names to fit in the 16-character limit. Thanks to Anna Cheremnykh for the fixes!
2016-11-11 21:14:02 +00:00
#include <mach-o/ldsyms.h>
Try to make embedded HRTF data sets work on OSX
2016-11-11 05:51:45 +00:00
static const ALubyte *GetResource(int name, size_t *size)
{
#if defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
Fixes for embedded HRTFs on OSX Use an empty source file to build a stub object file, instead of /dev/null. Use _mh_dylib_header to retrieve the data on 10.7+, instead of _mh_execute_header. And shorten the names to fit in the 16-character limit. Thanks to Anna Cheremnykh for the fixes!
2016-11-11 21:14:02 +00:00
/* NOTE: OSX 10.7 and up need to call getsectiondata(&_mh_dylib_header, ...). However, that
Try to make embedded HRTF data sets work on OSX
2016-11-11 05:51:45 +00:00
* call requires 10.7.
*/
if(name == IDR_DEFAULT_44100_MHR)
Fixes for embedded HRTFs on OSX Use an empty source file to build a stub object file, instead of /dev/null. Use _mh_dylib_header to retrieve the data on 10.7+, instead of _mh_execute_header. And shorten the names to fit in the 16-character limit. Thanks to Anna Cheremnykh for the fixes!
2016-11-11 21:14:02 +00:00
return getsectiondata(&_mh_dylib_header, "binary", "default_44100", size);
Try to make embedded HRTF data sets work on OSX
2016-11-11 05:51:45 +00:00
if(name == IDR_DEFAULT_48000_MHR)
Fixes for embedded HRTFs on OSX Use an empty source file to build a stub object file, instead of /dev/null. Use _mh_dylib_header to retrieve the data on 10.7+, instead of _mh_execute_header. And shorten the names to fit in the 16-character limit. Thanks to Anna Cheremnykh for the fixes!
2016-11-11 21:14:02 +00:00
return getsectiondata(&_mh_dylib_header, "binary", "default_48000", size);
Try to make embedded HRTF data sets work on OSX
2016-11-11 05:51:45 +00:00
#else
if(name == IDR_DEFAULT_44100_MHR)
Fixes for embedded HRTFs on OSX Use an empty source file to build a stub object file, instead of /dev/null. Use _mh_dylib_header to retrieve the data on 10.7+, instead of _mh_execute_header. And shorten the names to fit in the 16-character limit. Thanks to Anna Cheremnykh for the fixes!
2016-11-11 21:14:02 +00:00
return getsectdata("binary", "default_44100", size);
Try to make embedded HRTF data sets work on OSX
2016-11-11 05:51:45 +00:00
if(name == IDR_DEFAULT_48000_MHR)
Fixes for embedded HRTFs on OSX Use an empty source file to build a stub object file, instead of /dev/null. Use _mh_dylib_header to retrieve the data on 10.7+, instead of _mh_execute_header. And shorten the names to fit in the 16-character limit. Thanks to Anna Cheremnykh for the fixes!
2016-11-11 21:14:02 +00:00
return getsectdata("binary", "default_48000", size);
Try to make embedded HRTF data sets work on OSX
2016-11-11 05:51:45 +00:00
#endif
*size = 0;
return NULL;
}
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
#else
extern const ALubyte _binary_default_44100_mhr_start[] HIDDEN_DECL;
extern const ALubyte _binary_default_44100_mhr_end[] HIDDEN_DECL;
extern const ALubyte _binary_default_44100_mhr_size[] HIDDEN_DECL;
extern const ALubyte _binary_default_48000_mhr_start[] HIDDEN_DECL;
extern const ALubyte _binary_default_48000_mhr_end[] HIDDEN_DECL;
extern const ALubyte _binary_default_48000_mhr_size[] HIDDEN_DECL;
static const ALubyte *GetResource(int name, size_t *size)
{
if(name == IDR_DEFAULT_44100_MHR)
{
/* Make sure all symbols are referenced, to ensure the compiler won't
* ignore the declarations and lose the visibility attribute used to
* hide them (would be nice if ld or objcopy could automatically mark
* them as hidden when generating them, but apparently they can't).
*/
const void *volatile ptr =_binary_default_44100_mhr_size;
(void)ptr;
*size = _binary_default_44100_mhr_end - _binary_default_44100_mhr_start;
return _binary_default_44100_mhr_start;
}
if(name == IDR_DEFAULT_48000_MHR)
{
const void *volatile ptr =_binary_default_48000_mhr_size;
(void)ptr;
*size = _binary_default_48000_mhr_end - _binary_default_48000_mhr_start;
return _binary_default_48000_mhr_start;
}
*size = 0;
return NULL;
}
#endif
#endif
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
vector_EnumeratedHrtf EnumerateHrtf(const_al_string devname)
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
vector_EnumeratedHrtf list = VECTOR_INIT_STATIC();
Add a config option to specify the preferred HRTF
2016-02-21 10:44:02 +00:00
const char *defaulthrtf = "";
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
const char *pathlist = "";
bool usedefaults = true;
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
if(ConfigValueStr(alstr_get_cstr(devname), NULL, "hrtf-paths", &pathlist))
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
{
Avoid some unnecessary string reallocation
2017-04-01 06:22:06 +00:00
al_string pname = AL_STRING_INIT_STATIC();
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
while(pathlist && *pathlist)
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
{
const char *next, *end;
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
while(isspace(*pathlist) || *pathlist == ',')
pathlist++;
if(*pathlist == '\0')
continue;
next = strchr(pathlist, ',');
if(next)
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
end = next++;
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
else
{
end = pathlist + strlen(pathlist);
usedefaults = false;
}
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
while(end != pathlist && isspace(*(end-1)))
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
--end;
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
if(end != pathlist)
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
{
vector_al_string flist;
Avoid some unnecessary string reallocation
2017-04-01 06:22:06 +00:00
size_t i;
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Overwrite the old search path with the new one
2017-04-08 10:00:53 +00:00
alstr_copy_range(&pname, pathlist, end);
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
flist = SearchDataFiles(".mhr", alstr_get_cstr(pname));
Avoid some unnecessary string reallocation
2017-04-01 06:22:06 +00:00
for(i = 0;i < VECTOR_SIZE(flist);i++)
AddFileEntry(&list, VECTOR_ELEM(flist, i));
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
VECTOR_FOR_EACH(al_string, flist, alstr_reset);
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
VECTOR_DEINIT(flist);
}
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
pathlist = next;
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
}
Avoid some unnecessary string reallocation
2017-04-01 06:22:06 +00:00
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_reset(&pname);
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
}
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
else if(ConfigValueExists(alstr_get_cstr(devname), NULL, "hrtf_tables"))
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
ERR("The hrtf_tables option is deprecated, please use hrtf-paths instead.\n");
if(usedefaults)
{
Avoid some unnecessary string reallocation
2017-04-01 06:22:06 +00:00
al_string ename = AL_STRING_INIT_STATIC();
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
vector_al_string flist;
const ALubyte *rdata;
Avoid some unnecessary string reallocation
2017-04-01 06:22:06 +00:00
size_t rsize, i;
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
flist = SearchDataFiles(".mhr", "openal/hrtf");
Avoid some unnecessary string reallocation
2017-04-01 06:22:06 +00:00
for(i = 0;i < VECTOR_SIZE(flist);i++)
AddFileEntry(&list, VECTOR_ELEM(flist, i));
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
VECTOR_FOR_EACH(al_string, flist, alstr_reset);
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
VECTOR_DEINIT(flist);
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
rdata = GetResource(IDR_DEFAULT_44100_MHR, &rsize);
if(rdata != NULL && rsize > 0)
{
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_copy_cstr(&ename, "Built-In 44100hz");
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
AddBuiltInEntry(&list, ename, IDR_DEFAULT_44100_MHR);
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
}
rdata = GetResource(IDR_DEFAULT_48000_MHR, &rsize);
if(rdata != NULL && rsize > 0)
{
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_copy_cstr(&ename, "Built-In 48000hz");
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
AddBuiltInEntry(&list, ename, IDR_DEFAULT_48000_MHR);
Enumerate the embedded HRTF resources when available
2016-07-13 02:02:19 +00:00
}
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
alstr_reset(&ename);
Replace the hrtf_tables option with hrtf-paths
2016-02-23 18:54:42 +00:00
}
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
if(VECTOR_SIZE(list) > 1 && ConfigValueStr(alstr_get_cstr(devname), NULL, "default-hrtf", &defaulthrtf))
Add a config option to specify the preferred HRTF
2016-02-21 10:44:02 +00:00
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
const EnumeratedHrtf *iter;
Add a config option to specify the preferred HRTF
2016-02-21 10:44:02 +00:00
/* Find the preferred HRTF and move it to the front of the list. */
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
#define FIND_ENTRY(i) (alstr_cmp_cstr((i)->name, defaulthrtf) == 0)
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
VECTOR_FIND_IF(iter, const EnumeratedHrtf, list, FIND_ENTRY);
Don't warn if the desired default HRTF is already first
2016-09-10 14:55:33 +00:00
#undef FIND_ENTRY
if(iter == VECTOR_END(list))
WARN("Failed to find default HRTF \"%s\"\n", defaulthrtf);
else if(iter != VECTOR_BEGIN(list))
Add a config option to specify the preferred HRTF
2016-02-21 10:44:02 +00:00
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
EnumeratedHrtf entry = *iter;
Add a config option to specify the preferred HRTF
2016-02-21 10:44:02 +00:00
memmove(&VECTOR_ELEM(list,1), &VECTOR_ELEM(list,0),
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
(iter-VECTOR_BEGIN(list))*sizeof(EnumeratedHrtf));
Add a config option to specify the preferred HRTF
2016-02-21 10:44:02 +00:00
VECTOR_ELEM(list,0) = entry;
}
}
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
return list;
}
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
void FreeHrtfList(vector_EnumeratedHrtf *list)
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
{
Rename al_string_* functions to alstr_*
2017-04-04 13:58:53 +00:00
#define CLEAR_ENTRY(i) alstr_reset(&(i)->name)
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
VECTOR_FOR_EACH(EnumeratedHrtf, *list, CLEAR_ENTRY);
Store the Hrtf struct with the corresponding HrtfEntry Also store the filename with the Hrtf struct so it can be reused for multiple HrtfEntry objects.
2015-10-06 11:01:53 +00:00
VECTOR_DEINIT(*list);
#undef CLEAR_ENTRY
}
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
struct Hrtf *GetLoadedHrtf(struct HrtfEntry *entry)
{
struct Hrtf *hrtf = NULL;
struct FileMapping fmap;
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
const ALubyte *rdata;
const char *name;
size_t residx;
size_t rsize;
char ch;
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
Reference count HRTFs and unload them when unused
2017-04-06 20:00:29 +00:00
while(ATOMIC_FLAG_TEST_AND_SET(&LoadedHrtfLock, almemory_order_seq_cst))
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
althrd_yield();
if(entry->handle)
{
hrtf = entry->handle;
Reference count HRTFs and unload them when unused
2017-04-06 20:00:29 +00:00
Hrtf_IncRef(hrtf);
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
goto done;
}
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
fmap.ptr = NULL;
fmap.len = 0;
if(sscanf(entry->filename, "!"SZFMT"%c", &residx, &ch) == 2 && ch == '_')
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
{
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
name = strchr(entry->filename, ch)+1;
TRACE("Loading %s...\n", name);
rdata = GetResource(residx, &rsize);
if(rdata == NULL || rsize == 0)
{
ERR("Could not get resource "SZFMT", %s\n", residx, name);
goto done;
}
}
else
{
name = entry->filename;
TRACE("Loading %s...\n", entry->filename);
fmap = MapFileToMem(entry->filename);
if(fmap.ptr == NULL)
{
ERR("Could not open %s\n", entry->filename);
goto done;
}
rdata = fmap.ptr;
rsize = fmap.len;
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
}
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
if(rsize < sizeof(magicMarker01))
ERR("%s data is too short ("SZFMT" bytes)\n", name, rsize);
else if(memcmp(rdata, magicMarker01, sizeof(magicMarker01)) == 0)
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
{
TRACE("Detected data set format v1\n");
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
hrtf = LoadHrtf01(rdata+sizeof(magicMarker01),
rsize-sizeof(magicMarker01), name
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
);
}
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
else if(memcmp(rdata, magicMarker00, sizeof(magicMarker00)) == 0)
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
{
TRACE("Detected data set format v0\n");
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
hrtf = LoadHrtf00(rdata+sizeof(magicMarker00),
rsize-sizeof(magicMarker00), name
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
);
}
else
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
ERR("Invalid header in %s: \"%.8s\"\n", name, (const char*)rdata);
if(fmap.ptr)
UnmapFileMem(&fmap);
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
if(!hrtf)
{
Load embedded HRTF entries as-needed
2017-04-06 08:35:09 +00:00
ERR("Failed to load %s\n", name);
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
goto done;
}
Reference count HRTFs and unload them when unused
2017-04-06 20:00:29 +00:00
entry->handle = hrtf;
Hrtf_IncRef(hrtf);
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
TRACE("Loaded HRTF support for format: %s %uhz\n",
DevFmtChannelsString(DevFmtStereo), hrtf->sampleRate);
done:
Reference count HRTFs and unload them when unused
2017-04-06 20:00:29 +00:00
ATOMIC_FLAG_CLEAR(&LoadedHrtfLock, almemory_order_seq_cst);
Load HRTF files as needed Currently only applies to external files, rather than embedded datasets. Also, HRTFs aren't unloaded after being loaded, until library shutdown.
2017-04-05 19:27:30 +00:00
return hrtf;
}
Enumerate and list HRTFs per-device
2015-10-06 07:23:11 +00:00
Reference count HRTFs and unload them when unused
2017-04-06 20:00:29 +00:00
void Hrtf_IncRef(struct Hrtf *hrtf)
{
uint ref = IncrementRef(&hrtf->ref);
TRACEREF("%p increasing refcount to %u\n", hrtf, ref);
}
void Hrtf_DecRef(struct Hrtf *hrtf)
{
struct HrtfEntry *Hrtf;
uint ref = DecrementRef(&hrtf->ref);
TRACEREF("%p decreasing refcount to %u\n", hrtf, ref);
if(ref == 0)
{
while(ATOMIC_FLAG_TEST_AND_SET(&LoadedHrtfLock, almemory_order_seq_cst))
althrd_yield();
Hrtf = LoadedHrtfs;
while(Hrtf != NULL)
{
/* Need to double-check that it's still unused, as another device
* could've reacquired this HRTF after its reference went to 0 and
* before the lock was taken.
*/
if(hrtf == Hrtf->handle && ReadRef(&hrtf->ref) == 0)
{
al_free(Hrtf->handle);
Hrtf->handle = NULL;
TRACE("Unloaded unused HRTF %s\n", Hrtf->filename);
}
Hrtf = Hrtf->next;
}
ATOMIC_FLAG_CLEAR(&LoadedHrtfLock, almemory_order_seq_cst);
}
}
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
void FreeHrtfs(void)
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
struct HrtfEntry *Hrtf = LoadedHrtfs;
Allocate each HRTF as a single chunk
2016-02-17 03:56:44 +00:00
LoadedHrtfs = NULL;
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
Allocate each HRTF as a single chunk
2016-02-17 03:56:44 +00:00
while(Hrtf != NULL)
Update HRTF code This update allows for much more flexibility in the HRTF data. It also allows for HRTF table file names to include "%r" to represent the device's playback rate (e.g. if you set hrtf-%r.mhr, then it will try to use hrtf-44100.mhr or hrtf-48000.mhr depending if the device's output rate is 44100 or 48000, respectively). The makehrtf utility has also been updated to support more options and input file formats, as well as the new mhr format.
2012-09-11 08:59:42 +00:00
{
Store the loaded hrtf entry container in the enumerated hrtf entry
2017-04-05 18:29:58 +00:00
struct HrtfEntry *next = Hrtf->next;
al_free(Hrtf->handle);
Avoid standard malloc/free for Hrtf allocation
2016-07-07 17:31:43 +00:00
al_free(Hrtf);
Allocate each HRTF as a single chunk
2016-02-17 03:56:44 +00:00
Hrtf = next;
Use a minimum phase HRTF data set This reduces the coefficient size from 128 down to 32, with a set of delays
2011-06-03 08:06:00 +00:00
}
Dynamically allocate space for HRTF tables
2011-09-18 17:09:32 +00:00
}
Reference in New Issue Copy Permalink