feat(rtc): Add event_types filtering to FfiQueue.subscribe()

PROBLEM:
FfiQueue.put() broadcasts ALL FFI events to ALL subscribers via
call_soon_threadsafe(). Each call creates asyncio.Handle + context objects.
AudioStream/VideoStream filter events with wait_for(predicate), but objects
are already allocated. With N streams, this creates N × all_events objects,
with 95%+ discarded after allocation.

In a 2-hour meeting with 4 participants, we observed:
- 903,154 FFI events accumulated
- Memory grew from 312 MB to 1.29 GB
- Event loop lag increased to 20+ seconds

SOLUTION:
Add optional `event_types` parameter to FfiQueue.subscribe(). When specified,
events are filtered by type BEFORE calling call_soon_threadsafe(), preventing
unnecessary object allocation.

AudioStream now subscribes with event_types={"audio_stream_event"}
VideoStream now subscribes with event_types={"video_stream_event"}

This reduces memory allocations by ~95% for stream subscribers while
maintaining full backwards compatibility (event_types=None = all events).

TESTING:
- Added unit tests for event filtering functionality
- Verified 95% reduction in object creation with filtered subscribers
- Tested in production environment with stable memory usage

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Hormold

livekit-rtc/livekit/rtc/_ffi_client.py

@@ -24,7 +24,7 @@
 import platform
 import atexit
 import threading
-from typing import Generic, List, Optional, TypeVar
+from typing import Generic, List, Optional, Set, TypeVar
 
 from ._proto import ffi_pb2 as proto_ffi
 from ._utils import Queue, classproperty
@@ -114,29 +114,58 @@ def __repr__(self) -> str:
 class FfiQueue(Generic[T]):
     def __init__(self) -> None:
         self._lock = threading.RLock()
-        self._subscribers: List[tuple[Queue[T], asyncio.AbstractEventLoop]] = []
+        # Format: (queue, loop, event_types or None)
+        self._subscribers: List[
+            tuple[Queue[T], asyncio.AbstractEventLoop, Optional[Set[str]]]
+        ] = []
 
     def put(self, item: T) -> None:
+        # Get event type for filtering (if item has WhichOneof method)
+        which = None
+        try:
+            which = item.WhichOneof("message")  # type: ignore
+        except Exception:
+            pass
+
         with self._lock:
-            for queue, loop in self._subscribers:
+            for queue, loop, event_types in self._subscribers:
+                # Filter: if event_types specified and we know the type, skip non-matching
+                if event_types is not None and which is not None:
+                    if which not in event_types:
+                        continue
+
                 try:
                     loop.call_soon_threadsafe(queue.put_nowait, item)
                 except Exception as e:
                     # this could happen if user closes the runloop without unsubscribing first
                     # it's not good when it does occur, but we should not fail the entire runloop
                     logger.error("error putting to queue: %s", e)
 
-    def subscribe(self, loop: Optional[asyncio.AbstractEventLoop] = None) -> Queue[T]:
+    def subscribe(
+        self,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        event_types: Optional[Set[str]] = None,
+    ) -> Queue[T]:
+        """Subscribe to FFI events.
+
+        Args:
+            loop: Event loop to use (defaults to current).
+            event_types: Optional set of event type names to receive (e.g., {"audio_stream_event"}).
+                        If None, receives all events (original behavior).
+
+        Returns:
+            Queue to receive events from.
+        """
         with self._lock:
             queue = Queue[T]()
             loop = loop or asyncio.get_event_loop()
-            self._subscribers.append((queue, loop))
+            self._subscribers.append((queue, loop, event_types))
             return queue
 
     def unsubscribe(self, queue: Queue[T]) -> None:
         with self._lock:
             # looping here is ok, since we don't expect a lot of subscribers
-            for i, (q, _) in enumerate(self._subscribers):
+            for i, (q, _, _) in enumerate(self._subscribers):
                 if q == queue:
                     self._subscribers.pop(i)
                     break

livekit-rtc/livekit/rtc/audio_stream.py

@@ -102,7 +102,11 @@ def __init__(
         self._num_channels = num_channels
         self._frame_size_ms = frame_size_ms
         self._loop = loop or asyncio.get_event_loop()
-        self._ffi_queue = FfiClient.instance.queue.subscribe(self._loop)
+        # Only subscribe to audio_stream_event to avoid unnecessary memory allocations
+        # from other event types (room_event, track_event, etc.)
+        self._ffi_queue = FfiClient.instance.queue.subscribe(
+            self._loop, event_types={"audio_stream_event"}
+        )
         self._queue: RingQueue[AudioFrameEvent | None] = RingQueue(capacity)
 
         self._audio_filter_module: str | None = None

livekit-rtc/livekit/rtc/video_stream.py

@@ -47,7 +47,11 @@ def __init__(
         **kwargs,
     ) -> None:
         self._loop = loop or asyncio.get_event_loop()
-        self._ffi_queue = FfiClient.instance.queue.subscribe(self._loop)
+        # Only subscribe to video_stream_event to avoid unnecessary memory allocations
+        # from other event types (room_event, track_event, etc.)
+        self._ffi_queue = FfiClient.instance.queue.subscribe(
+            self._loop, event_types={"video_stream_event"}
+        )
         self._queue: RingQueue[VideoFrameEvent | None] = RingQueue(capacity)
         self._track: Track | None = track
         self._format = format