@ylink-sdk/mobile-web 0.1.6 → 0.1.9-beta.1

package/dist/e30037b8/libsvc-simd.d.ts

@@ -0,0 +1,767 @@
+/// <reference types="emscripten" />
+
+import './libsvc.ambient';
+
+/* eslint-disable camelcase */
+export interface SVCModule extends EmscriptenModuleWithRuntime {
+  SFUEndpoint: SFUEndpoint;
+  SFUTransport: SFUTransport;
+  SFUTransportProxy: SFUTransportProxy;
+  VideoChannel: VideoChannel;
+
+  Transport: Transport;
+  TransportFactory: TransportFactory;
+  TimerFactory: TimerFactory;
+
+  FrameSource: FrameSource;
+  FrameSink: FrameSink;
+  I420Buffer: I420Buffer;
+  EventEmitter: EventEmitter;
+
+  SFUReason: SFUReason;
+  SFUUserRole: SFUUserRole;
+  SFUTransportType: SFUTransportType;
+  SFUTransportStatus: SFUTransportStatus;
+  SFUTransportOrient: SFUTransportOrient;
+  SFUEndpointStatus: SFUEndpointStatus;
+  VideoChannelOrient: VideoChannelOrient;
+  VideoChannelMode: VideoChannelMode;
+  VideoRotation: VideoRotation;
+
+  DataChannel: DataChannel;
+  DataType: DataType;
+
+  SubtitleRecord: SubtitleRecord;
+  SubtitleRealtime: SubtitleRealtime;
+}
+
+export interface SFUTransport {
+  prototype: SFUTransportInterface;
+  new (endpoint: SFUEndpointInterface, type: SFUTransportType): SFUTransportInterface;
+}
+
+export interface SFUTransportInterface
+  extends EmscriptenClass<SFUTransportInterface>,
+    EventEmitterInterface<SFUTransportEvents> {
+  Connect(config: SFUTransportConfig): number;
+  Disconnect(): number;
+
+  Subscribe(request: SFUSubscribeData[], remove: SFUSubscribeData[]): number;
+
+  SendData(data: SFUData[], meta?: SFUDataMeta): number;
+  SendSingal(data: number, length: number, ccid: number): number;
+}
+
+export type SFUTransportEvents = {
+  onjoin: (reason: SFUReason) => void;
+  onleave: (reason: SFUReason) => void;
+  onstatus: (status: SFUTransportStatus, reason: SFUReason) => void;
+  onsubscribe: (ccid: number, reason: SFUReason) => void;
+  onsubscribeupdated: (requests: SFUSubscribeConfig[]) => void;
+  onbitrate: (info: SFUNetworkInfo) => void;
+  onsendstats: (stats: SFUNetworkStats) => void;
+  onrecvstats: (stats: SFUNetworkStats) => void;
+  onsendreport: (stats: SFUNetworkStats) => void;
+  onaudiosendstats: (stats: SFUNetworkAudioStats) => void;
+  onaudiorecvstats: (stats: SFUNetworkAudioStats) => void;
+  ontimestamps: () => void;
+  onmediasync: (timestamps: SFUTimestamp[]) => void;
+  onsignal: (data: number, length: number) => void;
+  ondata: (data: number, length: number, ccid: number, time: string, channel: number) => void;
+};
+
+export interface SFUTransportProxy {
+  prototype: SFUTransportProxyInterface;
+  new (delegate: SFUTransportDelegate): SFUTransportProxyInterface;
+}
+
+export interface SFUTransportProxyInterface
+  extends EmscriptenClass<SFUTransportProxyInterface>,
+    SFUTransportEvents {
+  // onjoin: (reason: SFUReason) => void;
+  // onleave: (reason: SFUReason) => void;
+  // onstatus: (status: SFUTransportStatus, reason: SFUReason) => void;
+  // onsubscribe: (ccid: number, reason: SFUReason) => void;
+  // onsubscribeupdated: (requests: SFUSubscribeConfig[]) => void;
+  // onbitrate: (info: SFUNetworkInfo) => void;
+  // onsendstats: (stats: SFUNetworkStats) => void;
+  // onrecvstats: (stats: SFUNetworkStats) => void;
+  // onsendreport: (stats: SFUNetworkStats) => void;
+  // ontimestamps: () => void;
+  // onmediasync: (timestamps: SFUTimestamp[]) => void;
+  // onsignal: (data: number, length: number) => void;
+  // ondata: (data: number, length: number, ccid: number, time: string) => void;
+}
+
+export interface SFUTransportDelegate {
+  Connect(config: SFUTransportConfig): void;
+  Disconnect(): void;
+
+  Subscribe(request: SFUSubscribeData[], remove: number[]): void;
+
+  SendData(data: SFUData[], meta: SFUDataMeta): void;
+  SendSingal(data: number, length: number, ccid: number): void;
+}
+
+// pointer, length
+export type SFUData = [number, number];
+
+export interface SFUDataMeta {
+  channel: number;
+  priority: number;
+  key_flag: number;
+  cursor_image_flag: number;
+  timestamp: number;
+}
+
+export interface SFUTransportConfig {
+  orient: SFUTransportOrient;
+  feature: number;
+  target_incoming_bitrate: number;
+  target_outgoing_bitrate: number;
+  desc: SFUData;
+}
+
+export enum SFUTransportType {
+  kAudio = 1,
+  kVideo,
+  kData,
+  kAnnotation,
+  kMessage,
+}
+
+export enum SFUTransportOrient {
+  kSend = 1,
+  kRecv,
+  kBoth,
+}
+
+export enum SFUUserRole {
+  kInteractive = 1,
+  kBroadcast,
+}
+
+export interface SFUNetworkInfo {
+  probe: number;
+  bitrate: number;
+}
+
+export interface SFUNetworkStats {
+  loss_rate: number;
+  accumulated_loss_packets: number;
+  jitter: number;
+  rtt: number;
+  bitrate: number;
+}
+
+export interface SFUNetworkReport {
+  allocate_bitrate: number;
+  bandwidth_estimation: number;
+  bandwidth_from_reciever: number;
+  fec_bitrate: number;
+  nack_bitrate: number;
+  paced_send_delay: number;
+}
+
+export interface SFUNetworkAudioStats {
+  rtt: number;
+  jitter: number;
+  bitrate: number;
+  audio_real_pkg_num: number;
+  loss_rate: number;
+  loss_continue_info: {
+    loss_continue_eq_2: number;
+    loss_continue_eq_3: number;
+    loss_continue_eq_4: number;
+    loss_continue_eq_5: number;
+    loss_continue_eq_6: number;
+    loss_continue_eq_7: number;
+    loss_continue_eq_8: number;
+    loss_continue_eq_9: number;
+    loss_continue_gte_10: number;
+  };
+  outband_fec_bitrate: number;
+  outband_fec_level: number;
+  outband_fec_recover_rate: number;
+  arq_bitrate: number;
+  arq_recover_rate: number;
+  arq_max_req_counts: number;
+  arq_avg_req_counts: number;
+  outband_loss_recover_rate: number;
+}
+
+export interface SFUTimestamp {
+  ccid: number;
+  timestamp: number;
+}
+
+export interface SFUSubscribeData {
+  ccid: number;
+  desc: SFUData;
+}
+export interface SFUSubscribeConfig {
+  width: number;
+  height: number;
+  fps: number;
+  bandwidth: number;
+  is_update: boolean;
+}
+
+export interface SFUEndpoint {
+  prototype: SFUEndpointInterface;
+  new (transport_factory: TransportFactoryInterface): SFUEndpointInterface;
+
+  Version(): string;
+
+  Init(factory: TimerFactoryInterface, callback?: VideoChannelLogCallback): void;
+  Exit(): void;
+}
+
+export interface SFUEndpointInterface
+  extends EmscriptenClass<SFUEndpointInterface>,
+    EventEmitterInterface<SFUEndpointEvents> {
+  Start(config: SFUEndpointConfig): void;
+  Stop(): void;
+
+  SendOutboundAppCommand(data: number, length: number): void;
+}
+
+export type SFUEndpointEvents = {
+  onstatus: (state: SFUEndpointStatus, reason: SFUReason) => void;
+};
+
+export interface SFUEndpointConfig {
+  ccid: number;
+  confid: string;
+  token: string;
+  encrypt: string;
+  user_account: string;
+  meeting_number: string;
+  meeting_param: string;
+  client_type: string;
+  role: SFUUserRole;
+}
+
+export enum SFUReason {
+  kOK = 0,
+  kError = 1000,
+  kExisted,
+  kNetworkError,
+  kMCFailed,
+  kMSSFailed,
+  kMSSLost,
+  kAuthFailed,
+  kLoadFailed,
+  kNoImplemented,
+}
+
+export enum SFUTransportStatus {
+  kReconnecting = 500,
+  kReconnectOK,
+  kReconnectNG,
+}
+
+export enum SFUEndpointStatus {
+  kHandshakeOK = 100,
+  kHandshakeNG,
+  kConnectOK,
+  kConnectNG,
+}
+
+export interface TransportInterface extends EmscriptenClass<TransportInterface> {
+  readonly identity: TransportType;
+  readonly callback: number;
+
+  onopen(): void;
+  onerror(): void;
+  onclose(error: boolean, code: number): void;
+  onmessage(data: number, length: number): void;
+}
+
+export interface TransportImpl {
+  send(data: number, length: number): void;
+  close(): void;
+  destroy(): void;
+}
+
+export interface Transport {
+  prototype: TransportInterface;
+  new (impl: TransportImpl, identity: TransportType, callback: number): TransportInterface;
+}
+
+export enum TransportType {
+  kSignal = 0,
+  kData,
+}
+
+export interface TransportFactoryInterface extends EmscriptenClass<TransportFactoryInterface> {}
+
+export interface TransportFactoryImpl {
+  create(identity: TransportType, callback: number): TransportInterface;
+}
+
+export interface TransportFactory {
+  prototype: TransportFactoryInterface;
+  new (impl: TransportFactoryImpl): TransportFactoryInterface;
+}
+
+export interface TimerFactoryInterface extends EmscriptenClass<TimerFactoryInterface> {}
+
+export interface TimerFactoryImpl {
+  start(callback: number, delay: number): any;
+  stop(id: any): void;
+}
+
+export interface TimerFactory {
+  prototype: TimerFactoryInterface;
+  new (impl: TimerFactoryImpl): TimerFactoryInterface;
+
+  Run(callback: number): void;
+}
+
+export interface VideoChannel {
+  prototype: VideoChannelInterface;
+  new (type: VideoChannelType): VideoChannelInterface;
+
+  Version(): string;
+
+  Init(factory: TimerFactoryInterface, callback?: VideoChannelLogCallback): void;
+  Exit(): void;
+
+  EncodeMode(mode: VideoEncodeMode): void;
+}
+
+export enum VideoEncodeMode {
+  kVeryfast = 0,
+  kUltrafast = 1,
+}
+
+export type VideoChannelLogCallback = (level: number, msg: string) => void;
+
+export interface VideoChannelInterface
+  extends EmscriptenClass<VideoChannelInterface>,
+    EventEmitterInterface<VideoChannelEvents> {
+  readonly type: VideoChannelType;
+
+  SetTransport(transport?: SFUTransportProxyInterface): number;
+  SetSource(source?: FrameSourceInterface): number;
+  SetSink(source?: FrameSinkInterface): number;
+  SetOrient(orient: VideoChannelOrient): number;
+
+  Join(config: VideoChannelConfig): number;
+  Leave(): number;
+
+  Subscribe(request: VideoSubscribeConfig[], remove: number[]): number;
+
+  SendStats(): VideoChannelStats;
+  RecvStats(ccid: number): VideoChannelStats;
+
+  SendReport(): VideoChannelSendReport;
+  RecvReport(ccid: number): VideoChannelRecvReport;
+}
+
+export type VideoChannelEvents = {
+  onjoin: (result: SFUReason) => void;
+  onsubscribe: (ccid: number, result: SFUReason) => void;
+  onfailoverstart: () => void;
+  onfailoverfailed: () => void;
+  onvideosize: (width: number, height: number) => void;
+  oncpu: (cores: number) => void;
+  onhighcpu: () => void;
+};
+
+// SFUTransportType
+// type VideoChannelType = SFUTransportType;
+export enum VideoChannelType {
+  kAudio = 1,
+  kVideo,
+  kData,
+  kAnnotation,
+  kMessage,
+}
+
+// SFUTransportOrient
+// type VideoChannelOrient = SFUTransportOrient;
+export enum VideoChannelOrient {
+  kSend = 1,
+  kRecv,
+  kBoth,
+}
+
+export enum VideoChannelMode {
+  kNormal = 0,
+  kSmooth,
+}
+
+export interface VideoChannelConfig {
+  ccid: number;
+  confid: string;
+  orient: VideoChannelOrient;
+  mode: VideoChannelMode;
+  max_width: number;
+  max_height: number;
+}
+
+export interface VideoSubscribeConfig {
+  ccid: number;
+  width: number;
+  height: number;
+}
+
+export interface VideoChannelStats {
+  width: number;
+  height: number;
+  frame_rate: number;
+  bit_rate: number;
+  loss_rate: number;
+  accumulated_loss_packets: number;
+  jitter: number;
+  rtt: number;
+}
+
+export interface VideoChannelSendReport {
+  send_net_info: VideoChannelOutboundInfo;
+  send_stream_info: VideoChannelStreamInfo;
+}
+
+export interface VideoChannelRecvReport {
+  recv_net_info: VideoChannelInboundInfo;
+  recv_decode_info: VideoChannelDecodeInfo;
+}
+
+export interface VideoChannelOutboundInfo {
+  ssrc: number;
+  rtt: number;
+  jitter: number;
+  loss_rate: number;
+  bandwidth_estimation: number;
+  allocate_bitrate: number;
+  bandwidth_from_reciever: number;
+  send_bitrate: number;
+  fec_bitrate: number;
+  nack_bitrate: number;
+  paced_send_delay: number;
+}
+export interface VideoChannelStreamInfo {
+  capture_fps: number;
+  datacap_avg_time: number;
+  video_encode_infos: VideoEncodeInfo[];
+}
+export interface VideoEncodeInfo {
+  enc_mode: number;
+  codec_type: string;
+  enc_width: number;
+  enc_height: number;
+  enc_fps: number;
+  enc_bitrate: number;
+  enc_avg_qp: number;
+  enc_max_qp: number;
+  enc_min_qp: number;
+  enc_i_avg_qp: number;
+  enc_idr_frame_num: number;
+  enc_avg_time: number;
+  cap2send_max_time: number;
+  enc_high_delay_frame_num: number;
+  big_frame_num: number;
+  recv_req_keyframe_num: number;
+  ltr_mark_frequency: number;
+}
+
+export interface VideoChannelInboundInfo {
+  ssrc: number;
+  rtt: number;
+  jitter: number;
+  loss_rate: number;
+  recv_bitrate: number;
+}
+export interface VideoChannelDecodeInfo {
+  codec_type: string;
+  dec_width: number;
+  dec_height: number;
+  first_frame_time: number;
+  video_aftdec_bitrate: number;
+  video_aftdec_framerate: number;
+  video_dec_errorcode: number;
+  video_recovfrm_time: number;
+  video_jitterbuf_time: number;
+  decode_avg_time: number;
+  req_keyframe_num: number;
+  freeze_time: number;
+  video_dec_largefreeze_num: number;
+  sync_delay: number;
+  eva_grade: number;
+  frozen_rate: number;
+}
+
+export interface FrameSourceInterface
+  extends EmscriptenClass<FrameSourceInterface>,
+    EventEmitterInterface<FrameSourceEvents> {
+  ccid: number;
+
+  readonly canstart: boolean;
+  readonly canstop: boolean;
+
+  OnFrame(buffer: I420BufferInterface): void;
+
+  AddSink(sink: FrameSinkInterface): void;
+  RemoveSink(sink: FrameSinkInterface): void;
+}
+
+export type FrameSourceEvents = {
+  onstart: () => void;
+  onstop: () => void;
+};
+
+export interface FrameSource {
+  prototype: FrameSourceInterface;
+  new (): FrameSourceInterface;
+  new (ccid: number): FrameSourceInterface;
+}
+
+export interface FrameSinkInterface
+  extends EmscriptenClass<FrameSinkInterface>,
+    EventEmitterInterface<FrameSinkEvents> {}
+
+export type FrameSinkEvents = {
+  onframe: (ccid: number, buffer: I420BufferInterface) => void;
+  oncursor: (ccid: number) => void;
+};
+
+export interface FrameSink {
+  prototype: FrameSinkInterface;
+  new (): FrameSinkInterface;
+}
+
+export interface I420BufferInterface extends EmscriptenClass<I420BufferInterface> {
+  readonly width: number;
+  readonly height: number;
+  readonly chromaWidth: number;
+  readonly chromaHeight: number;
+  readonly dataY: number;
+  readonly dataU: number;
+  readonly dataV: number;
+  readonly strideY: number;
+  readonly strideU: number;
+  readonly strideV: number;
+
+  CropAndScaleFrom(buffer: I420BufferInterface): void;
+  ScaleFrom(buffer: I420BufferInterface): void;
+  PasteFrom(buffer: I420BufferInterface, offset_col: number, offset_row: number): void;
+  ToABGR(pointer: number): void;
+}
+
+export interface I420Buffer {
+  prototype: I420BufferInterface;
+  new (width: number, height: number): I420BufferInterface;
+
+  Copy(buffer: I420BufferInterface): I420BufferInterface;
+  FromYUV(
+    width: number,
+    height: number,
+    dataY: number,
+    strideY: number,
+    dataU: number,
+    strideU: number,
+    dataV: number,
+    strideV: number
+  ): I420BufferInterface;
+  FromABGR(width: number, height: number, data: number, stride: number): I420BufferInterface;
+  Rotate(buffer: I420BufferInterface, rotation: VideoRotation): I420BufferInterface;
+  SetBlack(buffer: I420BufferInterface): void;
+}
+
+export enum VideoRotation {
+  kRotation_0 = 0,
+  kRotation_90 = 90,
+  kRotation_180 = 180,
+  kRotation_270 = 270,
+}
+
+export interface DataChannel {
+  prototype: DataChannelInterface;
+  // can only be VideoChannelType.kMessage
+  new (type: VideoChannelType): DataChannelInterface;
+}
+
+export enum DataType {
+  kCoopration = 1,
+  kRemoteControl,
+  kSubtitleRealtime,
+  kSubtitleRecord,
+}
+
+export interface DataChannelInterface
+  extends EmscriptenClass<DataChannelInterface>,
+    EventEmitterInterface<DataChannelEvents> {
+  readonly type: VideoChannelType;
+
+  SetTransport(transport?: SFUTransportProxyInterface): number;
+
+  Join(config: DataChannelConfig): number;
+  Leave(): number;
+
+  CreateDataStream(type: DataType): DataStreamInterface;
+}
+
+export type DataChannelEvents = Record<string, (...args: any[]) => void>;
+
+export interface DataChannelConfig {
+  ccid: number;
+  confid: string;
+}
+
+export interface DataStreamInterface
+  extends EmscriptenClass<DataStreamInterface>,
+    EventEmitterInterface<DataStreamEvents> {
+  Write(data: number, length: number, dest: number[], traits: DataTraits): void;
+  Subscribe(request: number[], remove: number[]): number;
+}
+
+export type DataStreamEvents = {
+  ondata: (data: number, length: number, from: number[]) => void;
+};
+
+export interface DataTraits {
+  direct: boolean;
+  merge: boolean;
+}
+
+export interface SubtitleRecord {
+  prototype: SubtitleRecordInterface;
+  new (): SubtitleRecordInterface;
+}
+
+export interface SubtitleRecordInterface {
+  encode(subtitle: RecordSubtitleInfo, callback: (data: SFUData) => void): void;
+  decode(data: SFUData, callback: (subtitle: RecordSubtitleInfo) => void): void;
+}
+
+export interface SubtitleRealtime {
+  prototype: SubtitleRealtimeInterface;
+  new (): SubtitleRealtimeInterface;
+}
+
+export interface SubtitleRealtimeInterface {
+  encode(subtitle: RealtimeSubtitleInfo, callback: (data: SFUData) => void): void;
+  decode(data: SFUData, callback: (subtitle: RealtimeSubtitleInfo) => void): void;
+}
+
+export interface SubtitleInfo {
+  sentence: SubtitleSentenceInfo;
+}
+export interface SubtitleSentenceInfo {
+  speakerid: number;
+  sentenceid: number;
+  action: SubtitleSentenceAction;
+  content: string;
+}
+export enum SubtitleSentenceAction {
+  kCommon = 0,
+  kShareStart,
+  kShareEnd,
+  kCoopStart,
+  kCoopEnd,
+  kServiceOver,
+}
+export interface RecordSubtitleInfo extends SubtitleInfo {
+  speaker: string;
+  starttime: number;
+  endtime: number;
+  words: SubtitleWordInfo[];
+}
+export interface RealtimeSubtitleInfo extends SubtitleInfo {
+  status: SubtitleSentenceStatus;
+}
+export enum SubtitleSentenceStatus {
+  kStart = 0,
+  kChanging,
+  kEnd,
+}
+export interface SubtitleWordInfo {
+  timeoffset: number;
+  content: string;
+}
+
+export interface EventEmitterInterface<
+  EventMap extends Record<string, (...args: any[]) => void> = never
+> {
+  once<T extends keyof EventMap>(event: T, callback: EventMap[T]): void;
+  once<T extends keyof EventMap>(
+    event: '*',
+    callback: (event: T, ...args: Parameters<EventMap[T]>) => void
+  ): void;
+  once<T extends keyof EventMap>(
+    event: '*',
+    callback: (event: T, ...args: unknown[]) => void
+  ): void;
+  once(event: string, callback: (...args: unknown[]) => void): void;
+
+  on<T extends keyof EventMap>(event: T, callback: EventMap[T]): void;
+  on<T extends keyof EventMap>(
+    event: '*',
+    callback: (event: T, ...args: Parameters<EventMap[T]>) => void
+  ): void;
+  on<T extends keyof EventMap>(event: '*', callback: (event: T, ...args: unknown[]) => void): void;
+  on(event: string, callback: (...args: unknown[]) => void): void;
+
+  off<T extends keyof EventMap>(event: T, callback?: EventMap[T]): void;
+  off(event: string, callback?: (...args: unknown[]) => void): void;
+
+  emit(event: keyof EventMap, ...args: Parameters<EventMap[typeof event]>): void;
+  emit(event: string, ...args: unknown[]): void;
+}
+
+export interface EventEmitter {
+  prototype: EventEmitterInterface & EmscriptenClass<EventEmitterInterface>;
+  new (): EventEmitterInterface & EmscriptenClass<EventEmitterInterface>;
+}
+
+export interface EmscriptenClass<T> {
+  clone(): T;
+  delete(): void;
+  deleteLater(): void;
+  isAliasOf(): boolean;
+  isDeleted(): boolean;
+}
+
+export interface EmscriptenModuleWithRuntime extends EmscriptenModule {
+  ccall: typeof ccall;
+  cwrap: typeof cwrap;
+
+  setValue: typeof setValue;
+  getValue: typeof getValue;
+
+  allocate: typeof allocate;
+
+  stackAlloc: typeof stackAlloc;
+  stackSave: typeof stackSave;
+  stackRestore: typeof stackRestore;
+
+  UTF8ToString: typeof UTF8ToString;
+  stringToUTF8: typeof stringToUTF8;
+  lengthBytesUTF8: typeof lengthBytesUTF8;
+  allocateUTF8: typeof allocateUTF8;
+  allocateUTF8OnStack: typeof allocateUTF8OnStack;
+  UTF16ToString: typeof UTF16ToString;
+  stringToUTF16: typeof stringToUTF16;
+  lengthBytesUTF16: typeof lengthBytesUTF16;
+  UTF32ToString: typeof UTF32ToString;
+  stringToUTF32: typeof stringToUTF32;
+  lengthBytesUTF32: typeof lengthBytesUTF32;
+
+  intArrayFromString: typeof intArrayFromString;
+  intArrayToString: typeof intArrayToString;
+  writeStringToMemory: typeof writeStringToMemory;
+  writeArrayToMemory: typeof writeArrayToMemory;
+  writeAsciiToMemory: typeof writeAsciiToMemory;
+
+  addRunDependency: typeof addRunDependency;
+  removeRunDependency: typeof removeRunDependency;
+
+  addFunction: typeof addFunction;
+  removeFunction: typeof removeFunction;
+}
+
+declare const factory: EmscriptenModuleFactory<SVCModule>;
+
+export default factory;