feat: room options & audio resampler (#17)

Author: theomonnom

examples/basic_room.py

@@ -34,12 +34,12 @@ def on_local_track_unpublished(publication: livekit.LocalTrackPublication):
         logging.info("local track unpublished: %s", publication.sid)
 
     @room.listens_to("track_published")
-    def on_track_published(publication: livekit.LocalTrackPublication, participant: livekit.RemoteParticipant):
+    def on_track_published(publication: livekit.RemoteTrackPublication, participant: livekit.RemoteParticipant):
         logging.info("track published: %s from participant %s (%s)",
                      publication.sid, participant.sid, participant.identity)
 
     @room.listens_to("track_unpublished")
-    def on_track_unpublished(publication: livekit.LocalTrackPublication, participant: livekit.RemoteParticipant):
+    def on_track_unpublished(publication: livekit.RemoteTrackPublication, participant: livekit.RemoteParticipant):
         logging.info("track unpublished: %s", publication.sid)
 
     # Keep a reference to the streams, otherwise they will be disposed

livekit/__init__.py

@@ -14,7 +14,7 @@
 from .audio_source import AudioSource
 from .audio_stream import AudioStream
 from .participant import LocalParticipant, Participant, RemoteParticipant
-from .room import ConnectError, Room
+from .room import ConnectError, Room, RoomOptions
 from .track import (
     LocalAudioTrack,
     LocalVideoTrack,

livekit/audio_frame.py

@@ -1,12 +1,12 @@
 import ctypes
 
 from ._ffi_client import FfiHandle, ffi_client
-from ._proto import audio_frame_pb2 as proto_audio_frame
+from ._proto import audio_frame_pb2 as proto_audio
 from ._proto import ffi_pb2 as proto_ffi
 
 
 class AudioFrame():
-    def __init__(self, info: proto_audio_frame.AudioFrameBufferInfo, ffi_handle: FfiHandle) -> None:
+    def __init__(self, info: proto_audio.AudioFrameBufferInfo, ffi_handle: FfiHandle) -> None:
         self._info = info
         self._ffi_handle = ffi_handle
 
@@ -29,6 +29,27 @@ def create(sample_rate: int, num_channels: int, samples_per_channel: int) -> 'Au
 
         return AudioFrame(info, ffi_handle)
 
+    def remix_and_resample(self, sample_rate: int, num_channels: int) -> 'AudioFrame':
+        """ Resample the audio frame to the given sample rate and number of channels."""
+
+        req = proto_ffi.FfiRequest()
+        req.new_audio_resampler.CopyFrom(
+            proto_audio.NewAudioResamplerRequest())
+
+        resp = ffi_client.request(req)
+        resampler_handle = FfiHandle(resp.new_audio_resampler.handle.id)
+
+        resample_req = proto_ffi.FfiRequest()
+        resample_req.remix_and_resample.resampler_handle.id = resampler_handle.handle
+        resample_req.remix_and_resample.buffer_handle.id = self._ffi_handle.handle
+        resample_req.remix_and_resample.sample_rate = sample_rate
+        resample_req.remix_and_resample.num_channels = num_channels
+
+        resp = ffi_client.request(resample_req)
+        info = resp.remix_and_resample.buffer
+        ffi_handle = FfiHandle(info.handle.id)
+        return AudioFrame(info, ffi_handle)
+
     @property
     def sample_rate(self) -> int:
         return self._info.sample_rate

livekit/participant.py

@@ -22,17 +22,17 @@
 
 
 class PublishTrackError(Exception):
-    def __init__(self, message: str):
+    def __init__(self, message: str) -> None:
         self.message = message
 
 
 class PublishDataError(Exception):
-    def __init__(self, message: str):
+    def __init__(self, message: str) -> None:
         self.message = message
 
 
 class Participant():
-    def __init__(self, info: proto_participant.ParticipantInfo):
+    def __init__(self, info: proto_participant.ParticipantInfo) -> None:
         self._info = info
         self.tracks: dict[str, TrackPublication] = {}
 
@@ -54,7 +54,7 @@ def metadata(self) -> str:
 
 
 class LocalParticipant(Participant):
-    def __init__(self, info: proto_participant.ParticipantInfo, room: weakref.ref['Room']):
+    def __init__(self, info: proto_participant.ParticipantInfo, room: weakref.ref['Room']) -> None:
         super().__init__(info)
         self._room = room
         self.tracks: dict[str, LocalTrackPublication] = {}
@@ -75,8 +75,6 @@ async def publish_data(self,
 
         cdata = (ctypes.c_byte * data_len)(*payload)
 
-
-
         req = proto_ffi.FfiRequest()
         req.publish_data.room_handle.id = room._ffi_handle.handle
         req.publish_data.data_ptr = ctypes.addressof(cdata)
@@ -146,6 +144,6 @@ def on_publish_callback(cb: proto_room.PublishTrackCallback):
 
 
 class RemoteParticipant(Participant):
-    def __init__(self, info: proto_participant.ParticipantInfo):
+    def __init__(self, info: proto_participant.ParticipantInfo) -> None:
         super().__init__(info)
         self.tracks: dict[str, RemoteTrackPublication] = {}

livekit/room.py

@@ -1,6 +1,7 @@
 import asyncio
 import ctypes
 import weakref
+from dataclasses import dataclass
 
 from pyee.asyncio import AsyncIOEventEmitter
 
@@ -16,6 +17,12 @@
 from .track_publication import LocalTrackPublication, RemoteTrackPublication
 
 
+@dataclass
+class RoomOptions:
+    auto_subscribe: bool = True
+    dynacast: bool = True
+
+
 class ConnectError(Exception):
     def __init__(self, message: str):
         self.message = message
@@ -47,14 +54,18 @@ def metadata(self) -> str:
     def isconnected(self) -> bool:
         return self._ffi_handle is not None and self.connection_state == ConnectionState.CONN_CONNECTED
 
-    async def connect(self, url: str, token: str) -> None:
+    async def connect(self, url: str, token: str, options: RoomOptions = RoomOptions()) -> None:
         # TODO(theomonnom): We should be more flexible about the event loop
         ffi_client.set_event_loop(asyncio.get_running_loop())
 
         req = proto_ffi.FfiRequest()
         req.connect.url = url
         req.connect.token = token
 
+        # options
+        req.connect.options.auto_subscribe = options.auto_subscribe
+        req.connect.options.dynacast = options.dynacast
+
         resp = ffi_client.request(req)
         future: asyncio.Future[proto_room.ConnectCallback] = asyncio.Future()
 
@@ -127,12 +138,14 @@ def _on_room_event(self, event: proto_room.RoomEvent):
 
             if track_info.kind == TrackKind.KIND_VIDEO:
                 local_video_track = LocalVideoTrack(ffi_handle, track_info)
-                publication.track = local_video_track 
-                self.emit('local_track_published', publication, local_video_track)
+                publication.track = local_video_track
+                self.emit('local_track_published',
+                          publication, local_video_track)
             elif track_info.kind == TrackKind.KIND_AUDIO:
                 local_audio_track = LocalAudioTrack(ffi_handle, track_info)
                 publication.track = local_audio_track
-                self.emit('local_track_published', publication, local_audio_track)
+                self.emit('local_track_published',
+                          publication, local_audio_track)
         elif which == 'local_track_unpublished':
             publication = self.local_participant.tracks.pop(
                 event.local_track_unpublished.publication_sid)