Noise is an Android wrapper for kissfft, a FFT implementation written in C.

Available items

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? **Create a request here**:

Readme

*A FFT computation library for Android*

Noise is an Android wrapper for kissfft, a FFT implementation written in C. Noise features an api that is designed to be easy to use, and familiar for Android devs. (JNI bindings are available as well)

Watch Noise compute FFT in real time from your microphone, the sample app is on Google Play!

Add jitpack.io repo to your root

build.gradle:

allprojects { repositories { //... maven { url "https://jitpack.io" } } }

Include in Android project:

implementation 'com.github.paramsen:noise:2.0.0'

This lib is a Kotlin wrapper for kissfft, consult the kissfft readme if you want more information about the internal FFT implementation.

Noise supports computing DFT from real and imaginary input data.

Instantiate, this example is configured to compute DFT:s on input arrays of size 4096.

Noise noise = Noise.real(4096) //input size == 4096

Invoke the FFT on some input data.

float[] src = new float[4096]; float[] dst = new float[4096 + 2]; //real output length equals src+2// .. fill src with data

// Compute FFT:

float[] fft = noise.fft(src, dst);

// The result array has the pairs of real+imaginary floats in a one dimensional array; even indices // are real, odd indices are imaginary. DC bin is located at index 0, 1, nyquist at index n-2, n-1

for(int i = 0; i < fft.length / 2; i++) { float real = fft[i * 2]; float imaginary = fft[i * 2 + 1];

`System.out.printf("index: %d, real: %.5f, imaginary: %.5f\n", i, real, imaginary);`

}

This example is configured to compute DFT:s on input arrays of size 8192 (4096 [real, imaginary] pairs).

Noise noise = Noise.imaginary(8192) //input size == 8192

In order to compute a DFT from imaginary input, we need to structure our real+imaginary pairs in a flat, one dimensional array. Thus the input array has pairs of real+imaginary like; float[0] = firstReal, float[1] = firstImaginary, float[2] = secondReal, float[3] = secondImaginary.. ``` float[] imaginaryInput = new float[8192];

// fill imaginaryInput with data (pairs is an array of pairs with [real, imaginary] objects):

for(int i = 0; i < pairs.length; i++) { imaginaryInput[i * 2] = pairs[i].real; imaginaryInput[i * 2 + 1] = pairs[i].imaginary; }

// Compute the FFT with imaginaryInput:

float[] fft = noise.fft(realInput);

// The output array has the pairs of real+imaginary floats in a one dimensional array; even indices // are real, odd indices are imaginary. DC bin is located at index 0, 1, nyquist at index n/2-2, n/2-1

for(int i = 0; i < fft.length / 2; i++) { float real = fft[i * 2]; float imaginary = fft[i * 2 + 1];

System.out.printf("index: %d, real: %.5f, imaginary: %.5f\n", i, real, imaginary);

}

#### OutputBoth the real and imaginary implementations produce an array of real and imaginary pairs, in a flat, one dimensional structure.

Thus each even and odd index is a pair of a real and imaginary numbers, we could convert the result array to an array of pairs to better show the relation like:

float[] fft = noise.fft(input);

Pair[] pairs = new Pair<>[fft.length / 2];

for(int i = 0; i < fft.length / 2; i++) { float real = fft[i * 2]; float imaginary = fft[i * 2 + 1];

pairs.add(new Pair(real, imaginary));

} ```

I've written a sample app in Kotlin which computes FFT:s on the real time microphone signal. It features some cool Rx solutions for mic integration that might be interesting in themselves. It's on Google Play and the source can be found in the sample module.

The following tests measure the average FFT computation time over 1000 computations for an array of length 4096. Run on a new S8+ and an old LG G3 for comparison.

**Samsung S8+:**

Optimized Imaginary: 0.32ms Optimized Real: 0.32ms Threadsafe Imaginary: 0.38ms Threadsafe Real: 0.48ms

**LG G3:**

Optimized Imaginary: 0.76ms Optimized Real: 0.72ms Threadsafe Imaginary: 1.02ms Threadsafe Real: 1.33ms

The implementation has been tested for compliance with the kissfft C library; for the same input,
equal output is given. The tests in the Android test suite that assures that equal output is
computed by loading a pre defined data set and asserting the result against a precomputed result.

The precomputed result is generated by the C test suite that runs kissfft directly
in C++.

Kissfft is not bundled in the source of this repository for many reasons, I have resided to let a git module script initiate it with a manual step.

Setup steps are:

- Run
git submodule init; git submodule update

in project root - Check that kissfft exists in
noise/src/native/kissfft

There's a Gradle task that generates the README.md from template and git tags the current commit with the version number. JitPack builds on push of the tag.

Release steps are:

- Bump version in
noise/build.gradle

- Run
./gradlew release

in project root (generates readme) - Push generated readme changes to repo
- Wait for JitPack to build

Noise is licensed under the Apache 2.0.

Kissfft is licensed under the Revised BSD License.