# Noise

*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)

## Sample app

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

## Get started

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'
```

## Instructions

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.

#### Real input

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);
}
```

#### Imaginary input

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);
}
```

#### Output

Both 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<Float, Float>[] 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));
}
```

## Sample code

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.

## Performance tests

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
```

## Tests

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++.

## Development

#### Setup

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`

#### Release

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

## License

Noise is licensed under the Apache 2.0.

Kissfft is licensed under the Revised BSD License.