Skip to content

Commit 0d7f6c7

Browse files
ardgzriveroardgzrivero
committed
[Binaural] Homogenizes directionality processing
1 parent 65dea68 commit 0d7f6c7

4 files changed

Lines changed: 64 additions & 29 deletions

File tree

‎3dti_Toolkit/BinauralSpatializer/Environment.cpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -777,10 +777,10 @@ namespace Binaural {
777777
// HA Directionality in reverb path
778778
//////////////////////////////////////////////////////////
779779
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::LEFT)) {
780-
ProcessDirectionality(outBufferLeft, ownerCore->GetListener()->GetReverbDirectionalityAttenuation_dB(Common::T_ear::LEFT));
780+
ProcessDirectionality(outBufferLeft, ownerCore->GetListener()->GetReverbDirectionalityLinearAttenuation(Common::T_ear::LEFT));
781781
}
782782
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::RIGHT)) {
783-
ProcessDirectionality(outBufferRight, ownerCore->GetListener()->GetReverbDirectionalityAttenuation_dB(Common::T_ear::RIGHT));
783+
ProcessDirectionality(outBufferRight, ownerCore->GetListener()->GetReverbDirectionalityLinearAttenuation(Common::T_ear::RIGHT));
784784
}
785785

786786
// WATCHER
@@ -997,10 +997,10 @@ namespace Binaural {
997997
// HA Directionality in reverb path
998998
//////////////////////////////////////////////////////////
999999
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::LEFT)) {
1000-
ProcessDirectionality(outBufferLeft, ownerCore->GetListener()->GetReverbDirectionalityAttenuation_dB(Common::T_ear::LEFT));
1000+
ProcessDirectionality(outBufferLeft, ownerCore->GetListener()->GetReverbDirectionalityLinearAttenuation(Common::T_ear::LEFT));
10011001
}
10021002
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::RIGHT)) {
1003-
ProcessDirectionality(outBufferRight, ownerCore->GetListener()->GetReverbDirectionalityAttenuation_dB(Common::T_ear::RIGHT));
1003+
ProcessDirectionality(outBufferRight, ownerCore->GetListener()->GetReverbDirectionalityLinearAttenuation(Common::T_ear::RIGHT));
10041004
}
10051005

10061006
// WATCHER
@@ -1216,10 +1216,10 @@ namespace Binaural {
12161216
// HA Directionality in reverb path
12171217
//////////////////////////////////////////////////////////
12181218
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::LEFT)) {
1219-
ProcessDirectionality(outBufferLeft, ownerCore->GetListener()->GetReverbDirectionalityAttenuation_dB(Common::T_ear::LEFT));
1219+
ProcessDirectionality(outBufferLeft, ownerCore->GetListener()->GetReverbDirectionalityLinearAttenuation(Common::T_ear::LEFT));
12201220
}
12211221
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::RIGHT)) {
1222-
ProcessDirectionality(outBufferRight, ownerCore->GetListener()->GetReverbDirectionalityAttenuation_dB(Common::T_ear::RIGHT));
1222+
ProcessDirectionality(outBufferRight, ownerCore->GetListener()->GetReverbDirectionalityLinearAttenuation(Common::T_ear::RIGHT));
12231223
}
12241224

12251225
// WATCHER

‎3dti_Toolkit/BinauralSpatializer/Listener.cpp‎

Lines changed: 39 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -222,60 +222,85 @@ namespace Binaural
222222
}
223223
if (ear == Common::T_ear::LEFT)
224224
{
225-
anechoicDirectionalityAttenuation.left = _directionalityAttenuation;
225+
anechoicDirectionalityAttenuation.left = std::pow(10, _directionalityAttenuation / 20);
226226
reverbDirectionalityAttenuation.left = CalculateReverbDirectionalityAttenuation(_directionalityAttenuation);
227227
}
228228
if (ear == Common::T_ear::RIGHT)
229229
{
230-
anechoicDirectionalityAttenuation.right = _directionalityAttenuation;
230+
anechoicDirectionalityAttenuation.right = std::pow(10, _directionalityAttenuation / 20);
231231
reverbDirectionalityAttenuation.right = CalculateReverbDirectionalityAttenuation(_directionalityAttenuation);
232232
}
233233
}
234234

235235
float CListener::GetAnechoicDirectionalityAttenuation_dB(Common::T_ear ear) const
236236
{
237237
if (ear == Common::T_ear::LEFT)
238-
return anechoicDirectionalityAttenuation.left;
238+
return 20 * std::log(anechoicDirectionalityAttenuation.left);
239+
if (ear == Common::T_ear::RIGHT)
240+
return 20 * std::log(anechoicDirectionalityAttenuation.right);
241+
return -1.0f;
242+
}
243+
244+
float CListener::GetAnechoicDirectionalityLinearAttenuation(Common::T_ear ear) const
245+
{
246+
if (ear == Common::T_ear::LEFT)
247+
return anechoicDirectionalityAttenuation.left;
239248
if (ear == Common::T_ear::RIGHT)
240249
return anechoicDirectionalityAttenuation.right;
241250
return -1.0f;
242251
}
243-
252+
244253
float CListener::GetReverbDirectionalityAttenuation_dB(Common::T_ear ear) const
245254
{
246255
if (ear == Common::T_ear::LEFT)
247-
return reverbDirectionalityAttenuation.left;
256+
return 20 * std::log(reverbDirectionalityAttenuation.left);
248257
if (ear == Common::T_ear::RIGHT)
249-
return reverbDirectionalityAttenuation.right;
258+
return 20 * std::log(reverbDirectionalityAttenuation.right);
250259
return -1.0f;
251260
}
252261

262+
float CListener::GetReverbDirectionalityLinearAttenuation(Common::T_ear ear) const
263+
{
264+
if (ear == Common::T_ear::LEFT)
265+
return reverbDirectionalityAttenuation.left;
266+
if (ear == Common::T_ear::RIGHT)
267+
return reverbDirectionalityAttenuation.right;
268+
return -1.0f;
269+
}
270+
253271
float CListener::CalculateReverbDirectionalityAttenuation(float directionalityExtend_dB)
254272
{
255273

256274
float angle_rad = 0;
257275
float angleStep = M_PI / (float)NUM_STEPS_TO_INTEGRATE_CARDIOID_FOR_REVERB;
258276
float v = 0;
277+
259278
for (int c = 0; c <= NUM_STEPS_TO_INTEGRATE_CARDIOID_FOR_REVERB; c++)
260279
{
261-
v += CalculateDirectionalityAttenuation(directionalityExtend_dB, angle_rad) * std::sin(angle_rad);
280+
v += std::pow(CalculateDirectionalityLinearAttenuation(directionalityExtend_dB, angle_rad),2);
262281
angle_rad += angleStep;
263282
}
264283

265-
v = 0.5 * v / (NUM_STEPS_TO_INTEGRATE_CARDIOID_FOR_REVERB + 1);
266-
267-
v = std::pow(10.0, v / 20.0);
284+
v = std::sqrt(v / NUM_STEPS_TO_INTEGRATE_CARDIOID_FOR_REVERB);
268285

269286
return v;
270287
}
271288

272-
float CListener::CalculateDirectionalityAttenuation( float directionalityExtend, float angleToForwardAxis_rad)
289+
float CListener::CalculateDirectionalityLinearAttenuation(float directionalityExtend, float angleToForwardAxis_rad)
273290
{
274-
if (directionalityExtend > 30) directionalityExtend = 30.0f;
291+
if (directionalityExtend > 30) directionalityExtend = 30.0f;
292+
else if (directionalityExtend < 0) directionalityExtend = 0.0f;
293+
275294
float directionalityFactor = 0.5f - 0.5f * std::pow(10, -directionalityExtend / 20);
276-
float directionalityAttenuation = 1 - directionalityFactor + (directionalityFactor)* std::cos(angleToForwardAxis_rad);
277-
return (20 * std::log10(directionalityAttenuation));
295+
296+
return 1 - directionalityFactor + directionalityFactor * std::cos(angleToForwardAxis_rad);
297+
}
298+
299+
float CListener::CalculateDirectionalityAttenuation_dB(float directionalityExtend, float angleToForwardAxis_rad)
300+
{
301+
return 20.0f * log10(CalculateDirectionalityLinearAttenuation(directionalityExtend, angleToForwardAxis_rad));
278302
}
303+
279304

280305
int CListener::GetHRTFResamplingStep() const
281306
{

‎3dti_Toolkit/BinauralSpatializer/Listener.h‎

Lines changed: 16 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -186,13 +186,13 @@ class CHRTF;
186186
*/
187187
float GetReverbDirectionalityAttenuation_dB(Common::T_ear ear) const;
188188

189-
/** \brief returns the attenuation in dB due to directionality
190-
* \param [in] directionalityExtend (typical values 0 - 30 dBs)
189+
/** \brief returns the linear attenuation due to directionality
190+
* \param [in] directionalityExtend sets the directionality front-back ratio (restricted values from 0 to 30 dBs)
191191
* \param [in] angleToForwardAxis_rad angle in radians between the forward direction and the vector to the sound source
192192
* \retval attenuation attenuation in dB
193193
* \eh Nothing is reported to the error handler.
194194
*/
195-
float CalculateDirectionalityAttenuation(float directionalityExtend, float angleToForwardAxis_rad);
195+
float CalculateDirectionalityAttenuation_dB(float directionalityExtend, float angleToForwardAxis_rad);
196196

197197
/** \brief Get HRTF resampling step from owner core
198198
* \retval HRTF resampling step, in degress
@@ -207,6 +207,16 @@ class CHRTF;
207207
// Calculate the HRTF resampling and FFT again
208208
void CalculateHRTF();
209209

210+
// Gets reverb directionality linear attenuation
211+
float GetReverbDirectionalityLinearAttenuation(Common::T_ear ear) const;
212+
213+
// Gets reverb directionality linear attenuation
214+
float GetAnechoicDirectionalityLinearAttenuation(Common::T_ear ear) const;
215+
216+
// Calculates reverb directionality linear attenuation
217+
float CalculateDirectionalityLinearAttenuation(float directionalityExtend, float angleToForwardAxis_rad);
218+
219+
// Calculates reverb directionality linear attenuation
210220
float CalculateReverbDirectionalityAttenuation(float directionalityExtend_dB);
211221

212222
// Reset HRTF
@@ -234,6 +244,9 @@ class CHRTF;
234244

235245
friend class CHRTF; //Friend Class definition
236246
friend class CCore; //Friend Class definition
247+
friend class CEnvironment; //Friend Class definition
248+
friend class CSingleSourceDSP; //Friend Class definition
249+
friend class CListener; //Friend Class definition
237250
};
238251
}
239252
#endif

‎3dti_Toolkit/BinauralSpatializer/SingleSourceDSP.cpp‎

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -570,22 +570,19 @@ namespace Binaural {
570570
{
571571
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::LEFT))
572572
{
573-
ProcessDirectionality(leftBuffer, ownerCore->GetListener()->GetAnechoicDirectionalityAttenuation_dB(Common::T_ear::LEFT), angleToForwardAxisRadians);
573+
ProcessDirectionality(leftBuffer, ownerCore->GetListener()->GetAnechoicDirectionalityLinearAttenuation(Common::T_ear::LEFT), angleToForwardAxisRadians);
574574
}
575575
if (ownerCore->GetListener()->IsDirectionalityEnabled(Common::T_ear::RIGHT))
576576
{
577-
ProcessDirectionality(rightBuffer, ownerCore->GetListener()->GetAnechoicDirectionalityAttenuation_dB(Common::T_ear::RIGHT), angleToForwardAxisRadians);
577+
ProcessDirectionality(rightBuffer, ownerCore->GetListener()->GetAnechoicDirectionalityLinearAttenuation(Common::T_ear::RIGHT), angleToForwardAxisRadians);
578578
}
579579
}
580580

581581
void CSingleSourceDSP::ProcessDirectionality(CMonoBuffer<float> &buffer, float directionalityAttenutaion, float angleToForwardAxis_rad)
582582
{
583-
float attL = ownerCore->GetListener()->CalculateDirectionalityAttenuation(directionalityAttenutaion, angleToForwardAxis_rad);
584-
attL = std::pow(10.0, attL / 20.0);
585-
buffer.ApplyGain(attL);
583+
buffer.ApplyGain(ownerCore->GetListener()->CalculateDirectionalityLinearAttenuation(directionalityAttenutaion, angleToForwardAxis_rad));
586584
}
587585

588-
589586
// Apply doppler effect simulation
590587
void CSingleSourceDSP::ProcessAddDelay_ExpansionMethod(CMonoBuffer<float>& input, CMonoBuffer<float>& output, CMonoBuffer<float>& delayBuffer, int newDelay)
591588
{

0 commit comments

Comments
 (0)