HelpSource/Classes/FFT.schelp

   1 class:: FFT
   2 summary:: Fast Fourier Transform
   3 related:: Classes/IFFT, Guides/FFT-Overview
   4 categories:: UGens>FFT
   5
   6 Description::
   7
   8 The fast fourier transform analyzes the frequency content of a signal, which can be useful for audio analysis or for frequency-domain sound processing (phase vocoder).
   9
  10 classmethods::
  11
  12 method::new
  13
  14 argument::buffer
  15 A buffer to store spectral data. The buffer's size must
  16 correspond to a power of 2. LocalBuf is useful here, because processes should not share data between synths. (Note: most PV UGens operate on this data in place. Use PV_Copy for parallel processing.)
  17
  18 argument::in
  19 The signal to be analyzed. The signal's rate determines the rate at which the input is read.
  20
  21 argument:: hop
  22 The amount of offset from the beginning of one FFT analysis frame to the next, measured in multiples of the analysis frame size. This can range between 1.0 and values close to (but larger than) 0.0, and the default is 0.5 (meaning each frame has a 50% overlap with the preceding/following frames).
  23
  24 argument:: wintype
  25 Defines how the data is windowed:
  26 table::
  27 ## -1 || strong::rectangular:: windowing, simple but typically not recommended;
  28 ## 0 || (the default) strong::Sine:: windowing, typically recommended for phase-vocoder work;
  29 ## 1 || strong::Hann:: windowing, typically recommended for analysis work.
  30 ::
  31
  32 argument:: active
  33 A simple control allowing FFT analysis to be active (>0) or inactive (<=0). This is mainly useful for signal analysis processes which are only intended to analyse at specific times rather than continuously
  34
  35 argument:: winsize
  36 The windowed audio frames are usually the same size as the buffer. If you wish the FFT to be zero-padded then you can specify a window size smaller than the actual buffer size (e.g. window size 1024 with buffer size 2048). Both values must still be a power of two. Leave this at its default of zero for no zero-padding.
  37
  38 returns::
  39 The FFT chain
  40
  41 discussion::
  42 Only the first two arguments are required. The remaining arguments allow for custom FFT analyses for specialised situations.
  43
  44 FFT uses a local buffer for holding the buffered audio. The buffer size must be a multiple of the control block size as well as being a power of two.
  45
  46 Note that for phase-vocoder usage, changing the hop or wintype settings from their defaults will typically result in unnatural sound when used in combination with IFFT, due to windowing artifacts. (A hop of 0.25, with Hann windowing, can be a useful combination for phase-vocoder work.)
  47
  48
  49 Examples::
  50
  51 code::
  52 (
  53 {
  54         var in, chain;
  55         in = WhiteNoise.ar(0.1);
  56         chain = FFT(LocalBuf(2048), in);
  57         IFFT(chain) // inverse FFT
  58 }.play;
  59 )
  60
  61 // hinspecting it, we see that the chain is an FFT:
  62 (
  63 {
  64         var in, chain;
  65         in = WhiteNoise.ar(0.1);
  66         chain = FFT(LocalBuf(2048), in);
  67         chain.inspect;
  68         IFFT(chain) // inverse FFT
  69 }.play;
  70 )
  71
  72 (
  73 {
  74         var in, chain;
  75         in = SinOsc.ar(SinOsc.kr(SinOsc.kr(0.08,0,6,6.2).squared, 0, 100, 800));
  76         chain = FFT(LocalBuf(2048), in);
  77         IFFT(chain)
  78 }.play;
  79 )
  80
  81 (
  82 {
  83         var in, chain;
  84         in = SinOsc.ar(SinOsc.kr(SinOsc.kr(0.08,0,6,6.2).squared, 0, 100,800));
  85         //in = WhiteNoise.ar(0.2);
  86         chain = FFT(LocalBuf(2048), in);
  87         chain = PV_MagAbove(chain, 310);
  88         0.5 * IFFT(chain);
  89 }.play;
  90 )
  91
  92 (
  93 {
  94         var in, chain;
  95         in = WhiteNoise.ar(0.2);
  96         chain = FFT(LocalBuf(2048), in);
  97         chain = PV_BrickWall(chain, SinOsc.kr(0.1));
  98         IFFT(chain)
  99 }.play;
 100 )
 101
 102 (
 103 {
 104         var in, chain;
 105         in = WhiteNoise.ar(0.8);
 106         chain = FFT(LocalBuf(2048), in);
 107         chain = PV_RandComb(chain, 0.95, Impulse.kr(0.4));
 108         IFFT(chain)
 109 }.play;
 110 )
 111
 112 (
 113 {
 114         var in, chain;
 115         in = WhiteNoise.ar(0.2);
 116         chain = FFT(LocalBuf(2048), in);
 117         chain = PV_RectComb(chain, 8, LFTri.kr(0.097,0,0.4,0.5),
 118                 LFTri.kr(0.24,0,-0.5,0.5));
 119         IFFT(chain)
 120 }.play;
 121 )
 122
 123 (
 124 {
 125         var in, chain;
 126         in = SinOsc.ar(LFNoise1.kr(5.2,250,400));
 127         chain = FFT(LocalBuf(2048), in);
 128         // moves in and out of freeze
 129         chain = PV_MagFreeze(chain, SinOsc.kr(0.2) );
 130         0.5 * IFFT(chain);
 131 }.play;
 132 )
 133
 134
 135 // stereo example:
 136
 137 (
 138 {
 139         var in, chain;
 140         in = SinOsc.ar(LFNoise1.kr([5.2, 3.3],250,400));
 141         chain = FFT({ LocalBuf(2048) } ! 2, in); // we need two buffers for stereo input.
 142         // moves in and out of freeze
 143         chain = PV_MagFreeze(chain, SinOsc.kr([0.2, 0.3]) );
 144         0.5 * IFFT(chain);
 145 }.play;
 146 )
 147
 148 ::
 149