publish sine wave example

Author: theomonnom

examples/publish_wave/room.py

@@ -0,0 +1,84 @@
+import livekit
+import logging
+import numpy as np
+import math
+import asyncio
+from signal import SIGINT, SIGTERM
+
+URL = 'ws://localhost:7880'
+TOKEN = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE5MDY2MTMyODgsImlzcyI6IkFQSVRzRWZpZFpqclFvWSIsIm5hbWUiOiJuYXRpdmUiLCJuYmYiOjE2NzI2MTMyODgsInN1YiI6Im5hdGl2ZSIsInZpZGVvIjp7InJvb20iOiJ0ZXN0Iiwicm9vbUFkbWluIjp0cnVlLCJyb29tQ3JlYXRlIjp0cnVlLCJyb29tSm9pbiI6dHJ1ZSwicm9vbUxpc3QiOnRydWV9fQ.uSNIangMRu8jZD5mnRYoCHjcsQWCrJXgHCs0aNIgBFY'
+
+
+async def publish_frames(source: livekit.AudioSource):
+    sample_rate = 48000
+    frequency = 440
+    amplitude = 32767  # for 16-bit audio
+    num_channels = 1
+    samples_per_channel = 480  # 10ms at 48kHz
+    time = np.arange(samples_per_channel) / sample_rate
+    total_samples = 0
+
+    audio_frame = livekit.AudioFrame.create(
+        sample_rate, num_channels, samples_per_channel)
+
+    audio_data = np.ctypeslib.as_array(audio_frame.data)
+
+    while True:
+        time = (total_samples + np.arange(samples_per_channel)) / sample_rate
+
+        sine_wave = (amplitude * np.sin(2 * np.pi *
+                     frequency * time)).astype(np.int16)
+        np.copyto(audio_data, sine_wave)
+
+        source.capture_frame(audio_frame)
+
+        total_samples += samples_per_channel
+
+        try:
+            await asyncio.sleep(1 / 100)  # 10m
+        except asyncio.CancelledError:
+            break
+
+
+async def main():
+    room = livekit.Room()
+
+    logging.info("connecting to %s", URL)
+    try:
+        await room.connect(URL, TOKEN)
+        logging.info("connected to room %s", room.name)
+    except livekit.ConnectError as e:
+        logging.error("failed to connect to the room: %s", e)
+        return False
+
+    # publish a track
+    source = livekit.AudioSource()
+    source_task = asyncio.create_task(publish_frames(source))
+
+    track = livekit.LocalAudioTrack.create_audio_track("sinewave", source)
+    options = livekit.TrackPublishOptions()
+    options.source = livekit.TrackSource.SOURCE_MICROPHONE
+    publication = await room.local_participant.publish_track(track, options)
+    logging.info("published track %s", publication.sid)
+
+    try:
+        await room.run()
+    except asyncio.CancelledError:
+        logging.info("closing the room")
+        source_task.cancel()
+        await source_task
+        await room.close()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, handlers=[
+                        logging.FileHandler("publish_wave.log"), logging.StreamHandler()])
+
+    loop = asyncio.get_event_loop()
+    main_task = asyncio.ensure_future(main())
+    for signal in [SIGINT, SIGTERM]:
+        loop.add_signal_handler(signal, main_task.cancel)
+    try:
+        loop.run_until_complete(main_task)
+    finally:
+        loop.close()

livekit/audio_frame.py

@@ -1,14 +1,42 @@
 import ctypes
+from ._ffi_client import (FfiClient, FfiHandle)
+from ._proto import ffi_pb2 as proto_ffi
+from ._proto import audio_frame_pb2 as proto_audio_frame
 
 
 class AudioFrame():
-    def __init__(self, sample_rate: int, num_channels: int, samples_per_channel: int, data=None, ffi_handle=None):
+    def __init__(self, info: proto_audio_frame.AudioFrameBufferInfo, ffi_handle: FfiHandle):
+        self._info = info
         self._ffi_handle = ffi_handle
-        self.sample_rate = sample_rate
-        self.num_channels = num_channels
-        self.samples_per_channel = samples_per_channel
-        if data is None:
-            self.data = (ctypes.c_int16 *
-                         (num_channels * samples_per_channel))()
-        else:
-            self.data = data
+
+        data_len = self.num_channels * self.samples_per_channel
+        self.data = ctypes.cast(info.data_ptr,
+                                ctypes.POINTER(ctypes.c_int16 * data_len)).contents
+
+    @staticmethod
+    def create(sample_rate: int, num_channels: int, samples_per_channel: int):
+        # TODO(theomonnom): There should be no problem to directly send audio date from a Python created ctypes buffer
+        req = proto_ffi.FfiRequest()
+        req.alloc_audio_buffer.sample_rate = sample_rate
+        req.alloc_audio_buffer.num_channels = num_channels
+        req.alloc_audio_buffer.samples_per_channel = samples_per_channel
+
+        ffi_client = FfiClient()
+        resp = ffi_client.request(req)
+
+        info = resp.alloc_audio_buffer.buffer
+        ffi_handle = FfiHandle(info.handle.id)
+
+        return AudioFrame(info, ffi_handle)
+
+    @property
+    def sample_rate(self) -> int:
+        return self._info.sample_rate
+
+    @property
+    def num_channels(self) -> int:
+        return self._info.num_channels
+
+    @property
+    def samples_per_channel(self) -> int:
+        return self._info.samples_per_channel

livekit/audio_source.py

@@ -1,5 +1,24 @@
+from ._ffi_client import (FfiClient, FfiHandle)
+from ._proto import ffi_pb2 as proto_ffi
+from ._proto import audio_frame_pb2 as proto_audio_frame
+from livekit import (AudioFrame)
 
 
-class AudioSource():
+class AudioSource:
     def __init__(self):
-        pass
+        req = proto_ffi.FfiRequest()
+        req.new_audio_source.type = proto_audio_frame.AudioSourceType.AUDIO_SOURCE_NATIVE
+
+        ffi_client = FfiClient()
+        resp = ffi_client.request(req)
+        self._info = resp.new_audio_source.source
+        self._ffi_handle = FfiHandle(self._info.handle.id)
+
+    def capture_frame(self, frame: AudioFrame):
+        req = proto_ffi.FfiRequest()
+
+        req.capture_audio_frame.source_handle.id = self._ffi_handle.handle
+        req.capture_audio_frame.buffer_handle.id = frame._ffi_handle.handle
+
+        ffi_client = FfiClient()
+        ffi_client.request(req)

livekit/audio_stream.py

@@ -37,11 +37,7 @@ def _on_audio_stream_event(cls, event: proto_audio_frame.AudioStreamEvent):
         if which == 'frame_received':
             frame_info = event.frame_received.frame
             ffi_handle = FfiHandle(frame_info.handle.id)
-            data_len = frame_info.num_channels * frame_info.samples_per_channel
-            data = ctypes.cast(frame_info.data_ptr,
-                               ctypes.POINTER(ctypes.c_uint16 * data_len)).contents
-            frame = AudioFrame(
-                frame_info.sample_rate, frame_info.num_channels, frame_info.samples_per_channel, data, ffi_handle)
+            frame = AudioFrame(frame_info, ffi_handle)
             stream._on_frame_received(frame)
 
     def __init__(self, track: Track):

livekit/track.py

@@ -4,7 +4,7 @@
 from typing import (Optional, TYPE_CHECKING)
 
 if TYPE_CHECKING:
-    from livekit import (VideoSource)
+    from livekit import (VideoSource, AudioSource)
 
 
 class Track():
@@ -40,6 +40,17 @@ class LocalAudioTrack(Track):
     def __init__(self, ffi_handle: FfiHandle, info: proto_track.TrackInfo):
         super().__init__(ffi_handle, info)
 
+    def create_audio_track(name: str, source: 'AudioSource') -> 'LocalAudioTrack':
+        req = proto_ffi.FfiRequest()
+        req.create_audio_track.name = name
+        req.create_audio_track.source_handle.id = source._ffi_handle.handle
+
+        ffi_client = FfiClient()
+        resp = ffi_client.request(req)
+        track_info = resp.create_audio_track.track
+        ffi_handle = FfiHandle(track_info.handle.id)
+        return LocalAudioTrack(ffi_handle, track_info)
+
 
 class LocalVideoTrack(Track):
     def __init__(self, ffi_handle: FfiHandle, info: proto_track.TrackInfo):