Yes this is certainly possible but seems overly complicated if you’re only after an integer factor time stretch, because it involves a lot of redundancies (most notably expressing the operation as a pitch shift and the entire frequency computation associated with it). Also you would be restricted to changing the speed of the signal in steps of 2^n due to the size limitations of the FFT that we use (unless you would replace it by a non-2^n FFT of course, which is not implemented in the code that we provide).

However, a similar method (different input/output transform sizes) is sometimes used for doing sinc interpolation for high quality sample rate conversion, but that does not involve keeping the speed of the signal constant.

For a more in-depth discussion I would recommend taking this to our forum at http://www.surroundsfx.com/forum/viewforum.php?f=11
I’d be happy to explain this in better detail there.

Best wishes, Stephan Bernsee

Now it also seems that the slowing down of tempo in music could also be achieved without a resampling function by using a second larger FFT for the synthesis stage. If the second FFT transform were 1024 in framesize, and the original analysis FFT transform was 512 in size, then the synthesis stage would create twice as many samples that could still play the music at its original pitch.

Of course the crux of the problem is how to calculate the new FFT bin values(real, imaginary) for the second oversize FFT of the synthesis step. In the case above, having FFT framesizes of 512 and 1024, we can calculate accurate bin values for “every other” FFT frequency row in the second FFT, by using your gAnaMagn[] gAnaFreq[] arrays and their respective calculations for phase and magnitude in the new bins of the second FFT (the ones that share the same frequency as those of the first FFT).

However we would have only calculated values for half of the synthesis FFT bins, because the gAnaMagn[] gAnaFreq[] arrays from the analysis only have half the values needed for the higher resolution of the synthesis FFT. At this point the second FFT would only have assigned values in “every other” frequency bin.

It would be easy to interpolate magnitude between the synthesis FFT’s frequency bins, but how could we interpolate phase values (or even gAnaFreq[] values) for the in-between FFT frequency bins that received no assignment? Your article makes it sound like we should see the same Estimated True Frequency values in adjacent bins of the analysis FFT, but as I examine gAnaFreq[] values from data of polyphonic music, this does not seem to be the case.

While it’s true that a reasonable signal can be synthesized with half of the second FFT frequency bins being empty, it seems that all the harmonic data of the original signal is not, and can not, be present.

If you have to reverse the subtraction you are most likely using a different FFT implementation or have a sign issue somewhere in your FFT code. If you use smbFft() you should get convergence with the code as it is – please let me know if you don’t, as this would be a bug (it seems to work ok on my test project on the Mac).

Thanks!
-Stephan

/* compute phase difference */
tmp = phase – gLastPhase[k];
to

/* compute phase difference */
tmp = gLastPhase[k] – phase;

to get the algorithm to work as it should. I get divergence in adjacent bins rather than convergence if I don’t.
Apart from that it’s wonderful stuff.

-P

Has anyone been able to develop a Java version for this code ?

Thank you.

I stopped at the deviation of the Kth partial’s phase from it’s bin frequency. Do you mean that if we devide the K’th partial to frame whose length is a multiple of the Kth bin frequency we can get the Kth partial’s true frequency from the deviation in phase from frame to frame?
Then I lost you on the computation of the true frequency when there is an overlap between frames.

so I just replaced this by:
//updated by asida [AT] centrum [DOT] cz
long eol = (long)(log((double)fftFrameSize)/log(2.0)+.5);
//for (k = 0, le = 2; k < (long)(log(fftFrameSize)/log(2.)+.5); k++) {
for (k = 0, le = 2; k < eol; k++) {

memmove(gOutputAccum, gOutputAccum+stepSize, fftFrameSize *sizeof(float));

Would it be?:

for(k=0; k<fftFrameSize; k++)
gOutputAccum[k] = gOutputAccum[k+stepSize];

Ill provide the java source once I can get it working.

Thanks.