CUPoleZeroIIR.h

//
//  CUPoleZeroFIR.h
//  Cornell University Game Library (CUGL)
//
//  This class is represents a one-pole, one-zero IIR filter. This is the
//  standard class for implementing first order highpass filters.  For
//  first-order filters, it is significantly more performant than IIRFilter.
//
//  This class supports vector optimizations for SSE and Neon 64.  In timed
//  simulations, these optimizations provide at least a 3-4x performance
//  increase (and in isolated cases, much higher). Our implementation is
//  limited to 128-bit words as 256-bit (e.g. AVX) and higher show no
//  significant increase in performance.
//
//  For performance reasons, this class does not have a (virtualized) subclass
//  relationship with other IIR or FIR filters.  However, the signature of the
//  the calculation and coefficient methods has been standardized so that it
//  can support templated polymorphism.
//
//  This class is NOT THREAD SAFE.  This is by design, for performance reasons.
//  External locking may be required when the filter is shared between multiple
//  threads (such as between an audio thread and the main thread).
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 6/11/18
//
#ifndef __CU_POLE_ZERO_FIR_H__
#define __CU_POLE_ZERO_FIR_H__
 
#include <cugl/math/dsp/CUIIRFilter.h>
#include <cugl/math/CUMathBase.h>
#include <cugl/util/CUAligned.h>
#include <cstring>
#include <vector>
 
namespace cugl {
    namespace dsp {
        
class PoleZeroFIR {
private:
    unsigned _channels;
    float _b0, _b1;
    float _a1, _a2;
    
    cugl::Aligned<float> _inns;
    cugl::Aligned<float> _outs;
    
    // Optimization data structures (single channel)
    float __attribute__((__aligned__(16))) _c1[4];
    float __attribute__((__aligned__(16))) _d1[16];
    
    // Optimization data structures (dual channel)
    float __attribute__((__aligned__(16))) _c2[8];
    float __attribute__((__aligned__(16))) _d2[16];
    
    void reset();
    
#pragma mark SPECIALIZED FILTERS
 
    void stride(float gain, float* input, float* output, size_t size, unsigned channel);
    
    void single(float gain, float* input, float* output, size_t size);
    
    void dual(float gain, float* input, float* output, size_t size);
    
    void trio(float gain, float* input, float* output, size_t size);
    
    void quad(float gain, float* input, float* output, size_t size);
    
    void quart(float gain, float* input, float* output, size_t size);
    
public:
    static bool VECTORIZE;
 
#pragma mark Constructors
 
    PoleZeroFIR();
    
    PoleZeroFIR(unsigned channels);
    
    PoleZeroFIR(unsigned channels, float b0, float b1, float a1);
    
    PoleZeroFIR(const PoleZeroFIR& copy);
    
    PoleZeroFIR(PoleZeroFIR&& filter);
    
    ~PoleZeroFIR();
    
#pragma mark IIR Signature
 
    unsigned getChannels() const { return _channels; }
    
    void setChannels(unsigned channels);
    
    void setCoeff(const std::vector<float> &bvals, const std::vector<float> &avals);
    
    const std::vector<float> getBCoeff() const;
    
    const std::vector<float> getACoeff() const;
    
#pragma mark Specialized Attributes
 
    void setBCoeff(float b0, float b1);
    
    void setACoeff(float a1);
    
    void setHighpass(float frequency);
    
    void setAllpass(float coefficient);
    
    void setBlockZero(float pole = 0.99f);
    
#pragma mark Filter Methods
 
    void step(float gain, float* input, float* output);
    
    void calculate(float gain, float* input, float* output, size_t size);
    
    void clear();
    
    size_t flush(float* output);
};
 
    }
}
#endif /* __CU_POLE_ZERO_FIR_H__ */