Remove the usage of the forked aiortc-getstream lib (#221)

dangusev · web-flow · commit 64754d919912 · 2026-03-17T10:32:14.000+01:00
diff --git a/getstream/video/rtc/__init__.py b/getstream/video/rtc/__init__.py
@@ -2,29 +2,29 @@
 from typing import Optional
 
 from getstream.video.async_call import Call
+from getstream.video.rtc.audio_track import AudioStreamTrack
+from getstream.video.rtc.connection_manager import ConnectionManager
+from getstream.video.rtc.connection_utils import join_call_coordinator_request
+from getstream.video.rtc.g711 import (
+    G711Encoding,
+    G711Mapping,
+)
 from getstream.video.rtc.location_discovery import (
-    HTTPHintLocationDiscovery,
-    HEADER_CLOUDFRONT_POP,
     FALLBACK_LOCATION_NAME,
+    HEADER_CLOUDFRONT_POP,
     STREAM_PROD_URL,
+    HTTPHintLocationDiscovery,
 )
 from getstream.video.rtc.models import (
+    Credentials,
     JoinCallRequest,
     JoinCallResponse,
     ServerCredentials,
-    Credentials,
 )
-from getstream.video.rtc.connection_utils import join_call_coordinator_request
-from getstream.video.rtc.connection_manager import ConnectionManager
-from getstream.video.rtc.audio_track import AudioStreamTrack
 from getstream.video.rtc.track_util import (
+    AudioFormat,
     PcmData,
     Resampler,
-    AudioFormat,
-)
-from getstream.video.rtc.g711 import (
-    G711Encoding,
-    G711Mapping,
 )
 
 logger = logging.getLogger(__name__)
diff --git a/getstream/video/rtc/encoders_patches.py b/getstream/video/rtc/encoders_patches.py
@@ -0,0 +1,112 @@
+import logging
+import os
+from typing import Optional
+
+from aiortc import RTCRtpCodecParameters
+from aiortc.codecs.h264 import H264Encoder
+from aiortc.codecs.vpx import Vp8Encoder
+from aiortc.rtcrtpsender import RTCEncodedFrame, RTCRtpSender
+
+logger = logging.getLogger(__name__)
+
+# Stream video bitrate overrides (applied per-connection, not globally).
+# These are higher than aiortc defaults to ensure acceptable video quality.
+STREAM_VIDEO_DEFAULT_BITRATE = 2_500_000  # 2.5 Mbps
+STREAM_VIDEO_MIN_BITRATE = 1_500_000  # 1.5 Mbps
+STREAM_VIDEO_MAX_BITRATE = 3_000_000  # 3 Mbps
+
+
+# Check if the Stream bitrate patching is disabled via environment variable
+BITRATE_PATCH_DISABLED = os.getenv(
+    "STREAM_PATCH_AIORTC_BITRATES", ""
+).lower().strip() in (
+    "0",
+    "false",
+    "no",
+    "off",
+)
+
+
+try:
+    # Verify the name-mangled attributes we depend on still exist.
+    assert hasattr(Vp8Encoder(), "_Vp8Encoder__target_bitrate")
+    assert hasattr(H264Encoder(), "_H264Encoder__target_bitrate")
+
+    class StreamVp8Encoder(Vp8Encoder):
+        """Vp8Encoder subclass with higher bitrate bounds for Stream calls."""
+
+        def __init__(self) -> None:
+            super().__init__()
+            self._Vp8Encoder__target_bitrate = STREAM_VIDEO_DEFAULT_BITRATE
+
+        @property
+        def target_bitrate(self) -> int:
+            return self._Vp8Encoder__target_bitrate
+
+        @target_bitrate.setter
+        def target_bitrate(self, bitrate: int) -> None:
+            bitrate = max(
+                STREAM_VIDEO_MIN_BITRATE, min(bitrate, STREAM_VIDEO_MAX_BITRATE)
+            )
+            self._Vp8Encoder__target_bitrate = bitrate
+
+    class StreamH264Encoder(H264Encoder):
+        """H264Encoder subclass with higher bitrate bounds for Stream calls."""
+
+        def __init__(self) -> None:
+            super().__init__()
+            self._H264Encoder__target_bitrate = STREAM_VIDEO_DEFAULT_BITRATE
+
+        @property
+        def target_bitrate(self) -> int:
+            return self._H264Encoder__target_bitrate
+
+        @target_bitrate.setter
+        def target_bitrate(self, bitrate: int) -> None:
+            bitrate = max(
+                STREAM_VIDEO_MIN_BITRATE, min(bitrate, STREAM_VIDEO_MAX_BITRATE)
+            )
+            self._H264Encoder__target_bitrate = bitrate
+
+except Exception:
+    logger.warning(
+        "Failed to patch aiortc video encoder subclasses with Stream bitrate values (aiortc internals may have changed), "
+        "falling back to default aiortc bitrates. \n"
+        "Set STREAM_PATCH_AIORTC_BITRATES=0 to disable patching.",
+        exc_info=True,
+    )
+    StreamVp8Encoder = None  # type: ignore[assignment, misc]
+    StreamH264Encoder = None  # type: ignore[assignment, misc]
+
+
+def patch_sender_encoder(sender: RTCRtpSender) -> None:
+    """Patch a video sender to use Stream's higher-bitrate encoders.
+
+    If anything goes wrong (e.g. aiortc internals changed), the sender
+    is left untouched and will use the stock encoder via get_encoder().
+    """
+    if StreamVp8Encoder is None or StreamH264Encoder is None:
+        return
+
+    try:
+        _orig_next = sender._next_encoded_frame
+
+        async def _next_with_stream_encoder(
+            codec: RTCRtpCodecParameters, _orig_next=_orig_next
+        ) -> Optional[RTCEncodedFrame]:
+            if sender._RTCRtpSender__encoder is None:  # type: ignore[attr-defined]
+                mime = codec.mimeType.lower()
+                if mime == "video/vp8":
+                    sender._RTCRtpSender__encoder = StreamVp8Encoder()  # type: ignore[attr-defined]
+                elif mime == "video/h264":
+                    sender._RTCRtpSender__encoder = StreamH264Encoder()  # type: ignore[attr-defined]
+            return await _orig_next(codec)
+
+        sender._next_encoded_frame = _next_with_stream_encoder  # type: ignore[method-assign]
+    except Exception:
+        logger.warning(
+            "Failed to patch aiortc video encoder subclasses with Stream bitrate values (aiortc internals may have changed), "
+            "falling back to default aiortc bitrates. \n"
+            "Set STREAM_PATCH_AIORTC_BITRATES=0 to disable patching.",
+            exc_info=True,
+        )
diff --git a/getstream/video/rtc/pc.py b/getstream/video/rtc/pc.py
@@ -4,13 +4,17 @@
 
 import aiortc
 from aiortc.contrib.media import MediaRelay
+from aiortc.mediastreams import MediaStreamTrack
+from aiortc.rtcrtpparameters import RTCRtpCodecCapability
+from aiortc.rtcrtpsender import RTCRtpSender
+from pyee.asyncio import AsyncIOEventEmitter
 
 from getstream.common import telemetry
+from getstream.video.rtc.encoders_patches import (
+    BITRATE_PATCH_DISABLED,
+    patch_sender_encoder,
+)
 from getstream.video.rtc.track_util import AudioTrackHandler
-from pyee.asyncio import AsyncIOEventEmitter
-from aiortc.rtcrtpsender import RTCRtpSender
-from aiortc.rtcrtpparameters import RTCRtpCodecCapability
-
 
 logger = logging.getLogger(__name__)
 
@@ -72,6 +76,12 @@ def on_connectionstatechange():
             if self.connectionState == "connected":
                 self._connected_event.set()
 
+    def addTrack(self, track: MediaStreamTrack) -> RTCRtpSender:
+        sender = super().addTrack(track)
+        if track.kind == "video" and not BITRATE_PATCH_DISABLED:
+            patch_sender_encoder(sender)
+        return sender
+
     async def handle_answer(self, response):
         """Handles the SDP answer received from the SFU for the publisher connection."""
 
diff --git a/pyproject.toml b/pyproject.toml
@@ -35,8 +35,8 @@ openai-realtime = [
   "openai[realtime]>=1.93.0",
 ]
 webrtc = [
-    "aiortc-getstream==1.13.0.post1",
-    "av>=14.0.0,<14.3",  # Pin to versions with pre-built wheels
+    "aiortc>=1.14.0, <1.15.0",
+    "av>=14.2.0, <17",
     "numpy>=2.2.6,<2.3",
     "soundfile>=0.13.1",
     "scipy>=1.15.3,<1.16",
diff --git a/tests/rtc/test_encoders_patches.py b/tests/rtc/test_encoders_patches.py
@@ -0,0 +1,197 @@
+import importlib
+from unittest.mock import MagicMock
+
+import pytest
+from aiortc.codecs.h264 import H264Encoder
+from aiortc.codecs.vpx import Vp8Encoder
+
+from getstream.video.rtc.encoders_patches import (
+    STREAM_VIDEO_DEFAULT_BITRATE,
+    STREAM_VIDEO_MAX_BITRATE,
+    STREAM_VIDEO_MIN_BITRATE,
+    StreamH264Encoder,
+    StreamVp8Encoder,
+    patch_sender_encoder,
+)
+
+# Original upstream values
+ORIGINAL_VPX = {
+    "DEFAULT_BITRATE": 500_000,
+    "MIN_BITRATE": 250_000,
+    "MAX_BITRATE": 1_500_000,
+}
+ORIGINAL_H264 = {
+    "DEFAULT_BITRATE": 1_000_000,
+    "MIN_BITRATE": 500_000,
+}
+
+
+class TestStreamVp8Encoder:
+    def test_default_bitrate(self):
+        enc = StreamVp8Encoder()
+        assert enc.target_bitrate == STREAM_VIDEO_DEFAULT_BITRATE
+
+    def test_clamps_above_max(self):
+        enc = StreamVp8Encoder()
+        enc.target_bitrate = 999_999_999
+        assert enc.target_bitrate == STREAM_VIDEO_MAX_BITRATE
+
+    def test_clamps_below_min(self):
+        enc = StreamVp8Encoder()
+        enc.target_bitrate = 1
+        assert enc.target_bitrate == STREAM_VIDEO_MIN_BITRATE
+
+    def test_accepts_in_range(self):
+        enc = StreamVp8Encoder()
+        enc.target_bitrate = 2_000_000
+        assert enc.target_bitrate == 2_000_000
+
+
+class TestStreamH264Encoder:
+    def test_default_bitrate(self):
+        enc = StreamH264Encoder()
+        assert enc.target_bitrate == STREAM_VIDEO_DEFAULT_BITRATE
+
+    def test_clamps_above_max(self):
+        enc = StreamH264Encoder()
+        enc.target_bitrate = 999_999_999
+        assert enc.target_bitrate == STREAM_VIDEO_MAX_BITRATE
+
+    def test_clamps_below_min(self):
+        enc = StreamH264Encoder()
+        enc.target_bitrate = 1
+        assert enc.target_bitrate == STREAM_VIDEO_MIN_BITRATE
+
+    def test_accepts_in_range(self):
+        enc = StreamH264Encoder()
+        enc.target_bitrate = 2_000_000
+        assert enc.target_bitrate == 2_000_000
+
+
+class TestBitratePatchDisabled:
+    @pytest.mark.parametrize("env_val", [None, "", "1", "true", "yes", "on"])
+    def test_enabled_by_default(self, monkeypatch, env_val):
+        """BITRATE_PATCH_DISABLED is False when env var is unset or truthy."""
+        if env_val is None:
+            monkeypatch.delenv("STREAM_PATCH_AIORTC_BITRATES", raising=False)
+        else:
+            monkeypatch.setenv("STREAM_PATCH_AIORTC_BITRATES", env_val)
+
+        import getstream.video.rtc.encoders_patches as mod
+
+        importlib.reload(mod)
+        assert mod.BITRATE_PATCH_DISABLED is False
+
+    @pytest.mark.parametrize("env_val", ["0", "false", "no", "off"])
+    def test_disabled_via_env(self, monkeypatch, env_val):
+        """BITRATE_PATCH_DISABLED is True when env var is a falsy value."""
+        monkeypatch.setenv("STREAM_PATCH_AIORTC_BITRATES", env_val)
+
+        import getstream.video.rtc.encoders_patches as mod
+
+        importlib.reload(mod)
+        assert mod.BITRATE_PATCH_DISABLED is True
+
+
+class TestPatchSenderEncoder:
+    @pytest.mark.asyncio
+    async def test_installs_vp8_encoder(self):
+        sender = MagicMock()
+        sender._RTCRtpSender__encoder = None
+
+        async def _orig_coro(codec):
+            return None
+
+        sender._next_encoded_frame = _orig_coro
+        patch_sender_encoder(sender)
+
+        codec = MagicMock()
+        codec.mimeType = "video/VP8"
+        await sender._next_encoded_frame(codec)
+
+        from getstream.video.rtc.encoders_patches import StreamVp8Encoder as Vp8Cls
+
+        assert isinstance(sender._RTCRtpSender__encoder, Vp8Cls)
+
+    @pytest.mark.asyncio
+    async def test_installs_h264_encoder(self):
+        sender = MagicMock()
+        sender._RTCRtpSender__encoder = None
+
+        async def _orig_coro(codec):
+            return None
+
+        sender._next_encoded_frame = _orig_coro
+        patch_sender_encoder(sender)
+
+        codec = MagicMock()
+        codec.mimeType = "video/H264"
+        await sender._next_encoded_frame(codec)
+
+        from getstream.video.rtc.encoders_patches import StreamH264Encoder as H264Cls
+
+        assert isinstance(sender._RTCRtpSender__encoder, H264Cls)
+
+    @pytest.mark.asyncio
+    async def test_does_not_replace_existing_encoder(self):
+        """Already-set encoder is not replaced."""
+        sender = MagicMock()
+        existing_encoder = MagicMock()
+        sender._RTCRtpSender__encoder = existing_encoder
+
+        async def _orig_coro(codec):
+            return None
+
+        sender._next_encoded_frame = _orig_coro
+        patch_sender_encoder(sender)
+
+        codec = MagicMock()
+        codec.mimeType = "video/H264"
+        await sender._next_encoded_frame(codec)
+        assert sender._RTCRtpSender__encoder is existing_encoder
+
+    def test_noop_when_encoders_none(self, monkeypatch):
+        """patch_sender_encoder is a no-op when encoder classes failed to load."""
+        import getstream.video.rtc.encoders_patches as mod
+
+        monkeypatch.setattr(mod, "StreamVp8Encoder", None)
+        sender = MagicMock()
+        orig = sender._next_encoded_frame
+        mod.patch_sender_encoder(sender)
+        assert sender._next_encoded_frame is orig
+
+
+class TestUpstreamAssumptions:
+    def test_upstream_assumptions_hold(self):
+        """Canary: fails if aiortc changes its internal API.
+
+        Our per-sender patching relies on name-mangled attributes and
+        the _next_encoded_frame method. If this breaks after an aiortc
+        upgrade, review the upstream code and update accordingly.
+        """
+        vp8 = Vp8Encoder()
+        assert hasattr(vp8, "target_bitrate"), "Vp8Encoder lost target_bitrate"
+
+        h264 = H264Encoder()
+        assert hasattr(h264, "target_bitrate"), "H264Encoder lost target_bitrate"
+
+        # Name-mangled __target_bitrate is accessible from subclasses
+        assert hasattr(vp8, "_Vp8Encoder__target_bitrate"), (
+            "Vp8Encoder name-mangled __target_bitrate changed"
+        )
+        assert hasattr(h264, "_H264Encoder__target_bitrate"), (
+            "H264Encoder name-mangled __target_bitrate changed"
+        )
+
+        # RTCRtpSender has _next_encoded_frame and uses __encoder
+        import inspect
+
+        from aiortc.rtcrtpsender import RTCRtpSender
+
+        assert hasattr(RTCRtpSender, "_next_encoded_frame"), (
+            "RTCRtpSender lost _next_encoded_frame"
+        )
+        source = inspect.getsource(RTCRtpSender._next_encoded_frame)
+        assert "self.__encoder" in source, (
+            "RTCRtpSender._next_encoded_frame no longer uses self.__encoder"
+        )
diff --git a/uv.lock b/uv.lock
