Auto-editor is a command-line application for automatically editing video and audio content. It analyzes media files to detect silent or still sections (based on audio loudness, motion, black frames, or subtitles) and automatically cuts them out, producing a more concise output. The tool supports a wide range of input and output formats, leveraging FFmpeg for media processing and offering export options tailored to popular video editing software like Adobe Premiere Pro, Final Cut Pro, DaVinci Resolve, Shotcut, and Kdenlive. The architecture is modular, with distinct modules for analysis (audio, motion, black detection, subtitle processing), rendering, export format handling, and command-line interface. Key features include a plugin-like system for edit methods (e.g., audio-based, motion-based), a caching mechanism to avoid redundant analysis, support for keyboard input via microphone, and integration with Whisper.cpp for speech transcription. The project also provides a web interface and supports advanced features like transitions, speed ramping, volume ducking, and keyframe-based effects. The codebase demonstrates strong engineering practices through its use of a custom expression language for defining edit decisions, SIMD-optimized performance critical paths, and a clear separation between media processing logic and user-facing functionality. Despite its complexity and reliance on external multimedia libraries, the project maintains active development with regular updates and cross-platform support.
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/`.
SenseVoice is a production-grade speech understanding application built around the SenseVoiceSmall encoder-only model. It provides automatic speech recognition (ASR), language identification, speech emotion recognition (SER), and audio event detection (AED) via a non-autoregressive CTC pipeline. The Python codebase includes a FastAPI inference server, Gradio web UI, ONNX/Libtorch export utilities, a long-audio inference script with bounded memory, and a fine-tuning workflow backed by DeepSpeed. The repository also ships an independent C++ runtime under `runtime/llama.cpp/` that ports the same model to GGUF format for CPU/edge deployment without Python. While the core model (`model.py`) is a thin wrapper around the FunASR library and tightly coupled to its conventions, supporting utilities like CTC forced alignment, device resolution, and SER evaluation are well-isolated and reusable. The llama.cpp C++ components (VAD, SenseVoice decoder, and an OpenAI-compatible streaming server) are self-contained, architecturally clean, and validated against the PyTorch reference, making them the highest-value reusable assets. The project is actively maintained with recent commits, thorough tests, and CI/CD for both container builds and the C++ runtime.
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.
MediaInfo is a mature, cross-platform application for extracting and displaying technical and tag metadata from audio and video files. It provides a command-line interface (CLI) and multiple graphical front-ends (Qt, wxWidgets, Cocoa, VCL, UWP, Android, iOS) all sharing a common core library (MediaInfoLib). The repository contains the full source for the CLI, all GUIs, Windows shell extension, installers, and build/packaging scripts. The architecture is a classic layered design: a central Core class wraps MediaInfoLib and is consumed by each GUI via platform-specific adapters. The codebase is functional and widely used, but suffers from significant fragmentation across GUI frameworks and build systems, with legacy components (VCL, UWP) and conditional compilation adding maintenance overhead. The translation system using CSV files is well-designed and the command-line parser is robust, but most components are tightly coupled to the MediaInfo domain and not easily reusable outside the project.
Astrofox is a desktop application (Electron + Next.js) for creating audio-reactive motion graphics in real time. It provides a timeline-based editor where users compose layers (2D canvas renderings, 3D geometries, images, videos, text) and apply post-processing effects (blur, glitch, VHS, etc.) that are dynamically modulated by audio analysis via a reactor system. The application supports live input from microphone, desktop audio, and MIDI controllers, and can export videos to file using ffmpeg (desktop) or MediaRecorder (web). The architecture is a monolith with an Electron shell; the UI is a single-page React app with Zustand state management, React Three Fiber for 3D rendering, and a custom WebGL compositor with a pass-based shader pipeline. A plugin system allows external displays and effects via sandboxed workers or shader code. The codebase is extensive but shows signs of technical debt (heavy use of `@ts-nocheck` in many files, legacy migration code, no visible tests). Several subsystems (storage abstraction, audio analysis, compositor passes, ffmpeg wrapper) are well-isolated and could be reused in other projects.