hinterpolator.h

#ifndef __HINTERPOLATOR_H
#define __HINTERPOLATOR_H
 
#include "hreader.h"
#include "hwriter.h"
#include "hwriterconsumer.h"
#include "hprobe.h"
 
#include <vector>
 
template <class T>
class HInterpolator: public HReader<T>, public HWriter<T>, public HWriterConsumer<T>
{
    private:
 
        HWriter<T>* _writer;
        HReader<T>* _reader;
        size_t _blocksize;
 
        HProbe<T>* _probe;
 
        int _factor;
        T* _inBuffer; 
        T* _outBuffer; 
        int _length;
 
        float * _coefficients;
        int _firLength;
        std::vector<HFir<T>*> _firs;
 
        void Init(float* coefficients = nullptr);
 
    protected:
 
        HInterpolator(HWriter<T>* writer, int factor, size_t blocksize, HProbe<T>* probe = nullptr);
 
        HInterpolator(HWriterConsumer<T>* consumer, int factor, size_t blocksize, HProbe<T>* probe = nullptr);
 
        HInterpolator(HReader<T>* reader, int factor, size_t blocksize, HProbe<T>* probe = nullptr);
 
    public:
 
        HInterpolator(HWriter<T>* writer, int factor, float* coefficients, int length, size_t blocksize, HProbe<T>* probe = nullptr);
 
        HInterpolator(HWriterConsumer<T>* consumer, int factor, float* coefficients, int length, size_t blocksize, HProbe<T>* probe = nullptr);
 
        HInterpolator(HReader<T>* reader, int factor, float* coefficients, int length, size_t blocksize, HProbe<T>* probe = nullptr);
 
        void SetWriter(HWriter<T>* writer) {
            _writer = writer;
        }
 
        ~HInterpolator();
 
        int Write(T* src, size_t blocksize);
 
        int Read(T* dest, size_t blocksize);
 
        bool Start() {
            if( _writer != nullptr )
            {
                return _writer->Start();
            }
            if( _reader != nullptr )
            {
                return _reader->Start();
            }
            return true;
        }
 
        bool Stop() {
            if( _writer != nullptr )
            {
                return _writer->Stop();
            }
            if( _reader != nullptr )
            {
                return _reader->Stop();
            }
            return true;
        }
 
        bool Command(HCommand* command) {
            if( _writer != nullptr )
            {
                return _writer->Command(command);
            }
            if( _reader != nullptr )
            {
                return _reader->Command(command);
            }
            return true;
        }
};
 
#endif