Conference Year: 2024

Snapshot Testing for Audio DSP

Typical tools for testing DSP algorithms often fall short when it comes to describing complex outputs. Articulating expected behavior concisely and elegantly is challenging, and maintaining such test cases over the long term can be difficult.

As a result, we often resort to manual or semi-automated testing strategies.

This talk will present an alternative testing technique that offers a convenient and automated solution for testing audio code. By using audio waveforms, we can easily generate and test the results of DSP algorithms, ensuring safety when refactoring audio code.

Filed under: Uncategorized

The Curious Case of Subnormals in Audio Code

Floating-point subnormals have long presented an interesting edge case in digital signal processing that can cause severe performance hits, particularly when dealing with decaying infinite impulse response (IIR) filters. Most audio applications therefore opt to set flush-to-zero (FTZ) and denormals-are-zero (DAZ) CPU control register flags in their workflows.

The talk will chart an exploratory journey prompted by failing platform tests for web audio and an ancient ECMAScript forum thread, leading the author to investigate the current situation and impact on common devices.

Are subnormals still a problem for floating-point arithmetic in 2024? Is there a difference between native and web targets? What does the future hold for fast math and cross-platform audio code?

Filed under: Uncategorized

Rock-Solid Releases

Deploying audio web applications and plugins in a production environment demands meticulous attention to detail. Ensuring that software is thoroughly tested, validated, and compiled for various scenarios and platforms is crucial to maintaining quality.

This talk offers a beginner-friendly exploration of how to leverage tools like GitHub Actions to automate the development and deployment processes for audio applications and plugins. We’ll discuss the benefits of integrating CI/CD tools into your projects, whether you’re working solo or within a larger team. By the end, you’ll understand how to enhance both efficiency and reliability in your development pipeline.

Filed under: Uncategorized

The Discrete Fourier Transform

The Discrete Fourier Transform (DFT) is an essential building block of Digital Signal Processing (DSP). It allows you to elegantly decompose digital signals into their fundamental frequencies, revealing characteristics that can't be observed in the time domain.

Understanding how the DFT works and how it's computed is an important step to using it in practice, but the DFT on paper can look quite different from the DFT in action.

Translating the DFT from theory to practice has many pitfalls with ambiguous solutions, especially when processing audio. Much of the DFT's elegance must be compromised in practice, and it's not entirely obvious how or why.

This talk aims to bridge the gap between theory and practice by exploring the inner-workings of the DFT and using it to perform EQ-related effects on an audio stream.

Filed under: Uncategorized

Frontend Development Strategies For WebUI

As WebUI is increasingly utilized for plugin UI and web audio tools, we propose some tools and strategies that can be leveraged from traditional web application frontend development.

A web-based UI may benefit from a wide range of frameworks, documentation, and support available online. Web-based UI enables theming and accessibility support. Where there may be concerns over performance, browser development tools help target smooth experiences at 60 frames per second or above. We cover ten such tips and provide demos and a GitHub pointer with these references plus any others might suggest in Q/A and discussions.

Topics covered (briefly, with references) include:

  • Web Components
  • Popular third-party frameworks tooling
  • Static Analysis and Build Tools
  • Theming
  • Accessibility
  • Web-based DSP Development
  • Testability
  • Browser DevTools Part 1: Iterative Development and the Inspectors
  • Browser DevTools Part 2: Performance Analysis and Animation Timing
  • Benefits of Community

Note: I'm not affiliated with any products mentioned here.

 

Filed under: Uncategorized

How to Price an Audio Plugin

A plugin's price can make or break its success in the market, so why is it often one of the last decisions made? And why do skilled DSP developers struggle to determine this one value? This talk will cover the relevant economics of pricing for digital products, and will lay out 12 factors that should influence the final decision, using real-world examples. Developers will gain insight into what questions to ask and what observations to make in pricing their next launch – whether it's an analogue-style EQ, a one-knob spectral compressor, or humanity's next legendary synth plugin.

Filed under: Uncategorized

“Engine-Swap” on Two Spatial Audio Plugins Will Be Easy, Right?

Tackling a project that involves swapping the cores of two audio plugins seemed straightforward at first:
Yes, spatial audio is complex, but these are two similar JUCE plugins and I can just swap the core code components, it will be easy, right?
It wasn't, and it uncovered many unexpected challenges and learning opportunities.

In this talk, I will share my experience of improving an existing spatial audio plugin (SPARTA 6DoFConv) by replacing its convolution engine with a more efficient alternative. This process required deep dives into complex and sparsely commented audio DSP code and problem-solving.

The core of this presentation will focus on the general learning points from this endeavor. I will discuss some of the strategies I employed to understand and navigate complex codebases and the practical steps taken to embed a new convolution engine in an audio plugin. Additionally, I will explore the unforeseen issues that arose, such as dealing with the drawbacks of highly optimized algorithms and integrating a crossfade system, compromising between efficiency and level of integration.

This talk aims to provide valuable insights for developers, especially those who are starting out and want to start understanding and customizing other people's code. Join me in exploring the lessons learned, strategies employed, and trade-offs considered in creating a more efficient six-degrees-of-freedom spatial audio plugin.

Key Points:

  • Addressing challenges with optimized algorithms and accepting tradeoffs;
  • General lessons learned and best practices when working with other people's plugin code;
  • Practical knowledge of different multichannel convolution engines for Ambisonics reverberation and 6 degrees-of-freedom navigation for extended reality applications.
Filed under: Uncategorized

Beyond ValueTrees

The JUCE website says "The ValueTree class is JUCE's secret weapon," and it's true. They give you:

  • A really easy way to capture and pass around the entire state of your application's data at run time
  • A rich mechanism to watch that data at a fine degree of granularity
  • Trivially easy persistence of application state

...but at the cost (in comparison to using native POD or class/struct variables) of being:

  • slower
  • less convenient to use
  • less type-safe, since all values are stored in the JUCE var variant type.

This talk will explore the new Cello library to abstract away the underlying API calls in favor of syntax that's more like working with POD data. The original goal was to be able to write code something like the below, but using ValueTrees as the backing data store:

struct MyStruct : public cello::Object 
{
    cello::Value<int> x;
    cello::Value<float> y;
};

MyStruct demo;

// will be executed any time the value of X changes
demo.x.onPropertyChange = [&demo] ()
{
    std::cout << "x changed to " << demo.x << "\n";
}

// after executing this line, stdout should print: "x changed to 100"
demo.x = 100;

...and it's surprising how close to that we were able to get.

This project has a set of overlapping goals:

  • make working with ValueTrees more like working with C++ objects and less like calling API functions
  • add type-safety and type conversions without explicit use of VariantConverter objects
  • reduce boilerplate wherever possible
  • handle undo/redo management invisibly
  • support validation of values when they are accessed
  • explore the gray area between compile-time strong typing as in C++ and the kind of runtime dynamic typing that's possible using the ValueTree API
  • explore the available methods of reactive programming enabled with this system
  • build out new functionality that's implied by the capabilities of ValueTrees but perhaps not obvious, like:
  • creating a kind of NoSQL database
  • creating an in-proccess sync mechanism to make ValueTrees thread-safe
  • creating a simple IPC implementation
  • In general, add support for more complex use cases where the complexity can be hidden inside the framework.
Filed under: Uncategorized

How To Recreate/Restore a Full Game Boy Advance Soundtrack in High Quality

A new subfield of video game music has recently emerged: some people call it music "restoration" (or recreation). It comes from the desire to preserve and share incredible soundtracks that were cursed by hardware limitations at the time they were composed. For instance, the Game Boy Advance was using sequenced music, associated with sound samples. Those sounds had to be heavily compressed so everything fits on a 8Mb cartridge, and the audio engine had limited processing power, low sample rate, cheap output speakers...

In this talk, I would like to detail how I restored the entirety of the soundtrack from the first two Golden Sun games (2001-2002), by tracking down the original hardware that was used to record the samples, extracting the midi sequences, carefully studying the subtleties for each instrument, applying modern mixing techniques, and even doing a bit of reverse engineering. The whole process was improved by creating python scripts and a custom VST in C++.

Filed under: Uncategorized