CamillaDSP is a real-time audio stream processing engine written in Rust. It captures audio from a configurable backend (ALSA, PulseAudio, PipeWire, CoreAudio, WASAPI, ASIO, or file), processes it through a user-defined pipeline of filters, mixers, compressors, and other DSP components, and outputs it to a playback device. The pipeline is defined via YAML configuration, supporting biquad filters, FIR convolution (with hand-optimized NEON and AVX+FMA SIMD kernels), loudness, limiting, noise gates, and dithering. A websocket-based control interface allows runtime adjustments of volume, mute, faders, and config reloads. The architecture is modular with separate threads for capture, processing, and playback, using a PI rate controller for buffer level regulation. Benchmarks demonstrate attention to performance. While primarily an application, the DSP filter implementations and utility components (ring buffer, conversion routines, rate controller) are reusable building blocks for audio software.
BlueALSA is a Bluetooth audio ALSA backend for Linux systems that integrates with BlueZ to provide A2DP, HFP/HSP, ASHA, and BLE-MIDI profiles. It operates as a daemon (bluealsad) managing Bluetooth connections and exposing audio streams via ALSA PCM plugins and D-Bus interfaces. The architecture is modular, separating transport management, codec handling, D-Bus communication, and ALSA plugin layers. Key entry points include the daemon (src/main.c), ALSA PCM plugin (src/asound/bluealsa-pcm.c), ALSA mixer plugin (src/asound/bluealsa-ctl.c), and control utility (src/bluealsactl/main.c). Data flows from ALSA applications through the PCM plugin to Bluetooth transports, with control signaling via D-Bus. External dependencies include BlueZ, ALSA, GLib, and various codec libraries (SBC, aptX, LDAC, etc.).
musikcube is a cross-platform, terminal-based music player and streaming server written in C++. It consists of a core library (`musikcore`) with a plugin-based architecture for decoders, encoders, audio outputs, DSP, and data streams. The project includes three distinct front-ends: a terminal UI (`musikcube`) built on a custom curses++ framework, a native Windows UI (`musikwin`) using a custom Win32 wrapper, and an Android remote client (`musikdroid`) written in Kotlin. The server plugin enables remote control and audio streaming via WebSocket and HTTP. The core manages a SQLite-backed music library with indexing, metadata extraction (via TagLib), and playlist management. Audio playback supports gapless and crossfade transitions, visualizers, and an equalizer. The system is designed for extensibility through a well-defined SDK interface set, allowing third-party plugins for decoders, outputs, and DSP. The codebase is mature (copyright 2004-2023) and shows signs of organic growth, with heavy vendored third-party dependencies and platform-specific code. While not architecturally pristine, it demonstrates solid engineering, a clean plugin API, and reusable UI frameworks.
Squeezelite is a lightweight, headless Squeezebox emulator that acts as a network audio player for Lyrion Music Server (formerly Logitech Media Server). It receives audio streams via the Slimproto protocol, decodes a wide range of codecs (MP3, FLAC, AAC, Ogg Vorbis, WMA, ALAC, DSD, Opus), and outputs to local audio hardware through ALSA, PortAudio, PulseAudio, or stdout. The application is written in C with a modular, multi-threaded architecture: separate threads for network streaming, decoding, resampling, and output, all communicating via circular buffers with mutex protection. It supports high-resolution audio, DSD (DoP and native), resampling with libsoxr, visualizer export to shared memory, IR remote control, and GPIO amplifier control. The codebase is highly portable, with dedicated Makefiles for Linux, macOS, Windows, Solaris, and various ARM architectures, as well as Visual Studio project files. Build-time options (LINKALL, DSD, RESAMPLE, etc.) allow static or dynamic linking of codec libraries. The project is actively maintained with a responsive community and is widely used in embedded audio players and home automation systems.
speakersafetyd is a Rust system daemon that implements a software Smart Amp speaker protection model for Apple Silicon Macs running Linux. It reads voltage and current sense (V/ISENSE) data from a TAS2764-class codec via an ALSA capture PCM, simulates voice coil and magnet temperatures using per-machine configurable thermal parameters, and reduces speaker volume through ALSA mixer controls when temperatures approach limits. The daemon is fail-safe by design: the kernel keeps speakers volume-limited until the daemon writes an unlock magic value, and any panic causes the daemon to exit so the kernel can restore the safe state.