Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/lsp-plugins/lsp-dsp-lib
DSP library for signal processing
https://github.com/lsp-plugins/lsp-dsp-lib
aarch64 algorithms architectures armv7 assembly convolution-algorithms dsp dsp-library fft fma3 lsp-dsp-lib processing-algorithms simd simd-instructions simd-library x86-32 x86-64
Last synced: about 1 month ago
JSON representation
DSP library for signal processing
- Host: GitHub
- URL: https://github.com/lsp-plugins/lsp-dsp-lib
- Owner: lsp-plugins
- License: lgpl-3.0
- Created: 2020-03-31T09:29:30.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2024-11-10T19:07:23.000Z (about 1 month ago)
- Last Synced: 2024-11-10T20:19:12.511Z (about 1 month ago)
- Topics: aarch64, algorithms, architectures, armv7, assembly, convolution-algorithms, dsp, dsp-library, fft, fma3, lsp-dsp-lib, processing-algorithms, simd, simd-instructions, simd-library, x86-32, x86-64
- Language: C++
- Homepage:
- Size: 3.35 MB
- Stars: 71
- Watchers: 3
- Forks: 18
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG
- Funding: .github/FUNDING.yml
- License: COPYING
Awesome Lists containing this project
- awesome-embedded-software - lsp-dsp-lib - DSP library for digital signal processing provides set of functions that perform SIMD-optimized computing on several hardware architectures. All functions currently operate on IEEE-754 single-precision floating-point numbers. (Data processing / DSP and Filtering)
README
# lsp-dsp-lib
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 AVX512;
* x86_64 architecture (64-bit): SSE, SSE2, SSE3, AVX, AVX2, FMA3 and 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.## Supported platforms
The build and correct unit test execution has been confirmed for following platforms:
* FreeBSD
* GNU/Linux
* OpenBSD
* Windows 32-bit
* Windows 64-bit## Supported architectures
The support of following list of hardware architectures has been implemented:
* i386 (32-bit) - full support (AVX-512 on the way).
* x86_64 (64-bit) - full support (AVX-512 on the way).
* 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.## Requirements
The following packages need to be installed for building:
* gcc >= 4.9
* make >= 4.0## Building
To build the library, perform the following commands:
```bash
make config # Configure the build
make fetch # Fetch dependencies from Git repository
make
sudo make install
```To get more build options, run:
```bash
make help
```To uninstall library, simply issue:
```bash
make uninstall
```To clean all binary files, run:
```bash
make clean
```To clean the whole project tree including configuration files, run:
```bash
make prune
```To fetch all possible dependencies and make the source code tree portable between
different architectures and platforms, run:```bash
make tree
```To build source code archive with all possible dependencies, run:
```bash
make distsrc
```## Usage
Here's the code snippet of how the library can be initialized and used in C++:
```C++
#include
#include
#includeint 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:
```C
#include
#include
#includeint 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;
}```
## SAST Tools
* [PVS-Studio](https://pvs-studio.com/en/pvs-studio/?utm_source=website&utm_medium=github&utm_campaign=open_source) - static analyzer for C, C++, C#, and Java code.