## Overview The **Inbound Streams – SRT & RTMP** page provides operators with the tools to **receive, configure, and monitor inbound live streams** inside the **Streaming Engine**. This page is primarily used to **ingest live streams from external sources** and then **publish them across multiple output protocols**. It is available at the route: `/inbound`. This page allows operators to: - Copy and share **preconfigured ingest URLs** (SRT / RTMP). - Configure and manage **custom SRT Inputs** (Caller / Listener / Rendez-Vous – Non-functional (future support). - Monitor the **status of SRT Inputs** (_Offline, Ready, Streaming_). - View and share **Published Inbound Streams** across multiple protocols. - Preview live streams directly using the built-in **video player**. > [!note] > Inbound streams are **initiated externally** (from publishers or encoders). This page provides the **endpoints, management, and monitoring tools** required for receiving and publishing them across multiple protocols. ![[Inbound Streams - SRT & RTMP page - overview.png|800]] <div class="page-break" style="page-break-before: always;"></div> ## Functionality The page is divided into three main sections: ### 1. Stream Ingest URLs (Preconfigured SRT, RTMP and RTMPS Inputs) These are default endpoints provided by the Streaming Engine for receiving streams: - **SRT Multi Stream Server Active** - Example: `srt://<hostname>:21330` - Hostname = machine where Streaming Engine is installed. - Port = `21330` (default, configurable). - **RTMP Server Active** - Examples: - `rtmp://<hostname>:1935/live` The standard RTMP port - `rtmps://<hostname>:1936/live` The secure RTMP port (TLS encryption) - Ports `1935` and `1936` are defaults (configurable). Each entry includes a **Copy URL** button for quick sharing. ![[Inbound Streams - SRT & RTMP page - preconfigured stream ingest URLs.png|700]] --- ### 2. SRT Input Manager The **SRT Input Manager** lets operators create and manage custom SRT inputs. - **Add SRT Input** – Opens a dialog where fields dynamically adjust based on connection mode: - **Listener** – Waits for publishers to connect (_Start Pull as Listener_). - **Caller** – Actively retries connection to a remote source (_Start Pull as Caller_). - **Rendez-Vous** – In development (placeholder for future support). - **SRT Inputs Table** – Displays each configured input with: - **Active Stream Name** - **UDP Port** - **Encryption & Passphrase** - **Connection Mode** - **Latency** - **Remote Address / Remote UDP Port** - **Status** – _Offline_, _Ready_, or _Streaming_ - **Actions** – **Start, Stop, Edit, Remove** - **Edit Behavior** – Any change requires a **restart** (Stop → Start) to apply. - **Start / Stop Behavior**: - Listener mode waits for incoming connections. - Caller mode retries in a loop until the remote publisher is available. ![[Inbound Streams - SRT & RTMP page -SRT Input Manager.png|700]] --- ### 3. Published Inbound Streams This section shows all **streams currently being received and published** via configured SRT inputs or ingest URLs. Each row displays: - **Stream Key (RTMP) / Active Stream Name (SRT)** - **Protocol (RTMP/SRT)** - **Connected Clients** - **Actions** – **View Output Endpoints** - **Video Player** – Preview the stream live When selecting **View Output Endpoints**, a popup window lists **all available playback URLs** across supported protocols: - RTSP / RTSP over TLS - RTMP / RTMP over TLS - HLS / HLS over HTTPS - WebRTC over HTTP / HTTPS Each URL includes a **Copy URL** button for easy sharing. ![[Inbound Streams - SRT & RTMP page -Published Inbound Streams.png|700]] ![[z_img/6cee511ed078cf2aaa45d5d9c404b9ca_MD5.jpg|700]] ## Workflow The typical workflow for inbound streams is: 1. **Copy Preconfigured Ingest URL** - From the **Stream Ingest URLs** section, copy an RTMP or SRT URL. - Provide it to an encoder, camera, or publishing client. 2. **Or Add Custom SRT Input** - Use **Add SRT Input** to configure a Listener or Caller input. - Save, then **Start** the input. 3. **Monitor SRT Input Status** (in case of **Custom SRT Input**) - Status updates in real time: - **Offline** → The input is not active (stopped). - **Ready** → The input is active, meaning: - In **Listener mode**, it has opened the socket and is waiting for a publisher. - In **Caller mode**, it has started trying to connect (retry loop if remote is offline). - **Streaming** → A live inbound stream is actually flowing through the input (at least one client is connected to the published point). 4. **View Published Inbound Streams** - Active inbound streams appear in the table with **protocol, connected clients, and preview player**. 5. **Share Output Endpoints** - Click **View Output Endpoints** to access multi-protocol URLs. - Distribute them for playback or integration in external systems. 6. **Preview in Video Player** - Use the built-in player to verify live playback directly from the UI. <div class="page-break" style="page-break-before: always;"></div> ## Setup and Verification ### Example: Create and Start an SRT Input (listener mode) and Verify with OBS & VLC The following example demonstrates how to configure and activate a new SRT Input. 1. **Click _Add SRT Input_** - In the **SRT Input Manager**, select the **Add SRT Input** button. - A configuration window opens. - Fields dynamically adjust based on the selected connection mode. - ![[z_img/91667e3f98644eebe6f86db2aede5129_MD5.jpeg|250]] - ![[z_img/da269b3ba42b3aea7d34064ea0700866_MD5.jpeg|250]] ![[z_img/60596c207ceee5f844440dcd7bb5315a_MD5.jpeg|250]] - ![[z_img/adea0f4c2a919fbb31bc4e655e9b65dd_MD5.jpeg|250]] ![[z_img/d49001ce9c6555ee1d96963e20ecf03a_MD5.jpeg|250]] - ![[z_img/4ee7e44fcb74892ca2d508ff04df92dc_MD5.jpeg|250]] ![[z_img/e8968e469a14b959242f598edda2b848_MD5.jpeg|250]] 2. **Complete the fields in the Add SRT Input pop-up window - Enter a descriptive **Active Stream Name** (e.g., `MyStreamViaSRTInput`). - Choose an available **UDP Port**. - Select **Encryption Key Length**: - `Disabled (0 bytes)` – no encryption. - `AES-128`, `AES-192`, or `AES-256` – requires entering a passphrase. - Provide a **Passphrase** if encryption is enabled. - Select a **Connection Mode**: - **Listener** – waits for a publisher to connect. - **Caller** – actively retries connecting to the remote source. - **Rendez-Vous** – currently not functional. ![[z_img/b3738ffa038a3378493e1cc1f7849e26_MD5.jpeg|250]] - For this example, we set the **Active Stream Name** = `"MyStreamViaSRTInput"`, **UDP Port** = `12`, with **Encryption Key Length (bits)** disabled, and **Connection Mode** = `"Listener"`. 3. **Save the SRT Input** - Click **Save**. - The new SRT Input appears in the **SRT Input Manager** table with status **Offline**. ![[z_img/909957db84016d6d1f27d4d3b8c0ba04_MD5.jpeg|700]] 4. **Start the SRT Input, use OBS Studio to stream to our SRT Input from Streaming Engine and then use VLC player to watch the published stream** - Use the **Start** button in the Actions column. - The status changes to **Ready**: - In **Listener mode** → the engine is waiting for the publisher. - In **Caller mode** → the engine begins retrying the connection until the remote publisher is online. ![[z_img/6909a0a3fd42eb7b54251d244b8fbe00_MD5.jpeg|700]] - **Configure OBS Studio** to publish an SRT stream to the **SRT Input URL** we created in the Streaming Engine. - ![[z_img/08ebea0ccf8b3c7bca7a8faf899b190e_MD5.jpeg|600]](OBS Studio) - The URL depends on the parameters we set in the **SRT Input Manager**. - Example: `srt://127.0.0.1:12?mode=caller` - `127.0.0.1` → the IP/hostname of the machine where our **Streaming Engine** is running (we must use the public IP if OBS runs on a different host). - `12` → the **UDP Port** we defined when creating the SRT Input. - `mode=caller` → tells OBS to connect as **Caller**, because our SRT Input on the Streaming Engine is in **Listener mode**. When OBS runs on another machine, we must replace `127.0.0.1` with the **external IP or hostname** of the Streaming Engine server. - (Just as additional information for another scenario) If we enabled **encryption (AES-128/192/256) with a passphrase** in our SRT Input on the Streaming Engine, the OBS URL must also include those parameters. Example: `srt://127.0.0.1:12?mode=caller&pbkeylen=16&passphrase=MySecretKey` - `pbkeylen` → key length in bytes (16 = AES-128, 24 = AES-192, 32 = AES-256). - `passphrase` → the encryption passphrase we entered when creating the input (max 79 characters). - ![[z_img/aef0d84215caea5aa5b9da4e303f08a1_MD5.jpeg|600]] (OBS Studio) - **Verify the Published Stream**: - Go to the **Published Inbound Streams** section - Click **View Output Endpoints** to open the popup with all available playback URLs - ![[Inbound Streams - SRT & RTMP page -Published Inbound Streams.png|600]] - Choose the desired **protocol** (e.g., RTSP) and click the **Copy URL** button. - ![[z_img/6147b361f3c7cfc99ccbb4c6a2fd49bc_MD5.jpeg|600]] - **Play the Stream in VLC Player**: - Open VLC → **Media → Open Network Stream**. - Paste the copied URL and press **Play**. - ![[z_img/435f5152d1b86cf1843c8c0ac4937a62_MD5.jpeg|600]] (VLC player) - Once a client (e.g., VLC or ORBNET Low Latency Player) connects to a published output, the **Status** of the SRT Input changes to **Streaming** (not just when OBS starts sending). - ![[z_img/0322fd2d4a8253448f6efd4e73d2ac28_MD5.jpeg|700]] --- ### Example: Create and Start an SRT Input (caller mode) and Verify with OBS & VLC - **Create SRT Input (Caller) in Streaming Engine** - ![[z_img/a1ef98a76ff781074dfbf3456a314ba5_MD5.jpeg|250]] - **Active Stream Name**: `MyStreamViaSRTInput` - **UDP Port**: `12` - **Encryption Key Length**: AES-256 (32 bytes) - **Passphrase**: `MySecretKey` - **Connection Mode**: Caller - **Remote Address**: `127.0.0.1` (where OBS is running) - **Remote UDP Port**: `12` (the port OBS listens on) - **Latency**: `120 ms` → The Streaming Engine will actively dial the OBS listener at `<destination_ip>:<destination_port>`. - **Configure OBS (Listener)** ![[z_img/e9282ea5f6970050706850f2fb5f3b53_MD5.jpeg|500]] - Generic URL format (defines the **listening IP/port** in OBS): `srt://<listening_ip>:<listening_port>?mode=listener&pbkeylen=<key_bytes>&passphrase=<your_passphrase>` - `<listening_ip>` → IP where OBS is running - `<listening_port>` → port OBS is configured to listen on - `pbkeylen` → 16 (AES-128), 24 (AES-192), 32 (AES-256) - `passphrase` → same as in our SRT Input - Example (OBS + Streaming Engine on the same machine, port `12`, AES-256, passphrase `012345678`): `srt://127.0.0.1:12?mode=listener&pbkeylen=32&passphrase=012345678` ![[z_img/1b01b41fef832b4f6135185295425af2_MD5.jpeg|500]] - **Start & Verify** - **Start the SRT Input** in Streaming Engine → status becomes **Ready**. - A publishing point is created while the engine actively tries to connect to the OBS listener. - **If OBS is not yet listening**, the connection attempt fails after a few seconds. - The publishing point is temporarily disposed. - The engine automatically retries, and the publishing point reappears when retrying. - **When we click _Start Streaming_ in OBS (Listener)**, the connection succeeds. - The publishing point remains active and stable. - Input status stays at **Ready** (connection established). - **When a client (e.g., VLC) connects** to one of the playback URLs from the publishing point (RTSP, HLS, WebRTC, etc.), - Input status changes to **Streaming** (because now at least one downstream client is consuming the stream). --- ### Example: Publish an RTMP Stream with FFmpeg and Verify with VLC This example shows how to publish an MP4 file to the Streaming Engine via preconfigured **RTMP** input, and then verify playback. 1. **Copy Preconfigured RTMP Ingest URL** - From the **Stream Ingest URLs** section, copy one of the RTMP endpoints: - RTMP: `rtmp://<hostname>:1935/live` - RTMPS (encrypted): `rtmps://<hostname>:1936/live` - ![[z_img/a567b54ebc3168b7beb9a44e71f3ff84_MD5.jpeg|800]] - Choose a **Stream Key** (for example: `testStreamKey`). → The full publish URL becomes: `rtmp://<hostname>:1935/live/testStreamKey` 2. **Install FFmpeg (if not already installed)** - Download from: [https://www.gyan.dev/ffmpeg/builds/](https://www.gyan.dev/ffmpeg/builds/) - Under **Release builds**, download: **`ffmpeg-release-full.7z`** - Extract to: `C:\ffmpeg` - Add FFmpeg to your system **PATH**: - Open _Start_ → search for “Environment Variables” - Find the variable called **Path** under **User variables** and click **Edit** - Click **New**, and add the path to the **bin** folder `C:\ffmpeg\bin` - Verify installation: - Open Command Prompt and run: `ffmpeg -version` 3. **Push a Test MP4 with FFmpeg** - Open **Command Prompt**. - Navigate to the folder where your input file is stored: `cd C:\path\to\your\video` - Run the ffmpeg command: - ![[z_img/4880bda58838b358b1d41f3c906a199d_MD5.jpeg|800]] - `ffmpeg -re -i <input_file>.mp4 -c:v libx264 -preset veryfast -b:v 2500k -c:a aac -ar 44100 -b:a 128k -f flv rtmp://<hostname>:1935/live/<stream_key>` - `<input_file>.mp4` → the name of the media file you want to publish (e.g., `drone1.mp4`). - `<stream_key>` → your chosen stream key (e.g., `testStreamKey`). - `-re` → send at real-time speed - `-c:v libx264` / `-c:a aac` → ensure RTMP-compatible codecs - `-f flv` → RTMP transport requires FLV container - If the MP4 is already H.264 + AAC, we can skip re-encoding: - `ffmpeg -re -i <input_file>.mp4 -c copy -f flv rtmp://<hostname>:1935/live/<stream_key>` 4. **Verify the Published Stream in the Streaming Engine** - In the **Published Inbound Streams** section we should see `testStreamKey` appear with **Protocol = RTMP**.. - ![[z_img/d69f7087153aeb3c0dde17cf5c8eee7f_MD5.jpeg|700]] 5. **Play the Stream with VLC** - Copy an output endpoint (HLS, RTMP, RTSP, or WebRTC) from **View Output Endpoints**. - In VLC: **Media → Open Network Stream**, paste the URL, click **Play**. - Example RTMP playback URL: `rtsp://DESKTOP-I9G7AP9:554/testStreamKey` ![[z_img/f6b39ad7d884a70408a7124acc64a547_MD5.jpeg|500]] <div class="page-break" style="page-break-before: always;"></div>