membraneframework/membrane_demo

This repository is a curated collection of Elixir-based demo applications built on the Membrane Framework, designed to illustrate real-time media processing and streaming capabilities. It provides concrete examples for ingesting, transcoding, and serving audio and video via protocols such as RTMP, RTP, RTSP, and WebRTC, as well as converting streams to HLS. The system also integrates AI and machine learning features, including speech-to-text transcription, object detection, and voice conversations, demonstrating how to embed these models into media pipelines.

7 changes.

The project underwent a significant reorganization, shifting from a single sample pipeline to a categorized collection of Membrane Framework examples under the Apache 2.0 license. This period focused on expanding the demo library with new applications for embedded systems, adaptive streaming, and secure RTP, while removing obsolete legacy code and placeholder tests.

6 changes.

This period focused on expanding the project's demonstration suite with new standalone applications for RTP-to-HLS streaming, simple audio pipelines, and custom element creation. It also enhanced the existing RTP demo by adding dedicated send and receive pipelines for H.264 and Opus streams, including optional SRTP encryption support.

11 changes.

This period focused on significantly expanding the project's demo library with new applications for live video streaming, including camera, RTMP, and WebRTC integrations. It also introduced AI-powered examples for speech-to-text, voice conversations, and object detection, alongside foundational updates to configuration and core plugin usage.

Introduces a new demo application for Raspberry Pi running Nerves that captures video from a camera module and broadcasts it via HLS. The project includes the necessary Elixir/Erlang configuration, a Membrane pipeline for video processing, and an embedded web server to serve the stream at http://nerves.local:8000/stream.html.

_camera\_to\_hls\nerves · high confidence

This change introduces a new demo application that receives an RTMP stream, transcodes it into multiple adaptive bitrate variants, and serves them as an HLS playlist via a web interface. The server listens for RTMP input on port 9006 and exposes the resulting HLS streams on port 4000, where a Vidstack-based web player allows viewers to switch between quality levels based on network conditions.

_rtmp\_to\_adaptive\hls · high confidence

The RTP demo now includes dedicated send and receive pipeline implementations that handle H.264 video and Opus audio streams over UDP. The send pipeline reads local sample files, parses and payloads the media into RTP packets, and transmits them via UDP, while the receive pipeline listens on UDP ports, demuxes and depayloads the RTP streams, decodes the media, and plays it back. Both pipelines support optional SRTP encryption via ExLibSRTP when configured.

rtp/lib · high confidence

Introduces a new \webrtc\_live\_view\ application that demonstrates real-time video streaming using Phoenix LiveView and the Membrane WebRTC plugin. The demo captures local media via the browser, processes it through a Membrane pipeline (including contour detection via Evision/Vix), and streams the result back to the client. It includes the necessary Phoenix web stack (router, endpoint, layouts, core components) and JavaScript hooks (\Capture\, \Player\) to manage the WebRTC connection and media rendering within the LiveView interface.

_webrtc\_live\view · high confidence

A new Livebook example has been added to the speech\_to\_text directory, demonstrating real-time speech-to-text conversion. The demo uses the Membrane Framework for audio pipeline management (capturing input via PortAudio) and Bumblebee with the OpenAI Whisper model for transcription. It includes a custom Membrane filter that handles audio preprocessing, voice activity detection, and model inference using the EXLA backend.

_speech\_to\text · high confidence

The rtp location now includes a functional demo for sending and receiving RTP streams, featuring scripts (send.exs, receive.exs) that launch Membrane pipelines for video and audio. Users can run the sender and receiver locally to view a video player, or use external tools like GStreamer to send streams to the receiver. The demo also supports secure streaming via SRTP by passing a --secure flag, utilizing a hardcoded SRTP key for demonstration purposes.

rtp · high confidence

The simple\_element demo now includes a new Counter element that tracks incoming audio buffers and emits a notification with the count (divided by a configurable divisor) at a specified time interval. The demo pipeline processes an MP3 file through a decoder and format converter, feeds the audio into the Counter element, and outputs to PortAudio, allowing users to observe buffer processing rates in real-time.

_simple\element/lib · high confidence

A new Elixir script (\mix\_audio.exs\) has been added to demonstrate mixing two WAV audio tracks into a single AAC file. The script uses the Membrane pipeline framework to read two input files, parse them as WAV, mix the audio streams (with the second stream offset by 2 seconds), encode the result using the FDK AAC encoder, and save the output to \output.aac\. This requires Elixir and the FDK AAC library to be installed.

_mix\audio · high confidence

This change introduces the \simple\_pipeline\ demo, a standalone Elixir project that demonstrates how to build a Membrane pipeline to play an MP3 file. The demo includes the necessary project structure (\.formatter.exs\, \.gitignore\, \config/config.exs\), a \run.exs\ script for execution, and the core pipeline implementation in \lib/membrane\_demo/simple\_pipeline.ex\. The pipeline reads an MP3 file, decodes it using the MAD decoder, converts the audio format using FFmpeg's SWResample, and outputs the audio via PortAudio. A README provides prerequisites and usage instructions.

_rtsp\_to\_hls, simple\pipeline · high confidence

The rtmp\_to\_hls location now provides a complete, runnable demo application that receives an RTMP stream (listening on localhost:9006), converts it to HLS segments, and serves the resulting manifest and chunks via a Phoenix web server (available on localhost:4000). The pipeline uses Membrane to ingest RTMP via a TCP source, transcode audio to AAC and video to H264, and write HLS output to the local 'output' directory. A web UI embeds the HLS.js player to stream the converted content, and the README includes setup instructions for OBS, including the required Keyframe Interval setting.

_rtmp\_to\hls · high confidence

Added several new Livebook and script-based demos demonstrating AI integration and media handling: an audio mixer that blends beep sounds into background music; a messages source and sink example for Erlang message-driven pipelines; an OpenAI Realtime API integration using WebRTC for browser-based voice conversations; an RTMP sender and receiver pair for streaming video; a real-time soundwave visualizer using Vega-Lite; a neural network style transfer demo with rotating styles via WebRTC; a Google Gemini voice conversation demo; a Whisper-based speech-to-text transcriber for live mic and file input; and a YOLO object detection demo with bounding box overlays. These additions expand the available examples for building real-time audio, video, and AI-powered applications.

(repo-wide) · high confidence

Added a new demo application in the rtp\_to\_hls directory that demonstrates converting RTP streams into HLS format. The solution includes a receiver script (rtp\_to\_hls.exs) that listens for UDP input on port 5000, demultiplexes H.264 video and AAC audio, and outputs HLS segments to an 'output' directory served via a local HTTP server on port 8000. A companion sender script (send.exs) is provided to generate test RTP traffic from a sample MP4 file. The entry also includes a web player (stream.html) for browser-based playback and standard project configuration files.

_rtp\_to\hls · high confidence

Added a new standalone Elixir script (camera\_to\_hls.exs) that captures raw video from a local camera, encodes it to H.264, and broadcasts it via HLS. The script uses Membrane plugins for capture, conversion, and encoding, serving the resulting stream via a local HTTP server on port 8000. It includes a simple HTML player (stream.html) for browser-based playback and documentation (README.md) with setup instructions and debugging tips for camera access.

_camera\_to\hls · high confidence

Added a new demo project (\simple\_element\) that demonstrates how to create a simple Membrane element and integrate it into a pipeline. The demo uses Membrane Core v1.0, includes a sample MP3 file, and features a counter element that tracks buffer processing while playing audio. It provides a \.formatter.exs\ configuration, a \.gitignore\, and a \run.exs\ script to start the pipeline.

_simple\element · high confidence

The application no longer includes the sample Membrane pipeline for playing MP3 files via PortAudio, nor the associated configuration file. Users relying on this specific demo for audio playback functionality will need to implement their own pipeline or use alternative solutions, as the \MembraneMP3Demo.Pipeline\ module and \config/config.exs\ have been deleted.

config, lib · high confidence

The RTP configuration file now explicitly sets the logger level to :info for the :logger application. This ensures that informational logs are captured for the RTP module, aiding in debugging and monitoring of RTP-related activities.

rtp/config · high confidence

The RTSP to HLS demo has been updated to use the latest RTSP plugin, replacing the previous implementation. This change introduces a new pipeline structure that explicitly handles audio and video tracks, configuring AAC encoding for audio and H.264 for video with 4-second segment durations. The demo now relies on the \Membrane.RTSP.Source\ element for stream ingestion and \Membrane.HTTPAdaptiveStream.SinkBin\ for HLS output, ensuring compatibility with the updated core framework.

_rtsp\_to\hls/lib · high confidence

The repository has been reorganized from a single sample pipeline into a collection of categorized Membrane Framework examples (Basics, Audio, Streaming protocols, and AI), including new additions like the Gemini audio chatbot and various RTMP/HLS/WebRTC demos. The project is now licensed under the Apache License, Version 2.0, and the README provides updated instructions for running these examples, many of which utilize Livebook.

(repo-wide) · high confidence

The application now uses a structured configuration system with environment-specific settings for development, production, and testing. The main config file imports environment-specific configurations, allowing for tailored behavior in each environment. Logging is configured to include request IDs in the console output for development, while production and test environments are set to debug level for detailed logging.

_rtsp\_to\hls/config · high confidence

A fix in rtp/samples — 1 commit (1 fix), 2 files.

rtp/samples · medium confidence · unverified

Added test helper for ExUnit initialization; Added test helper for RTP tests; Removed obsolete default test file.

Added two new demo projects: \camera\_to\_hls\_nerves\, which streams Raspberry Pi camera footage to HLS using the Nerves embedded systems framework (targeting Raspberry Pi 4), and \rtmp\_to\_adaptive\_hls\, which converts RTMP streams to adaptive bitrate HLS using Phoenix and Membrane plugins. Both demos include their \mix.exs\ and \mix.lock\ files, establishing the dependency trees for these new capabilities.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 43.

• Code Health 68
• Architecture 92
• Maturity 59
• Readiness 26
• Security 64
• Accessibility 49

• 300 commits — 268 feature/other, 32 fixes

• webrtc/videoroom_advanced — 59 commits
• (repo) — 39 commits
• webrtc/videoroom — 16 commits
• rtsp_to_hls/hls_proxy_api — 14 commits
• camera_to_hls/README.md — 12 commits
• rtsp_to_hls/lib — 11 commits
• (root) — 10 commits
• livebooks/rtmp — 7 commits
• livebooks/audio_mixer — 6 commits
• rtmp_to_hls/README.md — 6 commits
• rtp/lib — 6 commits
• webrtc_to_hls/README.md — 6 commits
• .circleci/config.yml — 5 commits
• simple_element/README.md — 5 commits
• camera_to_hls/lib — 4 commits
• rtp_to_hls/lib — 4 commits
• rtsp_to_hls/README.md — 4 commits
• simple_pipeline/README.md — 4 commits
• webrtc_to_hls/lib — 4 commits
• webrtc_videoroom/README.md — 4 commits

• fix: Fix CLI bug
• fix: Fix Elixir Formatter issue
• fix: Fix ex_libnice dependency version
• fix: Fix framerate (#179)
• fix: Fix minor errors in rtmp_to_hls readme
• fix: Fix simultaneous joining to the room
• fix: Fixed :new_rtp_stream notification handling.
• fix: Fixed CI.
• fix: Fixed env variables.
• fix: Fixed playback.
• fix: Fixed virtual host to use runtime variable (#154)
• fix: Merge branch 'master' into fix-deploy
• fix: Merge branch 'master' into fix-deploy
• fix: Merge pull request #156 from membraneframework/fix-cli-fail
• fix: Merge pull request #162 from membraneframework/fix-deploy
• fix: Merge pull request #173 from membraneframework/bug-fixes
• fix: Merge pull request #183 from membraneframework/revert-changes-commited-directly-to-master
• fix: Merge remote-tracking branch 'origin/master' into fix-deploy
• fix: Revert "Iterate over video devices, until find first working one"
• fix: Revert "Revert "[webrtc_to_hls] Add instructions for installing native deps on Ubuntu (#234)""
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

membraneframework/membrane_demo was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.