Skip to main content
Email Password   helpLost your password?

Sample Image - waveInFFT.jpg

Sample Image - waveInFFT_microeq.jpg

Sample Image - waveInFFT_Oscilliscope.jpg

Sample Image - waveInFFT_peak.jpg

Sample Image - waveInFFT_peakalt.jpg

Sample Image - waveInFFT_PixelGram.jpg

Sample Image - waveInFFT_spectrum.jpg

Introduction

The Fast Fourier Transform (FFT) allows users to view the spectrum content of an audio signal. The FFT code presented here was written by Don Cross, his homepage appears to have subsequently been taken down. Rather than explain the mathematical theory of the FFT, I will attempt to explain its usefulness as it relates to audio signals.

The FFT allows users to obtain the spectral makeup of an audio signal, obtain the decibels of its various frequencies, or obtain the intensity of its various frequencies. Spectral viewers (shown in the image above), Equalizers, or VU-Meters may all use the FFT in order to display their results. The difference between them then depends upon one of a couple of equations that take the real and imaginary components of the FFT, and return either the intensity or decibel levels to be used in the graphed result. The following code takes both the real and imaginary components of the FFT result, and returns the intensity and decibels.

inline double GetFrequencyIntensity(double re, double im)
{
    return sqrt((re*re)+(im*im));
}
#define mag_sqrd(re,im) (re*re+im*im)
#define Decibels(re,im) ((re == 0 && im == 0) ? (0) : 
        10.0 * log10(double(mag_sqrd(re,im))))
#define Amplitude(re,im,len) (GetFrequencyIntensity(re,im)/(len))
#define AmplitudeScaled(re,im,len,scale) ((int)Amplitude(re,im,len)%scale)

The FFT uses the audio signal as its real component, and uses a NULL pointer for its imaginary component indicating that the imaginary data does not exist. Upon its return, the FFT will return both the real and imaginary data components based upon the data given as the real component. The is mirrored with the return samples so that 0-FFT_LEN/2 contains the data, and FFT_LEN/2 to FFT_LEN contains a reverse of the data. This mistake was corrected in my code. The code that performs the FFT follows:

    DWORD nCount = 0;
    for (DWORD dw = 0; dw < FFT_LEN; dw++)
    {
        {
            //copy audio signal to fft real component for left channel

            finleft[nCount] = (double)((short*)pwh->lpData)[dw++];
            //copy audio signal to fft real component for right channel

            finright[nCount++] = (double)((short*)pwh->lpData)[dw];
        }
    }
    //Perform FFT on left channel

    fft_double(FFT_LEN/2,0,finleft,NULL,fout,foutimg);
    float re,im,fmax=-99999.9f,fmin=99999.9f;
    for(int i=1;i < FFT_LEN/4-1;i++)
    //Use FFT_LEN/4 since the data is mirrored within the array.

    {
        re = fout[i];
        im = foutimg[i];
        //get amplitude and scale to 0..256 range

        fdraw[i]=AmplitudeScaled(re,im,FFT_LEN/2,256);
        if (fdraw[i] > fmax)
        {
            fmax = fdraw[i];
        }
        if (fdraw[i] < fmin)
        {
            fmin = fdraw[i];
        }
    }
    //Use this to send the average band amplitude to something

    int nAvg, nBars=16, nCur = 0;
    for(int i=1;i < FFT_LEN/4;i++)
    {
        nAvg = 0;
        for (int n=0; n < nBars; n++)
        {
            nAvg += (int)fdraw[i];
        }
        nAvg /= nBars;
        //Send data here to something,

        //nothing to send it to so we print it.

        TRACE("Average for Bar#%d is %d\n",nCur++,nAvg);
        i+=nBars-1;
    }
    DataHolder* pDataHolder = (DataHolder*)lpData;
    // Draw left channel

    CFrequencyGraph* pPeak = (CFrequencyGraph*)pDataHolder->pData;
    if (::IsWindow(pPeak->GetSafeHwnd()))
    {
        pPeak->SetYRange(0,256);
        pPeak->Update(FFT_LEN/4,fdraw);
    }
    
    // Perform FFT on right channel

    fmax=-99999.9f,fmin=99999.9f;
    fft_double(FFT_LEN/2,0,finright,NULL,fout,foutimg);
    fdraw[0] = fdraw[FFT_LEN/4] = 0;
    for(i=1;i < FFT_LEN/4-1;i++)
    //Use FFT_LEN/4 since the data is mirrored within the array.

    {
        re = fout[i];
        im = foutimg[i];
        //get Decibels in 0-110 range

        fdraw[i] = Decibels(re,im);
        if (fdraw[i] > fmax)
        {
            fmax = fdraw[i];
        }
        if (fdraw[i] < fmin)
        {
            fmin = fdraw[i];
        }
    }
    //Draw right channel

    CFrequencyGraph* pPeak2 = (CFrequencyGraph*)pDataHolder->pData2;
    if (::IsWindow(pPeak2->GetSafeHwnd()))
    {
        pPeak2->SetNumberOfSteps(50);
        //Use updated dynamic range for scaling

        pPeak2->SetYRange((int)fmin,(int)fmax);
        pPeak2->Update(FFT_LEN/4,fdraw);
    }

This code is contained in a callback function that is called every time the waveIn functions return with updated audio signal data. The code that actually performs the FFT looks like:

void fft_double (unsigned int p_nSamples, bool p_bInverseTransform, 
    double *p_lpRealIn, double *p_lpImagIn, 
    double *p_lpRealOut, double *p_lpImagOut)
{

    if(!p_lpRealIn || !p_lpRealOut || !p_lpImagOut) return;


    unsigned int NumBits;
    unsigned int i, j, k, n;
    unsigned int BlockSize, BlockEnd;

    double angle_numerator = 2.0 * PI;
    double tr, ti;

    if( !IsPowerOfTwo(p_nSamples) )
    {
        return;
    }

    if( p_bInverseTransform ) angle_numerator = -angle_numerator;

    NumBits = NumberOfBitsNeeded ( p_nSamples );


    for( i=0; i < p_nSamples; i++ )
    {
        j = ReverseBits ( i, NumBits );
        p_lpRealOut[j] = p_lpRealIn[i];
        p_lpImagOut[j] = (p_lpImagIn == NULL) ? 0.0 : p_lpImagIn[i];
    }


    BlockEnd = 1;
    for( BlockSize = 2; BlockSize <= p_nSamples; BlockSize <<= 1 )
    {
        double delta_angle = angle_numerator / (double)BlockSize;
        double sm2 = sin ( -2 * delta_angle );
        double sm1 = sin ( -delta_angle );
        double cm2 = cos ( -2 * delta_angle );
        double cm1 = cos ( -delta_angle );
        double w = 2 * cm1;
        double ar[3], ai[3];

        for( i=0; i < p_nSamples; i += BlockSize )
        {

            ar[2] = cm2;
            ar[1] = cm1;

            ai[2] = sm2;
            ai[1] = sm1;

            for ( j=i, n=0; n < BlockEnd; j++, n++ )
            {

                ar[0] = w*ar[1] - ar[2];
                ar[2] = ar[1];
                ar[1] = ar[0];

                ai[0] = w*ai[1] - ai[2];
                ai[2] = ai[1];
                ai[1] = ai[0];

                k = j + BlockEnd;
                tr = ar[0]*p_lpRealOut[k] - ai[0]*p_lpImagOut[k];
                ti = ar[0]*p_lpImagOut[k] + ai[0]*p_lpRealOut[k];

                p_lpRealOut[k] = p_lpRealOut[j] - tr;
                p_lpImagOut[k] = p_lpImagOut[j] - ti;

                p_lpRealOut[j] += tr;
                p_lpImagOut[j] += ti;

            }
        }

        BlockEnd = BlockSize;

    }


    if( p_bInverseTransform )
    {
        double denom = (double)p_nSamples;

        for ( i=0; i < p_nSamples; i++ )
        {
            p_lpRealOut[i] /= denom;
            p_lpImagOut[i] /= denom;
        }
    }

}

And it requires the following supporting functions:

///////////////////////////////////////////////////////////

// check is a number is a power of 2

///////////////////////////////////////////////////////////


bool IsPowerOfTwo( unsigned int p_nX )
{

    if( p_nX < 2 ) return false;

    if( p_nX & (p_nX-1) ) return false;

    return true;

}


///////////////////////////////////////////////////////////

// return needed bits for fft

///////////////////////////////////////////////////////////


unsigned int NumberOfBitsNeeded( unsigned int p_nSamples )
{

    int i;

    if( p_nSamples < 2 )
    {
        return 0;
    }

    for ( i=0; ; i++ )
    {
        if( p_nSamples & (1 << i) ) return i;
    }

}



///////////////////////////////////////////////////////////

// ?

///////////////////////////////////////////////////////////


unsigned int ReverseBits(unsigned int p_nIndex, unsigned int p_nBits)
{

    unsigned int i, rev;

    for(i=rev=0; i < p_nBits; i++)
    {
        rev = (rev << 1) | (p_nIndex & 1);
        p_nIndex >>= 1;
    }

    return rev;
}



///////////////////////////////////////////////////////////

// return a frequency from the basefreq and num of samples

///////////////////////////////////////////////////////////


double Index_to_frequency(unsigned int p_nBaseFreq, 
    unsigned int p_nSamples, unsigned int p_nIndex)
{

    if(p_nIndex >= p_nSamples)
    {
        return 0.0;
    }
    else if(p_nIndex <= p_nSamples/2)
    {
        return ( (double)p_nIndex / 
                 (double)p_nSamples * p_nBaseFreq );
    }
    else
    {
        return ( -(double)(p_nSamples-p_nIndex) / 
                  (double)p_nSamples * p_nBaseFreq );
    }

}

The included sample class, CFrequencyGraph, will draw a sample EQ, peak meter, and spectral graph using the frequency intensity. Hopefully, this serves as a decent introduction to the uses and basics of the Fast Fourier Transform for audio signals. Other functions of the FFT include using it in combination with a Beat Detection Algorithm to detect beats in an audio signal. Another page with useful FFT information is located at FFT Spectrum Analyser.

This article uses waveIn* functions to retrieve the soundcard's data from the playing source. Therefore, you must manually open your soundcard properties and change the recording source to use mono/stereo mix or waveIn as the selected recording line. Also, if you set the playback wave option to false, this will override the recording options and no sound will appear. For information about doing an inverse FFT for transforming frequencies into an audio signal, please do a Google search on "Inverse FFT" or "IFFT".

History

You must Sign In to use this message board.
 
 
Per page   
 FirstPrevNext
GeneralMeasure units for Real and Ima. Data Pin
juanjo.montero		10:11 21 Oct '09  
Generalconver to C# Pin
enenegn		4:42 13 May '09  
GeneralDecibels explained? Pin
jweston		12:53 15 Apr '09  
GeneralFrequency Pin
sarlacc		4:15 17 Mar '09  
GeneralInternet archive for Don Cross' original page Pin
jo0ls		8:51 4 Jan '09  
Questiona few question about play wave file with DirectSound and display spectrum. Pin
jacky_zz		21:23 4 Sep '08  
GeneralQuestion about scaling the amplitude Pin
tabor25		3:36 14 Jul '08  
GeneralRe: Question about scaling the amplitude Pin
LLSS_China		2:13 10 Mar '09  
General[Message Deleted] Pin
Danny Rodriguez		10:09 27 Jan '08  
Generalxcode version Pin
eoghancunneen		4:25 9 Jan '08  
Generalfor another condition Pin
aa_esa		19:07 23 Nov '07  
Generaluse many cpu percenge Pin
shallopquan		1:15 13 Aug '07  
Generalre Pin
Leon.Minos		19:39 2 Aug '07  
QuestionVisualC++ Error Pin
edguardian		12:45 1 Aug '07  
AnswerRe: VisualC++ Error Pin
Fred Ackers		9:19 4 Aug '07  
QuestionPoor audio quality Pin
ChrisMitchell_		20:23 26 May '07  
AnswerRe: Poor audio quality Pin
Fred Ackers		13:32 29 May '07  
GeneralRe: Poor audio quality [modified] Pin
ChrisMitchell_		9:59 30 May '07  
GeneralRe: Poor audio quality Pin
Fred Ackers		13:51 31 May '07  
QuestionRe: Poor audio quality Pin
bquintero		19:27 27 Jun '07  
GeneralThank you Pin
DanMax		0:05 6 Apr '07  
GeneralNumber of channels? Pin
jakeparks		9:08 30 Mar '07  
GeneralRe: Number of channels? Pin
Fred Ackers		14:03 31 Mar '07  
GeneralRe: Number of channels? Pin
jakeparks		14:50 2 Apr '07  
GeneralRe: Number of channels? Pin
Fred Ackers		11:02 3 Apr '07  
Last Visit: 17:53 22 Nov '09     Last Update: 17:53 22 Nov '09 1234567 Next »


Last Updated 3 Apr 2007 | Advertise | Privacy | Terms of Use | Copyright © CodeProject, 1999-2009