WebRTC in Python: wat Python doet in een videogesprek

Python doet op een van twee manieren mee aan een WebRTC-gesprek. Meestal is het de server achter het gesprek: het geeft de aanbiedingen en netwerkadressen door tussen twee browsers en beslist wie wie mag bellen, terwijl de browsers het beeld en het geluid vervoeren. Minder vaak is het zelf een peer, met de bibliotheek aiortc, die video en audio verstuurt en ontvangt vanuit een Python-proces, om een gesprek op te nemen, er een bot in te laten meedoen of elk beeld te bewerken.
Dit artikel laat beide zien, elk als een kort programma dat tegen Chromium is getest, legt uit waar elk past, en laat daarna zien hoe een Django-, FastAPI- of Flask-app gesprekken tussen zijn gebruikers toevoegt zonder een van de twee.
Twee rollen voor Python in een gesprek
| Rol | Media via | Python heeft nodig |
|---|---|---|
| Signalingserver | De twee browsers | Het pakket websockets |
| Peer in het gesprek | Python zelf | aiortc |
In de eerste ziet Python geen enkel beeld. Het gesprek gaat van browser naar browser, en Python helpt ze alleen elkaar te vinden. Dat is wat een videochat tussen de gebruikers van een webapp nodig heeft, en het is hetzelfde in welke taal de server ook geschreven is (hoe WebRTC twee browsers verbindt laat de kant van de browser volledig zien).
In de tweede is Python een van de twee kanten van het gesprek. Het beantwoordt de aanbieding van een browser, decodeert wat binnenkomt en codeert wat het verstuurt. Dat is voor programma’s die de media zelf nodig hebben.
Python als signalingserver
Voordat er beeld stroomt, moeten twee browsers een aanbieding, een antwoord en een lijst adressen uitwisselen waarop elk bereikbaar zou kunnen zijn, kandidaten genoemd. WebRTC laat de manier waarop ze elkaar bereiken aan de app over (dat staat in RFC 9429, dat de API van de browser beschrijft). De kleinste signalingserver geeft elk bericht van de ene browser door aan de andere. Met het pakket websockets (pip install websockets):
import asyncio
from websockets.asyncio.server import serve
clients = set()
async def relay(websocket):
clients.add(websocket)
try:
async for message in websocket:
# Geef het door aan iedereen die verder verbonden is: hier de ander.
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())Hij weet niets van gesprekken en geeft alleen tekst door. We draaiden hem met de pagina uit ons artikel over videogesprekken in JavaScript, ongewijzigd, in twee Chromium-tabbladen met nepcamera’s, in beide volgordes, en elk tabblad toonde het andere. De pagina doet de rest: ze opent de camera, doet de aanbieding en antwoordt, en regelt welke kant voorrang geeft als beide tegelijk een aanbieding doen.
Wat een echte app toevoegt, is hetzelfde als op elke andere stack. De relay hierboven geeft elk bericht aan iedereen door, dus een echte controleert wie er is ingelogd en of die deze persoon mag bellen. Wie gebeld wordt, moet het horen overgaan in elk tabblad dat die open heeft, en daarvoor is een verbinding nodig die voor elke gebruiker open blijft (websockets in Python legt uit waarom Django en Flask op WSGI die niet kunnen vasthouden). En gesprekken achter strenge firewalls hebben een TURN-relay nodig (STUN- en TURN-servers uitgelegd).
Python als peer, met aiortc
aiortc implementeert WebRTC in Python op asyncio, met een API die die van de browser volgt, met coroutines in plaats van promises. De README noemt audio in Opus, PCMU en PCMA, video in VP8 en H.264, en datakanalen, getest tegen Chrome en Firefox. Versie 1.16 vraagt Python 3.11 of nieuwer.
Het programma hieronder beantwoordt een browser en stuurt zijn video meteen terug, nadat Python elk beeld heeft ontvangen. Het gebruikt aiohttp voor het ene verzoek dat de uitwisseling nodig heeft (pip install aiortc aiohttp):
import asyncio
from aiohttp import web
from aiortc import RTCPeerConnection, RTCSessionDescription, MediaStreamTrack
peers = set()
class Mirror(MediaStreamTrack):
"""Stuurt elk beeld dat binnenkomt terug, nadat Python het heeft gezien."""
kind = "video"
def __init__(self, source):
super().__init__()
self.source = source
async def recv(self):
frame = await self.source.recv() # een av.VideoFrame, gedecodeerd
# frame.to_ndarray(format="bgr24") geeft de pixels, voor NumPy of 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()) # verzamelt eerst alle kandidaten
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)De pagina komt in static/index.html, met twee video-elementen en het script:
<video id="me" autoplay playsinline muted></video>
<video id="back" autoplay playsinline></video>
<script type="module" src="/mirror.js"></script>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]);
};
// De Python-kant neemt één aanbieding met alle kandidaten erin, dus wacht op ze allemaal.
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());Draai python peer.py en open http://localhost:8081/index.html. De browser vraagt om de camera, en een paar seconden later toont de tweede video de eerste, terug van Python. We draaiden het in Chromium met een nepcamera: het beeld kwam terug met een breedte van 640 pixels en bleef komen.
Drie dingen zijn hier anders dan in een gesprek tussen twee browsers:
- Eén verzoek is de hele uitwisseling. De browser wacht tot hij alle kandidaten heeft, en stuurt ze mee in zijn aanbieding. aiortc verzamelt zijn eigen kandidaten in
setLocalDescription()en zet ze in zijn antwoord, dus er is geen websocket nodig en een gewone POST volstaat. - De track is een klasse. Elk beeld komt via
recv(), dat op een beeld van de browser wacht en er een teruggeeft om te versturen. Daartussen komt je eigen code: de pixels lezen, erop tekenen, ze bewaren, of iets anders versturen. - Python decodeert en codeert. Elk beeld dat erdoor gaat, wordt op de CPU gedecodeerd en opnieuw gecodeerd. Voor een paar gesprekken tegelijk is dat prima, en het is de reden dat een mediaserver die video naar veel mensen doorstuurt, die helemaal niet decodeert (hoe groepsvideogesprekken werken).
De pagina moet op localhost of HTTPS staan om de camera te openen. Op een eigen server heeft de Python-kant ook een STUN-server nodig, en een TURN-server voor mensen achter strenge netwerken, opgegeven in RTCConfiguration(iceServers=[...]). Komt een gesprek niet tot stand, dan loopt waarom een WebRTC-verbinding mislukt na wat je controleert.
Welke je nodig hebt
- Je gebruikers bellen elkaar. Python is de signalingserver, of laat dat aan een dienst over. De browsers vervoeren het gesprek, en Python beslist wie wie mag bellen.
- Een programma doet mee aan het gesprek. Een recorder, een bot die luistert en antwoordt, een camera op een klein apparaat, een test die vanuit een script belt. Hier maakt aiortc van Python een peer, en je draait het op je eigen servers.
De meeste webapps hebben het eerste nodig, en het werk zit minder in de relay dan eromheen: het overgaan in elk tabblad, de relays, opnieuw verbinden als een telefoon van netwerk wisselt, en groepsgesprekken met meer dan vier mensen. Dat is het deel dat een dienst kan dragen, zodat je app het ene besluit houdt dat er echt over gaat.
Gesprekken in Django, FastAPI en Flask met WordPlus Cloud
Met het pakket wordplus-realtime plaatst een Python-app gesprekken tussen zijn gebruikers zonder dat je een signalingserver, relay of belscherm hoeft te schrijven, en zonder dat Python iets hoeft te decoderen. Je app beslist wie mag bellen in een eigen view, die een token voor het gesprek teruggeeft. In Django:
# shop/views.py, op 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):
# Hier komt je eigen controle: wie wie mag bellen.
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")),
})De pagina start het belscherm en zet een knop waar mensen vandaan bellen, die je view om een token vraagt:
await rt.callScreen(); // het overgaan en het gespreksvenster, op elke pagina waar een gesprek kan binnenkomen<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>Het gesprek gaat over in elk tabblad en op elk apparaat dat Ann open heeft. Het gaat rechtstreeks tussen de twee browsers als hun netwerken dat toelaten, via onze relays op de poorten 443 en 80 als dat niet zo is, en via onze mediaservers als zelfs de relays er niet doorkomen, en het wisselt van de ene weg naar de andere zonder op te hangen. Gesprekken tussen twee mensen zijn op elke weg end-to-end versleuteld, en groepsgesprekken lopen over dezelfde servers. Zonder token van je view begint er niets, dus niemand kan eromheen.
De gesprekspagina’s van onze documentatie laten de rest zien voor Django, FastAPI en Flask: wie mag bellen, groepsgesprekken en een eigen gespreksinterface.
Videogesprekken voor je Python-app
WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, en gesprekken tussen twee mensen kosten op geen enkele weg credits. Bekijk videogesprekken en groepsgesprekken voor apps, of de prijzen voor apps. Vragen over je integratie? Schrijf ons.