Merge pull request SquarePine#13 from Density-One/fix/fx-tweaks

Fix/fx tweaks

Author: erictarrbelmont

modules/squarepine_audio/core/EffectProcessorChain.cpp

@@ -164,6 +164,9 @@ class EffectProcessorChain final : public InternalProcessor
     */
     bool setMixLevel (int index, float mixLevel);
 
+    using EffectUpdateFn = std::function<void (InternalProcessor&)>;
+    void setTimeEffectsInChain (EffectUpdateFn f);
+
     //==============================================================================
     /** Obtain the name of a plugin that exists within the array of effect plugins
 
@@ -255,7 +258,7 @@ class EffectProcessorChain final : public InternalProcessor
     /** @internal */
     [[nodiscard]] double getTailLengthSeconds() const override;
     /** @internal */
-    [[nodiscard]] Identifier getIdentifier() const override{ return "EffectProcessorChain"; }
+    [[nodiscard]] Identifier getIdentifier() const override { return "EffectProcessorChain"; }
     /** @internal */
     [[nodiscard]] const String getName() const override;
     /** @internal */
@@ -266,7 +269,6 @@ class EffectProcessorChain final : public InternalProcessor
     void getStateInformation (MemoryBlock&) override;
     /** @internal */
     void setStateInformation (const void*, int) override;
-
 private:
     //==============================================================================
     template<typename FloatType>
@@ -276,13 +278,13 @@ class EffectProcessorChain final : public InternalProcessor
 
         void clear() noexcept
         {
-            for (auto& buff : buffers)
+            for (auto& buff: buffers)
                 buff->clear();
         }
 
         void prepare (int numChannels, int numSamples)
         {
-            for (auto& buff : buffers)
+            for (auto& buff: buffers)
                 buff->setSize (numChannels, numSamples, false, true, true);
 
             clear();
@@ -322,8 +324,7 @@ class EffectProcessorChain final : public InternalProcessor
     void process (juce::AudioBuffer<FloatType>&, MidiBuffer&, BufferPackage<FloatType>&);
 
     template<typename FloatType>
-    void processInternal (juce::AudioBuffer<FloatType>& source, MidiBuffer& midiMessages,
-                          BufferPackage<FloatType>& bufferPackage, int numChannels, int numSamples);
+    void processInternal (juce::AudioBuffer<FloatType>& source, MidiBuffer& midiMessages, BufferPackage<FloatType>& bufferPackage, int numChannels, int numSamples);
 
     template<typename Type>
     [[nodiscard]] EffectProcessor::Ptr insertInternal (const Type& valueOrRef, int destinationIndex, InsertionStyle insertionStyle = InsertionStyle::insert);
@@ -343,7 +344,7 @@ class EffectProcessorChain final : public InternalProcessor
     template<void (AudioProcessor::*function)()>
     void loopThroughEffectsAndCall()
     {
-        for (auto effect : plugins)
+        for (auto effect: plugins)
             if (effect != nullptr)
                 if (auto* plugin = effect->plugin.get())
                     (plugin->*function)();

modules/squarepine_audio/core/EffectProcessorChain.h

@@ -111,6 +111,17 @@ void InternalProcessor::removeProperty (const Identifier& id, UndoManager* um)
 {
     getState().removeProperty (id, um);
 }
+//==============================================================================
+
+void InternalProcessor::setEffectPhaseRelativeToProjectDownBeat(double phaseRelativeToProjectDownBeat)
+{
+    effectPhaseRelativeToProjectDownBeat = phaseRelativeToProjectDownBeat;
+}
+
+void InternalProcessor::setIsInSteppedTimeMode(bool isInSteppedTimeMode)
+{
+    isSteppedTime = isInSteppedTimeMode;
+}
 
 //==============================================================================
 void InternalProcessor::setBypass (const bool shouldBeBypassed)

modules/squarepine_audio/core/InternalProcessor.cpp

@@ -116,6 +116,10 @@ class InternalProcessor : public AudioPluginInstance
     */
     void removeProperty (const Identifier&, UndoManager* undoManager = nullptr);
 
+    //==============================================================================
+    virtual void setEffectPhaseRelativeToProjectDownBeat (double PhaseRelativeToProjectDownBeat);
+    
+    virtual void setIsInSteppedTimeMode (bool isInSteppedTimeMode);
     //==============================================================================
     /** Effectively enables or disables this processor. */
     void setBypass (bool shouldBeBypassed);
@@ -195,7 +199,10 @@ class InternalProcessor : public AudioPluginInstance
 
     class BypassParameter;
     AudioParameterBool* bypassParameter = nullptr;
-
+    
+    double effectPhaseRelativeToProjectDownBeat = 0.0;
+    
+    bool isSteppedTime = false;
     /** */
     [[nodiscard]] std::unique_ptr<AudioParameterBool> createBypassParameter() const;
 

modules/squarepine_audio/core/InternalProcessor.h

@@ -23,6 +23,11 @@ class PhaseIncrementer
         angleChange = frequency * 2.0f * f_PI / Fs;
     }
 
+    void setCurrentAngle (float angleInRadians, int channel)
+    {
+        currentAngle[channel] = angleInRadians;
+    }
+    
 private:
 
     float f_PI = static_cast<float> (M_PI);

modules/squarepine_audio/effects/PhaseIncrementer.h

@@ -88,11 +88,18 @@ CrushProcessor::~CrushProcessor()
 //============================================================================== Audio processing
 void CrushProcessor::prepareToPlay (double sampleRate, int bufferSize)
 {
-    bitCrusher.prepareToPlay (sampleRate, bufferSize);
+    Fs = sampleRate;
+    
+    downSampler.setRatio (sampleRate, sampleRate);
+    const int numChannels = 2;
+    downSampler.prepare (numChannels);
+    upSampler.prepare (numChannels);
+    
     highPassFilter.setFilterType (DigitalFilter::FilterType::HPF);
     highPassFilter.setFs (sampleRate);
-    delayBlock.setFs (static_cast<float> (sampleRate));
-    dryBuffer = AudioBuffer<float> (2, bufferSize);
+    dryBuffer = AudioBuffer<float> (numChannels, bufferSize);
+    resampledBuffer = AudioBuffer<float> (numChannels, bufferSize);
+    
 }
 void CrushProcessor::processBlock (juce::AudioBuffer<float>& buffer, MidiBuffer& midi)
 {
@@ -115,26 +122,32 @@ void CrushProcessor::processBlock (juce::AudioBuffer<float>& buffer, MidiBuffer&
     if (abs(colour) < 0.01f)
         wet = 0.f;
 
+    
     for (int c = 0; c < numChannels; ++c)
     {
         dryBuffer.copyFrom (c, 0, buffer, c, 0, buffer.getNumSamples());
     }
-    bitCrusher.processBlock (buffer, midi);
+    
     highPassFilter.processBuffer (buffer, midi);
+    
+    downFs = (1.1f + (1.f - abs(colour))) * std::powf (10.f, (1.f - abs(colour)) + 3.f); // 1.1k - 22k
+    const auto downSamplingRatio = Fs / downFs;
+    
+    downSampler.setRatio (Fs, downFs);
+    upSampler.setRatio (downFs, Fs);
+    
+    const auto scaledBufferSize = (int) std::round ((double) numSamples / downSamplingRatio);
+    resampledBuffer.setSize (numChannels, scaledBufferSize, false, true, true);
+    downSampler.process (buffer, resampledBuffer);
+    upSampler.process (resampledBuffer, buffer);
 
     for (int c = 0; c < numChannels; ++c)
     {
         for (int n = 0; n < numSamples; ++n)
         {
-            float x = buffer.getWritePointer (c)[n];
-
-            float wetSample = delayBlock.processSample (x, c);
-
-            //float y = x + wetSmooth[c] * wetSample;
-            buffer.getWritePointer (c)[n] = wetSmooth[c] * wetSample * colorSmooth[c];
+            buffer.getWritePointer (c)[n] *= wetSmooth[c];
             dryBuffer.getWritePointer (c)[n] *= (1.f - wetSmooth[c]);
             wetSmooth[c] = 0.999f * wetSmooth[c] + 0.001f * wet;
-            colorSmooth[c] = 0.999f * colorSmooth[c] + 0.001f * colorSign;
         }
         buffer.addFrom (c, 0, dryBuffer, c, 0, buffer.getNumSamples());
     }
@@ -153,37 +166,20 @@ void CrushProcessor::parameterValueChanged (int paramNum, float value)
     if (paramNum == 2) {}// wet/dry
     else if (paramNum == 3) // "color"
     {
-        float other = otherParam->get();
-        float samplesOfDelay = jmin (15.f, 1.f + abs (value) * 10.f + other * 10.f);
-        delayBlock.setDelaySamples (samplesOfDelay);
         if (value <= 0.f)
         {
             highPassFilter.setFreq (20.0);
-            float normValue = (value * -1.f);
-            // 4 bits -> normValue = 0
-            // 9 bits -> normValue = 1
-            float bitDepth = 5.f * std::sqrt (1.f - normValue) + 4.f;
-            bitCrusher.setBitDepth (bitDepth);
-            colorSign = 1.f;
         }
         else
         {
             float normValue = value;
             // freqHz = 20 -> 5000
             float freqHz = 2.f * std::powf (10.f, 3.f * (normValue * 0.8f) + 1.f);
             highPassFilter.setFreq (freqHz);
-            // 9 bits -> value = 0.5, normValue = 0
-            // 4 bits -> value = 1, normValue = 0
-            float bitDepth = 5.f * std::sqrt (1.f - normValue) + 4.f;
-            bitCrusher.setBitDepth (bitDepth);
-            colorSign = -1.f;
         }
     }
     else if (paramNum == 4)// "other"
     {
-        float color = colourParam->get();
-        float samplesOfDelay = jmin (15.f, 1.f + value * 10.f + abs (color) * 10.f);
-        delayBlock.setDelaySamples (samplesOfDelay);
     }
 }
 

modules/squarepine_audio/effects/daweffects/CrushProcessor.cpp

@@ -58,15 +58,19 @@ class CrushProcessor final : public InternalProcessor,
 
     int idNumber = 1;
 
-    BitCrusherProcessor bitCrusher;
+    double Fs = 48000.0;
     DigitalFilter highPassFilter;
-    FractionalDelay delayBlock;
-    float colorSign = 1.f;
 
     float wetSmooth[2] = { 0.f };
     float colorSmooth[2] = { 0.f };
 
     AudioBuffer<float> dryBuffer;
+    
+    
+    ZeroOrderHoldResampler downSampler; //ZeroOrderHoldResampler
+    ZeroOrderHoldResampler upSampler; //LinearResampler //LagrangeResampler
+    AudioBuffer<float> resampledBuffer;
+    double downFs = 48000.0;
 };
 
 }