BUGFIX

Author: Ankalot

.vscode/settings.json

@@ -100,6 +100,7 @@
         "valarray": "cpp",
         "iterativelinearsolvers": "cpp",
         "sparse": "cpp",
-        "alignedvector3": "cpp"
+        "alignedvector3": "cpp",
+        "sparselu": "cpp"
     }
 }

plugin/include/Bifractalizer/PluginProcessor.h

@@ -4,8 +4,8 @@
 #include <Eigen/Sparse>
 #include <Eigen/SparseLU>
 
-//using FloatSolver = Eigen::SparseLU<Eigen::SparseMatrix<float>>;
-using FloatSolver = Eigen::BiCGSTAB<Eigen::SparseMatrix<float>>;
+using FloatSolver = Eigen::SparseLU<Eigen::SparseMatrix<float>>;
+//using FloatSolver = Eigen::BiCGSTAB<Eigen::SparseMatrix<float>>;
 
 
 namespace audio_plugin {
@@ -70,6 +70,8 @@ class AudioPluginAudioProcessor : public juce::AudioProcessor {
   bool actualDefrMatrix = false; 
   Eigen::SparseMatrix<float> defrMatrix;
   FloatSolver defrSolver;
+  juce::ThreadPool threadPool;
+  std::atomic<bool> solverReady{true};
   void prepareDefractalizer();
   // -~-~-~-~-~-~-~-~-~-~-~-~-~--~-~-~-~-~-~-~-~-~-~-~-~-~--~-~-~-~-~-~-~-~-~-
 

plugin/source/PluginProcessor.cpp

@@ -147,8 +147,10 @@ void AudioPluginAudioProcessor::updateBuffers(int hostBlockSize) {
                     blockSizeVal) + (hostBlockSize % blockSizeVal == 0 ? 0 : 1)) * blockSizeVal + inBufPos;
 
   int numChannels = getTotalNumInputChannels();
-  inputBuffer.setSize(numChannels, blockSizeVal, false, true, true);
-  outputBuffer.setSize(numChannels, outBufSize, false, true, true);
+  inputBuffer.setSize(numChannels, blockSizeVal);
+  inputBuffer.clear();
+  outputBuffer.setSize(numChannels, outBufSize);
+  outputBuffer.clear();
 
   outBufPosRead = 0;
   if (hostBlockSize % (outBufSize - inBufPos) == 0)
@@ -191,6 +193,7 @@ void AudioPluginAudioProcessor::prepareToPlay(double sampleRate,
   outBufPosRead = 0;    // for audio repeatability
   outputBuffer.clear(); // for audio repeatability
   prevBlockOffset = -1; // so inBufPos will be changed
+  processingN = -1;
   updateBuffers(samplesPerBlock);
 }
 
@@ -354,10 +357,15 @@ void AudioPluginAudioProcessor::processBlock(juce::AudioBuffer<float>& buffer,
 void AudioPluginAudioProcessor::prepareDefractalizer() {
   findDefractalizerMatrix(defrMatrix, two_pow_n, weights, processingN, max_terms);
 
-  //defrSolver.analyzePattern(defrMatrix);
-  //defrSolver.factorize(defrMatrix);
-  defrSolver.setMaxIterations(50);
-  defrSolver.compute(defrMatrix);
+  solverReady.store(false);
+  threadPool.addJob([this] {
+    defrSolver.analyzePattern(defrMatrix);
+    defrSolver.factorize(defrMatrix);
+    solverReady.store(true);
+  });
+
+  //defrSolver.setMaxIterations(max_terms*2);
+  //defrSolver.compute(defrMatrix);
   actualDefrMatrix = true;
 }
 
@@ -376,10 +384,16 @@ void AudioPluginAudioProcessor::processCustomBlock() {
     if (apvts.getRawParameterValue("mode")->load()==0) {
       fractalize(xGrid, processInBuffer, processOutBuffer, two_pow_n, weights, max_terms);
     } else {
-      if (!actualDefrMatrix) {
+      if (!actualDefrMatrix && solverReady) {
         prepareDefractalizer();
       }
       defractalize(processInBuffer, processOutBuffer, defrMatrix, defrSolver);
+        defractalize(processInBuffer, processOutBuffer, defrMatrix, defrSolver);
+      } else {
+        for (int ch = 0; ch < getNumInputChannels(); ++ch) {
+          processOutBuffer.copyFrom(ch, 0, processInBuffer, ch, 0, processingN);
+        }
+      }
     }
   }
 

plugin/source/bifractalizer.cpp

@@ -13,8 +13,8 @@
 #include <Eigen/Sparse>
 #include <Eigen/IterativeLinearSolvers>
 
-//using FloatSolver = Eigen::SparseLU<Eigen::SparseMatrix<float>>;
-using FloatSolver = Eigen::BiCGSTAB<Eigen::SparseMatrix<float>>;
+using FloatSolver = Eigen::SparseLU<Eigen::SparseMatrix<float>>;
+//using FloatSolver = Eigen::BiCGSTAB<Eigen::SparseMatrix<float>>;
 
 
 namespace audio_plugin {
@@ -34,7 +34,7 @@ void compute_f_optimized(juce::AudioBuffer<float>& f,        // size(f) == size(
                         const juce::AudioBuffer<float>& g,   // size(f) == size(x) == size(g)
                         const std::vector<float>& two_pow_n, // size(two_pow_n) == max_terms
                         const std::vector<float>& weights,   // size(weights) == max_terms
-                        int max_terms = 20                   /* Must be divisible by 4!*/) {
+                        int max_terms = 20) {
     const int N = g.getNumSamples();
     const int numChannels = f.getNumChannels();
     const float inv_g_step = static_cast<float>(N);
@@ -48,62 +48,17 @@ void compute_f_optimized(juce::AudioBuffer<float>& f,        // size(f) == size(
             const float xi = x_data[i];
             float sum = 0.0f;
 
-            for (int n = 0; n < max_terms; n += 4) {
-                const float arg0 = xi * two_pow_n[n];
-                const float arg1 = xi * two_pow_n[n+1];
-                const float arg2 = xi * two_pow_n[n+2];
-                const float arg3 = xi * two_pow_n[n+3];
-
-                const int idx0 = static_cast<int>((arg0 - std::floor(arg0)) * inv_g_step + 0.5f);
-                const int idx1 = static_cast<int>((arg1 - std::floor(arg1)) * inv_g_step + 0.5f);
-                const int idx2 = static_cast<int>((arg2 - std::floor(arg2)) * inv_g_step + 0.5f);
-                const int idx3 = static_cast<int>((arg3 - std::floor(arg3)) * inv_g_step + 0.5f);
-
-                sum += weights[n]   * g_data[idx0];
-                sum += weights[n+1] * g_data[idx1];
-                sum += weights[n+2] * g_data[idx2];
-                sum += weights[n+3] * g_data[idx3];
-            }
-
-            f_data[i] = sum;
-        }
-    }
-}
-
-
-/*void compute_f(juce::AudioBuffer<float>& f,
-               const std::vector<float>& x,
-               const juce::AudioBuffer<float>& g,
-               const std::vector<float>& two_pow_n,
-               const std::vector<float>& weights,
-               int max_terms = 20) {
-    const int N = g.getNumSamples();
-    const int numChannels = f.getNumChannels();
-
-    const float inv_g_step = static_cast<float>(N);
-    const float* x_data = x.data();
-
-    for (int ch = 0; ch < numChannels; ++ch) {
-        const float* g_data = g.getReadPointer(ch);
-        float* f_data = f.getWritePointer(ch);
-
-        for (int i = 0; i < N; ++i) {
-            float sum = 0.0f;
-            const float xi = x_data[i];
-
             for (int n = 0; n < max_terms; ++n) {
                 const float arg = xi * two_pow_n[n];
-                const float fractional = arg - std::floor(arg);
-                const int idx = static_cast<int>(fractional * inv_g_step + 0.5f);
-                //const int safe_idx = idx < N ? idx : N - 1;
-
-                sum += weights[n] * g_data[idx];
+                const int idx = static_cast<int>((arg - std::floor(arg)) * inv_g_step + 0.5f);
+                const int safe_idx = idx < N ? idx : N - 1;
+                sum += weights[n] * g_data[safe_idx];
             }
 
             f_data[i] = sum;
         }
     }
-}*/
+}
 
 
 void fractalize(const std::vector<float> &x_grid,