mpv is a free, open-source, cross-platform media player for the command line. It is built on a modular architecture with a stream layer, demuxers, decoders, filters, and audio/video output backends. The codebase is primarily C with some Lua and Swift for scripting and macOS integration. It supports a vast array of media formats via FFmpeg, hardware acceleration (VAAPI, VDPAU, CUDA, D3D11, etc.), and advanced rendering with libplacebo. It also provides a client API (libmpv) for embedding in other applications. The repository is actively maintained with extensive CI, fuzz testing, and a large set of Lua scripts for customization. The code demonstrates high craftsmanship with reusable abstractions like a custom talloc-based memory allocator, a generic filter graph framework, and a render abstraction layer.
This is a cross-platform desktop media player/manager application built with Electron, Vue 3, and TypeScript. It aggregates content from various sources (local files, online sites, IPTV streams) and provides playback through multiple backends including VLC, xgplayer, and artplayer. The application features media library management, history tracking, favorites, live TV support, subtitle/danmaku functionality, proxy settings, cloud synchronization, AI integration, and a plugin/extension system. It includes laboratory tools for cryptographic operations, content analysis, and experimentation. The architecture separates main and renderer processes with Fastify-based internal APIs, uses Pinia for state management, and employs worker pools for CPU-intensive operations.
Shaka Player is a production-grade, client-side JavaScript library for adaptive media streaming in web browsers. It implements the full DASH and HLS manifest parsing pipelines, DRM integration via Encrypted Media Extensions, and a comprehensive plugin system for ad insertion, text display, transmuxing, and device-specific quirks. The architecture is modular with clear separation of concerns: a core Player class orchestrates manifest parsers, streaming engines, ABR algorithms, and UI controls. Key capabilities include offline storage (IndexedDB), CMCD/CMSD metrics reporting, closed captions (CEA-608/708, WebVTT, TTML), and experimental MoQT streaming support. The codebase is heavily tested with over 1,000 unit and integration tests and runs in CI against real browsers and devices (Tizen, Chromecast, Xbox). It is not a data research project; it is a reusable software library designed for embedding in web applications.
IINA is a modern macOS media player built on the mpv framework. It provides a native macOS interface for playing local and online media, with features including subtitle support, playlist management, Touch Bar integration, picture-in-picture mode, and a JavaScript-based plugin system for extensibility. The application follows a modular architecture separating playback core (PlayerCore), UI components, preference management, plugin system, and utilities. Key strengths include a well-crafted threading system (Atomic/ReadWriteAtomic property wrappers), structured logging, and a preference observation pattern. While the core PlayerCore class exhibits some complexity, the overall codebase demonstrates professional macOS development practices with clean abstractions in utility modules and extensibility points.
Kazumi is a cross-platform Flutter application for browsing, collecting, and streaming anime (番剧). At its core, it provides a curated media experience: users can discover anime via popularity rankings, weekly schedules, text and image (trace.moe) search; manage a local watchlist synced with Bangumi (bgm.tv) and WebDAV; and play videos using a hardware-accelerated media_kit (libmpv) player with danmaku overlay, Anime4K super-resolution shaders, Picture-in-Picture, and external player support. It also downloads episodes (HLS segments) for offline playback and supports synchronized group viewing via the Syncplay protocol. The application is built as a Flutter monolith with modular routing (flutter_modular), reactive state management (MobX), local storage (Hive), and a custom plugin system that defines scraping rules (XPath/API) to extract video sources from third-party websites. External dependencies include Bangumi, DanDanPlay, trace.moe, WebDAV servers, and a GitHub-hosted plugin catalog. The codebase demonstrates mature engineering practices including well-isolated async utilities, event-sourced history sync with conflict resolution, and platform-specific WebView integrations for video source extraction and captcha handling.
This repository is an Android TV application (影視TV) that provides a comprehensive media center experience for streaming Video-on-Demand (VOD) and live television. It features a plugin-based content aggregation system using spiders written in Java, Python (via Chaquopy), and JavaScript (via QuickJS), allowing users to browse and play content from multiple external sources. The application supports multiple player engines (ExoPlayer and mpv), hardware/software decoding, subtitle and danmaku (bullet comment) overlays, DLNA casting (both sender and renderer), and a local HTTP server for remote control and file sharing. Architecturally, the project is a multi-module Gradle build with a shared core library (catvod) providing network utilities, cryptography, and data models. The main app module contains two UI tracks: 'leanback' for TV remote control navigation and 'mobile' for touch-based phone interaction, both sharing common logic under app/src/main. The system uses an event-driven architecture with EventBus, a Room-based SQLite database for persistence, and a ViewModel pattern for reactive UI updates. External content sources are integrated through a standardized Spider interface, with loaders for JAR, Python, and JavaScript plugins. Key features include a sophisticated playback controller with fallback policies, preloading, and history management; extensive audio/video effect pipelines (equalizer, loudness normalization, color adjustment); danmaku search and display; EPG (Electronic Program Guide) with timezone-aware parsing; and a comprehensive settings system covering player, decoding, subtitles, and network configuration. The project also includes a documentation website built with Next.js, providing developer guides for the spider API and local HTTP API.
Litefin is a high-performance, native Jellyfin media client designed specifically for Samsung Tizen and LG webOS smart TVs. It is built as a single-page web application using vanilla JavaScript with a custom component framework, no external UI libraries. The architecture is event-driven, centered around a global EventBus, StateManager, and Router. The application provides full media browsing, playback with advanced subtitle rendering (ASS/SSA via libass-wasm), live TV with EPG, SyncPlay group synchronization, a plugin system, and integration with Jellyseerr for media requests. It is optimized for TV remote control navigation with a sophisticated FocusManager and spatial navigation engine. The system communicates with a Jellyfin server via REST API and WebSocket for real-time events. It also integrates with TMDB (via Jellyseerr) for metadata and trailers, and uses a background service (Luna on WebOS, HTTP proxy on Tizen) for device discovery, Wake-on-LAN, and Smart Hub preview. The codebase is organized into core modules (App, Router, EventBus, StateManager), UI components (pages, modals, grids), a player subsystem with OSD menus, and platform adapters for Tizen and WebOS. It supports multiple build variants (Modern, Normal, Legacy, Ultra-Legacy) to accommodate different Chromium versions on TV firmware. Key entry points include src/index.js (bootstrap), src/core/App.js (orchestration), and src/core/Router.js (navigation). Data flows primarily through the ApiClient for Jellyfin endpoints and the WebSocketHandler for server push events. The plugin system allows third-party extensions like skip-intro and mdblist-ratings. The application is heavily optimized for TV hardware, using GPU-accelerated CSS transforms, lazy loading, and memory-efficient virtual scrolling.
DUNE is a specialized Android TV client application for the Jellyfin media server ecosystem. It functions as a media consumption interface optimized for remote control navigation, featuring video/audio playback, library browsing, live TV (DVR) management, and extensive user customization. The architecture is a monolithic Android application with modularized internal structure (app, playback, preference modules), utilizing a hybrid UI approach that combines Jetpack Compose for modern screens (preferences, overlays) with Android Leanback widgets for traditional TV browsing. The codebase demonstrates strong separation of concerns, particularly in the playback layer which abstracts media rendering logic from the UI. It relies heavily on the Jellyfin SDK for API communication and ExoPlayer (Media3) for media rendering.
Clapper is a modern media player application designed for the GNOME desktop, built with GTK 4 and powered by GStreamer. It features a queue-based playback system supporting sequential, repeat, carousel, and shuffle modes, along with standard media controls like play/pause, seeking, volume adjustment, and fullscreen toggling. The application emphasizes usability with an adaptive interface, subtitle/audio track selection, playback speed control, and media information display showing technical details such as codecs and bitrates. The architecture consists of three main layers: a core library (`clapper`) handling playback logic, queue management, and extensibility via plugins; a GTK library (`clapper-gtk`) providing reusable widgets like video display, buffering indicators, and custom layouts; and the main application (`clapper-app`) assembling the user interface and integrating with the core. Extensibility is achieved through a libpeas-based plugin system for metadata extraction, playlist parsing, and reactive components, while optional features like MPRIS and a built-in web server for remote control are marked as deprecated in favor of the external enhancer ecosystem. Clapper demonstrates strong engineering practices with proper GObject encapsulation, thread-safe design using a custom `ClapperThreadedObject` base class, and adherence to GTK 4 patterns such as template-based widgets and action-driven UI. The project maintains active development with recent commits, comprehensive internationalization support, and integration with modern GNOME technologies like libadwaita, though it relies on evolving dependencies (GStreamer, GTK) and contains some deprecated components requiring ongoing maintenance.
SmartTube is a free, open-source Android TV YouTube client that replaces the official YouTube app with enhanced features like SponsorBlock integration, adjustable playback speed, 8K/HDR support, live chat, and no dependency on Google Services. The architecture is a modular Android application built on a heavily customized fork of ExoPlayer (v2.10.6, Amazon variant) for media playback, and AndroidX Leanback (v1.0.0) for the TV-optimized user interface. The codebase follows a presenter-view pattern with clear separation of concerns, using singleton presenters and view interfaces. Key entry points include SplashActivity, BrowseActivity, PlaybackActivity, and various settings dialogs. Data flows primarily from YouTube's unofficial API (via SABR streaming protocol) through custom ExoPlayer extensions, with additional integrations for SponsorBlock, DeArrow, remote control, and Google Drive backup. External dependencies include ExoPlayer (forked), Leanback (vendored), Glide, RxJava, WorkManager, and a few third-party UI libraries (chatkit, slidableactivity, filepicker).
This repository is the manifest and build orchestration layer for Nova Video Player, an open-source Android video player. It does not contain the application source code itself; that resides in referenced submodules (Video, MediaLib, FileCoreLibrary, native/avos, etc.). The repo provides a repo-based manifest, Makefile, Dockerfile, CI/CD workflows, release scripts, comprehensive FAQ documentation, and SDK setup scripts. The build system is sophisticated, supporting native code compilation (FFmpeg, dav1d, libtorrent, etc.) via Android NDK, Gradle wrappers, and external dependency management. The repo is actively maintained with frequent releases and detailed changelogs. While the core application code is not present here, the build infrastructure demonstrates high craftsmanship with clear documentation, automated releases, and continuous integration. The repo serves as an entry point for building the entire application across multiple stores (Google Play, Amazon, F-Droid).
This is an Android TV application that serves as a client for media servers (primarily Jellyfin). It implements a Clean Architecture with clear separation between Data, Domain, and Presentation layers, using Jetpack Compose for the UI, Hilt for dependency injection, and Kotlin Coroutines/Flow for asynchronous operations. The application provides a TV-optimized interface for browsing media libraries, playing content with support for multiple players (ExoPlayer and MPV), handling subtitles/audio tracks/video quality, and managing user preferences. Key features include offline caching, background synchronization, advanced video format support (HDR, Dolby Vision), and a polished user experience with animations and focus handling for TV remotes.
NuvioTV is a full-featured Android TV media player application that aggregates content from Stremio-style addons, debrid services (Real-Debrid, Torbox, Premiumize), and torrent streaming via TorrServer. It provides a rich browsing experience with personalized continue-watching, library management, and cross-device watch progress sync through a Supabase backend. The application deeply integrates with tracking services (Trakt and Simkl) for scrobbling and history, and includes an extensive settings system for theme customization, playback controls, and addon management. Architecturally, it is a single-module Android app built with Kotlin, Jetpack Compose for TV (androidx.tv.material3), Hilt dependency injection, and a custom fork of AndroidX Media3 (ExoPlayer) with native components for Dolby Vision processing, subtitle sanitization, and frame-rate detection. The codebase follows MVVM with ViewModels emitting sealed UI states via StateFlow, and uses DataStore for per-profile preferences. It includes two build flavors (full with plugin runtime and updater, playstore with stripped features) and an extensive test suite covering sync logic, playback policies, and data migrations. The system's complexity lies in its multiple external integrations (addon protocol, debrid APIs, tracking providers, Supabase RPC) and the custom player pipeline that handles codec failover, subtitle merging, and adaptive bitrate control. While the code is generally well-structured with clean abstractions and reusable UI components, it suffers from moderate technical drift due to vendored AndroidX modifications, flavor divergence, and reliance on rapidly evolving third-party APIs.
Aerial Views is an Android TV screensaver (DreamService) that plays aerial videos and photos from multiple sources—Apple, Amazon, community feeds, local storage, Samba, WebDAV, Immich, Nextcloud Memories, and custom feeds. It provides a rich overlay system (clock, date, weather, metadata, now-playing, countdown, message API) and supports hardware vendor integrations (Projectivy, Philips TVs). The architecture follows a provider pattern with a central ScreenController orchestrating playback, overlays, and services. The codebase is actively maintained with extensive internationalization, unit tests, and CI/CD. While the provider abstractions are clean and extendable, the ScreenController is large and tightly coupled, and the app has moderate technical drift (deprecated APIs, unusual compileSdk 37). Overall it's a well-engineered, feature-complete application for its niche.
vlc-bittorrent is a VLC media player plugin that enables direct streaming of .torrent files and magnet links. It integrates libtorrent-rasterbar to handle the BitTorrent protocol, providing three VLC submodules: a stream_directory module to list torrent contents as a virtual directory, a stream_extractor module to stream individual files with on-demand piece downloading and priority-based piece selection, and an access module to resolve magnet URIs by downloading metadata from peers. The plugin manages a single libtorrent session shared across multiple torrents, handles asynchronous alerts via a dedicated thread, and supports interruptible I/O compatible with VLC's blocking read model. It includes a comprehensive test suite with TAP output and deterministic expected results.
This repository is a Home Assistant custom component that integrates Amazon Alexa/Echo devices into Home Assistant. It allows users to control media playback (play, pause, volume, source selection), manage alarms and timers, control smart home devices (lights, switches, sensors, alarm control panel for Alexa Guard), and send notifications (TTS, announcements, mobile push). The component authenticates with Amazon's unofficial internal API via the `alexapy` library, supporting OAuth, TOTP, and 2FA. Architecture follows Home Assistant's component pattern: a config flow for setup, multiple entity platforms (media_player, sensor, switch, light, alarm_control_panel, binary_sensor, notify), a `DataUpdateCoordinator` for polling with HTTP2 push fallback, and custom services. Data flows from Amazon's cloud to HA via either polling (configurable interval) or push updates (WebSocket/HTTP2), with caching and debouncing to reduce API calls. External dependencies include `alexapy`, `packaging`, `wrapt`, and `dictor`. The component is distributed via HACS (Home Assistant Community Store) and supports multiple Amazon accounts with extensive localization.
Plyr is a widely-used, client-side JavaScript library that provides a simple, accessible, and customizable media player for HTML5 video/audio, YouTube, and Vimeo. It is implemented as a modular class with plugins, utilities, and a comprehensive SCSS theming system. The library handles all aspects of media playback: custom controls, captions (VTT), fullscreen, picture-in-picture, AirPlay, speed and quality selection, preview thumbnails, and ads (Google IMA). It uses a build system based on Gulp and Rollup, produces ES and UMD bundles, and includes a polyfilled variant for older browsers. The codebase is well-organized with clear separation of concerns (controls, captions, fullscreen, listeners, storage, plugins) and extensive JSDoc documentation. However, it exhibits some technical drift, including legacy UA sniffing, a large controls module marked for refactoring, and deprecated build tooling. Despite this, the library remains actively maintained and is production-ready, with a robust demo site and a large user community.
MediaElement is a mature, client-side JavaScript library that provides a consistent, cross-browser HTML5 video and audio player experience. It wraps native `<video>` and `<audio>` elements with a unified API and UI, while supporting a plugin-based renderer system for fallback and streaming formats including YouTube, Vimeo, HLS, DASH, Facebook, SoundCloud, Twitch, and Dailymotion. The library is distributed as two bundles: a core `mediaelement.js` (API only) and `mediaelement-and-player.js` (with full UI controls). It includes internationalization (i18n) for over 30 languages, subtitle/caption track support, and a range of player features (play/pause, progress bar, volume, fullscreen, time display) that can be customized via a feature injection pattern. Architecturally, the codebase is organized into core modules (`mejs.js`, `mediaelement.js`, `renderer.js`, `i18n.js`), renderer implementations (each self-contained and registered via a common interface), player features (each added as a method on the player prototype), and utility functions (DOM helpers, time formatting, media type detection, polyfills). The build system uses Grunt with Browserify and Babel 6, targeting older browsers (IE10+, iOS 7+, Android 3+). The library is designed to be framework-agnostic but includes optional jQuery/Zepto integration. While the library is functionally complete and widely used, it shows signs of technical drift: the build toolchain is outdated (Grunt, Browserify 13, Babel 6), some dependencies are stale, and the codebase relies on global namespace pollution (`window.mejs`). The player class (`player.js`) is monolithic and handles many responsibilities. Despite these issues, the core abstractions—especially the renderer registry and i18n engine—are well-designed and could be extracted for reuse in other projects.
Litube is an advanced Android WebView wrapper for YouTube, providing ad-free playback, native video/audio downloading, background play, Picture-in-Picture (PiP), SponsorBlock integration, and a customizable extension system. It uses a hybrid architecture where YouTube's mobile site is rendered in a WebView via `YoutubeFragment`, while video playback is handled natively using AndroidX Media3 (ExoPlayer) with custom `YoutubeHttpDataSource` for streaming. The app includes a full-featured download manager (multi-threaded chunked downloads, audio/video merging with MP4Parser), a queue system, a mini-player, and gesture controls. It reverse-engineers YouTube's streaming protocols using the NewPipe Extractor and generates PoTokens through a WebView-based mechanism to bypass bot detection. The application is structured as a single-module Gradle project with Dagger Hilt for dependency injection, MMKV for key-value storage, and Gson for serialization. It has extensive JavaScript injection (`init.js`) to manipulate the YouTube DOM for features like hiding Shorts, displaying dislikes, and injecting a custom settings page. While primarily an application, it includes data extraction components (stream catalog, delivery analysis) that could be considered a research layer for understanding YouTube's streaming infrastructure.
MPC-QT is a desktop media player application that replicates the interface and functionality of Media Player Classic (MPC-HC) using Qt6 and libmpv. It supports local files, discs, network streams, and web videos (via yt-dlp), with advanced playback controls, playlist management, subtitle handling, hardware decoding, and HDR tone mapping. The architecture is a monolithic Qt Widgets GUI with a separation between the UI (MainWindow, SettingsWindow, PlaylistWindow), playback orchestration (PlaybackManager), mpv integration (MpvObject), and cross-platform abstractions (screensaver, device manager). IPC mechanisms include a JSON socket, HTTP server (MPC-HC compatible), and MPRIS D-Bus. The codebase is feature-rich but shows signs of technical debt: large files, manual memory management, hardcoded indices in settings, and incomplete localization. It is actively maintained with CI/CD pipelines for Linux and Windows, but translation files have many unfinished or vanished strings.