Mutagen is a mature, comprehensive Python library for reading and writing audio metadata across virtually all common formats, including MP3 (ID3v1/v2, APEv2), FLAC, Ogg Vorbis/Opus/Speex/Theora, MP4/M4A, ASF/WMA, WavPack, AIFF, DSF, DSDIFF, True Audio, Musepack, Monkey's Audio, OptimFROG, AAC, AC3, and more. It provides a consistent dictionary-like API for tag manipulation, format-specific stream info (bitrate, sample rate, channels, length), and low-level access to container structures (Ogg pages, ID3 frames, IFF chunks, MP4 atoms). The library is designed for embedding in larger applications (e.g., Quod Libet, Beets, MusicBrainz Picard) and also ships several command-line tools: mid3v2 (ID3 tag editor), mid3iconv (ID3 encoding converter), mid3cp (ID3 tag copier), moggsplit (Ogg stream splitter), mutagen-inspect (format inspector), and mutagen-pony (ID3 health checker). Architecturally, Mutagen follows a layered design: a base `FileType` class with format detection via static `score()` methods, per-format modules that parse container headers and metadata, and a shared utility layer (`_util.py`) providing file I/O decorators, binary packing/unpacking (`cdata`), bit-level readers, dictionary mixins, and padding management. The ID3 subsystem is particularly sophisticated, with a declarative frame specification system (`_specs.py`) that handles encoding, version conversion, and unsynchronization. The Ogg subsystem provides a clean `OggPage` abstraction reused by all Ogg-based formats. The IFF subsystem (`_iff.py`) generalizes chunk-based containers for AIFF, RIFF/WAVE, and DSDIFF. Data flows are straightforward: the user opens a file via `mutagen.File()` or a format-specific constructor, which triggers header parsing and tag loading. Tags are exposed as mutable dictionaries; saving writes updated metadata back to the file with configurable padding. The library supports file-like objects and pathlib paths throughout. External dependencies are minimal (pure Python, no runtime dependencies beyond the standard library), making it highly portable. The test suite includes over 3000 tests, fuzzing infrastructure, and a large corpus of synthetic audio fixtures covering edge cases and malformed inputs.
SpotiFLAC-Mobile is a cross-platform mobile application (Android and iOS) that enables users to download and play high-fidelity music in lossless formats such as FLAC and DSD. It operates through an extension-based architecture where community-provided plugins supply download sources, metadata, lyrics, and cover art. The application integrates with streaming services like Deezer, Tidal, Qobuz, and Spotify via these extensions, handling authentication, rate limiting, and content resolution. The system is built on a multi-language stack: a core Rust backend handles audio processing, metadata tagging, library management, and network communication; a Flutter (Dart) frontend provides the user interface; and platform-specific code in Kotlin (Android) and Swift (iOS) bridges native features like file system access, USB audio output, and system audio routing. The Rust backend is exposed to mobile languages via UniFFI-generated bindings. Key data flows include: extension-based download orchestration with cancellation and progress reporting, audio file finalization (metadata embedding, ReplayGain scanning, cover art insertion), incremental library scanning with SQLite persistence, and multi-provider lyrics fetching with caching. The application also features hi-res audio authenticity verification using STFT analysis, direct USB audio output for bit-perfect playback, and a comprehensive extension management system with sandboxed JavaScript runtimes. External dependencies include FFmpeg for audio conversion, libusb for USB audio transport, and various web APIs (Deezer, MusicBrainz, LRCLib, Apple Music, etc.) for metadata and lyrics enrichment. The project demonstrates strong engineering practices with extensive unit and integration tests, a modular crate architecture, and reusable patterns for cancellation, progress tracking, and caching.
SpotiFLAC is a cross-platform desktop application (built with Wails v2) that enables users to download high-quality FLAC audio from streaming services (Tidal, Qobuz, Amazon Music, Deezer) by leveraging Spotify metadata. The user inputs a Spotify track, album, playlist, or artist URL; the backend fetches metadata via Spotify's internal GraphQL API using reverse-engineered TOTP authentication, resolves streaming URLs through Songlink/Songstats, then downloads from the chosen service. The app includes a comprehensive suite of audio processing tools: audio analysis (spectrogram, FFT), BPM/key detection (Essentia.js), format conversion, resampling, ReplayGain tagging, lyrics management (LRCLIB), metadata enrichment, and file management. The frontend is built with React 19, TypeScript, Tailwind CSS, and shadcn/ui components, communicating with the Go backend via Wails bindings. The backend handles persistent storage (BoltDB for queue, history, caches), FFmpeg integration, and community API sessions for Tidal/Qobuz/Amazon. The architecture is a monolith desktop app with a clear separation between frontend UI and backend services, but the backend modules are tightly coupled to the app's specific workflow. The app is open-source (MIT) with a Patreon funding model and has a large internationalization footprint (11 languages). Key entry points include the SearchBar for URL input, the download queue for batch processing, and various tool pages (Audio Analysis, Converter, Resampler, ReplayGain, File Manager, Lyrics Manager). External dependencies include Spotify's undocumented API, Tidal/Qobuz/Amazon community APIs, Songlink, LRCLIB, MusicBrainz, FFmpeg, and Essentia.js. The codebase demonstrates significant reverse-engineering effort but carries maintenance risks due to reliance on fragile third-party APIs and hardcoded secrets.
fre:ac is a mature, cross-platform audio converter and CD ripper with a plugin-based component architecture. The system is built on the BoCA framework and smooth GUI library, providing both a graphical interface (freacGUI) and a command-line interface (freaccmd). In production it handles audio format conversion (MP3, AAC, FLAC, Opus, WMA, etc.), CD ripping with freedb/CDDB metadata lookup, AccurateRip verification, tag editing, and even YouTube/Vimeo video downloading via JavaScript-based site scripts. The codebase is extensive (906 files) with heavy use of the BoCA component system for decoders, encoders, DSP processors, verifiers, and extensions. Key entry points are src/loader/gui.cpp and src/loader/console.cpp. The architecture follows a job-based conversion pipeline with worker threads, progress reporting, and configuration persistence. Internationalization is comprehensive (40+ languages). While the code demonstrates solid engineering with signal/slot decoupling and reusable components, it carries technical debt from legacy V8 API usage, manual memory management, and platform-specific #ifdefs.