[1 byte] Is final flag (1 = last frame, 0 = more coming)
[16 bytes] Interaction ID (UUID)
[8 bytes] Timestamp (uint64, milliseconds)
[4 bytes] Usage (uint32)
[4 bytes] Frame index (uint32)
[4 bytes] Number of payload entries (uint32)
For each payload entry:
[4 bytes] Payload size (uint32)
[1 byte] Payload type (1 = audio, 2 = image)
[N bytes] Payload data
import asyncio
import json
import struct
import time
import numpy as np
import websockets
API_KEY = "your-api-key"
CONFIG_ID = "your-config-id"
URL = f"wss://models.ojin.ai/realtime?config_id={CONFIG_ID}"
async def send_audio_chunk(ws, audio_int16_bytes, params=None):
"""Send audio chunk to server."""
params_bytes = b""
if params:
params_bytes = json.dumps(params).encode('utf-8')
header = struct.pack(
'!BQI',
1, # Audio payload type
int(time.time() * 1000),
len(params_bytes)
)
await ws.send(header + params_bytes + audio_int16_bytes)
async def receive_frame(ws):
"""Receive and parse video frame."""
data = await ws.recv()
if isinstance(data, str):
# JSON message (SessionReady, Error, etc)
return json.loads(data)
# Binary frame
header_fmt = '!B16sQIII'
header_size = struct.calcsize(header_fmt)
(is_final, interaction_id_bytes, timestamp,
usage, index, num_payloads) = struct.unpack(header_fmt, data[:header_size])
offset = header_size
video_frame = None
audio_chunk = None
for _ in range(num_payloads):
size, payload_type = struct.unpack('!IB', data[offset:offset+5])
offset += 5
payload_data = data[offset:offset+size]
offset += size
if payload_type == 2:
video_frame = payload_data
elif payload_type == 1:
audio_chunk = payload_data
return {
'video_frame': video_frame,
'audio_chunk': audio_chunk,
'is_final': bool(is_final),
'index': index
}
async def main():
headers = {"Authorization": API_KEY}
async with websockets.connect(URL, extra_headers=headers) as ws:
# Wait for SessionReady
session_ready = await receive_frame(ws)
print(f"Session ready: {session_ready}")
# Generate sample audio (1 second, 440Hz sine wave)
sample_rate = 16000
duration = 1.0
t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
audio = (32767 * 0.5 * np.sin(2 * np.pi * 440 * t)).astype(np.int16)
# Send audio in chunks
chunk_size = 6400 # 400ms chunks
for i in range(0, len(audio), chunk_size):
chunk = audio[i:i + chunk_size]
await send_audio_chunk(ws, chunk.tobytes())
await asyncio.sleep(0.01) # Throttle sends
# End interaction
end_message = {
"type": "endInteraction",
"payload": {"timestamp": int(time.time() * 1000)}
}
await ws.send(json.dumps(end_message))
# Receive frames until final
while True:
frame = await receive_frame(ws)
if isinstance(frame, dict) and frame.get('is_final'):
print("Received final frame")
break
print(f"Received frame {frame.get('index', 'N/A')}")
if __name__ == "__main__":
asyncio.run(main())
