[PD] Convolution / Impulse Response

[Matt Barber]

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?
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL: <http://lists.puredata.info/pipermail/pd-list/attachments/20100121/0a39cf0d/attachment-0001.htm>
>