FFmpeg is a comprehensive, production-grade multimedia framework providing libraries and command-line tools for encoding, decoding, transcoding, muxing, demuxing, filtering, streaming, and playing audio, video, subtitles, and related metadata. The codebase is organized into several core libraries: libavcodec (codec implementations), libavformat (container formats), libavfilter (audio/video filters), libavutil (utilities), libavdevice (device I/O), libswresample (audio resampling), and libswscale (image scaling/colorspace conversion). The primary user-facing tools are ffmpeg (conversion/streaming), ffplay (media player), and ffprobe (media analysis). The architecture is modular, with each library exposing a public API and internally using a plugin-like registration system for codecs, demuxers, muxers, filters, and bitstream filters. Hardware acceleration is supported via Vulkan, CUDA, VA-API, D3D11VA, D3D12VA, VideoToolbox, MediaCodec, and others, with architecture-specific SIMD optimizations for x86, ARM, RISC-V, MIPS, LoongArch, and PowerPC. The project is actively maintained with extensive testing infrastructure including fuzzers, unit tests, and a checkasm framework for verifying assembly optimizations.
The KFR library is a high-performance C++ framework for digital signal processing (DSP) and audio applications. It provides optimized implementations of FFT/DFT, filter design (FIR/IIR), sample rate conversion, audio file I/O (supporting WAV, FLAC, MP3, AIFF, CAF, etc.), SIMD-accelerated mathematical operations, and tensor/multi-dimensional array operations. The library is designed for real-time processing and scientific computing, with architecture-specific optimizations for x86 SIMD, ARM NEON, and RISC-V RVV, and runtime dispatch for multiarchitecture support. Key architectural features include a header-only design (with optional separate compilation), expression templates for lazy evaluation and operator fusion, a portable SIMD abstraction layer, and a tensor system with NumPy interoperability. The library is used in production by scientific collaborations such as LIGO, Virgo, and KAGRA for gravitational-wave signal processing, benchmarked against FFTW. It employs a dual licensing model (GPLv2+/commercial) and requires C++20 for compilation. The codebase demonstrates strong engineering practices through reusable components such as the SIMD vector abstraction (vec<T, N>), expression template system, tensor class, and audio data handling unit. These components are self-contained, exhibit non-obvious skill in C++ template metaprogramming, and can be extracted for use in other projects with minimal modification. The library is actively maintained, with recent commits and CI/CD pipelines, and shows low technical drift by keeping pace with modern C++ standards and hardware advancements.
KISS FFT is a mixed-radix Fast Fourier Transform library implemented in C and C++. It provides a compact, portable, and reasonably efficient FFT implementation supporting complex and real-valued transforms in one or multiple dimensions. The library is designed to be simple to integrate, offering both a C API (kiss_fft, kiss_fftr, kiss_fftnd, kiss_fftndr) and a header-only C++ template class. It supports multiple scalar types (float, double, int16_t, int32_t) and SIMD acceleration via SSE, LSX, and LASX instruction sets. The core algorithm uses decimation-in-time with optimized butterflies for radices 2, 3, 4, and 5, and provides a cache mechanism (kfc) to reuse FFT configurations. The codebase is self-contained with no external dependencies beyond libm; optional tools require fftw3 and libpng for benchmarking and image generation. It is widely used in embedded systems, audio processing, and scientific computing due to its permissive BSD license and straightforward API.
songsee is a single-binary Go CLI tool that turns audio files into spectral visualization images. It decodes audio natively (WAV, MP3) or via ffmpeg, computes an FFT specrogram, and renders nine visualiation modes (spectrogram, mel, chroma, HPSS, self-similarity, loudness, tempogram, MFCC, spectral flux) as a grid of heatmaps in PNG or JPEG format. The architecture is a monlith: the `cmd/songsee/main.go` entry point parsers flags using Kong, delegates to `internal/audio` for decoding, `internal/dsp` for signal processing (STFT, mel filtering, chroma, median filters, etc.), and `internal/render` for image generation. It produces deterministic output – same input flags yield identical bytes. The codebase is well-structured with comprehensive tests, CI/CD, and a clean separation of concerns. It demonstrates high craftsmanship in DSP optimization (e.g., bit-exact HPSS with median networks, tiling) and safe WAV parsing.
This repository is the companion to Allen Downey's Think DSP book. It is primarily an educational Python library plus a collection of Jupyter notebooks, not a production service or a research data pipeline. The core deliverable is the `thinkdsp` package, a self-contained module that provides object-oriented primitives for representing periodic signals (`Signal`, `Sinusoid`, `Chirp`, `Noise`), sampling them into `Wave` objects, and transforming between time and frequency domains via FFT and DCT. The library also supports spectral arithmetic, filtering, convolution, autocorrelation, spectrogram generation, WAV file I/O, and basic audio synthesis. The notebooks in `nb/`, `split/`, and `examples/` walk through each chapter of the book, with solution notebooks and standalone solution scripts in `soln/`.
This is a full-stack, self-hosted satellite ground station, not a data-research repository, though it contains substantial orbital-data ingestion, telemetry parsing, and signal-processing components. The application connects software-defined radios (RTL-SDR, Airspy, UHD, SoapySDR, SDRplay) to a real-time web UI for satellite tracking, hardware control, IQ/waterfall visualization, demodulation, decoding, recording, and observation scheduling. The backend is Python with FastAPI/Socket.IO, SQLAlchemy/Alembic, multiprocessing workers, and pub/sub broadcaster components; the frontend is React/Redux Toolkit/Material-UI. The user-facing system manages rotators and rigs via Hamlib, propagates TLE/OMM orbital elements, predicts passes, applies Doppler correction, schedules automated observations, and exposes file browsing, telemetry analysis, and audio transcription through external AI providers.
Rune is a cross-platform music player and library manager built with a Rust backend and Flutter frontend. It provides local audio playback, metadata extraction, audio analysis (FFT, spectral features, MFCC, chroma), acoustic fingerprinting (MusicBrainz/Shazam-style), and a recommendation engine based on feature vectors. The system supports multi-device synchronization using Hybrid Logical Clocks (HLC) and chunked data transfer, LAN device discovery with TLS certificate pinning, and scrobbling to Last.fm, Libre.fm, and ListenBrainz. It includes a CLI tool, a Svelte-based authorization panel for remote server management, and a full GUI with cover art wall, lyrics display, dynamic mixes, and extensive theming. Architecturally, the project is a monorepo with 11 Rust crates and a Flutter app. The Rust backend (native/hub) handles database operations (SeaORM/SQLite), audio analysis, playback (rodio), networking (WebSocket/HTTP server), and sync. The Flutter frontend communicates via rinf (Rust-FFI message passing). The codebase demonstrates strong engineering practices: trait-based abstractions (FsIo, PlaybackStrategy, HLCRecord), macro-driven boilerplate reduction (collection_query!, parallel_media_files_processing!), and a clean separation of concerns between UI, business logic, and data layers. While primarily an application, it incorporates significant data engineering patterns in its sync and analysis subsystems, making it a hybrid project with reusable data infrastructure.
The FFTW.jl package provides Julia bindings to the FFTW library for performing fast Fourier transforms (FFTs) and related operations. It also supports Intel's MKL as an alternative backend via the MKL_jll package. The package is designed as a drop-in replacement for the FFT functionality that was formerly part of Base Julia, and it integrates with the AbstractFFTs.jl package to provide a unified interface for various FFT implementations. The architecture of the package centers around the FFTW module, which re-exports AbstractFFTs and defines concrete implementations of FFT plans for the FFTW and MKL libraries. Key features include support for multi-dimensional transforms, in-place and out-of-place operations, real-to-real transforms (including various types of discrete cosine and sine transforms), and thread-safe execution through the use of a global lock and careful management of plan lifecycle to avoid issues with the garbage collector during planning. The package allows users to switch between the FFTW and MKL backends at runtime (requiring a restart for the change to take effect) via the `set_provider!` function. One notable aspect of the codebase is its handling of thread safety and resource management. The package uses a reentrant lock to protect calls into the FFTW library, which is not thread-safe by default, and integrates with Julia's threading system to allow FFTW to utilize multiple threads. Additionally, it employs a deferred destruction mechanism for FFTW plans to prevent the garbage collector from running during critical planning operations, which could lead to deadlocks. These patterns demonstrate a high level of expertise in wrapping C libraries in Julia while maintaining safety and performance. The package is actively maintained, with recent commits and ongoing issue triage. It keeps pace with its dependencies, as evidenced by compatible version ranges in its Project.toml file, and does not show significant signs of technical debt. Overall, FFTW.jl is a robust and well-engineered solution for performing FFTs in Julia, suitable for both interactive use and high-performance applications.