fftbuffer.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// External Includes
#include <nap/resource.h>
#include <nap/numeric.h>
#include <complex>
#include <mutex>
#include <atomic>
 
namespace nap
{
    class NAPAPI FFTBuffer final
    {
        RTTI_ENABLE()
    public:
        using AmplitudeSpectrum = std::vector<float>;
        using PhaseSpectrum = std::vector<float>;
 
        enum class EOverlap : uint
        {
            One     = 1,
            Three   = 3,
            Five    = 5,
            Seven   = 7,
            Nine    = 9,
            Eleven  = 11
        };
 
        FFTBuffer(uint dataSize, EOverlap overlap = EOverlap::One);
 
        // Destructor
        ~FFTBuffer();
 
        void supply(const std::vector<float>& samples);
 
        uint getBinCount() const { return mBinCount; }
 
        uint getDataSize();
 
        const AmplitudeSpectrum& getAmplitudeSpectrum()             { transform(); return mAmplitude; }
 
        const PhaseSpectrum& getPhaseSpectrum()                     { transform(); return mPhase; }
 
    private:
 
        void transform();                                           //< Transform sample data into FFT image (thread safe)
        void createImage();                                         //< Construct FFT image
 
        class KissContext;
        std::unique_ptr<KissContext> mContext;
 
        std::vector<std::complex<float>> mComplexOut;               //< Complex
        std::vector<std::complex<float>> mComplexOutAverage;        //< Complex averaged over multiple analysis hops
 
        AmplitudeSpectrum mAmplitude;                               //< Magnitude (rho)
        PhaseSpectrum mPhase;                                       //< Phase angle (theta)
 
        std::vector<float> mForwardHammingWindow;                   //< Preprocessed window function coefficients
        float mHammingWindowSum;                                    //< The sum of all window function coefficients
        float mNormalizationFactor;                                 //< Inverse of the window sum (2/sum)
 
 
        std::mutex mSampleBufferMutex;                              //< The mutex for accessing the sample buffer
        std::vector<float> mSampleBufferA;                          //< Samples provided by the audio node
        std::vector<float> mSampleBufferB;                          //< Thread safe copy of original samples
        std::vector<float> mSampleBufferFormatted;                  //< The sample buffer before application of a window function
        std::vector<float> mSampleBufferWindowed;                   //< The sample buffer after application of a window function
 
        uint mBinCount;                                             //< The number of FFT bins          
        float mBinFrequency;                                        //< The frequency each bin comprises
 
        EOverlap mOverlap;                                          //< The number of audio buffer overlaps for FFT analysis (hops)
        uint mHopSize;                                              //< The number of bins of a single hop
        std::atomic<bool> mSampleData = { false };                  //< Amplitudes dirty checking flag, prevents redundant FFT analyses 
    };
}