Hi List, I was wondering if someone might be able to help with a performance issue I am having with ChucK in respect to the use of FFT/IFFT. I've written a Pulsar Generator and I've added a convolution function to the pulse train of the generator. I found a previous thread that I've used as a basis for the convolution (see the posting below). The main change was to replace the following line: adc => Gain input => FFT fftx => blackhole; with this one: SinOsc sin => WinFuncEnv env => Pan2 pan => Gain input => FFT fftx => blackhole; At rest, the JACK DSP Load is about 2.2%. When I run the Pulsar Generator at a reasonable rate, the DSP Load jumps to about 3.5% or so without convolution. When I add the convolution function as below, it quickly jumps to a 100% usage with steady Xruns. The sample sizes I am using for the SndBuf statement below are somewhere between 18000 and 28000 samples. Is there a strategy anyone could suggest to achieve greater performance of the convolution function below or are there alternative strategies for implementing convolution in general? I'd appreciate any advice. +++ [chuck-users] Daniel: Convolution (FFT version) Perry R Cook prc at CS.Princeton.EDU Tue Nov 25 19:09:31 EST 2014 Previous message: [chuck-users] Daniel: Convolution Next message: [chuck-users] chugins won't compile Messages sorted by: [ date ] [ thread ] [ subject ] [ author ] FFT version. Most efficient, lots of delay. Could chunk up and factor, overlap-add for less delay. This is the basic idea tho. // FFT convolution with static impulse response // by Perry R. Cook, November 2014 // upsides: as efficient as it could be, save for // constructing a specific fft convolution chugin // downsides: minimum delay is length of impulse response + buffers // fix: break into pieces and overlap add // Other fix: see filter version using my FIR Filter chugin // our fixed convolution kernal (impulse response) SndBuf s => FFT ffth => blackhole; "CelloBodyShort.wav" => s.read; // whatever you like (caution of length!!) 2 => int fftSize; while (fftSize < s.samples()) 2 *=> fftSize; // next highest power of two fftSize => int windowSize; // this is windowsize, only apply to signal blocks windowSize/2 => int hopSize; // this can any whole fraction of windowsize 2 *=> fftSize; // zero pad by 2x factor (for convolve) // our input signal, replace adc with anything you like adc => Gain input => FFT fftx => blackhole; // input signal IFFT outy => dac; // our output fftSize => ffth.size => fftx.size => outy.size; // sizes Windowing.hann(windowSize) => fftx.window; // <<< s.samples(), fftSize >>>; windowSize::samp => now; // load impulse response into h ffth.upchuck() @=> UAnaBlob H; // spectrum of fixed impulse response s =< ffth =< blackhole; // don't need impulse resp signal anymore complex Z[fftSize/2]; 1000 => input.gain; // fiddle with this how you like/need while (true) { fftx.upchuck() @=> UAnaBlob X; // spectrum of input signal // multiply spectra bin by bin (complex for free!): for(0 => int i; i < fftSize/2; i++ ) { fftx.cval(i) * H.cval(i) => Z[i]; } outy.transform( Z ); // take ifft hopSize :: samp => now; // and do it all again } Regards, Mitch