Bibliothèque FFT en Android Sdk

Vous pouvez utiliser cette classe, qui est assez rapide pour l'analyse audio en temps réel

public class FFT {

  int n, m;

  // Lookup tables. Only need to recompute when size of FFT changes.
  double[] cos;
  double[] sin;

  public FFT(int n) {
      this.n = n;
      this.m = (int) (Math.log(n) / Math.log(2));

      // Make sure n is a power of 2
      if (n != (1 << m))
          throw new RuntimeException("FFT length must be power of 2");

      // precompute tables
      cos = new double[n / 2];
      sin = new double[n / 2];

      for (int i = 0; i < n / 2; i++) {
          cos[i] = Math.cos(-2 * Math.PI * i / n);
          sin[i] = Math.sin(-2 * Math.PI * i / n);
      }

  }

  public void fft(double[] x, double[] y) {
      int i, j, k, n1, n2, a;
      double c, s, t1, t2;

      // Bit-reverse
      j = 0;
      n2 = n / 2;
      for (i = 1; i < n - 1; i++) {
          n1 = n2;
          while (j >= n1) {
              j = j - n1;
              n1 = n1 / 2;
          }
          j = j + n1;

          if (i < j) {
              t1 = x[i];
              x[i] = x[j];
              x[j] = t1;
              t1 = y[i];
              y[i] = y[j];
              y[j] = t1;
          }
      }

      // FFT
      n1 = 0;
      n2 = 1;

      for (i = 0; i < m; i++) {
          n1 = n2;
          n2 = n2 + n2;
          a = 0;

          for (j = 0; j < n1; j++) {
              c = cos[a];
              s = sin[a];
              a += 1 << (m - i - 1);

              for (k = j; k < n; k = k + n2) {
                  t1 = c * x[k + n1] - s * y[k + n1];
                  t2 = s * x[k + n1] + c * y[k + n1];
                  x[k + n1] = x[k] - t1;
                  y[k + n1] = y[k] - t2;
                  x[k] = x[k] + t1;
                  y[k] = y[k] + t2;
              }
          }
      }
  }
}

attention: ce code semble dérivé de ici, et a une licence GPLv2.

utiliser la classe à: https://www.ee.columbia.edu/~ronw/code/MEAPsoft/doc/html/FFT_8java-source.html

Brève Explication: call fft () x comme vous les données d'amplitude o comme tableau de tous les zéros, après que la fonction retourne votre première réponse sera a[0]=x[0]^2+y[0]^2.

explication: FFT est complexe transformer, il faut N nombres complexes et produit N des nombres complexes. Donc, x[0] est la partie réelle du premier numéro, y[0] est la partie complexe. Cette fonction calcule en place, donc quand la fonction retourne x et y auront les parties réelles et complexes de la transformation.

une utilisation typique est de calculer le spectre de puissance de l'audio. Vos échantillons audio ont seulement la partie réelle, vous votre partie complexe est 0. Pour calculer le spectre de puissance vous ajoutez le carré des parties réelles et complexes P[0]=x[0]^2+y[0]^2.

il est également important de noter que la Transformée de Fourier, lorsqu'elle est appliquée sur des nombres réels, résulte en un résultat symétrique (x[0]==x[x. lenth-1]). Les données à x[x.longueur/2] les données de fréquence f=0Hz. x[0]=x[x. length-1] a les données pour une fréquence égale à avoir le taux d'échantillonnage (par exemple, si vous échantillonniez 44000Hz que cela signifie F[0] renvoie à 22kHz).

procédure Complète:

1. créer un tableau p[n] avec 512 échantillons avec les zéros
2. Recueillir 1024 échantillons audio, de les écrire sur x
3. Jeu de y[n]=0 pour tout n
4. calculer fft (x, y)
5. calculer p[n]+ = x[n+512]^2 + y[n+512]^2 pour tous n = 0 à 512
6. aller 2 pour prendre un autre lot (après 50 lots de passer à l'étape suivante)
7. plot p
8. 1

qu'ajuster le nombre fixe à votre goût.

le nombre 512 définit la fenêtre d'échantillonnage, Je ne vais pas l'expliquer. Il suffit d'éviter de le réduire trop.

le nombre 1024 doit toujours être le double du dernier nombre.

le nombre 50 définit votre taux de mise à jour. Si votre taux d'échantillonnage est de 44000 échantillons par seconde, votre taux de mise à jour sera: r=44000/1024/50 = 0.85 secondes.

kissfft est une bibliothèque assez décente qui compile sur android. Il a une licence plus polyvalente que FFTW (même si FFTW est mieux).

vous pouvez trouver une reliure android pour kissfft en libgdx https://github.com/libgdx/libgdx/blob/0.9.9/extensions/gdx-audio/src/com/badlogic/gdx/audio/analysis/KissFFT.java

ou si vous souhaitez une solution basée sur Java pur essayer jtransformes https://sites.google.com/site/piotrwendykier/software/jtransforms

Utilisez ceci classe (celle dont découle la réponse d'EricLarch).

Notes D'Utilisation

cette fonction remplace vos tableaux d'entrées par la sortie FFT.

Entrée

• N = le nombre de points de données (la taille de votre tableau d'entrée, doit être une puissance de 2)
• X = la partie réelle de vos données à transformer
• Y = la partie imaginaire de données à transformée

i.e. si votre entrée est (1+8i, 2+3j, 7-i, -10-3i)

• N = 4
• X = (1, 2, 7, -10)