Как узнать частоту звука?

    while(1){
        Pa_ReadStream( stream, sampleBlock, FRAMES_PER_BUFFER );
        max_sample=0;
        for (j=0; j<FRAMES_PER_BUFFER; ++j)
        {
            if (sampleBlock[j] > max_sample) max_sample=sampleBlock[j];
        }
        printf("Amplitude= %.0f   \r",max_sample*100);
   }

while(1)
    {
        Pa_ReadStream( stream, sampleBlock, FRAMES_PER_BUFFER ); //читаем из потока в буфер       
        for(i=0; i<FRAMES_PER_BUFFER; i++) Im[i] = 0.0;  // обнуляем мнимую часть
        FFT(sampleBlock, Im, FRAMES_PER_BUFFER, POW_2, -1); // указатель,0,отсчёты,степень
 
        // определяем позицию в начале массива с максимальным вектором
        max_ampl=0;
        max_i=0;
        for(i=5; i<FRAMES_PER_BUFFER/100; i++)
        {
            len_vector=sampleBlock[i]*sampleBlock[i]+Im[i]*Im[i];
            if (len_vector>max_ampl)
            {
                max_ampl=len_vector;
                max_i=i;
            }
        }
        printf("Freq= %f    \r",(float)max_i*SAMPLE_RATE/FRAMES_PER_BUFFER);
    }

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "portaudio.h"
 
 
#define SAMPLE_RATE (44100)
//       N    = 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384;
//       LogN = 2, 3,  4,  5,  6,   7,   8,   9,   10,   11,   12,   13,    14;
#define FRAMES_PER_BUFFER (16384)
#define POW_2 (14)
#define NUM_CHANNELS (1)
 
/* Select sample format. */
#define PA_SAMPLE_TYPE paFloat32
#define SAMPLE_SIZE (4)
#define SAMPLE_SILENCE (0.0f)
#define CLEAR(a) memset( (a), 0, FRAMES_PER_BUFFER * NUM_CHANNELS * SAMPLE_SIZE ) // обнуление массива
#define PRINTF_S_FORMAT "%.8f"
 
#define  NUMBER_IS_2_POW_K(x)   ((!((x)&((x)-1)))&&((x)>1))  // x is pow(2, k), k=1,2, ...
#define  FT_DIRECT        -1    // Direct transform.
#define  FT_INVERSE        1    // Inverse transform.
 
struct
{
    int num;
    char letter[5];
    float freq;
    float freq_down;
    float freq_up;
} note[128];
 
void FreqOfNotes();
int FFT();
void VerPar(float x1,float y1,float x2,float y2,float x3,float y3);
float X0, Y0;
 
int main()
{
    printf("Note from mic\n");
 
    FreqOfNotes();// заполняем структуру нот
 
    PaStreamParameters inputParameters;
    PaStream *stream = NULL;
    //PaError err;
    float *sampleBlock,len_vector;
    int i,j,note_real;
    int max_ampl_1,max_ampl_2;
    int max_i, max_i_1,max_i_2;
    int numBytes;
    float Im[FRAMES_PER_BUFFER],freq_real;
 
    printf("patest_read_write_wire.c\n");
    fflush(stdout);
 
    numBytes = FRAMES_PER_BUFFER * NUM_CHANNELS * SAMPLE_SIZE ;
    sampleBlock = (float *) malloc( numBytes );
 
    CLEAR( sampleBlock );
 
    Pa_Initialize();
    inputParameters.device = Pa_GetDefaultInputDevice();
    inputParameters.channelCount = NUM_CHANNELS;
    inputParameters.sampleFormat = PA_SAMPLE_TYPE;
    inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultHighInputLatency ;
    inputParameters.hostApiSpecificStreamInfo = NULL;
 
    Pa_OpenStream(
        &stream,
        &inputParameters,
        0,
        SAMPLE_RATE,
        FRAMES_PER_BUFFER,
        paClipOff,
        NULL,
        NULL );
 
    Pa_StartStream( stream );
    printf("**************************************************\n");
    printf("               READING STREAM.\n");
    printf("**************************************************\n");
    fflush(stdout);
 
    while(1)
    {
        float max_sample=0;
        Pa_ReadStream( stream, sampleBlock, FRAMES_PER_BUFFER );
 
        printf("\r");
        // определяем максимальную амплитуду
        for (j=0; j<FRAMES_PER_BUFFER; ++j)
        {
            if (sampleBlock[j] > max_sample) max_sample=sampleBlock[j];
        }
        printf("Amplitude=%3.0f  \t",max_sample*100);
 
        // ***************************************
        // если аплтитуда мала, ничего не анализируем!
        if (max_sample>0.2)
        {
            // отправляем массив на БПФ, обнулив мнимую часть
            for(i=0; i<FRAMES_PER_BUFFER; i++) Im[i] = 0.0;
            FFT(sampleBlock, Im, FRAMES_PER_BUFFER, POW_2, -1);
 
            // определяем одну из двух частот с максимальным вектором
            max_ampl_1=0,max_ampl_2=0;
            max_i=0,max_i_1=0,max_i_2=0;
            for(i=15; i<FRAMES_PER_BUFFER/100; i++)
            {
                len_vector=sampleBlock[i]*sampleBlock[i]+Im[i]*Im[i];
                if (len_vector>max_ampl_1)
                {
                    max_ampl_1=len_vector;
                    max_i_1=i;
                }
            }
            // ищем второй пик
            for(i=15; i<FRAMES_PER_BUFFER/100; i++)
            {
                len_vector=sampleBlock[i]*sampleBlock[i]+Im[i]*Im[i];
                if (len_vector>max_ampl_2 && len_vector<max_ampl_1)
                {
                    max_ampl_2=len_vector;
                    max_i_2=i;
                }
            }
            if(max_i_1>max_i_2) max_i=max_i_2;
            else max_i=max_i_1;
            //printf("Freq= %f  \t",(float)max_i*SAMPLE_RATE/FRAMES_PER_BUFFER); // показывает частоту
 
            VerPar((float)max_i-1,     sampleBlock[max_i-1]*sampleBlock[max_i-1]+Im[max_i-1]*Im[max_i-1],
                   (float)max_i,   len_vector,
                   (float)max_i+1, sampleBlock[max_i+1]*sampleBlock[max_i+1]+Im[max_i+1]*Im[max_i+1]);
 
            freq_real=X0*SAMPLE_RATE/FRAMES_PER_BUFFER;
 
            // определяем номер ноты и пишем буквенное обозначение
            note_real=0;
            for (i=40; i<=83; i++)
            {
                if (freq_real>note[i].freq_down && freq_real<note[i].freq_up) note_real=i;
            }
            if (note_real>40)
            {
                // printf("FreqReal= %5.2f  \t",freq_real); // уточненная частота
                printf("Note= %s\t",note[note_real].letter);
                // печатаем отклонение в центах
                printf("delta= %f   \n", 1200 *  log2( freq_real / note[note_real].freq   ));
 
            }
        }
        else printf("\t\t\t\t\t\t");
    }
    CLEAR( sampleBlock );
    free( sampleBlock );
 
    Pa_StopStream( stream );
    Pa_Terminate();
    return 0;
}
 
int  FFT(float *Rdat, float *Idat, int N, int LogN, int Ft_Flag)
{
    // parameters error check:
    if((Rdat == NULL) || (Idat == NULL))                  return 0;
    if((N > 16384) || (N < 1))                            return 0;
    if(!NUMBER_IS_2_POW_K(N))                             return 0;
    if((LogN < 2) || (LogN > 14))                         return 0;
    if((Ft_Flag != FT_DIRECT) && (Ft_Flag != FT_INVERSE)) return 0;
 
    register int  i, j, n, k, io, ie, in, nn;
    float         ru, iu, rtp, itp, rtq, itq, rw, iw, sr;
 
    static const float Rcoef[14] =
    {
        -1.0000000000000000F,  0.0000000000000000F,  0.7071067811865475F,
        0.9238795325112867F,  0.9807852804032304F,  0.9951847266721969F,
        0.9987954562051724F,  0.9996988186962042F,  0.9999247018391445F,
        0.9999811752826011F,  0.9999952938095761F,  0.9999988234517018F,
        0.9999997058628822F,  0.9999999264657178F
    };
    static const float Icoef[14] =
    {
        0.0000000000000000F, -1.0000000000000000F, -0.7071067811865474F,
        -0.3826834323650897F, -0.1950903220161282F, -0.0980171403295606F,
        -0.0490676743274180F, -0.0245412285229122F, -0.0122715382857199F,
        -0.0061358846491544F, -0.0030679567629659F, -0.0015339801862847F,
        -0.0007669903187427F, -0.0003834951875714F
    };
 
    nn = N >> 1;
    ie = N;
    for(n=1; n<=LogN; n++)
    {
        rw = Rcoef[LogN - n];
        iw = Icoef[LogN - n];
        if(Ft_Flag == FT_INVERSE) iw = -iw;
        in = ie >> 1;
        ru = 1.0F;
        iu = 0.0F;
        for(j=0; j<in; j++)
        {
            for(i=j; i<N; i+=ie)
            {
                io       = i + in;
                rtp      = Rdat[i]  + Rdat[io];
                itp      = Idat[i]  + Idat[io];
                rtq      = Rdat[i]  - Rdat[io];
                itq      = Idat[i]  - Idat[io];
                Rdat[io] = rtq * ru - itq * iu;
                Idat[io] = itq * ru + rtq * iu;
                Rdat[i]  = rtp;
                Idat[i]  = itp;
            }
 
            sr = ru;
            ru = ru * rw - iu * iw;
            iu = iu * rw + sr * iw;
        }
 
        ie >>= 1;
    }
 
    for(j=i=1; i<N; i++)
    {
        if(i < j)
        {
            io       = i - 1;
            in       = j - 1;
            rtp      = Rdat[in];
            itp      = Idat[in];
            Rdat[in] = Rdat[io];
            Idat[in] = Idat[io];
            Rdat[io] = rtp;
            Idat[io] = itp;
        }
 
        k = nn;
 
        while(k < j)
        {
            j   = j - k;
            k >>= 1;
        }
 
        j = j + k;
    }
 
    if(Ft_Flag == FT_DIRECT) return 1;
 
    rw = 1.0F / N;
 
    for(i=0; i<N; i++)
    {
        Rdat[i] *= rw;
        Idat[i] *= rw;
    }
 
    return 1;
}
 
void VerPar(float x1,float y1,float x2,float y2,float x3,float y3)
{
    // определяем координаты вершины параболы, выводим в глобал переменные
    float A,B,C;
    A=(y3-( (x3*(y2-y1)+x2*y1-x1*y2) /  (x2-x1)))   /(x3*(x3-x1-x2)+x1*x2);
    B= (y2-y1)/(x2-x1) - A*(x1+x2);
    C= ( (x2*y1-x1*y2) / (x2-x1) )+A*x1*x2;
    X0= -(B/(2*A));
    Y0= - ( (B*B-4*A*C)  /   (4*A) );
}

# define DELTA_NOTE 49
 
struct
{
    int num;
    char letter[5];
    float freq;
    float freq_down;
    float freq_up;
} note[128];
 
void FreqOfNotes()
{
    int i;
    char *letters[] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};
 
    for (i=0; i<=127; i++)
    {
        note[i].num=i;
 
        strcat(note[i].letter, letters[i % 12]);
 
        if (i>=24 && i<=35) strcat (note[i].letter,"1");
        else if (i>=36 && i<=47) strcat (note[i].letter,"2");
        else if (i>=48 && i<=59) strcat (note[i].letter,"3");
        else if (i>=60 && i<=71) strcat (note[i].letter,"4");
        else if (i>=72 && i<=83) strcat (note[i].letter,"5");
        else if (i>=84 && i<=95) strcat (note[i].letter,"6");
 
        note[i].freq = 440 * pow(2,(i-69)/12.0) ;
        note[i].freq_up=note[i].freq* pow( pow (2,1/1200.), DELTA_NOTE); // смещение от ноты в центах
        note[i].freq_down=note[i].freq* pow( pow (2,1/1200.),- DELTA_NOTE); // смещение от ноты в центах
 
    }
    return ;
}