spectrum.h

/*
 * This file is part of Copiste.
 *
 * Copiste is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 *  Copiste is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Copiste.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef INCLUDED_SPECTRUMH
#define INCLUDED_SPECTRUMH

#include "features/extractor.h"

class SpectrumExtr : public FeatureExtractor
{
    public:
        // The algorithm automaticly adapts its data (output, butterfly, window)
        // to the size of the data it gets.
        // In order to be more efficient in the actual computing, we try to compute
        // everything before.

        SpectrumExtr(int chunkSize = 0);
        void reallocate();
        ~SpectrumExtr();

        // It is the standard FFT algorithm : the recursive design has been translated into
        // an iterative process. The output is normalized as the values can get quite high
        // rates.

        bool extract(std::deque<uint16_t> data, int size);
        void normalize(int bound);

    private:
        // The windows are intended to minimize the lack of precision of the actual computation
        // of the Fourier Transform. That's a well-known phenomon : when you try to compute
        // the spectrum of a perfect sinus wave on a finite window, you don't get a pefect dirac
        // as expected, but a large wave with some noise.

        static double rectangularWin(int i, int maxSize);
        static double triangularWin(int i, int maxSize);
        static double hammingWin(int i, int maxSize);
        static double blackmanHarrisWin(int i, int maxSize);

        void createWindowCache();

    public:
        enum FTWindow
        { WINDOW_RECTANGULAR,
          WINDOW_TRIANGULAR,
          WINDOW_HAMMING,
          WINDOW_BH };
        typedef enum FTWindow FTWindow;

        // These functions can be used to retrive the result of the computation.

        float value(int index);
        uint16_t* spectrum();
        int size();
        float min() { return 0; }
        float max() { return (uint16_t)(-1); }

        void setFloat(string key, float value) { ; }
        void setInt(string key, int value);
        float getFloat(string key) { return 0; }
        int getInt(string key);
        void setWindow(FTWindow win);

    private:
        // The size of the data sent to the algorithm must be a power of 2.

        static int regularSize(int size);
        static int log2(int x);
        static int pow2(int n);

    public:
        void watch();

    private:
        uint16_t* mResults;
        int* mButterfly;
        double* mWindowCache;
        FTWindow mCurrentWindow;
        int mSize;
        int mBound;
};

#endif