hfftoutput.h

#ifndef __HFFTOUTPUT_H
#define __HFFTOUTPUT_H
 
#include <complex>
 
#include "hfft.h"
#include "hmultiplier.h"
#include "hfirfilter.h"
#include "hdecimator.h"
#include "hmemorywriter.h"
#include "houtput.h"
#include "hbaseband.h"
 
struct HFftResults
{
    double* Spectrum;
 
    std::complex<double>* Result;
 
    int Size;
};
 
template <class T>
class HFftOutput : public HOutput<T, HFftResults>
{
    private:
 
        int _size;
        int _average;
        bool _isIq;
        int _skip;
        int _skipped;
 
        double* _spectrum;
        std::complex<double>* _fftResult;
        std::complex<double>* _result;
 
        int _count;
        HWindow<T>* _window;
 
        T* _buffer;
        std::complex<T>* _cxInput;
 
        HFft<T>* _fft;
 
        void Init();
 
        int _zoomFactor;
        int _zoomCenter;
        H_SAMPLE_RATE _zoomRate;
        T* _zoomOutput;
        HInputWriter<T>* _zoomInputWriter;
        HBaseband<T>* _zoomBaseband;
        HDecimator<T>* _zoomDecimator;
        HMemoryWriter<T>* _zoomMemoryWriter;
        T* Zoom(T* src, size_t size);
        bool _zoomEnabled;
 
    public:
 
        HFftOutput(int size, int average, int skip, HWriter<HFftResults>* writer, HWindow<T>* window, H_SAMPLE_RATE zoomRate = 0, int zoomFactor = 1, int zoomCenter = 0);
 
        HFftOutput(int size, int average, int skip, HWriterConsumer<T>* consumer, HWindow<T>* window, H_SAMPLE_RATE zoomRate = 0, int zoomFactor = 1, int zoomCenter = 0);
 
        HFftOutput(int size, int average, int skip, HWriter<HFftResults>* writer, HWindow<T>* window, bool isIq);
 
        HFftOutput(int size, int average, int skip, HWriterConsumer<T>* consumer, HWindow<T>* window, bool isIq);
 
        ~HFftOutput()
        {
            delete _spectrum;
            delete _fftResult;
            delete _buffer;
            delete _cxInput;
            delete _fft;
 
            if( _zoomEnabled ) {
                delete _zoomInputWriter;
                delete _zoomBaseband;
                delete _zoomDecimator;
                delete _zoomOutput;
            }
        }
 
        int Output(T* src, size_t size);
 
        bool Command(HCommand* command) {
            // No Further propagation of commands
            return true;
        }
 
        int Width() {
            if( !_zoomEnabled ) {
                HError("HFftOutput with zoom disabled cannot report FFT frequency span");
                return 0;
            }
 
            return (_zoomRate / 2) / _zoomFactor;
        }
 
        int Left() {
            if( !_zoomEnabled ) {
                HError("HFftOutput with zoom disabled cannot report left FFT frequency");
                return 0;
            }
 
            return Center() - (Width() / 2);
        }
 
        int Right() {
            if( !_zoomEnabled ) {
                HError("HFftOutput with zoom disabled cannot report right FFT frequency");
                return 0;
            }
 
            return Center() + (Width() / 2);
        }
 
        int Center() {
            if( !_zoomEnabled ) {
                HError("HFftOutput with zoom disabled cannot report center FFT frequency");
                return 0;
            }
 
            return _zoomCenter == 0
                           ? _zoomRate / 4
                           : _zoomCenter;
        }
 
        float BinSize() {
            if( !_zoomEnabled ) {
                HError("HFftOutput with zoom disabled cannot report FFT bin size");
                return 0;
            }
 
            return (((float) _zoomRate / 2) / ((float) _size / 2)) / (float) _zoomFactor;
        }
 
        float BinSize(H_SAMPLE_RATE rate) {
            return ((float) rate / 2) / ((float) _size / 2);
        }
 
        H_SAMPLE_RATE Rate() {
            if( !_zoomEnabled ) {
                HError("HFftOutput with zoom disabled cannot report FFT rate");
                return 0;
            }
 
            return _zoomRate / _zoomFactor;
        }
 
        void SetZoom(int zoomFactor, int zoomCenter);
 
        bool Start() {
 
            // Report first (empty) result
            HLog("Initialize spectrum");
            memset((void*) _spectrum, 0, (_size / 2) * sizeof(double));
            memset((void*) _result, 0, (_size / 2) * sizeof(std::complex<double>));
            HFftResults results;
            results.Spectrum = &_spectrum[0];
            results.Result = &_result[0];
            results.Size = _size / 2;
            HOutput<T, HFftResults>::Ready(&results, 1);
 
            return true;
        }
 
        bool Stop() {
 
            // Report one last (empty) result
            HLog("Clear spectrum");
            memset((void*) _spectrum, 0, (_size / 2) * sizeof(double));
            memset((void*) _result, 0, (_size / 2) * sizeof(std::complex<double>));
            HFftResults results;
            results.Spectrum = &_spectrum[0];
            results.Result = &_result[0];
            results.Size = _size / 2;
            HOutput<T, HFftResults>::Ready(&results, 1);
 
            return true;
        }
};
 
#endif