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

package/dist/e30037b8/librtc.d.ts

@@ -0,0 +1,438 @@
+import { AudioChannelInterface } from '@line-ui/line-rtc';
+import { AudioEngineInterface } from '@line-ui/line-rtc';
+import { AudioFrameBufferBuilder } from '@line-ui/line-media';
+import { AudioReceiverInterface } from '@line-ui/line-rtc';
+import { AudioRecvParameters } from '@line-ui/line-rtc';
+import { AudioRecvStats } from '@line-ui/line-rtc';
+import { AudioSenderInterface } from '@line-ui/line-rtc';
+import { AudioSendParameters } from '@line-ui/line-rtc';
+import { AudioSendStats } from '@line-ui/line-rtc';
+import { AudioSourceLike } from '@line-ui/line-rtc';
+import { AudioStats } from '@line-ui/line-rtc';
+import { AudioTransportInterface } from '@line-ui/line-media';
+import { DataChannelConfig } from '@vc-webassembly/libsvc';
+import { DataTraits } from '@vc-webassembly/libsvc';
+import { DataType } from '@vc-webassembly/libsvc';
+import { DTMFSender } from '@line-ui/line-rtc';
+import { FrameDecryptorInterface } from '@line-ui/line-rtc';
+import { FrameEncryptorInterface } from '@line-ui/line-rtc';
+import { IPVPAudioAdvanceStatsRX } from '@vc-webassembly/libipvp';
+import { IPVPAudioAdvanceStatsTX } from '@vc-webassembly/libipvp';
+import { IPVPAudioStatsReport } from '@vc-webassembly/libipvp';
+import { IPVPAudioStatsRX } from '@vc-webassembly/libipvp';
+import { IPVPAudioStatsTX } from '@vc-webassembly/libipvp';
+import { IPVPBandwidth } from '@vc-webassembly/libipvp';
+import { IPVPDspStats } from '@vc-webassembly/libipvp';
+import { MediaEngine } from '@line-ui/line-rtc';
+import { MediaType } from '@line-ui/line-rtc';
+import { Memory } from '@line-ui/line-wasm';
+import { MemoryAllocator } from '@line-ui/line-wasm';
+import { MemoryViewer } from '@line-ui/line-wasm';
+import { MojoChannel } from '@line-ui/line-mojo';
+import { MojoPendingReceiver } from '@line-ui/line-mojo';
+import { MojoReceiver } from '@line-ui/line-mojo';
+import { MojoRemote } from '@line-ui/line-mojo';
+import { OffscreenRenderer } from '@line-ui/line-rtc';
+import { RealtimeSubtitleInfo } from '@vc-webassembly/libsvc';
+import { RGBBufferBuilder } from '@line-ui/line-media';
+import { SFUEndpointConfig } from '@vc-webassembly/libsvc';
+import { SFUEndpointInterface } from '@vc-webassembly/libsvc';
+import { SFUNetworkAudioStats } from '@vc-webassembly/libsvc';
+import { SFUNetworkInfo } from '@vc-webassembly/libsvc';
+import { SFUNetworkStats } from '@vc-webassembly/libsvc';
+import { SFUReason } from '@vc-webassembly/libsvc';
+import { SFUSubscribeConfig } from '@vc-webassembly/libsvc';
+import { SFUTimestamp } from '@vc-webassembly/libsvc';
+import { SFUTransportInterface } from '@vc-webassembly/libsvc';
+import { SFUTransportStatus } from '@vc-webassembly/libsvc';
+import { SFUTransportType } from '@vc-webassembly/libsvc';
+import { SFUUserRole } from '@vc-webassembly/libsvc';
+import { TransportFactoryInterface } from '@vc-webassembly/libsvc';
+import { VideoChannelConfig } from '@vc-webassembly/libsvc';
+import { VideoChannelInterface } from '@line-ui/line-rtc';
+import { VideoChannelOrient } from '@vc-webassembly/libsvc';
+import { VideoChannelRecvReport } from '@vc-webassembly/libsvc';
+import { VideoChannelSendReport } from '@vc-webassembly/libsvc';
+import { VideoChannelStats } from '@vc-webassembly/libsvc';
+import { VideoChannelType } from '@vc-webassembly/libsvc';
+import { VideoEncodeMode } from '@vc-webassembly/libsvc';
+import { VideoEngineInterface } from '@line-ui/line-rtc';
+import { VideoReceiverInterface } from '@line-ui/line-rtc';
+import { VideoRecvParameters } from '@line-ui/line-rtc';
+import { VideoRecvStats } from '@line-ui/line-rtc';
+import { VideoSenderInterface } from '@line-ui/line-rtc';
+import { VideoSendParameters } from '@line-ui/line-rtc';
+import { VideoSendStats } from '@line-ui/line-rtc';
+import { VideoSinkLike } from '@line-ui/line-rtc';
+import { VideoSourceLike } from '@line-ui/line-rtc';
+import { VideoStats } from '@line-ui/line-rtc';
+import { VideoSubscribeConfig } from '@vc-webassembly/libsvc';
+
+declare interface AudioEngineEventHost {
+    speaking(id: number, ccid: number[]): void;
+    focusing(id: number, ccid: number[]): void;
+    decodestart(ccid: number): void;
+    decodestop(ccid: number): void;
+    gainchange(gain: number, track: number): void;
+}
+
+declare interface AudioEngineHost {
+    init(url: string, transportPR: MojoPendingReceiver, eventPR: MojoPendingReceiver, verbose?: boolean): void;
+    exit(): void;
+    mos(lossrate: number, rtt: number, realtime?: boolean): number;
+    aec(level: 0 | 1 | 2): void;
+    agc(enable: 0 | 1): void;
+    ans(ans: 0 | 1 | 2 | 3, tns?: 0 | 1 | 2 | 3): void;
+    mute(enable: boolean): void;
+    bypass(enable: boolean): void;
+    dtmf(tones: string): void;
+    sendstats(): IPVPAudioStatsTX;
+    recvstats(ccid: number): IPVPAudioStatsRX;
+    bandwidth(): IPVPBandwidth;
+    jitter(): [value: number, max: number];
+    sendstatsadv(): IPVPAudioAdvanceStatsTX;
+    recvstatsadv(ccid: number): IPVPAudioAdvanceStatsRX;
+    report(): IPVPAudioStatsReport;
+    micschedule(): IPVPDspStats;
+    spkschedule(): IPVPDspStats;
+    process(buffer?: Required<AudioFrameBufferBuilder>): Required<AudioFrameBufferBuilder> | void;
+    processdelay(samples: number): void;
+    push(buffer: Required<AudioFrameBufferBuilder>): void;
+    pushref(buffer: Required<AudioFrameBufferBuilder>): void;
+    pull(samples: number, channels: number, sampleRate: number): Required<AudioFrameBufferBuilder> | void;
+    pulldelay(samples: number): void;
+    receive(ccid: number, data: Uint8Array, channel: number): void;
+    setup(ccid: number, samplerate: number, type?: number): void;
+    trackgain(gain: number, track?: number): void;
+    fec(lossrate: number): void;
+    dumpstats(): void;
+    dumptalk(): void;
+    vtuner(host?: string, port?: number): void;
+}
+
+declare type AudioEngineHostFactory = () => Promise<[
+MojoChannel,
+MojoRemote<AudioEngineHost>,
+MojoReceiver<AudioEngineTransportHost>,
+MojoReceiver<AudioEngineEventHost>,
+() => Promise<void>
+]>;
+
+declare interface AudioEngineTransportHost {
+    send(id: number, data: Uint8Array): void;
+}
+
+export declare function bootstrap(): Promise<void>;
+
+export { DataChannelConfig }
+
+declare interface DataChannelHost extends VideoTransportEventHost {
+    open(config: DataChannelConfig): void;
+    datastream(type: DataType, listener: MojoPendingReceiver): MojoPendingReceiver;
+    subtitlestream(type: DataType, listener: MojoPendingReceiver): MojoPendingReceiver;
+}
+
+declare interface DataStreamHost {
+    write(data: Uint8Array, dest: number[], traits: DataTraits): void;
+    subscribe(request: number[], remove: number[]): void;
+}
+
+export { DataType }
+
+export declare class NativeAudioChannel implements AudioChannelInterface {
+    readonly type: MediaType;
+    readonly track: number;
+    readonly ssrc: number;
+    transport: SFUTransportInterface;
+    config: SFUEndpointConfig;
+    alloc: MemoryAllocator;
+    view: MemoryViewer;
+    description: Memory<Uint8Array>;
+    factory: AudioEngineHostFactory;
+    encoder: MojoRemote<AudioEngineHost>;
+    decoder: MojoRemote<AudioEngineHost>;
+    context: AudioContext;
+    audioTransport: AudioTransportInterface;
+    audioElement?: HTMLAudioElement;
+    audioStream?: MediaStream;
+    senders: Map<string | number, NativeAudioSender>;
+    receivers: Map<string | number, NativeAudioReceiver>;
+    stats: {
+        send: SFUNetworkStats;
+        recv: SFUNetworkStats;
+        audiosend: SFUNetworkAudioStats;
+        audiorecv: SFUNetworkAudioStats;
+    };
+    cleanup: (() => void)[];
+    onopen?: () => void;
+    onclose?: () => void;
+    onspeaking?: (ssrc: number[]) => void;
+    onfocusing?: (ssrc: number[]) => void;
+    constructor(transport: SFUTransportInterface, factory: AudioEngineHostFactory, context?: AudioContext);
+    createSender(ssrc?: number): NativeAudioSender;
+    removeSender(ssrc?: number): void;
+    createReceiver(ssrc?: number): NativeAudioReceiver;
+    removeReceiver(ssrc?: number): void;
+    addTrack(id: number): void;
+    removeTrack(id: number): void;
+    getStats(): Promise<AudioStats>;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    ans(enable: boolean): void;
+    dsp(): Promise<unknown>;
+    trackgain(value: number, track?: number): void;
+}
+
+export declare class NativeAudioEngine implements AudioEngineInterface {
+    init(): Promise<void>;
+    createChannel(transport: SFUTransportInterface): NativeAudioChannel;
+}
+
+export declare class NativeAudioReceiver implements AudioReceiverInterface {
+    readonly ssrc: number;
+    sink?: HTMLMediaElement;
+    engine: MojoRemote<AudioEngineHost>;
+    transport: AudioTransportInterface;
+    stream?: MediaStream;
+    element?: HTMLAudioElement;
+    cleanup?: () => void;
+    ondecodestart?: (ccid: number) => void;
+    ondecodestop?: (ccid: number) => void;
+    ongainchange?: (gain: number, track: number) => void;
+    constructor(ssrc: number, engine: MojoRemote<AudioEngineHost>, transport: AudioTransportInterface, stream?: MediaStream, element?: HTMLAudioElement);
+    setParameters(parameters: AudioRecvParameters): void;
+    getParameters(): AudioRecvParameters;
+    setFrameDecryptor(decryptor: FrameDecryptorInterface): void;
+    setSink(sink: HTMLMediaElement): void;
+    getStats(): Promise<AudioRecvStats>;
+    getStatsDetail(): Promise<AudioRecvStats>;
+    getStatsReport(): Promise<AudioRecvStats>;
+    start(): void;
+    stop(): void;
+}
+
+export declare class NativeAudioSender implements AudioSenderInterface {
+    readonly ssrc: number;
+    readonly dtmf: DTMFSender;
+    source?: AudioSourceLike;
+    engine: MojoRemote<AudioEngineHost>;
+    transport: AudioTransportInterface;
+    nodes: WeakMap<AudioSourceLike, MediaStreamAudioSourceNode | MediaElementAudioSourceNode>;
+    cleanup?: () => void;
+    constructor(ssrc: number, engine: MojoRemote<AudioEngineHost>, transport: AudioTransportInterface, dtmf: DTMFSender);
+    setParameters(parameters: AudioSendParameters): void;
+    getParameters(): AudioSendParameters;
+    setFrameEncryptor(encryptor: FrameEncryptorInterface): void;
+    setSource(source: AudioSourceLike): void;
+    getStats(): Promise<AudioSendStats>;
+    getStatsDetail(): Promise<AudioSendStats>;
+    getStatsReport(): Promise<AudioSendStats>;
+    stop(): void;
+}
+
+export declare class NativeDataChannel {
+    readonly type: MediaType;
+    transport: SFUTransportInterface;
+    config: SFUEndpointConfig;
+    alloc: MemoryAllocator;
+    view: MemoryViewer;
+    factory: VideoEngineHostFactory;
+    internal: MojoRemote<DataChannelHost>;
+    streams: Map<number, NativeDataStream | NativeSubtitleStream>;
+    cleanup: (() => void)[];
+    onopen?: () => void;
+    onclose?: () => void;
+    constructor(transport: SFUTransportInterface, factory: VideoEngineHostFactory);
+    createStream(type: DataType): Promise<NativeDataStream>;
+    closeStream(stream: NativeDataStream): Promise<void>;
+    createSubtitleStream(type?: DataType): Promise<NativeSubtitleStream>;
+    closeSubtitleStream(stream: NativeDataStream): Promise<void>;
+    open(channelConfig?: Partial<Omit<DataChannelConfig, 'ccid' | 'confid'>>): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare class NativeDataStream {
+    readonly type: DataType;
+    host: MojoRemote<DataStreamHost>;
+    ondata?: (data: Uint8Array, from: number[]) => void;
+    constructor(type: DataType, host: MojoRemote<DataStreamHost>);
+    write(data: Uint8Array, to?: number[], transfer?: boolean): void;
+    subscribe(request: number[], remove?: number[]): void;
+}
+
+export declare class NativeMediaEndpoint {
+    mss: string[];
+    transports: TransportLike[];
+    transport_factory: TransportFactoryInterface;
+    endpoint: SFUEndpointInterface;
+    config: SFUEndpointConfig;
+    onrefresh?: () => string[] | Promise<string[]>;
+    constructor(mss?: string[]);
+    init(): Promise<void>;
+    destroy(): void;
+    start(config: SFUEndpointConfig): Promise<void>;
+    stop(): void;
+    createTransport(type: SFUTransportType): SFUTransportInterface;
+}
+
+export declare class NativeMediaEngine implements MediaEngine {
+    audio: NativeAudioEngine;
+    video: NativeVideoEngine;
+    data: unknown;
+    constructor();
+    init(): Promise<void>;
+}
+
+export declare class NativeSubtitleStream {
+    readonly type: DataType;
+    host: MojoRemote<SubtitleStreamHost>;
+    ondata?: (data: RealtimeSubtitleInfo, from: number[]) => void;
+    constructor(type: DataType, host: MojoRemote<SubtitleStreamHost>);
+    write(data: RealtimeSubtitleInfo, to?: number[]): void;
+    subscribe(request: number[], remove?: number[]): void;
+}
+
+export declare class NativeVideoChannel implements VideoChannelInterface {
+    readonly type: MediaType;
+    readonly offscreen: OffscreenRenderer;
+    transport: SFUTransportInterface;
+    config: SFUEndpointConfig;
+    alloc: MemoryAllocator;
+    view: MemoryViewer;
+    factory: VideoEngineHostFactory;
+    encoder: MojoRemote<VideoChannelHost>;
+    decoder: MojoRemote<VideoChannelHost>;
+    senders: Map<number, NativeVideoSender>;
+    receivers: Map<number, NativeVideoReceiver>;
+    stats: {
+        send: SFUNetworkStats;
+        recv: SFUNetworkStats;
+    };
+    cleanup: (() => void)[];
+    onopen?: () => void;
+    onclose?: () => void;
+    constructor(transport: SFUTransportInterface, factory: VideoEngineHostFactory);
+    createSender(ssrc?: number): NativeVideoSender;
+    removeSender(ssrc?: number): void;
+    createReceiver(ssrc: number): NativeVideoReceiver;
+    removeReceiver(ssrc: number): void;
+    getStats(): Promise<VideoStats>;
+    open(channelConfig?: Partial<Omit<VideoChannelConfig, 'ccid' | 'confid' | 'orient'>>): Promise<void>;
+    close(): Promise<void>;
+}
+
+export declare class NativeVideoEngine implements VideoEngineInterface {
+    init(): Promise<void>;
+    createChannel(transport: SFUTransportInterface): NativeVideoChannel;
+    createDataChannel(transport: SFUTransportInterface): NativeDataChannel;
+}
+
+export declare class NativeVideoReceiver implements VideoReceiverInterface {
+    readonly ssrc: number;
+    sink?: VideoSinkLike;
+    channel: MojoChannel;
+    decoder: MojoRemote<VideoChannelHost>;
+    parameters: VideoRecvParameters;
+    loadeddata: boolean;
+    width?: number;
+    height?: number;
+    onloadeddata?: () => void;
+    onframechanged?: (width: number, height: number) => void;
+    onready?: () => void;
+    onfailed?: () => void;
+    constructor(ssrc: number, decoder: MojoRemote<VideoChannelHost>);
+    setParameters(parameters: VideoRecvParameters): void;
+    getParameters(): VideoRecvParameters;
+    setFrameDecryptor(decryptor: FrameDecryptorInterface): void;
+    setSink(sink?: VideoSinkLike, webgl?: boolean): void;
+    start(): void;
+    stop(): void;
+    getStats(): Promise<VideoRecvStats>;
+    getStatsDetail(): Promise<VideoRecvStats>;
+}
+
+export declare class NativeVideoSender implements VideoSenderInterface {
+    readonly ssrc: number;
+    readonly dtmf: void;
+    source?: VideoSourceLike;
+    channel: MojoChannel;
+    encoder: MojoRemote<VideoChannelHost>;
+    parameters: VideoSendParameters;
+    running: boolean;
+    onstart?: () => void;
+    onstop?: () => void;
+    onbusy?: (state: boolean) => void;
+    constructor(ssrc: number, encoder: MojoRemote<VideoChannelHost>);
+    setParameters(parameters: Partial<VideoSendParameters>): void;
+    getParameters(): VideoSendParameters;
+    setFrameEncryptor(encryptor: FrameEncryptorInterface): void;
+    setSource(source: VideoSourceLike): void;
+    stop(): void;
+    getStats(): Promise<VideoSendStats>;
+    getStatsDetail(): Promise<VideoSendStats>;
+}
+
+export declare function setupRemoteControl(stream: NativeDataStream, viewport: HTMLCanvasElement, remote: number[]): () => void;
+
+export { SFUEndpointConfig }
+
+export { SFUTransportType }
+
+export { SFUUserRole }
+
+declare interface SubtitleStreamHost {
+    write(data: RealtimeSubtitleInfo, dest: number[]): void;
+    subscribe(request: number[], remove: number[]): void;
+}
+
+declare type TransportLike = WebSocket | RTCPeerConnection;
+
+declare interface VideoChannelHost extends VideoTransportEventHost {
+    mode(value: VideoEncodeMode): void;
+    open(config: VideoChannelConfig): void;
+    encode(buffer: RGBBufferBuilder): void;
+    setsource(source?: MojoPendingReceiver, frameRate?: number): boolean;
+    setsink(ccid: number, sink?: MojoPendingReceiver, rendererId?: number): void;
+    setframerate(frameRate: number): void;
+    setorient(orient: VideoChannelOrient): void;
+    load(canvas: OffscreenCanvas, webgl?: boolean): number;
+    unload(id: number): void;
+    subscribe(request: VideoSubscribeConfig[], remove: number[]): void;
+    sendstats(): VideoChannelStats;
+    recvstats(ccid: number): VideoChannelStats;
+    sendreport(): VideoChannelSendReport;
+    recvreport(ccid: number): VideoChannelRecvReport;
+}
+
+declare interface VideoEngineHost {
+    init(url: string, verbose?: boolean): void;
+    exit(): void;
+    suspend(): void;
+    resume(): void;
+    setup(transport: string, type?: VideoChannelType): MojoPendingReceiver;
+    setup2(transport: MojoPendingReceiver, type?: DataType): MojoPendingReceiver;
+}
+
+declare type VideoEngineHostFactory = () => Promise<[
+MojoChannel,
+MojoRemote<VideoEngineHost>,
+() => Promise<void>
+]>;
+
+declare interface VideoTransportEventHost {
+    onjoin(reason: SFUReason, data: Uint8Array): void;
+    onleave(reason: SFUReason): void;
+    onstatus(status: SFUTransportStatus, reason: SFUReason): void;
+    onsubscribe(ccid: number, reason: SFUReason, data: Uint8Array): 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: Uint8Array): void;
+    ondata(data: Uint8Array, ccid: number, time: string): void;
+}
+
+export { }