@livekit/rtc-node 0.0.1

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "semi": true,
+  "tabWidth": 2,
+  "printWidth": 100,
+}

package/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+edition = "2021"
+name = "rtc-node"
+version = "0.0.1"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+napi = { version = "2.12.2", default-features = false, features = ["napi6"] }
+napi-derive = "2.12.2"
+livekit-ffi = { path = "./rust-sdks/livekit-ffi" }
+prost = "0.12"
+prost-types = "0.12"
+log = "0.4.20"
+
+[build-dependencies]
+napi-build = "2.0.1"
+
+[profile.release]
+lto = true

package/build.rs

@@ -0,0 +1,5 @@
+extern crate napi_build;
+
+fn main() {
+  napi_build::setup();
+}

package/generate_proto.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Copyright 2023 LiveKit, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# This script requires protobuf-compiler and https://github.com/nipunn1313/mypy-protobuf
+
+FFI_PROTOCOL=./rust-sdks/livekit-ffi/protocol
+FFI_OUT_NODE=./src/proto
+
+# ffi
+
+protoc \
+    -I=$FFI_PROTOCOL \
+    --es_out $FFI_OUT_NODE \
+    --es_opt target=ts \
+    $FFI_PROTOCOL/audio_frame.proto \
+    $FFI_PROTOCOL/ffi.proto \
+    $FFI_PROTOCOL/handle.proto \
+    $FFI_PROTOCOL/participant.proto \
+    $FFI_PROTOCOL/room.proto \
+    $FFI_PROTOCOL/track.proto \
+    $FFI_PROTOCOL/video_frame.proto \
+    $FFI_PROTOCOL/e2ee.proto \
+    $FFI_PROTOCOL/stats.proto

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@livekit/rtc-node",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "types": "src/index.ts",
+  "napi": {
+    "name": "rtc-node",
+    "triples": {
+      "defaults": false,
+      "additional": [
+        "aarch64-apple-darwin",
+        "x86_64-apple-darwin",
+        "aarch64-unknown-linux-gnu",
+        "x86_64-unknown-linux-gnu",
+        "x86_64-pc-windows-msvc"
+      ]
+    }
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@bufbuild/protobuf": "^1.4.2"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.16.5",
+    "@types/node": "^20.9.2",
+    "typed-emitter": "^2.1.0",
+    "typescript": "^5.2.2",
+    "prettier": "^3.0.3"
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "tsc && napi build --platform --release --dts src/native.d.ts --js src/native.js --pipe \"prettier -w\"",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "napi prepublish -t npm",
+    "universal": "napi universal",
+    "version": "napi version"
+  },
+  "optionalDependencies": {
+    "@livekit/rtc-node-darwin-arm64": "0.0.1",
+    "@livekit/rtc-node-darwin-x64": "0.0.1",
+    "@livekit/rtc-node-linux-arm64-gnu": "0.0.1",
+    "@livekit/rtc-node-linux-x64-gnu": "0.0.1",
+    "@livekit/rtc-node-win32-x64-msvc": "0.0.1"
+  }
+}

package/src/audio_frame.ts

@@ -0,0 +1,45 @@
+import { FfiClient, FfiHandle } from './ffi_client';
+import { AudioFrameBufferInfo, OwnedAudioFrameBuffer } from './proto/audio_frame_pb';
+
+export class AudioFrame {
+  data: Uint16Array;
+  sampleRate: number;
+  channels: number;
+  samplesPerChannel: number;
+
+  constructor(data: Uint16Array, sampleRate: number, channels: number, samplesPerChannel: number) {
+    this.data = data;
+    this.sampleRate = sampleRate;
+    this.channels = channels;
+    this.samplesPerChannel = samplesPerChannel;
+  }
+
+  static create(sampleRate: number, channels: number, samplesPerChannel: number): AudioFrame {
+    const data = new Uint16Array(channels * samplesPerChannel);
+    return new AudioFrame(data, sampleRate, channels, samplesPerChannel);
+  }
+
+  /** @internal */
+  static fromOwnedInfo(owned: OwnedAudioFrameBuffer): AudioFrame {
+    let info = owned.info;
+    let len = info.numChannels * info.samplesPerChannel * 2; // c_int16
+    let data = FfiClient.instance.copyBuffer(info.dataPtr, len);
+    new FfiHandle(owned.handle.id).dispose();
+    return new AudioFrame(
+      new Uint16Array(data.buffer),
+      info.sampleRate,
+      info.numChannels,
+      info.samplesPerChannel,
+    );
+  }
+
+  /** @internal */
+  protoInfo(): AudioFrameBufferInfo {
+    return new AudioFrameBufferInfo({
+      dataPtr: FfiClient.instance.retrievePtr(new Uint8Array(this.data.buffer)),
+      sampleRate: this.sampleRate,
+      numChannels: this.channels,
+      samplesPerChannel: this.samplesPerChannel,
+    });
+  }
+}

package/src/audio_source.ts

@@ -0,0 +1,64 @@
+import EventEmitter from 'events';
+import TypedEmitter from 'typed-emitter';
+import { FfiHandle } from './native';
+import { AudioFrame } from './audio_frame';
+import {
+  AudioSourceInfo,
+  AudioSourceType,
+  CaptureAudioFrameCallback,
+  CaptureAudioFrameRequest,
+  CaptureAudioFrameResponse,
+  NewAudioSourceRequest,
+  NewAudioSourceResponse,
+} from './proto/audio_frame_pb';
+import { FfiClient, FfiRequest } from './ffi_client';
+
+export class AudioSource {
+  /** @internal */
+  info: AudioSourceInfo;
+  /** @internal */
+  ffiHandle: FfiHandle;
+
+  sampleRate: number;
+  numChannels: number;
+
+  constructor(sampleRate: number, numChannels: number) {
+    this.sampleRate = sampleRate;
+    this.numChannels = numChannels;
+
+    let req = new NewAudioSourceRequest({
+      type: AudioSourceType.AUDIO_SOURCE_NATIVE,
+      sampleRate: sampleRate,
+      numChannels: numChannels,
+    });
+
+    let res = FfiClient.instance.request<NewAudioSourceResponse>({
+      message: {
+        case: 'newAudioSource',
+        value: req,
+      },
+    });
+
+    this.info = res.source.info;
+    this.ffiHandle = new FfiHandle(res.source.handle.id);
+  }
+
+  async captureFrame(frame: AudioFrame) {
+    let req = new CaptureAudioFrameRequest({
+      sourceHandle: this.ffiHandle.handle,
+      buffer: frame.protoInfo(),
+    });
+
+    let res = FfiClient.instance.request<CaptureAudioFrameResponse>({
+      message: { case: 'captureAudioFrame', value: req },
+    });
+
+    let cb = await FfiClient.instance.waitFor<CaptureAudioFrameCallback>((ev) => {
+      return ev.message.case == 'captureAudioFrame' && ev.message.value.asyncId == res.asyncId;
+    });
+
+    if (cb.error) {
+      throw new Error(cb.error);
+    }
+  }
+}

package/src/audio_stream.ts

@@ -0,0 +1,74 @@
+import { AudioFrame } from './audio_frame';
+import { FfiClient, FfiClientEvent, FfiEvent, FfiHandle, FfiRequest } from './ffi_client';
+import {
+  AudioStreamInfo,
+  AudioStreamType,
+  NewAudioStreamRequest,
+  NewAudioStreamResponse,
+} from './proto/audio_frame_pb';
+import { Track } from './track';
+import EventEmitter from 'events';
+import TypedEmitter from 'typed-emitter';
+
+export type AudioStreamCallbacks = {
+  frameReceived: (frame: AudioFrame) => void;
+};
+
+export enum AudioStreamEvent {
+  FrameReceived = 'frameReceived',
+}
+
+export class AudioStream extends (EventEmitter as new () => TypedEmitter<AudioStreamCallbacks>) {
+  /** @internal */
+  info: AudioStreamInfo;
+  /** @internal */
+  ffiHandle: FfiHandle;
+
+  track: Track;
+
+  constructor(track: Track) {
+    super();
+    this.track = track;
+
+    let req = new NewAudioStreamRequest({
+      type: AudioStreamType.AUDIO_STREAM_NATIVE,
+      trackHandle: track.ffi_handle.handle,
+    });
+
+    let res = FfiClient.instance.request<NewAudioStreamResponse>({
+      message: {
+        case: 'newAudioStream',
+        value: req,
+      },
+    });
+
+    this.info = res.stream.info;
+    this.ffiHandle = new FfiHandle(res.stream.handle.id);
+
+    FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onEvent);
+  }
+
+  private onEvent(ev: FfiEvent) {
+    if (
+      ev.message.case != 'audioStreamEvent' ||
+      ev.message.value.streamHandle != this.ffiHandle.handle
+    ) {
+      return;
+    }
+
+    let streamEvent = ev.message.value.message;
+    switch (streamEvent.case) {
+      case 'frameReceived':
+        let frame = AudioFrame.fromOwnedInfo(streamEvent.value.frame);
+        this.emit(AudioStreamEvent.FrameReceived, frame);
+        break;
+      case 'eos':
+        FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onEvent);
+        break;
+    }
+  }
+
+  close() {
+    this.ffiHandle.dispose();
+  }
+}

package/src/e2ee.ts

@@ -0,0 +1,311 @@
+import { FfiClient, FfiRequest } from './ffi_client';
+import {
+  E2eeManagerGetFrameCryptorsResponse,
+  E2eeManagerSetEnabledRequest,
+  E2eeRequest,
+  E2eeResponse,
+  EncryptionType,
+  FrameCryptorSetEnabledRequest,
+  FrameCryptorSetKeyIndexRequest,
+  GetKeyRequest,
+  GetKeyResponse,
+  GetSharedKeyRequest,
+  GetSharedKeyResponse,
+  RatchetKeyRequest,
+  RatchetKeyResponse,
+  RatchetSharedKeyRequest,
+  RatchetSharedKeyResponse,
+  SetKeyRequest,
+  SetSharedKeyRequest,
+} from './proto/e2ee_pb';
+
+const DEFAULT_RATCHET_SALT = new TextEncoder().encode('LKFrameEncryptionKey');
+const DEFAULT_RATCHET_WINDOW_SIZE = 16;
+const DEFAULT_FAILURE_TOLERANCE = -1;
+
+export interface KeyProviderOptions {
+  sharedKey?: Uint8Array;
+  ratchetSalt: Uint8Array;
+  ratchetWindowSize: number;
+  failureTolerance: number;
+}
+
+export const defaultKeyProviderOptions: KeyProviderOptions = {
+  ratchetSalt: DEFAULT_RATCHET_SALT,
+  ratchetWindowSize: DEFAULT_RATCHET_WINDOW_SIZE,
+  failureTolerance: DEFAULT_FAILURE_TOLERANCE,
+};
+
+export interface E2EEOptions {
+  keyProviderOptions: KeyProviderOptions;
+  encryptionType: EncryptionType;
+}
+
+export const defaultE2EEOptions: E2EEOptions = {
+  keyProviderOptions: defaultKeyProviderOptions,
+  encryptionType: EncryptionType.GCM,
+};
+
+export class KeyProvider {
+  private roomHandle: bigint;
+  options: KeyProviderOptions;
+
+  /** internal */
+  constructor(roomHandle: bigint, opts: KeyProviderOptions) {
+    this.roomHandle = roomHandle;
+    this.options = opts;
+  }
+
+  setSharedKey(sharedKey: Uint8Array, keyIndex: number) {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'setSharedKey',
+        value: new SetSharedKeyRequest({
+          keyIndex: keyIndex,
+          sharedKey: sharedKey,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  exportSharedKey(keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'getSharedKey',
+        value: new GetSharedKeyRequest({
+          keyIndex: keyIndex,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as GetSharedKeyResponse).key;
+  }
+
+  ratchetSharedKey(keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'ratchetSharedKey',
+        value: new RatchetSharedKeyRequest({
+          keyIndex: keyIndex,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as RatchetSharedKeyResponse).newKey;
+  }
+
+  setKey(participantIdentity: string, keyIndex: number) {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'setKey',
+        value: new SetKeyRequest({
+          keyIndex: keyIndex,
+          participantIdentity: participantIdentity,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  exportKey(participantIdentity: string, keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'getKey',
+        value: new GetKeyRequest({
+          keyIndex: keyIndex,
+          participantIdentity: participantIdentity,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as GetKeyResponse).key;
+  }
+
+  ratchetKey(participantIdentity: string, keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'ratchetKey',
+        value: new RatchetKeyRequest({
+          keyIndex: keyIndex,
+          participantIdentity: participantIdentity,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as RatchetKeyResponse).newKey;
+  }
+}
+
+export class FrameCryptor {
+  private roomHandle = 0n;
+  participantIdentity: string;
+  keyIndex: number;
+  enabled: boolean;
+
+  constructor(roomHandle: bigint, participantIdentity: string, keyIndex: number, enabled: boolean) {
+    this.roomHandle = roomHandle;
+    this.participantIdentity = participantIdentity;
+    this.keyIndex = keyIndex;
+    this.enabled = enabled;
+  }
+
+  setEnabled(enabled: boolean) {
+    this.enabled = enabled;
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'cryptorSetEnabled',
+        value: new FrameCryptorSetEnabledRequest({
+          participantIdentity: this.participantIdentity,
+          enabled: this.enabled,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  setKeyIndex(keyIndex: number) {
+    this.keyIndex = keyIndex;
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'cryptorSetKeyIndex',
+        value: new FrameCryptorSetKeyIndexRequest({
+          participantIdentity: this.participantIdentity,
+          keyIndex: this.keyIndex,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+}
+
+export class E2EEManager {
+  private roomHandle = 0n;
+  private options: E2EEOptions;
+  private keyProvider?: KeyProvider;
+
+  enabled: boolean;
+
+  constructor(roomHandle: bigint, opts?: E2EEOptions) {
+    this.roomHandle = roomHandle;
+    this.enabled = opts !== undefined;
+
+    if (opts !== undefined) {
+      const options = { ...defaultE2EEOptions, ...opts };
+
+      this.options = options;
+      this.keyProvider = new KeyProvider(roomHandle, options.keyProviderOptions);
+    }
+  }
+
+  setEnabled(enabled: boolean) {
+    this.enabled = enabled;
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'managerSetEnabled',
+        value: new E2eeManagerSetEnabledRequest({
+          enabled: this.enabled,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  frameCryptors(): FrameCryptor[] {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'managerGetFrameCryptors',
+        value: {},
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    let frameCryptors = (
+      res.message.value as E2eeManagerGetFrameCryptorsResponse
+    ).frameCryptors.map(
+      (cryptor) =>
+        new FrameCryptor(
+          this.roomHandle,
+          cryptor.participantIdentity,
+          cryptor.keyIndex,
+          cryptor.enabled,
+        ),
+    );
+
+    return frameCryptors;
+  }
+}

package/src/ffi_client.ts

@@ -0,0 +1,68 @@
+import { FfiRequest, FfiResponse, FfiEvent } from './proto/ffi_pb';
+import EventEmitter from 'events';
+import TypedEmitter from 'typed-emitter';
+import {
+  FfiHandle,
+  livekitFfiRequest,
+  livekitInitialize,
+  livekitCopyBuffer,
+  livekitRetrievePtr,
+} from './native';
+import { PartialMessage } from '@bufbuild/protobuf';
+
+export { FfiHandle, FfiEvent, FfiResponse, FfiRequest };
+
+export type FfiClientCallbacks = {
+  ffi_event: (event: FfiEvent) => void;
+};
+
+export enum FfiClientEvent {
+  FfiEvent = 'ffi_event',
+}
+
+export class FfiClient extends (EventEmitter as new () => TypedEmitter<FfiClientCallbacks>) {
+  static _client?: FfiClient;
+
+  /** @internal */
+  static get instance(): FfiClient {
+    if (!FfiClient._client) FfiClient._client = new FfiClient();
+
+    return FfiClient._client;
+  }
+
+  constructor() {
+    super();
+
+    livekitInitialize((event_data: Uint8Array) => {
+      let event = FfiEvent.fromBinary(event_data);
+      this.emit(FfiClientEvent.FfiEvent, event);
+    }, true);
+  }
+
+  request<T>(req: PartialMessage<FfiRequest>): T {
+    let request = new FfiRequest(req);
+    let req_data = request.toBinary();
+    let res_data = livekitFfiRequest(req_data);
+    return FfiResponse.fromBinary(res_data).message.value as T;
+  }
+
+  copyBuffer(ptr: bigint, len: number): Uint8Array {
+    return livekitCopyBuffer(ptr, len);
+  }
+
+  retrievePtr(data: Uint8Array): bigint {
+    return livekitRetrievePtr(data);
+  }
+
+  async waitFor<T>(predicate: (ev: FfiEvent) => boolean): Promise<T> {
+    return new Promise<T>((resolve, _) => {
+      let listener = (ev: FfiEvent) => {
+        if (predicate(ev)) {
+          this.off(FfiClientEvent.FfiEvent, listener);
+          resolve(ev.message.value as T);
+        }
+      };
+      this.on(FfiClientEvent.FfiEvent, listener);
+    });
+  }
+}