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.
Live Photo Converter is a cross-platform application for processing Android Live Photos (MVIMG files). It provides a modern GTK4/LibAdwaita graphical interface, a set of command-line tools, and a shared library (`liblivephototools`) for creating, extracting, and repairing these files. The core operation involves appending an MP4 video to a JPEG image and managing the associated XMP metadata (Google's GCamera and Container namespaces). It also supports generating long exposure photos from video frames and copying metadata between images. The architecture is a well-structured monolith written in Vala and built with Meson. The core logic resides in a shared library, with CLI and GUI frontends linking against it. Video processing is handled by a clean strategy pattern, defaulting to an in-process GStreamer pipeline with an FFmpeg subprocess fallback. The build system is highly sophisticated, supporting Linux (Flatpak, Arch), Windows (MSYS2), macOS (Homebrew), and Android (experimental, via pixiewood). The codebase demonstrates strong software craftsmanship. It features clean abstractions (abstract base classes `LivePhoto`/`LiveMaker`), meticulous thread safety (GOnce, AtomicInt, AsyncQueue, Mutex), and well-encapsulated utility components. The `PipelineWatch` class for GStreamer error handling and the `Reporter` class for CLI output are particularly well-crafted and reusable. The primary weakness is the absence of a formal unit test suite, which prevents a higher quality score.
Yasea is an Android live-streaming library and demo application that captures camera video and microphone audio, applies real-time GPU image filters, hardware-encodes to H.264/AAC via MediaCodec, muxes into FLV, and publishes over RTMP to servers such as SRS. The main entry point is SrsPublisher, which orchestrates SrsCameraView (an OpenGL ES preview surface), SrsEncoder (MediaCodec lifecycle and format negotiation), SrsFlvMuxer (FLV-over-RTMP publishing), and SrsMp4Muxer (simultaneous MP4 recording). The demo app (MainActivity) provides a working UI for URL entry, publish/pause, camera switching, recording, and filter selection. Architecturally, the repo is a Gradle project with two modules: a reusable Android library (library/) and a demo app (app/). The library is a monolith that bundles large vendored third-party codebases as source: Google's libyuv (native YUV/RGB conversion and scaling), mp4parser (ISO BMFF/MP4 parsing and authoring), simple-rtmp (RTMP client protocol), and MagicCamera (40+ GPU image filters with GLSL shaders). The repo's own code is the net.ossrs.yasea package, which integrates these pieces: camera frames flow through the GLSurfaceView filter chain as RGBA, are converted to I420/NV12 by the libenc JNI bridge (libenc.cc wrapping libyuv), encoded by MediaCodec, and muxed to FLV/MP4. Audio is captured via AudioRecord and encoded to AAC. Despite a recent commit, the codebase is frozen in the 2017-2020 Android era: compileSdk/targetSdk 26, Android support library 26.1.0, the deprecated Camera API, Gradle 6.5 with AGP 4.1.1, and a mips ABI that modern NDKs no longer support. The native build is commented out in library/build.gradle, and 285 open issues remain. Technical drift is high. This is purely an application/library repo - no data pipelines, notebooks, or research components.
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.