@livekit/rtc-node 0.0.2 → 0.0.3

package/src/index.ts

@@ -0,0 +1,52 @@
+export { Room, RoomEvent, ConnectError, RoomOptions, RtcConfiguration } from './room';
+export { Participant, RemoteParticipant, LocalParticipant } from './participant';
+export {
+  Track,
+  LocalTrack,
+  RemoteTrack,
+  VideoTrack,
+  LocalAudioTrack,
+  LocalVideoTrack,
+  RemoteAudioTrack,
+  RemoteVideoTrack,
+  AudioTrack,
+} from './track';
+export {
+  VideoFrame,
+  VideoFrameBuffer,
+  I420Buffer,
+  I422Buffer,
+  I444Buffer,
+  I420ABuffer,
+  NV12Buffer,
+  NativeBuffer,
+  I010Buffer,
+  PlanarYuvBuffer,
+  PlanarYuv8Buffer,
+  PlanarYuv16Buffer,
+  ArgbFrame,
+  BiplanarYuv8Buffer,
+} from './video_frame';
+export { AudioFrame } from './audio_frame';
+export { AudioStream } from './audio_stream';
+export { VideoStream } from './video_stream';
+export { AudioSource } from './audio_source';
+export { VideoSource } from './video_source';
+export {
+  TrackPublication,
+  RemoteTrackPublication,
+  LocalTrackPublication,
+} from './track_publication';
+export { E2EEManager, E2EEOptions, KeyProviderOptions, KeyProvider, FrameCryptor } from './e2ee';
+export {
+  ConnectionQuality,
+  IceServer,
+  IceTransportType,
+  DataPacketKind,
+  ContinualGatheringPolicy,
+  TrackPublishOptions,
+  ConnectionState,
+} from './proto/room_pb';
+export { EncryptionType, EncryptionState } from './proto/e2ee_pb';
+export { StreamState, TrackKind, TrackSource } from './proto/track_pb';
+export { VideoFormatType, VideoFrameBufferType, VideoRotation } from './proto/video_frame_pb';

package/src/lib.rs

@@ -0,0 +1,5 @@
+#![deny(clippy::all)]
+
+extern crate napi_derive;
+
+pub mod nodejs;

package/src/native.d.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export function livekitInitialize(callback: (data: Uint8Array) => void, captureLogs: boolean): void;
+export function livekitFfiRequest(data: Uint8Array): Uint8Array;
+export function livekitRetrievePtr(handle: Uint8Array): bigint;
+export function livekitCopyBuffer(ptr: bigint, len: number): Uint8Array;
+export class FfiHandle {
+  constructor(handle: bigint);
+  dispose(): void;
+  get handle(): bigint;
+}

package/src/native.js

@@ -0,0 +1,269 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path');
+
+const { platform, arch } = process;
+
+let nativeBinding = null;
+let localFileExisted = false;
+let loadError = null;
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim();
+      return readFileSync(lddPath, 'utf8').includes('musl');
+    } catch (e) {
+      return true;
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header;
+    return !glibcVersionRuntime;
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.android-arm64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.android-arm64.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-android-arm64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.android-arm-eabi.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.android-arm-eabi.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-android-arm-eabi');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`);
+    }
+    break;
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.win32-x64-msvc.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.win32-x64-msvc.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-win32-x64-msvc');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'ia32':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.win32-ia32-msvc.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.win32-ia32-msvc.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-win32-ia32-msvc');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.win32-arm64-msvc.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.win32-arm64-msvc.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-win32-arm64-msvc');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`);
+    }
+    break;
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'rtc-node.darwin-universal.node'));
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rtc-node.darwin-universal.node');
+      } else {
+        nativeBinding = require('@livekit/rtc-node-darwin-universal');
+      }
+      break;
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.darwin-x64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.darwin-x64.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-darwin-x64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.darwin-arm64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.darwin-arm64.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-darwin-arm64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`);
+    }
+    break;
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
+    }
+    localFileExisted = existsSync(join(__dirname, 'rtc-node.freebsd-x64.node'));
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rtc-node.freebsd-x64.node');
+      } else {
+        nativeBinding = require('@livekit/rtc-node-freebsd-x64');
+      }
+    } catch (e) {
+      loadError = e;
+    }
+    break;
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rtc-node.linux-x64-musl.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rtc-node.linux-x64-musl.node');
+            } else {
+              nativeBinding = require('@livekit/rtc-node-linux-x64-musl');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rtc-node.linux-x64-gnu.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rtc-node.linux-x64-gnu.node');
+            } else {
+              nativeBinding = require('@livekit/rtc-node-linux-x64-gnu');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        }
+        break;
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rtc-node.linux-arm64-musl.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rtc-node.linux-arm64-musl.node');
+            } else {
+              nativeBinding = require('@livekit/rtc-node-linux-arm64-musl');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rtc-node.linux-arm64-gnu.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rtc-node.linux-arm64-gnu.node');
+            } else {
+              nativeBinding = require('@livekit/rtc-node-linux-arm64-gnu');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        }
+        break;
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rtc-node.linux-arm-gnueabihf.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rtc-node.linux-arm-gnueabihf.node');
+          } else {
+            nativeBinding = require('@livekit/rtc-node-linux-arm-gnueabihf');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rtc-node.linux-riscv64-musl.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rtc-node.linux-riscv64-musl.node');
+            } else {
+              nativeBinding = require('@livekit/rtc-node-linux-riscv64-musl');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rtc-node.linux-riscv64-gnu.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rtc-node.linux-riscv64-gnu.node');
+            } else {
+              nativeBinding = require('@livekit/rtc-node-linux-riscv64-gnu');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`);
+    }
+    break;
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError;
+  }
+  throw new Error(`Failed to load native binding`);
+}
+
+const { livekitInitialize, livekitFfiRequest, livekitRetrievePtr, livekitCopyBuffer, FfiHandle } =
+  nativeBinding;
+
+module.exports.livekitInitialize = livekitInitialize;
+module.exports.livekitFfiRequest = livekitFfiRequest;
+module.exports.livekitRetrievePtr = livekitRetrievePtr;
+module.exports.livekitCopyBuffer = livekitCopyBuffer;
+module.exports.FfiHandle = FfiHandle;

package/src/nodejs.rs

@@ -0,0 +1,115 @@
+use livekit_ffi::FfiHandleId;
+use livekit_ffi::{proto, server, FFI_SERVER};
+use napi::{
+    bindgen_prelude::*,
+    threadsafe_function::{
+        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+    },
+    JsFunction, Status,
+};
+use napi_derive::napi;
+use prost::Message;
+use std::sync::Arc;
+
+#[napi(ts_args_type = "callback: (data: Uint8Array) => void, captureLogs: boolean")]
+fn livekit_initialize(cb: JsFunction, capture_logs: bool) {
+    let tsfn: ThreadsafeFunction<proto::FfiEvent, ErrorStrategy::Fatal> = cb
+        .create_threadsafe_function(0, |ctx: ThreadSafeCallContext<proto::FfiEvent>| {
+            let data = ctx.value.encode_to_vec();
+            let buf = Uint8Array::new(data);
+            Ok(vec![buf])
+        })
+        .unwrap();
+
+    FFI_SERVER.setup(server::FfiConfig {
+        callback_fn: Arc::new(move |event| {
+            let status = tsfn.call(event, ThreadsafeFunctionCallMode::NonBlocking);
+            if status != Status::Ok {
+                eprintln!("error calling callback status: {}", status);
+            }
+        }),
+        capture_logs,
+    });
+}
+
+#[napi]
+fn livekit_ffi_request(data: Uint8Array) -> Uint8Array {
+    let data = data.to_vec();
+    let res = match proto::FfiRequest::decode(data.as_slice()) {
+        Ok(res) => res,
+        Err(err) => {
+            panic!("failed to decode request: {}", err);
+        }
+    };
+
+    let res = match server::requests::handle_request(&FFI_SERVER, res) {
+        Ok(res) => res,
+        Err(err) => {
+            panic!("failed to handle request: {}", err);
+        }
+    }
+    .encode_to_vec();
+    Uint8Array::new(res)
+}
+
+// FfiHandle must be used instead
+//#[napi]
+//fn livekit_drop_handle(handle: BigInt) -> bool {
+//    let (_, handle, _) = handle.get_u64();
+//    FFI_SERVER.drop_handle(handle)
+//}
+
+#[napi]
+fn livekit_retrieve_ptr(handle: Uint8Array) -> BigInt {
+    BigInt::from(handle.as_ptr() as u64)
+}
+
+#[napi]
+fn livekit_copy_buffer(ptr: BigInt, len: u32) -> Uint8Array {
+    let (_, ptr, _) = ptr.get_u64();
+    let data = unsafe { std::slice::from_raw_parts(ptr as *const u8, len as usize) };
+    Uint8Array::with_data_copied(data)
+}
+
+#[napi(custom_finalize)]
+pub struct FfiHandle {
+    handle: BigInt,
+    disposed: bool,
+    // TODO(theomonnom): add gc pressure memory
+}
+
+#[napi]
+impl FfiHandle {
+    #[napi(constructor)]
+    pub fn new(handle: BigInt) -> Self {
+        Self {
+            handle,
+            disposed: false,
+        }
+    }
+
+    #[napi]
+    pub fn dispose(&mut self) -> Result<()> {
+        if self.disposed {
+            return Ok(());
+        }
+        self.disposed = true;
+        let (_, handle, _) = self.handle.get_u64();
+        if !FFI_SERVER.drop_handle(handle) {
+            return Err(Error::from_reason("trying to drop an invalid handle"));
+        }
+
+        Ok(())
+    }
+
+    #[napi(getter)]
+    pub fn handle(&self) -> BigInt {
+        self.handle.clone()
+    }
+}
+
+impl ObjectFinalize for FfiHandle {
+    fn finalize(mut self, env: Env) -> Result<()> {
+        self.dispose()
+    }
+}

package/src/participant.ts

@@ -0,0 +1,171 @@
+import { FfiClient, FfiClientEvent, FfiHandle, FfiRequest } from './ffi_client';
+import { ParticipantInfo, OwnedParticipant } from './proto/participant_pb';
+import {
+  DataPacketKind,
+  PublishDataCallback,
+  PublishDataRequest,
+  PublishDataResponse,
+  PublishTrackCallback,
+  PublishTrackRequest,
+  PublishTrackResponse,
+  TrackPublishOptions,
+  UnpublishTrackCallback,
+  UnpublishTrackRequest,
+  UnpublishTrackResponse,
+  UpdateLocalMetadataCallback,
+  UpdateLocalMetadataRequest,
+  UpdateLocalMetadataResponse,
+  UpdateLocalNameCallback,
+  UpdateLocalNameRequest,
+  UpdateLocalNameResponse,
+} from './proto/room_pb';
+import { LocalTrackPublication, RemoteTrackPublication, TrackPublication } from './track_publication';
+import { LocalTrack } from './track';
+
+export abstract class Participant {
+  /** @internal */
+  info: ParticipantInfo;
+
+  /** @internal */
+  ffi_handle: FfiHandle;
+
+  tracks = new Map<string, TrackPublication>();
+
+  constructor(owned_info: OwnedParticipant) {
+    this.info = owned_info.info;
+    this.ffi_handle = new FfiHandle(owned_info.handle.id);
+  }
+
+  get sid(): string {
+    return this.info.sid;
+  }
+
+  get name(): string {
+    return this.info.name;
+  }
+
+  get identity(): string {
+    return this.info.identity;
+  }
+
+  get metadata(): string {
+    return this.info.metadata;
+  }
+}
+
+export class LocalParticipant extends Participant {
+  tracks: Map<string, LocalTrackPublication> = new Map();
+
+  async publishData(
+    data: Uint8Array,
+    kind: DataPacketKind,
+    destination_sids: Array<string | RemoteParticipant> = [], // empty = broadcast
+  ) {
+    let req = new PublishDataRequest({
+      localParticipantHandle: this.ffi_handle.handle,
+      dataPtr: FfiClient.instance.retrievePtr(data),
+      dataLen: BigInt(data.byteLength),
+      kind: kind,
+    });
+
+    let sids = destination_sids.map((sid) => {
+      if (typeof sid == 'string') return sid;
+      return sid.sid;
+    });
+    req.destinationSids = sids;
+
+    let res = FfiClient.instance.request<PublishDataResponse>({
+      message: { case: 'publishData', value: req },
+    });
+
+    let cb = await FfiClient.instance.waitFor<PublishDataCallback>((ev) => {
+      return ev.message.case == 'publishData' && ev.message.value.asyncId == res.asyncId;
+    });
+
+    if (cb.error) {
+      throw new Error(cb.error);
+    }
+  }
+
+  async updateMetadata(metadata: string) {
+    let req = new UpdateLocalMetadataRequest({
+      localParticipantHandle: this.ffi_handle.handle,
+      metadata: metadata,
+    });
+
+    let res = FfiClient.instance.request<UpdateLocalMetadataResponse>({
+      message: { case: 'updateLocalMetadata', value: req },
+    });
+
+    await FfiClient.instance.waitFor<UpdateLocalMetadataCallback>((ev) => {
+      return ev.message.case == 'updateLocalMetadata' && ev.message.value.asyncId == res.asyncId;
+    });
+  }
+
+  async updateName(name: string) {
+    let req = new UpdateLocalNameRequest({
+      localParticipantHandle: this.ffi_handle.handle,
+      name: name,
+    });
+
+    let res = FfiClient.instance.request<UpdateLocalNameResponse>({
+      message: { case: 'updateLocalName', value: req },
+    });
+
+    await FfiClient.instance.waitFor<UpdateLocalNameCallback>((ev) => {
+      return ev.message.case == 'updateLocalName' && ev.message.value.asyncId == res.asyncId;
+    });
+  }
+
+  async publishTrack(
+    track: LocalTrack,
+    options: TrackPublishOptions,
+  ): Promise<LocalTrackPublication> {
+    let req = new PublishTrackRequest({
+      localParticipantHandle: this.ffi_handle.handle,
+      trackHandle: track.ffi_handle.handle,
+      options: options,
+    });
+
+    let res = FfiClient.instance.request<PublishTrackResponse>({
+      message: { case: 'publishTrack', value: req },
+    });
+
+    let cb = await FfiClient.instance.waitFor<PublishTrackCallback>((ev) => {
+      return ev.message.case == 'publishTrack' && ev.message.value.asyncId == res.asyncId;
+    });
+
+    let track_publication = new LocalTrackPublication(cb.publication);
+    track_publication.track = track;
+    this.tracks.set(track_publication.sid, track_publication);
+
+    return track_publication;
+  }
+
+  async unpublishTrack(trackSid: string) {
+    let req = new UnpublishTrackRequest({
+      localParticipantHandle: this.ffi_handle.handle,
+      trackSid: trackSid,
+    });
+
+    let res = FfiClient.instance.request<UnpublishTrackResponse>({
+      message: { case: 'unpublishTrack', value: req },
+    });
+
+    await FfiClient.instance.waitFor<UnpublishTrackCallback>((ev) => {
+      return ev.message.case == 'unpublishTrack' && ev.message.value.asyncId == res.asyncId;
+    });
+
+    let pub = this.tracks.get(trackSid);
+    pub.track = undefined;
+    this.tracks.delete(trackSid);
+  }
+}
+
+export class RemoteParticipant extends Participant {
+  tracks: Map<string, RemoteTrackPublication> = new Map();
+
+  constructor(owned_info: OwnedParticipant) {
+    super(owned_info);
+  }
+}