transports: deprecate TransportParams.camera_* in favor of video_*

CHANGELOG.md

@@ -27,6 +27,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Deprecated
 
+- `TransportParams.camera_*` parameters are now deprecated, use
+  `TransportParams.video_*` instead.
+
 - `TransportParams.vad_enabled` parameter is now deprecated, use
   `TransportParams.audio_in_enabled` and `TransportParams.vad_analyzer` instead.
 

src/pipecat/transports/base_input.py

@@ -77,6 +77,24 @@ class BaseInputTransport(FrameProcessor):
                 )
             self._params.audio_in_passthrough = True
 
+        if self._params.camera_in_enabled or self._params.camera_out_enabled:
+            import warnings
+
+            with warnings.catch_warnings():
+                warnings.simplefilter("always")
+                warnings.warn(
+                    "Parameters 'camera_*' are deprecated, use 'video_*' instead.",
+                    DeprecationWarning,
+                )
+            self._params.video_in_enabled = self._params.camera_in_enabled
+            self._params.video_out_enabled = self._params.camera_out_enabled
+            self._params.video_out_is_live = self._params.camera_out_is_live
+            self._params.video_out_width = self._params.camera_out_width
+            self._params.video_out_height = self._params.camera_out_height
+            self._params.video_out_bitrate = self._params.camera_out_bitrate
+            self._params.video_out_framerate = self._params.camera_out_framerate
+            self._params.video_out_color_format = self._params.camera_out_color_format
+
     def enable_audio_in_stream_on_start(self, enabled: bool) -> None:
         logger.debug(f"Enabling audio on start. {enabled}")
         self._params.audio_in_stream_on_start = enabled

src/pipecat/transports/base_output.py

@@ -212,10 +212,10 @@ class BaseOutputTransport(FrameProcessor):
             self._audio_buffer = self._audio_buffer[self._audio_chunk_size :]
 
     async def _handle_image(self, frame: OutputImageRawFrame | SpriteFrame):
-        if not self._params.camera_out_enabled:
+        if not self._params.video_out_enabled:
             return
 
-        if self._params.camera_out_is_live:
+        if self._params.video_out_is_live:
             await self._camera_out_queue.put(frame)
         else:
             await self._sink_queue.put(frame)
@@ -373,18 +373,18 @@ class BaseOutputTransport(FrameProcessor):
 
     def _create_camera_task(self):
         # Create camera output queue and task if needed.
-        if not self._camera_out_task and self._params.camera_out_enabled:
+        if not self._camera_out_task and self._params.video_out_enabled:
             self._camera_out_queue = asyncio.Queue()
             self._camera_out_task = self.create_task(self._camera_out_task_handler())
 
     async def _cancel_camera_task(self):
         # Stop camera output task.
-        if self._camera_out_task and self._params.camera_out_enabled:
+        if self._camera_out_task and self._params.video_out_enabled:
             await self.cancel_task(self._camera_out_task)
             self._camera_out_task = None
 
     async def _draw_image(self, frame: OutputImageRawFrame):
-        desired_size = (self._params.camera_out_width, self._params.camera_out_height)
+        desired_size = (self._params.video_out_width, self._params.video_out_height)
 
         # TODO: we should refactor in the future to support dynamic resolutions
         # which is kind of what happens in P2P connections.
@@ -408,10 +408,10 @@ class BaseOutputTransport(FrameProcessor):
     async def _camera_out_task_handler(self):
         self._camera_out_start_time = None
         self._camera_out_frame_index = 0
-        self._camera_out_frame_duration = 1 / self._params.camera_out_framerate
+        self._camera_out_frame_duration = 1 / self._params.video_out_framerate
         self._camera_out_frame_reset = self._camera_out_frame_duration * 5
         while True:
-            if self._params.camera_out_is_live:
+            if self._params.video_out_is_live:
                 await self._camera_out_is_live_handler()
             elif self._camera_images:
                 image = next(self._camera_images)

src/pipecat/transports/base_transport.py

@@ -40,6 +40,14 @@ class TransportParams(BaseModel):
     audio_in_filter: Optional[BaseAudioFilter] = None
     audio_in_stream_on_start: bool = True
     audio_in_passthrough: bool = True
+    video_in_enabled: bool = False
+    video_out_enabled: bool = False
+    video_out_is_live: bool = False
+    video_out_width: int = 1024
+    video_out_height: int = 768
+    video_out_bitrate: int = 800000
+    video_out_framerate: int = 30
+    video_out_color_format: str = "RGB"
     vad_enabled: bool = False
     vad_audio_passthrough: bool = False
     vad_analyzer: Optional[VADAnalyzer] = None

src/pipecat/transports/network/small_webrtc.py

@@ -328,9 +328,9 @@ class SmallWebRTCClient:
             self._audio_output_track = RawAudioTrack(sample_rate=self._out_sample_rate)
             self._webrtc_connection.replace_audio_track(self._audio_output_track)
 
-        if self._params.camera_out_enabled:
+        if self._params.video_out_enabled:
             self._video_output_track = RawVideoTrack(
-                width=self._params.camera_out_width, height=self._params.camera_out_height
+                width=self._params.video_out_width, height=self._params.video_out_height
             )
             self._webrtc_connection.replace_video_track(self._video_output_track)
 
@@ -391,7 +391,7 @@ class SmallWebRTCInputTransport(BaseInputTransport):
         await self._client.connect()
         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.camera_in_enabled:
+        if not self._receive_video_task and self._params.video_in_enabled:
             self._receive_video_task = self.create_task(self._receive_video())
 
     async def _stop_tasks(self):
@@ -465,7 +465,7 @@ class SmallWebRTCInputTransport(BaseInputTransport):
         self._image_requests[request_id] = frame
 
         # If we're not already receiving video, try to get a frame now
-        if not self._receive_video_task and self._params.camera_in_enabled:
+        if 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())
 

src/pipecat/transports/services/daily.py

@@ -383,12 +383,12 @@ class DailyTransportClient(EventHandler):
         self._in_sample_rate = self._params.audio_in_sample_rate or frame.audio_in_sample_rate
         self._out_sample_rate = self._params.audio_out_sample_rate or frame.audio_out_sample_rate
 
-        if self._params.camera_out_enabled and not self._camera:
+        if self._params.video_out_enabled and not self._camera:
             self._camera = Daily.create_camera_device(
                 self._camera_name(),
-                width=self._params.camera_out_width,
+                width=self._params.video_out_width,
-                height=self._params.camera_out_height,
+                height=self._params.video_out_height,
-                color_format=self._params.camera_out_color_format,
+                color_format=self._params.video_out_color_format,
             )
 
         if self._params.audio_out_enabled and not self._mic:
@@ -487,7 +487,7 @@ class DailyTransportClient(EventHandler):
             client_settings={
                 "inputs": {
                     "camera": {
-                        "isEnabled": self._params.camera_out_enabled,
+                        "isEnabled": self._params.video_out_enabled,
                         "settings": {
                             "deviceId": self._camera_name(),
                         },
@@ -510,8 +510,8 @@ class DailyTransportClient(EventHandler):
                             "maxQuality": "low",
                             "encodings": {
                                 "low": {
-                                    "maxBitrate": self._params.camera_out_bitrate,
+                                    "maxBitrate": self._params.video_out_bitrate,
-                                    "maxFramerate": self._params.camera_out_framerate,
+                                    "maxFramerate": self._params.video_out_framerate,
                                 }
                             },
                         }