New upstream version 1.9.0+ds

1 files changed, 100 insertions, 4 deletions

diff --git a/src/Reverb.cpp b/src/Reverb.cpp
index 3f1774d..ec80a67 100644
--- a/src/Reverb.cpp
+++ b/src/Reverb.cpp
@@ -37,7 +37,102 @@
 
 #include "Reverb.h"
 
+#include "freeverbdsp.h"  // stereo in and out
+#include "freeverbmonodsp.h"  // mono in and out (there is no mono to stereo case in jacktrip as yet)
 #include "jacktrip_types.h"
+#include "zitarevdsp.h"      // stereo in and out
+#include "zitarevmonodsp.h"  // mono in and out
+
+//*******************************************************************************
+Reverb::Reverb(int numInChans, int numOutChans, float reverbLevel, bool verboseFlag)
+    : mNumInChannels(numInChans), mNumOutChannels(numOutChans), mReverbLevel(reverbLevel)
+{
+    setVerbose(verboseFlag);
+    if (mNumInChannels < 1) {
+        std::cerr << "*** Reverb.h: must have at least one input audio channels\n";
+        mNumInChannels = 1;
+    }
+    if (mNumInChannels > 2) {
+        std::cerr << "*** Reverb.h: limiting number of audio output channels to 2\n";
+        mNumInChannels = 2;
+    }
+#if 0
+std::cout << "Reverb: constructed for "
+            << mNumInChannels << " input channels and "
+            << mNumOutChannels << " output channels with reverb level = "
+            << mReverbLevel << "\n";
+#endif
+
+    if (mReverbLevel <= 1.0) {                    // freeverb:
+        freeverbStereoP   = new freeverbdsp;      // stereo input and output
+        freeverbMonoP     = new freeverbmonodsp;  // mono input, stereo output
+        freeverbStereoUIP = new APIUI;            // #included in *dsp.h
+        freeverbMonoUIP   = new APIUI;
+        static_cast<freeverbdsp*>(freeverbStereoP)
+            ->buildUserInterface(static_cast<APIUI*>(freeverbStereoUIP));
+        static_cast<freeverbmonodsp*>(freeverbMonoP)
+            ->buildUserInterface(static_cast<APIUI*>(freeverbMonoUIP));
+        // std::cout << "Using freeverb\n";
+    } else {
+        zitarevStereoP   = new zitarevdsp;      // stereo input and output
+        zitarevMonoP     = new zitarevmonodsp;  // mono input, stereo output
+        zitarevStereoUIP = new APIUI;
+        zitarevMonoUIP   = new APIUI;
+        static_cast<zitarevdsp*>(zitarevStereoP)
+            ->buildUserInterface(static_cast<APIUI*>(zitarevStereoUIP));
+        static_cast<zitarevmonodsp*>(zitarevMonoP)
+            ->buildUserInterface(static_cast<APIUI*>(zitarevMonoUIP));
+        // std::cout << "Using zitarev\n";
+    }
+}
+
+//*******************************************************************************
+Reverb::~Reverb()
+{
+    if (mReverbLevel <= 1.0) {  // freeverb:
+        delete static_cast<freeverbdsp*>(freeverbStereoP);
+        delete static_cast<freeverbmonodsp*>(freeverbMonoP);
+        delete static_cast<APIUI*>(freeverbStereoUIP);
+        delete static_cast<APIUI*>(freeverbMonoUIP);
+    } else {
+        delete static_cast<zitarevdsp*>(zitarevStereoP);
+        delete static_cast<zitarevmonodsp*>(zitarevMonoP);
+        delete static_cast<APIUI*>(zitarevStereoUIP);
+        delete static_cast<APIUI*>(zitarevMonoUIP);
+    }
+}
+
+//*******************************************************************************
+void Reverb::init(int samplingRate)
+{
+    ProcessPlugin::init(samplingRate);
+    // std::cout << "Reverb: init(" << samplingRate << ")\n";
+    if (samplingRate != fSamplingFreq) {
+        std::cerr << "Sampling rate not set by superclass!\n";
+        std::exit(1);
+    }
+    fs = float(fSamplingFreq);
+    if (mReverbLevel <= 1.0) {  // freeverb:
+        static_cast<freeverbdsp*>(freeverbStereoP)
+            ->init(fs);  // compression filter parameters depend on sampling rate
+        static_cast<freeverbmonodsp*>(freeverbMonoP)
+            ->init(fs);  // compression filter parameters depend on sampling rate
+        int ndx = static_cast<APIUI*>(freeverbStereoUIP)->getParamIndex("Wet");
+        static_cast<APIUI*>(freeverbStereoUIP)->setParamValue(ndx, mReverbLevel);
+        static_cast<APIUI*>(freeverbMonoUIP)->setParamValue(ndx, mReverbLevel);
+    } else {  // zitarev:
+        static_cast<zitarevdsp*>(zitarevStereoP)
+            ->init(fs);  // compression filter parameters depend on sampling rate
+        static_cast<zitarevmonodsp*>(zitarevMonoP)
+            ->init(fs);  // compression filter parameters depend on sampling rate
+        int ndx = static_cast<APIUI*>(zitarevStereoUIP)->getParamIndex("Wet");
+        float zitaLevel =
+            mReverbLevel - 1.0f;  // range within zitarev is 0 to 1 (our version only)
+        static_cast<APIUI*>(zitarevStereoUIP)->setParamValue(ndx, zitaLevel);
+        static_cast<APIUI*>(zitarevMonoUIP)->setParamValue(ndx, zitaLevel);
+    }
+    inited = true;
+}
 
 //*******************************************************************************
 void Reverb::compute(int nframes, float** inputs, float** outputs)
@@ -53,17 +148,18 @@ void Reverb::compute(int nframes, float** inputs, float** outputs)
     }
     if (mReverbLevel <= 1.0) {
         if (mNumInChannels == 1) {
-            freeverbMonoP->compute(nframes, inputs, outputs);
+            static_cast<freeverbmonodsp*>(freeverbMonoP)
+                ->compute(nframes, inputs, outputs);
         } else {
             assert(mNumInChannels == 2);
-            freeverbStereoP->compute(nframes, inputs, outputs);
+            static_cast<freeverbdsp*>(freeverbStereoP)->compute(nframes, inputs, outputs);
         }
     } else {
         if (mNumInChannels == 1) {
-            zitarevMonoP->compute(nframes, inputs, outputs);
+            static_cast<zitarevmonodsp*>(zitarevMonoP)->compute(nframes, inputs, outputs);
         } else {
             assert(mNumInChannels == 2);
-            zitarevStereoP->compute(nframes, inputs, outputs);
+            static_cast<zitarevdsp*>(zitarevStereoP)->compute(nframes, inputs, outputs);
         }
     }
 }