marvin_SmoothedBiquadCoefficients.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
 
#ifndef MARVIN_SMOOTHEDBIQUAD_COEFFICIENTS_H
#define MARVIN_SMOOTHEDBIQUAD_COEFFICIENTS_H
 
#include "marvin/library/marvin_Concepts.h"
#include "marvin/dsp/filters/biquad/marvin_BiquadCoefficients.h"
#include "marvin/utils/marvin_SmoothedValue.h"
#include <array>
#include <cassert>
namespace marvin::dsp::filters {

    template <FloatType SampleType, utils::SmoothingType InterpolationType, size_t NumStages>
    requires(NumStages > 0)
    class SmoothedBiquadCoefficients final {
    public:
        void reset(int periodSamples) noexcept {
            for (auto& stage : m_stages) {
                stage.reset(periodSamples);
            }
        }

        void reset(double sampleRate, double timeMs) noexcept {
            for (auto& stage : m_stages) {
                stage.reset(sampleRate, timeMs);
            }
        }

        void setCurrentAndTargetCoeffs(size_t stage, BiquadCoefficients<SampleType> target) noexcept {
            assert(stage < NumStages);
            m_stages[stage].setCurrentAndTargetCoeffs(target);
        }

        void setTargetCoeffs(size_t stage, BiquadCoefficients<SampleType> target) noexcept {
            assert(stage < NumStages);
            m_stages[stage].setTargetCoeffs(target);
        }

        [[nodiscard]] BiquadCoefficients<SampleType> current(size_t stage) const noexcept {
            assert(stage < NumStages);
            return m_stages[stage].current();
        }

        [[nodiscard]] BiquadCoefficients<SampleType> target(size_t stage) const noexcept {
            assert(stage < NumStages);
            return m_stages[stage].target();
        }

        void interpolate() noexcept {
            for (auto& stage : m_stages) {
                stage.interpolate();
            }
        }
 
    private:
        class CoeffSmoothingStage final {
        public:
            void reset(int periodSamples) noexcept {
                for (auto& s : m_smoothers) {
                    s.reset(periodSamples);
                }
            }
 
            void reset(double sampleRate, double timeMs) noexcept {
                for (auto& s : m_smoothers) {
                    s.reset(sampleRate, timeMs);
                }
            }
 
            void setCurrentAndTargetCoeffs(BiquadCoefficients<SampleType> newCoeffs) noexcept {
                m_smoothers[0].setCurrentAndTargetValue(newCoeffs.a0);
                m_smoothers[1].setCurrentAndTargetValue(newCoeffs.a1);
                m_smoothers[2].setCurrentAndTargetValue(newCoeffs.a2);
                m_smoothers[3].setCurrentAndTargetValue(newCoeffs.b0);
                m_smoothers[4].setCurrentAndTargetValue(newCoeffs.b1);
                m_smoothers[5].setCurrentAndTargetValue(newCoeffs.b2);
                m_current = newCoeffs;
            }
 
            void setTargetCoeffs(BiquadCoefficients<SampleType> newCoeffs) noexcept {
                m_smoothers[0].setTargetValue(newCoeffs.a0);
                m_smoothers[1].setTargetValue(newCoeffs.a1);
                m_smoothers[2].setTargetValue(newCoeffs.a2);
                m_smoothers[3].setTargetValue(newCoeffs.b0);
                m_smoothers[4].setTargetValue(newCoeffs.b1);
                m_smoothers[5].setTargetValue(newCoeffs.b2);
            }
 
            void interpolate() noexcept {
                m_current = {
                    .a0 = m_smoothers[0](),
                    .a1 = m_smoothers[1](),
                    .a2 = m_smoothers[2](),
                    .b0 = m_smoothers[3](),
                    .b1 = m_smoothers[4](),
                    .b2 = m_smoothers[5]()
                };
            }
 
            [[nodiscard]] BiquadCoefficients<SampleType> current() const noexcept {
                return m_current;
            }
 
            [[nodiscard]] BiquadCoefficients<SampleType> target() const noexcept {
                return {
                    .a0 = m_smoothers[0].getTargetValue(),
                    .a1 = m_smoothers[1].getTargetValue(),
                    .a2 = m_smoothers[2].getTargetValue(),
                    .b0 = m_smoothers[3].getTargetValue(),
                    .b1 = m_smoothers[4].getTargetValue(),
                    .b2 = m_smoothers[5].getTargetValue()
                };
            }
 
        private:
            std::array<marvin::utils::SmoothedValue<SampleType, InterpolationType>, 6> m_smoothers;
            BiquadCoefficients<SampleType> m_current{};
        };
 
        std::array<CoeffSmoothingStage, NumStages> m_stages;
    };
} // namespace marvin::dsp::filters
#endif