hfir.h

#ifndef __HFIR_H
#define __HFIR_H
 
template <class T>
class HFir {
 
    private:
 
        float *_coefficients;
        int _length;
        T *_taps;
        int _head;
        int _spacing;
        int _advance;
        int _skip;
 
        void Init(float* coefficients) {
 
            // Copy coefficients
            _coefficients = new float[_length];
            SetCoefficients(coefficients, _length);
            HLog("Copied filter coefficients");
 
            // Create delay line
            _taps = new T[_length];
            memset((void *) _taps, 0, _length * sizeof(T));
            HLog("Allocated and initialized delay buffer for %d taps", _length);
        }
 
        inline T Filter(T value) {
 
            // Add new sample to the head of the delay line
            _taps[_head] = value;
 
            // Sum all taps
            float result = 0;
            for( int k = 0; k < _length; k++ ) {
                result += _taps[_head++] * _coefficients[k];
                if( _head == _length ) {
                    _head = 0;
                }
            }
 
            // Move tip of the delay line ringbuffer
            _head = _head == 0 ? _length : _head;
            _head--;
 
            // Return the result
            return result;
        }
 
        inline T Filter(T* value, int advance) {
 
            T result = Filter(*value);
 
            for( int i = 1; i < advance; i ++ ) {
 
                // Add new sample to the head of the delay line
                _taps[_head] = value[i * _skip];
 
                // Move tip of the delay line ringbuffer
                _head = _head == 0 ? _length : _head;
                _head--;
            }
 
            // Return the result
            return result;
        }
 
    public:
 
        HFir(float *coefficients, int length) : _length(length), _head(0), _spacing(1), _advance(1), _skip(1) {
 
            HLog("HFir(float*, %d)", length);
            Init(coefficients);
        }
 
        HFir(float *coefficients, int length, int spacing, int advance, int skip):
            _length(length), _head(0), _spacing(spacing), _advance(advance), _skip(skip) {
 
            HLog("HFir(float*, length=%d, spacing=%d, advance=%d, skip=%d)", length, spacing, advance, skip);
            Init(coefficients);
        }
 
        ~HFir() {
            HLog("~HFir()");
            delete[] _taps;
            delete[] _coefficients;
        }
 
        inline void Filter(T *values, T* result, size_t blocksize) {
 
            int j = 0;
            for( int i = 0; i < blocksize; i += _advance * _skip ) {
                result[j] = Filter(&values[i], _advance);
                j += (_spacing - 1) + (_advance * _skip);
            }
        }
 
        void SetCoefficients(float *coefficients, int length) {
 
            // Sanity check
            if (length != _length) {
                HError("It is not possible to assign a set of coefficients of different length than the length used at construction (%d)",
                    _length);
                throw new HFilterInitializationException("Length of coefficients differs from construction length");
            }
 
            // Copy coefficients
            memcpy(_coefficients, coefficients, length * sizeof(float));
        }
 
        std::vector<float> GetCoefficients() {
 
            std::vector<float> coefficients;
            for (int i = 0; i < _length; i++) {
                coefficients.push_back(_coefficients[i]);
            }
            return coefficients;
        }
};
 
#endif