Blog

WebRTC en Python: lo que hace Python en una videollamada

· Andrij Tkachenko · 9 min de lectura

Un servidor marcado con el logotipo de Python entre dos ventanas de navegador, cada una con una persona en vídeo, unidas por líneas discontinuas, con un fotograma que pasa por una de ellas

Python participa en una llamada WebRTC de una de dos formas. Lo más habitual es que sea el servidor que hay detrás de la llamada: pasa las ofertas y las direcciones de red entre dos navegadores y decide quién puede llamar a quién, mientras los navegadores llevan la imagen y el sonido. Con menos frecuencia es un participante más, con la biblioteca aiortc, que envía y recibe vídeo y audio desde un proceso de Python, para grabar una llamada, meter un bot en ella o trabajar sobre cada imagen.

Este artículo muestra las dos, cada una como un programa corto probado con Chromium, explica dónde encaja cada una y después muestra cómo una app de Django, FastAPI o Flask añade llamadas entre sus usuarios sin ninguna de las dos.

Los dos papeles de Python en una llamada

Papel Quién lleva el medio Qué necesita Python
Señalización Los dos navegadores Una biblioteca de websockets
Participante El propio Python aiortc

En el primero, Python no ve ni una sola imagen. La llamada va de navegador a navegador, y Python solo les ayuda a encontrarse. Eso es lo que necesita un videochat entre los usuarios de una app web, y es igual sea cual sea el lenguaje del servidor (cómo conecta WebRTC dos navegadores muestra entero el lado del navegador).

En el segundo, Python es uno de los extremos de la llamada. Responde a la oferta de un navegador, decodifica lo que llega y codifica lo que envía. Eso es para programas que necesitan el propio audio y vídeo.

Python como servidor de señalización

Antes de que llegue ninguna imagen, dos navegadores tienen que intercambiar una oferta, una respuesta y una lista de direcciones en las que se puede encontrar a cada uno, llamadas candidatos. WebRTC deja en manos de la app la forma en que se encuentran (lo dice el RFC 9429, que describe la API del navegador). El servidor de señalización más pequeño pasa cada mensaje de un navegador al otro. Con el paquete 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:
            # Pásalo a todos los demás conectados: aquí, a la otra persona.
            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())

No sabe nada de llamadas y solo reenvía texto. Lo probamos con la página de nuestro artículo sobre videollamadas en JavaScript, sin cambiarla, en dos pestañas de Chromium con cámaras simuladas, en los dos órdenes, y cada pestaña mostró a la otra. La página hace el resto: abre la cámara, crea la oferta y responde, y decide qué lado cede cuando los dos ofrecen a la vez.

Lo que añade una app real es lo mismo en cualquier stack. El relé de arriba pasa cualquier mensaje a cualquiera, así que uno real comprueba quién ha iniciado sesión y si puede llamar a esa persona. La persona a la que se llama tiene que oír el timbre en cada pestaña que tenga abierta, y eso necesita una conexión abierta para cada usuario (websockets en Python explica por qué Django y Flask sobre WSGI no pueden mantenerla). Y las llamadas detrás de cortafuegos estrictos necesitan un relé TURN (los servidores STUN y TURN, explicados).

Python como participante, con aiortc

aiortc implementa WebRTC en Python sobre asyncio, con una API que sigue la del navegador, con corrutinas en lugar de promesas. Su README enumera audio en Opus, PCMU y PCMA, vídeo en VP8 y H.264, y canales de datos, probados con Chrome y Firefox. La versión 1.16 necesita Python 3.11 o posterior.

El programa de abajo responde a un navegador y le devuelve su vídeo tal cual, después de que Python haya recibido cada imagen. Usa aiohttp para la única petición que necesita el intercambio (pip install aiortc aiohttp):

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

peers = set()

class Mirror(MediaStreamTrack):
    """Devuelve cada imagen que recibe, después de que Python la haya visto."""
    kind = "video"

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

    async def recv(self):
        frame = await self.source.recv()   # un av.VideoFrame, ya decodificado
        # frame.to_ndarray(format="bgr24") da los píxeles, para NumPy u 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())   # antes reúne todos los candidatos
    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 página va en static/index.html, con dos elementos de vídeo y el 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]);
};

// El lado de Python acepta una sola oferta con todos los candidatos dentro, así que espera a tenerlos todos.
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());

Ejecuta python peer.py y abre http://localhost:8081/index.html. El navegador pide la cámara, y unos segundos después el segundo vídeo muestra el primero, de vuelta desde Python. Lo probamos en Chromium con una cámara simulada: la imagen volvió con 640 píxeles de ancho y siguió llegando.

Hay tres cosas en él que no son como en una llamada entre dos navegadores:

  1. Una sola petición es todo el intercambio. El navegador espera hasta tener todos los candidatos y los envía en su oferta. aiortc reúne sus propios candidatos en setLocalDescription() y los pone en su respuesta, así que no hace falta ningún websocket y basta con un POST normal.
  2. La pista es una clase. Cada imagen pasa por recv(), que espera una del navegador y devuelve una para enviar. Entre las dos va tu código: leer los píxeles, dibujar sobre ellos, guardarlos o enviar otra cosa.
  3. Python decodifica y codifica. Cada imagen que pasa se decodifica y se vuelve a codificar en la CPU. Eso va bien para unas pocas llamadas a la vez, y es la razón por la que un servidor multimedia que reenvía vídeo a mucha gente no lo decodifica en absoluto (cómo funcionan las videollamadas en grupo).

La página tiene que estar en localhost o en HTTPS para que se abra la cámara. En un servidor tuyo, el lado de Python también necesita un servidor STUN, y un servidor TURN para la gente detrás de redes estrictas, indicados en RTCConfiguration(iceServers=[...]). Si una llamada no conecta, por qué falla una conexión WebRTC repasa qué comprobar.

Cuál de los dos necesitas

  • Tus usuarios se llaman entre sí. Python es el servidor de señalización, o deja eso a un servicio. Los navegadores llevan la llamada, y Python decide quién puede llamar a quién.
  • Un programa entra en la llamada. Una grabadora, un bot que escucha y responde, una cámara en un dispositivo pequeño, una prueba que hace una llamada desde un script. Aquí aiortc convierte a Python en participante, y lo ejecutas en servidores tuyos.

La mayoría de las apps web necesitan lo primero, y el trabajo no está tanto en el relé como en lo que lo rodea: el timbre en cada pestaña, los relés, reconectar cuando un teléfono cambia de red y las llamadas en grupo de más de cuatro personas. Esa es la parte que puede llevar un servicio, y a tu app le queda la única decisión que de verdad es suya.

Llamadas en Django, FastAPI y Flask con WordPlus Cloud

Con el paquete wordplus-realtime, una app de Python hace llamadas entre sus usuarios sin servidor de señalización, relé ni pantalla de llamada que escribir, y sin nada que Python tenga que decodificar. Tu app decide quién puede llamar en una vista propia, que responde con un token para la llamada. En Django:

Python
# shop/views.py, en 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):
    # Aquí va tu propia comprobación: quién puede llamar a quién.
    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 página inicia la pantalla de llamada y pone un botón allí desde donde la gente llama, que le pide el token a tu vista:

JavaScript
await rt.callScreen(); // el timbre y la ventana de la llamada, en cada página en la que pueda sonar una llamada
HTML
<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>

La llamada suena en cada pestaña y en cada dispositivo que Ann tenga abierto. Va directamente entre los dos navegadores cuando sus redes lo permiten, a través de nuestros relés en los puertos 443 y 80 cuando no, y a través de nuestros servidores multimedia cuando ni siquiera los relés llegan, pasando de uno a otro sin colgar. Las llamadas entre dos personas están cifradas de extremo a extremo sea cual sea el camino, y las llamadas en grupo funcionan en los mismos servidores. Sin un token de tu vista no empieza nada, así que nadie puede saltárselo.

Las páginas de llamadas de nuestra documentación muestran el resto para Django, FastAPI y Flask: quién puede llamar, las llamadas en grupo y una interfaz de llamada propia.

Videollamadas para tu app de Python

WordPlus Cloud for Apps tiene un precio según las conexiones simultáneas, a partir de 1.000, con facturación mensual o anual, y las llamadas entre dos personas no gastan créditos por ningún camino. Consulta las videollamadas y las llamadas en grupo para apps, o los precios para apps. ¿Preguntas sobre tu integración? Escríbenos.