mirror of
https://github.com/AndroidAudioMods/ViPERFX_RE.git
synced 2025-06-08 02:29:40 +08:00
554 lines
18 KiB
C++
554 lines
18 KiB
C++
#include "ViPER.h"
|
|
#include <cstring>
|
|
#include <chrono>
|
|
#include "constants.h"
|
|
|
|
ViPER::ViPER() :
|
|
updateProcessTime(false),
|
|
processTimeMs(0),
|
|
samplingRate(VIPER_DEFAULT_SAMPLING_RATE),
|
|
adaptiveBuffer(AdaptiveBuffer(2, 4096)),
|
|
waveBuffer(WaveBuffer(2, 4096)),
|
|
iirFilter(IIRFilter(10)) {
|
|
VIPER_LOGI("Welcome to ViPER FX");
|
|
VIPER_LOGI("Current version is %s (%d)", VERSION_NAME, VERSION_CODE);
|
|
|
|
this->convolver.SetEnable(false);
|
|
this->convolver.SetSamplingRate(this->samplingRate);
|
|
this->convolver.Reset();
|
|
|
|
this->vhe.SetEnable(false);
|
|
this->vhe.SetSamplingRate(this->samplingRate);
|
|
this->vhe.Reset();
|
|
|
|
this->viperDdc.SetEnable(false);
|
|
this->viperDdc.SetSamplingRate(this->samplingRate);
|
|
this->viperDdc.Reset();
|
|
|
|
this->spectrumExtend.SetEnable(false);
|
|
this->spectrumExtend.SetSamplingRate(this->samplingRate);
|
|
this->spectrumExtend.SetReferenceFrequency(7600);
|
|
this->spectrumExtend.SetExciter(0);
|
|
this->spectrumExtend.Reset();
|
|
|
|
this->iirFilter.SetEnable(false);
|
|
this->iirFilter.SetSamplingRate(this->samplingRate);
|
|
this->iirFilter.Reset();
|
|
|
|
this->colorfulMusic.SetEnable(false);
|
|
this->colorfulMusic.SetSamplingRate(this->samplingRate);
|
|
this->colorfulMusic.Reset();
|
|
|
|
this->reverberation.SetEnable(false);
|
|
this->reverberation.Reset();
|
|
|
|
this->playbackGain.SetEnable(false);
|
|
this->playbackGain.SetSamplingRate(this->samplingRate);
|
|
this->playbackGain.Reset();
|
|
|
|
this->fetCompressor.SetParameter(FETCompressor::ENABLE, 0.0);
|
|
this->fetCompressor.SetSamplingRate(this->samplingRate);
|
|
this->fetCompressor.Reset();
|
|
|
|
this->dynamicSystem.SetEnable(false);
|
|
this->dynamicSystem.SetSamplingRate(this->samplingRate);
|
|
this->dynamicSystem.Reset();
|
|
|
|
this->viperBass.SetSamplingRate(this->samplingRate);
|
|
this->viperBass.Reset();
|
|
|
|
this->viperClarity.SetSamplingRate(this->samplingRate);
|
|
this->viperClarity.Reset();
|
|
|
|
this->diffSurround.SetEnable(false);
|
|
this->diffSurround.SetSamplingRate(this->samplingRate);
|
|
this->diffSurround.Reset();
|
|
|
|
this->cure.SetEnable(false);
|
|
this->cure.SetSamplingRate(this->samplingRate);
|
|
this->cure.Reset();
|
|
|
|
this->tubeSimulator.SetEnable(false);
|
|
this->tubeSimulator.Reset();
|
|
|
|
this->analogX.SetEnable(false);
|
|
this->analogX.SetSamplingRate(this->samplingRate);
|
|
this->analogX.SetProcessingModel(0);
|
|
this->analogX.Reset();
|
|
|
|
this->speakerCorrection.SetEnable(false);
|
|
this->speakerCorrection.SetSamplingRate(this->samplingRate);
|
|
this->speakerCorrection.Reset();
|
|
|
|
for (auto &softwareLimiter: this->softwareLimiters) {
|
|
softwareLimiter.Reset();
|
|
}
|
|
|
|
this->frameScale = 1.0;
|
|
this->leftPan = 1.0;
|
|
this->rightPan = 1.0;
|
|
this->updateProcessTime = false;
|
|
this->processTimeMs = 0;
|
|
}
|
|
|
|
void ViPER::process(std::vector<float>& buffer, uint32_t size) {
|
|
if (this->updateProcessTime) {
|
|
auto now = std::chrono::system_clock::now();
|
|
auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
|
|
this->processTimeMs = now_ms.time_since_epoch().count();
|
|
}
|
|
|
|
uint32_t ret;
|
|
float *tmpBuf;
|
|
uint32_t tmpBufSize;
|
|
|
|
if (this->convolver.GetEnabled() || this->vhe.GetEnabled()) {
|
|
// VIPER_LOGD("Convolver or VHE is enable, use wave buffer");
|
|
|
|
if (!this->waveBuffer.PushSamples(buffer.data(), size)) {
|
|
this->waveBuffer.Reset();
|
|
return;
|
|
}
|
|
|
|
float *ptr = this->waveBuffer.GetBuffer();
|
|
ret = this->convolver.Process(ptr, ptr, size);
|
|
ret = this->vhe.Process(ptr, ptr, ret);
|
|
this->waveBuffer.SetBufferOffset(ret);
|
|
|
|
if (!this->adaptiveBuffer.PushZero(ret)) {
|
|
this->waveBuffer.Reset();
|
|
this->adaptiveBuffer.FlushBuffer();
|
|
return;
|
|
}
|
|
|
|
ptr = this->adaptiveBuffer.GetBuffer();
|
|
ret = this->waveBuffer.PopSamples(ptr, ret, true);
|
|
this->adaptiveBuffer.SetBufferOffset(ret);
|
|
|
|
tmpBuf = ptr;
|
|
tmpBufSize = ret;
|
|
} else {
|
|
// VIPER_LOGD("Convolver and VHE are disabled, use adaptive buffer");
|
|
|
|
if (this->adaptiveBuffer.PushFrames(buffer.data(), size)) {
|
|
this->adaptiveBuffer.SetBufferOffset(size);
|
|
|
|
tmpBuf = this->adaptiveBuffer.GetBuffer();
|
|
tmpBufSize = size;
|
|
} else {
|
|
this->adaptiveBuffer.FlushBuffer();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// VIPER_LOGD("Process buffer size: %d", tmpBufSize);
|
|
if (tmpBufSize != 0) {
|
|
this->viperDdc.Process(tmpBuf, size);
|
|
this->spectrumExtend.Process(tmpBuf, size);
|
|
this->iirFilter.Process(tmpBuf, tmpBufSize);
|
|
this->colorfulMusic.Process(tmpBuf, tmpBufSize);
|
|
this->diffSurround.Process(tmpBuf, tmpBufSize);
|
|
this->reverberation.Process(tmpBuf, tmpBufSize);
|
|
this->speakerCorrection.Process(tmpBuf, tmpBufSize);
|
|
this->playbackGain.Process(tmpBuf, tmpBufSize);
|
|
this->fetCompressor.Process(tmpBuf, tmpBufSize); // TODO: enable check
|
|
this->dynamicSystem.Process(tmpBuf, tmpBufSize);
|
|
this->viperBass.Process(tmpBuf, tmpBufSize);
|
|
this->viperClarity.Process(tmpBuf, tmpBufSize);
|
|
this->cure.Process(tmpBuf, tmpBufSize);
|
|
this->tubeSimulator.TubeProcess(tmpBuf, size);
|
|
this->analogX.Process(tmpBuf, tmpBufSize);
|
|
|
|
if (this->frameScale != 1.0) {
|
|
this->adaptiveBuffer.ScaleFrames(this->frameScale);
|
|
}
|
|
|
|
if (this->leftPan < 1.0 || this->rightPan < 1.0) {
|
|
this->adaptiveBuffer.PanFrames(this->leftPan, this->rightPan);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < tmpBufSize * 2; i += 2) {
|
|
tmpBuf[i] = this->softwareLimiters[0].Process(tmpBuf[i]);
|
|
tmpBuf[i + 1] = this->softwareLimiters[1].Process(tmpBuf[i + 1]);
|
|
}
|
|
|
|
if (!this->adaptiveBuffer.PopFrames(buffer.data(), tmpBufSize)) {
|
|
this->adaptiveBuffer.FlushBuffer();
|
|
return;
|
|
}
|
|
|
|
if (size <= tmpBufSize) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
memmove(buffer.data() + (size - tmpBufSize) * 2, buffer.data(), tmpBufSize * sizeof(float));
|
|
memset(buffer.data(), 0, (size - tmpBufSize) * sizeof(float));
|
|
}
|
|
|
|
void ViPER::DispatchCommand(int param, int val1, int val2, int val3, int val4, uint32_t arrSize,
|
|
signed char *arr) {
|
|
VIPER_LOGD("Dispatch command: %d, %d, %d, %d, %d, %d, %p", param, val1, val2, val3, val4, arrSize, arr);
|
|
switch (param) {
|
|
case PARAM_SET_UPDATE_STATUS: {
|
|
this->updateProcessTime = val1 != 0;
|
|
break;
|
|
}
|
|
case PARAM_SET_RESET_STATUS: {
|
|
this->resetAllEffects();
|
|
break;
|
|
}
|
|
case PARAM_CONVOLUTION_ENABLE: {
|
|
// this->convolver.SetEnabled(val1 != 0);
|
|
break;
|
|
} // 0x10002
|
|
case PARAM_CONVOLUTION_PREPARE_BUFFER: {
|
|
break;
|
|
} // 0x10004
|
|
case PARAM_CONVOLUTION_SET_BUFFER: {
|
|
break;
|
|
} // 0x10005
|
|
case PARAM_CONVOLUTION_COMMIT_BUFFER: {
|
|
break;
|
|
} // 0x10006
|
|
case PARAM_CONVOLUTION_CROSS_CHANNEL: {
|
|
this->convolver.SetCrossChannel((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10007
|
|
case PARAM_HEADPHONE_SURROUND_ENABLE: {
|
|
this->vhe.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10008
|
|
case PARAM_HEADPHONE_SURROUND_STRENGTH: {
|
|
this->vhe.SetEffectLevel(val1);
|
|
break;
|
|
} // 0x10009
|
|
case PARAM_DDC_ENABLE: {
|
|
this->viperDdc.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x1000A
|
|
case PARAM_DDC_COEFFICIENTS: {
|
|
this->viperDdc.SetCoeffs(arrSize, (float *) arr, (float *) (arr + arrSize * sizeof(float)));
|
|
break;
|
|
} // 0x1000B
|
|
case PARAM_SPECTRUM_EXTENSION_ENABLE: {
|
|
this->spectrumExtend.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x1000C
|
|
case PARAM_SPECTRUM_EXTENSION_BARK: {
|
|
this->spectrumExtend.SetReferenceFrequency(val1);
|
|
break;
|
|
} // 0x1000D
|
|
case PARAM_SPECTRUM_EXTENSION_BARK_RECONSTRUCT: {
|
|
this->spectrumExtend.SetExciter((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1000E
|
|
case PARAM_FIR_EQUALIZER_ENABLE: {
|
|
this->iirFilter.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x1000F
|
|
case PARAM_FIR_EQUALIZER_BAND_LEVEL: {
|
|
this->iirFilter.SetBandLevel((uint32_t) val1, (float) val2 / 100.0f);
|
|
break;
|
|
} // 0x10010
|
|
case PARAM_FIELD_SURROUND_ENABLE: {
|
|
this->colorfulMusic.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10011
|
|
case PARAM_FIELD_SURROUND_WIDENING: {
|
|
this->colorfulMusic.SetWidenValue((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10012
|
|
case PARAM_FIELD_SURROUND_MID_IMAGE: {
|
|
this->colorfulMusic.SetMidImageValue((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10013
|
|
case PARAM_FIELD_SURROUND_DEPTH: {
|
|
this->colorfulMusic.SetDepthValue((short) val1);
|
|
break;
|
|
} // 0x10014
|
|
case PARAM_DIFFERENTIAL_SURROUND_ENABLE: {
|
|
this->diffSurround.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10015
|
|
case PARAM_DIFFERENTIAL_SURROUND_DELAY: {
|
|
this->diffSurround.SetDelayTime((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10016
|
|
case PARAM_REVERBERATION_ENABLE: {
|
|
this->reverberation.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10017
|
|
case PARAM_REVERBERATION_ROOM_SIZE: {
|
|
this->reverberation.SetRoomSize((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10018
|
|
case PARAM_REVERBERATION_ROOM_WIDTH: {
|
|
this->reverberation.SetWidth((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10019
|
|
case PARAM_REVERBERATION_ROOM_DAMPENING: {
|
|
this->reverberation.SetDamp((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1001A
|
|
case PARAM_REVERBERATION_ROOM_WET_SIGNAL: {
|
|
this->reverberation.SetWet((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1001B
|
|
case PARAM_REVERBERATION_ROOM_DRY_SIGNAL: {
|
|
this->reverberation.SetDry((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1001C
|
|
case PARAM_AUTOMATIC_GAIN_CONTROL_ENABLE: {
|
|
this->playbackGain.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x1001D
|
|
case PARAM_AUTOMATIC_GAIN_CONTROL_RATIO: {
|
|
this->playbackGain.SetRatio((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1001E
|
|
case PARAM_AUTOMATIC_GAIN_CONTROL_VOLUME: {
|
|
this->playbackGain.SetVolume((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1001F
|
|
case PARAM_AUTOMATIC_GAIN_CONTROL_MAX_SCALER: {
|
|
this->playbackGain.SetMaxGainFactor((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10020
|
|
case PARAM_DYNAMIC_SYSTEM_ENABLE: {
|
|
this->dynamicSystem.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10021
|
|
case PARAM_DYNAMIC_SYSTEM_X_COEFFICIENTS: {
|
|
this->dynamicSystem.SetXCoeffs(val1, val2);
|
|
break;
|
|
} // 0x10022
|
|
case PARAM_DYNAMIC_SYSTEM_Y_COEFFICIENTS: {
|
|
this->dynamicSystem.SetYCoeffs(val1, val2);
|
|
break;
|
|
} // 0x10023
|
|
case PARAM_DYNAMIC_SYSTEM_SIDE_GAIN: {
|
|
this->dynamicSystem.SetSideGain((float) val1 / 100.0f, (float) val2 / 100.0f);
|
|
break;
|
|
} // 0x10024
|
|
case PARAM_DYNAMIC_SYSTEM_STRENGTH: {
|
|
this->dynamicSystem.SetBassGain((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10025
|
|
case PARAM_FIDELITY_BASS_ENABLE: {
|
|
this->viperBass.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10026
|
|
case PARAM_FIDELITY_BASS_MODE: {
|
|
this->viperBass.SetProcessMode((ViPERBass::ProcessMode) val1);
|
|
break;
|
|
} // 0x10027
|
|
case PARAM_FIDELITY_BASS_FREQUENCY: {
|
|
this->viperBass.SetSpeaker((uint32_t) val1);
|
|
break;
|
|
} // 0x10028
|
|
case PARAM_FIDELITY_BASS_GAIN: {
|
|
this->viperBass.SetBassFactor((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10029
|
|
case PARAM_FIDELITY_CLARITY_ENABLE: {
|
|
this->viperClarity.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x1002A
|
|
case PARAM_FIDELITY_CLARITY_MODE: {
|
|
this->viperClarity.SetProcessMode((ViPERClarity::ClarityMode) val1);
|
|
break;
|
|
} // 0x1002B
|
|
case PARAM_FIDELITY_CLARITY_GAIN: {
|
|
this->viperClarity.SetClarity((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1002C
|
|
case PARAM_CURE_CROSS_FEED_ENABLED: {
|
|
this->cure.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x1002D
|
|
case PARAM_CURE_CROSS_FEED_STRENGTH: {
|
|
switch (val1) {
|
|
case 0: {
|
|
// Cure_R::SetPreset(pCVar17,0x5f028a);
|
|
struct Crossfeed::Preset preset = {
|
|
.cutoff = 650,
|
|
.feedback = 95,
|
|
};
|
|
this->cure.SetPreset(preset);
|
|
break;
|
|
}
|
|
case 1: {
|
|
// Cure_R::SetPreset(pCVar17,0x3c02bc);
|
|
struct Crossfeed::Preset preset = {
|
|
.cutoff = 700,
|
|
.feedback = 60,
|
|
};
|
|
this->cure.SetPreset(preset);
|
|
break;
|
|
}
|
|
case 2: {
|
|
// Cure_R::SetPreset(pCVar17,0x2d02bc);
|
|
struct Crossfeed::Preset preset = {
|
|
.cutoff = 700,
|
|
.feedback = 45,
|
|
};
|
|
this->cure.SetPreset(preset);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
} // 0x1002E
|
|
case PARAM_TUBE_SIMULATOR_ENABLED: {
|
|
this->tubeSimulator.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x1002F
|
|
case PARAM_ANALOGX_ENABLE: {
|
|
this->analogX.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10030
|
|
case PARAM_ANALOGX_MODE: {
|
|
this->analogX.SetProcessingModel(val1);
|
|
break;
|
|
} // 0x10031
|
|
case PARAM_GATE_OUTPUT_VOLUME: {
|
|
this->frameScale = (float) val1 / 100.0f;
|
|
break;
|
|
} // 0x10032
|
|
case PARAM_GATE_CHANNEL_PAN: {
|
|
float tmp = (float) val1 / 100.0f;
|
|
if (tmp < 0.0f) {
|
|
this->leftPan = 1.0f;
|
|
this->rightPan = 1.0f + tmp;
|
|
} else {
|
|
this->leftPan = 1.0f - tmp;
|
|
this->rightPan = 1.0f;
|
|
}
|
|
break;
|
|
} // 0x10033
|
|
case PARAM_GATE_LIMIT: {
|
|
this->softwareLimiters[0].SetGate((float) val1 / 100.0f);
|
|
this->softwareLimiters[1].SetGate((float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10034
|
|
case PARAM_SPEAKER_OPTIMIZATION: {
|
|
this->speakerCorrection.SetEnable(val1 != 0);
|
|
break;
|
|
} // 0x10043
|
|
case PARAM_FET_COMPRESSOR_ENABLE: {
|
|
break;
|
|
} // 0x10049
|
|
case PARAM_FET_COMPRESSOR_THRESHOLD: {
|
|
break;
|
|
} // 0x1004A
|
|
case PARAM_FET_COMPRESSOR_RATIO: {
|
|
this->fetCompressor.SetParameter(FETCompressor::THRESHOLD, (float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1004B
|
|
case PARAM_FET_COMPRESSOR_KNEE: {
|
|
break;
|
|
} // 0x1004C
|
|
case PARAM_FET_COMPRESSOR_AUTO_KNEE: {
|
|
break;
|
|
} // 0x1004D
|
|
case PARAM_FET_COMPRESSOR_GAIN: {
|
|
break;
|
|
} // 0x1004E
|
|
case PARAM_FET_COMPRESSOR_AUTO_GAIN: {
|
|
this->fetCompressor.SetParameter(FETCompressor::GAIN, (float) val1 / 100.0f);
|
|
break;
|
|
} // 0x1004F
|
|
case PARAM_FET_COMPRESSOR_ATTACK: {
|
|
break;
|
|
} // 0x10050
|
|
case PARAM_FET_COMPRESSOR_AUTO_ATTACK: {
|
|
break;
|
|
} // 0x10051
|
|
case PARAM_FET_COMPRESSOR_RELEASE: {
|
|
break;
|
|
} // 0x10052
|
|
case PARAM_FET_COMPRESSOR_AUTO_RELEASE: {
|
|
break;
|
|
} // 0x10053
|
|
case PARAM_FET_COMPRESSOR_KNEE_MULTI: {
|
|
break;
|
|
} // 0x10054
|
|
case PARAM_FET_COMPRESSOR_MAX_ATTACK: {
|
|
break;
|
|
} // 0x10055
|
|
case PARAM_FET_COMPRESSOR_MAX_RELEASE: {
|
|
this->fetCompressor.SetParameter(FETCompressor::MAX_ATTACK, (float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10056
|
|
case PARAM_FET_COMPRESSOR_CREST: {
|
|
break;
|
|
} // 0x10057
|
|
case PARAM_FET_COMPRESSOR_ADAPT: {
|
|
break;
|
|
} // 0x10058
|
|
case PARAM_FET_COMPRESSOR_NO_CLIP: {
|
|
this->fetCompressor.SetParameter(FETCompressor::ADAPT, (float) val1 / 100.0f);
|
|
break;
|
|
} // 0x10059
|
|
}
|
|
}
|
|
|
|
void ViPER::resetAllEffects() {
|
|
this->adaptiveBuffer.FlushBuffer();
|
|
|
|
this->waveBuffer.Reset();
|
|
|
|
this->convolver.SetSamplingRate(this->samplingRate);
|
|
this->convolver.Reset();
|
|
|
|
this->vhe.SetSamplingRate(this->samplingRate);
|
|
this->vhe.Reset();
|
|
|
|
this->viperDdc.SetSamplingRate(this->samplingRate);
|
|
this->viperDdc.Reset();
|
|
|
|
this->spectrumExtend.SetSamplingRate(this->samplingRate);
|
|
this->spectrumExtend.Reset();
|
|
|
|
this->iirFilter.SetSamplingRate(this->samplingRate);
|
|
this->iirFilter.Reset();
|
|
|
|
this->colorfulMusic.SetSamplingRate(this->samplingRate);
|
|
this->colorfulMusic.Reset();
|
|
|
|
this->reverberation.Reset();
|
|
|
|
this->playbackGain.SetSamplingRate(this->samplingRate);
|
|
this->playbackGain.Reset();
|
|
|
|
this->fetCompressor.SetSamplingRate(this->samplingRate);
|
|
this->fetCompressor.Reset();
|
|
|
|
this->dynamicSystem.SetSamplingRate(this->samplingRate);
|
|
this->dynamicSystem.Reset();
|
|
|
|
this->viperBass.SetSamplingRate(this->samplingRate);
|
|
this->viperBass.Reset();
|
|
|
|
this->viperClarity.SetSamplingRate(this->samplingRate);
|
|
this->viperClarity.Reset();
|
|
|
|
this->diffSurround.SetSamplingRate(this->samplingRate);
|
|
this->diffSurround.Reset();
|
|
|
|
this->cure.SetSamplingRate(this->samplingRate);
|
|
this->cure.Reset();
|
|
|
|
this->tubeSimulator.Reset();
|
|
|
|
this->analogX.SetSamplingRate(this->samplingRate);
|
|
this->analogX.Reset();
|
|
|
|
this->speakerCorrection.SetSamplingRate(this->samplingRate);
|
|
this->speakerCorrection.Reset();
|
|
|
|
for (auto &softwareLimiter: softwareLimiters) {
|
|
softwareLimiter.Reset();
|
|
}
|
|
}
|