Code Log

// Constructs an FFT that will accept sample buffers 
// that are timeSize long and have been recorded 
// with a sample rate of sampleRate. 
// timeSize must be a power of two. 
// This will throw an exception if it is not.
FFT(int timeSize, float sampleRate)

// Performs a forward transform on buffer.
forward(float[] buffer)
// Returns the size of the spectrum created by this transform.
// In other words, the number of frequency bands produced by this transform. 
// This is typically equal to timeSize()/2 + 1, see above for an explanation.
int specSize()
// Returns the amplitude of the requested frequency band.
float getBand(int i) 
// Gets the amplitude of the requested frequency (Hz) in the spectrum.
float getFreq(float freq)  
// Returns the index of the frequency band that contains the requested frequency.
int freqToIndex(float freq)

fft.forward(audio.left);
for (int i = 0; i < fft.specSize(); i++)
{
   // draw the line for frequency band i, 
   // scaling it by 4 so we can see it a bit better
   line(i, height, i, height - fft.getBand(i) * 4);
}

// A constant indicating no window
static int NONE
// A constant indicating a Hamming window
static int HAMMING
// Sets the window to use on the samples 
// before taking the forward transform.
window(int which)

import ddf.minim.analysis.*;
import ddf.minim.*;
 
AudioPlayer jingle;
FFT fft;
String windowName;
 
void setup()
{
  size(512, 200);
  // always start Minim before you do anything with it
  Minim.start(this);
  jingle = Minim.loadFile("jingle.mp3");
  jingle.loop();
  // create an FFT object that has a time-domain 
  // buffer the same size as jingle's sample buffer
  // note that this needs to be a power of two 
  // and that it means the size of the spectrum will be 512.
  fft = new FFT(jingle.left.size(), 44100);
  textFont(createFont("Arial", 16));
  windowName = "None";
}
 
void draw()
{
  background(0);
  stroke(255);
  // perform a forward FFT on the samples in jingle's left buffer
  // note that if jingle were a MONO file, 
  // this would be the same as using jingle.right or jingle.mix
  fft.forward(jingle.left);
  for(int i = 0; i < fft.specSize(); i++)
  {
    // draw the line for frequency band i, 
    // scaling it by 4 so we can see it a bit better
    line(i, height, i, height - fft.getBand(i)*4);
  }
  fill(255);
  // keep us informed about the window being used
  text("The window being used is: " + windowName, 5, 20);
}
 
void keyReleased()
{
  if ( key == 'w' ) 
  {
    // a Hamming window can be used to shape 
    // the sample buffer that is passed to the FFT
    // this can reduce the amount of noise in the spectrum
    fft.window(FFT.HAMMING);
    windowName = "Hamming";
  }
 
  if ( key == 'e' ) 
  {
    fft.window(FFT.NONE);
    windowName = "None";
  }
}
 
void stop()
{
  // always close Minim audio classes when you finish with them
  jingle.close();
  // always stop Minim before exiting
  Minim.stop();
 
  super.stop();
}

// Sets the number of averages used when computing 
// the spectrum and spaces the averages in a linear manner.
void linAverages(int numAvg)
// Sets the number of averages used when computing
// the spectrum based on the minimum bandwidth for an octave           
// and the number of bands per octave.
void logAverages(int minBandwidth, int bandsPerOctave)          
// Sets the object to not compute averages.
void noAverages()          
// Gets the value of the ith average.
float getAvg(int i)
// Returns the number of averages currently being calculated.
int avgSize()
// Calculate the average amplitude of the 
// frequency band bounded by lowFreq and hiFreq, inclusive.
float calcAvg(float lowFreq, float hiFreq)

import ddf.minim.analysis.*;
import ddf.minim.*;
 
AudioPlayer jingle;
FFT fftLin;
FFT fftLog;
float height3;
float height23;
 
void setup()
{
  size(512, 300);
  height3 = height/3;
  height23 = 2*height/3;
  // always start Minim before you do anything with it
  Minim.start(this);
  // load jingle.wav from the data folder, default buffer length is 1024
  jingle = Minim.loadFile("jingle.mp3");
  // loop the file
  jingle.loop();
  // create an FFT object that has a time-domain buffer 
  // the same size as jingle's sample buffer
  // note that this needs to be a power of two 
  // and that it means the size of the spectrum will be 512. 
  fftLin = new FFT(jingle.bufferSize(), jingle.sampleRate());
  // calculate the averages by grouping 
  // frequency bands linearly. use 30 averages.
  fftLin.linAverages(30);
  fftLog = new FFT(jingle.bufferSize(), jingle.sampleRate());
  // calculate averages based on a miminum octave width of 22 Hz
  // split each octave into three bands
  // this should result in 30 averages
  fftLog.logAverages(22, 3);
  rectMode(CORNERS);
}
 
void draw()
{
  background(0);
  // perform a forward FFT on the samples in jingle's mix buffer
  // note that if jingle were a MONO file, 
  // this would be the same as using jingle.left or jingle.right
  fftLin.forward(jingle.mix);
 
  stroke(255);
  noFill();
  // draw the full spectrum
  for(int i = 0; i < fftLin.specSize(); i++)
  {
    line(i, height3, i, height3 - fftLin.getBand(i)*2);
  }
 
  noStroke();
  fill(255);
  // draw the linear averages
  int w = int(width/fftLin.avgSize());
  for(int i = 0; i < fftLin.avgSize(); i++)
  {
    // draw a rectangle for each average, 
    // multiply the value by 5 so we can see it better
    rect(i*w, height23, i*w + w, height23 - fftLin.getAvg(i)*5);
  }
 
  // draw the logarithmic averages
  fftLog.forward(jingle.mix);
  w = int(width/fftLog.avgSize());
  for(int i = 0; i < fftLog.avgSize(); i++)
  {
    // draw a rectangle for each average, 
    // multiply the value by 5 so we can see it better
    rect(i*w, height, i*w + w, height - fftLog.getAvg(i));
  }
}
 
void stop()
{
  // always close Minim audio classes when you are done with them
  jingle.close();
  // always stop Minim before exiting
  Minim.stop();
 
  super.stop();
}

// Performs an inverse transform of the 
// frequency spectrum and places the result in buffer.
void inverse(AudioBuffer buffer)
// Returns the length of the time domain signal
// generated by inverse
int timeSize()     
// Sets the amplitude of the requested frequency in the spectrum to a.
void setFreq(float freq, float a)
// Scales the amplitude of the requested frequency by a.
void scaleFreq(float freq, float s)
// Sets the amplitude of the ith frequency band to a.
void setBand(int i, float a)
// Scales the amplitude of the ith frequency band by s.
void scaleBand(int i, float s)

import ddf.minim.analysis.*;
import ddf.minim.signals.*;
 
FFT fft;
SineWave sine;
float[] buffer;
int bsize = 512;
 
void setup()
{
  size(512, 300);
  // create an FFT with a time-domain size the same as the size of buffer
  // it is required that these two values be the same
  // and also that the value is a power of two
  fft = new FFT(bsize, 44100);
  sine = new SineWave(600, 1, 44100);
  buffer = new float[bsize];
  // fill the buffer with a sine wave
  sine.generate(buffer);
}
 
void draw()
{
  background(0);
  noStroke();
  fill(255, 128);
  // draw the waveform
  for(int i = 0; i < buffer.length; i++)
  {
    ellipse(i, 50 + buffer[i]*10, 2, 2);
  }
  noFill();
  stroke(255);
  // draw the spectrum
  for(int i = 0; i < fft.specSize(); i++)
  {
    line(i, height, i, height - fft.getBand(i));
  }
  stroke(255, 0, 0);
  line(width/2, height, width/2, 0);
}
 
 
void keyReleased()
{
  if ( key == 'f' ) 
  {
    println("Performing a Forward FFT on buffer.");
    fft.forward(buffer);
  }
  if ( key == 'd' ) 
  {
    println("Performing an Inverse FFT and putting the result in buffer.");
    fft.inverse(buffer);
  }
  if ( key == 's' )
  {
    // by setting frequency band 20 to a high value, 
    // we are basically mixing in a sine wave at that frequency
    // after setting the frequency band and then taking the inverse FFT, 
    // you will see the waveform change
    println("Setting frequency band 20 to 150.");
    fft.setBand(20, 150);
  }
}