tklb::FFTOoura Class Reference

#include <TOouraFFT.hpp>

Collaboration diagram for tklb::FFTOoura:

Public Member Functions
	FFTOoura (uint size=0)
void	resize (uint size)
template<typename T >
void	forward (const AudioBufferTpl< T > &input, AudioBufferTpl< T > &result)
	timedomain to frequency domain More...
template<typename T >
void	back (const AudioBufferTpl< T > &input, AudioBufferTpl< T > &result)
	Frequency domain back to time domain. More...

Private Types
using	uchar = unsigned char
using	uint = unsigned int

Private Attributes
uint	mSize
HeapBuffer< int, 16 >	mIp
AudioBufferDouble	mW
AudioBufferDouble	mBuffer

Detailed Description

Definition at line 10 of file TOouraFFT.hpp.

Member Typedef Documentation

uchar

using tklb::FFTOoura::uchar = unsigned char

private

Definition at line 11 of file TOouraFFT.hpp.

uint

using tklb::FFTOoura::uint = unsigned int

private

Definition at line 12 of file TOouraFFT.hpp.

Constructor & Destructor Documentation

FFTOoura()

tklb::FFTOoura::FFTOoura ( uint  size = 0 )

inline

Definition at line 22 of file TOouraFFT.hpp.

                                {
            if (size == 0) { return; }
            resize(size);
        }

Here is the call graph for this function:

Member Function Documentation

back()

template<typename T >

void tklb::FFTOoura::back ( const AudioBufferTpl< T > &  input, AudioBufferTpl< T > &  result  )

inline

Frequency domain back to time domain.

Parameters

input	Buffer with 2 channels. channel 0 for real and 1 for imaginary
result	Single channel output buffer. Needs to be twice the size of the imput buffer

Definition at line 88 of file TOouraFFT.hpp.

                                                                             {
            TKLB_ASSERT(input.validSize() % mSize == 0) // Only multiples os the chunk size
            const T* real = input[0];
            const T* imaginary = input[1];
            T* out = result[0];
            uint processed = 0;
            while (processed < input.validSize()) {
                {
                    // TODO tklb make this mess readable
                    double* b = mBuffer[0];
                    double* bEnd = b + mSize;
                    const uint processedHalf = processed / 2;
                    const T* r = real + processedHalf;
                    const T* i = imaginary + processedHalf;
                    while (b != bEnd) {
                        *(b++) = (*(r++));
                        *(b++) = -(*(i++));
                    }
                    mBuffer[0][1] = real[mSize / 2];
                }
 
                ooura::rdft(int(mSize), -1, mBuffer[0], mIp.data(), mW[0]);
 
                const T volume = 2.0 / T(mSize);
                if (std::is_same<T, double>::value) {
                    mBuffer.multiply(volume); // scale the output
                    mBuffer.put(reinterpret_cast<double*>(out + processed), mSize);
                } else {
                    // or the old fashioned way if we need to convert sample types anyways
                    const double* buf = mBuffer[0];
                    for (uint i = 0; i < mSize; i++) {
                        out[i + processed] = buf[i] * volume;
                    }
                }
                processed += mSize;
            }
        }

Here is the call graph for this function:

forward()

template<typename T >

void tklb::FFTOoura::forward ( const AudioBufferTpl< T > &  input, AudioBufferTpl< T > &  result  )

inline

timedomain to frequency domain

Parameters

input	Input buffer, validSize needs to be a multiple of 2
output	Output buffer, must have 2 channel for real and imaginary. Half the length of thie input buffer

converts or copies the data we shouldn't use the original buffer since mBuffer gets written to by ooura

Definition at line 45 of file TOouraFFT.hpp.

                                                                                {
            TKLB_ASSERT(input.validSize() % mSize == 0) // Only multiples os the chunk size
            uint processed = 0;
            while (processed < input.validSize()) {
                const uint processedHalf = processed / 2;
                T* real = result[0] + processedHalf;
                T* imaginary = result[1] + processedHalf;
                const T* in = input[0] + processed;
                /**
                 * converts or copies the data
                 * we shouldn't use the original buffer since
                 * mBuffer gets written to by ooura
                 */
                mBuffer.set(in, mSize);
                ooura::rdft(mSize, +1, mBuffer[0], mIp.data(), mW[0]);
 
                // Convert back to split-complex
                {
                    // TODO tklb make this mess readable
                    double* b = mBuffer[0];
                    double* bEnd = b + mSize;
                    T* r = real;
                    T* i = imaginary;
                    while (b != bEnd) {
                        *(r++) = (*(b++));
                        *(i++) = (-(*(b++)));
                    }
                }
                const size_t size2 = mSize / 2;
                // real[size2] = -imaginary[0]; // this doens't make any sense
                // imaginary[0] = 0.0;
                // imaginary[size2] = 0.0; // this doesn't either
                processed += mSize;
            }
 
        }

Here is the call graph for this function:

resize()

void tklb::FFTOoura::resize ( uint  size )

inline

Definition at line 27 of file TOouraFFT.hpp.

                               {
            if (size == mSize) { return; }
            mIp.resize(2 + int(std::sqrt(double(size))));
            mW.resize(size / 2);
            mBuffer.resize(size);
            mSize = size;
 
            const int size4 = size / 4;
            ooura::makewt(size4, mIp.data(), mW[0]);
            ooura::makect(size4, mIp.data(), mW[0] + size4);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mBuffer

AudioBufferDouble tklb::FFTOoura::mBuffer

private

Definition at line 19 of file TOouraFFT.hpp.

mIp

HeapBuffer<int, 16> tklb::FFTOoura::mIp

private

Definition at line 16 of file TOouraFFT.hpp.

mSize

uint tklb::FFTOoura::mSize

private

Definition at line 14 of file TOouraFFT.hpp.

mW

AudioBufferDouble tklb::FFTOoura::mW

private

Definition at line 18 of file TOouraFFT.hpp.

---

The documentation for this class was generated from the following file:

• TOouraFFT.hpp