Hi Jim,

I'm doing something similar with Minim and Octave (or Matlab) running on Processing 1.5 in Ubuntu (v2.0 alpha locks up for me).

My scheme is to analyze a 2-D matrix for frequency analysis over time. 
(1) set up a audio buffer with a N x M matrix, and fill it up
      (to do this efficiently, I would want to avoid recreating the buffer, and instead keep track of the latest line)
(2) set up a N x M buffer to hold FFT analysis (actually I'd only need a N/2 x M matrix)
(3) Try to match with reasonable confidence the features in the FFT analysis.

To try to identify the salient features I started up Octave and ran:

1. octave> A = wavread('audio.wav');
2. octave> disp(size(A));
3. % size(A) will return a vector, in my case it was divisible by 480 samples, so I reshaped 480x604;
4. octave> C = reshape(A,[480,604]);
5. octave> figure; imagesc(abs(C)); set(gca,'YDir','normal'); ylim([0,240])
   
6. octave> D = fft(C); 
7. octave> figure; imagesc(log(abs(D))); set(gca,'YDir','normal'); ylim([0,240])
   

This produced some nifty audio and fourier plots that i can use to visualize sound as frequency over time.
The y axis should be frequency, but I haven't gotten around to writing the conversion from fft frequency (in samples) to fft frequency (in hertz).

To just plot the audio and FFT and in Minim, I reused an example library:

1. import ddf.minim.*;
2. import ddf.minim.analysis.*;
3. Minim minim;
4. AudioInput in;
5. FFT fft;
6. int highest = 0;
7. int bsize = 512;
8. void setup() {
9.   size(512, 200, P2D);
10.   minim = new Minim(this);
11.   minim.debugOn();
12.   // get a line in from Minim, default bit depth is 16
13.   in = minim.getLineIn(Minim.MONO, bsize, 44100);
14.   fft = new FFT(in.left.size(),44100);
15.   fft.window(FFT.HAMMING); //method
16. }
17. void draw() {
18.   background(0);
19.   stroke(255);
20.   fft.forward(in.left);
21.   highest = 0;
22.   long sum = 0;
23.   for(int n = 0; n < fft.specSize(); n++)
24.       sum += fft.getBand(n);
25.   for(int n = 0; n < fft.specSize(); n++) {
26.       // draw the line for frequency
27.       line(n,height,n,height-fft.getBand(n)*120);
28. 
    
29.       if(fft.getBand(n)>fft.getBand(highest))
30.         highest = n;
31.   }
32.   stroke(0,0,255);
33.   line(highest,height,highest,height-fft.getBand(highest)*4);
34. 
    
35.   // draw the waveforms
36.   for(int i = 0; i < in.bufferSize() - 1; i++)
37.   {
38.     line(i, 50 + in.left.get(i)*50, i+1, 50 + in.left.get(i+1)*50);
39.     line(i, 150 + in.right.get(i)*50, i+1, 150 + in.right.get(i+1)*50);
40.   }
41. }
42. 
    
43. void stop()
44. {
45.   // always close Minim audio classes when you are done with them
46.   in.close();
47.   minim.stop();
48.   super.stop();
49. }