iPhone FFT mit Accelerate-framework vDSP

Ich bin habend Schwierigkeit der Implementierung einer FFT mit vDSP. Ich verstehe die Theorie, aber bin auf der Suche nach einem bestimmten code-Beispiel bitte.

Ich habe Daten aus einer wav-Datei wie folgt:

Frage 1. Wie bekomme ich die audio-Daten in den FFT?

Frage 2. Wie bekomme ich die Ausgabe von Daten aus dem FFT?

Frage 3. Das ultimative Ziel ist zu prüfen, für niederfrequente Töne. Wie kann ich dies tun?

-(OSStatus)open:(CFURLRef)inputURL{
OSStatus result = -1;

result = AudioFileOpenURL (inputURL, kAudioFileReadPermission, 0, &mAudioFile);
if (result == noErr) {
    //get  format info
    UInt32 size = sizeof(mASBD);

    result = AudioFileGetProperty(mAudioFile, kAudioFilePropertyDataFormat, &size, &mASBD);

    UInt32 dataSize = sizeof packetCount;
    result = AudioFileGetProperty(mAudioFile, kAudioFilePropertyAudioDataPacketCount, &dataSize, &packetCount);
    NSLog([NSString stringWithFormat:@"File Opened, packet Count: %d", packetCount]);

    UInt32 packetsRead = packetCount;
    UInt32 numBytesRead = -1;
    if (packetCount > 0) { 
        //allocate  buffer
        audioData = (SInt16*)malloc( 2 *packetCount);
        //read the packets
        result = AudioFileReadPackets (mAudioFile, false, &numBytesRead, NULL, 0, &packetsRead,  audioData); 
        NSLog([NSString stringWithFormat:@"Read %d  bytes,  %d packets", numBytesRead, packetsRead]);
    }
}
return result;
}

FFT-code unten:

log2n = N;
n = 1 << log2n;
stride = 1;
nOver2 = n / 2;

printf("1D real FFT of length log2 ( %d ) = %d\n\n", n, log2n);

/* Allocate memory for the input operands and check its availability,
 * use the vector version to get 16-byte alignment. */

A.realp = (float *) malloc(nOver2 * sizeof(float));
A.imagp = (float *) malloc(nOver2 * sizeof(float));
originalReal = (float *) malloc(n * sizeof(float));
obtainedReal = (float *) malloc(n * sizeof(float));

if (originalReal == NULL || A.realp == NULL || A.imagp == NULL) {
printf("\nmalloc failed to allocate memory for  the real FFT"
"section of the sample.\n");
exit(0);
}

/* Generate an input signal in the real domain. */
for (i = 0; i < n; i++)

    originalReal[i] = (float) (i + 1);

/* Look at the real signal as an interleaved complex vector  by
 * casting it.  Then call the transformation function vDSP_ctoz to
 * get a split complex vector, which for a real signal, divides into
 * an even-odd configuration. */

vDSP_ctoz((COMPLEX *) originalReal, 2, &A, 1, nOver2);

/* Set up the required memory for the FFT routines and check  its
 * availability. */

setupReal = vDSP_create_fftsetup(log2n, FFT_RADIX2);

if (setupReal == NULL) {

printf("\nFFT_Setup failed to allocate enough memory  for"
"the real FFT.\n");

exit(0);
}

/* Carry out a Forward and Inverse FFT transform. */
vDSP_fft_zrip(setupReal, &A, stride, log2n, FFT_FORWARD);
vDSP_fft_zrip(setupReal, &A, stride, log2n, FFT_INVERSE);

/* Verify correctness of the results, but first scale it by  2n. */
scale = (float) 1.0 / (2 * n);
vDSP_vsmul(A.realp, 1, &scale, A.realp, 1, nOver2);
vDSP_vsmul(A.imagp, 1, &scale, A.imagp, 1, nOver2);

/* The output signal is now in a split real form.  Use the  function
 * vDSP_ztoc to get a split real vector. */
vDSP_ztoc(&A, 1, (COMPLEX *) obtainedReal, 2, nOver2);

/* Check for accuracy by looking at the inverse transform  results. */
Compare(originalReal, obtainedReal, n);

Dank

Wenn alles, was Sie tun möchten, ist zu erkennen niederfrequenten Töne dann per FFT kann overkill. Welche Frequenz/Frequenzen sind Sie auf der Suche nach, und mit wie viel Auflösung ?
Ich bin auf der Suche nach allen Frequenzen, die enthalten drum-oder bass-sounds, so dass ich reagieren kann, um die beats. Dank
in diesem Fall könnte man sich besser aus mit einem low-pass-filter + Hüllkurven-Detektor - einfacher zu implementieren und sollte es einfacher sein, sich auf die Akkulaufzeit, da es viel weniger rechenintensiv.

InformationsquelleAutor Simon | 2011-06-15

10
1. Stellen Sie Ihre audio-sample-Daten in die Reale Teil der Eingabe, und keine imaginären Teil.
2. Wenn Sie interessiert sind, in der Größenordnung von jeder bin-in die Frequenz-Domäne, dann berechnen Sie sqrt(re*re + im*im) für jeden Ausgang bin. Wenn Sie nur daran interessiert sind, in relative Größenordnung, dann können Sie drop die sqrt-und nur die Berechnung der magnitude squared, (re*re + im*im).
3. Würden Sie Blick auf die Größen der Behälter oder Behälter (siehe (2)), die entsprechend Ihrer Frequenz oder Frequenzen von Interesse. Wenn die Abtastrate ist Fs, und Ihre FFT-Größe N ist, dann die entsprechende Frequenz für die Ausgabe bin i ist gegeben durch f = i * Fs /N. Umgekehrt, wenn Sie daran interessiert sind, in einer bestimmten Frequenz f, dann den Papierkorb von Interesse, i, ist gegeben durch i = N * f /Fs.
Zusätzlicher Hinweis: Sie benötigen, um eine geeignete Fenster-Funktion (z.B. Hann aka Hanning) auf Ihrer FFT-Eingangsdaten vor der Berechnung der FFT selbst.
- Könnten Sie ein Beispiel für die Anwendung einer Fenster-Funktion vor der fft mit den vDSP Methoden?
InformationsquelleAutor Paul R

Können Sie überprüfen, äpfel Dokumentation darüber und nehmen gute Pflege von Daten Verpackung.
Hier ist mein Beispiel

// main.cpp
// FFTTest
//
// Created by Harry-Chris Stamatopoulos on 11/23/12.
// 

/* 
 This is an example of a hilbert transformer using 
 Apple's VDSP fft/ifft & other VDSP calls.
 Output signal has a PI/2 phase shift.
 COMPLEX_SPLIT vector "B" was used to cross-check
 real and imaginary parts coherence with the original vector "A"
 that is obtained straight from the fft.
 Tested and working. 
 Cheers!
*/

#include <iostream>
#include <Accelerate/Accelerate.h>
#define PI 3.14159265
#define DEBUG_PRINT 1

int main(int argc, const char * argv[])
{


    float fs = 44100;           //sample rate
    float f0 = 440;             //sine frequency
    uint32_t i = 0;


    uint32_t L = 1024;

    /* vector allocations*/
    float *input = new float [L];
    float *output = new float[L];
    float *mag = new float[L/2];
    float *phase = new float[L/2];


    for (i = 0 ; i < L; i++)
    {
        input[i] = cos(2*PI*f0*i/fs);
    }

    uint32_t log2n = log2f((float)L);
    uint32_t n = 1 << log2n;
    //printf("FFT LENGTH = %lu\n", n);


    FFTSetup fftSetup;
    COMPLEX_SPLIT A;
    COMPLEX_SPLIT B;
    A.realp = (float*) malloc(sizeof(float) * L/2);
    A.imagp = (float*) malloc(sizeof(float) * L/2);

    B.realp = (float*) malloc(sizeof(float) * L/2);
    B.imagp = (float*) malloc(sizeof(float) * L/2);


    fftSetup = vDSP_create_fftsetup(log2n, FFT_RADIX2);

    /* Carry out a Forward and Inverse FFT transform. */
    vDSP_ctoz((COMPLEX *) input, 2, &A, 1, L/2);
    vDSP_fft_zrip(fftSetup, &A, 1, log2n, FFT_FORWARD);


    mag[0] = sqrtf(A.realp[0]*A.realp[0]);


    //get phase
    vDSP_zvphas (&A, 1, phase, 1, L/2);
    phase[0] = 0;


    //get magnitude;
    for(i = 1; i < L/2; i++){
        mag[i] = sqrtf(A.realp[i]*A.realp[i] + A.imagp[i] * A.imagp[i]);
    }


    //after done with possible phase and mag processing re-pack the vectors in VDSP format
    B.realp[0] = mag[0];
    B.imagp[0] = mag[L/2 - 1];;

    //unwrap, process & re-wrap phase
    for(i = 1; i < L/2; i++){
        phase[i] -= 2*PI*i * fs/L;
        phase[i] -= PI / 2 ;
        phase[i] += 2*PI*i * fs/L;
    }

    //construct real & imaginary part of the output packed vector (input to ifft)
    for(i = 1; i < L/2; i++){
        B.realp[i] = mag[i] * cosf(phase[i]);
        B.imagp[i] = mag[i] * sinf(phase[i]);
    }


#if DEBUG_PRINT
    for (i = 0 ; i < L/2; i++)
    {
       printf("A REAL = %f \t A IMAG = %f \n", A.realp[i], A.imagp[i]);
       printf("B REAL = %f \t B IMAG = %f \n", B.realp[i], B.imagp[i]);
    }
#endif
    //ifft
    vDSP_fft_zrip(fftSetup, &B, 1, log2n, FFT_INVERSE);

    //scale factor
    float scale = (float) 1.0 / (2*L);

    //scale values
    vDSP_vsmul(B.realp, 1, &scale, B.realp, 1, L/2);
    vDSP_vsmul(B.imagp, 1, &scale, B.imagp, 1, L/2);

    //unpack B to real interleaved output
    vDSP_ztoc(&B, 1, (COMPLEX *) output, 2, L/2);


    //print output signal values to console
    printf("Shifted signal x = \n");
    for (i = 0 ; i < L/2; i++)
        printf("%f\n", output[i]);



    //release resources
    free(input);
    free(output);
    free(A.realp);
    free(A.imagp);
    free(B.imagp);
    free(B.realp);
    free(mag);
    free(phase);

}

InformationsquelleAutor Harry Chris Stamatopoulos

1

Eine Sache, die Sie müssen vorsichtig sein, um die DC-Komponente des FFT berechnet. Verglich ich meine Ergebnisse mit der fftw-Bibliothek FFT-und den Imaginärteil der Transformation, berechnet mit der vDSP Bibliothek hatte immer einen anderen Wert an index 0 (die 0 bedeutet die Frequenz, also DC).
Eine weitere Maßnahme habe ich mich beworben, wurde zu teilen sowohl die realen und imaginären Teile, die durch einen Faktor von 2. Ich denke, dies ist aufgrund des verwendeten Algorithmus in der Funktion. Auch diese beiden Probleme traten in den FFT-Prozess, aber nicht in der IFFT-Prozess.

Ich verwendet vDSP_fft_zrip. Ich hoffe, dass dies helfen kann.

Paolo

InformationsquelleAutor Paolo Turati

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.