reachy-mini 1.2.5rc1__py3-none-any.whl

reachy_mini/media/camera_utils.py

@@ -0,0 +1,111 @@
+"""Camera utility for Reachy Mini."""
+
+import platform
+from typing import Optional, Tuple, cast
+
+import cv2
+from cv2_enumerate_cameras import enumerate_cameras
+
+from reachy_mini.media.camera_constants import (
+    ArducamSpecs,
+    CameraSpecs,
+    OlderRPiCamSpecs,
+    ReachyMiniLiteCamSpecs,
+)
+
+
+def find_camera(
+    apiPreference: int = cv2.CAP_ANY, no_cap: bool = False
+) -> Tuple[Optional[cv2.VideoCapture], Optional[CameraSpecs]]:
+    """Find and return the Reachy Mini camera.
+
+    Looks for the Reachy Mini camera first, then Arducam, then older Raspberry Pi Camera. Returns None if no camera is found.
+
+    Args:
+        apiPreference (int): Preferred API backend for the camera. Default is cv2.CAP_ANY.
+        no_cap (bool): If True, close the camera after finding it. Default is False.
+
+    Returns:
+        cv2.VideoCapture | None: A VideoCapture object if the camera is found and opened successfully, otherwise None.
+
+    """
+    cap = find_camera_by_vid_pid(
+        ReachyMiniLiteCamSpecs.vid, ReachyMiniLiteCamSpecs.pid, apiPreference
+    )
+    if cap is not None:
+        fourcc = cv2.VideoWriter_fourcc("M", "J", "P", "G")  # type: ignore
+        cap.set(cv2.CAP_PROP_FOURCC, fourcc)
+        if no_cap:
+            cap.release()
+        return cap, cast(CameraSpecs, ReachyMiniLiteCamSpecs)
+
+    cap = find_camera_by_vid_pid(
+        OlderRPiCamSpecs.vid, OlderRPiCamSpecs.pid, apiPreference
+    )
+    if cap is not None:
+        fourcc = cv2.VideoWriter_fourcc("M", "J", "P", "G")  # type: ignore
+        cap.set(cv2.CAP_PROP_FOURCC, fourcc)
+        if no_cap:
+            cap.release()
+        return cap, cast(CameraSpecs, OlderRPiCamSpecs)
+
+    cap = find_camera_by_vid_pid(ArducamSpecs.vid, ArducamSpecs.pid, apiPreference)
+    if cap is not None:
+        if no_cap:
+            cap.release()
+        return cap, cast(CameraSpecs, ArducamSpecs)
+
+    return None, None
+
+
+def find_camera_by_vid_pid(
+    vid: int = ReachyMiniLiteCamSpecs.vid,
+    pid: int = ReachyMiniLiteCamSpecs.pid,
+    apiPreference: int = cv2.CAP_ANY,
+) -> cv2.VideoCapture | None:
+    """Find and return a camera with the specified VID and PID.
+
+    Args:
+        vid (int): Vendor ID of the camera. Default is ReachyMiniCamera
+        pid (int): Product ID of the camera. Default is ReachyMiniCamera
+        apiPreference (int): Preferred API backend for the camera. Default is cv2.CAP_ANY.
+
+    Returns:
+        cv2.VideoCapture | None: A VideoCapture object if the camera is found and opened successfully, otherwise None.
+
+    """
+    if platform.system() == "Linux":
+        apiPreference = cv2.CAP_V4L2
+
+    selected_cap = None
+    for c in enumerate_cameras(apiPreference):
+        if c.vid == vid and c.pid == pid:
+            # the Arducam camera creates two /dev/videoX devices
+            # that enumerate_cameras cannot differentiate
+            try:
+                cap = cv2.VideoCapture(c.index, c.backend)
+                if cap.isOpened():
+                    selected_cap = cap
+            except Exception as e:
+                print(f"Error opening camera {c.index}: {e}")
+    return selected_cap
+
+
+if __name__ == "__main__":
+    from reachy_mini.media.camera_constants import CameraResolution
+
+    cam, _ = find_camera()
+    if cam is None:
+        exit("Camera not found")
+
+    cam.set(cv2.CAP_PROP_FRAME_WIDTH, CameraResolution.R1280x720at30fps.value[0])
+    cam.set(cv2.CAP_PROP_FRAME_HEIGHT, CameraResolution.R1280x720at30fps.value[1])
+
+    while True:
+        ret, frame = cam.read()
+        if not ret:
+            print("Failed to grab frame")
+            break
+        cv2.imshow("Camera Feed", frame)
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break

reachy_mini/media/media_manager.py

@@ -0,0 +1,281 @@
+"""Media Manager.
+
+Provides camera and audio access based on the selected backedn
+"""
+
+import logging
+from enum import Enum
+from typing import Optional
+
+import numpy as np
+import numpy.typing as npt
+
+from reachy_mini.media.audio_base import AudioBase
+from reachy_mini.media.camera_base import CameraBase
+
+# actual backends are dynamically imported
+
+
+class MediaBackend(Enum):
+    """Media backends."""
+
+    NO_MEDIA = "no_media"
+    DEFAULT = "default"
+    DEFAULT_NO_VIDEO = "default_no_video"
+    GSTREAMER = "gstreamer"
+    GSTREAMER_NO_VIDEO = "gstreamer_no_video"
+    WEBRTC = "webrtc"
+
+
+class MediaManager:
+    """Abstract class for opening and managing audio devices."""
+
+    def __init__(
+        self,
+        backend: MediaBackend = MediaBackend.DEFAULT,
+        log_level: str = "INFO",
+        use_sim: bool = False,
+        signalling_host: str = "localhost",
+    ) -> None:
+        """Initialize the audio device."""
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(log_level)
+        self.backend = backend
+        self.camera: Optional[CameraBase] = None
+        self.audio: Optional[AudioBase] = None
+
+        match backend:
+            case MediaBackend.NO_MEDIA:
+                self.logger.info("No media backend selected.")
+            case MediaBackend.DEFAULT:
+                self.logger.info("Using default media backend (OpenCV + SoundDevice).")
+                self._init_camera(use_sim, log_level)
+                self._init_audio(log_level)
+            case MediaBackend.DEFAULT_NO_VIDEO:
+                self.logger.info("Using default media backend (SoundDevice only).")
+                self._init_audio(log_level)
+            case MediaBackend.GSTREAMER:
+                self.logger.info("Using GStreamer media backend.")
+                self._init_camera(use_sim, log_level)
+                self._init_audio(log_level)
+            case MediaBackend.GSTREAMER_NO_VIDEO:
+                self.logger.info("Using GStreamer audio backend.")
+                self._init_audio(log_level)
+            case MediaBackend.WEBRTC:
+                self.logger.info("Using WebRTC GStreamer backend.")
+                self._init_webrtc(log_level, signalling_host, 8443)
+                # self._init_audio(log_level)
+            case _:
+                raise NotImplementedError(f"Media backend {backend} not implemented.")
+
+    def close(self) -> None:
+        """Close the media manager and release resources."""
+        if self.camera is not None:
+            self.camera.close()
+        if self.audio is not None:
+            self.audio.stop_recording()
+            self.audio.stop_playing()
+
+    def __del__(self) -> None:
+        """Destructor to ensure resources are released."""
+        self.close()
+
+    def _init_camera(
+        self,
+        use_sim: bool,
+        log_level: str,
+    ) -> None:
+        """Initialize the camera."""
+        self.logger.debug("Initializing camera...")
+        if self.backend == MediaBackend.DEFAULT:
+            self.logger.info("Using OpenCV camera backend.")
+            from reachy_mini.media.camera_opencv import OpenCVCamera
+
+            self.camera = OpenCVCamera(log_level=log_level)
+            if use_sim:
+                self.camera.open(udp_camera="udp://@127.0.0.1:5005")
+            else:
+                self.camera.open()
+        elif self.backend == MediaBackend.GSTREAMER:
+            self.logger.info("Using GStreamer camera backend.")
+            from reachy_mini.media.camera_gstreamer import GStreamerCamera
+
+            self.camera = GStreamerCamera(log_level=log_level)
+            self.camera.open()
+            # Todo: use simulation with gstreamer?
+
+        else:
+            raise NotImplementedError(f"Camera backend {self.backend} not implemented.")
+
+    def get_frame(self) -> Optional[npt.NDArray[np.uint8]]:
+        """Get a frame from the camera.
+
+        Returns:
+            Optional[npt.NDArray[np.uint8]]: The captured BGR frame, or None if the camera is not available.
+
+        """
+        if self.camera is None:
+            self.logger.warning("Camera is not initialized.")
+            return None
+        return self.camera.read()
+
+    def _init_audio(self, log_level: str) -> None:
+        """Initialize the audio system."""
+        self.logger.debug("Initializing audio...")
+        if (
+            self.backend == MediaBackend.DEFAULT
+            or self.backend == MediaBackend.DEFAULT_NO_VIDEO
+        ):
+            self.logger.info("Using SoundDevice audio backend.")
+            from reachy_mini.media.audio_sounddevice import SoundDeviceAudio
+
+            self.audio = SoundDeviceAudio(log_level=log_level)
+        elif (
+            self.backend == MediaBackend.GSTREAMER
+            or self.backend == MediaBackend.GSTREAMER_NO_VIDEO
+        ):
+            self.logger.info("Using GStreamer audio backend.")
+            from reachy_mini.media.audio_gstreamer import GStreamerAudio
+
+            self.audio = GStreamerAudio(log_level=log_level)
+        else:
+            raise NotImplementedError(f"Audio backend {self.backend} not implemented.")
+
+    def _init_webrtc(
+        self, log_level: str, signalling_host: str, signalling_port: int
+    ) -> None:
+        """Initialize the WebRTC system (not implemented yet)."""
+        from gst_signalling.utils import find_producer_peer_id_by_name
+
+        from reachy_mini.media.webrtc_client_gstreamer import GstWebRTCClient
+
+        peer_id = find_producer_peer_id_by_name(
+            signalling_host, signalling_port, "reachymini"
+        )
+
+        webrtc_media: GstWebRTCClient = GstWebRTCClient(
+            log_level=log_level,
+            peer_id=peer_id,
+            signaling_host=signalling_host,
+            signaling_port=signalling_port,
+        )
+
+        self.camera = webrtc_media
+        self.audio = webrtc_media  # GstWebRTCClient handles both audio and video
+        self.camera.open()
+
+    def play_sound(self, sound_file: str) -> None:
+        """Play a sound file.
+
+        Args:
+            sound_file (str): Path to the sound file to play.
+
+        """
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return
+        self.audio.play_sound(sound_file)
+
+    def start_recording(self) -> None:
+        """Start recording audio."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return
+        self.audio.start_recording()
+
+    def get_audio_sample(self) -> Optional[bytes | npt.NDArray[np.float32]]:
+        """Get an audio sample from the audio device.
+
+        Returns:
+            Optional[np.ndarray]: The recorded audio sample, or None if no data is available.
+
+        """
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return None
+        return self.audio.get_audio_sample()
+
+    def get_input_audio_samplerate(self) -> int:
+        """Get the input samplerate of the audio device."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return -1
+        return self.audio.get_input_audio_samplerate()
+
+    def get_output_audio_samplerate(self) -> int:
+        """Get the output samplerate of the audio device."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return -1
+        return self.audio.get_output_audio_samplerate()
+
+    def get_input_channels(self) -> int:
+        """Get the number of input channels of the audio device."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return -1
+        return self.audio.get_input_channels()
+
+    def get_output_channels(self) -> int:
+        """Get the number of output channels of the audio device."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return -1
+        return self.audio.get_output_channels()
+
+    def stop_recording(self) -> None:
+        """Stop recording audio."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return
+        self.audio.stop_recording()
+
+    def start_playing(self) -> None:
+        """Start playing audio."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return
+        self.audio.start_playing()
+
+    def push_audio_sample(self, data: npt.NDArray[np.float32]) -> None:
+        """Push audio data to the output device.
+
+        Args:
+            data (npt.NDArray[np.float32]): The audio data to push to the output device (mono format).
+
+        """
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return
+
+        if data.ndim > 2 or data.ndim == 0:
+            self.logger.warning(
+                f"Audio samples arrays must have at most 2 dimensions and at least 1 dimension, got {data.ndim}"
+            )
+            return
+
+        # Transpose data to match sounddevice channels last convention
+        if data.ndim == 2 and data.shape[1] > data.shape[0]:
+            data = data.T
+
+        # Fit data to match output stream channels
+        output_channels = self.get_output_channels()
+
+        # Mono input to multiple channels output : duplicate to fit
+        if data.ndim == 1 and output_channels > 1:
+            data = np.column_stack((data,) * output_channels)
+        # Lower channels input to higher channels output : reduce to mono and duplicate to fit
+        elif data.ndim == 2 and data.shape[1] < output_channels:
+            data = np.column_stack((data[:, 0],) * output_channels)
+        # Higher channels input to lower channels output : crop to fit
+        elif data.ndim == 2 and data.shape[1] > output_channels:
+            data = data[:, :output_channels]
+
+        self.audio.push_audio_sample(data)
+
+    def stop_playing(self) -> None:
+        """Stop playing audio."""
+        if self.audio is None:
+            self.logger.warning("Audio system is not initialized.")
+            return
+        self.audio.stop_playing()

reachy_mini/media/webrtc_client_gstreamer.py

@@ -0,0 +1,288 @@
+"""GStreamer WebRTC client implementation.
+
+The class is a client for the webrtc server hosted on the Reachy Mini Wireless robot.
+"""
+
+from threading import Thread
+from typing import Optional, cast
+
+import gi
+import numpy as np
+import numpy.typing as npt
+
+from reachy_mini.media.audio_base import AudioBase
+from reachy_mini.media.camera_base import CameraBase
+from reachy_mini.media.camera_constants import (
+    CameraResolution,
+    CameraSpecs,
+    ReachyMiniWirelessCamSpecs,
+)
+
+gi.require_version("Gst", "1.0")
+gi.require_version("GstApp", "1.0")
+from gi.repository import GLib, Gst, GstApp  # noqa: E402, F401
+
+
+class GstWebRTCClient(CameraBase, AudioBase):
+    """GStreamer WebRTC client implementation."""
+
+    def __init__(
+        self,
+        log_level: str = "INFO",
+        peer_id: str = "",
+        signaling_host: str = "",
+        signaling_port: int = 8443,
+    ):
+        """Initialize the GStreamer WebRTC client."""
+        super().__init__(log_level=log_level)
+        Gst.init(None)
+        self._loop = GLib.MainLoop()
+        self._thread_bus_calls = Thread(target=lambda: self._loop.run(), daemon=True)
+        self._thread_bus_calls.start()
+
+        self._pipeline_record = Gst.Pipeline.new("audio_recorder")
+        self._bus_record = self._pipeline_record.get_bus()
+        self._bus_record.add_watch(
+            GLib.PRIORITY_DEFAULT, self._on_bus_message, self._loop
+        )
+
+        self._appsink_audio = Gst.ElementFactory.make("appsink")
+        caps = Gst.Caps.from_string(
+            f"audio/x-raw,rate={self.SAMPLE_RATE},channels={self.CHANNELS},format=F32LE,layout=interleaved"
+        )
+        self._appsink_audio.set_property("caps", caps)
+        self._appsink_audio.set_property("drop", True)  # avoid overflow
+        self._appsink_audio.set_property("max-buffers", 500)
+        self._pipeline_record.add(self._appsink_audio)
+
+        self.camera_specs = cast(CameraSpecs, ReachyMiniWirelessCamSpecs)
+        self.set_resolution(CameraResolution.R1920x1080at30fps)
+
+        self._appsink_video = Gst.ElementFactory.make("appsink")
+        caps_video = Gst.Caps.from_string("video/x-raw,format=BGR")
+        self._appsink_video.set_property("caps", caps_video)
+        self._appsink_video.set_property("drop", True)  # avoid overflow
+        self._appsink_video.set_property("max-buffers", 1)  # keep last image only
+        self._pipeline_record.add(self._appsink_video)
+
+        webrtcsrc = self._configure_webrtcsrc(signaling_host, signaling_port, peer_id)
+        self._pipeline_record.add(webrtcsrc)
+
+        self._pipeline_playback = Gst.Pipeline.new("audio_player")
+        self._init_pipeline_playback(
+            self._pipeline_playback, signaling_host, signaling_port
+        )
+        self._bus_playback = self._pipeline_playback.get_bus()
+        self._bus_playback.add_watch(
+            GLib.PRIORITY_DEFAULT, self._on_bus_message, self._loop
+        )
+
+    def __del__(self) -> None:
+        """Destructor to ensure gstreamer resources are released."""
+        super().__del__()
+        self._loop.quit()
+        self._bus_record.remove_watch()
+        self._bus_playback.remove_watch()
+
+    def set_resolution(self, resolution: CameraResolution) -> None:
+        """Set the camera resolution."""
+        super().set_resolution(resolution)
+        self._resolution = resolution
+
+    def _configure_webrtcsrc(
+        self, signaling_host: str, signaling_port: int, peer_id: str
+    ) -> Gst.Element:
+        source = Gst.ElementFactory.make("webrtcsrc")
+        if not source:
+            raise RuntimeError(
+                "Failed to create webrtcsrc element. Is the GStreamer webrtc rust plugin installed?"
+            )
+
+        source.connect("pad-added", self._webrtcsrc_pad_added_cb)
+        signaller = source.get_property("signaller")
+        signaller.set_property("producer-peer-id", peer_id)
+        signaller.set_property("uri", f"ws://{signaling_host}:{signaling_port}")
+        return source
+
+    def _configure_webrtcbin(self, webrtcsrc: Gst.Element) -> None:
+        if isinstance(webrtcsrc, Gst.Bin):
+            webrtcbin_name = "webrtcbin0"
+            webrtcbin = webrtcsrc.get_by_name(webrtcbin_name)
+            assert webrtcbin is not None
+            # jitterbuffer has a default 200 ms buffer. Should be ok to lower this in localnetwork config
+            webrtcbin.set_property("latency", 100)
+
+    def _webrtcsrc_pad_added_cb(self, webrtcsrc: Gst.Element, pad: Gst.Pad) -> None:
+        self._configure_webrtcbin(webrtcsrc)
+        if pad.get_name().startswith("video"):
+            queue = Gst.ElementFactory.make("queue")
+
+            videoconvert = Gst.ElementFactory.make("videoconvert")
+            videoscale = Gst.ElementFactory.make("videoscale")
+            videorate = Gst.ElementFactory.make("videorate")
+
+            self._pipeline_record.add(queue)
+            self._pipeline_record.add(videoconvert)
+            self._pipeline_record.add(videoscale)
+            self._pipeline_record.add(videorate)
+            pad.link(queue.get_static_pad("sink"))
+
+            queue.link(videoconvert)
+            videoconvert.link(videoscale)
+            videoscale.link(videorate)
+            videorate.link(self._appsink_video)
+
+            queue.sync_state_with_parent()
+            videoconvert.sync_state_with_parent()
+            videoscale.sync_state_with_parent()
+            videorate.sync_state_with_parent()
+            self._appsink_video.sync_state_with_parent()
+
+        elif pad.get_name().startswith("audio"):
+            audioconvert = Gst.ElementFactory.make("audioconvert")
+            audioresample = Gst.ElementFactory.make("audioresample")
+            self._pipeline_record.add(audioconvert)
+            self._pipeline_record.add(audioresample)
+
+            pad.link(audioconvert.get_static_pad("sink"))
+            audioconvert.link(audioresample)
+            audioresample.link(self._appsink_audio)
+
+            self._appsink_audio.sync_state_with_parent()
+            audioconvert.sync_state_with_parent()
+            audioresample.sync_state_with_parent()
+
+    def _on_bus_message(self, bus: Gst.Bus, msg: Gst.Message, loop) -> bool:  # type: ignore[no-untyped-def]
+        t = msg.type
+        if t == Gst.MessageType.EOS:
+            self.logger.warning("End-of-stream")
+            return False
+
+        elif t == Gst.MessageType.ERROR:
+            err, debug = msg.parse_error()
+            self.logger.error(f"Error: {err} {debug}")
+            return False
+
+        return True
+
+    def open(self) -> None:
+        """Open the video stream."""
+        self._pipeline_record.set_state(Gst.State.PLAYING)
+
+    def _get_sample(self, appsink: GstApp.AppSink) -> Optional[bytes]:
+        sample = appsink.try_pull_sample(20_000_000)
+        if sample is None:
+            return None
+        data = None
+        if isinstance(sample, Gst.Sample):
+            buf = sample.get_buffer()
+            if buf is None:
+                self.logger.warning("Buffer is None")
+
+            data = buf.extract_dup(0, buf.get_size())
+        return data
+
+    def get_audio_sample(self) -> Optional[npt.NDArray[np.float32]]:
+        """Read a sample from the audio card. Returns the sample or None if error.
+
+        Returns:
+            Optional[npt.NDArray[np.float32]]: The captured sample in raw format, or None if error.
+
+        """
+        sample = self._get_sample(self._appsink_audio)
+        if sample is None:
+            return None
+        return np.frombuffer(sample, dtype=np.float32).reshape(-1, 2)
+
+    def read(self) -> Optional[npt.NDArray[np.uint8]]:
+        """Read a frame from the camera. Returns the frame or None if error.
+
+        Returns:
+            Optional[npt.NDArray[np.uint8]]: The captured frame in BGR format, or None if error.
+
+        """
+        data = self._get_sample(self._appsink_video)
+        if data is None:
+            return None
+
+        arr = np.frombuffer(data, dtype=np.uint8).reshape(
+            (self.resolution[1], self.resolution[0], 3)
+        )
+        return arr
+
+    def close(self) -> None:
+        """Stop the pipeline."""
+        # self._loop.quit()
+        self._pipeline_record.set_state(Gst.State.NULL)
+
+    def start_recording(self) -> None:
+        """Open the audio card using GStreamer."""
+        pass  # already started in open()
+
+    def stop_recording(self) -> None:
+        """Release the camera resource."""
+        pass  # managed in close()
+
+    def _init_pipeline_playback(
+        self, pipeline: Gst.Pipeline, signaling_host: str, signaling_port: int
+    ) -> None:
+        """Initialize the audio playback pipeline."""
+        self._appsrc = Gst.ElementFactory.make("appsrc")
+        self._appsrc.set_property("format", Gst.Format.TIME)
+        self._appsrc.set_property("is-live", True)
+        caps = Gst.Caps.from_string(
+            f"audio/x-raw,format=F32LE,channels={self.CHANNELS},rate={self.SAMPLE_RATE},layout=interleaved"
+        )
+        self._appsrc.set_property("caps", caps)
+        audioconvert = Gst.ElementFactory.make("audioconvert")
+        audioresample = Gst.ElementFactory.make("audioresample")
+        opusenc = Gst.ElementFactory.make("opusenc")
+        queue = Gst.ElementFactory.make("queue")
+        rtpopuspay = Gst.ElementFactory.make("rtpopuspay")
+        udpsink = Gst.ElementFactory.make("udpsink")
+
+        udpsink.set_property("host", signaling_host)
+        udpsink.set_property("port", 5000)
+
+        pipeline.add(self._appsrc)
+        pipeline.add(audioconvert)
+        pipeline.add(audioresample)
+        pipeline.add(opusenc)
+        pipeline.add(queue)
+        pipeline.add(rtpopuspay)
+        pipeline.add(udpsink)
+
+        self._appsrc.link(audioconvert)
+        audioconvert.link(audioresample)
+        audioresample.link(opusenc)
+        opusenc.link(queue)
+        queue.link(rtpopuspay)
+        rtpopuspay.link(udpsink)
+
+    def start_playing(self) -> None:
+        """Open the audio output using GStreamer."""
+        self._pipeline_playback.set_state(Gst.State.PLAYING)
+
+    def stop_playing(self) -> None:
+        """Stop playing audio and release resources."""
+        self._pipeline_playback.set_state(Gst.State.NULL)
+
+    def push_audio_sample(self, data: npt.NDArray[np.float32]) -> None:
+        """Push audio data to the output device."""
+        if self._appsrc is not None:
+            buf = Gst.Buffer.new_wrapped(data.tobytes())
+            self._appsrc.push_buffer(buf)
+
+        else:
+            self.logger.warning(
+                "AppSrc is not initialized. Call start_playing() first."
+            )
+
+    def play_sound(self, sound_file: str) -> None:
+        """Play a sound file.
+
+        Args:
+            sound_file (str): Path to the sound file to play.
+
+        """
+        self.logger.warning("Audio playback not implemented in WebRTC client.")