CODEWITHSUNDEEP
iosobjective-caudiosignal-processingfft
codeman
codeman

Reputation: 9038

More precise frequency from FFT with pure sine tones

I'm currently using FFT code from here: https://github.com/syedhali/EZAudio/tree/master/EZAudioExamples/iOS/EZAudioFFTExample

Here's the code from the 2 relevant methods:

-(void)createFFTWithBufferSize:(float)bufferSize withAudioData:(float*)data {

  // Setup the length
  _log2n = log2f(bufferSize);

  // Calculate the weights array. This is a one-off operation.
  _FFTSetup = vDSP_create_fftsetup(_log2n, FFT_RADIX2);

  // For an FFT, numSamples must be a power of 2, i.e. is always even
  int nOver2 = bufferSize/2;

  // Populate *window with the values for a hamming window function
  float *window = (float *)malloc(sizeof(float)*bufferSize);
  vDSP_hamm_window(window, bufferSize, 0);
  // Window the samples
  vDSP_vmul(data, 1, window, 1, data, 1, bufferSize);
  free(window);

  // Define complex buffer
 _A.realp = (float *) malloc(nOver2*sizeof(float));
 _A.imagp = (float *) malloc(nOver2*sizeof(float));

}

-(void)updateFFTWithBufferSize:(float)bufferSize withAudioData:(float*)data {

  // For an FFT, numSamples must be a power of 2, i.e. is always even
  int nOver2 = bufferSize/2;

  // Pack samples:
  // C(re) -> A[n], C(im) -> A[n+1]
  vDSP_ctoz((COMPLEX*)data, 2, &_A, 1, nOver2);

  // Perform a forward FFT using fftSetup and A
  // Results are returned in A
  vDSP_fft_zrip(_FFTSetup, &_A, 1, _log2n, FFT_FORWARD);

  // Convert COMPLEX_SPLIT A result to magnitudes
  float amp[nOver2];
  float maxMag = 0;

  for(int i=0; i<nOver2; i++) {
    // Calculate the magnitude
    float mag = _A.realp[i]*_A.realp[i]+_A.imagp[i]*_A.imagp[i];
    maxMag = mag > maxMag ? mag : maxMag;
  }
  for(int i=0; i<nOver2; i++) {
    // Calculate the magnitude
    float mag = _A.realp[i]*_A.realp[i]+_A.imagp[i]*_A.imagp[i];
   // Bind the value to be less than 1.0 to fit in the graph
   amp[i] = [EZAudio MAP:mag leftMin:0.0 leftMax:maxMag rightMin:0.0 rightMax:1.0];
 }

I've modified the updateFFTWithBufferSize method above so that I could get the frequency in Hz like this:

for(int i=0; i<nOver2; i++) {
    // Calculate the magnitude
    float mag = _A.realp[i]*_A.realp[i]+_A.imagp[i]*_A.imagp[i];
    if(maxMag < mag) {
        _i_max = i;
    }
    maxMag = mag > maxMag ? mag : maxMag;
}

float frequency = _i_max / bufferSize * 44100;
NSLog(@"FREQUENCY: %f", frequency);

I've generated a few pure sine tones with Audacity at different frequencies to test with. The issue I'm seeing is that the code is returning the same frequency for two different sine tones that are relatively close in value.

For example: A sine tone generated at 19255Hz will show up from FFT as 19293.750000Hz. So will a sine tone generated at 19330Hz. Something must be off in the calculations.

Any assistance in how I can modify the above code to get a more precise FFT frequency reading for pure sine tones is greatly appreciated. Thank you!

Upvotes: 0

Views: 1168

Answers (4)

tom10
tom10

Reputation: 69242

You've got a number of problems going on here:

1) Your frequency axis spacing is fmax/N, or about 80Hz, so you're not going to get a resolution much better than that.

2) You're signal is very close to the Nyquist frequency (ie, 20KHz/44.1KHz is almost 0.5), and when you're this close to the Nyquist limit you need to be very careful if you want accurate results. (That is, at 20KHz, you're only recording about two data points for each full oscillation cycle.)

3) Since 20KHz is at the edge of human hearing (and higher for most people), many microphones don't really worry about it. Here's a measurement for the iPhone.

Upvotes: 1

MSalters
MSalters

Reputation: 179991

The FFT is a very good method to get a spectrum if you don't know anything about the input. If you know that the input is a pure sine wave, you can do much better. Start off by calculating the FFT to get a rough idea where the sine is. Get the minimum and maximum to estimate the amplitude [or get that from the FFT - square all inputs, add them, take square root] , get the phase at the begin and end given the estimated frequency and amplitude.

In general, you'll find that the phase does not match. That's because the phase at the end is off by 2*Δf * N. f - Δf is a better estimate of the frequency. Keep in mind that such a method is super noise sensitive. The method works because the input is a pure sine wave, and noise is everything but that. Using this method iteratively blows up quickly; you even hit rounding errors (not sinusoidal either)

Another similar trick is subtracting the estimated wave. The difference between two sines is the product of two sines, one with the frequencies added (in your case, ±38.5 kHz) and one with the frequencies subtracted (Δ_f_, less than 100 Hz). See also Heterodyne detection

Upvotes: 0

hotpaw2
hotpaw2

Reputation: 70733

You can get a rough frequency estimate by fitting a parabolic curve to the 3 FFT bin magnitudes around the peak magnitude bin, and then finding the extrema of that parabola.

A better estimate can be created by using the transform of your FFT window as an interpolation kernel, and doing successive approximation to refine an estimate of the maxima of the interpolated points. (Zero padding and using a much longer FFT will give you a similar type of interpolated estimate.)

The easy way for a stationary signal is, if possible, to just use a longer FFT with more samples that span a longer time interval.

Upvotes: 1

Duncan C
Duncan C

Reputation: 131471

Perhaps your sampling frequency isn't high enough?

Upvotes: 0

Related Questions