filternode.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Std includes
#include <atomic>
 
// Audio includes
#include <audio/core/audionode.h>
#include <audio/utility/delay.h>
#include <audio/utility/dirtyflag.h>
#include <audio/utility/linearsmoothedvalue.h>
 
namespace nap
{
    namespace audio
    {
 
        class NAPAPI FilterNode : public Node
        {
        public:
            enum class EMode
            {
                LowPass, HighPass, BandPass, LowRes, HighRes
            };
 
        public:
            FilterNode(NodeManager& nodeManager) : Node(nodeManager), mOutput(8), mInput(8)
            {
                update();
            }
 
            // Inherited from Node
            void process() override;
 
            InputPin audioInput = {this};
 
            OutputPin audioOutput = {this};
 
            void prepare(ControllerValue frequency, ControllerValue resonanceBand, ControllerValue gain);
 
            void setMode(EMode mode);
 
            void setFrequency(ControllerValue cutoffFrequency);
 
            void setResonance(ControllerValue resonance);
 
            void setBand(ControllerValue band);
 
            void setGain(ControllerValue gain);
 
            EMode getMode() const { return mMode; }
 
            ControllerValue getFrequency() const { return mFrequency; }
 
            ControllerValue getResonance() const { return mResonance; }
 
            ControllerValue getBand() const { return mBand; }
 
            ControllerValue getGain() const { return mGain; }
 
        private:
            void update();
            void calcCoeffs();
 
            std::atomic<EMode> mMode = {EMode::LowPass};
            std::atomic<ControllerValue> mFrequency = {440.f};
            std::atomic<ControllerValue> mResonance = {0.f};
            std::atomic<ControllerValue> mBand = {100.f};
            std::atomic<ControllerValue> mGain = {1.f};
            DirtyFlag mIsDirty;
 
            // Filter coefficients
            LinearSmoothedValue<ControllerValue> a0 = { 0, 64 };
            LinearSmoothedValue<ControllerValue> a1 = { 0, 64 };
            LinearSmoothedValue<ControllerValue> a2 = { 0, 64 };
            LinearSmoothedValue<ControllerValue> b1 = { 0, 64 };
            LinearSmoothedValue<ControllerValue> b2 = { 0, 64 };
 
            // Coeffecient destinations before update.
            ControllerValue a0Dest, a1Dest, a2Dest, b1Dest, b2Dest = 0;
 
            Delay mOutput; // Delay line storing the input signal.
            Delay mInput; // Delay line storing the output signal.
        };
 
    }
}