Skip to content

Show RTSP IP Cameras in a Web Browser with WHEP in C# / .NET

Try it Download Windows trial dotnet add package VisioForge.DotNet.MediaBlocks Pricing →

Media Blocks SDK .NET

Demo Sample

The code in this guide comes from the RTSP WHEP Camera Grid Demo (WPF) in the samples repository: it adds cameras by RTSP URL, serves a grid page with every camera, and forwards each camera's WHEP requests to its own server.

The block reference is in Sink blocks → WHEP server.

What You Will Build

A browser cannot open an RTSP URL. The usual ways to put an IP camera on a web page are to transcode it to HLS (several seconds of delay and a decoder plus an encoder per camera) or to run a separate media server next to your application. This guide takes a third route: your .NET application itself becomes a WebRTC server, and the camera's H.264 goes to the browser exactly as the camera sent it.

The pipeline for one camera is two blocks:

graph LR;
    RTSPRAWSourceBlock -- H.264 --> WHEPServerSinkBlock;
  • RTSPRAWSourceBlock connects to the camera and outputs its encoded H.264 without decoding it.
  • WHEPServerSinkBlock runs a WHEP (WebRTC-HTTP Egress Protocol) server. A browser posts a WebRTC offer to it over HTTP, gets an answer, and receives the video over its own WebRTC session.

What this buys you:

  • Sub-second latency. The browser plays the stream over WebRTC, not through a segment-based protocol.
  • Almost no CPU per camera, for any number of viewers. Nothing is decoded or encoded: the block sends the camera's stream to every viewer as it arrives. Each viewer still costs network bandwidth equal to the camera's bitrate.
  • No media server. The WHEP server runs inside your process; the browser side is about 20 lines of JavaScript with no player library.

WHEP is a small HTTP protocol on top of WebRTC: one POST with the SDP offer, a 201 Created with the SDP answer and a Location header for the session, and a DELETE on that Location when the viewer leaves. Any WHEP player can use the endpoint, not only the page in this guide.

Prerequisites

  • Windows x64. WHEPServerSinkBlock uses the rswebrtc GStreamer plugin, which ships in the Windows Adds runtime package.
  • .NET 10 (the demo targets net10.0-windows).
  • An IP camera with an H.264 RTSP stream.
  • Media Blocks SDK .NET version 2026.11.18 or later — the release that adds WHEPServerSinkBlock.

NuGet packages:

Without the Adds package WHEPServerSinkBlock.IsAvailable() returns false. For deployment details see the Deployment Guide.

The browser page is a file the application serves, so copy it to the output folder in the .csproj, as the demo does:

<ItemGroup>
  <Content Include="wwwroot\**" CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>

The One Thing to Know First: Same Origin

The WHEP server sends no CORS headers. A browser therefore accepts its answers only on a page served from the same address and port as the endpoint. Opening index.html from disk, or serving it from another port, fails at the fetch of the offer.

The demo solves it the simple way: the application runs a small HTTP server for the page and forwards every request under /whep/ to the WHEP server, which itself listens on loopback only. The browser talks to one origin; the WHEP server is never exposed directly.

sequenceDiagram
    participant Browser
    participant Page as Page server (your app)
    participant WHEPServerSinkBlock
    Browser->>Page: GET /
    Page-->>Browser: index.html
    Browser->>Page: POST /whep/endpoint (SDP offer)
    Page->>WHEPServerSinkBlock: POST /whep/endpoint
    WHEPServerSinkBlock-->>Page: 201 Created, SDP answer, Location
    Page-->>Browser: 201 Created, SDP answer, Location
    WHEPServerSinkBlock-)Browser: camera H.264 over WebRTC
    Browser->>Page: DELETE Location (page closed)
    Page->>WHEPServerSinkBlock: DELETE Location

Only the HTTP exchange goes through the page server. The video travels over the WebRTC connection that the offer and answer set up.

One Camera: the Complete Server

The console program below is the demo's code for a single camera. It builds the pipeline, serves wwwroot/index.html on http://localhost:8080/ and forwards /whep/... to the WHEP server on 127.0.0.1:9100.

using System;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;

const string PageUrl = "http://localhost:8080/";
const string WhepServer = "http://127.0.0.1:9100";

await VisioForgeX.InitSDKAsync();

using var http = new HttpClient();
MediaBlocksPipeline? pipeline = null;
HttpListener? pageServer = null;

try
{
    if (!WHEPServerSinkBlock.IsAvailable())
    {
        Console.WriteLine("WHEPServerSinkBlock is not available: the VisioForge.CrossPlatform.Core.Windows.Adds.x64 package is missing.");
        return;
    }

    pipeline = new MediaBlocksPipeline();
    pipeline.OnError += (s, e) => Console.WriteLine(e.Message);

    // Encoded H.264 straight from the camera, without audio: browsers take Opus, not the camera's AAC.
    var rtspSettings = await RTSPRAWSourceSettings.CreateAsync(new Uri("rtsp://192.168.1.64:554/stream1"), "admin", "password", audioEnabled: false);
    var rtsp = new RTSPRAWSourceBlock(rtspSettings);

    // The WHEP server listens on loopback only; browsers reach it through the page server below.
    var whep = new WHEPServerSinkBlock(new WHEPServerSinkSettings { ServerAddress = WhepServer });
    whep.ConsumerAdded += (s, e) => Console.WriteLine($"Viewer connected: {e.PeerId}");
    whep.ConsumerRemoved += (s, e) => Console.WriteLine($"Viewer left: {e.PeerId}");

    pipeline.Connect(rtsp.VideoOutput, whep.Input);

    // The page and the WHEP requests share one origin: whepserversink sends no CORS headers.
    pageServer = new HttpListener();
    pageServer.Prefixes.Add(PageUrl);
    pageServer.Start();
    _ = ServePageAsync(pageServer);

    if (await pipeline.StartAsync())
    {
        Console.WriteLine($"Open {PageUrl} in a browser. Press Enter to stop.");
        Console.ReadLine();
    }
}
catch (Exception ex)
{
    // CreateAsync throws when the camera cannot be read; HttpListener.Start when the page port is taken.
    Console.WriteLine(ex.Message);
}
finally
{
    pageServer?.Close();

    if (pipeline != null)
    {
        await pipeline.StopAsync();
        await pipeline.DisposeAsync();
    }

    VisioForgeX.DestroySDK();
}

async Task ServePageAsync(HttpListener server)
{
    while (server.IsListening)
    {
        HttpListenerContext context;
        try
        {
            context = await server.GetContextAsync();
        }
        catch (Exception ex) when (ex is HttpListenerException || ex is ObjectDisposedException)
        {
            return;
        }

        _ = HandleRequestAsync(context);
    }
}

async Task HandleRequestAsync(HttpListenerContext context)
{
    var request = context.Request;
    var response = context.Response;

    try
    {
        var path = request.Url?.AbsolutePath ?? string.Empty;

        if (path == "/")
        {
            await WriteAsync(response, "text/html", File.ReadAllBytes(Path.Combine(AppContext.BaseDirectory, "wwwroot", "index.html")));
        }
        else if (path.StartsWith("/whep/", StringComparison.Ordinal))
        {
            // The offer and the session's DELETE go to the WHEP server unchanged.
            using var forward = new HttpRequestMessage(new HttpMethod(request.HttpMethod), WhepServer + path);
            if (request.HasEntityBody)
            {
                using var body = new MemoryStream();
                await request.InputStream.CopyToAsync(body);
                forward.Content = new ByteArrayContent(body.ToArray());
                forward.Content.Headers.TryAddWithoutValidation("Content-Type", request.ContentType);
            }

            using var reply = await http.SendAsync(forward);
            if (reply.Headers.Location != null)
            {
                // The session URL the player deletes when it leaves.
                response.Headers["Location"] = reply.Headers.Location.OriginalString;
            }

            response.StatusCode = (int)reply.StatusCode;
            await WriteAsync(response, reply.Content.Headers.ContentType?.ToString(), await reply.Content.ReadAsByteArrayAsync());
        }
        else
        {
            response.StatusCode = 404;
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
        response.StatusCode = 502;
    }
    finally
    {
        response.Close();
    }
}

static async Task WriteAsync(HttpListenerResponse response, string? contentType, byte[] body)
{
    if (contentType != null)
    {
        response.ContentType = contentType;
    }

    response.ContentLength64 = body.Length;
    await response.OutputStream.WriteAsync(body);
}

What each part does:

  • RTSPRAWSourceSettings.CreateAsync connects to the camera and reads its stream description before the pipeline is built. audioEnabled: false leaves the camera's audio out: the WHEP server has a single video input, and browsers take Opus over WebRTC, not the AAC or G.711 a camera sends. CreateAsync throws InvalidOperationException when it cannot read the stream — the camera is offline, the URL is wrong, or the credentials are refused.
  • RTSPRAWSourceBlock.VideoOutput carries the camera's encoded H.264. Connecting it straight to WHEPServerSinkBlock.Input is the whole media path: no decoder, no encoder.
  • WHEPServerSinkSettings.ServerAddress is the address the WHEP server listens on. 127.0.0.1 keeps it reachable from this machine only, which is what you want when the page server forwards to it. The block's EndpointUrl property returns the URL players post to — here http://127.0.0.1:9100/whep/endpoint.
  • ConsumerAdded / ConsumerRemoved report each viewer that connects and leaves, with its session ID in PeerId. They are raised on a GStreamer thread: in a UI application marshal to the UI thread without blocking it — the demo uses Dispatcher.BeginInvoke. ConsumerRemoved is not raised for viewers still connected when the pipeline stops; their sessions end with it.
  • try / finally reports what went wrong — CreateAsync failing on the camera, HttpListener.Start on a taken port — and the finally closes the page server, stops and disposes the pipeline and calls VisioForgeX.DestroySDK() whether start-up succeeded or failed.
  • The page server uses HttpListener, which serves http://localhost:<port>/ without administrator rights. It answers / with the page, forwards /whep/... with the same method, body and Content-Type, and copies the status code, the answer body and the Location header back to the browser.

The page server is started before the pipeline, so the page is reachable as soon as the stream is.

The Browser Side: a Minimal WHEP Player

Put this file in wwwroot/index.html. The play function is the demo's player with one addition, the iceServers list passed to RTCPeerConnection (see NAT, STUN and TURN):

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Camera</title>
    <style>
        body { margin: 0; background: #111; color: #ddd; font-family: sans-serif; }
        figure { margin: 0; position: relative; background: #000; }
        video { width: 100%; aspect-ratio: 16 / 9; display: block; }
        figcaption { position: absolute; left: 8px; top: 6px; font-size: 13px; text-shadow: 0 0 3px #000; }
    </style>
</head>
<body>
<figure>
    <video id="video" autoplay muted playsinline></video>
    <figcaption id="caption" data-name="Camera">Camera</figcaption>
</figure>
<script>
    // STUN/TURN servers for the viewer's side of the connection; empty is enough on a local network.
    const iceServers = [];

    // A minimal WHEP player: offer, POST it to the endpoint, apply the answer.
    async function play(endpoint, video, caption) {
        const pc = new RTCPeerConnection({ iceServers });
        pc.addTransceiver('video', { direction: 'recvonly' });
        pc.ontrack = e => video.srcObject = e.streams[0] || new MediaStream([e.track]);

        await pc.setLocalDescription(await pc.createOffer());
        // Send the offer with all ICE candidates in it.
        await new Promise(resolve => {
            if (pc.iceGatheringState === 'complete') resolve();
            else pc.onicegatheringstatechange = () => pc.iceGatheringState === 'complete' && resolve();
        });

        const response = await fetch(endpoint, { method: 'POST', headers: { 'Content-Type': 'application/sdp' }, body: pc.localDescription.sdp });
        if (response.status !== 201) throw new Error(`${endpoint}: HTTP ${response.status}`);
        await pc.setRemoteDescription({ type: 'answer', sdp: await response.text() });

        // End the session on the server when the page closes.
        const session = response.headers.get('Location');
        addEventListener('pagehide', () => fetch(session, { method: 'DELETE', keepalive: true }));
        pc.onconnectionstatechange = () => caption.textContent = `${caption.dataset.name} - ${pc.connectionState}`;
    }

    const caption = document.getElementById('caption');
    play('/whep/endpoint', document.getElementById('video'), caption).catch(e => caption.textContent = e.message);
</script>
</body>
</html>

Step by step:

  1. A receive-only video transceiver. The page only watches, so it offers to receive one video track and sends nothing.
  2. Wait for ICE gathering to complete before sending the offer. All network candidates then travel inside the single POST, so the player never needs WHEP's PATCH requests for trickle ICE.
  3. POST the SDP offer with Content-Type: application/sdp. The server answers 201 Created with the SDP answer in the body.
  4. Apply the answer. WebRTC connects and ontrack hands the camera's track to the <video> element.
  5. Delete the session on pagehide. The Location header names the session; keepalive: true lets the DELETE go out while the page unloads. The server then raises ConsumerRemoved.

The <video> element is muted, which lets the browser start playback without a click, and playsinline for mobile browsers. The caption shows the connection state (connecting, connected, failed), which is the first thing to look at when a tile stays black.

Scaling to Several Cameras

A WHEPServerSinkBlock serves one camera. For several cameras the demo runs one block per camera, each on its own port, and gives each camera its own path on the page server.

The pipeline part, from the demo's start handler — one RTSPRAWSourceBlock → WHEPServerSinkBlock pair per camera, WHEP ports counted up from 9100:

for (var i = 0; i < _cameras.Count; i++)
{
    var camera = _cameras[i];

    // Encoded H.264 straight from the camera, without audio: browsers take Opus, not the camera's AAC.
    var rtspSettings = await RTSPRAWSourceSettings.CreateAsync(camera.Url, camera.Login, camera.Password, audioEnabled: false);
    var rtsp = new RTSPRAWSourceBlock(rtspSettings);

    // One WHEP server per camera; only this app talks to it, the browsers go through the page server below.
    var whep = new WHEPServerSinkBlock(new WHEPServerSinkSettings { ServerAddress = $"http://127.0.0.1:{FirstWhepPort + i}" });
    whep.ConsumerAdded += (s, args) => UpdateViewers(+1);
    whep.ConsumerRemoved += (s, args) => UpdateViewers(-1);

    _pipeline.Connect(rtsp.VideoOutput, whep.Input);
}

The routing part: the page server forwards /cam/N/whep/... to camera N's server and puts the same /cam/N prefix in front of the Location it returns, so that the browser's DELETE reaches the right camera too:

var path = request.Url?.AbsolutePath ?? string.Empty;
var parts = path.Split('/', 4, StringSplitOptions.RemoveEmptyEntries);

if (parts.Length == 4 && parts[0] == "cam" && int.TryParse(parts[1], out var camera) && camera >= 0 && camera < _cameras.Count)
{
    // /cam/N/whep/... is forwarded to camera N's WHEP server.
    using var forward = new HttpRequestMessage(new HttpMethod(request.HttpMethod), $"http://127.0.0.1:{FirstWhepPort + camera}/{parts[2]}/{parts[3]}");
    if (request.HasEntityBody)
    {
        using var body = new MemoryStream();
        await request.InputStream.CopyToAsync(body);
        forward.Content = new ByteArrayContent(body.ToArray());
        forward.Content.Headers.TryAddWithoutValidation("Content-Type", request.ContentType);
    }

    using var reply = await _http.SendAsync(forward);
    if (reply.Headers.Location != null)
    {
        // The session URL the player deletes when it leaves, under the same /cam/N prefix.
        response.Headers["Location"] = $"/cam/{camera}{reply.Headers.Location.OriginalString}";
    }

    response.StatusCode = (int)reply.StatusCode;
    await WriteAsync(response, reply.Content.Headers.ContentType?.ToString(), await reply.Content.ReadAsByteArrayAsync());
}

The demo's page server also answers /cameras with the number of cameras, and the grid page builds one tile per camera with its play function — the one above, without the iceServers addition:

(async () => {
    const count = await (await fetch('/cameras')).json();
    for (let i = 0; i < count; i++) {
        const figure = document.createElement('figure');
        const video = Object.assign(document.createElement('video'), { autoplay: true, muted: true, playsInline: true });
        const caption = document.createElement('figcaption');
        caption.dataset.name = caption.textContent = `Camera ${i}`;
        figure.append(video, caption);
        document.getElementById('grid').append(figure);
        play(`/cam/${i}/whep/endpoint`, video, caption).catch(e => caption.textContent = e.message);
    }
})();

With the CSS rule #grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(420px, 1fr)); } the tiles wrap to the window width.

Two design notes for a real NVR:

  • One pipeline or one per camera. The demo puts every camera pair in one MediaBlocksPipeline, so they start and stop together, and a camera that cannot be read makes CreateAsync throw before the start. To restart one camera without touching the others, give each pair its own pipeline — the same pattern the Multi-Camera RTSP Grid guide uses for local rendering.
  • Bandwidth, not CPU, is the budget. Every viewer of every tile receives the camera's full bitrate. For a grid, point the source at the camera's H.264 sub-stream and keep the main stream for single-camera views and for recording without re-encoding.

Limits to Know Before Shipping

Codec: H.264 only

The block's input accepts encoded H.264 only. Raw video, or any other codec, fails to connect and the pipeline does not start: the block never encodes for viewers. An H.265 camera stream is refused for the same reason — most browsers cannot play H.265 over WebRTC anyway. Switch the camera, or its sub-stream, to H.264.

H.264 profiles and browsers

The camera's stream reaches the browser untouched, so the browser's WebRTC decoder must take the camera's profile. Chromium-based browsers (Chrome, Edge) played a camera's 1080p Main profile H.264 in our tests. A browser whose WebRTC decoder takes only constrained baseline shows no picture for a Main or High profile camera. When one viewer sees an empty tile and another does not, open the page in Chrome or Edge, or switch the camera's stream to the Baseline profile if the camera offers one.

The SDK's own WHEPSourceBlock offers H.264 only as constrained baseline with the exact profile-level-id 42e016, which camera streams do not match, so it gets no picture from this block. Use a browser, or a player that sends level-asymmetry-allowed=1 as browsers do.

No audio

The block has one input, for video. Create the RTSP source with audioEnabled: false.

Listening address

ServerAddress takes http:// addresses only and defaults to http://127.0.0.1:9090, which accepts players on this machine only; http://0.0.0.0:<port> accepts players from other machines. For a server listening on 0.0.0.0, EndpointUrl names the loopback address — players on other machines use this machine's network address instead.

With the page-server pattern of this guide, keep the WHEP server on 127.0.0.1 and expose only the page server. The demo's page server listens on localhost; to show the cameras on other computers, put a reverse proxy (nginx, IIS, Caddy) in front of it, forward the same paths and set the Host header to localhost:<port>, because the page server answers no other host name.

HTTPS

Receiving WebRTC needs no HTTPS, so plain http:// works for viewers on the local network. The WHEP server itself speaks http:// only; if your deployment needs HTTPS, terminate it in the server or reverse proxy that serves the page.

NAT, STUN and TURN

Each side of a WebRTC connection gathers its own network candidates, so STUN and TURN are set on each side separately:

  • The server's side: StunServer (stun://hostname:port) and TurnServer (turn(s)://username:password@host:port) in WHEPServerSinkSettings. Both are unset by default, which means no STUN server — enough on a local network.
  • The viewer's side: the iceServers list the page passes to RTCPeerConnection. It is empty in the page above.

The signaller also announces the server's STUN server in a Link header of its answer, but the page server in this guide does not forward that header and the player does not read it, so the page sets its own iceServers.

var whep = new WHEPServerSinkBlock(new WHEPServerSinkSettings
{
    ServerAddress = "http://127.0.0.1:9100",
    StunServer = "stun://stun.l.google.com:19302",
    TurnServer = "turn://user:password@turn.example.com:3478"
});
const iceServers = [
    { urls: 'stun:stun.l.google.com:19302' },
    { urls: 'turn:turn.example.com:3478', username: 'user', credential: 'password' }
];

Authentication

WHEPServerSinkSettings has no authentication setting: anyone who can reach the WHEP server's address can watch. Keep it on 127.0.0.1 and put your access control — login, session cookie, token check — in the page server that forwards the requests, before the forward.

Errors the block reports

The block's build fails, with a message through the pipeline's OnError event, when ServerAddress is not an http:// address with a port in 1–65535 or when its port is already in use. Give every camera its own free port.

Platforms

Windows x64, with the VisioForge.CrossPlatform.Core.Windows.Adds.x64 package. Check WHEPServerSinkBlock.IsAvailable() at startup, as the demo does.

Troubleshooting

Symptom Cause and fix
WHEPServerSinkBlock.IsAvailable() returns false The VisioForge.CrossPlatform.Core.Windows.Adds.x64 package is not referenced.
CreateAsync throws InvalidOperationException ("Unable to read RTSP stream info") The camera is unreachable, or the URL or credentials are wrong. Open the same URL in another RTSP client to check it.
StartAsync returns false Read the OnError messages: a port already in use, an invalid ServerAddress, or a camera stream that is not H.264 (H.265, MJPEG).
The page shows a fetch error such as Failed to fetch The page and the endpoint are on different origins. Serve the page from the server that forwards /whep/, never from disk or from another port.
The page shows HTTP 404 or HTTP 502 The page server did not forward the path, or the WHEP server is not running on the forwarded port.
The caption stays at connecting, then failed The browser cannot reach the application machine over WebRTC. Check the firewall on that machine; for viewers outside the local network set STUN/TURN on both sides — StunServer and TurnServer for the server, iceServers in the page.
The caption says connected, the tile stays black The browser's decoder does not take the camera's H.264 profile. Try Chrome or Edge, or the camera's Baseline profile.
No ConsumerRemoved for a viewer that is gone The page sends its DELETE on pagehide; a browser that crashes or loses the network does not send it. Viewers still connected when the pipeline stops raise no event.
HttpListener.Start throws HttpListenerException The page port is taken, or the prefix is not localhost and needs administrator rights. Choose another port or keep localhost.

WHEP Server, WebRTC, WHIP or HLS?

  • WHEPServerSinkBlock (this guide) — the source is already H.264 (an IP camera) and the viewers are browsers on your network. Passthrough, no encoder, no media server, video only.
  • WebRTCSinkBlock — the video is raw or processed in the pipeline (a webcam, the screen, overlays, analytics), or you need audio. It encodes for each viewer (VP8 video, Opus audio) with per-viewer congestion control, at the cost of an encoder per viewer, and uses the webrtcsink WebSocket signalling protocol instead of WHEP.
  • WHIPSinkBlock — you already run a WebRTC media server (MediaMTX, Janus, Cloudflare Stream) and want the application to push one stream to it; the server then handles the viewers. Requires H.264 video and Opus audio; runs on Windows, macOS and Linux.
  • HLS — viewers on the open internet through a CDN or a plain <video> player, when a delay of several seconds is acceptable. See also HLS streaming and the ASP.NET Web Forms HLS player guide.

Frequently Asked Questions

Can a browser play an RTSP stream directly?

No. Browsers do not implement RTSP. The stream has to reach the page over a protocol the browser supports — WebRTC, as in this guide, or HLS. With WHEPServerSinkBlock the camera's H.264 is carried over WebRTC without being converted.

Does the application re-encode the video?

No. RTSPRAWSourceBlock outputs the camera's encoded H.264 and WHEPServerSinkBlock sends it to every viewer as it arrives. That is why a camera costs almost no CPU however many viewers watch it, and also why the camera must send H.264 in a profile the browser can decode.

Do I need a media server such as MediaMTX or Janus?

No. The WHEP server runs inside your .NET process. You need a media server only if you want one to handle the viewers, for example on the internet — then push the stream to it with WHIPSinkBlock.

Why is there no audio?

The block has a single video input. Browsers receive Opus over WebRTC, and IP cameras send AAC or G.711, so the camera's audio cannot be passed through. Create the source with audioEnabled: false. When you need audio in the browser, use WebRTCSinkBlock, which encodes it to Opus.

Can I play the stream with something other than a browser?

Yes, any WHEP player can post an offer to the endpoint. The exception is the SDK's own WHEPSourceBlock, which offers only constrained baseline 42e016 and gets no picture from a camera stream.

How many cameras and viewers can one application serve?

There is no per-viewer encoding, so the limit is network bandwidth: each viewer of each camera receives that camera's full bitrate. Use the cameras' sub-streams for grid views.

See Also