ViPERFX_RE/src/cpp/viper/ViPER.cpp

#include "ViPER.h"
#include <ctime>
#include "constants.h"

ViPER::ViPER() {
    VIPER_LOGI("Welcome to ViPER FX");
    VIPER_LOGI("Current version is %s %s", VERSION_STRING, VERSION_CODENAME);

    this->adaptiveBuffer = new AdaptiveBuffer(2, 4096);
    this->waveBuffer = new WaveBuffer(2, 4096);

    this->convolver = new Convolver();
    this->convolver->SetEnable(false);
    this->convolver->SetSamplingRate(this->samplingRate);
    this->convolver->Reset();

    this->vhe = new VHE();
    this->vhe->SetEnable(false);
    this->vhe->SetSamplingRate(this->samplingRate);
    this->vhe->Reset();

    this->viperDdc = new ViPERDDC();
    this->viperDdc->SetEnable(false);
    this->viperDdc->SetSamplingRate(this->samplingRate);
    this->viperDdc->Reset();

    this->spectrumExtend = new SpectrumExtend();
    this->spectrumExtend->SetEnable(false);
    this->spectrumExtend->SetSamplingRate(this->samplingRate);
    this->spectrumExtend->SetReferenceFrequency(7600);
    this->spectrumExtend->SetExciter(0);
    this->spectrumExtend->Reset();

    this->iirFilter = new IIRFilter(10);
    this->iirFilter->SetEnable(false);
    this->iirFilter->SetSamplingRate(this->samplingRate);
    this->iirFilter->Reset();

    this->colorfulMusic = new ColorfulMusic();
    this->colorfulMusic->SetEnable(false);
    this->colorfulMusic->SetSamplingRate(this->samplingRate);
    this->colorfulMusic->Reset();

    this->reverberation = new Reverberation();
    this->reverberation->SetEnable(false);
    this->reverberation->SetSamplingRate(this->samplingRate);
    this->reverberation->Reset();

    this->playbackGain = new PlaybackGain();
    this->playbackGain->SetEnable(false);
    this->playbackGain->SetSamplingRate(this->samplingRate);
    this->playbackGain->Reset();

    this->fetCompressor = new FETCompressor();
    this->fetCompressor->SetParameter(0, 0.0);
    this->fetCompressor->SetSamplingRate(this->samplingRate);
    this->fetCompressor->Reset();

    this->dynamicSystem = new DynamicSystem();
    this->dynamicSystem->SetEnable(false);
    this->dynamicSystem->SetSamplingRate(this->samplingRate);
    this->dynamicSystem->Reset();

    this->viperBass = new ViPERBass();
    this->viperBass->SetSamplingRate(this->samplingRate);
    this->viperBass->Reset();

    this->viperClarity = new ViPERClarity();
    this->viperClarity->SetSamplingRate(this->samplingRate);
    this->viperClarity->Reset();

    this->diffSurround = new DiffSurround();
    this->diffSurround->SetEnable(false);
    this->diffSurround->SetSamplingRate(this->samplingRate);
    this->diffSurround->Reset();

    this->cure = new Cure();
    this->cure->SetEnable(false);
    this->cure->SetSamplingRate(this->samplingRate);
    this->cure->Reset();

    this->tubeSimulator = new TubeSimulator();
    this->tubeSimulator->enabled = false; //SetEnable(false);
    this->tubeSimulator->Reset();

    this->analogX = new AnalogX();
//    this->analogX->SetEnable(false);
    this->analogX->SetSamplingRate(this->samplingRate);
    this->analogX->SetProcessingModel(0);
    this->analogX->Reset();

    this->speakerCorrection = new SpeakerCorrection();
    this->speakerCorrection->SetEnable(false);
    this->speakerCorrection->SetSamplingRate(this->samplingRate);
    this->speakerCorrection->Reset();

    for (auto &softwareLimiter: this->softwareLimiters) {
        softwareLimiter = new SoftwareLimiter();
        softwareLimiter->ResetLimiter();
    }

    this->fetcomp_enabled = false;
    this->init_ok = true;
    this->frame_scale = 1.0;
    this->left_pan = 1.0;
    this->process_time_ms = 0;
    this->right_pan = 1.0;
    this->enabled = false;
    this->force_enabled = false;
    this->update_status = false;
}

ViPER::~ViPER() {
    delete this->adaptiveBuffer;
    delete this->waveBuffer;
    delete this->convolver;
    delete this->vhe;
    delete this->viperDdc;
    delete this->spectrumExtend;
    delete this->iirFilter;
    delete this->colorfulMusic;
    delete this->reverberation;
    delete this->playbackGain;
    delete this->fetCompressor;
    delete this->dynamicSystem;
    delete this->viperBass;
    delete this->viperClarity;
    delete this->diffSurround;
    delete this->cure;
    delete this->tubeSimulator;
    delete this->analogX;
    delete this->speakerCorrection;
    for (auto &softwareLimiter: this->softwareLimiters) {
        delete softwareLimiter;
    }
}

// TODO: Return int
void ViPER::processBuffer(float *buffer, uint32_t size) {
    if (!this->enabled) return;
    if (size == 0) return;
    if (!this->init_ok) return;

    if (this->update_status) {
        struct timeval time{};
        gettimeofday(&time, nullptr);
        this->process_time_ms = time.tv_sec * 1000 + time.tv_usec / 1000;
    }

    uint32_t ret;

    // if convolver is enabled
    ret = this->waveBuffer->PushSamples(buffer, size);
    if (ret == 0) {
        this->waveBuffer->Reset();
        return;
    }

    auto pWaveBuffer = this->waveBuffer->GetBuffer();
    this->convolver->Process(pWaveBuffer, pWaveBuffer, size);
    this->vhe->Process(pWaveBuffer, pWaveBuffer, size);
    this->waveBuffer->SetBufferOffset(size);

    ret = this->adaptiveBuffer->PushZero(size);
    if (ret == 0) {
        this->waveBuffer->Reset();
        this->adaptiveBuffer->FlushBuffer();
        return;
    }

    auto pAdaptiveBuffer = this->adaptiveBuffer->GetBufferPointer();
    ret = this->waveBuffer->PopSamples((float *) pAdaptiveBuffer, size, true);
    this->adaptiveBuffer->SetBufferOffset(ret);

    pAdaptiveBuffer = this->adaptiveBuffer->GetBufferPointer();
    if (ret != 0) {
        this->viperDdc->Process(pAdaptiveBuffer, size);
        this->spectrumExtend->Process(pAdaptiveBuffer, size);
        this->iirFilter->Process(pAdaptiveBuffer, ret);
        this->colorfulMusic->Process(pAdaptiveBuffer, ret);
        this->diffSurround->Process(pAdaptiveBuffer, ret);
        this->reverberation->Process(pAdaptiveBuffer, ret);
        this->speakerCorrection->Process(pAdaptiveBuffer, ret);
        this->playbackGain->Process(pAdaptiveBuffer, ret);
        this->fetCompressor->Process(pAdaptiveBuffer, ret);
        this->dynamicSystem->Process(pAdaptiveBuffer, ret);
        this->viperBass->Process(pAdaptiveBuffer, ret);
        this->viperClarity->Process(pAdaptiveBuffer, ret);
        this->cure->Process(pAdaptiveBuffer, ret);
        this->tubeSimulator->TubeProcess(pAdaptiveBuffer, size);
        this->analogX->Process(pAdaptiveBuffer, ret);
    }

    if (this->frame_scale != 1.0) {
        this->adaptiveBuffer->ScaleFrames(this->frame_scale);
    }
    if (this->left_pan < 1.0 || this->right_pan < 1.0) {
        this->adaptiveBuffer->PanFrames(this->left_pan, this->right_pan);
    }

    if (ret << 1 != 0) {

    }

}

void ViPER::DispatchCommand(int param, int val1, int val2, int val3, int val4, uint32_t arrSize,
                            signed char *arr) {
    switch (param) {
        case PARAM_SET_UNKNOWN: {
            break;
        }
        case PARAM_SET_UPDATE_STATUS: {
            break;
        }
        case PARAM_SET_RESET_STATUS: {
            break;
        }
        case PARAM_SET_DOPROCESS_STATUS: {
            break;
        }
        case PARAM_SET_FORCEENABLE_STATUS: {
            break;
        }
        case PARAM_SET_SELFDIAGNOSE_STATUS: {
            break;
        }
        case PARAM_FX_TYPE_SWITCH: {
            // Unused
            // TODO: Remove
            break;
        } // 0x10001
        case PARAM_HPFX_CONV_PROCESS_ENABLED: {
            break;
        } // 0x10002
        case PARAM_HPFX_CONV_UPDATEKERNEL: {
            break;
        } // 0x10003
        case PARAM_HPFX_CONV_PREPAREBUFFER: {
            this->convolver->PrepareKernelBuffer(val1, val2, val3);
            break;
        } // 0x10004
        case PARAM_HPFX_CONV_SETBUFFER: {
            break;
        } // 0x10005
        case PARAM_HPFX_CONV_COMMITBUFFER: {
            this->convolver->CommitKernelBuffer(val1, val2, val3);
            break;
        } // 0x10006
        case PARAM_HPFX_CONV_CROSSCHANNEL: {
            break;
        } // 0x10007
        case PARAM_HPFX_VHE_PROCESS_ENABLED: {
            this->vhe->SetEnable(val1 != 0);
            break;
        } // 0x10008
        case PARAM_HPFX_VHE_EFFECT_LEVEL: {
            this->vhe->SetEffectLevel(val1);
            break;
        } // 0x10009
        case PARAM_HPFX_VDDC_PROCESS_ENABLED: {
            this->viperDdc->SetEnable(val1 != 0);
            break;
        } // 0x1000A
        case PARAM_HPFX_VDDC_COEFFS: {
            // TODO: Finish
            //this->viperDdc->SetCoeffs();
            break;
        } // 0x1000B
        case PARAM_HPFX_VSE_PROCESS_ENABLED: {
            this->spectrumExtend->SetEnable(val1 != 0);
            break;
        } // 0x1000C
        case PARAM_HPFX_VSE_REFERENCE_BARK: {
            this->spectrumExtend->SetReferenceFrequency(val1);
            break;
        } // 0x1000D
        case PARAM_HPFX_VSE_BARK_RECONSTRUCT: {
            this->spectrumExtend->SetExciter((float) val1 / 100.0f);
            break;
        } // 0x1000E
        case PARAM_HPFX_FIREQ_PROCESS_ENABLED: {
            this->iirFilter->SetEnable(val1 != 0);
            break;
        } // 0x1000F
        case PARAM_HPFX_FIREQ_BANDLEVEL: {
            this->iirFilter->SetBandLevel(val1, (float) val2 / 100.0f);
            break;
        } // 0x10010
        case PARAM_HPFX_COLM_PROCESS_ENABLED: {
            this->colorfulMusic->SetEnable(val1 != 0);
            break;
        } // 0x10011
        case PARAM_HPFX_COLM_WIDENING: {
            this->colorfulMusic->SetWidenValue((float) val1 / 100.0f);
            break;
        } // 0x10012
        case PARAM_HPFX_COLM_MIDIMAGE: {
            this->colorfulMusic->SetMidImageValue((float) val1 / 100.0f);
            break;
        } // 0x10013
        case PARAM_HPFX_COLM_DEPTH: {
            this->colorfulMusic->SetDepthValue((short) val1);
            break;
        } // 0x10014
        case PARAM_HPFX_DIFFSURR_PROCESS_ENABLED: {
            break;
        } // 0x10015
        case PARAM_HPFX_DIFFSURR_DELAYTIME: {
            this->diffSurround->SetDelayTime((float) val1 / 100.0f);
            break;
        } // 0x10016
        case PARAM_HPFX_REVB_PROCESS_ENABLED: {
            break;
        } // 0x10017
        case PARAM_HPFX_REVB_ROOMSIZE: {
            break;
        } // 0x10018
        case PARAM_HPFX_REVB_WIDTH: {
            this->reverberation->SetWidth((float) val1 / 100.0f);
            break;
        } // 0x10019
        case PARAM_HPFX_REVB_DAMP: {
            break;
        } // 0x1001A
        case PARAM_HPFX_REVB_WET: {
            break;
        } // 0x1001B
        case PARAM_HPFX_REVB_DRY: {
            break;
        } // 0x1001C
        case PARAM_HPFX_AGC_PROCESS_ENABLED: {
            this->playbackGain->SetEnable(val1 != 0);
            break;
        } // 0x1001D
        case PARAM_HPFX_AGC_RATIO: {
            this->playbackGain->SetRatio((float) val1 / 100.0f);
            break;
        } // 0x1001E
        case PARAM_HPFX_AGC_VOLUME: {
            this->playbackGain->SetVolume((float) val1 / 100.0f);
            break;
        } // 0x1001F
        case PARAM_HPFX_AGC_MAXSCALER: {
            this->playbackGain->SetMaxGainFactor((float) val1 / 100.0f);
            break;
        } // 0x10020
        case PARAM_HPFX_DYNSYS_PROCESS_ENABLED: {
            this->dynamicSystem->SetEnable(val1 != 0);
            break;
        } // 0x10021
        case PARAM_HPFX_DYNSYS_XCOEFFS: {
            this->dynamicSystem->SetXCoeffs(val1, val2);
            break;
        } // 0x10022
        case PARAM_HPFX_DYNSYS_YCOEFFS: {
            this->dynamicSystem->SetYCoeffs(val1, val2);
            break;
        } // 0x10023
        case PARAM_HPFX_DYNSYS_SIDEGAIN: {
            this->dynamicSystem->SetSideGain((float) val1 / 100.0f, (float) val2 / 100.0f);
            break;
        } // 0x10024
        case PARAM_HPFX_DYNSYS_BASSGAIN: {
            this->dynamicSystem->SetBassGain((float) val1 / 100.0f);
            break;
        } // 0x10025
        case PARAM_HPFX_VIPERBASS_PROCESS_ENABLED: {
//            this->viperBass->SetEnable(val1 != 0);
            break;
        } // 0x10026
        case PARAM_HPFX_VIPERBASS_MODE: {
            this->viperBass->SetProcessMode(static_cast<ViPERBass::ProcessMode>(val1));
            break;
        } // 0x10027
        case PARAM_HPFX_VIPERBASS_SPEAKER: {
            this->viperBass->SetSpeaker(val1);
            break;
        } // 0x10028
        case PARAM_HPFX_VIPERBASS_BASSGAIN: {
            this->viperBass->SetBassFactor((float) val1 / 100.0f);
            break;
        } // 0x10029
        case PARAM_HPFX_VIPERCLARITY_PROCESS_ENABLED: {
            //this->viperClarity->SetEnable(val1 != 0);
            break;
        } // 0x1002A
        case PARAM_HPFX_VIPERCLARITY_MODE: {
            this->viperClarity->SetProcessMode(static_cast<ViPERClarity::ClarityMode>(val1));
            break;
        } // 0x1002B
        case PARAM_HPFX_VIPERCLARITY_CLARITY: {
            this->viperClarity->SetClarity((float) val1 / 100.0f);
            break;
        } // 0x1002C
        case PARAM_HPFX_CURE_PROCESS_ENABLED: {
            this->cure->SetEnable(val1 != 0);
            break;
        } // 0x1002D
        case PARAM_HPFX_CURE_CROSSFEED: {
            switch (val1) {
                case 0:
                    // Cure_R::SetPreset(pCVar17,0x5f028a);
                    break;
                case 1:
                    // Cure_R::SetPreset(pCVar17,0x3c02bc);
                    break;
                case 2:
                    // Cure_R::SetPreset(pCVar17,0x2d02bc);
                    break;
            }
            break;
        } // 0x1002E
        case PARAM_HPFX_TUBE_PROCESS_ENABLED: {
            // TODO: Enable
            break;
        } // 0x1002F
        case PARAM_HPFX_ANALOGX_PROCESS_ENABLED: {
            // TODO: Enable
            break;
        } // 0x10030
        case PARAM_HPFX_ANALOGX_MODE: {
            this->analogX->SetProcessingModel(val1);
            break;
        } // 0x10031
        case PARAM_HPFX_OUTPUT_VOLUME: {

            break;
        } // 0x10032
        case PARAM_HPFX_OUTPUT_PAN: {
            float tmp = (float) val1 / 100.0f;
            if (tmp < 0.0f) {
                this->left_pan = 1.0f;
                this->right_pan = 1.0f + tmp;
            } else {
                this->left_pan = 1.0f - tmp;
                this->right_pan = 1.0f;
            }
            break;
        } // 0x10033
        case PARAM_HPFX_LIMITER_THRESHOLD: {
            this->softwareLimiters[0]->SetGate((float) val1 / 100.0f);
            this->softwareLimiters[1]->SetGate((float) val1 / 100.0f);
            break;
        } // 0x10034
        case PARAM_SPKFX_CONV_PROCESS_ENABLED: {
            break;
        } // 0x10035
        case PARAM_SPKFX_CONV_UPDATEKERNEL: {
            break;
        } // 0x10036
        case PARAM_SPKFX_CONV_PREPAREBUFFER: {
            break;
        } // 0x10037
        case PARAM_SPKFX_CONV_SETBUFFER: {
            break;
        } // 0x10038
        case PARAM_SPKFX_CONV_COMMITBUFFER: {
            break;
        } // 0x10039
        case PARAM_SPKFX_CONV_CROSSCHANNEL: {
            this->convolver->SetCrossChannel((float) val1 / 100.0f);
            break;
        } // 0x1003A
        case PARAM_SPKFX_FIREQ_PROCESS_ENABLED: {
            break;
        } // 0x1003B
        case PARAM_SPKFX_FIREQ_BANDLEVEL: {
            break;
        } // 0x1003C
        case PARAM_SPKFX_REVB_PROCESS_ENABLED: {
            this->reverberation->SetEnable(val1 != 0);
            break;
        } // 0x1003D
        case PARAM_SPKFX_REVB_ROOMSIZE: {
            this->reverberation->SetRoomSize((float) val1 / 100.0f);
            break;
        } // 0x1003E
        case PARAM_SPKFX_REVB_WIDTH: {
            break;
        } // 0x1003F
        case PARAM_SPKFX_REVB_DAMP: {
            this->reverberation->SetDamp((float) val1 / 100.0f);
            break;
        } // 0x10040
        case PARAM_SPKFX_REVB_WET: {
            this->reverberation->SetWet((float) val1 / 100.0f);
            break;
        } // 0x10041
        case PARAM_SPKFX_REVB_DRY: {
            this->reverberation->SetDry((float) val1 / 100.0f);
            break;
        } // 0x10042
        case PARAM_SPKFX_AGC_PROCESS_ENABLED: {
            this->speakerCorrection->SetEnable(val1 != 0);
            break;
        } // 0x10043
        case PARAM_SPKFX_AGC_RATIO: {
            break;
        } // 0x10044
        case PARAM_SPKFX_AGC_VOLUME: {
            this->playbackGain->SetVolume((float) val1 / 100.0f);
            break;
        } // 0x10045
        case PARAM_SPKFX_AGC_MAXSCALER: {
            this->playbackGain->SetMaxGainFactor((float) val1 / 100.0f);
            break;
        } // 0x10046
        case PARAM_SPKFX_OUTPUT_VOLUME: {
            this->frame_scale = (float) val1 / 100.0f;
            break;
        } // 0x10047
        case PARAM_SPKFX_LIMITER_THRESHOLD: {
            this->frame_scale = (float) val1 / 100.0f;
            break;
        } // 0x10048
        case PARAM_HPFX_FETCOMP_PROCESS_ENABLED: {
            break;
        } // 0x10049
        case PARAM_HPFX_FETCOMP_THRESHOLD: {
            break;
        } // 0x1004A
        case PARAM_HPFX_FETCOMP_RATIO: {
            this->fetCompressor->SetParameter(1, (float) val1 / 100.0f);
            break;
        } // 0x1004B
        case PARAM_HPFX_FETCOMP_KNEEWIDTH: {
            break;
        } // 0x1004C
        case PARAM_HPFX_FETCOMP_AUTOKNEE_ENABLED: {
            break;
        } // 0x1004D
        case PARAM_HPFX_FETCOMP_GAIN: {
            break;
        } // 0x1004E
        case PARAM_HPFX_FETCOMP_AUTOGAIN_ENABLED: {
            this->fetCompressor->SetParameter(5, (float) val1 / 100.0f);
            break;
        } // 0x1004F
        case PARAM_HPFX_FETCOMP_ATTACK: {
            break;
        } // 0x10050
        case PARAM_HPFX_FETCOMP_AUTOATTACK_ENABLED: {
            break;
        } // 0x10051
        case PARAM_HPFX_FETCOMP_RELEASE: {
            break;
        } // 0x10052
        case PARAM_HPFX_FETCOMP_AUTORELEASE_ENABLED: {
            break;
        } // 0x10053
        case PARAM_HPFX_FETCOMP_META_KNEEMULTI: {
            break;
        } // 0x10054
        case PARAM_HPFX_FETCOMP_META_MAXATTACK: {
            break;
        } // 0x10055
        case PARAM_HPFX_FETCOMP_META_MAXRELEASE: {
            this->fetCompressor->SetParameter(12, (float) val1 / 100.0f);
            break;
        } // 0x10056
        case PARAM_HPFX_FETCOMP_META_CREST: {
            break;
        } // 0x10057
        case PARAM_HPFX_FETCOMP_META_ADAPT: {
            break;
        } // 0x10058
        case PARAM_HPFX_FETCOMP_META_NOCLIP_ENABLED: {
            this->fetCompressor->SetParameter(15, (float) val1 / 100.0f);
            break;
        } // 0x10059
        case PARAM_SPKFX_FETCOMP_PROCESS_ENABLED: {
            break;
        } // 0x1005A
        case PARAM_SPKFX_FETCOMP_THRESHOLD: {

            break;
        } // 0x1005B
        case PARAM_SPKFX_FETCOMP_RATIO: {
            break;
        } // 0x1005C
        case PARAM_SPKFX_FETCOMP_KNEEWIDTH: {
            this->fetCompressor->SetParameter(2, (float) val1 / 100.0f);
            break;
        } // 0x1005D
        case PARAM_SPKFX_FETCOMP_AUTOKNEE_ENABLED: {
            break;
        } // 0x1005E
        case PARAM_SPKFX_FETCOMP_GAIN: {
            break;
        } // 0x1005F
        case PARAM_SPKFX_FETCOMP_AUTOGAIN_ENABLED: {
            break;
        } // 0x10060
        case PARAM_SPKFX_FETCOMP_ATTACK: {
            break;
        } // 0x10061
        case PARAM_SPKFX_FETCOMP_AUTOATTACK_ENABLED: {
            break;
        } // 0x10062
        case PARAM_SPKFX_FETCOMP_RELEASE: {
            break;
        } // 0x10063
        case PARAM_SPKFX_FETCOMP_AUTORELEASE_ENABLED: {
            break;
        } // 0x10064
        case PARAM_SPKFX_FETCOMP_META_KNEEMULTI: {
            break;
        } // 0x10065
        case PARAM_SPKFX_FETCOMP_META_MAXATTACK: {
            break;
        } // 0x10066
        case PARAM_SPKFX_FETCOMP_META_MAXRELEASE: {
            break;
        } // 0x10067
        case PARAM_SPKFX_FETCOMP_META_CREST: {
            break;
        } // 0x10068
        case PARAM_SPKFX_FETCOMP_META_ADAPT: {
            break;
        } // 0x10069
        case PARAM_SPKFX_FETCOMP_META_NOCLIP_ENABLED: {
            break;
        } // 0x1006A
    }
}

void ViPER::ResetAllEffects() {
    if (this->adaptiveBuffer != nullptr) {
        this->adaptiveBuffer->FlushBuffer();
    }
    if (this->waveBuffer != nullptr) {
        this->waveBuffer->Reset();
    }
    if (this->convolver != nullptr) {
        this->convolver->SetSamplingRate(this->samplingRate);
        this->convolver->Reset();
    }
    if (this->vhe != nullptr) {
        this->vhe->SetSamplingRate(this->samplingRate);
        this->vhe->Reset();
    }
    if (this->viperDdc != nullptr) {
        this->viperDdc->SetSamplingRate(this->samplingRate);
        this->viperDdc->Reset();
    }
    if (this->spectrumExtend != nullptr) {
        this->spectrumExtend->SetSamplingRate(this->samplingRate);
        this->spectrumExtend->Reset();
    }
    if (this->iirFilter != nullptr) {
        this->iirFilter->SetSamplingRate(this->samplingRate);
        this->iirFilter->Reset();
    }
    if (this->colorfulMusic != nullptr) {
        this->colorfulMusic->SetSamplingRate(this->samplingRate);
        this->colorfulMusic->Reset();
    }
    if (this->reverberation != nullptr) {
        this->reverberation->SetSamplingRate(this->samplingRate);
        this->reverberation->Reset();
    }
    if (this->playbackGain != nullptr) {
        this->playbackGain->SetSamplingRate(this->samplingRate);
        this->playbackGain->Reset();
    }
    if (this->fetCompressor != nullptr) {
        this->fetCompressor->SetSamplingRate(this->samplingRate);
        this->fetCompressor->Reset();
    }
    if (this->dynamicSystem != nullptr) {
        this->dynamicSystem->SetSamplingRate(this->samplingRate);
        this->dynamicSystem->Reset();
    }
    if (this->viperBass != nullptr) {
        this->viperBass->SetSamplingRate(this->samplingRate);
        this->viperBass->Reset();
    }
    if (this->viperClarity != nullptr) {
        this->viperClarity->SetSamplingRate(this->samplingRate);
        this->viperClarity->Reset();
    }
    if (this->diffSurround != nullptr) {
        this->diffSurround->SetSamplingRate(this->samplingRate);
        this->diffSurround->Reset();
    }
    if (this->cure != nullptr) {
        this->cure->SetSamplingRate(this->samplingRate);
        this->cure->Reset();
    }
    if (this->tubeSimulator != nullptr) {
        this->tubeSimulator->Reset();
    }
    if (this->analogX != nullptr) {
        this->analogX->SetSamplingRate(this->samplingRate);
        this->analogX->Reset();
    }
    if (this->speakerCorrection != nullptr) {
        this->speakerCorrection->SetSamplingRate(this->samplingRate);
        this->speakerCorrection->Reset();
    }
    for (auto &softwareLimiter: softwareLimiters) {
        if (softwareLimiter != nullptr) {
            softwareLimiter->ResetLimiter();
        }
    }
}