audio-dsp

Design real-time DSP architectures with RT-safe state and SPSC queues in C++/Rust.

16|9|Updated Nov 6, 2013
One-click install
npx skills add https://github.com/erikstmartin/dotfiles --skill audio-dsp
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: audio-dsp
Source: https://github.com/erikstmartin/dotfiles/tree/main/skills/catalog/audio/audio-dsp
Command: npx skills add https://github.com/erikstmartin/dotfiles --skill audio-dsp

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Provide a structured approach to designing and implementing real-time DSP components for audio applications, focusing on RT-safe patterns, deterministic memory usage, and robust threading models.

Core Features & Use Cases

  • RT-safe DI and STFT pipelines with preallocated state
  • Lock-free concurrency patterns and SPSC communication between audio and worker threads
  • Practical examples: Biquad filters, STFT analysis, and parameter smoothing
  • Guidance for testing, performance tuning, and portability across C++/Rust

Quick Start

Configure and implement a minimal RT-safe DSP pipeline for audio processing in your project.

Frequently Asked Questions about audio-dsp

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design real-time audio DSP pipelines without dynamic allocations?

Real-time audio DSP pipelines require preallocated state and zero dynamic allocations on the audio thread. You enforce deterministic memory usage by utilizing SPSC queues for thread communication and STFT pipelines for analysis.

What is the best way to communicate between audio and worker threads in a DSP engine?

The best way to communicate between audio and worker threads in a DSP engine is using lock-free concurrency patterns. Specifically, SPSC queues provide real-time safe communication between threads without blocking the audio callback.

Can I implement biquad filters and parameter smoothing in C++ or Rust?

You can implement biquad filters and parameter smoothing in C++ or Rust. The approach provides guidance for testing, performance tuning, and portability across both languages within multi-threaded contexts.

Why does my real-time audio processing drop samples when allocating state?

Real-time audio processing drops samples when allocating state because dynamic allocations on the audio thread cause non-deterministic latency. You must use preallocated RT-safe state to ensure deterministic memory usage during processing.

Does this approach work for offline audio analysis and STFT pipelines?

This approach works for offline audio analysis and STFT pipelines. The real-time DSP architecture applies to both real-time audio engines and offline analysis, utilizing preallocated state for STFT processing.