uStreamer is a lightweight, high-performance MJPEG-HTTP video streaming server designed primarily for PiKVM (IP-KVM over HDMI). It captures video from V4L2 devices (USB cameras, HDMI capture cards) and streams it as MJPEG over HTTP with sub-second latency, while also supporting H.264 streaming via WebRTC through a Janus plugin. The system is a single, multithreaded C daemon with pluggable JPEG encoders (CPU via libjpeg-turbo, hardware passthrough, and V4L2 M2M acceleration) and includes a worker pool for parallel encoding. It integrates tightly with Linux multimedia subsystems (V4L2, ALSA, DRM) and provides additional features like audio capture/playback with Opus encoding, GPIO control, systemd socket activation, and shared memory IPC for zero-copy frame access by other processes (e.g., Janus, Python bindings, dump tool). The codebase is production-grade, extensively tested in the PiKVM ecosystem, and packaged for multiple Linux distributions and container environments. The architecture separates concerns into clean modules: capture (V4L2 buffer management with DMA export), encoding (abstraction over CPU/HW/M2M), HTTP server (libevent-based, serving MJPEG streams, snapshots, and static assets), and a generic worker thread pool for parallel JPEG compression. Shared memory sinks (memsink) enable efficient frame transfer to external consumers like the Janus WebRTC plugin or the standalone dump utility. The project also includes a full-featured Janus plugin for H.264/Opus streaming with NTP timestamping and PLI handling, a Python C extension for shared memory client access, and a separate V4 passthrough tool for the PiKVM V4 Plus hardware. Build configuration uses Makefiles with numerous feature flags (WITH_GPIO, WITH_JANUS, WITH_SYSTEMD, etc.), permitting a modular build. Overall, uStreamer exemplifies careful engineering of real-time video pipelines on embedded Linux, with a focus on minimal latency, hardware offload, and robust IPC.
SRS (Simple Realtime Server) is a high-performance, multi-protocol media streaming server primarily written in C++ with a newer Go-based proxy component (SRSX). It ingests, processes, and delivers live audio/video streams via RTMP, WebRTC (WHIP/WHEP), HLS, HTTP-FLV, SRT, and GB28181. The core C++ engine uses a coroutine model built on state-threads, implements stream forwarding, transcoding via FFmpeg, and provides a full HTTP API for management. The Go proxy component (cmd/proxy, internal/) adds load balancing, Redis integration, and protocol proxying for RTMP/HTTP/WebRTC, designed to scale origin/edge deployments. The repository also includes extensive research code, blackbox integration tests, and vendored third-party libraries (FFmpeg 4, OpenSSL 1.1, gperftools, SRT, libsrtp) that have been customized with a '-fit' suffix. This hybrid architecture is actively developed with multiple CI workflows and a large test suite, though some vendored dependencies are older and may require security updates.
DistroAV is an OBS Studio plugin that enables real-time network audio/video transmission using NDI technology. It implements both NDI sources (receiving streams) and NDI outputs (transmitting the main scene, preview, or per-source filters) within OBS. The architecture is a standard OBS plugin: it registers custom source, output, and filter types using the OBS API, provides a Qt-based settings dialog for configuration, and includes an automatic update checker. Key data flows involve capturing OBS video/audio frames, converting them to NDI frames using the NDI SDK (v6.3+), and sending/receiving over the network. External dependencies include the NDI runtime library, OBS Studio 31.1.1+, Qt6, and libcurl for updates. The codebase is well-structured with cross-platform CMake build system, CI/CD pipelines, and internationalization support, though it relies on a proprietary SDK and contains some legacy code paths.
MediaCMS is a production-grade, self-hosted video and media content management platform built as a Django monolith with a React frontend. In production it ingests video, audio, image, and PDF uploads via a chunked Fine Uploader flow, transcodes video through FFmpeg into multiple MP4/HLS renditions matched by configurable encoding profiles, streams them through a customized video.js player, and supports subtitles (manual upload and Whisper transcription), chapter markers, video trimming/editing, playlists, comments with mention notifications, likes, reports, and PostgreSQL full-text search. It ships a REST API under /api/v1/, an editor/manager admin UI, RSS feeds with Yahoo Media RSS extensions, and a small Click-based CLI. The backend is organized into Django apps (files, users, actions, rbac, lti, saml_auth, identity_providers, migrationservice, uploader) with DRF serializers/views, Celery workers for encoding and notifications, Redis as broker, and Nginx serving protected media through an auth_request subrequest. A significant portion is education/LMS-focused: an LTI 1.3 tool provider with deep linking, SAML authentication, RBAC groups mapped to categories, Moodle filter and TinyMCE plugins, and a migration service that imports media, captions, and users from Kaltura, Panopto, and YouTube with quiet-hours scheduling and encrypted credentials. This gives the repository a mild data-pipeline flavor through the migration service, but its dominant character is a full web application. Engineering quality is strong for an open-source Django project: extensive pytest coverage across API, permissions, LTI, SAML, RBAC, migration providers, and pipeline tasks; a large Jest suite for frontend components, hooks, and stores; semantic-release and pre-commit CI; and a clean provider abstraction for migration sources. Weaknesses include legacy webpack-built minified bundles checked into static/, a mix of JSX and TSX across the frontend, duplicated iOS player code between the video-editor and chapters-editor tools, several TODO/FIXME markers, and version-sensitive external dependencies (yt-dlp, Moodle, LTI). Overall it is an actively maintained codebase with several genuinely reusable components, though it carries moderate legacy debt in its frontend tooling.
This repository contains a native WebRTC streaming application designed for Raspberry Pi and NVIDIA Jetson platforms. It captures video from various camera sources (libcamera, libargus, V4L2) and audio from PulseAudio/ALSA, encodes the streams using hardware acceleration when available or software fallbacks, and transmits them via WebRTC with multiple signaling options (MQTT, WebSocket, HTTP/WHEP). The application includes recording capabilities, snapshot functionality, and IPC for local control. The architecture is modular with clearly separated concerns for capture, encoding, signaling, and real-time communication.
SimpMusic is a production-grade Kotlin Multiplatform music player for Android and desktop (JVM) that streams from YouTube Music's undocumented backend. The codebase is organized around a shared Compose Multiplatform UI module (composeApp), Android entry points (androidApp), a desktop entry point (desktopApp), and optional feature modules for Google Cast, Last.fm scrobbling, and crash reporting. A separately referenced core submodule supplies domain and media-service logic. Internally it uses MVVM with Koin dependency injection, Repository interfaces backed by Room entities and DataStore, StateFlow-based ViewModels, and a large custom Compose component library covering home feed, library management, playlist sync, fullscreen player, lyrics, equalizer, podcasts, Android home-screen widgets, and a desktop mini-player. The app is shipped as a packaged consumer application with Play Store metadata, GitHub Actions, fastlane changelogs, and build variants that swap real integrations for empty stubs in FOSS builds.
CloudStream is an Android media aggregation application that streams and downloads movies, TV series, and anime via a plugin-based provider system. The app has no built-in content; all media sources are provided by community extensions implementing `MainAPI` and `ExtractorApi` interfaces. The architecture comprises a Kotlin Multiplatform library defining plugin APIs and an Android app with ExoPlayer/Media3 playback, download manager, sync with tracking services (MAL, AniList, Kitsu, Simkl, Trakt), multi-source subtitle fetching, Chromecast support, and adaptive phone/TV UI. Content acquisition relies on web scraping: over 100 built-in extractors parse video hosting sites, often using JavaScript deobfuscation (via a custom JS interpreter) and AES decryption. The plugin system supports repository-based distribution, versioning, and binary compatibility checks. While the codebase is actively maintained and demonstrates good engineering practices (MVVM, coroutines, custom adapters), many extractors are brittle due to external site dependencies, and some modules exhibit tight coupling and deprecated API usage.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
Awesome Video is a curated resource catalog for streaming video technologies, maintained as structured JSON (contents.json) and rendered into both a README and a static documentation site (MkDocs Material) deployed to awesome.video. The catalog spans ~50 hierarchical categories covering HLS, DASH, FFmpeg, codecs (HEVC/VP9/AV1), transport protocols (RIST/SRT/RTMP), players, DRM, QoE, testing, CDN, HDR, subtitles, and learning resources. It is not a runtime application — it is a content curation pipeline: contents.json is the source of truth, convert.rb generates the README, database.json feeds the site's lunr search index, and loader.py imports bookmarks from Raindrop.io. The repo is hybrid in nature: primarily a curated data catalog with a static-site build system around it, rather than a software application or research pipeline. The build pipeline (GitHub Actions) validates the JSON against schema.json, checks external links with awesome_bot, and deploys to GitHub Pages. The curation quality is strong — entries include authoritative references (Netflix TechBlog, DASH-IF specs, Apple WWDC sessions, Xiph test media) — but the supporting code is simple utility scripting with notable weaknesses: hardcoded Raindrop.io credentials in loader.py, inconsistent category identifiers and malformed tag entries in the data, and aging CI dependencies (Python 3.7, jinja2 3.0.3). The repo is actively maintained and the data model (hierarchical categories + multi-tagged project records) is a clean, portable schema for any awesome-list-style content site.
Streama is a self-hosted media streaming server implemented as a Grails 3 (Groovy) monolith with an AngularJS 1.x single-page application frontend. In production, it allows users to upload or mount video files (movies, TV shows, generic videos), fetch metadata from TheMovieDB, stream videos via HTTP range requests (or optional transcoding via FFmpeg), manage subtitles (manual or from OpenSubtitles), track viewing progress, and manage multi-profile accounts with role-based access. The system relies on MySQL (or H2 for dev), Java 8, and external APIs (TheMovieDB, OpenSubtitles). The architecture is a traditional Grails web application with RESTful controllers, Groovy services for business logic, and a rich client-side AngularJS interface that includes a custom video player directive, admin panels, and dashboard views. The codebase shows signs of a long-lived project with a large number of vendored frontend dependencies (Bower-managed), some now outdated (AngularJS 1.x, jQuery UI, Bootstrap 3). While the application is functional and well-documented, the technology stack is aging, and the frontend particularly would benefit from modernization.
This repository is a collection of Kodi/XBMC addons focused on media streaming, playback, and extended functionality. It contains numerous plugin.video.* and plugin.audio.* addons that scrape or API-fetch content from various online sources (e.g., MEGOGO.NET, Kinozal.tv, YouTube, torrent sites) and integrate with Kodi's media player. The repository also includes utility modules for HTML parsing (html5lib, BeautifulSoup), JSON handling (simplejson), downloading, caching, and framework components (xbmcswift2). The architecture is a collection of largely independent addons, each with its own default.py entry point, shared libraries, and resource files. Data flows involve fetching metadata from external sources, parsing it into Kodi-compatible formats, and passing media URLs to Kodi's player. External dependencies include Kodi/XBMC APIs, vendored Python libraries (html5lib, beautifulsoup4, simplejson), and external web services/APIs.