I used to have a set of abstractions that did this. I threw it together on a whim, it wasn't all that efficient, and I haven't tested it in a couple of years... it would need a total revamp to be usable even for teaching because the constituent abstractions are not documented and not altogether straightforward.

Anyway, I think you can copy the contents of an impulse-response array to several smaller arrays (the partitioning) using dynamic patching, then do fft-convolution with the incoming signal and the contents of the array (using [tabreceive~]), and then delay each separate signal by the appropriate amount (taking block delay into account) so that the aggregate produces the original impulse response convolved with the input. I think you might be able to get a bonus in efficiency if you do the partitioning into the following array sizes:

64 64 128 128 256 256 512 512 etc.

Then you can avoid having more than a 64-sample-block delay overall, because the block delay associated with each set of larger arrays will be just enough to collect enough samples to compute the fft, do the mulitplication and ifft, and output the result. You might even be able to build in a buffer by doing:

64 32 32 64 64 128 128 256 256 512 512 etc.

This should give extra time to compute the fft->mult->ifft

I think I had built in an optional maximum fft size, so that at some point it would just continue to partition into, say, 8192-sample chunks.

I had been thinking about doing the first block as a direct convolution for no overall delay, but I couldn't decide whether it would be worth it from the standpoint of efficiency... anyway, I couldn't get it to work without dropouts for a response of more than about 2 seconds long.

Matt

is it possible to do something vaguely similiar in vanilla pd?