Blog

WebRTC w Pythonie: co Python robi w rozmowie wideo

· Andrij Tkachenko · 7 min czytania

Serwer oznaczony logo Pythona między dwoma oknami przeglądarki, w każdym osoba na wideo, połączony z nimi przerywanymi liniami, wzdłuż jednej z nich przesuwa się klatka filmu

Python bierze udział w rozmowie WebRTC na jeden z dwóch sposobów. Najczęściej jest serwerem stojącym za rozmową: przekazuje oferty i adresy sieciowe między dwiema przeglądarkami i decyduje, kto może dzwonić do kogo, a obraz i dźwięk przenoszą same przeglądarki. Rzadziej jest osobnym uczestnikiem rozmowy, z biblioteką aiortc, i wysyła oraz odbiera wideo i dźwięk z procesu Pythona, żeby nagrać rozmowę, uruchomić w niej bota albo przetworzyć każdą klatkę.

Ten wpis pokazuje oba sposoby, każdy jako krótki program przetestowany z Chromium, wyjaśnia, kiedy który pasuje, a potem pokazuje, jak aplikacja w Django, FastAPI albo Flasku dodaje rozmowy między swoimi użytkownikami bez żadnego z nich.

Dwie role Pythona w rozmowie

Rola Kto przenosi media Czego trzeba
Serwer sygnalizacji Dwie przeglądarki Biblioteki websocket
Uczestnik rozmowy Sam Python aiortc

W pierwszej roli Python nie widzi ani jednej klatki. Rozmowa idzie od przeglądarki do przeglądarki, a Python tylko pomaga im się odnaleźć. Tego potrzebuje czat wideo między użytkownikami aplikacji internetowej i wygląda to tak samo, w czymkolwiek napisany jest serwer (jak WebRTC łączy dwie przeglądarki pokazuje w całości stronę przeglądarki).

W drugiej roli Python jest jednym końcem rozmowy. Odpowiada na ofertę przeglądarki, dekoduje to, co przychodzi, i koduje to, co wysyła. To rozwiązanie dla programów, które potrzebują samych mediów.

Python jako serwer sygnalizacji

Zanim popłynie jakikolwiek obraz, dwie przeglądarki muszą wymienić ofertę, odpowiedź i listę adresów, pod którymi każda może być osiągalna, zwanych kandydatami. WebRTC zostawia aplikacji sposób, w jaki do siebie docierają (mówi to RFC 9429, który opisuje API przeglądarki). Najmniejszy serwer sygnalizacji przekazuje każdą wiadomość od jednej przeglądarki do drugiej. Z pakietem 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:
            # Przekaż dalej wszystkim innym połączonym: tutaj drugiej osobie.
            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())

Nie wie nic o rozmowach i tylko przekazuje tekst. Uruchomiliśmy go ze stroną z naszego wpisu o rozmowach wideo w JavaScript, bez zmian, w dwóch kartach Chromium z wirtualnymi kamerami, w obu kolejnościach, i każda karta pokazała drugą. Resztę robi strona: otwiera kamerę, tworzy ofertę i odpowiada, a także ustala, która strona ustępuje, gdy obie wysyłają ofertę naraz.

To, co dodaje prawdziwa aplikacja, jest takie samo na każdym stosie. Powyższy przekaźnik przekazuje każdą wiadomość każdemu, więc prawdziwy sprawdza, kto jest zalogowany i czy może dzwonić do tej osoby. Osoba, do której dzwonisz, musi usłyszeć dzwonek w każdej otwartej karcie, a to wymaga połączenia utrzymywanego dla każdego użytkownika (websockety w Pythonie wyjaśniają, dlaczego Django i Flask na WSGI go nie utrzymają). A rozmowy za restrykcyjnymi zaporami potrzebują przekaźnika TURN (Serwery STUN i TURN).

Python jako uczestnik rozmowy, z aiortc

aiortc implementuje WebRTC w Pythonie na asyncio, z API wzorowanym na przeglądarkowym, z korutynami w miejscu obietnic. Jego README wymienia dźwięk w Opus, PCMU i PCMA, wideo w VP8 i H.264 oraz kanały danych, przetestowane z Chrome i Firefoksem. Wersja 1.16 wymaga Pythona 3.11 lub nowszego.

Poniższy program odpowiada przeglądarce i odsyła jej wideo z powrotem, gdy Python już odebrał każdą klatkę. Do jedynego żądania, którego potrzebuje wymiana, używa aiohttp (pip install aiortc aiohttp):

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

peers = set()

class Mirror(MediaStreamTrack):
    """Odsyła każdą odebraną klatkę, gdy Python już ją zobaczył."""
    kind = "video"

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

    async def recv(self):
        frame = await self.source.recv()   # av.VideoFrame, już zdekodowana
        # frame.to_ndarray(format="bgr24") daje piksele, dla NumPy albo 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())   # najpierw zbiera wszystkich kandydatów
    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)

Strona trafia do static/index.html, z dwoma elementami wideo i skryptem:

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

// Strona Pythona przyjmuje jedną ofertę ze wszystkimi kandydatami, więc poczekaj na nich wszystkich.
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());

Uruchom python peer.py i otwórz http://localhost:8081/index.html. Przeglądarka poprosi o kamerę, a kilka sekund później drugie wideo pokaże pierwsze, odesłane przez Pythona. Uruchomiliśmy to w Chromium z wirtualną kamerą: obraz wrócił o szerokości 640 pikseli i płynął dalej.

Trzy rzeczy różnią się tu od rozmowy między dwiema przeglądarkami:

  1. Jedno żądanie to cała wymiana. Przeglądarka czeka, aż będzie miała wszystkich kandydatów, i wysyła ich w swojej ofercie. aiortc zbiera własnych kandydatów w setLocalDescription() i umieszcza ich w odpowiedzi, więc websocket nie jest potrzebny i wystarcza zwykły POST.
  2. Ścieżka jest klasą. Każda klatka przechodzi przez recv(), które czeka na klatkę z przeglądarki i zwraca klatkę do wysłania. Między jednym a drugim jest miejsce na Twój kod: odczytaj piksele, rysuj na nich, zachowaj je albo wyślij coś innego.
  3. Python dekoduje i koduje. Każda klatka, która przez niego przechodzi, jest dekodowana i kodowana na nowo na procesorze. Przy kilku rozmowach naraz to wystarcza, i właśnie dlatego serwer mediów, który przekazuje wideo wielu osobom, w ogóle go nie dekoduje (jak działają grupowe rozmowy wideo).

Strona musi działać na localhost albo przez HTTPS, żeby kamera się otworzyła. Na Twoim własnym serwerze strona Pythona potrzebuje też serwera STUN, a dla osób w restrykcyjnych sieciach serwera TURN, podanych w RTCConfiguration(iceServers=[...]). Jeśli rozmowa się nie łączy, dlaczego połączenie WebRTC się nie udaje omawia, co sprawdzić.

Której roli potrzebujesz

  • Twoi użytkownicy dzwonią do siebie nawzajem. Python jest serwerem sygnalizacji albo zostawia to usłudze. Rozmowę przenoszą przeglądarki, a Python decyduje, kto może dzwonić do kogo.
  • Program dołącza do rozmowy. Rejestrator, bot, który słucha i odpowiada, kamera na małym urządzeniu, test, który wykonuje rozmowę ze skryptu. Tutaj aiortc robi z Pythona uczestnika rozmowy, a uruchamiasz go na własnych serwerach.

Większość aplikacji internetowych potrzebuje pierwszej roli, a pracy jest mniej w samym przekaźniku niż wokół niego: dzwonek w każdej karcie, przekaźniki, ponowne łączenie, gdy telefon zmienia sieć, i rozmowy grupowe powyżej czterech osób. To część, którą może przejąć usługa, zostawiając Twojej aplikacji jedyną decyzję, która naprawdę jej dotyczy.

Rozmowy w Django, FastAPI i Flasku z WordPlus Cloud

Z pakietem wordplus-realtime aplikacja w Pythonie wykonuje rozmowy między swoimi użytkownikami bez serwera sygnalizacji, przekaźnika i ekranu rozmowy do napisania, a Python nie musi niczego dekodować. Twoja aplikacja decyduje, kto może dzwonić, we własnym widoku, który zwraca token rozmowy. W Django:

Python
# shop/views.py, pod 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):
    # Tutaj Twoje własne sprawdzenie: kto może dzwonić do kogo.
    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")),
    })

Strona uruchamia ekran rozmowy i umieszcza przycisk tam, skąd ludzie dzwonią, a ten pyta Twój widok:

JavaScript
await rt.callScreen(); // dzwonek i okno rozmowy, na każdej stronie, na której może zadzwonić rozmowa
HTML
<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>

Rozmowa dzwoni w każdej karcie i na każdym urządzeniu, które Ann ma otwarte. Idzie bezpośrednio między dwiema przeglądarkami, gdy pozwalają na to ich sieci, przez nasze przekaźniki na portach 443 i 80, gdy nie pozwalają, i przez nasze serwery mediów, gdy nawet przekaźniki nie mogą dotrzeć, przechodząc z jednej drogi na drugą bez rozłączania. Rozmowy między dwiema osobami są szyfrowane end-to-end na każdej drodze, a rozmowy grupowe działają na tych samych serwerach. Bez tokenu z Twojego widoku nic się nie zaczyna, więc nikt tego nie obejdzie.

Strony o rozmowach w naszej dokumentacji pokazują resztę dla Django, FastAPI i Flaska: kto może dzwonić, rozmowy grupowe i własny interfejs rozmowy.

Rozmowy wideo dla Twojej aplikacji w Pythonie

WordPlus Cloud for Apps ma cenę według jednoczesnych połączeń, od 1000 wzwyż, rozliczaną miesięcznie lub rocznie, a rozmowy między dwiema osobami nie zużywają kredytów na żadnej drodze. Zobacz rozmowy wideo i rozmowy grupowe dla aplikacji albo cennik dla aplikacji. Masz pytania o swoją integrację? Napisz do nas.