dv-pipecat-ai 0.0.74.dev770__py3-none-any.whl → 0.0.82.dev776__py3-none-any.whl

pipecat/transports/network/small_webrtc.py

@@ -4,6 +4,13 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
+"""Small WebRTC transport implementation for Pipecat.
+
+This module provides a WebRTC transport implementation using aiortc for
+real-time audio and video communication. It supports bidirectional media
+streaming, application messaging, and client connection management.
+"""
+
 import asyncio
 import fractions
 import time
@@ -33,7 +40,6 @@ from pipecat.transports.base_input import BaseInputTransport
 from pipecat.transports.base_output import BaseOutputTransport
 from pipecat.transports.base_transport import BaseTransport, TransportParams
 from pipecat.transports.network.webrtc_connection import SmallWebRTCConnection
-from pipecat.utils.asyncio.watchdog_async_iterator import WatchdogAsyncIterator
 
 try:
     import cv2
@@ -45,15 +51,38 @@ except ModuleNotFoundError as e:
     logger.error("In order to use the SmallWebRTC, you need to `pip install pipecat-ai[webrtc]`.")
     raise Exception(f"Missing module: {e}")
 
+CAM_VIDEO_SOURCE = "camera"
+SCREEN_VIDEO_SOURCE = "screenVideo"
+MIC_AUDIO_SOURCE = "microphone"
+
 
 class SmallWebRTCCallbacks(BaseModel):
+    """Callback handlers for SmallWebRTC events.
+
+    Parameters:
+        on_app_message: Called when an application message is received.
+        on_client_connected: Called when a client establishes connection.
+        on_client_disconnected: Called when a client disconnects.
+    """
+
     on_app_message: Callable[[Any], Awaitable[None]]
     on_client_connected: Callable[[SmallWebRTCConnection], Awaitable[None]]
     on_client_disconnected: Callable[[SmallWebRTCConnection], Awaitable[None]]
 
 
 class RawAudioTrack(AudioStreamTrack):
+    """Custom audio stream track for WebRTC output.
+
+    Handles audio frame generation and timing for WebRTC transmission,
+    supporting queued audio data with proper synchronization.
+    """
+
     def __init__(self, sample_rate):
+        """Initialize the raw audio track.
+
+        Args:
+            sample_rate: The audio sample rate in Hz.
+        """
         super().__init__()
         self._sample_rate = sample_rate
         self._samples_per_10ms = sample_rate * 10 // 1000
@@ -64,7 +93,17 @@ class RawAudioTrack(AudioStreamTrack):
         self._chunk_queue = deque()
 
     def add_audio_bytes(self, audio_bytes: bytes):
-        """Adds bytes to the audio buffer and returns a Future that completes when the data is processed."""
+        """Add audio bytes to the buffer for transmission.
+
+        Args:
+            audio_bytes: Raw audio data to queue for transmission.
+
+        Returns:
+            A Future that completes when the data is processed.
+
+        Raises:
+            ValueError: If audio bytes are not a multiple of 10ms size.
+        """
         if len(audio_bytes) % self._bytes_per_10ms != 0:
             raise ValueError("Audio bytes must be a multiple of 10ms size.")
         future = asyncio.get_running_loop().create_future()
@@ -79,7 +118,11 @@ class RawAudioTrack(AudioStreamTrack):
         return future
 
     async def recv(self):
-        """Returns the next audio frame, generating silence if needed."""
+        """Return the next audio frame for WebRTC transmission.
+
+        Returns:
+            An AudioFrame containing the next audio data or silence.
+        """
         # Compute required wait time for synchronization
         if self._timestamp > 0:
             wait = self._start + (self._timestamp / self._sample_rate) - time.time()
@@ -106,18 +149,37 @@ class RawAudioTrack(AudioStreamTrack):
 
 
 class RawVideoTrack(VideoStreamTrack):
+    """Custom video stream track for WebRTC output.
+
+    Handles video frame queuing and conversion for WebRTC transmission.
+    """
+
     def __init__(self, width, height):
+        """Initialize the raw video track.
+
+        Args:
+            width: Video frame width in pixels.
+            height: Video frame height in pixels.
+        """
         super().__init__()
         self._width = width
         self._height = height
         self._video_buffer = asyncio.Queue()
 
     def add_video_frame(self, frame):
-        """Adds a raw video frame to the buffer."""
+        """Add a video frame to the transmission buffer.
+
+        Args:
+            frame: The video frame to queue for transmission.
+        """
         self._video_buffer.put_nowait(frame)
 
     async def recv(self):
-        """Returns the next video frame, waiting if the buffer is empty."""
+        """Return the next video frame for WebRTC transmission.
+
+        Returns:
+            A VideoFrame ready for WebRTC transmission.
+        """
         raw_frame = await self._video_buffer.get()
 
         # Convert bytes to NumPy array
@@ -134,6 +196,12 @@ class RawVideoTrack(VideoStreamTrack):
 
 
 class SmallWebRTCClient:
+    """WebRTC client implementation for handling connections and media streams.
+
+    Manages WebRTC peer connections, audio/video streaming, and application
+    messaging through the SmallWebRTCConnection interface.
+    """
+
     FORMAT_CONVERSIONS = {
         "yuv420p": cv2.COLOR_YUV2RGB_I420,
         "yuvj420p": cv2.COLOR_YUV2RGB_I420,  # OpenCV treats both the same
@@ -142,6 +210,12 @@ class SmallWebRTCClient:
     }
 
     def __init__(self, webrtc_connection: SmallWebRTCConnection, callbacks: SmallWebRTCCallbacks):
+        """Initialize the WebRTC client.
+
+        Args:
+            webrtc_connection: The underlying WebRTC connection handler.
+            callbacks: Event callbacks for connection and message handling.
+        """
         self._webrtc_connection = webrtc_connection
         self._closing = False
         self._callbacks = callbacks
@@ -150,11 +224,13 @@ class SmallWebRTCClient:
         self._video_output_track = None
         self._audio_input_track: Optional[AudioStreamTrack] = None
         self._video_input_track: Optional[VideoStreamTrack] = None
+        self._screen_video_track: Optional[VideoStreamTrack] = None
 
         self._params = None
         self._audio_in_channels = None
         self._in_sample_rate = None
         self._out_sample_rate = None
+        self._leave_counter = 0
 
         # We are always resampling it for 16000 if the sample_rate that we receive is bigger than that.
         # otherwise we face issues with Silero VAD
@@ -180,14 +256,14 @@ class SmallWebRTCClient:
             await self._handle_app_message(message)
 
     def _convert_frame(self, frame_array: np.ndarray, format_name: str) -> np.ndarray:
-        """Convert a given frame to RGB format based on the input format.
+        """Convert a video frame to RGB format based on the input format.
 
         Args:
-            frame_array (np.ndarray): The input frame.
-            format_name (str): The format of the input frame.
+            frame_array: The input frame as a NumPy array.
+            format_name: The format of the input frame.
 
         Returns:
-            np.ndarray: The converted RGB frame.
+            The converted RGB frame as a NumPy array.
 
         Raises:
             ValueError: If the format is unsupported.
@@ -202,17 +278,30 @@ class SmallWebRTCClient:
 
         return cv2.cvtColor(frame_array, conversion_code)
 
-    async def read_video_frame(self):
-        """Reads a video frame from the given MediaStreamTrack, converts it to RGB,
+    async def read_video_frame(self, video_source: str):
+        """Read video frames from the WebRTC connection.
+
+        Reads a video frame from the given MediaStreamTrack, converts it to RGB,
         and creates an InputImageRawFrame.
+
+        Args:
+            video_source: Video source to capture ("camera" or "screenVideo").
+
+        Yields:
+            UserImageRawFrame objects containing video data from the peer.
         """
         while True:
-            if self._video_input_track is None:
+            video_track = (
+                self._video_input_track
+                if video_source == CAM_VIDEO_SOURCE
+                else self._screen_video_track
+            )
+            if video_track is None:
                 await asyncio.sleep(0.01)
                 continue
 
             try:
-                frame = await asyncio.wait_for(self._video_input_track.recv(), timeout=2.0)
+                frame = await asyncio.wait_for(video_track.recv(), timeout=2.0)
             except asyncio.TimeoutError:
                 if self._webrtc_connection.is_connected():
                     logger.warning("Timeout: No video frame received within the specified time.")
@@ -238,11 +327,18 @@ class SmallWebRTCClient:
                 size=(frame.width, frame.height),
                 format="RGB",
             )
+            image_frame.transport_source = video_source
 
             yield image_frame
 
     async def read_audio_frame(self):
-        """Reads 20ms of audio from the given MediaStreamTrack and creates an InputAudioRawFrame."""
+        """Read audio frames from the WebRTC connection.
+
+        Reads 20ms of audio from the given MediaStreamTrack and creates an InputAudioRawFrame.
+
+        Yields:
+            InputAudioRawFrame objects containing audio data from the peer.
+        """
         while True:
             if self._audio_input_track is None:
                 await asyncio.sleep(0.01)
@@ -285,20 +381,38 @@ class SmallWebRTCClient:
                 yield audio_frame
 
     async def write_audio_frame(self, frame: OutputAudioRawFrame):
+        """Write an audio frame to the WebRTC connection.
+
+        Args:
+            frame: The audio frame to transmit.
+        """
         if self._can_send() and self._audio_output_track:
             await self._audio_output_track.add_audio_bytes(frame.audio)
 
     async def write_video_frame(self, frame: OutputImageRawFrame):
+        """Write a video frame to the WebRTC connection.
+
+        Args:
+            frame: The video frame to transmit.
+        """
         if self._can_send() and self._video_output_track:
             self._video_output_track.add_video_frame(frame)
 
     async def setup(self, _params: TransportParams, frame):
+        """Set up the client with transport parameters.
+
+        Args:
+            _params: Transport configuration parameters.
+            frame: The initialization frame containing setup data.
+        """
         self._audio_in_channels = _params.audio_in_channels
         self._in_sample_rate = _params.audio_in_sample_rate or frame.audio_in_sample_rate
         self._out_sample_rate = _params.audio_out_sample_rate or frame.audio_out_sample_rate
         self._params = _params
+        self._leave_counter += 1
 
     async def connect(self):
+        """Establish the WebRTC connection."""
         if self._webrtc_connection.is_connected():
             # already initialized
             return
@@ -307,6 +421,11 @@ class SmallWebRTCClient:
         await self._webrtc_connection.connect()
 
     async def disconnect(self):
+        """Disconnect from the WebRTC peer."""
+        self._leave_counter -= 1
+        if self._leave_counter > 0:
+            return
+
         if self.is_connected and not self.is_closing:
             logger.info(f"Disconnecting to Small WebRTC")
             self._closing = True
@@ -314,16 +433,23 @@ class SmallWebRTCClient:
             await self._handle_peer_disconnected()
 
     async def send_message(self, frame: TransportMessageFrame | TransportMessageUrgentFrame):
+        """Send an application message through the WebRTC connection.
+
+        Args:
+            frame: The message frame to send.
+        """
         if self._can_send():
             self._webrtc_connection.send_app_message(frame.message)
 
     async def _handle_client_connected(self):
+        """Handle client connection establishment."""
         # There is nothing to do here yet, the pipeline is still not ready
         if not self._params:
             return
 
         self._audio_input_track = self._webrtc_connection.audio_input_track()
         self._video_input_track = self._webrtc_connection.video_input_track()
+        self._screen_video_track = self._webrtc_connection.screen_video_input_track()
         if self._params.audio_out_enabled:
             self._audio_output_track = RawAudioTrack(sample_rate=self._out_sample_rate)
             self._webrtc_connection.replace_audio_track(self._audio_output_track)
@@ -337,57 +463,98 @@ class SmallWebRTCClient:
         await self._callbacks.on_client_connected(self._webrtc_connection)
 
     async def _handle_peer_disconnected(self):
+        """Handle peer disconnection cleanup."""
         self._audio_input_track = None
         self._video_input_track = None
+        self._screen_video_track = None
         self._audio_output_track = None
         self._video_output_track = None
 
     async def _handle_client_closed(self):
+        """Handle client connection closure."""
         self._audio_input_track = None
         self._video_input_track = None
+        self._screen_video_track = None
         self._audio_output_track = None
         self._video_output_track = None
         await self._callbacks.on_client_disconnected(self._webrtc_connection)
 
     async def _handle_app_message(self, message: Any):
+        """Handle incoming application messages."""
         await self._callbacks.on_app_message(message)
 
     def _can_send(self):
+        """Check if the connection is ready for sending data."""
         return self.is_connected and not self.is_closing
 
     @property
     def is_connected(self) -> bool:
+        """Check if the WebRTC connection is established.
+
+        Returns:
+            True if connected to the peer.
+        """
         return self._webrtc_connection.is_connected()
 
     @property
     def is_closing(self) -> bool:
+        """Check if the connection is in the process of closing.
+
+        Returns:
+            True if the connection is closing.
+        """
         return self._closing
 
 
 class SmallWebRTCInputTransport(BaseInputTransport):
+    """Input transport implementation for SmallWebRTC.
+
+    Handles incoming audio and video streams from WebRTC peers,
+    including user image requests and application message handling.
+    """
+
     def __init__(
         self,
         client: SmallWebRTCClient,
         params: TransportParams,
         **kwargs,
     ):
+        """Initialize the WebRTC input transport.
+
+        Args:
+            client: The WebRTC client instance.
+            params: Transport configuration parameters.
+            **kwargs: Additional arguments passed to parent class.
+        """
         super().__init__(params, **kwargs)
         self._client = client
         self._params = params
         self._receive_audio_task = None
         self._receive_video_task = None
+        self._receive_screen_video_task = None
         self._image_requests = {}
 
         # Whether we have seen a StartFrame already.
         self._initialized = False
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process incoming frames including user image requests.
+
+        Args:
+            frame: The frame to process.
+            direction: The direction of frame flow in the pipeline.
+        """
         await super().process_frame(frame, direction)
 
         if isinstance(frame, UserImageRequestFrame):
             await self.request_participant_image(frame)
 
     async def start(self, frame: StartFrame):
+        """Start the input transport and establish WebRTC connection.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
         await super().start(frame)
 
         if self._initialized:
@@ -397,13 +564,14 @@ class SmallWebRTCInputTransport(BaseInputTransport):
 
         await self._client.setup(self._params, frame)
         await self._client.connect()
+        await self.set_transport_ready(frame)
         if not self._receive_audio_task and self._params.audio_in_enabled:
             self._receive_audio_task = self.create_task(self._receive_audio())
         if not self._receive_video_task and self._params.video_in_enabled:
-            self._receive_video_task = self.create_task(self._receive_video())
-        await self.set_transport_ready(frame)
+            self._receive_video_task = self.create_task(self._receive_video(CAM_VIDEO_SOURCE))
 
     async def _stop_tasks(self):
+        """Stop all background tasks."""
         if self._receive_audio_task:
             await self.cancel_task(self._receive_audio_task)
             self._receive_audio_task = None
@@ -412,66 +580,88 @@ class SmallWebRTCInputTransport(BaseInputTransport):
             self._receive_video_task = None
 
     async def stop(self, frame: EndFrame):
+        """Stop the input transport and disconnect from WebRTC.
+
+        Args:
+            frame: The end frame signaling transport shutdown.
+        """
         await super().stop(frame)
         await self._stop_tasks()
         await self._client.disconnect()
 
     async def cancel(self, frame: CancelFrame):
+        """Cancel the input transport and disconnect immediately.
+
+        Args:
+            frame: The cancel frame signaling immediate cancellation.
+        """
         await super().cancel(frame)
         await self._stop_tasks()
         await self._client.disconnect()
 
     async def _receive_audio(self):
+        """Background task for receiving audio frames from WebRTC."""
         try:
             audio_iterator = self._client.read_audio_frame()
-            async for audio_frame in WatchdogAsyncIterator(
-                audio_iterator, manager=self.task_manager
-            ):
+            async for audio_frame in audio_iterator:
                 if audio_frame:
                     await self.push_audio_frame(audio_frame)
 
         except Exception as e:
             logger.error(f"{self} exception receiving data: {e.__class__.__name__} ({e})")
 
-    async def _receive_video(self):
+    async def _receive_video(self, video_source: str):
+        """Background task for receiving video frames from WebRTC.
+
+        Args:
+            video_source: Video source to capture ("camera" or "screenVideo").
+        """
         try:
-            video_iterator = self._client.read_video_frame()
-            async for video_frame in WatchdogAsyncIterator(
-                video_iterator, manager=self.task_manager
-            ):
+            video_iterator = self._client.read_video_frame(video_source)
+            async for video_frame in video_iterator:
                 if video_frame:
                     await self.push_video_frame(video_frame)
 
                     # Check if there are any pending image requests and create UserImageRawFrame
                     if self._image_requests:
                         for req_id, request_frame in list(self._image_requests.items()):
-                            # Create UserImageRawFrame using the current video frame
-                            image_frame = UserImageRawFrame(
-                                user_id=request_frame.user_id,
-                                request=request_frame,
-                                image=video_frame.image,
-                                size=video_frame.size,
-                                format=video_frame.format,
-                            )
-                            # Push the frame to the pipeline
-                            await self.push_video_frame(image_frame)
-                            # Remove from pending requests
-                            del self._image_requests[req_id]
+                            if request_frame.video_source == video_source:
+                                # Create UserImageRawFrame using the current video frame
+                                image_frame = UserImageRawFrame(
+                                    user_id=request_frame.user_id,
+                                    request=request_frame,
+                                    image=video_frame.image,
+                                    size=video_frame.size,
+                                    format=video_frame.format,
+                                )
+                                image_frame.transport_source = video_source
+                                # Push the frame to the pipeline
+                                await self.push_video_frame(image_frame)
+                                # Remove from pending requests
+                                del self._image_requests[req_id]
 
         except Exception as e:
             logger.error(f"{self} exception receiving data: {e.__class__.__name__} ({e})")
 
     async def push_app_message(self, message: Any):
+        """Push an application message into the pipeline.
+
+        Args:
+            message: The application message to process.
+        """
         logger.debug(f"Received app message inside SmallWebRTCInputTransport  {message}")
         frame = TransportMessageUrgentFrame(message=message)
         await self.push_frame(frame)
 
     # Add this method similar to DailyInputTransport.request_participant_image
     async def request_participant_image(self, frame: UserImageRequestFrame):
-        """Requests an image frame from the participant's video stream.
+        """Request an image frame from the participant's video stream.
 
         When a UserImageRequestFrame is received, this method will store the request
         and the next video frame received will be converted to a UserImageRawFrame.
+
+        Args:
+            frame: The user image request frame.
         """
         logger.debug(f"Requesting image from participant: {frame.user_id}")
 
@@ -479,19 +669,82 @@ class SmallWebRTCInputTransport(BaseInputTransport):
         request_id = f"{frame.function_name}:{frame.tool_call_id}"
         self._image_requests[request_id] = frame
 
+        # Default to camera if no source specified
+        if frame.video_source is None:
+            frame.video_source = CAM_VIDEO_SOURCE
         # If we're not already receiving video, try to get a frame now
-        if not self._receive_video_task and self._params.video_in_enabled:
+        if (
+            frame.video_source == CAM_VIDEO_SOURCE
+            and not self._receive_video_task
+            and self._params.video_in_enabled
+        ):
             # Start video reception if it's not already running
-            self._receive_video_task = self.create_task(self._receive_video())
+            self._receive_video_task = self.create_task(self._receive_video(CAM_VIDEO_SOURCE))
+        elif (
+            frame.video_source == SCREEN_VIDEO_SOURCE
+            and not self._receive_screen_video_task
+            and self._params.video_in_enabled
+        ):
+            # Start screen video reception if it's not already running
+            self._receive_screen_video_task = self.create_task(
+                self._receive_video(SCREEN_VIDEO_SOURCE)
+            )
+
+    async def capture_participant_media(
+        self,
+        source: str = CAM_VIDEO_SOURCE,
+    ):
+        """Capture media from a specific participant.
+
+        Args:
+            source: Media source to capture from. ("camera", "microphone", or "screenVideo")
+        """
+        # If we're not already receiving video, try to get a frame now
+        if (
+            source == MIC_AUDIO_SOURCE
+            and not self._receive_audio_task
+            and self._params.audio_in_enabled
+        ):
+            # Start audio reception if it's not already running
+            self._receive_audio_task = self.create_task(self._receive_audio())
+        elif (
+            source == CAM_VIDEO_SOURCE
+            and not self._receive_video_task
+            and self._params.video_in_enabled
+        ):
+            # Start video reception if it's not already running
+            self._receive_video_task = self.create_task(self._receive_video(CAM_VIDEO_SOURCE))
+        elif (
+            source == SCREEN_VIDEO_SOURCE
+            and not self._receive_screen_video_task
+            and self._params.video_in_enabled
+        ):
+            # Start screen video reception if it's not already running
+            self._receive_screen_video_task = self.create_task(
+                self._receive_video(SCREEN_VIDEO_SOURCE)
+            )
 
 
 class SmallWebRTCOutputTransport(BaseOutputTransport):
+    """Output transport implementation for SmallWebRTC.
+
+    Handles outgoing audio and video streams to WebRTC peers,
+    including transport message sending.
+    """
+
     def __init__(
         self,
         client: SmallWebRTCClient,
         params: TransportParams,
         **kwargs,
     ):
+        """Initialize the WebRTC output transport.
+
+        Args:
+            client: The WebRTC client instance.
+            params: Transport configuration parameters.
+            **kwargs: Additional arguments passed to parent class.
+        """
         super().__init__(params, **kwargs)
         self._client = client
         self._params = params
@@ -500,6 +753,11 @@ class SmallWebRTCOutputTransport(BaseOutputTransport):
         self._initialized = False
 
     async def start(self, frame: StartFrame):
+        """Start the output transport and establish WebRTC connection.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
         await super().start(frame)
 
         if self._initialized:
@@ -512,24 +770,55 @@ class SmallWebRTCOutputTransport(BaseOutputTransport):
         await self.set_transport_ready(frame)
 
     async def stop(self, frame: EndFrame):
+        """Stop the output transport and disconnect from WebRTC.
+
+        Args:
+            frame: The end frame signaling transport shutdown.
+        """
         await super().stop(frame)
         await self._client.disconnect()
 
     async def cancel(self, frame: CancelFrame):
+        """Cancel the output transport and disconnect immediately.
+
+        Args:
+            frame: The cancel frame signaling immediate cancellation.
+        """
         await super().cancel(frame)
         await self._client.disconnect()
 
     async def send_message(self, frame: TransportMessageFrame | TransportMessageUrgentFrame):
+        """Send a transport message through the WebRTC connection.
+
+        Args:
+            frame: The transport message frame to send.
+        """
         await self._client.send_message(frame)
 
     async def write_audio_frame(self, frame: OutputAudioRawFrame):
+        """Write an audio frame to the WebRTC connection.
+
+        Args:
+            frame: The output audio frame to transmit.
+        """
         await self._client.write_audio_frame(frame)
 
     async def write_video_frame(self, frame: OutputImageRawFrame):
+        """Write a video frame to the WebRTC connection.
+
+        Args:
+            frame: The output video frame to transmit.
+        """
         await self._client.write_video_frame(frame)
 
 
 class SmallWebRTCTransport(BaseTransport):
+    """WebRTC transport implementation for real-time communication.
+
+    Provides bidirectional audio and video streaming over WebRTC connections
+    with support for application messaging and connection event handling.
+    """
+
     def __init__(
         self,
         webrtc_connection: SmallWebRTCConnection,
@@ -537,6 +826,14 @@ class SmallWebRTCTransport(BaseTransport):
         input_name: Optional[str] = None,
         output_name: Optional[str] = None,
     ):
+        """Initialize the WebRTC transport.
+
+        Args:
+            webrtc_connection: The underlying WebRTC connection handler.
+            params: Transport configuration parameters.
+            input_name: Optional name for the input processor.
+            output_name: Optional name for the output processor.
+        """
         super().__init__(input_name=input_name, output_name=output_name)
         self._params = params
 
@@ -558,6 +855,11 @@ class SmallWebRTCTransport(BaseTransport):
         self._register_event_handler("on_client_disconnected")
 
     def input(self) -> SmallWebRTCInputTransport:
+        """Get the input transport processor.
+
+        Returns:
+            The input transport for handling incoming media streams.
+        """
         if not self._input:
             self._input = SmallWebRTCInputTransport(
                 self._client, self._params, name=self._input_name
@@ -565,6 +867,11 @@ class SmallWebRTCTransport(BaseTransport):
         return self._input
 
     def output(self) -> SmallWebRTCOutputTransport:
+        """Get the output transport processor.
+
+        Returns:
+            The output transport for handling outgoing media streams.
+        """
         if not self._output:
             self._output = SmallWebRTCOutputTransport(
                 self._client, self._params, name=self._input_name
@@ -572,20 +879,57 @@ class SmallWebRTCTransport(BaseTransport):
         return self._output
 
     async def send_image(self, frame: OutputImageRawFrame | SpriteFrame):
+        """Send an image frame through the transport.
+
+        Args:
+            frame: The image frame to send.
+        """
         if self._output:
             await self._output.queue_frame(frame, FrameDirection.DOWNSTREAM)
 
     async def send_audio(self, frame: OutputAudioRawFrame):
+        """Send an audio frame through the transport.
+
+        Args:
+            frame: The audio frame to send.
+        """
         if self._output:
             await self._output.queue_frame(frame, FrameDirection.DOWNSTREAM)
 
     async def _on_app_message(self, message: Any):
+        """Handle incoming application messages."""
         if self._input:
             await self._input.push_app_message(message)
         await self._call_event_handler("on_app_message", message)
 
     async def _on_client_connected(self, webrtc_connection):
+        """Handle client connection events."""
         await self._call_event_handler("on_client_connected", webrtc_connection)
 
     async def _on_client_disconnected(self, webrtc_connection):
+        """Handle client disconnection events."""
         await self._call_event_handler("on_client_disconnected", webrtc_connection)
+
+    async def capture_participant_video(
+        self,
+        video_source: str = CAM_VIDEO_SOURCE,
+    ):
+        """Capture video from a specific participant.
+
+        Args:
+            video_source: Video source to capture from ("camera" or "screenVideo").
+        """
+        if self._input:
+            await self._input.capture_participant_media(source=video_source)
+
+    async def capture_participant_audio(
+        self,
+        audio_source: str = MIC_AUDIO_SOURCE,
+    ):
+        """Capture audio from a specific participant.
+
+        Args:
+            audio_source: Audio source to capture from. (currently, "microphone" is the only supported option)
+        """
+        if self._input:
+            await self._input.capture_participant_media(source=audio_source)