Cascade.h

 
#pragma once
 
#include "Common.h"
#include "Biquad.h"
#include "Layout.h"
#include "MathSupplement.h"
 
namespace Iir {

        class IIR_EXPORT Cascade
        {
        public:
        
        Cascade () = default;

        struct IIR_EXPORT Storage
        {
            Storage() = delete;
            Storage(const int maxNumBiquads, Biquad* const biquadArray) : maxStages(maxNumBiquads), stageArray(biquadArray) {}
            const int maxStages = 0;
            Biquad* const stageArray = nullptr;
        };

        int getNumStages () const
        {
                return m_numStages;
        }

        const Biquad& operator[] (int index)
        {
                if ((index < 0) || (index >= m_numStages))
                        throw_invalid_argument("Index out of bounds.");
                return m_stageArray[index];
        }

        complex_t response (double normalizedFrequency) const;

        std::vector<PoleZeroPair> getPoleZeros () const;
 
        void setCascadeStorage (const Storage& storage);
 
        void applyScale (double scale);
 
        void setLayout (const LayoutBase& proto);
 
        private:
        int m_numStages = 0;
        int m_maxStages = 0;
        Biquad* m_stageArray = nullptr;
        };
 
 
//------------------------------------------------------------------------------
        
        template <int MaxStages,class StateType>
        class CascadeStages {
 
        public:
        CascadeStages() = default;
                
                
        public:
        void reset ()
        {
                for (auto &state: m_states)
                        state.reset();
        }
        
        public:
        void setup (const double (&sosCoefficients)[MaxStages][6]) {
                for (int i = 0; i < MaxStages; i++) {
                        m_stages[i].setCoefficients(
                                sosCoefficients[i][3],
                                sosCoefficients[i][4],
                                sosCoefficients[i][5],
                                sosCoefficients[i][0],
                                sosCoefficients[i][1],
                                sosCoefficients[i][2]);
                }
        }
 
        void setup (const std::array<std::array<double,6>,MaxStages> sosCoefficients) {
                for (int i = 0; i < MaxStages; i++) {
                        m_stages[i].setCoefficients(
                                sosCoefficients[i][3],
                                sosCoefficients[i][4],
                                sosCoefficients[i][5],
                                sosCoefficients[i][0],
                                sosCoefficients[i][1],
                                sosCoefficients[i][2]);
                }
        }
 
        public:
        template <typename Sample>
        inline Sample filter(const Sample in)
        {
                double out = in;
                StateType* state = m_states;
                for (const auto &stage: m_stages)
                        out = (state++)->filter(out, stage);
                return static_cast<Sample> (out);
        }

        const Cascade::Storage getCascadeStorage()
        {
            const Cascade::Storage s(MaxStages, m_stages);
            return s;
        }
        
        private:
        Biquad m_stages[MaxStages] = {};
        StateType m_states[MaxStages] = {};
        };
        
}