Skip to content

Commit 793b6da

Browse files
jananifernandezjananifernandez
committed
relavent examples now resample HRIRs to match host samplerate
1 parent a71005a commit 793b6da

File tree

12 files changed

+133
-59
lines changed

12 files changed

+133
-59
lines changed

‎examples/src/ambi_bin/ambi_bin.c‎

Lines changed: 21 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,7 @@ void ambi_bin_create
9393
pars->sofa_filepath = NULL;
9494
pars->hrirs = NULL;
9595
pars->hrir_dirs_deg = NULL;
96+
pars->hrir_orig_fs = __default_hrir_fs;
9697
pars->itds_s = NULL;
9798
pars->hrtf_fb = NULL;
9899
pars->weights = NULL;
@@ -242,6 +243,25 @@ void ambi_bin_initCodec
242243
pars->hrir_dirs_deg = realloc1d(pars->hrir_dirs_deg, pars->N_hrir_dirs*2*sizeof(float));
243244
memcpy(pars->hrir_dirs_deg, (float*)__default_hrir_dirs_deg, pars->N_hrir_dirs*2*sizeof(float));
244245
}
246+
247+
/* Resample HRIRs if needed */
248+
pars->hrir_orig_fs = pars->hrir_fs;
249+
if(pars->hrir_fs!=pData->fs){
250+
strcpy(pData->progressBarText, "Resampling HRIRs");
251+
pData->progressBar0_1 = 0.25f;
252+
float* hrirs_resampled;
253+
int hrir_length_resample;
254+
resampleHRIRs(pars->hrirs, pars->N_hrir_dirs, pars->hrir_len, pars->hrir_fs, pData->fs, 1, &hrirs_resampled, &hrir_length_resample);
255+
256+
/* Replace with resampled HRIRs */
257+
pars->hrir_fs = pData->fs;
258+
pars->hrir_len = hrir_length_resample;
259+
pars->hrirs = realloc1d(pars->hrirs, pars->N_hrir_dirs*NUM_EARS*(pars->hrir_len)*sizeof(float));
260+
memcpy(pars->hrirs, hrirs_resampled, pars->N_hrir_dirs*NUM_EARS*(pars->hrir_len)*sizeof(float));
261+
262+
/* Clean-up */
263+
free(hrirs_resampled);
264+
}
245265

246266
/* convert hrirs to filterbank coefficients */
247267
pData->progressBar0_1 = 0.4f;
@@ -826,7 +846,7 @@ int ambi_bin_getHRIRsamplerate(void* const hAmbi)
826846
{
827847
ambi_bin_data *pData = (ambi_bin_data*)(hAmbi);
828848
ambi_bin_codecPars* pars = pData->pars;
829-
return pars->hrir_fs;
849+
return pars->hrir_orig_fs;
830850
}
831851

832852
int ambi_bin_getDAWsamplerate(void* const hAmbi)

‎examples/src/ambi_bin/ambi_bin_internal.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,7 @@ typedef struct _ambi_bin_codecPars
103103
float* hrir_dirs_deg; /**< directions of the HRIRs in degrees [azi elev]; FLAT: N_hrir_dirs x 2 */
104104
_Atomic_INT32 N_hrir_dirs; /**< number of HRIR directions in the current sofa file */
105105
_Atomic_INT32 hrir_len; /**< length of the HRIRs, this can be truncated, see "saf_sofa_reader.h" */
106+
_Atomic_INT32 hrir_orig_fs; /**< Can be different from hrir_fs if HRIRs were resampled */
106107
_Atomic_INT32 hrir_fs; /**< sampling rate of the HRIRs, should ideally match the host sampling rate, although not required */
107108

108109
/* hrtf filterbank coefficients */

‎examples/src/ambi_dec/ambi_dec.c‎

Lines changed: 27 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -98,6 +98,7 @@ void ambi_dec_create
9898
}
9999
pars->sofa_filepath = NULL;
100100
pars->hrirs = NULL;
101+
pars->hrir_orig_fs = __default_hrir_fs;
101102
pars->hrir_dirs_deg = NULL;
102103
pars->hrtf_vbap_gtableIdx = NULL;
103104
pars->hrtf_vbap_gtableComp = NULL;
@@ -176,9 +177,12 @@ void ambi_dec_init
176177
ambi_dec_data *pData = (ambi_dec_data*)(hAmbi);
177178

178179
/* define frequency vector */
179-
pData->fs = sampleRate;
180-
if (pData->codecStatus == CODEC_STATUS_INITIALISED)
181-
afSTFT_getCentreFreqs(pData->hSTFT, (float)pData->fs, HYBRID_BANDS, pData->freqVector);
180+
if(pData->fs != sampleRate){
181+
pData->fs = sampleRate;
182+
pData->reinit_hrtfsFLAG = 1;
183+
ambi_dec_setCodecStatus(hAmbi, CODEC_STATUS_NOT_INITIALISED);
184+
}
185+
afSTFT_getCentreFreqs(pData->hSTFT, (float)pData->fs, HYBRID_BANDS, pData->freqVector);
182186
}
183187

184188
void ambi_dec_initCodec
@@ -402,6 +406,25 @@ void ambi_dec_initCodec
402406
memcpy(pars->hrir_dirs_deg, (float*)__default_hrir_dirs_deg, pars->N_hrir_dirs*2*sizeof(float));
403407
}
404408

409+
/* Resample HRIRs if needed */
410+
pars->hrir_orig_fs = pars->hrir_fs;
411+
if(pars->hrir_fs!=pData->fs){
412+
strcpy(pData->progressBarText, "Resampling HRIRs");
413+
pData->progressBar0_1 = 0.6f;
414+
float* hrirs_resampled;
415+
int hrir_length_resample;
416+
resampleHRIRs(pars->hrirs, pars->N_hrir_dirs, pars->hrir_len, pars->hrir_fs, pData->fs, 1, &hrirs_resampled, &hrir_length_resample);
417+
418+
/* Replace with resampled HRIRs */
419+
pars->hrir_fs = pData->fs;
420+
pars->hrir_len = hrir_length_resample;
421+
pars->hrirs = realloc1d(pars->hrirs, pars->N_hrir_dirs*NUM_EARS*(pars->hrir_len)*sizeof(float));
422+
memcpy(pars->hrirs, hrirs_resampled, pars->N_hrir_dirs*NUM_EARS*(pars->hrir_len)*sizeof(float));
423+
424+
/* Clean-up */
425+
free(hrirs_resampled);
426+
}
427+
405428
/* estimate the ITDs for each HRIR */
406429
pars->itds_s = realloc1d(pars->itds_s, pars->N_hrir_dirs*sizeof(float));
407430
estimateITDs(pars->hrirs, pars->N_hrir_dirs, pars->hrir_len, pars->hrir_fs, pars->itds_s);
@@ -995,7 +1018,7 @@ int ambi_dec_getHRIRsamplerate(void* const hAmbi)
9951018
{
9961019
ambi_dec_data *pData = (ambi_dec_data*)(hAmbi);
9971020
ambi_dec_codecPars* pars = pData->pars;
998-
return pars->hrir_fs;
1021+
return pars->hrir_orig_fs;
9991022
}
10001023

10011024
int ambi_dec_getDAWsamplerate(void* const hAmbi)

‎examples/src/ambi_dec/ambi_dec_internal.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,7 @@ typedef struct _ambi_dec_codecPars
108108
float* hrir_dirs_deg; /**< directions of the HRIRs in degrees [azi elev]; N_hrir_dirs x 2 */
109109
_Atomic_INT32 N_hrir_dirs; /**< number of HRIR directions in the current sofa file */
110110
_Atomic_INT32 hrir_len; /**< length of the HRIRs, this can be truncated, see "saf_sofa_reader.h" */
111+
_Atomic_INT32 hrir_orig_fs; /**< Can be different from hrir_fs if HRIRs were resampled */
111112
_Atomic_INT32 hrir_fs; /**< sampling rate of the HRIRs, should ideally match the host sampling rate, although not required */
112113

113114
/* vbap gain table for panning the HRIRs */

‎examples/src/array2sh/array2sh.c‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -153,7 +153,11 @@ void array2sh_init
153153
{
154154
array2sh_data *pData = (array2sh_data*)(hA2sh);
155155

156-
pData->fs = sampleRate;
156+
if(pData->fs != sampleRate){
157+
pData->fs = sampleRate;
158+
pData->reinitSHTmatrixFLAG = 1;
159+
array2sh_setEvalStatus(hA2sh, EVAL_STATUS_NOT_EVALUATED);
160+
}
157161
afSTFT_getCentreFreqs(pData->hSTFT, (float)pData->fs, HYBRID_BANDS, pData->freqVector);
158162
pData->freqVector[0] = pData->freqVector[1]/4.0f; /* avoids NaNs at DC */
159163
}

‎examples/src/binauraliser/binauraliser.c‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -69,8 +69,8 @@ void binauraliser_create
6969
pData->hrir_dirs_deg = NULL;
7070
pData->sofa_filepath = NULL;
7171
pData->weights = NULL;
72-
pData->N_hrir_dirs = pData->hrir_loaded_len = pData->hrir_runtime_len = 0;
73-
pData->hrir_loaded_fs = pData->hrir_runtime_fs = -1; /* unknown */
72+
pData->N_hrir_dirs = pData->hrir_len = 0;
73+
pData->hrir_orig_fs = __default_hrir_fs;
7474

7575
/* vbap (amplitude normalised) */
7676
pData->hrtf_vbap_gtableIdx = NULL;
@@ -144,11 +144,13 @@ void binauraliser_init
144144

145145
/* define frequency vector */
146146
pData->fs = sampleRate;
147-
afSTFT_getCentreFreqs(pData->hSTFT, (float)sampleRate, HYBRID_BANDS, pData->freqVector);
148-
if(pData->hrir_runtime_fs!=pData->fs){
147+
if(pData->fs != sampleRate){
148+
pData->fs = sampleRate;
149149
pData->reInitHRTFsAndGainTables = 1;
150150
binauraliser_setCodecStatus(hBin, CODEC_STATUS_NOT_INITIALISED);
151151
}
152+
if (pData->codecStatus == CODEC_STATUS_INITIALISED)
153+
afSTFT_getCentreFreqs(pData->hSTFT, (float)sampleRate, HYBRID_BANDS, pData->freqVector);
152154

153155
/* defaults */
154156
pData->recalc_M_rotFLAG = 1;
@@ -563,13 +565,13 @@ float binauraliser_getHRIRElev_deg(void* const hBin, int index)
563565
int binauraliser_getHRIRlength(void* const hBin)
564566
{
565567
binauraliser_data *pData = (binauraliser_data*)(hBin);
566-
return pData->hrir_loaded_len;
568+
return pData->hrir_len;
567569
}
568570

569571
int binauraliser_getHRIRsamplerate(void* const hBin)
570572
{
571573
binauraliser_data *pData = (binauraliser_data*)(hBin);
572-
return pData->hrir_loaded_fs;
574+
return pData->hrir_orig_fs;
573575
}
574576

575577
int binauraliser_getUseDefaultHRIRsflag(void* const hBin)

‎examples/src/binauraliser/binauraliser_internal.c‎

Lines changed: 31 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -125,8 +125,8 @@ void binauraliser_interpHRTFs
125125
void binauraliser_initHRTFsAndGainTables(void* const hBin)
126126
{
127127
binauraliser_data *pData = (binauraliser_data*)(hBin);
128-
int i, new_len;
129-
float* hrtf_vbap_gtable, *hrirs_resampled;//, *hrir_dirs_rad;
128+
int i;
129+
float* hrtf_vbap_gtable;//, *hrir_dirs_rad;
130130
#ifdef SAF_ENABLE_SOFA_READER_MODULE
131131
SAF_SOFA_ERROR_CODES error;
132132
saf_sofa_container sofa;
@@ -148,11 +148,11 @@ void binauraliser_initHRTFsAndGainTables(void* const hBin)
148148
}
149149
else{
150150
/* Copy SOFA data */
151-
pData->hrir_loaded_fs = (int)sofa.DataSamplingRate;
152-
pData->hrir_loaded_len = sofa.DataLengthIR;
151+
pData->hrir_fs = (int)sofa.DataSamplingRate;
152+
pData->hrir_len = sofa.DataLengthIR;
153153
pData->N_hrir_dirs = sofa.nSources;
154-
pData->hrirs = realloc1d(pData->hrirs, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_loaded_len)*sizeof(float));
155-
memcpy(pData->hrirs, sofa.DataIR, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_loaded_len)*sizeof(float));
154+
pData->hrirs = realloc1d(pData->hrirs, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_len)*sizeof(float));
155+
memcpy(pData->hrirs, sofa.DataIR, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_len)*sizeof(float));
156156
pData->hrir_dirs_deg = realloc1d(pData->hrir_dirs_deg, pData->N_hrir_dirs*2*sizeof(float));
157157
cblas_scopy(pData->N_hrir_dirs, sofa.SourcePosition, 3, pData->hrir_dirs_deg, 2); /* azi */
158158
cblas_scopy(pData->N_hrir_dirs, &sofa.SourcePosition[1], 3, &pData->hrir_dirs_deg[1], 2); /* elev */
@@ -166,41 +166,43 @@ void binauraliser_initHRTFsAndGainTables(void* const hBin)
166166
#endif
167167
if(pData->useDefaultHRIRsFLAG){
168168
/* Copy default HRIR data */
169-
pData->hrir_loaded_fs = __default_hrir_fs;
170-
pData->hrir_loaded_len = __default_hrir_len;
169+
pData->hrir_fs = __default_hrir_fs;
170+
pData->hrir_len = __default_hrir_len;
171171
pData->N_hrir_dirs = __default_N_hrir_dirs;
172-
pData->hrirs = realloc1d(pData->hrirs, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_loaded_len)*sizeof(float));
173-
memcpy(pData->hrirs, (float*)__default_hrirs, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_loaded_len)*sizeof(float));
172+
pData->hrirs = realloc1d(pData->hrirs, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_len)*sizeof(float));
173+
memcpy(pData->hrirs, (float*)__default_hrirs, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_len)*sizeof(float));
174174
pData->hrir_dirs_deg = realloc1d(pData->hrir_dirs_deg, pData->N_hrir_dirs*2*sizeof(float));
175175
memcpy(pData->hrir_dirs_deg, (float*)__default_hrir_dirs_deg, pData->N_hrir_dirs*2*sizeof(float));
176176
}
177177

178+
/* Resample HRIRs if needed */
179+
pData->hrir_orig_fs = pData->hrir_fs;
180+
if(pData->hrir_fs!=pData->fs){
181+
strcpy(pData->progressBarText, "Resampling HRIRs");
182+
pData->progressBar0_1 = 0.3f;
183+
float* hrirs_resampled;
184+
int hrir_length_resample;
185+
resampleHRIRs(pData->hrirs, pData->N_hrir_dirs, pData->hrir_len, pData->hrir_fs, pData->fs, 1, &hrirs_resampled, &hrir_length_resample);
186+
187+
/* Replace with resampled HRIRs */
188+
pData->hrir_fs = pData->fs;
189+
pData->hrir_len = hrir_length_resample;
190+
pData->hrirs = realloc1d(pData->hrirs, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_len)*sizeof(float));
191+
memcpy(pData->hrirs, hrirs_resampled, pData->N_hrir_dirs*NUM_EARS*(pData->hrir_len)*sizeof(float));
192+
193+
/* Clean-up */
194+
free(hrirs_resampled);
195+
}
196+
178197
/* Convert from the 0..360 convention, to -180..180 */
179198
convert_0_360To_m180_180(pData->hrir_dirs_deg, pData->N_hrir_dirs);
180199

181200
/* estimate the ITDs for each HRIR */
182201
strcpy(pData->progressBarText,"Estimating ITDs");
183202
pData->progressBar0_1 = 0.4f;
184203
pData->itds_s = realloc1d(pData->itds_s, pData->N_hrir_dirs*sizeof(float));
185-
estimateITDs(pData->hrirs, pData->N_hrir_dirs, pData->hrir_loaded_len, pData->hrir_loaded_fs, pData->itds_s);
204+
estimateITDs(pData->hrirs, pData->N_hrir_dirs, pData->hrir_len, pData->hrir_fs, pData->itds_s);
186205

187-
/* Resample the HRIRs if needed */
188-
if(pData->hrir_loaded_fs!=pData->fs){
189-
strcpy(pData->progressBarText,"Resampling the HRIRs");
190-
pData->progressBar0_1 = 0.5f;
191-
hrirs_resampled = NULL;
192-
resampleHRIRs(pData->hrirs, pData->N_hrir_dirs, pData->hrir_loaded_len, pData->hrir_loaded_fs, pData->fs, 1, &hrirs_resampled, &new_len);
193-
pData->hrirs = realloc1d(pData->hrirs, pData->N_hrir_dirs*NUM_EARS*new_len*sizeof(float));
194-
cblas_scopy(pData->N_hrir_dirs*NUM_EARS*new_len, hrirs_resampled, 1, pData->hrirs, 1);
195-
free(hrirs_resampled);
196-
pData->hrir_runtime_fs = pData->fs;
197-
pData->hrir_runtime_len = new_len;
198-
}
199-
else{
200-
pData->hrir_runtime_fs = pData->hrir_loaded_fs;
201-
pData->hrir_runtime_len = pData->hrir_loaded_len;
202-
}
203-
204206
/* generate VBAP gain table */
205207
strcpy(pData->progressBarText,"Generating interpolation table");
206208
pData->progressBar0_1 = 0.6f;
@@ -223,7 +225,7 @@ void binauraliser_initHRTFsAndGainTables(void* const hBin)
223225
/* convert hrirs to filterbank coefficients */
224226
pData->progressBar0_1 = 0.6f;
225227
pData->hrtf_fb = realloc1d(pData->hrtf_fb, HYBRID_BANDS * NUM_EARS * (pData->N_hrir_dirs)*sizeof(float_complex));
226-
HRIRs2HRTFs_afSTFT(pData->hrirs, pData->N_hrir_dirs, pData->hrir_runtime_len, HOP_SIZE, 0, 1, pData->hrtf_fb);
228+
HRIRs2HRTFs_afSTFT(pData->hrirs, pData->N_hrir_dirs, pData->hrir_len, HOP_SIZE, 0, 1, pData->hrtf_fb);
227229

228230
/* HRIR pre-processing */
229231
if(pData->enableHRIRsDiffuseEQ){

‎examples/src/binauraliser/binauraliser_internal.h‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -92,10 +92,9 @@ typedef struct _binauraliser
9292
float* hrirs; /**< time domain HRIRs; FLAT: N_hrir_dirs x #NUM_EARS x hrir_len */
9393
float* hrir_dirs_deg; /**< directions of the HRIRs in degrees [azi elev]; FLAT: N_hrir_dirs x 2 */
9494
_Atomic_INT32 N_hrir_dirs; /**< number of HRIR directions in the current sofa file */
95-
_Atomic_INT32 hrir_loaded_len; /**< length of the loaded HRIRs, in samples */
96-
_Atomic_INT32 hrir_runtime_len; /**< length of the HRIRs being used for processing (after any resampling), in samples */
97-
_Atomic_INT32 hrir_loaded_fs; /**< sampling rate of the loaded HRIRs */
98-
_Atomic_INT32 hrir_runtime_fs; /**< sampling rate of the HRIRs being used for processing (after any resampling) */
95+
_Atomic_INT32 hrir_len; /**< length of the loaded HRIRs, in samples */
96+
_Atomic_INT32 hrir_orig_fs; /**< Can be different from hrir_fs if HRIRs were resampled */
97+
_Atomic_INT32 hrir_fs; /**< sampling rate of the HRIRs being used for processing (after any resampling) */
9998
float* weights; /**< Integration weights for the HRIR measurement grid; N_hrir_dirs x 1 */
10099

101100
/* vbap gain table */

‎examples/src/binauraliser_nf/binauraliser_nf.c‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -84,12 +84,12 @@ void binauraliserNF_create /* FREQUENCY DOMAIN version */
8484
/* time-frequency transform + buffers */
8585
pData->hSTFT = NULL;
8686
/* hrir data */
87-
pData->hrirs = NULL;
88-
pData->hrir_dirs_deg = NULL;
89-
pData->sofa_filepath = NULL;
90-
pData->weights = NULL;
91-
pData->N_hrir_dirs = pData->hrir_loaded_len = pData->hrir_runtime_len = 0;
92-
pData->hrir_loaded_fs = pData->hrir_runtime_fs = -1; /* unknown */
87+
pData->hrirs = NULL;
88+
pData->hrir_dirs_deg = NULL;
89+
pData->sofa_filepath = NULL;
90+
pData->weights = NULL;
91+
pData->N_hrir_dirs = pData->hrir_len = 0;
92+
pData->hrir_orig_fs = __default_hrir_fs;
9393

9494
/* time domain buffers */
9595
pData->fs = 48000.0f;

‎examples/src/binauraliser_nf/binauraliser_nf_internal.h‎

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ typedef struct _binauraliserNF {
6868
float** outframeTD; /**< time-domain output frame; #NUM_EARS x #BINAURALISER_FRAME_SIZE */
6969
float_complex*** inputframeTF; /**< time-frequency domain input frame; #HYBRID_BANDS x #MAX_NUM_INPUTS x #TIME_SLOTS */
7070
float_complex*** outputframeTF; /**< time-frequency domain input frame; #HYBRID_BANDS x #NUM_EARS x #TIME_SLOTS */
71-
int fs; /**< Host sampling rate, in Hz */
71+
_Atomic_FLOAT32 fs; /**< Host sampling rate, in Hz */
7272
float freqVector[HYBRID_BANDS]; /**< Frequency vector (filterbank centre frequencies) */
7373
void* hSTFT; /**< afSTFT handle */
7474

@@ -77,10 +77,9 @@ typedef struct _binauraliserNF {
7777
float* hrirs; /**< time domain HRIRs; FLAT: N_hrir_dirs x #NUM_EARS x hrir_len */
7878
float* hrir_dirs_deg; /**< directions of the HRIRs in degrees [azi elev]; FLAT: N_hrir_dirs x 2 */
7979
_Atomic_INT32 N_hrir_dirs; /**< number of HRIR directions in the current sofa file */
80-
_Atomic_INT32 hrir_loaded_len; /**< length of the loaded HRIRs, in samples */
81-
_Atomic_INT32 hrir_runtime_len; /**< length of the HRIRs being used for processing (after any resampling), in samples */
82-
_Atomic_INT32 hrir_loaded_fs; /**< sampling rate of the loaded HRIRs */
83-
_Atomic_INT32 hrir_runtime_fs; /**< sampling rate of the HRIRs being used for processing (after any resampling) */
80+
_Atomic_INT32 hrir_len; /**< length of the loaded HRIRs, in samples */
81+
_Atomic_INT32 hrir_orig_fs; /**< Can be different from hrir_fs if HRIRs were resampled */
82+
_Atomic_INT32 hrir_fs; /**< sampling rate of the HRIRs being used for processing (after any resampling) */
8483
float* weights; /**< Integration weights for the HRIR measurement grid; N_hrir_dirs x 1 */
8584

8685
/* vbap gain table */
@@ -127,7 +126,6 @@ typedef struct _binauraliserNF {
127126
_Atomic_INT32 useRollPitchYawFlag; /**< rotation order flag, 1: r-p-y, 0: y-p-r */
128127
_Atomic_FLOAT32 src_gains[MAX_NUM_INPUTS]; /**< Gains applied per source */
129128

130-
131129
/* End copied _binauraliser struct members. The following are unique to the _binauraliserNF struct */
132130

133131
float b_dvf[MAX_NUM_INPUTS][NUM_EARS][2]; /**< shelf IIR numerator coefficients for each input, left and right. */

0 commit comments

Comments
 (0)