amy/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-12 15:31:00 -05:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions
winamp/Src/external_dependencies/openmpt-trunk/soundlib/plugins/dmo/I3DL2Reverb.cpp
Jef f2d940131e Initial community commit
2024-09-24 14:54:57 +02:00

645 lines
20 KiB
C++
Raw Blame History

/*
* I3DL2Reverb.cpp
* ---------------
* Purpose: Implementation of the DMO I3DL2Reverb DSP (for non-Windows platforms)
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#ifndef NO_PLUGINS
#include "../../Sndfile.h"
#include "I3DL2Reverb.h"
#ifdef MODPLUG_TRACKER
#include "../../../sounddsp/Reverb.h"
#endif // MODPLUG_TRACKER
#include "mpt/base/numbers.hpp"
#endif // !NO_PLUGINS
OPENMPT_NAMESPACE_BEGIN
#ifndef NO_PLUGINS
namespace DMO
{
void I3DL2Reverb::DelayLine::Init(int32 ms, int32 padding, uint32 sampleRate, int32 delayTap)
{
m_length = Util::muldiv(sampleRate, ms, 1000) + padding;
m_position = 0;
SetDelayTap(delayTap);
assign(m_length, 0.0f);
}
void I3DL2Reverb::DelayLine::SetDelayTap(int32 delayTap)
{
if(m_length > 0)
m_delayPosition = (delayTap + m_position + m_length) % m_length;
}
void I3DL2Reverb::DelayLine::Advance()
{
if(--m_position < 0)
m_position += m_length;
if(--m_delayPosition < 0)
m_delayPosition += m_length;
}
MPT_FORCEINLINE void I3DL2Reverb::DelayLine::Set(float value)
{
at(m_position) = value;
}
float I3DL2Reverb::DelayLine::Get(int32 offset) const
{
offset = (offset + m_position) % m_length;
if(offset < 0)
offset += m_length;
return at(offset);
}
MPT_FORCEINLINE float I3DL2Reverb::DelayLine::Get() const
{
return at(m_delayPosition);
}
IMixPlugin* I3DL2Reverb::Create(VSTPluginLib &factory, CSoundFile &sndFile, SNDMIXPLUGIN *mixStruct)
{
return new (std::nothrow) I3DL2Reverb(factory, sndFile, mixStruct);
}
I3DL2Reverb::I3DL2Reverb(VSTPluginLib &factory, CSoundFile &sndFile, SNDMIXPLUGIN *mixStruct)
: IMixPlugin(factory, sndFile, mixStruct)
{
m_param[kI3DL2ReverbRoom] = 0.9f;
m_param[kI3DL2ReverbRoomHF] = 0.99f;
m_param[kI3DL2ReverbRoomRolloffFactor] = 0.0f;
m_param[kI3DL2ReverbDecayTime] = 0.07f;
m_param[kI3DL2ReverbDecayHFRatio] = 0.3842105f;
m_param[kI3DL2ReverbReflections] = 0.672545433f;
m_param[kI3DL2ReverbReflectionsDelay] = 0.233333333f;
m_param[kI3DL2ReverbReverb] = 0.85f;
m_param[kI3DL2ReverbReverbDelay] = 0.11f;
m_param[kI3DL2ReverbDiffusion] = 1.0f;
m_param[kI3DL2ReverbDensity] = 1.0f;
m_param[kI3DL2ReverbHFReference] = (5000.0f - 20.0f) / 19980.0f;
m_param[kI3DL2ReverbQuality] = 2.0f / 3.0f;
SetCurrentProgram(m_program);
m_mixBuffer.Initialize(2, 2);
InsertIntoFactoryList();
}
void I3DL2Reverb::Process(float *pOutL, float *pOutR, uint32 numFrames)
{
if(m_recalcParams)
{
auto sampleRate = m_effectiveSampleRate;
RecalculateI3DL2ReverbParams();
// Resize and clear delay lines if quality has changed
if(sampleRate != m_effectiveSampleRate)
PositionChanged();
}
if(!m_ok || !m_mixBuffer.Ok())
return;
const float *in[2] = { m_mixBuffer.GetInputBuffer(0), m_mixBuffer.GetInputBuffer(1) };
float *out[2] = { m_mixBuffer.GetOutputBuffer(0), m_mixBuffer.GetOutputBuffer(1) };
uint32 frames = numFrames;
if(!(m_quality & kFullSampleRate) && m_remain && frames > 0)
{
// Remaining frame from previous render call
frames--;
*(out[0]++) = m_prevL;
*(out[1]++) = m_prevR;
in[0]++;
in[1]++;
m_remain = false;
}
while(frames > 0)
{
// Apply room filter and insert into early reflection delay lines
const float inL = *(in[0]++);
const float inRoomL = (m_filterHist[12] - inL) * m_roomFilter + inL;
m_filterHist[12] = inRoomL;
m_delayLines[15].Set(inRoomL);
const float inR = *(in[1]++);
const float inRoomR = (m_filterHist[13] - inR) * m_roomFilter + inR;
m_filterHist[13] = inRoomR;
m_delayLines[16].Set(inRoomR);
// Early reflections (left)
float earlyL = m_delayLines[15].Get(m_earlyTaps[0][1]) * 0.68f
- m_delayLines[15].Get(m_earlyTaps[0][2]) * 0.5f
- m_delayLines[15].Get(m_earlyTaps[0][3]) * 0.62f
- m_delayLines[15].Get(m_earlyTaps[0][4]) * 0.5f
- m_delayLines[15].Get(m_earlyTaps[0][5]) * 0.62f;
if(m_quality & kMoreDelayLines)
{
float earlyL2 = earlyL;
earlyL = m_delayLines[13].Get() + earlyL * 0.618034f;
m_delayLines[13].Set(earlyL2 - earlyL * 0.618034f);
}
const float earlyRefOutL = earlyL * m_ERLevel;
m_filterHist[15] = m_delayLines[15].Get(m_earlyTaps[0][0]) + m_filterHist[15];
m_filterHist[16] = m_delayLines[16].Get(m_earlyTaps[1][0]) + m_filterHist[16];
// Lots of slightly different copy-pasta ahead
float reverbL1, reverbL2, reverbL3, reverbR1, reverbR2, reverbR3;
reverbL1 = -m_filterHist[15] * 0.707f;
reverbL2 = m_filterHist[16] * 0.707f + reverbL1;
reverbR2 = reverbL1 - m_filterHist[16] * 0.707f;
m_filterHist[5] = (m_filterHist[5] - m_delayLines[5].Get()) * m_delayCoeffs[5][1] + m_delayLines[5].Get();
reverbL1 = m_filterHist[5] * m_delayCoeffs[5][0] + reverbL2 * m_diffusion;
m_delayLines[5].Set(reverbL2 - reverbL1 * m_diffusion);
reverbL2 = reverbL1;
reverbL3 = -0.15f * reverbL1;
m_filterHist[4] = (m_filterHist[4] - m_delayLines[4].Get()) * m_delayCoeffs[4][1] + m_delayLines[4].Get();
reverbL1 = m_filterHist[4] * m_delayCoeffs[4][0] + reverbL2 * m_diffusion;
m_delayLines[4].Set(reverbL2 - reverbL1 * m_diffusion);
reverbL2 = reverbL1;
reverbL3 -= reverbL1 * 0.2f;
if(m_quality & kMoreDelayLines)
{
m_filterHist[3] = (m_filterHist[3] - m_delayLines[3].Get()) * m_delayCoeffs[3][1] + m_delayLines[3].Get();
reverbL1 = m_filterHist[3] * m_delayCoeffs[3][0] + reverbL2 * m_diffusion;
m_delayLines[3].Set(reverbL2 - reverbL1 * m_diffusion);
reverbL2 = reverbL1;
reverbL3 += 0.35f * reverbL1;
m_filterHist[2] = (m_filterHist[2] - m_delayLines[2].Get()) * m_delayCoeffs[2][1] + m_delayLines[2].Get();
reverbL1 = m_filterHist[2] * m_delayCoeffs[2][0] + reverbL2 * m_diffusion;
m_delayLines[2].Set(reverbL2 - reverbL1 * m_diffusion);
reverbL2 = reverbL1;
reverbL3 -= reverbL1 * 0.38f;
}
m_delayLines[17].Set(reverbL2);
reverbL1 = m_delayLines[17].Get() * m_delayCoeffs[12][0];
m_filterHist[17] = (m_filterHist[17] - reverbL1) * m_delayCoeffs[12][1] + reverbL1;
m_filterHist[1] = (m_filterHist[1] - m_delayLines[1].Get()) * m_delayCoeffs[1][1] + m_delayLines[1].Get();
reverbL1 = m_filterHist[17] * m_diffusion + m_filterHist[1] * m_delayCoeffs[1][0];
m_delayLines[1].Set(m_filterHist[17] - reverbL1 * m_diffusion);
reverbL2 = reverbL1;
float reverbL4 = reverbL1 * 0.38f;
m_filterHist[0] = (m_filterHist[0] - m_delayLines[0].Get()) * m_delayCoeffs[0][1] + m_delayLines[0].Get();
reverbL1 = m_filterHist[0] * m_delayCoeffs[0][0] + reverbL2 * m_diffusion;
m_delayLines[0].Set(reverbL2 - reverbL1 * m_diffusion);
reverbL3 -= reverbL1 * 0.38f;
m_filterHist[15] = reverbL1;
// Early reflections (right)
float earlyR = m_delayLines[16].Get(m_earlyTaps[1][1]) * 0.707f
- m_delayLines[16].Get(m_earlyTaps[1][2]) * 0.6f
- m_delayLines[16].Get(m_earlyTaps[1][3]) * 0.5f
- m_delayLines[16].Get(m_earlyTaps[1][4]) * 0.6f
- m_delayLines[16].Get(m_earlyTaps[1][5]) * 0.5f;
if(m_quality & kMoreDelayLines)
{
float earlyR2 = earlyR;
earlyR = m_delayLines[14].Get() + earlyR * 0.618034f;
m_delayLines[14].Set(earlyR2 - earlyR * 0.618034f);
}
const float earlyRefOutR = earlyR * m_ERLevel;
m_filterHist[11] = (m_filterHist[11] - m_delayLines[11].Get()) * m_delayCoeffs[11][1] + m_delayLines[11].Get();
reverbR1 = m_filterHist[11] * m_delayCoeffs[11][0] + reverbR2 * m_diffusion;
m_delayLines[11].Set(reverbR2 - reverbR1 * m_diffusion);
reverbR2 = reverbR1;
m_filterHist[10] = (m_filterHist[10] - m_delayLines[10].Get()) * m_delayCoeffs[10][1] + m_delayLines[10].Get();
reverbR1 = m_filterHist[10] * m_delayCoeffs[10][0] + reverbR2 * m_diffusion;
m_delayLines[10].Set(reverbR2 - reverbR1 * m_diffusion);
reverbR3 = reverbL4 - reverbR2 * 0.15f - reverbR1 * 0.2f;
reverbR2 = reverbR1;
if(m_quality & kMoreDelayLines)
{
m_filterHist[9] = (m_filterHist[9] - m_delayLines[9].Get()) * m_delayCoeffs[9][1] + m_delayLines[9].Get();
reverbR1 = m_filterHist[9] * m_delayCoeffs[9][0] + reverbR2 * m_diffusion;
m_delayLines[9].Set(reverbR2 - reverbR1 * m_diffusion);
reverbR2 = reverbR1;
reverbR3 += reverbR1 * 0.35f;
m_filterHist[8] = (m_filterHist[8] - m_delayLines[8].Get()) * m_delayCoeffs[8][1] + m_delayLines[8].Get();
reverbR1 = m_filterHist[8] * m_delayCoeffs[8][0] + reverbR2 * m_diffusion;
m_delayLines[8].Set(reverbR2 - reverbR1 * m_diffusion);
reverbR2 = reverbR1;
reverbR3 -= reverbR1 * 0.38f;
}
m_delayLines[18].Set(reverbR2);
reverbR1 = m_delayLines[18].Get() * m_delayCoeffs[12][0];
m_filterHist[18] = (m_filterHist[18] - reverbR1) * m_delayCoeffs[12][1] + reverbR1;
m_filterHist[7] = (m_filterHist[7] - m_delayLines[7].Get()) * m_delayCoeffs[7][1] + m_delayLines[7].Get();
reverbR1 = m_filterHist[18] * m_diffusion + m_filterHist[7] * m_delayCoeffs[7][0];
m_delayLines[7].Set(m_filterHist[18] - reverbR1 * m_diffusion);
reverbR2 = reverbR1;
float lateRevOutL = (reverbL3 + reverbR1 * 0.38f) * m_ReverbLevelL;
m_filterHist[6] = (m_filterHist[6] - m_delayLines[6].Get()) * m_delayCoeffs[6][1] + m_delayLines[6].Get();
reverbR1 = m_filterHist[6] * m_delayCoeffs[6][0] + reverbR2 * m_diffusion;
m_delayLines[6].Set(reverbR2 - reverbR1 * m_diffusion);
m_filterHist[16] = reverbR1;
float lateRevOutR = (reverbR3 - reverbR1 * 0.38f) * m_ReverbLevelR;
float outL = earlyRefOutL + lateRevOutL;
float outR = earlyRefOutR + lateRevOutR;
for(auto &line : m_delayLines)
line.Advance();
if(!(m_quality & kFullSampleRate))
{
*(out[0]++) = (outL + m_prevL) * 0.5f;
*(out[1]++) = (outR + m_prevR) * 0.5f;
m_prevL = outL;
m_prevR = outR;
in[0]++;
in[1]++;
if(frames-- == 1)
{
m_remain = true;
break;
}
}
*(out[0]++) = outL;
*(out[1]++) = outR;
frames--;
}
ProcessMixOps(pOutL, pOutR, m_mixBuffer.GetOutputBuffer(0), m_mixBuffer.GetOutputBuffer(1), numFrames);
}
int32 I3DL2Reverb::GetNumPrograms() const
{
#ifdef MODPLUG_TRACKER
return NUM_REVERBTYPES;
#else
return 0;
#endif
}
void I3DL2Reverb::SetCurrentProgram(int32 program)
{
#ifdef MODPLUG_TRACKER
if(program < static_cast<int32>(NUM_REVERBTYPES))
{
m_program = program;
const auto &preset = *GetReverbPreset(m_program);
m_param[kI3DL2ReverbRoom] = (preset.lRoom + 10000) / 10000.0f;
m_param[kI3DL2ReverbRoomHF] = (preset.lRoomHF + 10000) / 10000.0f;
m_param[kI3DL2ReverbRoomRolloffFactor] = 0.0f;
m_param[kI3DL2ReverbDecayTime] = (preset.flDecayTime - 0.1f) / 19.9f;
m_param[kI3DL2ReverbDecayHFRatio] = (preset.flDecayHFRatio - 0.1f) / 1.9f;
m_param[kI3DL2ReverbReflections] = (preset.lReflections + 10000) / 11000.0f;
m_param[kI3DL2ReverbReflectionsDelay] = preset.flReflectionsDelay / 0.3f;
m_param[kI3DL2ReverbReverb] = (preset.lReverb + 10000) / 12000.0f;
m_param[kI3DL2ReverbReverbDelay] = preset.flReverbDelay / 0.1f;
m_param[kI3DL2ReverbDiffusion] = preset.flDiffusion / 100.0f;
m_param[kI3DL2ReverbDensity] = preset.flDensity / 100.0f;
m_param[kI3DL2ReverbHFReference] = (5000.0f - 20.0f) / 19980.0f;
RecalculateI3DL2ReverbParams();
}
#else
MPT_UNUSED_VARIABLE(program);
#endif
}
PlugParamValue I3DL2Reverb::GetParameter(PlugParamIndex index)
{
if(index < kI3DL2ReverbNumParameters)
{
return m_param[index];
}
return 0;
}
void I3DL2Reverb::SetParameter(PlugParamIndex index, PlugParamValue value)
{
if(index < kI3DL2ReverbNumParameters)
{
value = mpt::safe_clamp(value, 0.0f, 1.0f);
if(index == kI3DL2ReverbQuality)
value = mpt::round(value * 3.0f) / 3.0f;
m_param[index] = value;
m_recalcParams = true;
}
}
void I3DL2Reverb::Resume()
{
RecalculateI3DL2ReverbParams();
PositionChanged();
m_isResumed = true;
}
void I3DL2Reverb::PositionChanged()
{
MemsetZero(m_filterHist);
m_prevL = 0;
m_prevR = 0;
m_remain = false;
try
{
uint32 sampleRate = static_cast<uint32>(m_effectiveSampleRate);
m_delayLines[0].Init(67, 5, sampleRate, m_delayTaps[0]);
m_delayLines[1].Init(62, 5, sampleRate, m_delayTaps[1]);
m_delayLines[2].Init(53, 5, sampleRate, m_delayTaps[2]);
m_delayLines[3].Init(43, 5, sampleRate, m_delayTaps[3]);
m_delayLines[4].Init(32, 5, sampleRate, m_delayTaps[4]);
m_delayLines[5].Init(22, 5, sampleRate, m_delayTaps[5]);
m_delayLines[6].Init(75, 5, sampleRate, m_delayTaps[6]);
m_delayLines[7].Init(69, 5, sampleRate, m_delayTaps[7]);
m_delayLines[8].Init(60, 5, sampleRate, m_delayTaps[8]);
m_delayLines[9].Init(48, 5, sampleRate, m_delayTaps[9]);
m_delayLines[10].Init(36, 5, sampleRate, m_delayTaps[10]);
m_delayLines[11].Init(25, 5, sampleRate, m_delayTaps[11]);
m_delayLines[12].Init(0, 0, 0); // Dummy for array index consistency with both tap and coefficient arrays
m_delayLines[13].Init(3, 0, sampleRate, m_delayTaps[13]);
m_delayLines[14].Init(3, 0, sampleRate, m_delayTaps[14]);
m_delayLines[15].Init(407, 1, sampleRate);
m_delayLines[16].Init(400, 1, sampleRate);
m_delayLines[17].Init(10, 0, sampleRate, -1);
m_delayLines[18].Init(10, 0, sampleRate, -1);
m_ok = true;
} catch(mpt::out_of_memory e)
{
m_ok = false;
mpt::delete_out_of_memory(e);
}
}
#ifdef MODPLUG_TRACKER
CString I3DL2Reverb::GetParamName(PlugParamIndex param)
{
switch(param)
{
case kI3DL2ReverbRoom: return _T("Room");
case kI3DL2ReverbRoomHF: return _T("RoomHF");
case kI3DL2ReverbRoomRolloffFactor: return _T("RoomRolloffFactor");
case kI3DL2ReverbDecayTime: return _T("DecayTime");
case kI3DL2ReverbDecayHFRatio: return _T("DecayHFRatio");
case kI3DL2ReverbReflections: return _T("Reflections");
case kI3DL2ReverbReflectionsDelay: return _T("ReflectionsDelay");
case kI3DL2ReverbReverb: return _T("Reverb");
case kI3DL2ReverbReverbDelay: return _T("ReverbDelay");
case kI3DL2ReverbDiffusion: return _T("Diffusion");
case kI3DL2ReverbDensity: return _T("Density");
case kI3DL2ReverbHFReference: return _T("HFRefrence");
case kI3DL2ReverbQuality: return _T("Quality");
}
return CString();
}
CString I3DL2Reverb::GetParamLabel(PlugParamIndex param)
{
switch(param)
{
case kI3DL2ReverbRoom:
case kI3DL2ReverbRoomHF:
case kI3DL2ReverbReflections:
case kI3DL2ReverbReverb:
return _T("dB");
case kI3DL2ReverbDecayTime:
case kI3DL2ReverbReflectionsDelay:
case kI3DL2ReverbReverbDelay:
return _T("s");
case kI3DL2ReverbDiffusion:
case kI3DL2ReverbDensity:
return _T("%");
case kI3DL2ReverbHFReference:
return _T("Hz");
}
return CString();
}
CString I3DL2Reverb::GetParamDisplay(PlugParamIndex param)
{
static constexpr const TCHAR * const modes[] = { _T("LQ"), _T("LQ+"), _T("HQ"), _T("HQ+") };
float value = m_param[param];
switch(param)
{
case kI3DL2ReverbRoom: value = Room() * 0.01f; break;
case kI3DL2ReverbRoomHF: value = RoomHF() * 0.01f; break;
case kI3DL2ReverbRoomRolloffFactor: value = RoomRolloffFactor(); break;
case kI3DL2ReverbDecayTime: value = DecayTime(); break;
case kI3DL2ReverbDecayHFRatio: value = DecayHFRatio(); break;
case kI3DL2ReverbReflections: value = Reflections() * 0.01f; break;
case kI3DL2ReverbReflectionsDelay: value = ReflectionsDelay(); break;
case kI3DL2ReverbReverb: value = Reverb() * 0.01f; break;
case kI3DL2ReverbReverbDelay: value = ReverbDelay(); break;
case kI3DL2ReverbDiffusion: value = Diffusion(); break;
case kI3DL2ReverbDensity: value = Density(); break;
case kI3DL2ReverbHFReference: value = HFReference(); break;
case kI3DL2ReverbQuality: return modes[Quality() % 4u];
}
CString s;
s.Format(_T("%.2f"), value);
return s;
}
CString I3DL2Reverb::GetCurrentProgramName()
{
return GetProgramName(m_program);
}
CString I3DL2Reverb::GetProgramName(int32 program)
{
return mpt::ToCString(GetReverbPresetName(program));
}
#endif // MODPLUG_TRACKER
void I3DL2Reverb::RecalculateI3DL2ReverbParams()
{
m_quality = Quality();
m_effectiveSampleRate = static_cast<float>(m_SndFile.GetSampleRate() / ((m_quality & kFullSampleRate) ? 1u : 2u));
// Diffusion
m_diffusion = Diffusion() * (0.618034f / 100.0f);
// Early Reflection Level
m_ERLevel = std::min(std::pow(10.0f, (Room() + Reflections()) / (100.0f * 20.0f)), 1.0f) * 0.761f;
// Room Filter
float roomHF = std::pow(10.0f, RoomHF() / 100.0f / 10.0f);
if(roomHF == 1.0f)
{
m_roomFilter = 0.0f;
} else
{
float freq = std::cos(HFReference() * (2.0f * mpt::numbers::pi_v<float>) / m_effectiveSampleRate);
float roomFilter = (freq * (roomHF + roomHF) - 2.0f + std::sqrt(freq * (roomHF * roomHF * freq * 4.0f) + roomHF * 8.0f - roomHF * roomHF * 4.0f - roomHF * freq * 8.0f)) / (roomHF + roomHF - 2.0f);
m_roomFilter = Clamp(roomFilter, 0.0f, 1.0f);
}
SetDelayTaps();
SetDecayCoeffs();
m_recalcParams = false;
}
void I3DL2Reverb::SetDelayTaps()
{
// Early reflections
static constexpr float delays[] =
{
1.0000f, 1.0000f, 0.0000f, 0.1078f, 0.1768f, 0.2727f,
0.3953f, 0.5386f, 0.6899f, 0.8306f, 0.9400f, 0.9800f,
};
const float sampleRate = m_effectiveSampleRate;
const float reflectionsDelay = ReflectionsDelay();
const float reverbDelay = std::max(ReverbDelay(), 5.0f / 1000.0f);
m_earlyTaps[0][0] = static_cast<int32>((reverbDelay + reflectionsDelay + 7.0f / 1000.0f) * sampleRate);
for(uint32 i = 1; i < 12; i++)
{
m_earlyTaps[i % 2u][i / 2u] = static_cast<int32>((reverbDelay * delays[i] + reflectionsDelay) * sampleRate);
}
// Late reflections
float density = std::min((Density() / 100.0f + 0.1f) * 0.9091f, 1.0f);
float delayL = density * 67.0f / 1000.0f * sampleRate;
float delayR = density * 75.0f / 1000.0f * sampleRate;
for(int i = 0, power = 0; i < 6; i++)
{
power += i;
float factor = std::pow(0.93f, static_cast<float>(power));
m_delayTaps[i + 0] = static_cast<int32>(delayL * factor);
m_delayTaps[i + 6] = static_cast<int32>(delayR * factor);
}
m_delayTaps[12] = static_cast<int32>(10.0f / 1000.0f * sampleRate);
// Early reflections (extra delay lines)
m_delayTaps[13] = static_cast<int32>(3.25f / 1000.0f * sampleRate);
m_delayTaps[14] = static_cast<int32>(3.53f / 1000.0f * sampleRate);
for(std::size_t d = 0; d < std::size(m_delayTaps); d++)
m_delayLines[d].SetDelayTap(m_delayTaps[d]);
}
void I3DL2Reverb::SetDecayCoeffs()
{
float levelLtmp = 1.0f, levelRtmp = 1.0f;
float levelL = 0.0f, levelR = 0.0f;
levelLtmp *= CalcDecayCoeffs(5);
levelRtmp *= CalcDecayCoeffs(11);
levelL += levelLtmp * 0.0225f;
levelR += levelRtmp * 0.0225f;
levelLtmp *= CalcDecayCoeffs(4);
levelRtmp *= CalcDecayCoeffs(10);
levelL += levelLtmp * 0.04f;
levelR += levelRtmp * 0.04f;
if(m_quality & kMoreDelayLines)
{
levelLtmp *= CalcDecayCoeffs(3);
levelRtmp *= CalcDecayCoeffs(9);
levelL += levelLtmp * 0.1225f;
levelR += levelRtmp * 0.1225f;
levelLtmp *= CalcDecayCoeffs(2);
levelRtmp *= CalcDecayCoeffs(8);
levelL += levelLtmp * 0.1444f;
levelR += levelRtmp * 0.1444f;
}
CalcDecayCoeffs(12);
levelLtmp *= m_delayCoeffs[12][0] * m_delayCoeffs[12][0];
levelRtmp *= m_delayCoeffs[12][0] * m_delayCoeffs[12][0];
levelLtmp *= CalcDecayCoeffs(1);
levelRtmp *= CalcDecayCoeffs(7);
levelL += levelRtmp * 0.1444f;
levelR += levelLtmp * 0.1444f;
levelLtmp *= CalcDecayCoeffs(0);
levelRtmp *= CalcDecayCoeffs(6);
levelL += levelLtmp * 0.1444f;
levelR += levelRtmp * 0.1444f;
// Final Reverb Level
float level = std::min(std::pow(10.0f, (Room() + Reverb()) / (100.0f * 20.0f)), 1.0f);
float monoInv = 1.0f - ((levelLtmp + levelRtmp) * 0.5f);
m_ReverbLevelL = level * std::sqrt(monoInv / levelL);
m_ReverbLevelR = level * std::sqrt(monoInv / levelR);
}
float I3DL2Reverb::CalcDecayCoeffs(int32 index)
{
float hfRef = (2.0f * mpt::numbers::pi_v<float>) / m_effectiveSampleRate * HFReference();
float decayHFRatio = DecayHFRatio();
if(decayHFRatio > 1.0f)
hfRef = mpt::numbers::pi_v<float>;
float c1 = std::pow(10.0f, ((m_delayTaps[index] / m_effectiveSampleRate) * -60.0f / DecayTime()) / 20.0f);
float c2 = 0.0f;
float c21 = (std::pow(c1, 2.0f - 2.0f / decayHFRatio) - 1.0f) / (1.0f - std::cos(hfRef));
if(c21 != 0 && std::isfinite(c21))
{
float c22 = -2.0f * c21 - 2.0f;
float c23sq = c22 * c22 - c21 * c21 * 4.0f;
float c23 = c23sq > 0.0f ? std::sqrt(c23sq) : 0.0f;
c2 = (c23 - c22) / (c21 + c21);
if(std::abs(c2) > 1.0f)
c2 = (-c22 - c23) / (c21 + c21);
c2 = mpt::sanitize_nan(c2);
}
m_delayCoeffs[index][0] = c1;
m_delayCoeffs[index][1] = c2;
c1 *= c1;
float diff2 = m_diffusion * m_diffusion;
return diff2 + c1 / (1.0f - diff2 * c1) * (1.0f - diff2) * (1.0f - diff2);
}
} // namespace DMO
#else
MPT_MSVC_WORKAROUND_LNK4221(I3DL2Reverb)
#endif // !NO_PLUGINS
OPENMPT_NAMESPACE_END
Reference in a new issue View git blame Copy permalink