HelpSource/Guides/FFT-Overview.schelp

   1 title:: FFT Overview
   2 summary:: Overview of FFT UGens
   3 categories:: UGens>FFT
   4 related:: Classes/FFT, Classes/IFFT
   5
   6 section:: FFT and IFFT
   7
   8 SuperCollider implements a number of UGens supporting FFT based processing. The most basic of these are FFT and IFFT which convert data between the time and frequency domains:
   9 code::
  10 chain = FFT(buffer, input)
  11 ::
  12 code::
  13 output = IFFT(chain)
  14 ::
  15 link::Classes/FFT:: stores spectral data in a local buffer ( see link::Classes/Buffer:: ) in the following order: DC, nyquist, real 1f, imag 1f, real 2f, imag 2f, ... real (N-1)f, imag (N-1)f, where f is the frequency corresponding to the window size, and N is the window size / 2.
  16
  17 The buffer's size must correspond to a power of 2, and must also be a multiple of SC's block size. The window size is equivalent to the buffer size, and the window overlap defaults to 2. Both link::Classes/FFT:: and link::Classes/IFFT:: use a Sine window by default, the combination of which (i.e. raised sine, that is, sine squared) is a Hanning window.
  18
  19 section:: Phase Vocoder UGens and Spectral Processing
  20
  21 In between an FFT and an IFFT one can chain together a number of Phase Vocoder UGens (i.e. 'PV_...') to manipulate blocks of spectral data before reconversion. The process of buffering the appropriate amount of audio, windowing, conversion, overlap-add, etc. is handled for you automatically.
  22 code::
  23 (
  24 { var in, chain;
  25         in = WhiteNoise.ar(0.8);
  26         chain = FFT(LocalBuf(2048), in);
  27         chain = PV_RandComb(chain, 0.95, Impulse.kr(0.4));
  28         IFFT(chain);
  29 }.play(s);
  30 )
  31 ::
  32
  33 PV Ugens write their output data emphasis:: in place ::, i.e. back into the same buffer from which they read. PV UGens which require two buffers write their data into the first buffer, usually called 'bufferA'.
  34 code::
  35 d = Buffer.read(s, Help.dir +/+ "sounds/a11wlk01.wav");
  36
  37 (
  38 { var inA, chainA, inB, chainB, chain;
  39         inA = LFSaw.ar([100, 150], 0, 0.2);
  40         inB = PlayBuf.ar(1, d, BufRateScale.kr(d), loop: 1);
  41         chainA = FFT(LocalBuf(2048), inA);
  42         chainB = FFT(LocalBuf(2048), inB);
  43         chain = PV_MagMul(chainA, chainB); // writes into bufferA
  44         0.1 * IFFT(chain);
  45 }.play(s);
  46 )
  47
  48 d.free;
  49 ::
  50
  51 Because each PV UGen overwrites the output of the previous one, it is necessary to copy the data to an additional buffer at the desired point in the chain in order to do parallel processing of input without using multiple FFT UGens. link::Classes/PV_Copy:: allows for this.
  52 code::
  53 (
  54 b = Buffer.alloc(s,2048,1); // use global buffers for plotting the data
  55 c = Buffer.alloc(s,2048,1);
  56 )
  57
  58 //// proof of concept
  59 (
  60 x = { var inA, chainA, chainB;
  61     inA = LFClipNoise.ar(100);
  62     chainA = FFT(b, inA);
  63     chainB = PV_Copy(chainA, c);
  64     IFFT(chainA) - IFFT(chainB); // cancels to zero so silent!
  65 }.play(s);
  66 )
  67 x.free;
  68 // IFFTed frames contain the same windowed output data
  69 b.plot(\b, Rect(200, 430, 700, 300), nil, nil); c.plot(\c, Rect(200, 100, 700, 300), nil, nil);
  70 [b, c].do(_.free);
  71 ::
  72
  73 Note that PV UGens convert as needed between cartesian (complex) and polar representations, therefore when using multiple PV UGens it may be impossible to know in which form the values will be at any given time. FFT produces complex output (see above), so while the following produces a reliable magnitude plot:
  74 code::
  75 b = Buffer.alloc(s,1024); // use global buffers for plotting the data
  76 a = { FFT(b, LFSaw.ar(4000)); 0.0 }.play;
  77 (
  78 b.getn(0, 1024, { arg buf;
  79         var z, x;
  80         z = buf.clump(2).flop;
  81         z = [Signal.newFrom(z[0]), Signal.newFrom(z[1])];
  82         x = Complex(z[0], z[1]);
  83         {x.magnitude.plot}.defer
  84 })
  85 )
  86 a.free; b.free;
  87 ::
  88 any Synth using PV UGens might not.
  89
  90 It is possible to manipulate the FFT data directly within a synth graph (if there doesn't already exist a PV UGen which will do what you want), using the methods pvcalc, pvcalc2, pvcollect. Here's an example which uses the link::Classes/SequenceableCollection:: methods clump and flop to rearrange the order of the spectral bins:
  91 code::
  92 c = Buffer.read(s, Help.dir +/+ "sounds/a11wlk01.wav");
  93
  94 (
  95 x = {
  96   var in, numFrames=2048, chain, v;
  97   in = PlayBuf.ar(1, c, loop: 1);
  98   chain = FFT(LocalBuf(numFrames), in);
  99
 100   chain = chain.pvcalc(numFrames, {|mags, phases|
 101       /* Play with the mags and phases, then return them */
 102       [mags, phases].flop.clump(2).flop.flatten
 103   }, tobin: 250);
 104
 105   Out.ar(0, 0.5 * IFFT(chain).dup);
 106 }.play(s);
 107 )
 108 x.free; c.free;
 109 ::
 110
 111 section:: Multichannel Expansion with FFT UGens
 112
 113 Care must be taken when using multichannel expansion with FFT UGens, as they require separate buffers. Code such as this can be deceptive:
 114 code::
 115 chain = FFT(bufnum, {WhiteNoise.ar(0.2)}.dup);
 116 ::
 117
 118 The above may seem to work, but does not. It does result in two FFT UGens, but as they both write to the same buffer, the second simply overwrites the data from the first, thus wasting CPU and accomplishing nothing.
 119
 120 When using multichannel expansion with FFT UGens it is necessary to ensure that each one writes to a different buffer. Here's an example of one way to do this:
 121 code::
 122 (
 123 SynthDef("help-multichannel FFT", { arg out=0; // bufnum is an array
 124         var in, chain;
 125         in = [SinOsc.ar(200, 0, 0.2), WhiteNoise.ar(0.2)];
 126         chain = FFT(LocalBuf([2048, 2048]), in); // each FFT has a different buffer
 127         // now we can multichannel expand as normal
 128         chain = PV_BrickWall(chain, SinOsc.kr(-0.1));
 129         Out.ar(out, IFFT(chain));
 130 }).play;
 131 )
 132
 133 // or using global buffers
 134
 135 b = {Buffer.alloc(s,2048,1)}.dup;
 136
 137 (
 138 SynthDef("help-multichannel FFT", { arg out=0, bufnum= #[0, 1]; // bufnum is an array
 139         var in, chain;
 140         in = [SinOsc.ar(200, 0, 0.2), WhiteNoise.ar(0.2)];
 141         chain = FFT(bufnum, in); // each FFT has a different buffer
 142         // now we can multichannel expand as normal
 143         chain = PV_BrickWall(chain, SinOsc.kr(-0.1));
 144         Out.ar(out, IFFT(chain));
 145 }).play(s,[\bufnum, b]);
 146 )
 147 ::
 148
 149 Note that dup on a UGen just makes a reference to that UGen, because UGen defines -copy to simply return the receiver. (See link::Classes/UGen:: for more detail.)
 150 code::
 151 a = SinOsc.ar;
 152 a.dup[1] === a
 153
 154 true
 155 ::
 156 Code like code::IFFT(chain).dup:: is found throughout the PV help files , and is just a convenient way to copy a mono signal to stereo, without further computation.
 157
 158 See also link::Guides/Multichannel-Expansion::.
 159
 160 section:: PV and FFT UGens in the Standard Library
 161
 162 The following PV UGens are included in the standard SC distribution:
 163 definitionlist::
 164 ## link::Classes/FFT:: || Fast Fourier Transform
 165 ## link::Classes/IFFT:: || Inverse Fast Fourier Transform
 166 ## link::Classes/PV_Add:: || complex addition
 167 ## link::Classes/PV_BinScramble:: || scramble bins
 168 ## link::Classes/PV_BinShift:: || shift and stretch bin position
 169 ## link::Classes/PV_BinWipe:: || combine low and high bins from two inputs
 170 ## link::Classes/PV_BrickWall:: || zero bins
 171 ## link::Classes/PV_ConformalMap:: || complex plane attack
 172 ## link::Classes/PV_Copy:: || copy an FFT buffer
 173 ## link::Classes/PV_CopyPhase:: || copy magnitudes and phases
 174 ## link::Classes/PV_Diffuser:: || random phase shifting
 175 ## link::Classes/PV_HainsworthFoote:: || onset detection
 176 ## link::Classes/PV_JensenAndersen:: || onset detection
 177 ## link::Classes/PV_LocalMax:: || pass bins which are a local maximum
 178 ## link::Classes/PV_MagAbove:: || pass bins above a threshold
 179 ## link::Classes/PV_MagBelow:: || pass bins below a threshold
 180 ## link::Classes/PV_MagClip:: || clip bins to a threshold
 181 ## link::Classes/PV_MagFreeze:: || freeze magnitudes
 182 ## link::Classes/PV_MagMul:: || multiply magnitudes
 183 ## link::Classes/PV_MagDiv:: || division of magnitudes
 184 ## link::Classes/PV_MagNoise:: || multiply magnitudes by noise
 185 ## link::Classes/PV_MagShift:: || shift and stretch magnitude bin position
 186 ## link::Classes/PV_MagSmear:: || average magnitudes across bins
 187 ## link::Classes/PV_MagSquared:: || square magnitudes
 188 ## link::Classes/PV_Max:: || maximum magnitude
 189 ## link::Classes/PV_Min:: || minimum magnitude
 190 ## link::Classes/PV_Mul:: || complex multiply
 191 ## link::Classes/PV_PhaseShift:: || shift phase of all bins
 192 ## link::Classes/PV_PhaseShift270:: || shift phase by 270 degrees
 193 ## link::Classes/PV_PhaseShift90:: || shift phase by 90 degrees
 194 ## link::Classes/PV_RandComb:: || pass random bins
 195 ## link::Classes/PV_RandWipe:: || crossfade in random bin order
 196 ## link::Classes/PV_RectComb:: || make gaps in spectrum
 197 ## link::Classes/PV_RectComb2:: || make gaps in spectrum
 198 ## link::Classes/UnpackFFT::, link::Classes/PackFFT::, link::Classes/Unpack1FFT:: || "unpacking" components used in pvcalc, pvcalc2, pvcollect (can also be used on their own)
 199 ::
 200 For a full list of FFT UGens, see strong::UGens>FFT:: in the link::Browse#UGens>FFT:: page.
 201