AudioFixedFFT.h

Go to the documentation of this file.

#pragma once
 
#include "AudioFFT.h"
#include "FixedFFT.h"
 
namespace audio_tools {
 
template <typename CalcT = int16_t>
class FFTDriverFixedFFT : public FFTDriver {
    public:
        bool begin(int len) override {
            this->len = len;
            valid = ffp_object.begin(len);
            if (!valid) {
                LOGE("fixedpoint_fft begin failed: len must be a power of two <= %d",
                     (int)fixedpoint_fft::FixedFFTEngineCore<CalcT>::kMaxN);
            }
            return valid;
        }
 
        void end() override {
            ffp_object.end();
            valid = false;
        }
 
        void setValue(int idx, float value) override {
            ffp_object.realData()[idx] = fixedpoint_fft::fftConvertSample<float, CalcT>(value);
            ffp_object.imagData()[idx] = 0;
        }
 
        void fft() override {
            ffp_object.fft();
        };
 
        void rfft() override {
            // safeScale: the spectrum may not have come from fft() (e.g. after setBin())
            ffp_object.ifft(true);
        }
 
        bool isReverseFFT() override { return true; }
 
        float magnitude(int idx) override {
            return sqrt(magnitudeFast(idx));
        }
 
        float magnitudeFast(int idx) override {
            float re = realAsFloat(idx);
            float im = imagAsFloat(idx);
            return re * re + im * im;
        }
 
        bool isValid() override { return valid; }
 
        float getValue(int idx) override { return realAsFloat(idx); }
 
        bool setBin(int pos, float real, float img) override {
            if (pos < 0 || pos >= len) return false;
            ffp_object.realData()[pos] = fixedpoint_fft::fftConvertSample<float, CalcT>(real);
            ffp_object.imagData()[pos] = fixedpoint_fft::fftConvertSample<float, CalcT>(img);
            return true;
        }
        bool getBin(int pos, FFTBin &bin) override {
            if (pos < 0 || pos >= len) return false;
            bin.real = realAsFloat(pos);
            bin.img = imagAsFloat(pos);
            return true;
        }
 
        fixedpoint_fft::FixedFFTEngineCore<CalcT> *engine() { return &ffp_object; }
 
 
    protected:
        fixedpoint_fft::FixedFFTEngineCore<CalcT> ffp_object;
        int len = 0;
        bool valid = false;
 
        float realAsFloat(int idx) {
            return fixedpoint_fft::fftConvertSample<CalcT, float>(ffp_object.real(idx));
        }
        float imagAsFloat(int idx) {
            return fixedpoint_fft::fftConvertSample<CalcT, float>(ffp_object.imag(idx));
        }
};
 
template <typename CalcT = int16_t>
class AudioFixedFFT : public AudioFFTBase {
    public:
        AudioFixedFFT():AudioFFTBase(new FFTDriverFixedFFT<CalcT>()) {}
 
        CalcT* realArray() {
            return driverEx()->engine()->realData();
        }
 
        CalcT* imgArray() {
            return driverEx()->engine()->imagData();
        }
 
        FFTDriverFixedFFT<CalcT>* driverEx() {
            return (FFTDriverFixedFFT<CalcT>*)driver();
        }
};
 
}