htranslatebyfour.h

#ifndef __HTRANSLATEBYFOUR_H
#define __HTRANSLATEBYFOUR_H
 
#include "hfilter.h"
#include "hwriter.h"
#include "hwriterconsumer.h"
#include "hreader.h"
#include "hprobe.h"
 
template <class T>
class HTranslateByFour : public HFilter<T>
{
    private:
 
        bool _isQ;
 
        static void DoFilter(T* src, T* dest, size_t blocksize, bool isQ);
 
    public:
 
        HTranslateByFour(HWriter<T>* writer, size_t blocksize, bool isQ = false, HProbe<T>* probe = NULL):
            HFilter<T>(writer, blocksize, probe),
            _isQ(isQ) {}
 
        HTranslateByFour(HWriterConsumer<T>* consumer, size_t blocksize, bool isQ = false, HProbe<T>* probe = NULL):
            HFilter<T>(consumer, blocksize, probe),
            _isQ(isQ) {}
 
        HTranslateByFour(HReader<T>* reader, size_t blocksize, bool isQ = false, HProbe<T>* probe = NULL):
            HFilter<T>(reader, blocksize, probe),
            _isQ(isQ) {}
 
        ~HTranslateByFour() {}
 
        void Filter(T* src, T* dest, size_t blocksize) {
            HTranslateByFour<T>::DoFilter(src, dest, blocksize, _isQ);
        }
 
        void SetIsQ(bool isQ) {
            _isQ = isQ;
        }
 
        static void Translate(T* src, std::complex<T>* dest, size_t blocksize) {
            T* IChannel;
            T* QChannel;
 
            IChannel = new T[blocksize];
            QChannel = new T[blocksize];
 
            HTranslateByFour<T>::DoFilter(src, IChannel, blocksize, false);
            HTranslateByFour<T>::DoFilter(src, QChannel, blocksize, true);
 
            for( int i = 0; i < blocksize; i++ ) {
                dest[i] = std::complex<T>(IChannel[i], QChannel[i]);
            }
 
            delete IChannel;
            delete QChannel;
        }
 
        static void Translate(T* src, std::complex<double>* dest, size_t blocksize) {
            T* IChannel;
            T* QChannel;
 
            IChannel = new T[blocksize];
            QChannel = new T[blocksize];
 
            HTranslateByFour<T>::DoFilter(src, IChannel, blocksize, false);
            HTranslateByFour<T>::DoFilter(src, QChannel, blocksize, true);
 
            for( int i = 0; i < blocksize; i++ ) {
                dest[i] = std::complex<double>((double) IChannel[i], (double) QChannel[i]);
            }
        }
};
 
#endif