HelpSource/Classes/UnpackFFT.schelp

   1 class:: UnpackFFT
   2 summary:: Unpack an FFT chain into separate demand-rate FFT bin streams
   3 categories:: UGens>FFT
   4 related:: Classes/PackFFT, Classes/Unpack1FFT
   5
   6 description::
   7 Takes an FFT chain and separates the magnitude and phase data into separate demand-rate streams, for arithmetic manipulation etc.
   8
   9 This is technically a demand-rate UGen. The actual "demand" is usually created by PackFFT later on in the graph, which requests the values in order to re-pack the data. This allows for processing to occur imbetween...
  10
  11 See also pvcollect, pvcalc and pvcalc2 methods ( in link::Classes/PV_ChainUGen:: ) which provide convenient ways to process audio in the frequency domain. The help for pvcollect includes notes on efficiency considerations.
  12
  13 classmethods::
  14 private:: categories
  15
  16 method:: new
  17 argument:: chain
  18 FFT chain
  19 argument:: bufsize
  20 FFT buffer size
  21 argument:: frombin
  22 limiting analysis to the bins of interest
  23 argument:: tobin
  24 limiting analysis to the bins of interest
  25 returns::
  26 A list from DC up to Nyquist of code:: [mag[0], phase[0], mag[1], phase[1], ... mag[nyquist], phase[nyquist]]. ::
  27 discussion::
  28 Note that you do have to decide your FFT buffer size in advance, since this determines how many values the UGen will output.
  29 code::
  30 #magsphases = UnpackFFT(chain, bufsize)
  31 ::
  32
  33 examples::
  34 code::
  35 (
  36 s.boot.doWhenBooted {
  37         var fftsize = 1024;
  38         b = Buffer.alloc(s, fftsize, 1);
  39         c = Buffer.read(s, Platform.resourceDir +/+ "sounds/a11wlk01.wav");
  40 }
  41 )
  42
  43 // This one just drags out various the values and posts them - a little bit pointless!
  44 (
  45 x = {
  46         var sig, chain, unp;
  47         sig = SinOsc.ar;
  48         sig = PlayBuf.ar(1, c, BufRateScale.kr(c), loop: 1);
  49         chain = FFT(b, sig);
  50
  51         // Using the frombin & tobin args makes it much more efficient, limiting analysis to the bins of interest
  52         unp = UnpackFFT(chain, b.numFrames, frombin: 0, tobin: 4);
  53
  54         // Demand some data from the unpacker.
  55         // NOTE: At present, Demand.kr is unable to handle more than 32 inputs,
  56         // so using frombin & tobin to limit the number of bins is compulsory.
  57         Demand.kr(chain>=0, 0, unp).collect{|anunp, index|
  58                 anunp.poll(chain>=0, if(index % 2 == 0,  "Magnitude", "Phase")+(index/2).floor);
  59         };
  60
  61         (sig*0.1).dup;
  62 }.play(s);
  63 )
  64 x.free;
  65
  66 // Now a simple frequency-domain manipulation, square-rooting the magnitudes AND phases.
  67 (
  68 x = {
  69         var in, chain, magsphases;
  70         in = PlayBuf.ar(1, c, BufRateScale.kr(c), loop: 1);
  71         chain = FFT(b, in);
  72         magsphases = UnpackFFT(chain, b.numFrames);
  73         magsphases = magsphases.collect(_.sqrt);
  74         PackFFT(chain, b.numFrames, magsphases);
  75         Out.ar(0, 0.25 * IFFT(chain).dup);
  76 }.play(s);
  77 )
  78 x.free;
  79 ::
  80