Blog

WebRTC in Python: was Python in einem Videoanruf tut

· Andrij Tkachenko · 8 Min. Lesezeit

Ein Server mit dem Python-Logo zwischen zwei Browserfenstern mit je einer Person im Video, verbunden durch gestrichelte Linien, auf einer davon wandert ein Filmbild entlang

Python nimmt auf eine von zwei Arten an einem WebRTC-Anruf teil. Meist ist es der Server hinter dem Anruf: Es reicht die Angebote und Netzwerkadressen zwischen zwei Browsern weiter und entscheidet, wer wen anrufen darf, während die Browser Bild und Ton übertragen. Seltener ist es ein eigener Peer, mit der Bibliothek aiortc, der aus einem Python-Prozess Video und Audio sendet und empfängt, um einen Anruf aufzuzeichnen, einen Bot darin laufen zu lassen oder jedes Bild zu bearbeiten.

Dieser Beitrag zeigt beides, jeweils als kurzes Programm, getestet mit Chromium, erklärt, wofür sich was eignet, und zeigt dann, wie eine Django-, FastAPI- oder Flask-App Anrufe zwischen ihren Nutzern ohne beides ergänzt.

Zwei Aufgaben, die Python in einem Anruf haben kann

Aufgabe Wer die Medien trägt Was Python braucht
Signalisierung Die beiden Browser Eine WebSocket-Bibliothek
Peer im Anruf Python selbst aiortc

Im ersten Fall sieht Python kein einziges Bild. Der Anruf läuft von Browser zu Browser, und Python hilft ihnen nur, einander zu finden. Das braucht ein Video-Chat zwischen den Nutzern einer Web-App, und es ist dasselbe, in welcher Sprache der Server auch geschrieben ist (wie WebRTC zwei Browser verbindet zeigt die Seite im Browser vollständig).

Im zweiten Fall ist Python ein Ende des Anrufs. Es beantwortet das Angebot eines Browsers, dekodiert, was ankommt, und kodiert, was es sendet. Das ist etwas für Programme, die die Medien selbst brauchen.

Python als Signalisierungsserver

Bevor ein Bild fließt, müssen zwei Browser ein Angebot, eine Antwort und eine Liste von Adressen austauschen, unter denen jeder erreichbar sein könnte, die sogenannten Kandidaten. WebRTC überlässt der App, wie sie einander erreichen (RFC 9429, das die Browser-API beschreibt, sagt das ausdrücklich). Der kleinste Signalisierungsserver reicht jede Nachricht von einem Browser an den anderen weiter. Mit dem Paket 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:
            # An alle anderen Verbundenen weiterreichen: hier an die andere Person.
            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())

Er weiß nichts über Anrufe und reicht nur Text weiter. Wir haben ihn mit der Seite aus unserem Beitrag zu Videoanrufen in JavaScript laufen lassen, unverändert, in zwei Chromium-Tabs mit simulierten Kameras, in beiden Reihenfolgen, und jeder Tab zeigte den anderen. Den Rest erledigt die Seite: Sie öffnet die Kamera, macht das Angebot und antwortet, und sie regelt, welche Seite nachgibt, wenn beide zugleich ein Angebot machen.

Was eine echte App ergänzt, ist auf jedem Stack dasselbe. Der Server oben reicht jede Nachricht an jeden weiter, also prüft ein echter, wer angemeldet ist und ob diese Person die andere anrufen darf. Die angerufene Person muss das Klingeln in jedem Tab hören, den sie offen hat, und das braucht für jeden Nutzer eine offene Verbindung (WebSockets in Python erklärt, warum Django und Flask unter WSGI keine halten können). Und Anrufe hinter strengen Firewalls brauchen ein TURN-Relay (STUN- und TURN-Server erklärt).

Python als Peer, mit aiortc

aiortc setzt WebRTC in Python auf asyncio um, mit einer API, die der des Browsers folgt, Koroutinen statt Promises. Seine README nennt Audio in Opus, PCMU und PCMA, Video in VP8 und H.264 sowie Datenkanäle, getestet mit Chrome und Firefox. Version 1.16 braucht Python 3.11 oder neuer.

Das Programm unten beantwortet einen Browser und schickt sein Video direkt zurück, nachdem Python jedes Bild empfangen hat. Für die eine Anfrage, die der Austausch braucht, nutzt es aiohttp (pip install aiortc aiohttp):

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

peers = set()

class Mirror(MediaStreamTrack):
    """Schickt jedes empfangene Bild zurück, nachdem Python es gesehen hat."""
    kind = "video"

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

    async def recv(self):
        frame = await self.source.recv()   # ein av.VideoFrame, dekodiert
        # frame.to_ndarray(format="bgr24") liefert die Pixel, für NumPy oder 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())   # sammelt zuerst 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)

Die Seite kommt nach static/index.html, mit zwei Video-Elementen und dem Skript:

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]);
};

// Die Python-Seite nimmt ein Angebot mit allen Kandidaten darin, also auf alle warten.
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());

Starten Sie python peer.py und öffnen Sie http://localhost:8081/index.html. Der Browser fragt nach der Kamera, und ein paar Sekunden später zeigt das zweite Video das erste, zurück von Python. Wir haben es in Chromium mit einer simulierten Kamera laufen lassen: Das Bild kam mit 640 Pixeln Breite zurück und kam weiter.

Drei Dinge darin unterscheiden sich von einem Anruf zwischen zwei Browsern:

  1. Eine Anfrage ist der ganze Austausch. Der Browser wartet, bis er alle Kandidaten hat, und schickt sie in seinem Angebot mit. aiortc sammelt seine eigenen Kandidaten in setLocalDescription() und legt sie in seine Antwort, also braucht es keinen WebSocket, und ein einfacher POST genügt.
  2. Der Track ist eine Klasse. Jedes Bild kommt durch recv(), das auf eines vom Browser wartet und eines zum Senden zurückgibt. Dazwischen gehört Ihr Code hin: die Pixel lesen, darauf zeichnen, sie speichern oder etwas anderes senden.
  3. Python dekodiert und kodiert. Jedes Bild, das durchläuft, wird auf der CPU dekodiert und wieder kodiert. Für ein paar Anrufe zugleich ist das in Ordnung, und deshalb dekodiert ein Medienserver, der Video an viele Personen weiterleitet, es gar nicht (wie Gruppen-Videoanrufe funktionieren).

Die Seite muss auf localhost oder HTTPS liegen, damit sich die Kamera öffnet. Auf einem Ihrer Server braucht die Python-Seite außerdem einen STUN-Server und für Menschen hinter strengen Netzwerken einen TURN-Server, angegeben in RTCConfiguration(iceServers=[...]). Kommt ein Anruf nicht zustande, geht warum eine WebRTC-Verbindung scheitert durch, was Sie prüfen sollten.

Was Sie brauchen

  • Ihre Nutzer rufen einander an. Python ist der Signalisierungsserver oder überlässt das einem Dienst. Die Browser tragen den Anruf, und Python entscheidet, wer wen anrufen darf.
  • Ein Programm nimmt am Anruf teil. Ein Aufzeichner, ein Bot, der zuhört und antwortet, eine Kamera an einem kleinen Gerät, ein Test, der aus einem Skript anruft. Hier macht aiortc Python zum Peer, und Sie betreiben es auf eigenen Servern.

Die meisten Web-Apps brauchen das Erste, und die Arbeit steckt weniger im Relay als darum herum: das Klingeln in jedem Tab, die Relays, das neue Verbinden, wenn ein Smartphone das Netzwerk wechselt, und Gruppenanrufe mit mehr als vier Personen. Diesen Teil kann ein Dienst übernehmen, und Ihrer App bleibt die eine Entscheidung, die wirklich sie betrifft.

Anrufe in Django, FastAPI und Flask mit WordPlus Cloud

Mit dem Paket wordplus-realtime führt eine Python-App Anrufe zwischen ihren Nutzern, ohne dass Sie einen Signalisierungsserver, ein Relay oder einen Anrufbildschirm schreiben, und Python muss nichts dekodieren. Ihre App entscheidet in einer eigenen View, wer anrufen darf, und diese antwortet mit einem Token für den Anruf. In Django:

Python
# shop/views.py, unter 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 kommt Ihre eigene Prüfung hin: wer wen anrufen darf.
    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")),
    })

Die Seite startet den Anrufbildschirm und setzt einen Button dorthin, von wo aus Menschen anrufen, der Ihre View fragt:

JavaScript
await rt.callScreen(); // das Klingeln und das Anruffenster, auf jeder Seite, auf der ein Anruf klingeln kann
HTML
<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>

Der Anruf klingelt in jedem Tab und auf jedem Gerät, das Ann offen hat. Er läuft direkt zwischen den beiden Browsern, wenn ihre Netzwerke es erlauben, über unsere Relays auf den Ports 443 und 80, wenn nicht, und über unsere Medienserver, wenn selbst die Relays nicht durchkommen, und wechselt von einem zum nächsten, ohne aufzulegen. Anrufe zwischen zwei Personen sind auf jedem Weg Ende-zu-Ende-verschlüsselt, und Gruppenanrufe laufen auf denselben Servern. Ohne Token von Ihrer View startet nichts, also kommt niemand daran vorbei.

Die Seiten zu Anrufen in unserer Dokumentation zeigen den Rest für Django, FastAPI und Flask: wer anrufen darf, Gruppenanrufe und eine eigene Anrufoberfläche.

Videoanrufe für Ihre Python-App

Für WordPlus Cloud for Apps gelten Preise nach gleichzeitigen Verbindungen, ab 1.000, monatlich oder jährlich abgerechnet, und Anrufe zwischen zwei Personen verbrauchen auf keinem Weg Credits. Sehen Sie sich Videoanrufe und Gruppenanrufe für Apps an oder die Preise für Apps. Fragen zu Ihrer Integration? Schreiben Sie uns.