NeuralAmpModelerPlugin

Plugin for Neural Amp Modeler
Log | Files | Refs | Submodules | README | LICENSE

commit b6f4c52224b10b7a73a3e39ecc08fd48de4b423b
parent 604930b1b5e3314dd061bba1d84a6aabd23733bf
Author: Oli Larkin <olilarkin@googlemail.com>
Date:   Sat,  1 Jul 2023 02:41:03 +0200

Cleanup naming of methods and variables (#268)

* Rename GetNAM()/GetIR() -> StageModel()/StageIR()

* Rename mNAM -> mModel

* Rename mStagedNAM -> mStagedModel

* Rename mFlagRemoveNAM -> mShouldRemoveModel

* Rename mFlagRemoveIR -> mShouldRemoveIR

* Rename mNewNAMLoadedInDSP -> mNewModelLoadedInDSP

* Remove unnecessary CTOR initializers

* mNUM_INTERNAL_CHANNELS -> kNumChannelsInternal

* Remove unnessecary use of this->
Diffstat:
MNeuralAmpModeler/NeuralAmpModeler.cpp | 307+++++++++++++++++++++++++++++++++++++------------------------------------------
MNeuralAmpModeler/NeuralAmpModeler.h | 34+++++++++++++++++-----------------
2 files changed, 162 insertions(+), 179 deletions(-)

diff --git a/NeuralAmpModeler/NeuralAmpModeler.cpp b/NeuralAmpModeler/NeuralAmpModeler.cpp @@ -51,36 +51,20 @@ const IVStyle style = NeuralAmpModeler::NeuralAmpModeler(const InstanceInfo& info) : Plugin(info, MakeConfig(kNumParams, kNumPresets)) -, mInputPointers(nullptr) -, mOutputPointers(nullptr) -, mNoiseGateTrigger() -, mNAM(nullptr) -, mIR(nullptr) -, mStagedNAM(nullptr) -, mStagedIR(nullptr) -, mFlagRemoveNAM(false) -, mFlagRemoveIR(false) -, mToneBass() -, mToneMid() -, mToneTreble() -, mNAMPath() -, mIRPath() -, mInputSender() -, mOutputSender() { activations::Activation::enable_fast_tanh(); - this->GetParam(kInputLevel)->InitGain("Input", 0.0, -20.0, 20.0, 0.1); - this->GetParam(kToneBass)->InitDouble("Bass", 5.0, 0.0, 10.0, 0.1); - this->GetParam(kToneMid)->InitDouble("Middle", 5.0, 0.0, 10.0, 0.1); - this->GetParam(kToneTreble)->InitDouble("Treble", 5.0, 0.0, 10.0, 0.1); - this->GetParam(kOutputLevel)->InitGain("Output", 0.0, -40.0, 40.0, 0.1); - this->GetParam(kNoiseGateThreshold)->InitGain("Gate", -80.0, -100.0, 0.0, 0.1); - this->GetParam(kNoiseGateActive)->InitBool("NoiseGateActive", true); - this->GetParam(kEQActive)->InitBool("ToneStack", true); - this->GetParam(kOutNorm)->InitBool("OutNorm", false); - this->GetParam(kIRToggle)->InitBool("IRToggle", true); - - this->mNoiseGateTrigger.AddListener(&this->mNoiseGateGain); + GetParam(kInputLevel)->InitGain("Input", 0.0, -20.0, 20.0, 0.1); + GetParam(kToneBass)->InitDouble("Bass", 5.0, 0.0, 10.0, 0.1); + GetParam(kToneMid)->InitDouble("Middle", 5.0, 0.0, 10.0, 0.1); + GetParam(kToneTreble)->InitDouble("Treble", 5.0, 0.0, 10.0, 0.1); + GetParam(kOutputLevel)->InitGain("Output", 0.0, -40.0, 40.0, 0.1); + GetParam(kNoiseGateThreshold)->InitGain("Gate", -80.0, -100.0, 0.0, 0.1); + GetParam(kNoiseGateActive)->InitBool("NoiseGateActive", true); + GetParam(kEQActive)->InitBool("ToneStack", true); + GetParam(kOutNorm)->InitBool("OutNorm", false); + GetParam(kIRToggle)->InitBool("IRToggle", true); + + mNoiseGateTrigger.AddListener(&mNoiseGateGain); mMakeGraphicsFunc = [&]() { @@ -189,7 +173,7 @@ NeuralAmpModeler::NeuralAmpModeler(const InstanceInfo& info) if (fileName.GetLength()) { // Sets mNAMPath and mStagedNAM - const std::string msg = this->_GetNAM(fileName); + const std::string msg = _StageModel(fileName); // TODO error messages like the IR loader. if (msg.size()) { @@ -210,8 +194,8 @@ NeuralAmpModeler::NeuralAmpModeler(const InstanceInfo& info) auto loadIRCompletionHandler = [&](const WDL_String& fileName, const WDL_String& path) { if (fileName.GetLength()) { - this->mIRPath = fileName; - const dsp::wav::LoadReturnCode retCode = this->_GetIR(fileName); + mIRPath = fileName; + const dsp::wav::LoadReturnCode retCode = _StageIR(fileName); if (retCode != dsp::wav::LoadReturnCode::SUCCESS) { std::stringstream message; @@ -356,63 +340,63 @@ NeuralAmpModeler::NeuralAmpModeler(const InstanceInfo& info) NeuralAmpModeler::~NeuralAmpModeler() { - this->_DeallocateIOPointers(); + _DeallocateIOPointers(); } void NeuralAmpModeler::ProcessBlock(iplug::sample** inputs, iplug::sample** outputs, int nFrames) { - const size_t numChannelsExternalIn = (size_t)this->NInChansConnected(); - const size_t numChannelsExternalOut = (size_t)this->NOutChansConnected(); - const size_t numChannelsInternal = this->mNUM_INTERNAL_CHANNELS; + const size_t numChannelsExternalIn = (size_t)NInChansConnected(); + const size_t numChannelsExternalOut = (size_t)NOutChansConnected(); + const size_t numChannelsInternal = kNumChannelsInternal; const size_t numFrames = (size_t)nFrames; - const double sampleRate = this->GetSampleRate(); + const double sampleRate = GetSampleRate(); // Disable floating point denormals std::fenv_t fe_state; std::feholdexcept(&fe_state); disable_denormals(); - this->_PrepareBuffers(numChannelsInternal, numFrames); + _PrepareBuffers(numChannelsInternal, numFrames); // Input is collapsed to mono in preparation for the NAM. - this->_ProcessInput(inputs, numFrames, numChannelsExternalIn, numChannelsInternal); - this->_ApplyDSPStaging(); - const bool noiseGateActive = this->GetParam(kNoiseGateActive)->Value(); - const bool toneStackActive = this->GetParam(kEQActive)->Value(); + _ProcessInput(inputs, numFrames, numChannelsExternalIn, numChannelsInternal); + _ApplyDSPStaging(); + const bool noiseGateActive = GetParam(kNoiseGateActive)->Value(); + const bool toneStackActive = GetParam(kEQActive)->Value(); // Noise gate trigger sample** triggerOutput = mInputPointers; if (noiseGateActive) { const double time = 0.01; - const double threshold = this->GetParam(kNoiseGateThreshold)->Value(); // GetParam... + const double threshold = GetParam(kNoiseGateThreshold)->Value(); // GetParam... const double ratio = 0.1; // Quadratic... const double openTime = 0.005; const double holdTime = 0.01; const double closeTime = 0.05; const dsp::noise_gate::TriggerParams triggerParams(time, threshold, ratio, openTime, holdTime, closeTime); - this->mNoiseGateTrigger.SetParams(triggerParams); - this->mNoiseGateTrigger.SetSampleRate(sampleRate); - triggerOutput = this->mNoiseGateTrigger.Process(mInputPointers, numChannelsInternal, numFrames); + mNoiseGateTrigger.SetParams(triggerParams); + mNoiseGateTrigger.SetSampleRate(sampleRate); + triggerOutput = mNoiseGateTrigger.Process(mInputPointers, numChannelsInternal, numFrames); } - if (mNAM != nullptr) + if (mModel != nullptr) { - mNAM->SetNormalize(this->GetParam(kOutNorm)->Value()); + mModel->SetNormalize(GetParam(kOutNorm)->Value()); // TODO remove input / output gains from here. const double inputGain = 1.0; const double outputGain = 1.0; const int nChans = (int)numChannelsInternal; - mNAM->process(triggerOutput, this->mOutputPointers, nChans, nFrames, inputGain, outputGain, mNAMParams); - mNAM->finalize_(nFrames); + mModel->process(triggerOutput, mOutputPointers, nChans, nFrames, inputGain, outputGain, mNAMParams); + mModel->finalize_(nFrames); } else { - this->_FallbackDSP(triggerOutput, this->mOutputPointers, numChannelsInternal, numFrames); + _FallbackDSP(triggerOutput, mOutputPointers, numChannelsInternal, numFrames); } // Apply the noise gate sample** gateGainOutput = noiseGateActive - ? this->mNoiseGateGain.Process(this->mOutputPointers, numChannelsInternal, numFrames) - : this->mOutputPointers; + ? mNoiseGateGain.Process(mOutputPointers, numChannelsInternal, numFrames) + : mOutputPointers; sample** toneStackOutPointers = gateGainOutput; if (toneStackActive) @@ -420,9 +404,9 @@ void NeuralAmpModeler::ProcessBlock(iplug::sample** inputs, iplug::sample** outp // Translate params from knob 0-10 to dB. // Tuned ranges based on my ear. E.g. seems treble doesn't need nearly as // much swing as bass can use. - const double bassGainDB = 4.0 * (this->GetParam(kToneBass)->Value() - 5.0); // +/- 20 - const double midGainDB = 3.0 * (this->GetParam(kToneMid)->Value() - 5.0); // +/- 15 - const double trebleGainDB = 2.0 * (this->GetParam(kToneTreble)->Value() - 5.0); // +/- 10 + const double bassGainDB = 4.0 * (GetParam(kToneBass)->Value() - 5.0); // +/- 20 + const double midGainDB = 3.0 * (GetParam(kToneMid)->Value() - 5.0); // +/- 15 + const double trebleGainDB = 2.0 * (GetParam(kToneTreble)->Value() - 5.0); // +/- 10 const double bassFrequency = 150.0; const double midFrequency = 425.0; @@ -438,48 +422,48 @@ void NeuralAmpModeler::ProcessBlock(iplug::sample** inputs, iplug::sample** outp recursive_linear_filter::BiquadParams trebleParams(sampleRate, trebleFrequency, trebleQuality, trebleGainDB); // Apply tone stack // Set parameters - this->mToneBass.SetParams(bassParams); - this->mToneMid.SetParams(midParams); - this->mToneTreble.SetParams(trebleParams); - sample** bassPointers = this->mToneBass.Process(gateGainOutput, numChannelsInternal, numFrames); - sample** midPointers = this->mToneMid.Process(bassPointers, numChannelsInternal, numFrames); - sample** treblePointers = this->mToneTreble.Process(midPointers, numChannelsInternal, numFrames); + mToneBass.SetParams(bassParams); + mToneMid.SetParams(midParams); + mToneTreble.SetParams(trebleParams); + sample** bassPointers = mToneBass.Process(gateGainOutput, numChannelsInternal, numFrames); + sample** midPointers = mToneMid.Process(bassPointers, numChannelsInternal, numFrames); + sample** treblePointers = mToneTreble.Process(midPointers, numChannelsInternal, numFrames); toneStackOutPointers = treblePointers; } sample** irPointers = toneStackOutPointers; - if (this->mIR != nullptr && this->GetParam(kIRToggle)->Value()) - irPointers = this->mIR->Process(toneStackOutPointers, numChannelsInternal, numFrames); + if (mIR != nullptr && GetParam(kIRToggle)->Value()) + irPointers = mIR->Process(toneStackOutPointers, numChannelsInternal, numFrames); // restore previous floating point state std::feupdateenv(&fe_state); // Let's get outta here // This is where we exit mono for whatever the output requires. - this->_ProcessOutput(irPointers, outputs, numFrames, numChannelsInternal, numChannelsExternalOut); + _ProcessOutput(irPointers, outputs, numFrames, numChannelsInternal, numChannelsExternalOut); // * Output of input leveling (inputs -> mInputPointers), // * Output of output leveling (mOutputPointers -> outputs) - this->_UpdateMeters(this->mInputPointers, outputs, numFrames, numChannelsInternal, numChannelsExternalOut); + _UpdateMeters(mInputPointers, outputs, numFrames, numChannelsInternal, numChannelsExternalOut); } void NeuralAmpModeler::OnReset() { - const auto sampleRate = this->GetSampleRate(); - this->mInputSender.Reset(sampleRate); - this->mOutputSender.Reset(sampleRate); + const auto sampleRate = GetSampleRate(); + mInputSender.Reset(sampleRate); + mOutputSender.Reset(sampleRate); } void NeuralAmpModeler::OnIdle() { - this->mInputSender.TransmitData(*this); - this->mOutputSender.TransmitData(*this); + mInputSender.TransmitData(*this); + mOutputSender.TransmitData(*this); - if (this->mNewNAMLoadedInDSP) + if (mNewModelLoadedInDSP) { if (auto* pGraphics = GetUI()) - pGraphics->GetControlWithTag(kCtrlTagOutNorm)->SetDisabled(!this->mNAM->HasLoudness()); + pGraphics->GetControlWithTag(kCtrlTagOutNorm)->SetDisabled(!mModel->HasLoudness()); - this->mNewNAMLoadedInDSP = false; + mNewModelLoadedInDSP = false; } } @@ -487,21 +471,21 @@ bool NeuralAmpModeler::SerializeState(IByteChunk& chunk) const { // Model directory (don't serialize the model itself; we'll just load it again // when we unserialize) - chunk.PutStr(this->mNAMPath.Get()); - chunk.PutStr(this->mIRPath.Get()); + chunk.PutStr(mNAMPath.Get()); + chunk.PutStr(mIRPath.Get()); return SerializeParams(chunk); } int NeuralAmpModeler::UnserializeState(const IByteChunk& chunk, int startPos) { WDL_String dir; - startPos = chunk.GetStr(this->mNAMPath, startPos); - startPos = chunk.GetStr(this->mIRPath, startPos); + startPos = chunk.GetStr(mNAMPath, startPos); + startPos = chunk.GetStr(mIRPath, startPos); int retcode = UnserializeParams(chunk, startPos); - if (this->mNAMPath.GetLength()) - this->_GetNAM(this->mNAMPath); - if (this->mIRPath.GetLength()) - this->_GetIR(this->mIRPath); + if (mNAMPath.GetLength()) + _StageModel(mNAMPath); + if (mIRPath.GetLength()) + _StageIR(mIRPath); return retcode; } @@ -509,13 +493,13 @@ void NeuralAmpModeler::OnUIOpen() { Plugin::OnUIOpen(); - if (this->mNAMPath.GetLength()) + if (mNAMPath.GetLength()) SendControlMsgFromDelegate( - kCtrlTagModelFileBrowser, kMsgTagLoadedModel, this->mNAMPath.GetLength(), this->mNAMPath.Get()); - if (this->mIRPath.GetLength()) - SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadedIR, this->mIRPath.GetLength(), this->mIRPath.Get()); - if (this->mNAM != nullptr) - this->GetUI()->GetControlWithTag(kCtrlTagOutNorm)->SetDisabled(!this->mNAM->HasLoudness()); + kCtrlTagModelFileBrowser, kMsgTagLoadedModel, mNAMPath.GetLength(), mNAMPath.Get()); + if (mIRPath.GetLength()) + SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadedIR, mIRPath.GetLength(), mIRPath.Get()); + if (mModel != nullptr) + GetUI()->GetControlWithTag(kCtrlTagOutNorm)->SetDisabled(!mModel->HasLoudness()); } void NeuralAmpModeler::OnParamChangeUI(int paramIdx, EParamSource source) @@ -540,8 +524,8 @@ bool NeuralAmpModeler::OnMessage(int msgTag, int ctrlTag, int dataSize, const vo { switch (msgTag) { - case kMsgTagClearModel: mFlagRemoveNAM = true; return true; - case kMsgTagClearIR: mFlagRemoveIR = true; return true; + case kMsgTagClearModel: mShouldRemoveModel = true; return true; + case kMsgTagClearIR: mShouldRemoveIR = true; return true; default: return false; } } @@ -550,63 +534,63 @@ bool NeuralAmpModeler::OnMessage(int msgTag, int ctrlTag, int dataSize, const vo void NeuralAmpModeler::_AllocateIOPointers(const size_t nChans) { - if (this->mInputPointers != nullptr) + if (mInputPointers != nullptr) throw std::runtime_error("Tried to re-allocate mInputPointers without freeing"); - this->mInputPointers = new sample*[nChans]; - if (this->mInputPointers == nullptr) + mInputPointers = new sample*[nChans]; + if (mInputPointers == nullptr) throw std::runtime_error("Failed to allocate pointer to input buffer!\n"); - if (this->mOutputPointers != nullptr) + if (mOutputPointers != nullptr) throw std::runtime_error("Tried to re-allocate mOutputPointers without freeing"); - this->mOutputPointers = new sample*[nChans]; - if (this->mOutputPointers == nullptr) + mOutputPointers = new sample*[nChans]; + if (mOutputPointers == nullptr) throw std::runtime_error("Failed to allocate pointer to output buffer!\n"); } void NeuralAmpModeler::_ApplyDSPStaging() { // Move things from staged to live - if (this->mStagedNAM != nullptr) + if (mStagedModel != nullptr) { // Move from staged to active DSP - this->mNAM = std::move(this->mStagedNAM); - this->mStagedNAM = nullptr; - this->mNewNAMLoadedInDSP = true; + mModel = std::move(mStagedModel); + mStagedModel = nullptr; + mNewModelLoadedInDSP = true; } - if (this->mStagedIR != nullptr) + if (mStagedIR != nullptr) { - this->mIR = std::move(this->mStagedIR); - this->mStagedIR = nullptr; + mIR = std::move(mStagedIR); + mStagedIR = nullptr; } // Remove marked modules - if (this->mFlagRemoveNAM) + if (mShouldRemoveModel) { - this->mNAM = nullptr; - this->mNAMPath.Set(""); - this->mFlagRemoveNAM = false; + mModel = nullptr; + mNAMPath.Set(""); + mShouldRemoveModel = false; } - if (this->mFlagRemoveIR) + if (mShouldRemoveIR) { - this->mIR = nullptr; - this->mIRPath.Set(""); - this->mFlagRemoveIR = false; + mIR = nullptr; + mIRPath.Set(""); + mShouldRemoveIR = false; } } void NeuralAmpModeler::_DeallocateIOPointers() { - if (this->mInputPointers != nullptr) + if (mInputPointers != nullptr) { - delete[] this->mInputPointers; - this->mInputPointers = nullptr; + delete[] mInputPointers; + mInputPointers = nullptr; } - if (this->mInputPointers != nullptr) + if (mInputPointers != nullptr) throw std::runtime_error("Failed to deallocate pointer to input buffer!\n"); - if (this->mOutputPointers != nullptr) + if (mOutputPointers != nullptr) { - delete[] this->mOutputPointers; - this->mOutputPointers = nullptr; + delete[] mOutputPointers; + mOutputPointers = nullptr; } - if (this->mOutputPointers != nullptr) + if (mOutputPointers != nullptr) throw std::runtime_error("Failed to deallocate pointer to output buffer!\n"); } @@ -615,29 +599,29 @@ void NeuralAmpModeler::_FallbackDSP(iplug::sample** inputs, iplug::sample** outp { for (auto c = 0; c < numChannels; c++) for (auto s = 0; s < numFrames; s++) - this->mOutputArray[c][s] = this->mInputArray[c][s]; + mOutputArray[c][s] = mInputArray[c][s]; } -std::string NeuralAmpModeler::_GetNAM(const WDL_String& modelPath) +std::string NeuralAmpModeler::_StageModel(const WDL_String& modelPath) { - WDL_String previousNAMPath = this->mNAMPath; + WDL_String previousNAMPath = mNAMPath; try { auto dspPath = std::filesystem::u8path(modelPath.Get()); - mStagedNAM = get_dsp(dspPath); - this->mNAMPath = modelPath; + mStagedModel = get_dsp(dspPath); + mNAMPath = modelPath; SendControlMsgFromDelegate( - kCtrlTagModelFileBrowser, kMsgTagLoadedModel, this->mNAMPath.GetLength(), this->mNAMPath.Get()); + kCtrlTagModelFileBrowser, kMsgTagLoadedModel, mNAMPath.GetLength(), mNAMPath.Get()); } catch (std::exception& e) { SendControlMsgFromDelegate(kCtrlTagModelFileBrowser, kMsgTagLoadFailed); - if (this->mStagedNAM != nullptr) + if (mStagedModel != nullptr) { - this->mStagedNAM = nullptr; + mStagedModel = nullptr; } - this->mNAMPath = previousNAMPath; + mNAMPath = previousNAMPath; std::cerr << "Failed to read DSP module" << std::endl; std::cerr << e.what() << std::endl; return e.what(); @@ -645,18 +629,18 @@ std::string NeuralAmpModeler::_GetNAM(const WDL_String& modelPath) return ""; } -dsp::wav::LoadReturnCode NeuralAmpModeler::_GetIR(const WDL_String& irPath) +dsp::wav::LoadReturnCode NeuralAmpModeler::_StageIR(const WDL_String& irPath) { // FIXME it'd be better for the path to be "staged" as well. Just in case the // path and the model got caught on opposite sides of the fence... - WDL_String previousIRPath = this->mIRPath; - const double sampleRate = this->GetSampleRate(); + WDL_String previousIRPath = mIRPath; + const double sampleRate = GetSampleRate(); dsp::wav::LoadReturnCode wavState = dsp::wav::LoadReturnCode::ERROR_OTHER; try { auto irPathU8 = std::filesystem::u8path(irPath.Get()); - this->mStagedIR = std::make_unique<dsp::ImpulseResponse>(irPathU8.string().c_str(), sampleRate); - wavState = this->mStagedIR->GetWavState(); + mStagedIR = std::make_unique<dsp::ImpulseResponse>(irPathU8.string().c_str(), sampleRate); + wavState = mStagedIR->GetWavState(); } catch (std::exception& e) { @@ -667,16 +651,16 @@ dsp::wav::LoadReturnCode NeuralAmpModeler::_GetIR(const WDL_String& irPath) if (wavState == dsp::wav::LoadReturnCode::SUCCESS) { - this->mIRPath = irPath; - SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadedIR, this->mIRPath.GetLength(), this->mIRPath.Get()); + mIRPath = irPath; + SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadedIR, mIRPath.GetLength(), mIRPath.Get()); } else { - if (this->mStagedIR != nullptr) + if (mStagedIR != nullptr) { - this->mStagedIR = nullptr; + mStagedIR = nullptr; } - this->mIRPath = previousIRPath; + mIRPath = previousIRPath; SendControlMsgFromDelegate(kCtrlTagIRFileBrowser, kMsgTagLoadFailed); } @@ -686,60 +670,59 @@ dsp::wav::LoadReturnCode NeuralAmpModeler::_GetIR(const WDL_String& irPath) size_t NeuralAmpModeler::_GetBufferNumChannels() const { // Assumes input=output (no mono->stereo effects) - return this->mInputArray.size(); + return mInputArray.size(); } size_t NeuralAmpModeler::_GetBufferNumFrames() const { - if (this->_GetBufferNumChannels() == 0) + if (_GetBufferNumChannels() == 0) return 0; - return this->mInputArray[0].size(); + return mInputArray[0].size(); } void NeuralAmpModeler::_PrepareBuffers(const size_t numChannels, const size_t numFrames) { - const bool updateChannels = numChannels != this->_GetBufferNumChannels(); - const bool updateFrames = updateChannels || (this->_GetBufferNumFrames() != numFrames); + const bool updateChannels = numChannels != _GetBufferNumChannels(); + const bool updateFrames = updateChannels || (_GetBufferNumFrames() != numFrames); // if (!updateChannels && !updateFrames) // Could we do this? // return; if (updateChannels) { - this->_PrepareIOPointers(numChannels); - this->mInputArray.resize(numChannels); - this->mOutputArray.resize(numChannels); + _PrepareIOPointers(numChannels); + mInputArray.resize(numChannels); + mOutputArray.resize(numChannels); } if (updateFrames) { - for (auto c = 0; c < this->mInputArray.size(); c++) + for (auto c = 0; c < mInputArray.size(); c++) { - this->mInputArray[c].resize(numFrames); - std::fill(this->mInputArray[c].begin(), this->mInputArray[c].end(), 0.0); + mInputArray[c].resize(numFrames); + std::fill(mInputArray[c].begin(), mInputArray[c].end(), 0.0); } - for (auto c = 0; c < this->mOutputArray.size(); c++) + for (auto c = 0; c < mOutputArray.size(); c++) { - this->mOutputArray[c].resize(numFrames); - std::fill(this->mOutputArray[c].begin(), this->mOutputArray[c].end(), 0.0); + mOutputArray[c].resize(numFrames); + std::fill(mOutputArray[c].begin(), mOutputArray[c].end(), 0.0); } } // Would these ever get changed by something? - for (auto c = 0; c < this->mInputArray.size(); c++) - this->mInputPointers[c] = this->mInputArray[c].data(); - for (auto c = 0; c < this->mOutputArray.size(); c++) - this->mOutputPointers[c] = this->mOutputArray[c].data(); + for (auto c = 0; c < mInputArray.size(); c++) + mInputPointers[c] = mInputArray[c].data(); + for (auto c = 0; c < mOutputArray.size(); c++) + mOutputPointers[c] = mOutputArray[c].data(); } void NeuralAmpModeler::_PrepareIOPointers(const size_t numChannels) { - this->_DeallocateIOPointers(); - this->_AllocateIOPointers(numChannels); + _DeallocateIOPointers(); + _AllocateIOPointers(numChannels); } void NeuralAmpModeler::_ProcessInput(iplug::sample** inputs, const size_t nFrames, const size_t nChansIn, const size_t nChansOut) { // We'll assume that the main processing is mono for now. We'll handle dual amps later. - // See also: this->mNUM_INTERNAL_CHANNELS if (nChansOut != 1) { std::stringstream ss; @@ -760,9 +743,9 @@ void NeuralAmpModeler::_ProcessInput(iplug::sample** inputs, const size_t nFrame for (size_t c = 0; c < nChansIn; c++) for (size_t s = 0; s < nFrames; s++) if (c == 0) - this->mInputArray[0][s] = gain * inputs[c][s]; + mInputArray[0][s] = gain * inputs[c][s]; else - this->mInputArray[0][s] += gain * inputs[c][s]; + mInputArray[0][s] += gain * inputs[c][s]; } void NeuralAmpModeler::_ProcessOutput(iplug::sample** inputs, iplug::sample** outputs, const size_t nFrames, @@ -789,6 +772,6 @@ void NeuralAmpModeler::_UpdateMeters(sample** inputPointer, sample** outputPoint { // Right now, we didn't specify MAXNC when we initialized these, so it's 1. const int nChansHack = 1; - this->mInputSender.ProcessBlock(inputPointer, (int)nFrames, kCtrlTagInputMeter, nChansHack); - this->mOutputSender.ProcessBlock(outputPointer, (int)nFrames, kCtrlTagOutputMeter, nChansHack); + mInputSender.ProcessBlock(inputPointer, (int)nFrames, kCtrlTagInputMeter, nChansHack); + mOutputSender.ProcessBlock(outputPointer, (int)nFrames, kCtrlTagOutputMeter, nChansHack); } diff --git a/NeuralAmpModeler/NeuralAmpModeler.h b/NeuralAmpModeler/NeuralAmpModeler.h @@ -11,6 +11,9 @@ #include "ISender.h" const int kNumPresets = 1; +// The plugin is mono inside +constexpr size_t kNumChannelsInternal = 1; + enum EParams { @@ -88,15 +91,15 @@ private: // Sizes based on mInputArray size_t _GetBufferNumChannels() const; size_t _GetBufferNumFrames() const; - // Gets a new Neural Amp Model object and stores it to mStagedNAM - // Returns an emptry string on success, or an error message on failure. - std::string _GetNAM(const WDL_String& dspFile); - // Gets the IR and stores to mStagedIR. + // Loads a NAM model and stores it to mStagedNAM + // Returns an empty string on success, or an error message on failure. + std::string _StageModel(const WDL_String& dspFile); + // Loads an IR and stores it to mStagedIR. // Return status code so that error messages can be relayed if // it wasn't successful. - dsp::wav::LoadReturnCode _GetIR(const WDL_String& irPath); + dsp::wav::LoadReturnCode _StageIR(const WDL_String& irPath); - bool _HaveModel() const { return this->mNAM != nullptr; }; + bool _HaveModel() const { return this->mModel != nullptr; }; // Prepare the input & output buffers void _PrepareBuffers(const size_t numChannels, const size_t numFrames); // Manage pointers @@ -119,32 +122,29 @@ private: // Member data - // The plugin is mono inside - const size_t mNUM_INTERNAL_CHANNELS = 1; - // Input arrays to NAM std::vector<std::vector<iplug::sample>> mInputArray; // Output from NAM std::vector<std::vector<iplug::sample>> mOutputArray; // Pointer versions - iplug::sample** mInputPointers; - iplug::sample** mOutputPointers; + iplug::sample** mInputPointers = nullptr; + iplug::sample** mOutputPointers = nullptr; // Noise gates dsp::noise_gate::Trigger mNoiseGateTrigger; dsp::noise_gate::Gain mNoiseGateGain; - // The Neural Amp Model (NAM) actually being used: - std::unique_ptr<DSP> mNAM; + // The model actually being used: + std::unique_ptr<DSP> mModel; // And the IR std::unique_ptr<dsp::ImpulseResponse> mIR; // Manages switching what DSP is being used. - std::unique_ptr<DSP> mStagedNAM; + std::unique_ptr<DSP> mStagedModel; std::unique_ptr<dsp::ImpulseResponse> mStagedIR; // Flags to take away the modules at a safe time. - std::atomic<bool> mFlagRemoveNAM; - std::atomic<bool> mFlagRemoveIR; + std::atomic<bool> mShouldRemoveModel = false; + std::atomic<bool> mShouldRemoveIR = false; - std::atomic<bool> mNewNAMLoadedInDSP = false; + std::atomic<bool> mNewModelLoadedInDSP = false; // Tone stack modules recursive_linear_filter::LowShelf mToneBass;