Skip to content

High-level classes for performing DSP

License

LGPL-3.0, GPL-3.0 licenses found

Licenses found

LGPL-3.0
COPYING.LESSER
GPL-3.0
COPYING
Notifications You must be signed in to change notification settings

lsp-plugins/lsp-dsp-units

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

lsp-dsp-units

C++ DSP modules

This library provides set of functions and objects that perform different DSP processing of the audio signal.

Set of modules provided:

  • Signal control
    • Blink toggle
    • Bypass switch
    • Counter
    • Crossfade switch
    • Toggle
  • Dynamic processing
    • Autogain
    • Compressor
    • Dynamic processor
    • Expander
    • Gate
    • Limiter
    • Simple autogain
    • Surge protector
  • Filters and equalization
    • Butterworth filter
    • Dynamic filters
    • Equalizer
    • Filter
    • Spectral tilt
  • Metering
    • Correlation meter
    • Loudness meter
  • Miscellaneous functions
    • Broadcasting related functions and constants
    • Signal envelope functions
    • Interpolation functions
    • FFT windows
    • Fading functions
    • LFO functions
  • Noise generators
    • LGC generator
    • MLS generator
    • Velvet generator
  • Sampling
    • Sample
    • Sample player
    • Sample playbakc control
  • Utilities
    • Chirp Processor
    • Convolver
    • Crossover
    • Delay
    • Dynamic Delay
    • De-popper
    • Dither
    • FFT crossover
    • Impulse response taker
    • Latency detector
    • Meter history
    • Oscillator
    • Oversampler
    • Randomizer
    • Raw ring buffer
    • Ring buffer
    • Shift buffer
    • Sidechain control
    • Spectral processor
    • Spectrum analyzer
    • Trigger

Supported platforms

The build and correct unit test execution has been confirmed for following platforms:

  • FreeBSD
  • GNU/Linux
  • Windows 32-bit
  • Windows 64-bit

Requirements

The following packages need to be installed for building:

  • gcc >= 4.9
  • GNU make >= 4.0

Building

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

Usage

Here's the code snippet of how the library can be initialized and used in C++:

#include <lsp-plug.in/dsp/dsp.h>
#include <lsp-plug.in/dsp-units/units.h>
#include <lsp-plug.in/dsp-units/sampling/Sample.h>
#include <lsp-plug.in/dsp-units/filters/Filter.h>
#include <string.h>
#include <stdio.h>

static int process_file(const char *in, const char *out)
{
    // We will process file as a single audio sample
    // That can take many memory for large files
    // but for demo it's OK
    lsp::dspu::Sample s;
    lsp::dspu::Filter f;
    lsp::dspu::filter_params_t fp;
    lsp::io::Path path;

    // We consider pathnames encoded using native system encoding.
    // That's why we use io::Path::set_native() method
    path.set_native(in);
    if (s.load(&path) != lsp::STATUS_OK)
    {
        fprintf(stderr, "Error loading audio sample from file: %s\n", in);
        return -1;
    }

    // Apply +6 dB hi-shelf filter at 1 kHz
    fp.nType        = lsp::dspu::FLT_BT_BWC_HISHELF;
    fp.fFreq        = 1000.0f;
    fp.fFreq2       = 1000.0f;
    fp.fGain        = lsp::dspu::db_to_gain(6.0f);
    fp.nSlope       = 2;
    fp.fQuality     = 0.0f;

    f.init(NULL);   // Use own internal filter bank
    f.update(s.sample_rate(), &fp); // Apply filter settings

    // Now we need to process each channel in the sample
    for (size_t i=0; i<s.channels(); ++i)
    {
        float *c    = s.channel(i);     // Get channel data
        f.clear();                      // Reset internal memory of filter
        f.process(c, c, s.samples());
    }

    // Resample the processed sample to 48 kHz sample rate
    s.resample(48000);

    // Save sample to file
    path.set_native(out);
    if (s.save(&path) < 0)
    {
        fprintf(stderr, "Error saving audio sample to file: %s\n", out);
        return -2;
    }

    return 0;
}

int main(int argc, const char **argv)
{
    lsp::dsp::context_t ctx;

    if (argc < 3)
    {
        fprintf(stderr, "Input file name and output file name required");
        return -1;
    }

    // Initialize DSP
    lsp::dsp::init();
    lsp::dsp::start(&ctx);

    int res = process_file(argv[1], argv[2]);

    lsp::dsp::finish(&ctx);

    return res;
}

SAST Tools

  • PVS-Studio - static analyzer for C, C++, C#, and Java code.