tklb::FFTpffft Class Reference

#include <Tpffft.hpp>

Collaboration diagram for tklb::FFTpffft:

Public Member Functions
	FFTpffft (uint size=0)
	~FFTpffft ()
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
PFFFT_Setup *	mSetup = nullptr
AudioBufferFloat	mBuffer
AudioBufferFloat	mRc

Detailed Description

Definition at line 20 of file Tpffft.hpp.

Member Typedef Documentation

uchar

using tklb::FFTpffft::uchar = unsigned char

private

Definition at line 21 of file Tpffft.hpp.

uint

using tklb::FFTpffft::uint = unsigned int

private

Definition at line 22 of file Tpffft.hpp.

Constructor & Destructor Documentation

FFTpffft()

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

inline

Definition at line 30 of file Tpffft.hpp.

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

Here is the call graph for this function:

~FFTpffft()

tklb::FFTpffft::~FFTpffft ( )

inline

Definition at line 35 of file Tpffft.hpp.

                    {
            if (mSetup == nullptr) { return; }
            pffft_destroy_setup(mSetup);
        }

Member Function Documentation

back()

template<typename T >

void tklb::FFTpffft::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 89 of file Tpffft.hpp.

                                                                             {
            uint processed = 0;
            TKLB_ASSERT(input.validSize() % mSize == 0) // Only multiples os the chunk size
            while (processed < input.validSize()) {
                const uint sizeHalf = mSize / 2;
                const uint processedHalf = processed / 2;
                mRc.set(input[0] + processedHalf, sizeHalf);
                mRc.set(input[1] + processedHalf, sizeHalf, sizeHalf);
                const T volume = 1.0 / double(mSize);
                if (std::is_same<T, float>::value) {
                    float* out = reinterpret_cast<float*>(result[0]) + processed;
                    pffft_transform_ordered(mSetup, mRc[0], out, nullptr, PFFFT_BACKWARD);
                    result.multiply(volume); // scale the result
                } else {
                    pffft_transform_ordered(mSetup, mRc[0], mBuffer[0], nullptr, PFFFT_BACKWARD);
                    const float* buf = mBuffer[0];
                    T* out = result[0] + processed;
                    for (uint i = 0; i < mSize; i++) {
                        out[i] = buf[i] * volume; // scale the result + type conversion
                    }
                }
                processed += mSize;
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

forward()

template<typename T >

void tklb::FFTpffft::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

Definition at line 56 of file Tpffft.hpp.

                                                                                {
            uint processed = 0;
            TKLB_ASSERT(input.validSize() % mSize == 0) // Only multiples os the chunk size
            while (processed < input.validSize()) {
                const float* data = nullptr;
                if (std::is_same<T, float>::value) {
                    data = reinterpret_cast<const float*>(input[0] + processed);
                } else {
                    mBuffer.set(input[0] + processed, mSize); // Type conversion
                    data = mBuffer[0];
                }
 
                pffft_transform_ordered(mSetup, data, mRc[0], nullptr, PFFFT_FORWARD);
 
                // Split real and complex in two channels
                const uint sizeHalf = mSize / 2;
 
                // mRc[0][sizeHalf] = 0;
                // result.setFromInterleaved(mRc[0], sizeHalf, 2, processed / 2);
                result.set(mRc[0], mSize, processed);
                // result.set(mRc[0],            sizeHalf, 0, processed / 2);
                // result.set(mRc[0] + sizeHalf, sizeHalf, 1, processed / 2);
 
                processed += mSize;
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

resize()

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

inline

Definition at line 40 of file Tpffft.hpp.

                               {
            if (mSetup != nullptr) {
                pffft_destroy_setup(mSetup);
            }
            mSetup = pffft_new_setup(size, PFFFT_REAL);
            mBuffer.resize(size);
            mRc.resize(size * 2);
            mSize = size;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mBuffer

AudioBufferFloat tklb::FFTpffft::mBuffer

private

Definition at line 26 of file Tpffft.hpp.

mRc

AudioBufferFloat tklb::FFTpffft::mRc

private

Definition at line 27 of file Tpffft.hpp.

mSetup

PFFFT_Setup* tklb::FFTpffft::mSetup = nullptr

private

Definition at line 25 of file Tpffft.hpp.

mSize

uint tklb::FFTpffft::mSize

private

Definition at line 24 of file Tpffft.hpp.

---

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

• Tpffft.hpp