Blog

WebRTC en Python : ce que fait Python dans un appel vidéo

· Andrij Tkachenko · 8 min de lecture

Un serveur marqué du logo de Python entre deux fenêtres de navigateur, une personne en vidéo dans chacune, reliées par des lignes pointillées, une image de film passant le long de l’une d’elles

Python prend part à un appel WebRTC de l’une de deux façons. Le plus souvent, il est le serveur derrière l’appel : il fait passer les offres et les adresses réseau entre deux navigateurs et décide qui peut appeler qui, pendant que les navigateurs transportent l’image et le son. Plus rarement, il est un pair à part entière, avec la bibliothèque aiortc, et envoie et reçoit la vidéo et l’audio depuis un processus Python, pour enregistrer un appel, y faire tourner un bot ou traiter chaque image.

Cet article montre les deux, chacun sous la forme d’un court programme testé avec Chromium, explique où chacun a sa place, puis montre comment une application Django, FastAPI ou Flask ajoute des appels entre ses utilisateurs sans aucun des deux.

Les deux rôles de Python dans un appel

Rôle Qui porte les médias Ce qu’il faut
Serveur de signalisation Les deux navigateurs Une bibliothèque websocket
Pair de l’appel Python lui-même aiortc

Dans le premier cas, Python ne voit jamais la moindre image. L’appel va d’un navigateur à l’autre, et Python les aide seulement à se trouver. C’est ce dont a besoin un chat vidéo entre les utilisateurs d’une application web, et c’est pareil quel que soit le langage du serveur (comment WebRTC relie deux navigateurs montre le côté navigateur en entier).

Dans le second, Python est l’un des deux bouts de l’appel. Il répond à l’offre d’un navigateur, décode ce qui arrive et encode ce qu’il envoie. C’est pour les programmes qui ont besoin des médias eux-mêmes.

Python comme serveur de signalisation

Avant que la moindre image ne passe, deux navigateurs doivent échanger une offre, une réponse et une liste des adresses où chacun pourrait être joint, appelées candidates. WebRTC laisse à l’application la façon dont ils se joignent (c’est ce que dit la RFC 9429, qui décrit l’API du navigateur). Le plus petit serveur de signalisation fait passer chaque message d’un navigateur à l’autre. Avec le paquet websockets (pip install websockets) :

signaling.py
import asyncio
from websockets.asyncio.server import serve

clients = set()

async def relay(websocket):
    clients.add(websocket)
    try:
        async for message in websocket:
            # Le transmettre à tous les autres connectés : ici, l’autre personne.
            for other in clients - {websocket}:
                await other.send(message)
    finally:
        clients.discard(websocket)

async def main():
    async with serve(relay, "localhost", 8080) as server:
        await server.serve_forever()

asyncio.run(main())

Il ne sait rien des appels et ne fait que relayer du texte. Nous l’avons fait tourner avec la page de notre article sur les appels vidéo en JavaScript, sans y toucher, dans deux onglets Chromium avec de fausses caméras, dans les deux ordres, et chaque onglet a affiché l’autre. La page fait le reste : elle ouvre la caméra, fait l’offre et répond, et règle quel côté cède quand les deux font une offre en même temps.

Ce qu’une vraie application y ajoute est le même travail que sur n’importe quelle pile. Le relais ci-dessus transmet n’importe quel message à n’importe qui, alors un vrai relais vérifie qui est connecté et si cette personne peut appeler l’autre. La personne appelée doit entendre la sonnerie dans chaque onglet qu’elle a ouvert, ce qui demande une connexion gardée ouverte pour chaque utilisateur (les websockets en Python explique pourquoi Django et Flask sur WSGI ne peuvent pas en tenir une). Et les appels derrière des pare-feu stricts ont besoin d’un relais TURN (les serveurs STUN et TURN, expliqués).

Python comme pair, avec aiortc

aiortc implémente WebRTC en Python sur asyncio, avec une API qui suit celle du navigateur, des coroutines à la place des promesses. Son README liste l’audio en Opus, PCMU et PCMA, la vidéo en VP8 et H.264, et les canaux de données, testés avec Chrome et Firefox. La version 1.16 demande Python 3.11 ou plus récent.

Le programme ci-dessous répond à un navigateur et lui renvoie sa vidéo telle quelle, après que Python a reçu chaque image. Il utilise aiohttp pour la seule requête dont l’échange a besoin (pip install aiortc aiohttp) :

peer.py
import asyncio
from aiohttp import web
from aiortc import RTCPeerConnection, RTCSessionDescription, MediaStreamTrack

peers = set()

class Mirror(MediaStreamTrack):
    """Renvoie chaque image qu’elle reçoit, une fois que Python l’a vue."""
    kind = "video"

    def __init__(self, source):
        super().__init__()
        self.source = source

    async def recv(self):
        frame = await self.source.recv()   # un av.VideoFrame, décodé
        # frame.to_ndarray(format="bgr24") donne les pixels, pour NumPy ou OpenCV.
        return frame

async def offer(request):
    params = await request.json()
    pc = RTCPeerConnection()
    peers.add(pc)

    @pc.on("track")
    def on_track(track):
        if track.kind == "video":
            pc.addTrack(Mirror(track))

    @pc.on("connectionstatechange")
    async def on_state():
        if pc.connectionState in ("failed", "closed"):
            await pc.close()
            peers.discard(pc)

    await pc.setRemoteDescription(RTCSessionDescription(sdp=params["sdp"], type=params["type"]))
    await pc.setLocalDescription(await pc.createAnswer())   # rassemble d’abord toutes les candidates
    return web.json_response({"sdp": pc.localDescription.sdp, "type": pc.localDescription.type})

async def close_all(app):
    await asyncio.gather(*(pc.close() for pc in peers))

app = web.Application()
app.router.add_post("/offer", offer)
app.router.add_static("/", "static")
app.on_shutdown.append(close_all)
web.run_app(app, host="localhost", port=8081)

La page va dans static/index.html, avec deux éléments vidéo et le script :

HTML
<video id="me" autoplay playsinline muted></video>
<video id="back" autoplay playsinline></video>
<script type="module" src="/mirror.js"></script>
static/mirror.js
const local = await navigator.mediaDevices.getUserMedia({ video: true });
document.getElementById('me').srcObject = local;

const pc = new RTCPeerConnection();
pc.addTrack(local.getVideoTracks()[0], local);
pc.ontrack = ({ track }) => {
  document.getElementById('back').srcObject = new MediaStream([track]);
};

// Le côté Python prend une seule offre contenant toutes les candidates, donc on les attend toutes.
await pc.setLocalDescription(await pc.createOffer());
await new Promise((resolve) => {
  if (pc.iceGatheringState === 'complete') return resolve();
  pc.addEventListener('icegatheringstatechange', () => {
    if (pc.iceGatheringState === 'complete') resolve();
  });
});

const response = await fetch('/offer', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(pc.localDescription),
});
await pc.setRemoteDescription(await response.json());

Lancez python peer.py et ouvrez http://localhost:8081/index.html. Le navigateur demande la caméra, et quelques secondes plus tard la seconde vidéo montre la première, revenue de Python. Nous l’avons fait tourner dans Chromium avec une fausse caméra : l’image est revenue en 640 pixels de large et n’a pas cessé d’arriver.

Trois choses y diffèrent d’un appel entre deux navigateurs :

  1. Une seule requête fait tout l’échange. Le navigateur attend d’avoir toutes ses candidates et les envoie dans son offre. aiortc rassemble les siennes dans setLocalDescription() et les met dans sa réponse, si bien qu’aucun websocket n’est nécessaire et qu’un simple POST suffit.
  2. La piste est une classe. Chaque image passe par recv(), qui en attend une du navigateur et en renvoie une à envoyer. C’est entre les deux que va votre code : lire les pixels, dessiner dessus, les garder, ou envoyer autre chose.
  3. Python décode et encode. Chaque image qui passe est décodée puis encodée de nouveau sur le processeur. Cela convient pour quelques appels à la fois, et c’est pourquoi un serveur multimédia qui transmet la vidéo à beaucoup de gens ne la décode pas du tout (comment fonctionnent les appels vidéo de groupe).

La page doit être sur localhost ou en HTTPS pour que la caméra s’ouvre. Sur un serveur à vous, le côté Python a aussi besoin d’un serveur STUN, et d’un serveur TURN pour les personnes derrière des réseaux stricts, donnés dans RTCConfiguration(iceServers=[...]). Si un appel ne se connecte pas, pourquoi une connexion WebRTC échoue passe en revue ce qu’il faut vérifier.

Celui qu’il vous faut

  • Vos utilisateurs s’appellent entre eux. Python est le serveur de signalisation, ou le confie à un service. Les navigateurs transportent l’appel, et Python décide qui peut appeler qui.
  • Un programme rejoint l’appel. Un enregistreur, un bot qui écoute et répond, une caméra sur un petit appareil, un test qui passe un appel depuis un script. Ici, aiortc fait de Python un pair, et vous le faites tourner sur vos propres serveurs.

La plupart des applications web ont besoin du premier, et le travail tient moins au relais qu’à tout ce qui l’entoure : la sonnerie dans chaque onglet, les relais, la reconnexion quand un téléphone change de réseau, et les appels de groupe au-delà de quatre personnes. C’est la partie qu’un service peut prendre en charge, en laissant à votre application la seule décision qui la concerne vraiment.

Des appels dans Django, FastAPI et Flask avec WordPlus Cloud

Avec le paquet wordplus-realtime, une application Python passe des appels entre ses utilisateurs sans serveur de signalisation, sans relais ni écran d’appel à écrire, et sans rien que Python ait à décoder. Votre application décide qui peut appeler dans une vue à elle, qui renvoie un jeton pour l’appel. Dans Django :

Python
# shop/views.py, sur path("call-token", views.call_token) : GET /call-token?to=34&type=video
from django.http import HttpResponse, JsonResponse
from wordplus_realtime.django import realtime

def call_token(request):
    # Votre propre vérification va ici : qui peut appeler qui.
    if not request.user.is_authenticated:
        return HttpResponse(status=401)
    return JsonResponse({
        "token": realtime.call_token(request.user.pk, request.GET["to"], type=request.GET.get("type")),
    })

La page démarre l’écran d’appel et pose un bouton là d’où les gens appellent, qui interroge votre vue :

JavaScript
await rt.callScreen(); // la sonnerie et la fenêtre d’appel, sur chaque page où un appel peut sonner
HTML
<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>

L’appel sonne dans chaque onglet et sur chaque appareil qu’Ann a ouverts. Il passe directement entre les deux navigateurs quand leurs réseaux le permettent, par nos relais sur les ports 443 et 80 quand ils ne le permettent pas, et par nos serveurs multimédias quand même les relais ne passent pas, en basculant de l’un à l’autre sans raccrocher. Les appels entre deux personnes sont chiffrés de bout en bout sur chaque chemin, et les appels de groupe passent par les mêmes serveurs. Sans jeton de votre vue, rien ne démarre, si bien que personne ne peut la contourner.

Les pages sur les appels de notre documentation montrent le reste pour Django, FastAPI et Flask : qui peut appeler, les appels de groupe et une interface d’appel à vous.

Des appels vidéo pour votre application Python

WordPlus Cloud for Apps a un prix selon les connexions simultanées, à partir de 1 000, facturé au mois ou à l’année, et les appels entre deux personnes ne prennent aucun crédit, quel que soit le chemin. Découvrez les appels vidéo et les appels de groupe pour les applications, ou les tarifs pour les applications. Des questions sur votre intégration ? Écrivez-nous.