DSP library for digital signal processing (and more)
This library provides set of functions that perform SIMD-optimized computing on several hardware architectures.
Currently supported set of SIMD extensions:
- i586 architecture (32-bit): SSE, SSE2, SSE3, AVX, AVX2, FMA3 and partial support of AVX512;
- x86_64 architecture (64-bit): SSE, SSE2, SSE3, AVX, AVX2, FMA3 and partial support of AVX512;
- armv7 architecture (32-bit): NEON;
- AArch64 architecture (64-bit): ASIMD.
All functions currently operate on IEEE-754 single-precision floating-point numbers.
Current set of functions provided:
- Functions that gather system information and optimize CPU for better computing;
- Cooley-Tukey 1-dimensional FFT algorithms with unpacked complex numbers;
- Cooley-Tukey 1-dimensional FFT algorithms with packed complex numbers;
- Direct convolution algorithm;
- Fast convolution functions that enhance performance of FFT-based convolution algorithms;
- Biquad static filter transform and processing algorithms;
- Biquad dynamic filter transform and processing algorithms;
- Floating-point operations: copying, moving, protection from NaNs and denormals;
- Parallel arithmetics functions on long vectors including fused multiply operations;
- Basic unpacked complex number arithmetics;
- Basic packed complex number arithmetics;
- Some functions that operate on RGB and HSL colors and their conversions;
- Mid/Side matrix functions for converting Stereo channel to Mid/Side and back;
- Functions for searching minimums and maximums;
- Resampling functions based on Lanczos filter;
- Interpolation functions;
- Some set of function to work with 3D mathematics.
The build and correct unit test execution has been confirmed for following platforms:
- FreeBSD
- GNU/Linux
- MacOS
- OpenBSD
- Windows 32-bit
- Windows 64-bit
The support of following list of hardware architectures has been implemented:
- i386 (32-bit) - full support (SSE1-SSE3, AVX, AVX2, partial support for AVX-512).
- x86_64 (64-bit) - full support (SSE1-SSE3, AVX, AVX2, partial support for AVX-512).
- ARMv6A - full support.
- ARMv7A - full support.
- AArch64 - full support.
For all other architectures the generic implementation of algorithms is used, without any architecture-specific optimizations.
The following packages need to be installed for building:
- gcc >= 4.9
- make >= 4.0
To build the library, perform the following commands:
make config # Configure the build
make fetch # Fetch dependencies from Git repository
make
sudo make install
To get more build options, run:
make help
To uninstall library, simply issue:
make uninstall
To clean all binary files, run:
make clean
To clean the whole project tree including configuration files, run:
make prune
To fetch all possible dependencies and make the source code tree portable between different architectures and platforms, run:
make tree
To build source code archive with all possible dependencies, run:
make distsrc
Here's the code snippet of how the library can be initialized and used in C :
#include <lsp-plug.in/dsp/dsp.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, const char **argv)
{
// Initialize DSP
lsp::dsp::init();
// Optionally: output information about the system
lsp::dsp::info_t *info = lsp::dsp::info();
if (info != NULL)
{
printf("Architecture: %s\n", info->arch);
printf("Processor: %s\n", info->cpu);
printf("Model: %s\n", info->model);
printf("Features: %s\n", info->features);
::free(info);
}
// For faster computing we can tune CPU by updating thread context.
// This will enable Flush-to-Zero and Denormals-are-Zero flags on
// CPUs that support them. This is thread-local change and should
// be called in each individual processing thread
lsp::dsp::context_t ctx;
lsp::dsp::start(&ctx);
// Here we call some dsp functions, for example dsp::fill_zero
float v[0x1000];
lsp::dsp::fill_zero(v, sizeof(v)/sizeof(float));
// At the end, we need to restore the context and reset CPU settings to defaults
lsp::dsp::finish(&ctx);
return 0;
}
Also all functions can be accessed from pure C with lsp_dsp_
prefix in the funcion and type names:
#include <lsp-plug.in/dsp/dsp.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, const char **argv)
{
// Initialize DSP
lsp_dsp_init();
// Optionally: output information about the system
lsp_dsp_info_t *info = lsp_dsp_info();
if (info != NULL)
{
printf("Architecture: %s\n", info->arch);
printf("Processor: %s\n", info->cpu);
printf("Model: %s\n", info->model);
printf("Features: %s\n", info->features);
free(info);
}
// For faster computing we can tune CPU by updating thread context.
// This will enable Flush-to-Zero and Denormals-are-Zero flags on
// CPUs that support them. This is thread-local change and should
// be called in each individual processing thread
lsp_dsp_context_t ctx;
lsp_dsp_start(&ctx);
// Here we call some dsp functions, for example lsp_dsp_fill_zero
float v[0x1000];
lsp_dsp_fill_zero(v, sizeof(v)/sizeof(float));
// At the end, we need to restore the context and reset CPU settings to defaults
lsp_dsp_finish(&ctx);
return 0;
}
- PVS-Studio - static analyzer for C, C , C#, and Java code.