Diffuser l'écran ou une caméra vers des navigateurs web en WebRTC et publier avec WHIP en C# / .NET¶
Exemples de démonstration
La partie navigateur de ce guide suit le WebRTC Browser Streamer Demo (WPF) : une caméra et un micro, un aperçu local et une page de visionnage servie par l'application. La partie WHIP suit le WebRTC WHIP Streamer Demo (WPF) et sa version Avalonia pour Windows, macOS et Linux.
La référence des blocs se trouve dans Blocs sink → WebRTC et Blocs sink → WHIP.
Ce que vous allez construire¶
Deux façons de montrer en direct l'écran, une fenêtre d'application ou une caméra à des personnes qui n'ont qu'un navigateur web, toutes deux avec une latence inférieure à une seconde :
- Directement vers les navigateurs, sans serveur.
WebRTCSinkBlockfait de votre application .NET un serveur WebRTC : il sert la page de visionnage, assure la signalisation et envoie à chaque spectateur son propre flux WebRTC. Rien à installer à côté de l'application. - Par un serveur multimédia, avec WHIP.
WHIPSinkBlockpublie un flux vers un serveur multimédia WebRTC (MediaMTX, Janus, Cloudflare Stream) en WHIP (WebRTC-HTTP Ingestion Protocol). Le serveur le distribue ensuite à autant de spectateurs que nécessaire, y compris sur Internet.

graph LR;
src["Écran, fenêtre ou caméra<br/>+ micro"] --> app;
subgraph app ["Votre application .NET"]
WebRTCSinkBlock;
WHIPSinkBlock;
end
WebRTCSinkBlock -- "WebRTC, VP8 + Opus" --> b1["Navigateurs de votre réseau"];
WHIPSinkBlock -- "WHIP : H.264 + Opus" --> server["Serveur multimédia<br/>MediaMTX, Janus"];
server -- "WebRTC (WHEP)" --> b2["Navigateurs partout"]; Lequel choisir :
WebRTCSinkBlock | WHIPSinkBlock | |
|---|---|---|
| Logiciel supplémentaire | aucun | un serveur multimédia WebRTC |
| Encodage | VP8 et Opus, un encodeur par spectateur, avec contrôle de congestion par spectateur | H.264 et Opus, encodés une seule fois dans votre pipeline |
| CPU par spectateur supplémentaire | un encodeur VP8 de plus | aucun : le serveur relaie le flux |
| Page de visionnage | servie par le bloc, environ 100 lignes de JavaScript | le lecteur du serveur, ou tout lecteur WHEP |
| Plateformes | Windows | Windows, macOS, Linux |
| Usage typique | partage d'écran et vues de caméra pour quelques spectateurs sur un réseau local | diffusion à de nombreux spectateurs, ou via Internet |
Prérequis¶
- Windows x64 pour
WebRTCSinkBlock; Windows, macOS ou Linux pourWHIPSinkBlock. - .NET 10 (.NET 8 ou ultérieur sous Linux).
- Media Blocks SDK .NET version 2026.11.21 ou ultérieure. Cette version apporte la correction de la capture d'écran vers
WebRTCSinkBlocksur laquelle repose ce guide ; avec 2026.11.20,WebRTCSinkBlocklit les caméras, mais le spectateur d'une capture d'écran Direct3D 11 ne reçoit jamais d'image. - Pour WHIP, un serveur multimédia WebRTC. Les exemples utilisent MediaMTX, dont la configuration par défaut accepte WHIP sur le port 8889.
Paquets NuGet :
- VisioForge.DotNet.MediaBlocks : le SDK
- Windows : VisioForge.CrossPlatform.Core.Windows.x64 et VisioForge.CrossPlatform.Core.Windows.Adds.x64 : le runtime GStreamer et les plugins supplémentaires, dont
rswebrtc(les deux blocs) - macOS (WHIP) : VisioForge.CrossPlatform.Core.macOS et VisioForge.CrossPlatform.Core.macOS.Adds
- Linux (WHIP) :
VisioForge.CrossPlatform.Core.Linux.x64etVisioForge.CrossPlatform.Core.Linux.Adds.x64(.arm64pour ARM), plus le GStreamer de la distribution avecgstreamer1.0-plugins-badetgstreamer1.0-nice
Sans le paquet Adds, WebRTCSinkBlock.IsAvailable() et WHIPSinkBlock.IsAvailable() renvoient false. Pour le déploiement, consultez le Guide de déploiement.
Partie 1 : directement vers les navigateurs avec WebRTCSinkBlock¶
Comment un spectateur se connecte¶
WebRTCSinkBlock exécute deux serveurs dans votre processus : un serveur web pour la page de visionnage et un serveur de signalisation WebSocket. La page demande le flux au serveur de signalisation, le bloc envoie une offre WebRTC et le navigateur répond. Ensuite, la vidéo passe par la propre connexion WebRTC du spectateur.
sequenceDiagram
participant Browser as Navigateur
participant Web as Serveur web (WebRTCSinkBlock)
participant Sig as Serveur de signalisation (WebRTCSinkBlock)
Browser->>Web: GET /?signalling=8443
Web-->>Browser: index.html
Browser->>Sig: WebSocket : inscription comme listener, liste des producteurs
Browser->>Sig: ouverture d'une session avec le producteur
Sig-->>Browser: offre SDP (VP8, Opus)
Browser->>Sig: réponse SDP, candidats ICE
Sig-->>Browser: candidats ICE
Note over Browser,Sig: ConsumerAdded est déclenché
Note over Browser,Sig: l'écran ou la caméra est lu par la propre connexion WebRTC du spectateur Chaque spectateur obtient son propre encodeur et son propre contrôle de congestion : un spectateur sur un Wi-Fi lent reçoit un débit plus faible sans dégrader la qualité des autres.
Le programme complet¶
Le programme console ci-dessous envoie l'écran principal (ou, avec camera sur la ligne de commande, la première caméra) et le premier micro à chaque navigateur qui ouvre http://localhost:8090/?signalling=8443.
using System;
using System.IO;
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;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;
// 127.0.0.1 ne sert que cet ordinateur ; "0.0.0.0" sert aussi les spectateurs des autres ordinateurs.
const string Host = "127.0.0.1";
const int WebPort = 8090;
const int SignallingPort = 8443;
await VisioForgeX.InitSDKAsync();
MediaBlocksPipeline? pipeline = null;
try
{
if (!WebRTCSinkBlock.IsAvailable())
{
Console.WriteLine("WebRTCSinkBlock is not available: add the VisioForge.CrossPlatform.Core.Windows.Adds.x64 package.");
return;
}
pipeline = new MediaBlocksPipeline();
pipeline.OnError += (s, e) => Console.WriteLine(e.Message);
// L'écran principal par défaut, la première caméra avec "camera" sur la ligne de commande.
MediaBlock video;
if (args.Length > 0 && args[0] == "camera")
{
var cameras = await DeviceEnumerator.Shared.VideoSourcesAsync();
if (cameras.Length == 0)
{
Console.WriteLine("No camera found.");
return;
}
video = new SystemVideoSourceBlock(new VideoCaptureDeviceSourceSettings(cameras[0]));
}
else
{
video = new ScreenSourceBlock(new ScreenCaptureD3D11SourceSettings { FrameRate = new VideoFrameRate(30) });
}
// Son propre serveur de signalisation, plus un serveur web pour la page de visionnage dans wwwroot.
var webrtc = new WebRTCSinkBlock(new WebRTCSinkSettings
{
SignallingServerHost = Host,
SignallingServerPort = SignallingPort,
WebServerDirectory = Path.Combine(AppContext.BaseDirectory, "wwwroot"),
WebServerAddress = $"http://{Host}:{WebPort}/"
});
webrtc.ConsumerAdded += (s, e) => Console.WriteLine($"Viewer connected: {e.PeerId}");
webrtc.ConsumerRemoved += (s, e) => Console.WriteLine($"Viewer left: {e.PeerId}");
// Vidéo brute : le sink l'encode en VP8 pour chaque spectateur.
pipeline.Connect(video.Output, webrtc.CreateNewInput(MediaBlockPadMediaType.Video));
// Le premier micro, s'il y en a un : encodé en Opus pour chaque spectateur.
var microphones = await DeviceEnumerator.Shared.AudioSourcesAsync();
if (microphones.Length > 0)
{
var microphone = new SystemAudioSourceBlock(microphones[0].CreateSourceSettings());
pipeline.Connect(microphone.Output, webrtc.CreateNewInput(MediaBlockPadMediaType.Audio));
}
if (await pipeline.StartAsync())
{
Console.WriteLine($"Open http://localhost:{WebPort}/?signalling={SignallingPort} in a browser. Press Enter to stop.");
Console.ReadLine();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (pipeline != null)
{
await pipeline.StopAsync();
await pipeline.DisposeAsync();
}
VisioForgeX.DestroySDK();
}
Copiez la page de visionnage dans le dossier de sortie à la compilation ; ajoutez ceci au .csproj :
<ItemGroup>
<Content Include="wwwroot\**" CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>
Rôle de chaque partie :
ScreenSourceBlockavecScreenCaptureD3D11SourceSettingscapture le moniteur principal via Direct3D 11 à sa résolution native.FrameRatevaut 10 par défaut ; à 30, les mouvements de souris et le défilement sont fluides.MonitorIndexchoisit un autre moniteur.SystemVideoSourceBlockouvre une caméra.new VideoCaptureDeviceSourceSettings(device)choisit son format HD quand elle en a un ; définissezFormatpour en choisir un autre.WebRTCSinkBlock.CreateNewInputcrée une entrée par appel. Le bloc encode la vidéo et l'audio bruts pour chaque spectateur, la vidéo en VP8 et l'audio en Opus. Une vidéo déjà encodée en VP8 (avecVPXEncoderBlock) est envoyée telle quelle, sans encodeur par spectateur.WebServerDirectoryactive le serveur web du bloc et le fait pointer sur le dossier contenantindex.html. Laissez-le ànullpour servir la page vous-même (voir Servir la page depuis votre propre serveur web).SignallingServerHostet l'hôte deWebServerAddressdéterminent qui peut se connecter :127.0.0.1n'accepte que cet ordinateur,0.0.0.0toutes les interfaces réseau.ConsumerAdded/ConsumerRemovedsignalent chaque spectateur qui se connecte et qui part. Ils sont déclenchés sur un thread GStreamer : dans une application graphique, repassez sur le thread de l'interface, comme le fait la démo avecDispatcher.Invoke.ConsumerRemovedn'est pas déclenché pour les spectateurs encore connectés à l'arrêt du pipeline ; leurs sessions se terminent avec lui.try/finallysignale ce qui a échoué et, dans tous les cas, arrête et libère le pipeline et appelleVisioForgeX.DestroySDK(). QuandStartAsyncrenvoiefalse, la raison figure dans les messagesOnError; un port déjà utilisé est le cas le plus courant.
La page de visionnage¶
La page parle le protocole de signalisation de l'élément GStreamer webrtcsink : des messages JSON sur un WebSocket. Enregistrez-la sous wwwroot/index.html. C'est la page du WebRTC Browser Streamer Demo : elle lit le premier flux annoncé par le serveur, réessaie tant que l'application n'est pas lancée et démarre en sourdine pour que le navigateur la lise sans clic.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>VisioForge WebRTC Viewer</title>
<link rel="icon" href="data:,">
<style>
body { margin: 0; background: #111; color: #ddd; font-family: system-ui, sans-serif; display: flex; flex-direction: column; align-items: center; }
video { width: 100%; max-width: 1280px; max-height: 80vh; background: #000; margin-top: 16px; }
#bar { margin: 12px 16px; display: flex; gap: 12px; align-items: center; }
button { padding: 6px 14px; }
</style>
</head>
<body>
<video id="video" autoplay playsinline muted></video>
<div id="bar">
<button id="unmute">Unmute</button>
<span id="status">Connecting...</span>
</div>
<script>
// Port de signalisation de WebRTCSinkBlock : ?signalling=8443 dans l'URL de la page.
const port = new URLSearchParams(location.search).get('signalling') || '8443';
const video = document.getElementById('video');
const status = document.getElementById('status');
let ws, pc, sessionId;
document.getElementById('unmute').onclick = () => { video.muted = false; };
function send(msg) { ws.send(JSON.stringify(msg)); }
function connect() {
ws = new WebSocket(`ws://${location.hostname}:${port}`);
ws.onopen = () => send({ type: 'setPeerStatus', roles: ['listener'], meta: null });
ws.onclose = () => { reset(); status.textContent = 'Disconnected, retrying...'; setTimeout(connect, 2000); };
ws.onmessage = e => onMessage(e.data).catch(err => fail('Error: ' + err));
}
function startSession(peerId) {
if (sessionId === undefined) {
sessionId = null;
send({ type: 'startSession', peerId });
}
}
async function onMessage(data) {
const msg = JSON.parse(data);
switch (msg.type) {
case 'welcome':
send({ type: 'list' });
break;
case 'list':
if (msg.producers.length > 0) startSession(msg.producers[0].id);
else status.textContent = 'Waiting for the stream...';
break;
case 'peerStatusChanged':
if (msg.roles.includes('producer')) startSession(msg.peerId);
break;
case 'sessionStarted':
sessionId = msg.sessionId;
break;
case 'peer':
await onPeer(msg);
break;
case 'endSession':
reset();
status.textContent = 'Stream ended, waiting...';
listLater();
break;
case 'error':
fail('Error: ' + msg.details);
break;
}
}
async function onPeer(msg) {
if (msg.sdp && msg.sdp.type === 'offer') {
// Reprenez ici les StunServer et TurnServers du sink lorsqu'ils sont définis.
if (pc) { pc.close(); video.srcObject = null; }
pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] });
const conn = pc;
pc.onconnectionstatechange = () => {
if (conn === pc && conn.connectionState === 'failed') {
video.srcObject = null;
fail('Connection lost');
}
};
pc.ontrack = e => { video.srcObject = e.streams[0] || new MediaStream([e.track]); status.textContent = 'Playing'; };
pc.onicecandidate = e => {
if (e.candidate) send({ type: 'peer', sessionId, ice: { candidate: e.candidate.candidate, sdpMLineIndex: e.candidate.sdpMLineIndex } });
};
await pc.setRemoteDescription(msg.sdp);
const answer = await pc.createAnswer();
await pc.setLocalDescription(answer);
send({ type: 'peer', sessionId, sdp: { type: 'answer', sdp: answer.sdp } });
} else if (msg.ice && pc) {
await pc.addIceCandidate({ candidate: msg.ice.candidate, sdpMLineIndex: msg.ice.sdpMLineIndex });
}
}
// Une erreur pendant la lecture d'un flux (message périmé, candidat refusé) ne l'interrompt pas ;
// sinon la session est terminée et la liste des producteurs redemandée.
function fail(text) {
if (video.srcObject) {
status.textContent = text;
return;
}
if (sessionId) send({ type: 'endSession', sessionId });
reset();
status.textContent = text + ', retrying...';
listLater();
}
// Redemande la liste des producteurs après une pause, pour qu'une session en échec ne réessaie pas en boucle serrée.
function listLater() {
const socket = ws;
setTimeout(() => { if (ws === socket && ws.readyState === WebSocket.OPEN) send({ type: 'list' }); }, 2000);
}
function reset() {
if (pc) pc.close();
pc = undefined;
sessionId = undefined;
video.srcObject = null;
}
connect();
</script>
</body>
</html>
L'échange, étape par étape :
- S'inscrire comme listener. La page ouvre un WebSocket vers le port de signalisation, envoie
setPeerStatusavec le rôlelistener, puis demande la liste des producteurs (list). Votre application est le producteur. - Ouvrir une session. La page envoie
startSessionavec l'identifiant du producteur ; un producteur qui apparaît plus tard est annoncé parpeerStatusChanged, la page peut donc être ouverte avant le démarrage de l'application. - Répondre à l'offre. Le bloc envoie l'offre SDP dans un message
peer; la page crée unRTCPeerConnection, répond, et les deux côtés échangent leurs candidats ICE dans d'autres messagespeer. - Lire.
ontrackremet le flux à l'élément<video>. L'état affichePlaying; Unmute active le son, car les navigateurs lisent une vidéo muette sans clic et une vidéo sonore seulement après. - Se rétablir. Quand la connexion échoue ou que l'application s'arrête, la page se réinitialise et redemande la liste ; elle se reconnecte d'elle-même au retour du flux.
Partager une fenêtre plutôt que tout l'écran¶
Définissez WindowHandle pour capturer une seule fenêtre d'application via Windows Graphics Capture. La fenêtre est capturée même lorsque d'autres fenêtres la recouvrent, et le reste du bureau reste privé :
var screen = new ScreenCaptureD3D11SourceSettings
{
FrameRate = new VideoFrameRate(30),
WindowHandle = windowHandle // HWND de la fenêtre à partager, par exemple Process.MainWindowHandle
};
var video = new ScreenSourceBlock(screen);
Le flux prend la taille de la fenêtre au démarrage de la capture. Une fenêtre réduite ne fournit aucune image tant qu'elle n'est pas restaurée.
Servir la page depuis votre propre serveur web¶
Le serveur web du bloc est facultatif. Avec WebServerDirectory laissé à null, seul le serveur de signalisation tourne ; placez index.html dans votre propre site (ASP.NET Core, IIS, nginx) et passez le port de signalisation dans la chaîne de requête. La page se connecte à ws://<hôte de la page>:<port> : le serveur de signalisation doit donc être joignable sous le même nom d'hôte que la page.
Spectateurs sur d'autres ordinateurs¶
- Définissez
Hostsur"0.0.0.0"pour que les deux serveurs écoutent sur toutes les interfaces réseau. - Autorisez le port web et le port de signalisation (ici 8090 et 8443) dans le Pare-feu Windows Defender, ainsi que l'application elle-même pour les médias WebRTC, qui utilisent des ports UDP choisis à l'exécution.
- Ouvrez
http://<adresse de cet ordinateur>:8090/?signalling=8443sur l'autre ordinateur.
La réception WebRTC ne demande pas HTTPS, donc http:// suffit sur un réseau local. WebRTCSinkSettings n'a aucun réglage d'authentification : quiconque atteint les deux ports peut regarder. Gardez 127.0.0.1 quand le flux ne doit pas quitter l'ordinateur, et utilisez WHIP avec un serveur multimédia qui vérifie des jetons quand il doit atteindre Internet.
Partie 2 : publier vers un serveur multimédia avec WHIPSinkBlock¶
Le pipeline¶
WHIP accepte de la vidéo H.264 et de l'audio Opus déjà encodés. Le pipeline encode une seule fois ; le serveur multimédia relaie le flux à chaque spectateur.
graph LR;
ScreenSourceBlock -- "vidéo brute" --> H264EncoderBlock;
SystemAudioSourceBlock -- "audio brut" --> OPUSEncoderBlock;
H264EncoderBlock -- H.264 --> WHIPSinkBlock;
OPUSEncoderBlock -- Opus --> WHIPSinkBlock;
WHIPSinkBlock -- "WHIP (HTTP + WebRTC)" --> MediaMTX; Le programme complet¶
Le programme console publie l'écran principal et le premier micro vers http://<serveur>:8889/screen/whip, le point de terminaison WHIP de MediaMTX pour un flux nommé screen. Passez un autre point de terminaison sur la ligne de commande. L'écran est capturé avec ScreenCaptureD3D11SourceSettings, ce programme se compile donc pour Windows ; sous macOS utilisez ScreenCaptureMacOSSourceSettings, sous Linux ScreenCaptureXDisplaySourceSettings, ou une caméra, comme le fait la démo Avalonia.
using System;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.AudioEncoders;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.VideoEncoders;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sinks;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.Types.X.VideoEncoders;
// Le point de terminaison WHIP du serveur multimédia ; MediaMTX accepte http://<serveur>:8889/<nom du flux>/whip.
var whipUrl = args.Length > 0 ? args[0] : "http://192.168.1.10:8889/screen/whip";
await VisioForgeX.InitSDKAsync();
MediaBlocksPipeline? pipeline = null;
try
{
if (!WHIPSinkBlock.IsAvailable())
{
Console.WriteLine("WHIPSinkBlock is not available: add the VisioForge.CrossPlatform.Core.*.Adds package for this platform.");
return;
}
pipeline = new MediaBlocksPipeline();
pipeline.OnError += (s, e) => Console.WriteLine(e.Message);
var screen = new ScreenSourceBlock(new ScreenCaptureD3D11SourceSettings { FrameRate = new VideoFrameRate(30) });
// WHIP transporte de la vidéo H.264 et de l'audio Opus : encodage unique ici, le serveur sert chaque spectateur.
var h264 = new H264EncoderBlock(new OpenH264EncoderSettings());
var whip = new WHIPSinkBlock(new WHIPSinkSettings { Location = whipUrl });
pipeline.Connect(screen.Output, h264.Input);
pipeline.Connect(h264.Output, whip.CreateNewInput(MediaBlockPadMediaType.Video));
var microphones = await DeviceEnumerator.Shared.AudioSourcesAsync();
if (microphones.Length > 0)
{
var microphone = new SystemAudioSourceBlock(microphones[0].CreateSourceSettings());
var opus = new OPUSEncoderBlock(new OPUSEncoderSettings());
pipeline.Connect(microphone.Output, opus.Input);
pipeline.Connect(opus.Output, whip.CreateNewInput(MediaBlockPadMediaType.Audio));
}
if (await pipeline.StartAsync())
{
Console.WriteLine($"Publishing to {whipUrl}. Press Enter to stop.");
Console.ReadLine();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (pipeline != null)
{
await pipeline.StopAsync();
await pipeline.DisposeAsync();
}
VisioForgeX.DestroySDK();
}
Rôle de chaque partie :
H264EncoderBlockavecOpenH264EncoderSettingsencode en logiciel, sur tout ordinateur Windows, avec le profil Constrained Baseline que décodent tous les navigateurs. Sur un ordinateur doté d'un GPU NVIDIA, AMD ou Intel, les réglages d'un encodeur matériel (NVENCH264EncoderSettings,AMFH264EncoderSettings,QSVH264EncoderSettings) déchargent le CPU de l'encodage.OPUSEncoderBlockencode le micro en Opus, le codec audio de WebRTC.WHIPSinkBlock.CreateNewInputcrée l'entrée vidéo et l'entrée audio. Le bloc ajoute lui-même l'encapsulation RTP, les encodeurs s'y connectent donc directement. L'audio est facultatif : sans micro, le flux est uniquement vidéo.WHIPSinkSettings.Locationest le point de terminaison WHIP. AuStartAsync, le bloc y envoie son offre SDP, le serveur répond et les médias circulent en WebRTC. À l'arrêt, le bloc supprime la session sur le serveur.
Regarder le flux¶
MediaMTX sert son propre lecteur pour chaque flux à http://<serveur>:8889/<nom du flux>/, ici http://<serveur>:8889/screen/. Tout lecteur WHEP peut aussi le lire depuis http://<serveur>:8889/screen/whep, y compris le WHEPSourceBlock du SDK.

Authentification, STUN et TURN¶
var whip = new WHIPSinkBlock(new WHIPSinkSettings
{
Location = "https://media.example.com/live/whip",
AuthToken = "secret-token", // envoyé sous la forme "Authorization: Bearer secret-token"
StunServer = "stun://stun.l.google.com:19302",
TurnServer = "turn://user:password@turn.example.com:3478"
});
AuthToken: le jeton bearer des services qui en exigent un (Cloudflare Stream, un serveur Janus ou MediaMTX avec authentification).StunServer/TurnServer: la part de l'éditeur dans la traversée de NAT. Non défini, le bloc n'utilise aucun serveur STUN, ce qui suffit quand l'application et le serveur sont sur le même réseau.UseLinkHeaders(activé par défaut) reprend aussi les serveurs ICE que le serveur WHIP annonce dans ses en-têtesLink.IceTransportPolicy = WHIPIceTransportPolicy.Relayfait tout passer par le serveur TURN, pour les réseaux qui bloquent l'UDP direct.Timeout(15 secondes par défaut) borne chaque requête HTTP WHIP, y compris leDELETEde la session à l'arrêt.
Les deux depuis une seule capture¶
Une capture peut alimenter les deux sorties à la fois : les spectateurs du réseau local reçoivent le flux directement de l'application, et le serveur multimédia reçoit le flux WHIP pour tous les autres. TeeBlock divise la vidéo :
var tee = new TeeBlock(2, MediaBlockPadMediaType.Video);
pipeline.Connect(screen.Output, tee.Input);
// Spectateurs locaux : vidéo brute, encodée en VP8 par spectateur.
pipeline.Connect(tee.Outputs[0], webrtc.CreateNewInput(MediaBlockPadMediaType.Video));
// Le serveur multimédia : H.264, encodé une seule fois.
pipeline.Connect(tee.Outputs[1], h264.Input);
pipeline.Connect(h264.Output, whip.CreateNewInput(MediaBlockPadMediaType.Video));
TeeBlock se trouve dans VisioForge.Core.MediaBlocks.Special. Les deux sorties démarrent et s'arrêtent ensemble : un serveur WHIP injoignable fait échouer le démarrage de tout le pipeline. Placez-les dans deux pipelines quand le flux local doit continuer sans le serveur.
Limites à connaître avant la mise en production¶
Plateformes¶
WebRTCSinkBlock fonctionne sous Windows x64 avec VisioForge.CrossPlatform.Core.Windows.Adds.x64. WHIPSinkBlock fonctionne sous Windows, macOS et Linux avec le paquet Adds de la plateforme ; sous Linux, il lui faut aussi gstreamer1.0-plugins-bad et gstreamer1.0-nice de la distribution. Vérifiez IsAvailable() au démarrage, comme le font les deux programmes.
Codecs¶
WebRTCSinkBlock envoie de la vidéo VP8 et de l'audio Opus, que lisent tous les navigateurs actuels. Il accepte la vidéo et l'audio bruts, ou du VP8 et de l'Opus déjà encodés ; il n'accepte pas le H.264. WHIPSinkBlock n'accepte que H.264 et Opus.
CPU et résolution¶
WebRTCSinkBlock exécute un encodeur VP8 logiciel par spectateur. Lors de nos tests sur un ordinateur Windows, une caméra 1080p et une fenêtre de 1902×1131 ont été lues à 30 images par seconde, tandis qu'un moniteur entier de 3840×2160 atteignait environ 20 images par seconde dans le navigateur. Pour un écran 4K, réduisez la vidéo avant le sink avec VideoResizeBlock (espace de noms VisioForge.Core.MediaBlocks.VideoProcessing) :
var resize = new VideoResizeBlock(1920, 1080);
pipeline.Connect(screen.Output, resize.Input);
pipeline.Connect(resize.Output, webrtc.CreateNewInput(MediaBlockPadMediaType.Video));
Au-delà de quelques spectateurs, publiez une seule fois en WHIP et laissez le serveur multimédia les servir.
Débit¶
StartBitrate (2 Mbit/s) est le point de départ de chaque spectateur ; le contrôle de congestion (CongestionControl, Google Congestion Control par défaut) le monte jusqu'à MaxBitrate (8 Mbit/s) tant que le réseau suit, et le baisse sinon. Augmentez MaxBitrate pour un texte net sur un grand écran ; définissez CongestionControl = WebRTCSinkCongestionControl.Disabled pour maintenir chaque spectateur à StartBitrate.
Ports¶
Les valeurs par défaut sont 8443 pour la signalisation et 8080 pour le serveur web. Quand un port est occupé, StartAsync renvoie false et OnError indique lequel. Les programmes de ce guide utilisent 8090 pour la page.
NAT, STUN et TURN¶
Sur un réseau local, aucun serveur STUN n'est nécessaire. Pour des spectateurs derrière d'autres réseaux, définissez StunServer et TurnServers dans WebRTCSinkSettings (StunServer vaut stun://stun.l.google.com:19302 par défaut) et les mêmes serveurs dans la liste iceServers de la page. Via Internet, WHIP vers un serveur multimédia doté d'une adresse publique est généralement la voie la plus simple.
Dépannage¶
| Symptôme | Cause et solution |
|---|---|
IsAvailable() renvoie false | Le paquet Adds de la plateforme n'est pas référencé, ou sous Linux gstreamer1.0-plugins-bad et gstreamer1.0-nice manquent. |
StartAsync renvoie false et OnError indique que le serveur web ne peut pas écouter | Un autre programme utilise le port web. Choisissez un autre port dans WebServerAddress, ou arrêtez l'autre programme. |
La page affiche Disconnected, retrying... | Le serveur de signalisation est injoignable : l'application n'est pas lancée, le port ?signalling= est faux, ou le pare-feu le bloque. |
La page affiche Waiting for the stream... | La page a atteint le serveur de signalisation, mais le pipeline n'est pas encore en lecture. Vérifiez StartAsync et les messages OnError. |
La page affiche Playing mais il n'y a pas de son | La vidéo démarre en sourdine. Cliquez sur Unmute. |
Un spectateur sur un autre ordinateur reste sur Connection lost | Les médias WebRTC sont bloqués : autorisez l'application dans le pare-feu, ou configurez STUN/TURN des deux côtés. |
| Une capture d'écran Direct3D 11 n'est jamais lue dans le navigateur et la page se reconnecte sans cesse | Media Blocks SDK .NET 2026.11.20 ou antérieur. Passez à 2026.11.21 ou ultérieur. |
| L'écran est lu avec peu d'images par seconde | Un écran 4K est encodé en logiciel pour chaque spectateur. Réduisez-le en 1080p avec VideoResizeBlock, ou publiez en WHIP. |
WHIP : StartAsync renvoie false ou OnError signale une erreur HTTP | Le point de terminaison est faux, le serveur est arrêté ou il a refusé le jeton. Ouvrez la page du lecteur de la même URL dans un navigateur pour vérifier le serveur. |
WHIP : le flux atteint le serveur mais reste noir ou affiche ICE failed | L'UDP entre l'application et le serveur est bloqué. Autorisez le port UDP WebRTC du serveur (8189 sur MediaMTX), ou configurez un serveur TURN avec IceTransportPolicy = Relay. |
Questions fréquentes¶
Faut-il un serveur multimédia pour afficher mon écran dans un navigateur ?¶
Non. WebRTCSinkBlock sert la page, assure la signalisation et diffuse vers chaque navigateur depuis votre processus. Un serveur multimédia se justifie quand les spectateurs sont nombreux ou sur Internet ; publiez alors vers lui avec WHIPSinkBlock.
Pourquoi VP8 pour les navigateurs et H.264 pour WHIP ?¶
WebRTCSinkBlock encode par spectateur et utilise VP8, que décodent tous les navigateurs et que le bloc peut adapter à la bande passante de chaque spectateur. Les serveurs WHIP comme MediaMTX relaient un seul flux à tous les spectateurs sans réencoder : le flux doit donc déjà être dans un codec qu'ils acceptent ; H.264 est celui qu'acceptent tous les serveurs et navigateurs.
Combien de spectateurs WebRTCSinkBlock peut-il servir ?¶
Chaque spectateur coûte un encodeur VP8. Un flux 1080p sert quelques spectateurs sur un CPU de bureau ; en 4K, le premier spectateur est déjà la limite. Pour davantage de spectateurs, publiez une seule fois en WHIP.
Puis-je ajouter de l'audio ?¶
Oui. Connectez une source audio brute à CreateNewInput(MediaBlockPadMediaType.Audio) de WebRTCSinkBlock, qui encode en Opus par spectateur, ou la sortie d'un OPUSEncoderBlock à l'entrée audio de WHIPSinkBlock.
Cela fonctionne-t-il sous macOS et Linux ?¶
WHIPSinkBlock oui, sous Windows, macOS et Linux. WebRTCSinkBlock est réservé à Windows ; sous macOS et Linux, publiez en WHIP, ou servez des caméras avec WHEPServerSinkBlock.
Un navigateur peut-il lire le flux WHIP sans la page du serveur multimédia ?¶
Oui. Le serveur expose le flux en WHEP, et une page d'une vingtaine de lignes de JavaScript le lit : le lecteur de Caméras IP RTSP dans le navigateur avec WHEP fonctionne avec l'URL /whep de MediaMTX.
Voir aussi¶
- Blocs sink → WebRTC : référence de
WebRTCSinkBlocketWebRTCSinkSettings - Blocs sink → WHIP : référence de
WHIPSinkBlocketWHIPSinkSettings - Caméras IP RTSP dans le navigateur avec WHEP : des caméras IP dans une page web sans réencodage
- Bloc source écran : réglages de capture d'écran, de fenêtre et de moniteur
- Enregistrement pré-événement : conservez les secondes précédant un événement pendant la diffusion