chowdsp_utils

This repository contains JUCE modules with utilities for building Chowdhury DSP plugins.

There are a handful of simple examples in the examples/ directory.

For complete documentation, see the API docs.

Usage

If you are using JUCE with CMake, simply add this repository as a subdirectory after adding JUCE to your CMake project.

add_subdirectory(JUCE)
add_subdirectory(chowdsp_utils)

target_link_libraries(MyTarget PUBLIC
    juce::juce_audio_utils
    juce::juce_dsp
    # other JUCE modules...
    chowdsp::chowdsp_dsp
    chowdsp::chowdsp_gui
    chowdsp::chowdsp_plugin_base
    # Other modules and libraries...
)

Alternatively, you may add these modules from the repository directory using the Projucer.

If you are using a non-JUCE CMake project, it is possible to create your own static library from the DSP modules in this repository:

add_subdirectory(chowdsp_utils)

# create static library based on these modules
setup_chowdsp_lib(chowdsp_lib               # Name of the static library
    MODULES chowdsp_math chowdsp_dsp_utils  # DSP modules that should be included in the library...
)

# link the static library to your project
target_link_libraries(MyCoolProject PRIVATE chowdsp_lib)

Examples

If you would like to build the example plugins included in this repository, you may clone the repository, and use the following CMake commands:

cmake -Bbuild -DCHOWDSP_ENABLE_EXAMPLES=ON
cmake --build build --target $EXAMPLE_TARGET

where $EXAMPLE_TARGET is the name of the target you'd like to build, for example SimpleEQ_Standalone.

Modules

Dependencies

The modules in this repository are mostly dependent on C++17 or later. Modules not in the "Common" or "DSP" categories also depend on JUCE 6 or later.

There are a few other dependencies as well, some of which are bundled internally within the repository, and others which must be managed externally. In either case, you must be sure to abide by the license of each module, as well as whichever libraries are being used.

Common Modules

chowdsp_core (BSD)

• DoubleBuffer: A circular buffer which always maintans a contiguous block of data.
• TupleHelpers: Useful methods for working with tuple-like data structures.
• AtomicHelpers: Useful methods for working with atomics.

chowdsp_json (BSD)

• A thin wrapper around nlohmann::json (MIT license, included internally).

chowdsp_reflection (BSD)

• A thin wrapper around boost::pfr (Boost license, included internally).

chowdsp_serialization (BSD)

• Tools for serializing/deserializing data, using JSON or XML formats.

DSP Modules

chowdsp_dsp_data_structures (GPLv3)

• LookupTableTransform: Some modifications on juce::dsp::LookupTableTransform.
• RebufferedProcessor: A processor which rebuffers the input to have a constant block size.
• SmoothedBufferValue: A buffered version of juce::SmoothedValue.
• COLAProcessor: A base class for doing Constant Overlap-Add processing.

chowdsp_dsp_utils (GPLv3)

• Utilities for working with convolution and impulse responses.
• DelayLine: A re-implementation of juce::dsp::DelayLine with more interpolation options.
• PitchShifter: Simple pitch-shifting effect using a ring buffer with two read pointers.
• Useful classes for modal signal processing.
• Various classes for integer or non-integer resampling
  • Optionally depends on libsamplerate. User must link with libsamplerate externally, and define CHOWDSP_USE_LIBSAMPLERATE=1
• Sources: "magic circle" sine wave oscillator, anti-aliased saw and square wave oscillators, noise generator.
• A few other useful processors.

chowdsp_eq (GPLv3)

• EQBand: A single EQ band.
• EQProcessor: A collection of EQ bands.
• LinearPhaseEQ: Constructs a linear phase EQ from a give prototype EQ.

chowdsp_filters (GPLv3)

• Basic first and second order filters (HPF/LPF/BPF, shelving filters, peaking filters, notch filters).
• Some higher-order filters (Butterworth, Chebyshev (Type II), Elliptic).
• StateVariableFilter: A modified version of juce::dsp::StateVariableTPTFilter with more filter types and better performance.
• ModFilterWrapper: Turns any biquad filter into a State Variable Filter.
• FIRFilter: An FIR filter with SIMD optimizations.

chowdsp_math (BSD)

• FloatVectorOperations: Some extensions on juce::FloatVectorOperations.
• Polynomials: Methods for evaluating polynomials with Horner's method or Estrin's scheme.
• A few other useful math operations.

chowdsp_reverb (GPLv3)

• Some modular template classes for constructing Feedback Delay Network reverbs.

chowdsp_simd (BSD)

• A wrapper around XSIMD (BSD, included internally).
• SIMDSmoothedValue: A SIMD specialization of juce::SmoothedValue.
• A few other extea SIMD math functions.

chowdsp_waveshapers (GPLv3)

• Basic waveshaping processes implemented with integrated waveshaping (ADAA), including:
  • hard clipper
  • tanh soft clipper
  • polynomial soft clipper

GUI Modules

chowdsp_gui (GPLv3)

• Custom LookAndFeel.
• Helper class for optionally using OpenGL.
• Helper classes for working with long-presses and popup menus on touch screens.
• Custom tooltip viewer.
• Component to display plugin info (version, format, etc.).
• Component for controlling preset management.

chowdsp_foleys (GPLv3)

• Interface between chowdsp_gui and foleys_gui_magic (must be linked externally).

Music Modules

chowdsp_rhythm (BSD)

• Utilities for working with rhythms, and converting between a rhythm and a unit of time.

Plugin Utility Modules

chowdsp_clap_extensions (BSD)

• CLAPExtensions::CLAPProcessorExtensions: implements clap_direct_process with parameter modulation.
• CLAPExtensions::CLAPInfoExtensions: implements getPluginTypeString().
• ModParameterMixin: interface for supporting CLAP parameter modulation.

chowdsp_parameters (BSD)

• ParamUtils: Useful methods for creating parameters.
• ForwardingParameter: A parameter that forwards on a parameter from another processor.

chowdsp_plugin_base (GPLv3)

• Bass classes for creating audio effect or synthesizer plugins.

chowdsp_plugin_utils (GPLv3)

• FileListener: A listener which triggers a callback whenever a file is changed.
• PluginLogger: A logging system which can be used within a plugin.
• SharedPluginSettings: A shared object for managing settings which apply ot all instances of a plugin.
• SharedLNFAllocator: A shared object for managing juce::LookAndFeel classes.
• AudioUIBackgroundThread: A thread class which accepts data from the audio thread, and performs a background task (often useful for creating meters).

chowdsp_presets (BSD)

• A system for managing plugin presets.

chowdsp_version (BSD)

• Utilities for managing the version of an app or plugin.

Development

The development environment for this repository expects the following directory structure:

|- JUCE
|- modules
  |- foleys_gui_magic
  |- chowdsp_utils

Building Module Tests

To build the module tests, run:

cmake -Bbuild -DCHOWDSP_ENABLE_TESTING=ON
cmake --build build --target $TEST_TARGET

where $TEST_TARGET is the name of the test target you'd like to build.

If you would like to build the tests with flags for analyzing code coverage, add -DCODE_COVERAGE=ON to the CMake configure step.

Building Module Benchmarks

Toe build the module benchmarks, run:

cmake -Bbuild -DCMAKE_BUILD_TYPE=Release -DCHOWDSP_ENABLE_BENCHMARKS=ON
cmake --build build --config Release $BENCH_TARGET

where $BENCH_TARGET is the name of the benchmark you would like to build.

License

Each module in this repository has its own unique license. If you would like to use code from one of the modules, please check the license of that particular module.

If you are making a proprietary or closed source app and would like to use code from a module that is under a GPL-style license, please contact chowdsp@gmail.com for non-GPL licensing options.

All non-module code in this repository (tests, examples, benchmarks, etc.) is licensed under the GPLv3.