WebRTC ב-Python: מה Python עושה בשיחת וידאו

Python משתתף בשיחת WebRTC באחת משתי דרכים. ברוב המקרים הוא השרת שמאחורי השיחה: הוא מעביר את ההצעות ואת כתובות הרשת בין שני דפדפנים ומחליט מי רשאי להתקשר למי, והדפדפנים עצמם מעבירים את התמונה והקול. לעתים רחוקות יותר הוא צד בשיחה בעצמו, עם הספרייה aiortc, ושולח ומקבל וידאו ושמע מתהליך של Python, כדי להקליט שיחה, להריץ בה בוט או לעבד כל תמונה.
הפוסט הזה מראה את שתיהן, כל אחת כתוכנית קצרה שנבדקה מול Chromium, מסביר איפה כל אחת מתאימה, ואז מראה איך אפליקציית Django, FastAPI או Flask מוסיפה שיחות בין המשתמשים שלה בלי אף אחת מהן.
שני תפקידים ש-Python יכול למלא בשיחה
| תפקיד | מי מעביר את המדיה | מה Python צריך |
|---|---|---|
| שרת איתות | שני הדפדפנים | ספריית websocket |
| צד בשיחה | Python עצמו | aiortc |
בראשון, Python לא רואה אף תמונה. השיחה עוברת מדפדפן לדפדפן, ו-Python רק עוזר להם למצוא זה את זה. זה מה שצ׳אט וידאו בין משתמשים של אפליקציית ווב צריך, וזה אותו דבר בכל שפה שבה השרת כתוב (איך WebRTC מחבר שני דפדפנים מראה את צד הדפדפן במלואו).
בשני, Python הוא קצה אחד של השיחה. הוא עונה להצעה של דפדפן, מפענח את מה שמגיע ומקודד את מה שהוא שולח. זה מיועד לתוכניות שצריכות את המדיה עצמה.
Python כשרת האיתות
לפני שתמונה כלשהי עוברת, שני דפדפנים צריכים להחליף הצעה, תשובה ורשימה של כתובות שבהן אפשר אולי להגיע לכל אחד, שנקראות מועמדים. WebRTC משאיר לאפליקציה את הדרך שבה הם מגיעים זה לזה (RFC 9429, שמתאר את ה-API של הדפדפן, אומר זאת במפורש). שרת האיתות הקטן ביותר מעביר כל הודעה מדפדפן אחד לשני. עם החבילה 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:
# מעבירים לכל שאר המחוברים: כאן, לאדם השני.
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())הוא לא יודע כלום על שיחות ורק מעביר טקסט. הרצנו אותו עם הדף מהפוסט שלנו על שיחות וידאו ב-JavaScript, בלי שינוי, בשתי לשוניות של Chromium עם מצלמות מדומות, בשני הסדרים, וכל לשונית הציגה את השנייה. הדף עושה את השאר: הוא פותח את המצלמה, יוצר את ההצעה ועונה, ומכריע איזה צד מוותר כששניהם מציעים בבת אחת.
מה שאפליקציה אמיתית מוסיפה הוא אותו דבר בכל סטאק. הממסר שלמעלה מעביר כל הודעה לכל אחד, ולכן ממסר אמיתי בודק מי מחובר והאם מותר לו להתקשר לאדם הזה. מי שמתקשרים אליו צריך לשמוע את הצלצול בכל לשונית שפתוחה אצלו, וזה דורש חיבור פתוח לכל משתמש (חיבורי websocket ב-Python מסביר למה Django ו-Flask על WSGI לא יכולים להחזיק חיבור כזה). ושיחות מאחורי חומות אש מחמירות צריכות ממסר TURN (שרתי STUN ו-TURN, בהסבר).
Python כצד בשיחה, עם aiortc
aiortc מממש את WebRTC ב-Python על asyncio, עם API שהולך בעקבות זה של הדפדפן, ו-coroutines במקום promises. ה-README שלו מונה שמע ב-Opus, PCMU ו-PCMA, וידאו ב-VP8 וב-H.264, וערוצי נתונים, שנבדקו מול Chrome ו-Firefox. גרסה 1.16 דורשת Python 3.11 ומעלה.
התוכנית שלמטה עונה לדפדפן ושולחת לו את הווידאו שלו ישר בחזרה, אחרי ש-Python קיבל כל תמונה. היא משתמשת ב-aiohttp לבקשה האחת שההחלפה צריכה (pip install aiortc aiohttp):
import asyncio
from aiohttp import web
from aiortc import RTCPeerConnection, RTCSessionDescription, MediaStreamTrack
peers = set()
class Mirror(MediaStreamTrack):
"""שולח בחזרה כל תמונה שהוא מקבל, אחרי ש-Python ראה אותה."""
kind = "video"
def __init__(self, source):
super().__init__()
self.source = source
async def recv(self):
frame = await self.source.recv() # av.VideoFrame, מפוענח
# frame.to_ndarray(format="bgr24") נותן את הפיקסלים, ל-NumPy או ל-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()) # אוסף קודם את כל המועמדים
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)הדף נמצא ב-static/index.html, עם שני רכיבי וידאו והסקריפט:
<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]);
};
// צד ה-Python מקבל הצעה אחת עם כל המועמדים בתוכה, ולכן מחכים לכולם.
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());הריצו python peer.py ופתחו את http://localhost:8081/index.html. הדפדפן מבקש גישה למצלמה, וכמה שניות אחר כך הווידאו השני מציג את הראשון, חוזר מ-Python. הרצנו אותו ב-Chromium עם מצלמה מדומה: התמונה חזרה ברוחב 640 פיקסלים והמשיכה להגיע.
שלושה דברים בו שונים משיחה בין שני דפדפנים:
- בקשה אחת היא כל ההחלפה. הדפדפן מחכה עד שיש לו את כל המועמדים, ושולח אותם בתוך ההצעה שלו. aiortc אוסף את המועמדים שלו ב-
setLocalDescription()ומכניס אותם לתשובה, כך שלא צריך websocket, ו-POST רגיל מספיק. - הערוץ הוא מחלקה. כל תמונה עוברת דרך
recv(), שמחכה לתמונה מהדפדפן ומחזירה תמונה לשליחה. בין השניים נכנס הקוד שלכם: לקרוא את הפיקסלים, לצייר עליהם, לשמור אותם, או לשלוח משהו אחר. - Python מפענח ומקודד. כל תמונה שעוברת מפוענחת ומקודדת מחדש על ה-CPU. זה בסדר לכמה שיחות בבת אחת, וזו הסיבה ששרת מדיה שמעביר וידאו לאנשים רבים לא מפענח אותו בכלל (איך שיחות וידאו קבוצתיות עובדות).
הדף חייב להיות ב-localhost או ב-HTTPS כדי שהמצלמה תיפתח. בשרת שלכם, צד ה-Python צריך גם שרת STUN, ושרת TURN לאנשים מאחורי רשתות מחמירות, שמוגדרים ב-RTCConfiguration(iceServers=[...]). אם שיחה לא מתחברת, למה חיבור WebRTC נכשל עובר על מה לבדוק.
באיזו מהן אתם צריכים
- המשתמשים שלכם מתקשרים זה לזה. Python הוא שרת האיתות, או משאיר את זה לשירות. הדפדפנים מעבירים את השיחה, ו-Python מחליט מי רשאי להתקשר למי.
- תוכנית מצטרפת לשיחה. מקליט, בוט שמקשיב ועונה, מצלמה במכשיר קטן, בדיקה שמתקשרת מסקריפט. כאן aiortc הופך את Python לצד בשיחה, ואתם מריצים אותו על שרתים משלכם.
רוב אפליקציות הווב צריכות את הראשונה, והעבודה היא פחות בממסר ויותר במה שמסביבו: הצלצול בכל לשונית, הממסרים, התחברות מחדש כשטלפון מחליף רשת, ושיחות קבוצתיות של יותר מארבעה אנשים. זה החלק ששירות יכול לשאת, ולהשאיר לאפליקציה שלכם את ההחלטה היחידה שבאמת שייכת לה.
שיחות ב-Django, FastAPI ו-Flask עם WordPlus Cloud
עם החבילה wordplus-realtime, אפליקציית Python מקיימת שיחות בין המשתמשים שלה בלי שרת איתות, ממסר או מסך שיחה לכתוב, ובלי שום דבר ש-Python צריך לפענח. האפליקציה שלכם מחליטה מי רשאי להתקשר ב-view משלה, שמחזיר token לשיחה. ב-Django:
# shop/views.py, ב-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):
# כאן הבדיקה שלכם: מי רשאי להתקשר למי.
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")),
})הדף מפעיל את מסך השיחה ומציב כפתור במקום שממנו אנשים מתקשרים, והכפתור שואל את ה-view שלכם:
await rt.callScreen(); // הצלצול וחלון השיחה, בכל דף ששיחה עשויה לצלצל בו<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>השיחה מצלצלת בכל לשונית ובכל מכשיר שפתוחים אצל Ann. היא עוברת ישירות בין שני הדפדפנים כשהרשתות שלהם מאפשרות זאת, דרך הממסרים שלנו בפורטים 443 ו-80 כשלא, ודרך שרתי המדיה שלנו כשאפילו הממסרים לא מצליחים להגיע, ועוברת מנתיב לנתיב בלי לנתק. שיחות בין שני אנשים מוצפנות מקצה לקצה בכל נתיב, ושיחות קבוצתיות רצות על אותם שרתים. בלי token מה-view שלכם שום דבר לא מתחיל, כך שאף אחד לא יכול לעקוף אותו.
דפי השיחות בתיעוד שלנו מראים את השאר ל-Django, ל-FastAPI ול-Flask: מי רשאי להתקשר, שיחות קבוצתיות וממשק שיחה משלכם.
שיחות וידאו לאפליקציית ה-Python שלכם
WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי, ושיחות בין שני אנשים לא לוקחות קרדיטים באף נתיב. ראו שיחות וידאו ושיחות קבוצתיות לאפליקציות, או את המחירים לאפליקציות. שאלות על האינטגרציה שלכם? כתבו לנו.