I’m currently studying the juce-Convolution, currently only the internal ConvolutionEngine-struct.

The algorithm has a special adaption to user bigger chunks of impulse data (relative to input data) when used with smaller buffer sizes "blockSize > 128”. It uses then FFT-blocks which are 4x bigger than the block-size instead of 2x bigger.

In this case more overlap data is created, which is preserved for later operations.

I see theoretical benefit from it, but only if the impulse-response is at least four times bigger than the block-size (in my simplified model I assume that FFT-calculation time is proportional to the FFT-size, and the engine is fed with optimal aligned input-blocks)

fftSize = BlockSize * 2

processingTime = roundup(IRSize / BlockSize) * fftSize

Vs adapted

fftSize = BlockSize * 4

processingTime = roundup(IRSize / (fftSize-blockSize)) * fftSize

Imho the condition for this adaption should not dependent on the size of the block "blockSize > 128”, instead it should be “irsamples > (blocksize * 4)

These are theoretical thoughts, probably only @reuk and @fr810 can say something about it, because they wrote the engine

```
struct ConvolutionEngine
{
ConvolutionEngine (const float* samples,
size_t numSamples,
size_t maxBlockSize)
: blockSize ((size_t) nextPowerOfTwo ((int) maxBlockSize)),
fftSize (blockSize > 128 ? 2 * blockSize : 4 * blockSize),
fftObject (std::make_unique<FFT> (roundToInt (std::log2 (fftSize)))),
numSegments (numSamples / (fftSize - blockSize) + 1u),
numInputSegments ((blockSize > 128 ? numSegments : 3 * numSegments)),
```

PS:

Is it planned to transform the whole engine to use templates to support double-precision in the near future?