iphone - tarjetas - Usando Apple FFT y Accelerate Framework

no me aparece apple pay en wallet

Question

¿Alguien ha usado Apple FFT para una aplicación de iPhone todavía o sabe dónde puedo encontrar una aplicación de muestra sobre cómo usarlo? Sé que Apple ha publicado un código de muestra, pero no estoy seguro de cómo implementarlo en un proyecto real.

Answer 1

Acabo de obtener el código FFT trabajando para un proyecto de iPhone:

• crea un nuevo proyecto
• eliminar todos los archivos a excepción de main.m y xxx_info.plist
• ir a la configuración del proyecto y buscar pch e impedir que intente cargar un archivo .pch (dado que lo hemos eliminado)
• copiar pegar el ejemplo del código sobre lo que sea que tengas en main.m
• elimine la línea que #incluye Carbono. Carbon es para OSX.
• elimine todos los marcos y agregue acelere el marco

Es posible que también deba eliminar una entrada de info.plist que le dice al proyecto que cargue un xib, pero estoy seguro de que no necesita preocuparse por eso.

NOTA: Las salidas del programa a la consola, los resultados salen como 0.000 eso no es un error, es muy muy rápido

Este código es realmente estúpidamente oscuro; se comenta generosamente, pero los comentarios en realidad no hacen la vida más fácil.

Básicamente en el corazón de esto está:

vDSP_fft_zrip(setupReal, &A, stride, log2n, FFT_FORWARD);
vDSP_fft_zrip(setupReal, &A, stride, log2n, FFT_INVERSE);

FFT en n flotadores reales, y luego retrocede para volver al punto de partida. ip significa in situ, lo que significa que sobrescribe a A Esa es la razón de toda esta malarkey de empaquetado especial, de modo que podamos aplastar el valor de retorno en el mismo espacio que el valor de envío.

Para dar una perspectiva (como, por ejemplo, ¿por qué estaríamos usando esta función en primer lugar?), Digamos que queremos realizar la detección de tono en la entrada del micrófono, y lo hemos configurado para que se active alguna devolución de llamada cada vez el micrófono se pone en 1024 flotadores. Suponiendo que la frecuencia de muestreo del micrófono fuera de 44.1kHz, entonces eso es ~ 44 cuadros / seg.

Por lo tanto, nuestra ventana de tiempo es cualquiera que sea el tiempo de duración de 1024 muestras, es decir, 1/44 s.

Así que empacaríamos A con 1024 flotadores del micrófono, estableceríamos log2n = 10 (2 ^ 10 = 1024), precalculamos algunas bobinas (setupReal) y:

vDSP_fft_zrip(setupReal, &A, stride, log2n, FFT_FORWARD);

Ahora A contendrá n / 2 números complejos. Estos representan n / 2 contenedores de frecuencia:

• bin [1] .idealFreq = 44Hz - es decir, la frecuencia más baja que podemos detectar de manera confiable es UNA onda completa dentro de esa ventana, es decir, una onda de 44Hz.

• bin [2] .idealFreq = 2 * 44Hz

• etc.

• bin [512] .idealFreq = 512 * 44Hz - La frecuencia más alta que podemos detectar (conocida como frecuencia Nyquist) es donde cada par de puntos representa una onda, es decir, 512 ondas completas dentro de la ventana, es decir, 512 * 44Hz, o: n / 2 * bin [1] .idealFreq

• En realidad, hay un Bin, Bin [0] extra que a menudo se conoce como ''DC Offset''. Sucede que Bin [0] y Bin [n / 2] siempre tendrán el componente complejo 0, por lo que A [0] .realp se usa para almacenar Bin [0] y A [0] .imagp se usa para almacenar Bin [ n / 2]

Y la magnitud de cada número complejo es la cantidad de energía que vibra alrededor de esa frecuencia.

Entonces, como puede ver, no sería un detector de tono muy grande ya que no tiene una granularidad casi lo suficientemente fina. Hay un truco astuto Extracción de frecuencias precisas de los contenedores de FFT usando el cambio de fase entre fotogramas para obtener la frecuencia precisa para un contenedor determinado.

Ok, ahora en el código:

Observe la ''ip'' en vDSP_fft_zrip, = ''in place'', es decir, la salida sobrescribe A (''r'' significa que toma entradas reales)

Mira la documentación en vDSP_fft_zrip,

Los datos reales se almacenan en forma compleja dividida, con los reales impares almacenados en el lado imaginario de la forma compleja dividida e incluso los reales almacenados en el lado real.

esto es probablemente lo más difícil de entender. Estamos utilizando el mismo contenedor (& A) durante todo el proceso. entonces al principio queremos llenarlo con n números reales. después de la FFT va a tener n / 2 números complejos. luego lo arrojamos a la transformación inversa, y esperamos obtener nuestros n números reales originales.

ahora la estructura de A es su configuración para valores complejos. Entonces vDSP necesita estandarizar cómo empacar números reales en él.

entonces primero generamos n números reales: 1, 2, ..., n

for (i = 0; i < n; i++)
    originalReal[i] = (float) (i + 1);

A continuación, los empaquetamos en A como n / 2 complejos #s:

// 1. masquerades n real #s as n/2 complex #s = {1+2i, 3+4i, ...}
// 2. splits to 
//   A.realP = {1,3,...} (n/2 elts)
//   A.compP = {2,4,...} (n/2 elts)
//
vDSP_ctoz(
          (COMPLEX *) originalReal, 
          2,                            // stride 2, as each complex # is 2 floats
          &A, 
          1,                            // stride 1 in A.realP & .compP
          nOver2);                      // n/2 elts

Realmente necesitaría ver cómo se asigna A para obtener esto, tal vez busque COMPLEX_SPLIT en la documentación.

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

A continuación hacemos un cálculo previo.

Clase DSP rápida para cuerpos matemáticos: la teoría de Fourier toma mucho tiempo para darse cabeza (la he estado viendo y dejando de lado por varios años)

Un cisoid es:

z = exp(i.theta) = cos(theta) + i.sin(theta)

es decir, un punto en el círculo unitario en el plano complejo.

Cuando multiplicas números complejos, los ángulos se suman. Entonces z ^ k seguirá saltando alrededor del círculo unitario; z ^ k se puede encontrar en un ángulo k.theta

• Elija z1 = 0 + 1i, es decir, un cuarto de vuelta desde el eje real, y observe que z1 ^ 2 z1 ^ 3 z1 ^ 4 cada uno da otro cuarto de vuelta para que z1 ^ 4 = 1

• Elige z2 = -1, es decir, media vuelta. también z2 ^ 4 = 1 pero z2 ha completado 2 ciclos en este punto (z2 ^ 2 también es = 1). Entonces, podrías pensar en z1 como la frecuencia fundamental y z2 como el primer armónico

• De manera similar, z3 = el punto de "tres cuartos de revolución", es decir, -i completa exactamente 3 ciclos, pero en realidad ir hacia delante 3/4 cada vez es lo mismo que retroceder 1/4 cada vez.

es decir, z3 es solo z1 pero en la dirección opuesta: se llama aliasing

z2 es la frecuencia más significativa, ya que elegimos 4 muestras para mantener una onda completa.

• z0 = 1 + 0i, z0 ^ (cualquier cosa) = 1, esto es DC offset

Puede expresar cualquier señal de 4 puntos como una combinación lineal de z0 z1 y z2, es decir, la está proyectando en estos vectores de base

pero te escucho preguntando "¿qué significa proyectar una señal en un cisoide?"

Puede pensarlo de esta manera: la aguja gira alrededor del cisoide, por lo que en la muestra k, la aguja apunta en la dirección k.theta, y la longitud es la señal [k]. Una señal que coincida con la frecuencia del cisoide exactamente abombará la forma resultante en alguna dirección. Entonces, si suma todas las contribuciones, obtendrá un fuerte vector resultante. Si la frecuencia es casi igual, la protuberancia será más pequeña y se moverá lentamente alrededor del círculo. Para una señal que no coincide con la frecuencia, las contribuciones se cancelarán entre sí.

http://complextoreal.com/tutorials/tutorial-4-fourier-analysis-made-easy-part-1/ te ayudará a obtener una comprensión intuitiva.

Pero la esencia es; si hemos elegido proyectar 1024 muestras en {z0, ..., z512}, habríamos precalculado z0 a z512, y eso es lo que es este paso de precalculación .

Tenga en cuenta que si está haciendo esto en código real, probablemente desee hacer esto una vez cuando la aplicación se carga y llamar a la función de liberación complementaria una vez cuando se cierre. NO lo haga muchas veces, es caro.

// let''s say log2n = 8, so n=2^8=256 samples, or ''harmonics'' or ''terms''
// if we pre-calculate the 256th roots of unity (of which there are 256) 
// that will save us time later.
//
// Note that this call creates an array which will need to be released 
// later to avoid leaking
setupReal = vDSP_create_fftsetup(log2n, FFT_RADIX2);

Vale la pena señalar que si configuramos log2n como, por ejemplo, 8, puede arrojar estos valores precalculados en cualquier función fft que utilice resolución <= 2 ^ 8. Entonces (a menos que desee la máxima optimización de la memoria) simplemente cree un juego para la resolución más alta que necesitará y úselo para todo.

Ahora las transformaciones actuales, haciendo uso de las cosas que acabamos de calcular previamente:

vDSP_fft_zrip(setupReal, &A, stride, log2n, FFT_FORWARD);

En este punto, A contendrá n / 2 números complejos, solo que el primero es en realidad dos números reales (DC offset, Nyquist #) enmascarado como un número complejo. La descripción general de la documentación explica este empaque. Es bastante limpio, básicamente permite que los resultados (complejos) de la transformación se empaqueten en la misma huella de memoria que las entradas (reales, pero extrañamente empaquetadas).

vDSP_fft_zrip(setupReal, &A, stride, log2n, FFT_INVERSE);

y de regreso ... todavía necesitaremos descomprimir nuestro arreglo original de A. luego lo compararemos solo para verificar que hayamos recuperado exactamente con lo que comenzamos, lanzamos nuestras bobinas precalculadas y listo!

¡Pero espera! antes de desempacar, hay una última cosa que debe hacerse:

// Need to see the documentation for this one...
// in order to optimise, different routines return values 
// that need to be scaled by different amounts in order to 
// be correct as per the math
// In this case...
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);

Answer 2

Aquí hay otro ejemplo del mundo real: https://github.com/krafter/DetectingAudioFrequency

Answer 3

Aquí hay un ejemplo del mundo real: Un fragmento de c ++ que utiliza las rutinas vfps vDSP de Accelerate para realizar la autocorrelación en la entrada de la unidad de audio de IO remoto. Usar este marco es bastante complicado, pero la documentación no es tan mala.

OSStatus DSPCore::initialize (double _sampleRate, uint16_t _bufferSize) {
    sampleRate = _sampleRate;
    bufferSize = _bufferSize;
    peakIndex = 0;
    frequency = 0.f;
    uint32_t maxFrames = getMaxFramesPerSlice();
    displayData = (float*)malloc(maxFrames*sizeof(float));
    bzero(displayData, maxFrames*sizeof(float));
    log2n = log2f(maxFrames);
    n = 1 << log2n;
    assert(n == maxFrames);
    nOver2 = maxFrames/2;
    A.realp = (float*)malloc(nOver2 * sizeof(float));
    A.imagp = (float*)malloc(nOver2 * sizeof(float));
    FFTSetup fftSetup = vDSP_create_fftsetup(log2n, FFT_RADIX2);

    return noErr;
}

void DSPCore::Render(uint32_t numFrames, AudioBufferList *ioData) {

    bufferSize = numFrames;
    float ln = log2f(numFrames);

    //vDSP autocorrelation

    //convert real input to even-odd
    vDSP_ctoz((COMPLEX*)ioData->mBuffers[0].mData, 2, &A, 1, numFrames/2);
    memset(ioData->mBuffers[0].mData, 0, ioData->mBuffers[0].mDataByteSize);
    //fft
    vDSP_fft_zrip(fftSetup, &A, 1, ln, FFT_FORWARD);

    // Absolute square (equivalent to mag^2)
    vDSP_zvmags(&A, 1, A.realp, 1, numFrames/2);
    bzero(A.imagp, (numFrames/2) * sizeof(float));    

    // Inverse FFT
    vDSP_fft_zrip(fftSetup, &A, 1, ln, FFT_INVERSE);

    //convert complex split to real
    vDSP_ztoc(&A, 1, (COMPLEX*)displayData, 2, numFrames/2);

    // Normalize
    float scale = 1.f/displayData[0];
    vDSP_vsmul(displayData, 1, &scale, displayData, 1, numFrames);

    // Naive peak-pick: find the first local maximum
    peakIndex = 0;
    for (size_t ii=1; ii < numFrames-1; ++ii) {
        if ((displayData[ii] > displayData[ii-1]) && (displayData[ii] > displayData[ii+1])) {
            peakIndex = ii;
            break;
        }
    }

    // Calculate frequency
    frequency = sampleRate / peakIndex + quadInterpolate(&displayData[peakIndex-1]);

    bufferSize = numFrames;

    for (int ii=0; ii<ioData->mNumberBuffers; ++ii) {
        bzero(ioData->mBuffers[ii].mData, ioData->mBuffers[ii].mDataByteSize);
    }
}

Answer 4

Aunque diré que el Framework FFT de Apple es rápido ... Necesita saber cómo funciona una FFT para obtener una detección de tono precisa (es decir, calcular la diferencia de fase en cada FFT sucesiva para encontrar el tono exacto, no el tono del la mayoría domina bin).

No sé si es de alguna ayuda, pero subí mi objeto Pitch Detector desde mi aplicación de sintonizador (musicianskit.com/developer.php). También hay un ejemplo de proyecto xCode 4 para descargar (para que pueda ver cómo funciona la implementación).

Estoy trabajando para cargar una implementación FFT de ejemplo, así que estad atentos y actualizaré esto una vez que eso ocurra.

Feliz codificación!