larksr_websdk 3.2.402 → 3.2.404

package/types/lark/webcodecs.generated.d.ts

@@ -0,0 +1,417 @@
+/////////////////////////////
+/// webcodecs APIs
+/////////////////////////////
+
+interface AudioDataCopyToOptions {
+    format?: AudioSampleFormat | undefined;
+    frameCount?: number | undefined;
+    frameOffset?: number | undefined;
+    planeIndex: number;
+}
+
+interface AudioDataInit {
+    data: AllowSharedBufferSource;
+    format: AudioSampleFormat;
+    numberOfChannels: number;
+    numberOfFrames: number;
+    sampleRate: number;
+    timestamp: number;
+}
+
+interface AudioDecoderConfig {
+    codec: string;
+    description?: AllowSharedBufferSource | undefined;
+    numberOfChannels: number;
+    sampleRate: number;
+}
+
+interface AudioDecoderInit {
+    error: WebCodecsErrorCallback;
+    output: AudioDataOutputCallback;
+}
+
+interface AudioDecoderSupport {
+    config: AudioDecoderConfig;
+    supported: boolean;
+}
+
+interface AudioEncoderConfig {
+    bitrate?: number | undefined;
+    codec: string;
+    numberOfChannels: number;
+    sampleRate: number;
+}
+
+interface AudioEncoderInit {
+    error: WebCodecsErrorCallback;
+    output: EncodedAudioChunkOutputCallback;
+}
+
+interface AudioEncoderSupport {
+    config: AudioEncoderConfig;
+    supported: boolean;
+}
+
+interface AvcEncoderConfig {
+    format?: AvcBitstreamFormat | undefined;
+}
+
+interface EncodedAudioChunkInit {
+    data: AllowSharedBufferSource;
+    duration?: number | undefined;
+    timestamp: number;
+    type: EncodedAudioChunkType;
+}
+
+interface EncodedAudioChunkMetadata {
+    decoderConfig?: AudioDecoderConfig | undefined;
+}
+
+interface EncodedVideoChunkInit {
+    data: AllowSharedBufferSource;
+    duration?: number | undefined;
+    timestamp: number;
+    type: EncodedVideoChunkType;
+}
+
+interface EncodedVideoChunkMetadata {
+    decoderConfig?: VideoDecoderConfig | undefined;
+    temporalLayerId?: number | undefined;
+}
+
+interface ImageDecodeOptions {
+    completeFramesOnly?: boolean | undefined;
+    frameIndex?: number | undefined;
+}
+
+interface ImageDecodeResult {
+    complete: boolean;
+    image: VideoFrame;
+}
+
+interface ImageDecoderInit {
+    colorSpaceConversion?: ColorSpaceConversion | undefined;
+    data: ImageBufferSource;
+    desiredHeight?: number | undefined;
+    desiredWidth?: number | undefined;
+    preferAnimation?: boolean | undefined;
+    premultiplyAlpha?: PremultiplyAlpha | undefined;
+    type: string;
+}
+
+interface PlaneLayout {
+    offset: number;
+    stride: number;
+}
+
+interface VideoColorSpaceInit {
+    fullRange?: boolean | null | undefined;
+    matrix?: VideoMatrixCoefficients | null | undefined;
+    primaries?: VideoColorPrimaries | null | undefined;
+    transfer?: VideoTransferCharacteristics | null | undefined;
+}
+
+interface VideoDecoderConfig {
+    codec: string;
+    codedHeight?: number | undefined;
+    codedWidth?: number | undefined;
+    colorSpace?: VideoColorSpaceInit | undefined;
+    description?: AllowSharedBufferSource | undefined;
+    displayAspectHeight?: number | undefined;
+    displayAspectWidth?: number | undefined;
+    hardwareAcceleration?: HardwarePreference | undefined;
+    optimizeForLatency?: boolean | undefined;
+}
+
+interface VideoDecoderInit {
+    error: WebCodecsErrorCallback;
+    output: VideoFrameOutputCallback;
+}
+
+interface VideoDecoderSupport {
+    config?: VideoDecoderConfig;
+    supported?: boolean;
+}
+
+interface VideoEncoderConfig {
+    alpha?: AlphaOption | undefined;
+    avc?: AvcEncoderConfig | undefined;
+    bitrate?: number | undefined;
+    bitrateMode?: VideoEncoderBitrateMode | undefined;
+    codec: string;
+    displayHeight?: number | undefined;
+    displayWidth?: number | undefined;
+    framerate?: number | undefined;
+    hardwareAcceleration?: HardwarePreference | undefined;
+    height: number;
+    latencyMode?: LatencyMode | undefined;
+    scalabilityMode?: string | undefined;
+    width: number;
+}
+
+interface VideoEncoderEncodeOptions {
+    keyFrame?: boolean;
+}
+
+interface VideoEncoderInit {
+    error: WebCodecsErrorCallback;
+    output: EncodedVideoChunkOutputCallback;
+}
+
+interface VideoEncoderSupport {
+    config?: VideoEncoderConfig;
+    supported?: boolean;
+}
+
+interface VideoFrameBufferInit {
+    codedHeight: number;
+    codedWidth: number;
+    colorSpace?: VideoColorSpaceInit | undefined;
+    displayHeight?: number | undefined;
+    displayWidth?: number | undefined;
+    duration?: number | undefined;
+    format: VideoPixelFormat;
+    layout?: PlaneLayout[] | undefined;
+    timestamp: number;
+    visibleRect?: DOMRectInit | undefined;
+}
+
+interface VideoFrameCopyToOptions {
+    layout?: PlaneLayout[] | undefined;
+    rect?: DOMRectInit | undefined;
+}
+
+interface VideoFrameInit {
+    alpha?: AlphaOption | undefined;
+    displayHeight?: number | undefined;
+    displayWidth?: number | undefined;
+    duration?: number | undefined;
+    timestamp?: number | undefined;
+    visibleRect?: DOMRectInit | undefined;
+}
+
+interface AudioData {
+    readonly duration: number;
+    readonly format: AudioSampleFormat;
+    readonly numberOfChannels: number;
+    readonly numberOfFrames: number;
+    readonly sampleRate: number;
+    readonly timestamp: number;
+    allocationSize(options: AudioDataCopyToOptions): number;
+    clone(): AudioData;
+    close(): void;
+    copyTo(destination: AllowSharedBufferSource, options: AudioDataCopyToOptions): void;
+}
+
+declare var AudioData: {
+    prototype: AudioData;
+    new(init: AudioDataInit): AudioData;
+};
+
+/** Available only in secure contexts. */
+interface AudioDecoder {
+    readonly decodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: AudioDecoderConfig): void;
+    decode(chunk: EncodedAudioChunk): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var AudioDecoder: {
+    prototype: AudioDecoder;
+    new(init: AudioDecoderInit): AudioDecoder;
+    isConfigSupported(config: AudioDecoderConfig): Promise<AudioDecoderSupport>;
+};
+
+/** Available only in secure contexts. */
+interface AudioEncoder {
+    readonly encodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: AudioEncoderConfig): void;
+    encode(data: AudioData): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var AudioEncoder: {
+    prototype: AudioEncoder;
+    new(init: AudioEncoderInit): AudioEncoder;
+    isConfigSupported(config: AudioEncoderConfig): Promise<AudioEncoderSupport>;
+};
+
+interface EncodedAudioChunk {
+    readonly byteLength: number;
+    readonly duration: number | null;
+    readonly timestamp: number;
+    readonly type: EncodedAudioChunkType;
+    copyTo(destination: AllowSharedBufferSource): void;
+}
+
+declare var EncodedAudioChunk: {
+    prototype: EncodedAudioChunk;
+    new(init: EncodedAudioChunkInit): EncodedAudioChunk;
+};
+
+interface EncodedVideoChunk {
+    readonly byteLength: number;
+    readonly duration: number | null;
+    readonly timestamp: number;
+    readonly type: EncodedVideoChunkType;
+    copyTo(destination: AllowSharedBufferSource): void;
+}
+
+declare var EncodedVideoChunk: {
+    prototype: EncodedVideoChunk;
+    new(init: EncodedVideoChunkInit): EncodedVideoChunk;
+};
+
+/** Available only in secure contexts. */
+interface ImageDecoder {
+    readonly complete: boolean;
+    readonly completed: Promise<void>;
+    readonly tracks: ImageTrackList;
+    readonly type: string;
+    close(): void;
+    decode(options?: ImageDecodeOptions): Promise<ImageDecodeResult>;
+    reset(): void;
+}
+
+declare var ImageDecoder: {
+    prototype: ImageDecoder;
+    new(init: ImageDecoderInit): ImageDecoder;
+    isTypeSupported(type: string): Promise<boolean>;
+};
+
+interface ImageTrack {
+    readonly animated: boolean;
+    readonly frameCount: number;
+    readonly repetitionCount: number;
+    selected: boolean;
+}
+
+declare var ImageTrack: {
+    prototype: ImageTrack;
+    new(): ImageTrack;
+};
+
+interface ImageTrackList {
+    readonly length: number;
+    readonly ready: Promise<void>;
+    readonly selectedIndex: number;
+    readonly selectedTrack: ImageTrack | null;
+    [index: number]: ImageTrack;
+}
+
+declare var ImageTrackList: {
+    prototype: ImageTrackList;
+    new(): ImageTrackList;
+};
+
+interface VideoColorSpace {
+    readonly fullRange: boolean | null;
+    readonly matrix: VideoMatrixCoefficients | null;
+    readonly primaries: VideoColorPrimaries | null;
+    readonly transfer: VideoTransferCharacteristics | null;
+    toJSON(): VideoColorSpaceInit;
+}
+
+declare var VideoColorSpace: {
+    prototype: VideoColorSpace;
+    new(init?: VideoColorSpaceInit): VideoColorSpace;
+};
+
+/** Available only in secure contexts. */
+interface VideoDecoder {
+    readonly decodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: VideoDecoderConfig): void;
+    decode(chunk: EncodedVideoChunk): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var VideoDecoder: {
+    prototype: VideoDecoder;
+    new(init: VideoDecoderInit): VideoDecoder;
+    isConfigSupported(config: VideoDecoderConfig): Promise<VideoDecoderSupport>;
+};
+
+/** Available only in secure contexts. */
+interface VideoEncoder {
+    readonly encodeQueueSize: number;
+    readonly state: CodecState;
+    close(): void;
+    configure(config: VideoEncoderConfig): void;
+    encode(frame: VideoFrame, options?: VideoEncoderEncodeOptions): void;
+    flush(): Promise<void>;
+    reset(): void;
+}
+
+declare var VideoEncoder: {
+    prototype: VideoEncoder;
+    new(init: VideoEncoderInit): VideoEncoder;
+    isConfigSupported(config: VideoEncoderConfig): Promise<VideoEncoderSupport>;
+};
+
+interface VideoFrame {
+    readonly codedHeight: number;
+    readonly codedRect: DOMRectReadOnly | null;
+    readonly codedWidth: number;
+    readonly colorSpace: VideoColorSpace;
+    readonly displayHeight: number;
+    readonly displayWidth: number;
+    readonly duration: number | null;
+    readonly format: VideoPixelFormat | null;
+    readonly timestamp: number;
+    readonly visibleRect: DOMRectReadOnly | null;
+    allocationSize(options?: VideoFrameCopyToOptions): number;
+    clone(): VideoFrame;
+    close(): void;
+    copyTo(destination: AllowSharedBufferSource, options?: VideoFrameCopyToOptions): Promise<PlaneLayout[]>;
+}
+
+declare var VideoFrame: {
+    prototype: VideoFrame;
+    new(source: CanvasImageSource, init?: VideoFrameInit): VideoFrame;
+    new(data: AllowSharedBufferSource, init: VideoFrameBufferInit): VideoFrame;
+};
+
+interface AudioDataOutputCallback {
+    (output: AudioData): void;
+}
+
+interface EncodedAudioChunkOutputCallback {
+    (output: EncodedAudioChunk, metadata: EncodedAudioChunkMetadata): void;
+}
+
+interface EncodedVideoChunkOutputCallback {
+    (chunk: EncodedVideoChunk, metadata: EncodedVideoChunkMetadata): void;
+}
+
+interface VideoFrameOutputCallback {
+    (output: VideoFrame): void;
+}
+
+interface WebCodecsErrorCallback {
+    (error: DOMException): void;
+}
+
+// type AllowSharedBufferSource = ArrayBuffer | ArrayBufferView;
+// type BitrateMode = "constant" | "variable";
+type ImageBufferSource = ArrayBuffer | ArrayBufferView | ReadableStream;
+// type AlphaOption = "discard" | "keep";
+type AudioSampleFormat = "f32" | "f32-planar" | "s16" | "s16-planar" | "s32" | "s32-planar" | "u8" | "u8-planar";
+// type AvcBitstreamFormat = "annexb" | "avc";
+// type CodecState = "closed" | "configured" | "unconfigured";
+type EncodedAudioChunkType = "delta" | "key";
+// type EncodedVideoChunkType = "delta" | "key";
+type HardwarePreference = "no-preference" | "prefer-hardware" | "prefer-software";
+// type LatencyMode = "quality" | "realtime";
+// type VideoColorPrimaries = "bt470bg" | "bt709" | "smpte170m";
+// type VideoMatrixCoefficients = "bt470bg" | "bt709" | "rgb" | "smpte170m";
+// type VideoPixelFormat = "BGRA" | "BGRX" | "I420" | "I420A" | "I422" | "I444" | "NV12" | "RGBA" | "RGBX";
+// type VideoTransferCharacteristics = "bt709" | "iec61966-2-1" | "smpte170m";

package/types/lark/websocket_channel.d.ts

@@ -34,6 +34,7 @@ export default class WebsocketChannel extends EventBase<CHANNEL_EVENT_TYPE, Chan
     close(): Promise<void>;
     sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
     sendBuffer(data: ArrayBuffer): void;
+    sendKeepAlive(): void;
     isOpen(): boolean;
     private startKeepAlive;
     private stopKeepAlive;

package/types/lark/websocket_proxy.d.ts

@@ -21,6 +21,7 @@ export default class WebsocketProxy extends EventBase<PROXY_EVENT_TYPE, ProxyEve
     private config;
     private connection;
     private keepAliveTimeout;
+    private timerWorker;
     private larksr;
     constructor(config: ProxyConfig, larksr: LarkSR);
     /**
@@ -34,6 +35,7 @@ export default class WebsocketProxy extends EventBase<PROXY_EVENT_TYPE, ProxyEve
     isOpen(): boolean;
     sendMsg(msg: Msg.CloudLark.ToServerMessage): void;
     sendBuffer(data: ArrayBuffer): void;
+    sendKeepAlive(): void;
     private startKeepAlive;
     private stopKeepAlive;
     /**

package/types/larksr.d.ts

@@ -385,10 +385,10 @@ interface ILarkSRConfig {
     mobileForceLandscape?: boolean;
     /**
      * 可选项
-     * 初始化鼠标模式, true 锁定，false 非锁定
+     * 初始化鼠标模式, 0 自动判断 1 锁定 2 非锁定
      * 对应后台应用管理->应用编辑->通用高级设置->初始化鼠标模式,该配置优先级高于后台配置
      */
-    initCursorMode?: boolean;
+    initCursorMode?: number;
     /**
      * 可选项
      * 渲染服务器外网端口映射
@@ -435,10 +435,11 @@ interface ILarkSRConfig {
     /**
      * 可选项
      * 触摸指令，移动端的触摸指令对应为云端的触屏还是鼠标
-     * 'touchScreen' | 'mouse'
+     * 'touchScreen' | 'mouse' | 'mix'
+     * mix 客户端触摸指令同时对应为触摸和鼠标指令发送给云端
      * 触摸指令模式，对应后台应用管理->应用编辑->移动端高级设置->触摸指令模式 优先级高于后台配置
      */
-    touchOperateMode?: 'touchScreen' | 'mouse';
+    touchOperateMode?: 'touchScreen' | 'mouse' | 'mix';
     /**
      * 可选项
      * 优先使用渲染服务器点对点连接外网ip
@@ -495,6 +496,10 @@ interface ILarkSRConfig {
      * 此处配置优先级大于管理后台配置
      */
     initResolutionType?: number;
+    /**
+     * 是否使用 webcodec
+     */
+    useWebcodec?: boolean;
 }
 declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     /**
@@ -644,10 +649,12 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     isTaskOwner(): boolean;
     _isTaskOwner: boolean;
     /**
-     * true：锁定模式 false：非锁定模式
+     * 0: 自动判断
+     * 1：锁定模式
+     * 2: 非锁定模式
      */
-    set initCursorMode(mode: boolean);
-    get initCursorMode(): boolean;
+    set initCursorMode(mode: number);
+    get initCursorMode(): number;
     /**
      * 当前打开的音频设备 ID，如果打开时没指定为空
      */
@@ -823,6 +830,10 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
      * @returns 是否成功。主要校验授权码是否成功
      */
     start(): Promise<void>;
+    /**
+     * 主动调用发送心跳包
+     */
+    sendKeepAlive(): void;
     /**
      * 重新开始云渲染流程
      */
@@ -1298,6 +1309,7 @@ declare class LarkSR extends EventBase<LarkSRClientEvent, LarkSREvent> {
     private onRTCRetrySuccess;
     private onGotRemoteStream;
     private onGotRemoteAudioStream;
+    private onMediaPlayed;
     private onCursorStyle;
     private onAppResize;
     private onAppMouseMode;