trtc-electron-sdk 11.7.603 → 11.8.112-beta.0

package/liteav/VideoRenderControl/LocalVideoRenderController.d.ts

@@ -0,0 +1,21 @@
+import TRTCCloud from '../trtc';
+declare class LocalVideoRenderController {
+    private logPrefix;
+    private trtcCloud;
+    private currentState;
+    private isExternalRenderEnabled;
+    private isLocalPreviewStarted;
+    private hasLocalPreviewView;
+    private isLocalSharingStarted;
+    private hasLocalSharingView;
+    constructor(trtcCloud: TRTCCloud);
+    startLocalPreview(views: Array<HTMLElement> | HTMLElement | null): void;
+    stopLocalPreview(): void;
+    updateLocalView(views: Array<HTMLElement> | HTMLElement | null): void;
+    startScreenCapture(view?: HTMLElement | null): void;
+    stopScreenCapture(): void;
+    setExternalRenderEnabled(enabled: boolean): void;
+    private update;
+    private calcTargetState;
+}
+export default LocalVideoRenderController;

package/liteav/VideoRenderControl/LocalVideoRenderController.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const type_1 = require("./type");
+const logger_1 = __importDefault(require("../logger"));
+class LocalVideoRenderController {
+    constructor(trtcCloud) {
+        this.logPrefix = '[LocalVideoRenderController]';
+        this.trtcCloud = trtcCloud;
+        this.currentState = type_1.LocalVideoRenderCallbackState.NotListening;
+        this.isExternalRenderEnabled = false;
+        this.isLocalPreviewStarted = false;
+        this.hasLocalPreviewView = false;
+        this.isLocalSharingStarted = false;
+        this.hasLocalSharingView = false;
+    }
+    startLocalPreview(views) {
+        this.isLocalPreviewStarted = true;
+        this.hasLocalPreviewView = views !== null && views !== undefined;
+        if (Array.isArray(views)) {
+            this.hasLocalPreviewView = views.length >= 1;
+        }
+        this.update();
+    }
+    stopLocalPreview() {
+        this.isLocalPreviewStarted = false;
+        this.hasLocalPreviewView = false;
+        this.update();
+    }
+    updateLocalView(views) {
+        this.hasLocalPreviewView = views !== null && views !== undefined;
+        if (Array.isArray(views)) {
+            this.hasLocalPreviewView = views.length >= 1;
+        }
+        this.update();
+    }
+    startScreenCapture(view = null) {
+        this.isLocalSharingStarted = true;
+        this.hasLocalSharingView = view !== null && view !== undefined;
+        this.update();
+    }
+    stopScreenCapture() {
+        this.isLocalSharingStarted = false;
+        this.hasLocalSharingView = false;
+        this.update();
+    }
+    setExternalRenderEnabled(enabled) {
+        this.isExternalRenderEnabled = enabled;
+    }
+    update() {
+        const targetState = this.calcTargetState();
+        if (targetState !== this.currentState) {
+            if (targetState === type_1.LocalVideoRenderCallbackState.NotListening) {
+                logger_1.default.log(`${this.logPrefix}update not listening`);
+                this.trtcCloud.removeLocalVideoRenderCallback();
+            }
+            else {
+                logger_1.default.log(`${this.logPrefix}update listening`);
+                this.trtcCloud.addLocalVideoRenderCallback();
+            }
+            this.currentState = targetState;
+        }
+        else {
+            return;
+        }
+    }
+    calcTargetState() {
+        if (this.isExternalRenderEnabled) {
+            return type_1.LocalVideoRenderCallbackState.Listening;
+        }
+        if (this.isLocalPreviewStarted && this.hasLocalPreviewView) {
+            return type_1.LocalVideoRenderCallbackState.Listening;
+        }
+        if (this.isLocalSharingStarted && this.hasLocalSharingView) {
+            return type_1.LocalVideoRenderCallbackState.Listening;
+        }
+        return type_1.LocalVideoRenderCallbackState.NotListening;
+    }
+}
+exports.default = LocalVideoRenderController;

package/liteav/VideoRenderControl/type.d.ts

@@ -0,0 +1,4 @@
+export declare enum LocalVideoRenderCallbackState {
+    Listening = 1,
+    NotListening = 2
+}

package/liteav/VideoRenderControl/type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalVideoRenderCallbackState = void 0;
+var LocalVideoRenderCallbackState;
+(function (LocalVideoRenderCallbackState) {
+    LocalVideoRenderCallbackState[LocalVideoRenderCallbackState["Listening"] = 1] = "Listening";
+    LocalVideoRenderCallbackState[LocalVideoRenderCallbackState["NotListening"] = 2] = "NotListening";
+})(LocalVideoRenderCallbackState = exports.LocalVideoRenderCallbackState || (exports.LocalVideoRenderCallbackState = {}));

package/liteav/logger.js

@@ -53,7 +53,7 @@ class Logger {
     getTime() {
         const date = new Date();
         return `${date.toLocaleTimeString('en-US', {
-            hour12: false,
+            hourCycle: 'h23',
         })}.${padMs(date.getMilliseconds())}`;
     }
 }

package/liteav/trtc.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { TRTCConfig } from './Renderer/util';
-import { AudioMusicParam, Rect, TRTCAppScene, TRTCAudioEffectParam, TRTCAudioQuality, TRTCBeautyStyle, TRTCDeviceState, TRTCDeviceType, TRTCLogLevel, TRTCRenderParams, TRTCRoleType, TRTCSpeedTestResult, TRTCStatistics, TRTCSwitchRoomParam, TRTCVideoBufferType, TRTCVideoFillMode, TRTCAudioFrame, TRTCVideoPixelFormat, TRTCVideoRotation, TRTCVideoStreamType, TRTCVolumeInfo, TRTCWaterMarkSrcType, TRTCQualityInfo, TRTCPluginType, TRTCPluginInfo, TRTCVideoProcessPluginOptions, TRTCMediaEncryptDecryptPluginOptions, TRTCAudioRecordingParams, TRTCScreenCaptureSourceInfo, TRTCScreenCaptureProperty, TRTCSpeedTestParams, TRTCRecordType, TRTCDeviceInfo, TRTCCameraCaptureParams, TRTCImageBuffer, TRTCInitConfig, TRTCAudioParallelParams, TRTCVoiceReverbType, TRTCMusicPlayObserver } from './trtc_define';
+import { AudioMusicParam, Rect, TRTCAppScene, TRTCAudioEffectParam, TRTCAudioQuality, TRTCBeautyStyle, TRTCDeviceState, TRTCDeviceType, TRTCLogLevel, TRTCRenderParams, TRTCRoleType, TRTCSpeedTestResult, TRTCStatistics, TRTCSwitchRoomParam, TRTCVideoBufferType, TRTCVideoFillMode, TRTCAudioFrame, TRTCVideoPixelFormat, TRTCVideoRotation, TRTCVideoStreamType, TRTCVolumeInfo, TRTCWaterMarkSrcType, TRTCQualityInfo, TRTCPluginType, TRTCPluginInfo, TRTCVideoProcessPluginOptions, TRTCMediaEncryptDecryptPluginOptions, TRTCAudioRecordingParams, TRTCScreenCaptureSourceInfo, TRTCScreenCaptureProperty, TRTCSpeedTestParams, TRTCRecordType, TRTCDeviceInfo, TRTCCameraCaptureParams, TRTCImageBuffer, TRTCInitConfig, TRTCAudioParallelParams, TRTCVoiceReverbType, TRTCMusicPlayObserver, TRTCAudioFrameCallback } from './trtc_define';
 export * from './trtc_define';
 export * from './trtc_code';
 export * from './vod_player';
@@ -40,6 +40,7 @@ declare class TRTCCloud extends EventEmitter {
     private videoProcessBufferType;
     private videoProcessPixelFormat;
     private videoRenderFPS;
+    private localVideoRenderController;
     private localRotation;
     private localMirrorType;
     private remoteMainStreamFillMode;
@@ -1895,6 +1896,51 @@ declare class TRTCCloud extends EventEmitter {
      * @returns {Number} - 时间戳（单位：ms）
      */
     generateCustomPTS(): number;
+    /**
+     * 设置音频数据自定义回调
+     *
+     * 设置该回调之后，SDK 内部会把音频数据（PCM 格式）回调出来，包括：
+     *   {onCapturedAudioFrame}：本地麦克风采集到的音频数据回调
+     * - {onLocalProcessedAudioFrame}：本地采集并经过音频模块前处理后的音频数据回调
+     * - {onPlayAudioFrame}：混音前的每一路远程用户的音频数据
+     * - {onMixedPlayAudioFrame}：将各路音频混合之后并最终要由系统播放出的音频数据回调
+     * - {onMixedAllAudioFrame}：SDK 所有音频混合后的音频数据（包括采集到的和待播放的）
+     *
+     * 注意: 设置回调为空即代表停止自定义音频回调，反之，设置回调不为空则代表启动自定义音频回调。
+     *
+     * @example
+     * import TRTCCloud from 'trtc-electron-sdk';
+     *
+     * const rtcCloud = TRTCCloud.getTRTCShareInstance();
+     *
+     * onCapturedAudioFrame(frame: TRTCAudioFrame) {}
+     * onLocalProcessedAudioFrame(frame: TRTCAudioFrame) {}
+     * onPlayAudioFrame(frame: TRTCAudioFrame, userId: string) {}
+     * onMixedPlayAudioFrame(frame: TRTCAudioFrame) {}
+     * onMixedAllAudioFrame(frame: TRTCAudioFrame) {}
+     *
+     * // 设置音频数据自定义回调
+     * rtcCloud.setAudioFrameCallback({
+     *   onCapturedAudioFrame: onCapturedAudioFrame,
+     *   onLocalProcessedAudioFrame: onLocalProcessedAudioFrame,
+     *   onPlayAudioFrame: onPlayAudioFrame,
+     *   onMixedPlayAudioFrame: onMixedPlayAudioFrame,
+     *   onMixedAllAudioFrame: onMixedAllAudioFrame,
+     * });
+     *
+     * // 取消音频数据自定义回调
+     * rtcCloud.setAudioFrameCallback({
+     *   onCapturedAudioFrame: null,
+     *   onLocalProcessedAudioFrame: null,
+     *   onPlayAudioFrame: null,
+     *   onMixedPlayAudioFrame: null,
+     *   onMixedAllAudioFrame: null,
+     * });
+     *
+     * @param {TRTCAudioFrameCallback} callback - 音频数据自定义回调对象。
+     *
+     */
+    setAudioFrameCallback(callback: TRTCAudioFrameCallback): void;
     /**
      * @private
      * 设置本地视频自定义渲染（Electron 平台下不可用）
@@ -1906,7 +1952,7 @@ declare class TRTCCloud extends EventEmitter {
      * @param {Fuction} callback    自定义渲染回调
      * @return {Number} 0：成功；<0：错误
      */
-    setLocalVideoRenderCallback(pixelFormat: TRTCVideoPixelFormat, bufferType: TRTCVideoBufferType, callback: () => void): 0 | -1;
+    setLocalVideoRenderCallback(pixelFormat: TRTCVideoPixelFormat, bufferType: TRTCVideoBufferType, callback: () => void): number;
     /**
      * @private
      * 设置远端视频自定义渲染（Electron 平台下不可用）
@@ -1921,7 +1967,7 @@ declare class TRTCCloud extends EventEmitter {
      * @param {Function} callback    自定义渲染回调
      * @return {Number} 0：成功；<0：错误
      */
-    setRemoteVideoRenderCallback(userId: string, pixelFormat: TRTCVideoPixelFormat, bufferType: TRTCVideoBufferType, callback: () => void): 0 | -1;
+    setRemoteVideoRenderCallback(userId: string, pixelFormat: TRTCVideoPixelFormat, bufferType: TRTCVideoBufferType, callback: () => void): number;
     /**
      * 发送自定义消息给房间内所有用户
      *
@@ -2359,8 +2405,12 @@ declare class TRTCCloud extends EventEmitter {
      * @param {String} jsonStr - 接口及参数描述的 JSON 字符串
      */
     callExperimentalAPI(jsonStr: string): void;
+    private _localVideoRenderCallback;
     addLocalVideoRenderCallback(): void;
+    removeLocalVideoRenderCallback(): void;
+    private _remoteVideoRenderCallback;
     addRemoteVideoRenderCallback(userId: string): void;
+    removeRemoteVideoRenderCallback(userId: string): void;
     /**
      * 废弃接口：选择绘制的模式 (webgl/yuvcanvs/)
      *

package/liteav/trtc.js

@@ -35,6 +35,7 @@ const YCbCr_1 = __importDefault(require("yuv-canvas/src/YCbCr"));
 const trtc_define_1 = require("./trtc_define");
 const validate_util_1 = require("./validate-util");
 const logger_1 = __importStar(require("./logger"));
+const LocalVideoRenderController_1 = __importDefault(require("./VideoRenderControl/LocalVideoRenderController"));
 const NodeTRTCEngine = require('../build/Release/trtc_electron_sdk.node');
 const pkg = require('../package.json');
 __exportStar(require("./trtc_define"), exports);
@@ -206,6 +207,9 @@ class TRTCCloud extends events_1.EventEmitter {
         this.videoRenderFPS = 15;
         this.setVideoRenderFPS(this.videoRenderFPS);
         this.callExperimentalAPI("{\"api\":\"setCurrentEnvironment\",\"params\" :{\"electron\":true}}");
+        this._localVideoRenderCallback = this._localVideoRenderCallback.bind(this);
+        this._remoteVideoRenderCallback = this._remoteVideoRenderCallback.bind(this);
+        this.localVideoRenderController = new LocalVideoRenderController_1.default(this);
         if (!TRTCCloud.sharedTRTCCloudInstance) {
             TRTCCloud.sharedTRTCCloudInstance = this;
         }
@@ -277,6 +281,7 @@ class TRTCCloud extends events_1.EventEmitter {
     }
     setExternalRenderEnabled(enabled) {
         this.isExternalRenderEnabled = enabled;
+        this.localVideoRenderController.setExternalRenderEnabled(enabled);
         if (this.isExternalRenderEnabled) {
             this.pixelFormat = trtc_define_1.TRTCVideoPixelFormat.TRTCVideoPixelFormat_RGBA32;
             this.pixelLength = 4;
@@ -1792,7 +1797,6 @@ class TRTCCloud extends events_1.EventEmitter {
             this.rtcCloud.setLocalVideoBuffer('', this.localVideoBufferMap.big.buffer, trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeBig, this.localVideoBufferMap.big.width, this.localVideoBufferMap.big.height, this.localVideoBufferMap.big.pixelFormat, this.localVideoBufferMap.big.id);
         }
         this.rtcCloud.startLocalPreview();
-        this.addLocalVideoRenderCallback();
     }
     /**
      * 启动本地摄像头采集和预览
@@ -1817,6 +1821,7 @@ class TRTCCloud extends events_1.EventEmitter {
             else {
                 this._startLocalPreview([]);
             }
+            this.localVideoRenderController.startLocalPreview(views);
         }
         else {
             this.logger.error('startLocalPreview parameter is undefined, it should be Array<HTMLElement>, HTMLElement or null');
@@ -1829,6 +1834,7 @@ class TRTCCloud extends events_1.EventEmitter {
         this.logger.debug(`stopLocalPreview`);
         const key = this._getKey(LOCAL_USER_VIDEO_ID, trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeBig);
         this._destroyRenderer(key, null);
+        this.localVideoRenderController.stopLocalPreview();
         this.rtcCloud.stopLocalPreview();
         if (this.localVideoBufferMap.big.buffer) {
             this.rtcCloud.setLocalVideoBuffer('', this.localVideoBufferMap.big.buffer, trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeBig, 0, 0, this.localVideoBufferMap.big.pixelFormat, this.localVideoBufferMap.big.id);
@@ -1862,6 +1868,7 @@ class TRTCCloud extends events_1.EventEmitter {
             else {
                 this._destroyRenderer(key, null);
             }
+            this.localVideoRenderController.updateLocalView(views);
         }
         else {
             this.logger.error('updateLocalView parameter is undefined, it should be Array<HTMLElement>, HTMLElement or null');
@@ -3142,7 +3149,7 @@ class TRTCCloud extends events_1.EventEmitter {
                 const key = this._getKey(LOCAL_USER_VIDEO_ID, type);
                 this._initRenderer(key, [view]);
             }
-            this.addLocalVideoRenderCallback();
+            this.localVideoRenderController.startScreenCapture(view);
         }
         if (params) {
             this.rtcCloud.startScreenCapture(type, params);
@@ -3169,6 +3176,7 @@ class TRTCCloud extends events_1.EventEmitter {
     stopScreenCapture() {
         const key = this._getKey(LOCAL_USER_VIDEO_ID, this.screenCaptureStreamType);
         this._destroyRenderer(key, null);
+        this.localVideoRenderController.stopScreenCapture();
         this.rtcCloud.stopScreenCapture();
         this.screenCaptureStreamType = trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeSub;
     }
@@ -3387,6 +3395,53 @@ class TRTCCloud extends events_1.EventEmitter {
     generateCustomPTS() {
         return this.rtcCloud.generateCustomPTS();
     }
+    /**
+     * 设置音频数据自定义回调
+     *
+     * 设置该回调之后，SDK 内部会把音频数据（PCM 格式）回调出来，包括：
+     *   {onCapturedAudioFrame}：本地麦克风采集到的音频数据回调
+     * - {onLocalProcessedAudioFrame}：本地采集并经过音频模块前处理后的音频数据回调
+     * - {onPlayAudioFrame}：混音前的每一路远程用户的音频数据
+     * - {onMixedPlayAudioFrame}：将各路音频混合之后并最终要由系统播放出的音频数据回调
+     * - {onMixedAllAudioFrame}：SDK 所有音频混合后的音频数据（包括采集到的和待播放的）
+     *
+     * 注意: 设置回调为空即代表停止自定义音频回调，反之，设置回调不为空则代表启动自定义音频回调。
+     *
+     * @example
+     * import TRTCCloud from 'trtc-electron-sdk';
+     *
+     * const rtcCloud = TRTCCloud.getTRTCShareInstance();
+     *
+     * onCapturedAudioFrame(frame: TRTCAudioFrame) {}
+     * onLocalProcessedAudioFrame(frame: TRTCAudioFrame) {}
+     * onPlayAudioFrame(frame: TRTCAudioFrame, userId: string) {}
+     * onMixedPlayAudioFrame(frame: TRTCAudioFrame) {}
+     * onMixedAllAudioFrame(frame: TRTCAudioFrame) {}
+     *
+     * // 设置音频数据自定义回调
+     * rtcCloud.setAudioFrameCallback({
+     *   onCapturedAudioFrame: onCapturedAudioFrame,
+     *   onLocalProcessedAudioFrame: onLocalProcessedAudioFrame,
+     *   onPlayAudioFrame: onPlayAudioFrame,
+     *   onMixedPlayAudioFrame: onMixedPlayAudioFrame,
+     *   onMixedAllAudioFrame: onMixedAllAudioFrame,
+     * });
+     *
+     * // 取消音频数据自定义回调
+     * rtcCloud.setAudioFrameCallback({
+     *   onCapturedAudioFrame: null,
+     *   onLocalProcessedAudioFrame: null,
+     *   onPlayAudioFrame: null,
+     *   onMixedPlayAudioFrame: null,
+     *   onMixedAllAudioFrame: null,
+     * });
+     *
+     * @param {TRTCAudioFrameCallback} callback - 音频数据自定义回调对象。
+     *
+     */
+    setAudioFrameCallback(callback) {
+        this.rtcCloud.setAudioFrameCallback(callback.onCapturedAudioFrame, callback.onLocalProcessedAudioFrame, callback.onPlayAudioFrame, callback.onMixedPlayAudioFrame, callback.onMixedAllAudioFrame);
+    }
     /**
      * @private
      * 设置本地视频自定义渲染（Electron 平台下不可用）
@@ -4102,56 +4157,67 @@ class TRTCCloud extends events_1.EventEmitter {
     //
     /////////////////////////////////////////////////////////////////////////////////
     ///------------------------内部方法-----------------------------
-    addLocalVideoRenderCallback() {
-        this.rtcCloud.addLocalVideoRenderCallback((args) => {
-            const [id, type, width, height, timestamp, rotation, valid, bufferId] = args;
-            if (this.enableRenderFrame) {
-                if (valid === true) {
-                    if (this.isScreenCapturing
-                        && this.screenCaptureStreamType === type
-                        && this.localVideoBufferMap.sub
-                        && this.localVideoBufferMap.sub.id === bufferId) {
-                        this._onRenderFrame(id, type, width, height, timestamp, rotation, this.localVideoBufferMap.sub.buffer);
-                    }
-                    else if (this.localVideoBufferMap.big.id === bufferId) {
-                        this._onRenderFrame(id, type, width, height, timestamp, rotation, this.localVideoBufferMap.big.buffer);
-                    }
-                    else {
-                        this.logger.log(`${id} ${type} video buffer reallocated`);
-                    }
+    _localVideoRenderCallback(args) {
+        const [id, type, width, height, timestamp, rotation, valid, bufferId] = args;
+        if (this.enableRenderFrame) {
+            if (valid === true) {
+                if (this.isScreenCapturing
+                    && this.screenCaptureStreamType === type
+                    && this.localVideoBufferMap.sub
+                    && this.localVideoBufferMap.sub.id === bufferId) {
+                    this._onRenderFrame(id, type, width, height, timestamp, rotation, this.localVideoBufferMap.sub.buffer);
+                }
+                else if (this.localVideoBufferMap.big.id === bufferId) {
+                    this._onRenderFrame(id, type, width, height, timestamp, rotation, this.localVideoBufferMap.big.buffer);
                 }
                 else {
-                    this.handleVideoSizeChange(id, type, width, height);
+                    this.logger.log(`${id} ${type} video buffer reallocated`);
                 }
             }
-        }, this.pixelFormat);
+            else {
+                this.handleVideoSizeChange(id, type, width, height);
+            }
+        }
     }
-    addRemoteVideoRenderCallback(userId) {
-        this.rtcCloud.addRemoteVideoRenderCallback(userId, (args) => {
-            const [id, type, width, height, timestamp, rotation, valid, bufferId] = args;
-            if (this.enableRenderFrame) {
-                if (valid === true) {
-                    const remoteUserVideoBuffers = this.remoteVideoBufferMap.get(id);
-                    if (remoteUserVideoBuffers) {
-                        if (type === trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeBig && remoteUserVideoBuffers.big && remoteUserVideoBuffers.big.id === bufferId) {
-                            this._onRenderFrame(id, type, width, height, timestamp, rotation, remoteUserVideoBuffers.big.buffer);
-                        }
-                        else if (type === trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeSmall && remoteUserVideoBuffers.small && remoteUserVideoBuffers.small.id === bufferId) {
-                            this._onRenderFrame(id, type, width, height, timestamp, rotation, remoteUserVideoBuffers.small.buffer);
-                        }
-                        else if (type === trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeSub && remoteUserVideoBuffers.sub && remoteUserVideoBuffers.sub.id === bufferId) {
-                            this._onRenderFrame(id, type, width, height, timestamp, rotation, remoteUserVideoBuffers.sub.buffer);
-                        }
+    addLocalVideoRenderCallback() {
+        this.rtcCloud.addLocalVideoRenderCallback(this._localVideoRenderCallback, this.pixelFormat);
+    }
+    removeLocalVideoRenderCallback() {
+        this.rtcCloud.removeLocalVideoRenderCallback();
+    }
+    _remoteVideoRenderCallback(args) {
+        const [id, type, width, height, timestamp, rotation, valid, bufferId] = args;
+        if (this.enableRenderFrame) {
+            if (valid === true) {
+                const remoteUserVideoBuffers = this.remoteVideoBufferMap.get(id);
+                if (remoteUserVideoBuffers) {
+                    if (type === trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeBig && remoteUserVideoBuffers.big && remoteUserVideoBuffers.big.id === bufferId) {
+                        this._onRenderFrame(id, type, width, height, timestamp, rotation, remoteUserVideoBuffers.big.buffer);
+                    }
+                    else if (type === trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeSmall && remoteUserVideoBuffers.small && remoteUserVideoBuffers.small.id === bufferId) {
+                        this._onRenderFrame(id, type, width, height, timestamp, rotation, remoteUserVideoBuffers.small.buffer);
+                    }
+                    else if (type === trtc_define_1.TRTCVideoStreamType.TRTCVideoStreamTypeSub && remoteUserVideoBuffers.sub && remoteUserVideoBuffers.sub.id === bufferId) {
+                        this._onRenderFrame(id, type, width, height, timestamp, rotation, remoteUserVideoBuffers.sub.buffer);
                     }
                     else {
                         this.logger.log(`${id} ${type} video buffer reallocated`);
                     }
                 }
                 else {
-                    this.handleVideoSizeChange(id, type, width, height);
+                    this.logger.warn(`no remote video render for frame:`, args);
                 }
             }
-        }, this.pixelFormat);
+            else {
+                this.handleVideoSizeChange(id, type, width, height);
+            }
+        }
+    }
+    addRemoteVideoRenderCallback(userId) {
+        this.rtcCloud.addRemoteVideoRenderCallback(userId, this._remoteVideoRenderCallback, this.pixelFormat);
+    }
+    removeRemoteVideoRenderCallback(userId) {
+        this.rtcCloud.removeRemoteVideoRenderCallback(userId);
     }
     //----------------------------------//
     // Render Mode API

package/liteav/trtc_define.d.ts

@@ -438,12 +438,21 @@ export declare class TRTCQualityInfo {
  *
  * @param {String} userId - 说话者的 userId，字符编码格式是 UTF-8
  * @param {Number} volume - 说话者的音量， 取值范围0 - 100
+ * @param {Number} vad - 是否检测到人声，0：非人声 1：人声
+ * @param {Number} pitch - 本地用户的人声频率（单位：Hz），取值范围[0 - 4000]，对于远端用户，该值始终为0。
+ * @param {Float32Array} spectrumData - 音频频谱数据是将音频数据在频率域中的分布，划分为 256 个频率段，使用 spectrumData 记录各个频率段的能量值，每个能量值的取值范围为 [-300, 0]，单位为 dBFS。
+                                        本地频谱使用编码前的音频数据计算，会受到本地采集音量、BGM等影响；远端频谱使用接收到的音频数据计算，本地调整远端播放音量等操作不会对其产生影响。
+ * @param {Number} spectrumDataLength - spectrumDataLength 记录音频频谱数据的长度，为 256。
  *
  */
 export declare class TRTCVolumeInfo {
     userId: string;
     volume: number;
-    constructor(userId?: string, volume?: number);
+    vad: number;
+    pitch: number;
+    spectrumData: Float32Array;
+    spectrumDataLength: number;
+    constructor(userId?: string, volume?: number, vad?: number, pitch?: number, spectrumData?: Float32Array, spectrumDataLength?: number);
 }
 /**
  * 测速参数
@@ -752,10 +761,16 @@ export declare class TRTCLocalStatistics {
  * 远端成员的音视频统计信息
  *
  * @param {String} userId          - 用户 ID，指定是哪个用户的视频流
- * @param {Number} finalLoss       - 该线路的总丢包率（％）
- *                                   这个值越小越好，比如：0%的丢包率代表网络很好。
- *                                   这个丢包率是该线路的 userId 从上行到服务器再到下行的总丢包率。
- *                                   如果 downLoss 为 0%, 但是 finalLoss 不为0%，说明该 userId 在上行就出现了无法恢复的丢包。
+ * @param {Number} audioPacketLoss - 音频流的总丢包率（％）
+ *                                   audioPacketLoss 代表音频流历经`主播>云端>观众`这样一条完整的传输链路后，最终在观众端统计到的丢包率。
+ *                                   audioPacketLoss 越小越好，丢包率为0即表示该路音频流的所有数据均已经完整地到达了观众端。
+ *                                   如果出现了 downLoss == 0 但 audioPacketLoss != 0 的情况，说明该路音频流在“云端=>观众”这一段链路上没有出现丢包，
+ *                                   但是在`主播>云端`这一段链路上出现了不可恢复的丢包。
+ * @param {Number} videoPacketLoss - 该路视频流的总丢包率（％）
+ *                                   videoPacketLoss 代表该路视频流历经`主播>云端>观众`这样一条完整的传输链路后，最终在观众端统计到的丢包率。
+ *                                   videoPacketLoss 越小越好，丢包率为0即表示该路视频流的所有数据均已经完整地到达了观众端。
+ *                                   如果出现了 downLoss == 0 但 videoPacketLoss != 0 的情况，说明该路视频流在`云端>观众`这一段链路上没有出现丢包，
+ *                                   但是在`主播>云端`这一段链路上出现了不可恢复的丢包。
  * @param {Number} width           - 视频宽度
  * @param {Number} height          - 视频高度
  * @param {Number} frameRate       - 接收帧率（fps）
@@ -763,10 +778,21 @@ export declare class TRTCLocalStatistics {
  * @param {Number} audioSampleRate - 音频采样率（Hz）
  * @param {Number} audioBitrate    - 音频码率（Kbps）
  * @param {Number} jitterBufferDelay    - 播放时延（ms）
+ * @param {Number} point2PointDelay     - 端到端延迟（ms）
+ *                                        point2PointDelay 代表 “主播=>云端=>观众” 的延迟，更准确地说，它代表了“采集=>编码=>网络传输=>接收=>缓冲=>解码=>播放” 全链路的延迟。
+ *                                        point2PointDelay 需要本地和远端的 SDK 均为 8.5 及以上的版本才生效，若远端用户为 8.5 以前的版本，此数值会一直为0，代表无意义。
  * @param {Number} audioTotalBlockTime    - 音频播放卡顿累计时长（ms）
  * @param {Number} audioBlockRate    - 音频播放卡顿率，音频卡顿累计时长占音频总播放时长的百分比 (%)
  * @param {Number} videoTotalBlockTime    - 视频播放卡顿累计时长（ms）
  * @param {Number} videoBlockRate    - 视频播放卡顿率，视频卡顿累计时长占音频总播放时长的百分比（%）
+ * @param {Number} finalLoss         - 该线路的总丢包率（％）。已废弃，不推荐使用；建议使用 audioPacketLoss、videoPacketLoss 替代
+ * @param {Number} remoteNetworkUplinkLoss - 该用户从 SDK 到云端的上行丢包率，单位 (%)
+ *                                           该数值越小越好，如果 remoteNetworkUplinkLoss 为 0%，则意味着上行链路的网络质量很好，上传到云端的数据包基本不发生丢失。
+ *                                           如果 remoteNetworkUplinkLoss 为 30%，则意味着 SDK 向云端发送的音视频数据包中，会有 30% 丢失在传输链路中。
+ * @param {Number} remoteNetworkRTT        - 该用户从 SDK 到云端的往返延时，单位 ms
+ *                                           该数值代表从 SDK 发送一个网络包到云端，再从云端回送一个网络包到 SDK 的总计耗时，也就是一个网络包经历 “SDK=>云端=>SDK” 的总耗时。
+ *                                           该数值越小越好：如果 remoteNetworkRTT < 50ms，意味着较低的音视频通话延迟；如果 remoteNetworkRTT > 200ms，则意味着较高的音视频通话延迟。
+ *                                           需要特别解释的是，remoteNetworkRTT 代表 “SDK=>云端=>SDK” 的总耗时，所以不需要区分 remoteNetworkUpRTT 和 remoteNetworkDownRTT
  * @param {TRTCVideoStreamType} streamType - 流类型（大画面 | 小画面 | 辅路画面）
  *
  */
@@ -785,7 +811,12 @@ export declare class TRTCRemoteStatistics {
     videoTotalBlockTime: number;
     videoBlockRate: number;
     streamType: TRTCVideoStreamType;
-    constructor(userId?: string, finalLoss?: number, width?: number, height?: number, frameRate?: number, videoBitrate?: number, audioSampleRate?: number, audioBitrate?: number, jitterBufferDelay?: number, audioTotalBlockTime?: number, audioBlockRate?: number, videoTotalBlockTime?: number, videoBlockRate?: number, streamType?: TRTCVideoStreamType);
+    audioPacketLoss: number;
+    videoPacketLoss: number;
+    point2PointDelay: number;
+    remoteNetworkUplinkLoss: number;
+    remoteNetworkRTT: number;
+    constructor(userId?: string, finalLoss?: number, width?: number, height?: number, frameRate?: number, videoBitrate?: number, audioSampleRate?: number, audioBitrate?: number, jitterBufferDelay?: number, audioTotalBlockTime?: number, audioBlockRate?: number, videoTotalBlockTime?: number, videoBlockRate?: number, streamType?: TRTCVideoStreamType, audioPacketLoss?: number, videoPacketLoss?: number, point2PointDelay?: number, remoteNetworkUplinkLoss?: number, remoteNetworkRTT?: number);
 }
 /**
  * 统计数据
@@ -870,6 +901,42 @@ export declare type TRTCMusicPlayObserver = {
      */
     onComplete: (id: number, errCode: number) => void | null;
 };
+/**
+ * 音频数据自定义回调事件监听器类型定义
+ */
+export declare type TRTCAudioFrameCallback = {
+    /**
+     * 本地采集并经过音频模块前处理后的音频数据回调
+     * @param {TRTCAudioFrame} frame - PCM 格式的音频数据帧(只读)
+     * @returns
+     */
+    onCapturedAudioFrame: (frame: TRTCAudioFrame) => void | null;
+    /**
+     * 本地采集并经过音频模块前处理、音效处理和混 BGM 后的音频数据回调
+     * @param {TRTCAudioFrame} frame - PCM 格式的音频数据帧(只读)
+     * @returns
+     */
+    onLocalProcessedAudioFrame: (frame: TRTCAudioFrame) => void | null;
+    /**
+     * 混音前的每一路远程用户的音频数据
+     * @param {TRTCAudioFrame} frame - PCM 格式的音频数据帧(只读)
+     * @param {String} userId - 用户ID
+     * @returns
+     */
+    onPlayAudioFrame: (frame: TRTCAudioFrame, userId: string) => void | null;
+    /**
+     * 将各路待播放音频混合之后并在最终提交系统播放之前的数据回调
+     * @param {TRTCAudioFrame} frame - PCM 格式的音频数据帧(只读)
+     * @returns
+     */
+    onMixedPlayAudioFrame: (frame: TRTCAudioFrame) => void | null;
+    /**
+     * SDK 所有音频混合后的音频数据（包括采集到的和待播放的）
+     * @param {TRTCAudioFrame} frame - PCM 格式的音频数据帧(只读)
+     * @returns
+     */
+    onMixedAllAudioFrame: (frame: TRTCAudioFrame) => void | null;
+};
 /**
  * 房间切换参数
  *

package/liteav/trtc_define.js

@@ -994,12 +994,21 @@ exports.TRTCQualityInfo = TRTCQualityInfo;
  *
  * @param {String} userId - 说话者的 userId，字符编码格式是 UTF-8
  * @param {Number} volume - 说话者的音量， 取值范围0 - 100
+ * @param {Number} vad - 是否检测到人声，0：非人声 1：人声
+ * @param {Number} pitch - 本地用户的人声频率（单位：Hz），取值范围[0 - 4000]，对于远端用户，该值始终为0。
+ * @param {Float32Array} spectrumData - 音频频谱数据是将音频数据在频率域中的分布，划分为 256 个频率段，使用 spectrumData 记录各个频率段的能量值，每个能量值的取值范围为 [-300, 0]，单位为 dBFS。
+                                        本地频谱使用编码前的音频数据计算，会受到本地采集音量、BGM等影响；远端频谱使用接收到的音频数据计算，本地调整远端播放音量等操作不会对其产生影响。
+ * @param {Number} spectrumDataLength - spectrumDataLength 记录音频频谱数据的长度，为 256。
  *
  */
 class TRTCVolumeInfo {
-    constructor(userId = '', volume = 0) {
+    constructor(userId = '', volume = 0, vad = 0, pitch = 0, spectrumData = new Float32Array(0), spectrumDataLength = 0) {
         this.userId = userId;
         this.volume = volume;
+        this.vad = vad;
+        this.pitch = pitch;
+        this.spectrumData = spectrumData;
+        this.spectrumDataLength = spectrumDataLength;
     }
 }
 exports.TRTCVolumeInfo = TRTCVolumeInfo;
@@ -1457,10 +1466,16 @@ exports.TRTCLocalStatistics = TRTCLocalStatistics;
  * 远端成员的音视频统计信息
  *
  * @param {String} userId          - 用户 ID，指定是哪个用户的视频流
- * @param {Number} finalLoss       - 该线路的总丢包率（％）
- *                                   这个值越小越好，比如：0%的丢包率代表网络很好。
- *                                   这个丢包率是该线路的 userId 从上行到服务器再到下行的总丢包率。
- *                                   如果 downLoss 为 0%, 但是 finalLoss 不为0%，说明该 userId 在上行就出现了无法恢复的丢包。
+ * @param {Number} audioPacketLoss - 音频流的总丢包率（％）
+ *                                   audioPacketLoss 代表音频流历经`主播>云端>观众`这样一条完整的传输链路后，最终在观众端统计到的丢包率。
+ *                                   audioPacketLoss 越小越好，丢包率为0即表示该路音频流的所有数据均已经完整地到达了观众端。
+ *                                   如果出现了 downLoss == 0 但 audioPacketLoss != 0 的情况，说明该路音频流在“云端=>观众”这一段链路上没有出现丢包，
+ *                                   但是在`主播>云端`这一段链路上出现了不可恢复的丢包。
+ * @param {Number} videoPacketLoss - 该路视频流的总丢包率（％）
+ *                                   videoPacketLoss 代表该路视频流历经`主播>云端>观众`这样一条完整的传输链路后，最终在观众端统计到的丢包率。
+ *                                   videoPacketLoss 越小越好，丢包率为0即表示该路视频流的所有数据均已经完整地到达了观众端。
+ *                                   如果出现了 downLoss == 0 但 videoPacketLoss != 0 的情况，说明该路视频流在`云端>观众`这一段链路上没有出现丢包，
+ *                                   但是在`主播>云端`这一段链路上出现了不可恢复的丢包。
  * @param {Number} width           - 视频宽度
  * @param {Number} height          - 视频高度
  * @param {Number} frameRate       - 接收帧率（fps）
@@ -1468,15 +1483,26 @@ exports.TRTCLocalStatistics = TRTCLocalStatistics;
  * @param {Number} audioSampleRate - 音频采样率（Hz）
  * @param {Number} audioBitrate    - 音频码率（Kbps）
  * @param {Number} jitterBufferDelay    - 播放时延（ms）
+ * @param {Number} point2PointDelay     - 端到端延迟（ms）
+ *                                        point2PointDelay 代表 “主播=>云端=>观众” 的延迟，更准确地说，它代表了“采集=>编码=>网络传输=>接收=>缓冲=>解码=>播放” 全链路的延迟。
+ *                                        point2PointDelay 需要本地和远端的 SDK 均为 8.5 及以上的版本才生效，若远端用户为 8.5 以前的版本，此数值会一直为0，代表无意义。
  * @param {Number} audioTotalBlockTime    - 音频播放卡顿累计时长（ms）
  * @param {Number} audioBlockRate    - 音频播放卡顿率，音频卡顿累计时长占音频总播放时长的百分比 (%)
  * @param {Number} videoTotalBlockTime    - 视频播放卡顿累计时长（ms）
  * @param {Number} videoBlockRate    - 视频播放卡顿率，视频卡顿累计时长占音频总播放时长的百分比（%）
+ * @param {Number} finalLoss         - 该线路的总丢包率（％）。已废弃，不推荐使用；建议使用 audioPacketLoss、videoPacketLoss 替代
+ * @param {Number} remoteNetworkUplinkLoss - 该用户从 SDK 到云端的上行丢包率，单位 (%)
+ *                                           该数值越小越好，如果 remoteNetworkUplinkLoss 为 0%，则意味着上行链路的网络质量很好，上传到云端的数据包基本不发生丢失。
+ *                                           如果 remoteNetworkUplinkLoss 为 30%，则意味着 SDK 向云端发送的音视频数据包中，会有 30% 丢失在传输链路中。
+ * @param {Number} remoteNetworkRTT        - 该用户从 SDK 到云端的往返延时，单位 ms
+ *                                           该数值代表从 SDK 发送一个网络包到云端，再从云端回送一个网络包到 SDK 的总计耗时，也就是一个网络包经历 “SDK=>云端=>SDK” 的总耗时。
+ *                                           该数值越小越好：如果 remoteNetworkRTT < 50ms，意味着较低的音视频通话延迟；如果 remoteNetworkRTT > 200ms，则意味着较高的音视频通话延迟。
+ *                                           需要特别解释的是，remoteNetworkRTT 代表 “SDK=>云端=>SDK” 的总耗时，所以不需要区分 remoteNetworkUpRTT 和 remoteNetworkDownRTT
  * @param {TRTCVideoStreamType} streamType - 流类型（大画面 | 小画面 | 辅路画面）
  *
  */
 class TRTCRemoteStatistics {
-    constructor(userId = '', finalLoss = 0, width = 0, height = 0, frameRate = 0, videoBitrate = 0, audioSampleRate = 0, audioBitrate = 0, jitterBufferDelay = 0, audioTotalBlockTime = 0, audioBlockRate = 0, videoTotalBlockTime = 0, videoBlockRate = 0, streamType = TRTCVideoStreamType.TRTCVideoStreamTypeBig) {
+    constructor(userId = '', finalLoss = 0, width = 0, height = 0, frameRate = 0, videoBitrate = 0, audioSampleRate = 0, audioBitrate = 0, jitterBufferDelay = 0, audioTotalBlockTime = 0, audioBlockRate = 0, videoTotalBlockTime = 0, videoBlockRate = 0, streamType = TRTCVideoStreamType.TRTCVideoStreamTypeBig, audioPacketLoss = 0, videoPacketLoss = 0, point2PointDelay = 0, remoteNetworkUplinkLoss = 0, remoteNetworkRTT = 0) {
         this.userId = userId;
         this.finalLoss = finalLoss;
         this.width = width;
@@ -1491,6 +1517,11 @@ class TRTCRemoteStatistics {
         this.videoTotalBlockTime = videoTotalBlockTime;
         this.videoBlockRate = videoBlockRate;
         this.streamType = streamType;
+        this.audioPacketLoss = audioPacketLoss;
+        this.videoPacketLoss = videoPacketLoss;
+        this.point2PointDelay = point2PointDelay;
+        this.remoteNetworkUplinkLoss = remoteNetworkUplinkLoss;
+        this.remoteNetworkRTT = remoteNetworkRTT;
     }
 }
 exports.TRTCRemoteStatistics = TRTCRemoteStatistics;
@@ -1586,6 +1617,17 @@ exports.AudioMusicParam = AudioMusicParam;
  * @property {TRTCMusicEvent~onComplete|null} onComplete - 背景音乐播放完毕事件。
  */
 const TRTCMusicPlayObserver_HACK_JSDOC = null;
+/**
+ * 音频数据自定义回调
+ *
+ * @typedef {Object} TRTCAudioFrameCallback
+ * @property {TRTCAudioFrameCallback~onCapturedAudioFrame|null} onCapturedAudioFrame - 本地采集并经过音频模块前处理后的音频数据回调。
+ * @property {TRTCAudioFrameCallback~onLocalProcessedAudioFrame|null} onLocalProcessedAudioFrame - 本地采集并经过音频模块前处理、音效处理和混 BGM 后的音频数据回调。
+ * @property {TRTCAudioFrameCallback~onPlayAudioFrame|null} onPlayAudioFrame - 混音前的每一路远程用户的音频数据。
+ * @property {TRTCAudioFrameCallback~onMixedPlayAudioFrame|null} onMixedPlayAudioFrame - 将各路待播放音频混合之后并在最终提交系统播放之前的数据回调。
+ * @property {TRTCAudioFrameCallback~onMixedAllAudioFrame|null} onMixedAllAudioFrame - SDK 所有音频混合后的音频数据（包括采集到的和待播放的）。
+ */
+const TRTCAudioFrameCallback_HACK_JSDOC = null;
 /**
  * 房间切换参数
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trtc-electron-sdk",
-  "version": "11.7.603",
+  "version": "11.8.112-beta.0",
   "description": "trtc electron sdk",
   "main": "./liteav/trtc.js",
   "types": "./liteav/trtc.d.ts",