Single stage mono convolver based on HiFi-Lofis convolver The FFT and buffers use the tklb types and the simd was replaced with xsimd TODO tklb all ! FIX THIS MESS ! FIX THIS MESS ! FIX THIS MESS ! FIX THIS MESS. More...

#include <TConvolverFFT.hpp>

Collaboration diagram for tklb::ConvolverMonoTpl< T >:

Public Types
using	uchar = unsigned char

using	uint = unsigned int

using	Buffer = AudioBufferTpl< T >

using	Size = typename Buffer::Size

Public Member Functions
	ConvolverMonoTpl ()=default

template<typename T2 >
void	load (const AudioBufferTpl< T2 > &buffer, const uint blockSize, const uchar channel)
	Load a impulse response and prepare the convolution. More...

template<typename T2 >
void	process (const AudioBufferTpl< T2 > &inBuf, AudioBufferTpl< T2 > &outBuf, const uchar channel)
	Do the convolution. More...

Private Types
using	Segments = HeapBuffer< Buffer >

Static Private Member Functions
static void	complexMultiply (Buffer &bufferOut, const Buffer &bufferA, const Buffer &bufferB)

Detailed Description

template<typename T>
class tklb::ConvolverMonoTpl< T >

Single stage mono convolver based on HiFi-Lofis convolver The FFT and buffers use the tklb types and the simd was replaced with xsimd TODO tklb all ! FIX THIS MESS ! FIX THIS MESS ! FIX THIS MESS ! FIX THIS MESS.

Definition at line 27 of file TConvolverFFT.hpp.

Member Typedef Documentation

◆ Buffer

template<typename T >

using tklb::ConvolverMonoTpl< T >::Buffer = AudioBufferTpl<T>

Definition at line 31 of file TConvolverFFT.hpp.

◆ Segments

template<typename T >

using tklb::ConvolverMonoTpl< T >::Segments = HeapBuffer<Buffer>

private

Definition at line 44 of file TConvolverFFT.hpp.

◆ Size

template<typename T >

using tklb::ConvolverMonoTpl< T >::Size = typename Buffer::Size

Definition at line 32 of file TConvolverFFT.hpp.

◆ uchar

template<typename T >

using tklb::ConvolverMonoTpl< T >::uchar = unsigned char

Definition at line 29 of file TConvolverFFT.hpp.

◆ uint

template<typename T >

using tklb::ConvolverMonoTpl< T >::uint = unsigned int

Definition at line 30 of file TConvolverFFT.hpp.

Constructor & Destructor Documentation

◆ ConvolverMonoTpl()

template<typename T >

tklb::ConvolverMonoTpl< T >::ConvolverMonoTpl ( )

default

Member Function Documentation

◆ complexMultiply()

template<typename T >

static void tklb::ConvolverMonoTpl< T >::complexMultiply	(	Buffer &	bufferOut,
		const Buffer &	bufferA,
		const Buffer &	bufferB
	)

inlinestaticprivate

Definition at line 170 of file TConvolverFFT.hpp.

          {
            const uint size = bufferOut.size();
            const T* aReal = bufferA[0];
            const T* aImag = bufferA[1];
            const T* bReal = bufferB[0];
            const T* bImag = bufferB[1];
            T* outReal = bufferOut[0];
            T* outImag = bufferOut[1];
            #ifdef TKLB_NO_SIMD
                for (uint i = 0; i < size; i++) {
                    outReal[i] += aReal[i] * bReal[i] - aImag[i] * bImag[i];
                    outImag[i] += aReal[i] * bImag[i] + aImag[i] * bReal[i];
                }
            #else
                const uint vectorize = size - size % Buffer::stride;
                for(uint i = 0; i < vectorize; i += Buffer::stride) {
                    xsimd::simd_type<T> aR = xsimd::load_aligned(aReal + i);
                    xsimd::simd_type<T> bR = xsimd::load_aligned(bReal + i);
                    xsimd::simd_type<T> aI = xsimd::load_aligned(aImag + i);
                    xsimd::simd_type<T> bI = xsimd::load_aligned(bImag + i);
                    xsimd::store_aligned(outReal + i, (aR * bR) - (aI * bI));
                    xsimd::store_aligned(outImag + i, (aR * bI) + (aI * bR));
                }
                for(uint i = vectorize; i < size; i++) {
                    outReal[i] += aReal[i] * bReal[i] - aImag[i] * bImag[i];
                    outImag[i] += aReal[i] * bImag[i] + aImag[i] * bReal[i];
                }
            #endif
        }

Here is the caller graph for this function:

◆ load()

template<typename T >

template<typename T2 >

void tklb::ConvolverMonoTpl< T >::load	(	const AudioBufferTpl< T2 > &	buffer,
		const uint	blockSize,
		const uchar	channel
	)

inline

Load a impulse response and prepare the convolution.

Parameters

buffer	The ir buffer. Only the first channel is used
blockSize	Size of blocks ir will be divided in

Definition at line 63 of file TConvolverFFT.hpp.

                                                                                               {
            uint irLength = buffer.validSize();
            const T2* ir = buffer[channel];
            // trim silence, since longer IRs increase CPU usage considerably
            const T2 silence = 0.000001;
            while (irLength && silence > fabs(ir[irLength])) { irLength--; }
            if (irLength == 0) { return; }
            irLength++; // index to length
 
            // Figure out how many segments a block is
            mBlockSize = powerOf2(blockSize);
            mSegmentSize = 2 * mBlockSize;
            mSegmentCount = uint(std::ceil(irLength / double(mBlockSize)));
            mFFTComplexSize = mBlockSize + 1;
 
            // create segment buffers for the input signal
            mFFT.resize(mSegmentSize);
            mFFTBuffer.resize(mSegmentSize);
 
            // create segment buffers for the impulse response
            mSegments.resize(mSegmentCount);
            mSegments.construct();
            mSegmentsIR.resize(mSegmentCount);
            mSegmentsIR.construct();
 
            for (uint i = 0; i < mSegmentCount; i++) {
                const uint remaining = std::min(irLength - (i * mBlockSize), mBlockSize);
                mFFTBuffer.set(0);
                // Put the segment in the fft buffer, might do type conversion
                mFFTBuffer.set(ir + (i * mBlockSize), remaining);
                mSegmentsIR[i].resize(mFFTComplexSize, 2); // make space in the result buffer
                mSegments[i].resize(mFFTComplexSize, 2); // and the input signal buffer
                mFFT.forward(mFFTBuffer, mSegmentsIR[i]); // save the fft result for each segment
            }
 
            mPremultipliedBuffer.resize(mFFTComplexSize, 2);
            mConvolutionBuffer.resize(mFFTComplexSize, 2);
            mOverlapBuffer.resize(mBlockSize);
            mInputBuffer.resize(mBlockSize);
 
            mCurrentPosition = 0;
            mInputBufferFill = 0;
        }

Here is the call graph for this function:

◆ process()

template<typename T >

template<typename T2 >

void tklb::ConvolverMonoTpl< T >::process	(	const AudioBufferTpl< T2 > &	inBuf,
		AudioBufferTpl< T2 > &	outBuf,
		const uchar	channel
	)

inline

Do the convolution.

Definition at line 111 of file TConvolverFFT.hpp.

                                                                                                       {
            if (mSegmentCount == 0) {
                outBuf.set(inBuf);
                return;
            }
 
            const uint length = inBuf.validSize();
            const T2* in = inBuf[channel];
            T2* out = outBuf[channel];
 
            uint processed = 0;
            uint iterations = 0;
            while (processed < length) {
                const bool inputBufferWasEmpty = (mInputBufferFill == 0);
                const uint processing = std::min(length - processed, mBlockSize - mInputBufferFill);
                const uint inputBufferPos = mInputBufferFill;
 
                mInputBuffer.set(in + processed, processing, 0, inputBufferPos);
 
                mFFTBuffer.set(mInputBuffer, mBlockSize);
                mFFTBuffer.set(0, 0, mBlockSize); // pad the rest with 0
                mFFT.forward(mFFTBuffer, mSegments[mCurrentPosition]);
 
                if (inputBufferWasEmpty) {
                    mPremultipliedBuffer.set(0);
                    for (uint i = 1; i < mSegmentCount; i++) {
                        const size_t indexIr = i;
                        const size_t indexAudio = (mCurrentPosition + i) % mSegmentCount;
                        complexMultiply(mPremultipliedBuffer, mSegmentsIR[indexIr], mSegments[indexAudio]);
                    }
                }
 
                mConvolutionBuffer.set(mPremultipliedBuffer);
                complexMultiply(mConvolutionBuffer, mSegmentsIR[0], mSegments[mCurrentPosition]);
 
                mFFT.back(mConvolutionBuffer, mFFTBuffer);
 
                // outBuf.set(mFFTBuffer[0] + inputBufferPos, processing, 0, processed);
                // outBuf.add(mOverlapBuffer, processing, processed, inputBufferPos);
                for (int i = 0; i < processing; i++) {
                    out[i + processed] =
                        (mFFTBuffer[0][i + inputBufferPos] +
                        mOverlapBuffer[0][i + inputBufferPos]);
                }
 
                mInputBufferFill += processing;
                if (mInputBufferFill == mBlockSize) {
                    mInputBuffer.set(0);
                    mInputBufferFill = 0;
                    mOverlapBuffer.set(mFFTBuffer, mBlockSize, 0, mBlockSize);
                    mCurrentPosition = (mCurrentPosition > 0) ? (mCurrentPosition - 1) : (mSegmentCount - 1);
                }
 
                processed += processing;
                iterations++;
            }
        }

Here is the call graph for this function:

Member Data Documentation

◆ mBlockSize

template<typename T >

Size tklb::ConvolverMonoTpl< T >::mBlockSize

private

Definition at line 35 of file TConvolverFFT.hpp.

◆ mComplexIr

template<typename T >

Buffer tklb::ConvolverMonoTpl< T >::mComplexIr

private

Definition at line 41 of file TConvolverFFT.hpp.

◆ mConvolutionBuffer

template<typename T >

Buffer tklb::ConvolverMonoTpl< T >::mConvolutionBuffer

private

Definition at line 50 of file TConvolverFFT.hpp.

◆ mCurrentPosition

template<typename T >

Size tklb::ConvolverMonoTpl< T >::mCurrentPosition

private

Definition at line 40 of file TConvolverFFT.hpp.

◆ mFFT

template<typename T >

FFT tklb::ConvolverMonoTpl< T >::mFFT

private

Definition at line 47 of file TConvolverFFT.hpp.

◆ mFFTBuffer

template<typename T >

Buffer tklb::ConvolverMonoTpl< T >::mFFTBuffer

private

Definition at line 42 of file TConvolverFFT.hpp.

◆ mFFTComplexSize

template<typename T >

Size tklb::ConvolverMonoTpl< T >::mFFTComplexSize

private

Definition at line 38 of file TConvolverFFT.hpp.

◆ mInputBuffer

template<typename T >

Buffer tklb::ConvolverMonoTpl< T >::mInputBuffer

private

Definition at line 49 of file TConvolverFFT.hpp.

◆ mInputBufferFill

template<typename T >

Size tklb::ConvolverMonoTpl< T >::mInputBufferFill

private

Definition at line 39 of file TConvolverFFT.hpp.

◆ mOverlapBuffer

template<typename T >

Buffer tklb::ConvolverMonoTpl< T >::mOverlapBuffer

private

Definition at line 51 of file TConvolverFFT.hpp.

◆ mPremultipliedBuffer

template<typename T >

Buffer tklb::ConvolverMonoTpl< T >::mPremultipliedBuffer

private

Definition at line 48 of file TConvolverFFT.hpp.

◆ mSegmentCount

template<typename T >

Size tklb::ConvolverMonoTpl< T >::mSegmentCount

private

Definition at line 37 of file TConvolverFFT.hpp.

◆ mSegments

template<typename T >

Segments tklb::ConvolverMonoTpl< T >::mSegments

private

Definition at line 46 of file TConvolverFFT.hpp.

◆ mSegmentsIR

template<typename T >

Segments tklb::ConvolverMonoTpl< T >::mSegmentsIR

private

Definition at line 45 of file TConvolverFFT.hpp.

◆ mSegmentSize

template<typename T >

Size tklb::ConvolverMonoTpl< T >::mSegmentSize

private

Definition at line 36 of file TConvolverFFT.hpp.

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

TConvolverFFT.hpp

Private Attributes
Size	mBlockSize

Size	mSegmentSize

Size	mSegmentCount

Size	mFFTComplexSize

Size	mInputBufferFill

Size	mCurrentPosition

Buffer	mComplexIr

Buffer	mFFTBuffer

Segments	mSegmentsIR

Segments	mSegments

FFT	mFFT

Buffer	mPremultipliedBuffer

Buffer	mInputBuffer

Buffer	mConvolutionBuffer

Buffer	mOverlapBuffer

Public Types

Public Member Functions

Private Types

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Buffer

◆ Segments

◆ Size

◆ uchar

◆ uint

Constructor & Destructor Documentation

◆ ConvolverMonoTpl()

Member Function Documentation

◆ complexMultiply()

◆ load()

◆ process()

Member Data Documentation

◆ mBlockSize

◆ mComplexIr

◆ mConvolutionBuffer

◆ mCurrentPosition

◆ mFFT

◆ mFFTBuffer

◆ mFFTComplexSize

◆ mInputBuffer

◆ mInputBufferFill

◆ mOverlapBuffer

◆ mPremultipliedBuffer

◆ mSegmentCount

◆ mSegments

◆ mSegmentsIR

◆ mSegmentSize