Initial Checkin

Samples for delaying audio by a few seconds and showing an image

Author: alitair

README.md

@@ -1,2 +1,26 @@
-# bc-python
-Python api
+# Project Name
+bc-python
+
+This project requires Python 3.12 and specific dependencies listed in `requirements.txt`. Follow the instructions below to set up your development environment using Conda.
+
+## Prerequisites
+
+- [Anaconda](https://www.anaconda.com/products/distribution#download-section) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html) should be installed on your system.
+
+## Setting Up the Environment
+
+1. **Create a New Conda Environment**
+
+   Open your terminal or command prompt and create a new Conda environment with Python 3.12:
+
+   ```bash
+   conda create --name birdconv python=3.12
+
+
+2. **Activate birdconv
+   ```bash
+   conda activate birdconv
+
+3. **Install requirements
+   ```bash
+   pip install -r requirements.txt

bird.png

@@ -0,0 +1,70 @@
+import requests
+import json
+
+
+# Grab your uid from the python section of https://birdcallauth.web.app
+api_request = {"uid": "API KEY HERE"} 
+host        = "https://birdcallauth.web.app"
+
+# if you are running the birdconv server locally, use this instead
+# host        = "http://localhost:5173"
+
+active_path = '/api/active'
+room_path   = '/api/room'
+token_path  = '/api/token_monitor'
+headers     = {'Content-Type': 'application/json'}
+
+
+# choose printIt=True to see the request and response from the api
+def send_request( path, api_request, printit=True) :
+
+    if printit:
+        print("Request to " + path)
+        print(json.dumps(api_request, indent=4))
+
+    response = requests.post( host + path, headers=headers, json=api_request)
+    if response.ok:
+        res = response.json()
+    else:
+        print(f"Error: {response.status_code}, {response.text}")
+
+    if printit:
+        print("Response:")
+        print(json.dumps(res, indent=4))
+    return res
+
+# Get a list of active devices in birdconv
+def active():
+    return send_request(active_path, api_request, printit=False)
+
+# create a room with a subset of the active devices
+def create_room( devices , recording=False, expiryTime=1):
+    roomRequest = {
+        "devices"    : devices, # A subset of the array of devices returned by the /active endpoint
+        "audioOnly"  : False, # this value is ignored, 
+        "recording"  : recording, # set to True to record
+        "expiryTime" : expiryTime*60,    # how long the call will be active, 1 min * 60 sec
+    }
+    roomRequest.update(api_request)
+
+    return send_request(room_path, roomRequest, printit=False)
+
+# get a token for this program to join a room
+def create_token( room  , username):
+
+    device = {
+        "username"   : username,  # here is your python program's name
+        "species"    : "computer",  # use computer
+        "deviceId"   : "",  # !! leave blank !!
+        "fcm_token"  : "",  # !! leave blank !!
+    }
+    device.update(api_request)
+
+    token_request = {
+        "device" : device,
+        "eavesdrop" : False # this way you are allowed to send video and audio!
+    }
+    token_request.update(room)
+    token_request.update(api_request)
+
+    return send_request(token_path, token_request, printit=False)

birdconv.py

@@ -0,0 +1,158 @@
+import threading
+import queue
+import time
+import birdconv
+from   daily import *
+
+
+BUFFER  = 2 # 2 second of buffering
+
+SAMPLE_RATE = 16000
+NUM_CHANNELS = 1
+BYTES_PER_SAMPLE =2
+
+
+class AudioApp:
+    def __init__(self, sample_rate, num_channels):
+
+        self._sample_rate  = sample_rate
+        self._num_channels = num_channels
+        self._client = CallClient()
+        self._client.update_subscription_profiles({
+            "base": {
+                "camera": "unsubscribed",
+                "microphone": "subscribed"
+            }
+        })
+
+        self._mic_device     = Daily.create_microphone_device("my-mic" ,sample_rate=sample_rate,channels=num_channels)
+        self._speaker_device = Daily.create_speaker_device("my-speaker",sample_rate=sample_rate,channels=num_channels)
+        Daily.select_speaker_device("my-speaker")
+
+        self.client_settings = {
+            "inputs": {
+                "camera": False,
+                "microphone": {
+                    "isEnabled": True,
+                    "settings": {
+                        "deviceId": "my-mic"
+                    }
+                }
+            }
+        }
+
+        self._app_quit = False
+        self._app_error = None
+
+        self._buffer_queue = queue.Queue()
+
+        self._start_receive_event = threading.Event()
+        self._thread_receive      = threading.Thread(target=self.receive_audio)
+        self._thread_receive.start()
+
+        self._start_send_event = threading.Event()
+        self._thread_send       = threading.Thread(target=self.send_audio)
+        self._thread_send.start()
+
+
+    def on_joined(self, data, error):
+        if error:
+            print(f"Unable to join meeting: {error}")
+            self._app_error = error
+        self._start_receive_event.set()
+        self._start_send_event.set()
+
+    def run(self, meeting):
+        meeting_url  = meeting["url"]
+        meeting_token = meeting["token"]
+        self._client.join(meeting_url, meeting_token=meeting_token, client_settings=self.client_settings, completion=self.on_joined)
+
+        # wait until both threads terrminate 
+        self._thread_receive.join()
+        self._thread_send.join()
+
+    def leave(self):
+        self._app_quit = True
+        self._thread_receive.join()
+        self._thread_send.join()
+        self._client.leave()
+        self._client.release()
+
+
+    def receive_audio(self):
+        self._start_receive_event.wait()
+        print("starting receive audio thread")
+
+        if self._app_error:
+            print("Unable to receive audio!")
+            return
+
+        while not self._app_quit:
+            # Read BUFFER seconds worth of audio frames.
+            num_frames = int(self._sample_rate * BUFFER)
+            buffer = self._speaker_device.read_frames(num_frames)
+
+            if buffer:
+                self._buffer_queue.put(buffer) 
+
+    def send_audio(self):
+        self._start_send_event.wait()
+        print("starting send audio thread")
+
+
+        if self._app_error:
+            print("Unable to send audio!")
+            return
+
+        while not self._app_quit:
+            try:
+                # Wait for BUFFER seconds before sending audio
+                buffer = self._buffer_queue.get(timeout=.5)  # wait for buffer with timeout to avoid blocking indefinitely
+                if buffer:
+                    self._mic_device.write_frames(buffer)
+            except queue.Empty:
+                print("Buffer queue is empty, continuing...")
+                continue
+
+def main():
+
+    # set api_key
+    # Get it from the website under python.
+    birdconv.api_request["uid"] = "API KEY HERE"
+
+    # get the list of birdconv devices
+    devices  = birdconv.active()
+
+    # pick the devices that you want to place in a call
+    my_device = None
+    for device in devices :
+        if device["username"] == "Alistair":
+            my_device = device
+            break
+    
+    # place 1 or more selected devices on a call
+    room  = birdconv.create_room( [my_device] ) 
+
+    # get a token so that this python program can join the call
+    # FYI : don't use "-" in a username, use an "_"
+    meeting = birdconv.create_token( room , "Delay_Audio") 
+    print("Meeting URL: "   + meeting["url"])
+    # print("Meeting Token: " + meeting["token"])
+
+    print("sleeping for 1 second")
+    time.sleep(1)
+
+    Daily.init()
+
+    app = AudioApp(SAMPLE_RATE, NUM_CHANNELS)
+
+    try: 
+        app.run(meeting)
+    except KeyboardInterrupt:
+        print("Ctrl-C detected. Exiting!")
+    finally:
+        app.leave()
+
+
+if __name__ == '__main__':
+    main()

delay_audio.py

@@ -0,0 +1,4 @@
+boto3
+requests
+daily-python
+pillow

requirements.txt

@@ -0,0 +1,121 @@
+import requests
+import json
+from daily import *
+
+from PIL import Image
+import time
+import threading
+import birdconv
+
+
+
+
+class  Participant:
+    def __init__(self, image_file, framerate):
+        self.__image = Image.open(image_file)
+        self.__framerate = framerate
+
+        self.__camera = Daily.create_camera_device("my-camera",
+                                                   width=self.__image.width,
+                                                   height=self.__image.height,
+                                                   color_format="RGB")
+
+        self.__client = CallClient()
+
+        self.__client.update_subscription_profiles({
+            "base": {
+                "camera": "unsubscribed",
+                "microphone": "unsubscribed"
+            }
+        })
+
+        self.__app_quit = False
+        self.__app_error = None
+
+        self.__start_event = threading.Event()
+        self.__thread = threading.Thread(target=self.send_image)
+        self.__thread.start()
+
+    def on_joined(self, data, error):
+        if error:
+            print(f"Unable to join meeting: {error}")
+            self.__app_error = error
+        self.__start_event.set()
+
+    def run(self, meeting):
+        self.__client.join(meeting["url"], meeting_token=meeting["token"], client_settings={
+            "inputs": {
+                "camera": {
+                    "isEnabled": True,
+                    "settings": { "deviceId": "my-camera"}
+                },
+                "microphone": False
+            }
+        }, completion=self.on_joined)
+        self.__thread.join()
+
+    def leave(self):
+        self.__app_quit = True
+        self.__thread.join()
+        self.__client.leave()
+        self.__client.release()
+
+    def send_image(self):
+        self.__start_event.wait()
+
+        if self.__app_error:
+            print(f"Unable to send!")
+            return
+
+        sleep_time = 1.0 / self.__framerate
+        image_bytes = self.__image.tobytes()
+
+        while not self.__app_quit:
+            self.__camera.write_frame(image_bytes)
+            time.sleep(sleep_time)
+
+
+
+def main():
+
+
+    # set api_key
+    birdconv.api_request["uid"] = "0dtTMNNV6tYiNoSco8fdL3lzyYp2"
+
+    # get the list of birdconv devices
+    devices  = birdconv.active()
+
+    # pick the devices that you want to place in a call
+    my_device = None
+    for device in devices :
+        if device["username"] == "Alistair":
+            my_device = device
+            break
+    
+    # place 1 or more selected devices on a call
+    room  = birdconv.create_room( [my_device] ) 
+
+    # get a token so that this python program can join the call
+    meeting = birdconv.create_token( room ,  "show_image.py" )
+    print("Meeting URL: "   + meeting["url"])
+    # print("Meeting Token: " + meeting["token"])
+
+    print("sleeping for 5 seconds")
+    time.sleep(5)
+
+    print("connecting...")
+    Daily.init()
+
+    print("showing a picture of a bird")
+    participant = Participant("bird.png", 30)
+
+    try:
+        participant.run(meeting)
+    except KeyboardInterrupt:
+        print("Ctrl-C detected. Exiting!")
+    finally:
+        participant.leave()
+
+
+if __name__ == "__main__":
+    main()