How do I use KISS FFT for real-valued signals?

Include kiss_fftr.h and use functions like kiss_fftr for even-length transforms, which return the positive half-spectrum. Note that odd-length real FFTs lack optimization and may require workarounds.

KISS FFT vs FFTW: which is better for my project?

Choose KISS FFT for simplicity, small code size, and easy integration; it's about twice as slow as FFTW but much lighter. Opt for FFTW if you need maximum performance and can handle its complexity and licensing.

Can I compile KISS FFT for embedded systems with fixed-point?

Yes, set KISSFFT_DATATYPE to int16_t or int32_t during build. However, some tools like fast convolution don't work with fixed point, so check the README for limitations before relying on advanced features.

How to build KISS FFT with OpenMP support for multi-core FFTs?

Use make KISSFFT_OPENMP=1 for Make or -DKISSFFT_OPENMP=ON for CMake during configuration. Ensure your compiler (GCC, Clang, or MSVC) supports OpenMP, as it's turned off by default.

What's the memory usage of KISS FFT compared to other libraries?

It's very lightweight; a sample program is around 18KB without optimization, versus 522KB for similar FFT_BRANDX usage. No static data is used, and core routines are thread-safe for low overhead.

Does KISS FFT support multi-dimensional FFTs?

Yes, tools in the tools/ directory provide multi-dimensional FFT capabilities, but they may have limitations with fixed-point data types and require additional compilation flags to enable.

Open-Awesome

kissfft

NOASSERTIONC131.2.0

A simple, portable Fast Fourier Transform (FFT) library for C with support for fixed and floating point data types.

GitHub

2.0k stars361 forks0 contributors

What is kissfft?

KISS FFT is a Fast Fourier Transform library written in C that implements mixed-radix FFT algorithms. It solves the need for a simple, portable FFT implementation that supports both fixed and floating point data types with minimal licensing restrictions. The library is designed to be easily incorporated into C programs while maintaining reasonable performance.

Target Audience

C/C++ developers working on signal processing, audio applications, or embedded systems who need a straightforward FFT implementation without the complexity of highly optimized libraries.

Value Proposition

Developers choose KISS FFT for its simplicity, portability, and permissive licensing. Unlike larger, more complex FFT libraries, it offers a clean codebase (about 500 lines for the core) that's easy to understand and integrate, with support for multiple data types and build systems.

Overview

a Fast Fourier Transform (FFT) library that tries to Keep it Simple, Stupid

Use Cases

Best For

Embedded systems requiring fixed-point FFT computations
Educational projects teaching Fourier transform implementation
Audio processing applications needing real-valued FFTs
Prototyping signal processing algorithms quickly
Projects with strict code size constraints
Multi-platform applications needing portable FFT functionality

Not Ideal For

Applications demanding peak FFT performance, such as real-time high-frequency signal processing or scientific simulations where every millisecond counts
Projects requiring robust optimization for odd-length real-valued FFTs, as the library currently only supports even lengths
Embedded systems needing fixed-point fast convolution, which is explicitly not available in KISS FFT
Teams seeking extensive documentation, commercial support, or active community debugging, as the author offers limited assistance per the FAQ

Pros & Cons

Pros

Minimal Code Footprint

Core routines are only about 500 lines for 1-D complex FFTs, making integration and auditing straightforward without bloat, as highlighted in comparisons with larger libraries.

Flexible Data Types

Supports compilation with float, double, Q15, or Q31 samples via build flags, allowing adaptation to various precision needs across embedded and desktop platforms.

Permissive Licensing

Uses a revised BSD license compatible with both open-source and commercial projects, reducing legal hurdles for integration into diverse codebases.

Build System Portability

Offers both Make and CMake builds with configurable options like static/shared libraries and OpenMP support, ensuring easy adoption in different development environments.

Cons

Performance Limitations

Benchmarks show it's roughly half as fast as highly optimized libraries like FFTW, making it unsuitable for performance-critical applications where speed is paramount.

Incomplete Feature Set

Real FFT optimization only works for even lengths, and fast convolution is unavailable for fixed-point data, limiting utility in specific signal processing tasks as noted in the TODO list.

Sparse Documentation

The README admits gaps like undocumentated fast convolution methods and scaling issues, forcing developers to rely on code inspection or external resources for troubleshooting.

Frequently Asked Questions

Related Projects

DSPFilters

A Collection of Useful C++ Classes for Digital Signal Processing

Stars2,072

Forks412

Last commit3 years ago

iir1

DSP IIR realtime filter library written in C++

Stars780

Forks160

Last commit1 year ago

wavelib

C Implementation of 1D and 2D Wavelet Transforms (DWT,SWT and MODWT) along with 1D Wavelet packet Transform and 1D Continuous Wavelet Transform.

Stars446

Forks137

Last commit8 months ago

fCWT

The fast Continuous Wavelet Transform (fCWT) is a library for fast calculation of CWT.

Stars402

Forks84