agora-electron-sdk 4.1.1-rc.1 → 4.2.0-dev.13

package/js/Renderer/RendererManager.js

@@ -1,392 +1,479 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RendererManager = void 0;
-const AgoraBase_1 = require("../Private/AgoraBase");
-const AgoraMediaBase_1 = require("../Private/AgoraMediaBase");
-const Types_1 = require("../Types");
-const Utils_1 = require("../Utils");
-const GlRenderer_1 = __importDefault(require("./GlRenderer"));
-const YUVCanvasRenderer_1 = require("./YUVCanvasRenderer");
-/**
- * @ignore
- */
-class RendererManager {
-    /**
-     * @ignore
-     */
-    constructor() {
-        /**
-         * @ignore
-         */
-        this.isRendering = false;
-        this.renderFps = 10;
-        this.renderers = new Map();
-        this.renderMode = this.checkWebglEnv()
-            ? Types_1.RENDER_MODE.WEBGL
-            : Types_1.RENDER_MODE.SOFTWARE;
-        this.msgBridge = Utils_1.AgoraEnv.AgoraElectronBridge;
-    }
-    /**
-     * Registers an audio frame observer object.
-     *
-     * @param mode The use mode of the audio frame. See RawAudioFrameOpModeType .
-     */
-    setRenderMode(mode) {
-        this.renderMode = mode;
-        (0, Utils_1.logInfo)('setRenderMode:  new render mode will take effect only if new view bind to render');
-    }
-    /**
-     * @ignore
-     */
-    setFPS(fps) {
-        this.renderFps = fps;
-        this.restartRender();
-    }
-    setRenderOption(view, contentMode = AgoraMediaBase_1.RenderModeType.RenderModeFit, mirror = false) {
-        if (!view) {
-            /**
-             * @ignore
-             */
-            (0, Utils_1.logError)('setRenderOption: view not exist', view);
-        }
-        this.forEachStream(({ renders }) => {
-            renders === null || renders === void 0 ? void 0 : renders.forEach((render) => {
-                if (render.equalsElement(view)) {
-                    render.setRenderOption({ contentMode, mirror });
-                }
-            });
-        });
-    }
-    setRenderOptionByConfig(rendererConfig) {
-        const { uid, channelId, rendererOptions, videoSourceType, } = 
-        /**
-         * @ignore
-         */
-        (0, Utils_1.getDefaultRendererVideoConfig)(rendererConfig);
-        if (!rendererConfig.view) {
-            (0, Utils_1.logError)('setRenderOptionByView: view not exist');
-            return -1;
-        }
-        const renderList = this.getRenderers({ uid, channelId, videoSourceType });
-        renderList
-            ? renderList
-                .filter((renderItem) => renderItem.equalsElement(rendererConfig.view))
-                .forEach((renderItem) => renderItem.setRenderOption(rendererOptions))
-            : (0, Utils_1.logWarn)(`RenderStreamType: ${videoSourceType} channelId:${channelId} uid:${uid} have no render view, you need to call this api after setView`);
-        return 0;
-    }
-    checkWebglEnv() {
-        let gl;
-        const canvas = document.createElement('canvas');
-        try {
-            gl =
-                canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
-            /**
-             * @ignore
-             */
-            (0, Utils_1.logInfo)('Your browser support webGL');
-        }
-        catch (e) {
-            (0, Utils_1.logWarn)('Your browser may not support webGL');
-            return false;
-        }
-        if (gl) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    setupVideo(rendererVideoConfig) {
-        const formatConfig = (0, Utils_1.getDefaultRendererVideoConfig)(rendererVideoConfig);
-        const { uid, channelId, videoSourceType, rendererOptions, view } = formatConfig;
-        if (!formatConfig.view) {
-            (0, Utils_1.logWarn)('setupVideo->destroyRenderersByConfig, because of view is null');
-            AgoraRendererManager.destroyRenderersByConfig(videoSourceType, channelId, uid);
-            return -1;
-        }
-        // ensure a render to RenderMap
-        const render = this.bindHTMLElementToRender(formatConfig, view);
-        // render config
-        render.setRenderOption(rendererOptions);
-        // enable iris videoFrame
-        this.enableVideoFrameCache({
-            uid,
-            channelId,
-            videoSourceType,
-        });
-        // enable render
-        this.enableRender(true);
-        return 0;
-    }
-    setupLocalVideo(rendererConfig) {
-        const { videoSourceType } = rendererConfig;
-        if (videoSourceType === AgoraBase_1.VideoSourceType.VideoSourceRemote) {
-            (0, Utils_1.logError)('setupLocalVideo videoSourceType error', videoSourceType);
-            return -1;
-        }
-        this.setupVideo(Object.assign({}, rendererConfig));
-        return 0;
-    }
-    setupRemoteVideo(rendererConfig) {
-        const { videoSourceType } = rendererConfig;
-        if (videoSourceType !== AgoraBase_1.VideoSourceType.VideoSourceRemote) {
-            (0, Utils_1.logError)('setupRemoteVideo videoSourceType error', videoSourceType);
-            return -1;
-        }
-        this.setupVideo(Object.assign(Object.assign({}, rendererConfig), { videoSourceType: AgoraBase_1.VideoSourceType.VideoSourceRemote }));
-        return 0;
-    }
-    destroyRendererByView(view) {
-        const renders = this.renderers;
-        renders.forEach((channelMap, videoSourceType) => {
-            channelMap.forEach((uidMap, channelId) => {
-                uidMap.forEach((renderConfig, uid) => {
-                    var _a;
-                    let hasRender = false;
-                    const remainRenders = (_a = renderConfig.renders) === null || _a === void 0 ? void 0 : _a.filter((render) => {
-                        const isFilter = render.equalsElement(view);
-                        if (isFilter) {
-                            hasRender = true;
-                            render.unbind();
-                        }
-                        return !isFilter;
-                    });
-                    if (!hasRender) {
-                        return;
-                    }
-                    if ((remainRenders === null || remainRenders === void 0 ? void 0 : remainRenders.length) === 0 || !remainRenders) {
-                        this.disableVideoFrameCache({ uid, channelId, videoSourceType });
-                    }
-                    renderConfig.renders = remainRenders;
-                });
-            });
-        });
-    }
-    destroyRenderersByConfig(videoSourceType, channelId, uid) {
-        var _a, _b;
-        const config = (0, Utils_1.formatConfigByVideoSourceType)(videoSourceType, channelId, uid);
-        videoSourceType = config.videoSourceType;
-        channelId = config.channelId;
-        uid = config.uid;
-        this.disableVideoFrameCache(config);
-        const uidMap = (_a = this.renderers.get(videoSourceType)) === null || _a === void 0 ? void 0 : _a.get(channelId);
-        const renderMap = uidMap === null || uidMap === void 0 ? void 0 : uidMap.get(uid);
-        if (!renderMap) {
-            return;
-        }
-        (_b = renderMap.renders) === null || _b === void 0 ? void 0 : _b.forEach((renderItem) => {
-            renderItem.unbind();
-        });
-        renderMap.renders = [];
-    }
-    removeAllRenderer() {
-        const renderMap = this.forEachStream((renderConfig, videoFrameCacheConfig) => {
-            var _a;
-            this.disableVideoFrameCache(videoFrameCacheConfig);
-            (_a = renderConfig.renders) === null || _a === void 0 ? void 0 : _a.forEach((renderItem) => {
-                renderItem.unbind();
-            });
-            renderConfig.renders = [];
-        });
-        renderMap.clear();
-    }
-    clear() {
-        this.stopRender();
-        this.removeAllRenderer();
-    }
-    enableRender(enabled = true) {
-        if (enabled && this.isRendering) {
-            //is already _isRendering
-        }
-        else if (enabled && !this.isRendering) {
-            this.startRenderer();
-        }
-        else {
-            this.stopRender();
-        }
-    }
-    startRenderer() {
-        this.isRendering = true;
-        const renderFunc = (rendererItem, { videoSourceType, channelId, uid }) => {
-            const { renders } = rendererItem;
-            if (!renders || (renders === null || renders === void 0 ? void 0 : renders.length) === 0) {
-                return;
-            }
-            let finalResult = this.msgBridge.GetVideoFrame(rendererItem.shareVideoFrame);
-            switch (finalResult.ret) {
-                case 0:
-                    // IRIS_VIDEO_PROCESS_ERR::ERR_OK = 0,
-                    // everything is ok
-                    break;
-                case 1:
-                    // IRIS_VIDEO_PROCESS_ERR::ERR_NULL_POINTER = 1,
-                    break;
-                case 2: {
-                    // IRIS_VIDEO_PROCESS_ERR::ERR_SIZE_NOT_MATCHING
-                    const { width, height } = finalResult;
-                    const newShareVideoFrame = this.resizeShareVideoFrame(videoSourceType, channelId, uid, width, height);
-                    rendererItem.shareVideoFrame = newShareVideoFrame;
-                    finalResult = this.msgBridge.GetVideoFrame(newShareVideoFrame);
-                    break;
-                }
-                case 5:
-                    // IRIS_VIDEO_PROCESS_ERR::ERR_BUFFER_EMPTY
-                    // setupVideo/AgoraView render before initialize
-                    this.enableVideoFrameCache({ videoSourceType, channelId, uid });
-                    return;
-                default:
-                    return;
-            }
-            if (finalResult.ret !== 0) {
-                (0, Utils_1.logWarn)('GetVideoFrame ret is', finalResult.ret, rendererItem);
-                return;
-            }
-            if (!finalResult.isNewFrame) {
-                (0, Utils_1.logDebug)('GetVideoFrame isNewFrame is false', rendererItem);
-                return;
-            }
-            const renderVideoFrame = rendererItem.shareVideoFrame;
-            if (renderVideoFrame.width > 0 && renderVideoFrame.height > 0) {
-                renders.forEach((renderItem) => {
-                    renderItem.drawFrame(rendererItem.shareVideoFrame);
-                });
-            }
-        };
-        this.videoFrameUpdateInterval = setInterval(() => {
-            this.forEachStream(renderFunc);
-        }, 1000 / this.renderFps);
-    }
-    stopRender() {
-        this.isRendering = false;
-        if (this.videoFrameUpdateInterval) {
-            clearInterval(this.videoFrameUpdateInterval);
-            this.videoFrameUpdateInterval = undefined;
-        }
-    }
-    restartRender() {
-        if (this.videoFrameUpdateInterval) {
-            this.stopRender();
-            this.startRenderer();
-            (0, Utils_1.logInfo)(`restartRender: Fps: ${this.renderFps} restartInterval`);
-        }
-    }
-    createRenderer(failCallback) {
-        if (this.renderMode === Types_1.RENDER_MODE.SOFTWARE) {
-            return new YUVCanvasRenderer_1.YUVCanvasRenderer();
-        }
-        else {
-            return new GlRenderer_1.default(failCallback);
-        }
-    }
-    getRender({ videoSourceType, channelId, uid, }) {
-        var _a, _b;
-        return (_b = (_a = this.renderers.get(videoSourceType)) === null || _a === void 0 ? void 0 : _a.get(channelId)) === null || _b === void 0 ? void 0 : _b.get(uid);
-    }
-    getRenderers({ videoSourceType, channelId, uid, }) {
-        var _a, _b, _c;
-        return (((_c = (_b = (_a = this.renderers.get(videoSourceType)) === null || _a === void 0 ? void 0 : _a.get(channelId)) === null || _b === void 0 ? void 0 : _b.get(uid)) === null || _c === void 0 ? void 0 : _c.renders) ||
-            []);
-    }
-    bindHTMLElementToRender(config, view) {
-        this.ensureRendererConfig(config);
-        const renders = this.getRenderers(config);
-        const filterRenders = (renders === null || renders === void 0 ? void 0 : renders.filter((render) => render.equalsElement(view))) || [];
-        const hasBeenAdd = filterRenders.length > 0;
-        if (hasBeenAdd) {
-            (0, Utils_1.logWarn)('bindHTMLElementToRender: this view has bind to render', filterRenders);
-            return filterRenders[0];
-        }
-        const renderer = this.createRenderer(() => {
-            const renderConfig = this.getRender(config);
-            if (!renderConfig) {
-                return;
-            }
-            renderConfig.renders = renders.filter((r) => r !== renderer);
-            const contentMode = renderer.contentMode;
-            renderer.unbind();
-            this.setRenderMode(Types_1.RENDER_MODE.SOFTWARE);
-            const newRender = this.createRenderer();
-            newRender.contentMode = contentMode;
-            newRender.bind(view);
-            renderConfig.renders.push(newRender);
-        });
-        renderer.bind(view);
-        renders.push(renderer);
-        return renderer;
-    }
-    forEachStream(callbackfn) {
-        const renders = this.renderers;
-        renders.forEach((channelMap, videoSourceType) => {
-            channelMap.forEach((uidMap, channelId) => {
-                uidMap.forEach((renderConfig, uid) => {
-                    callbackfn(renderConfig, { videoSourceType, channelId, uid }, { channelMap, uidMap });
-                });
-            });
-        });
-        return renders;
-    }
-    enableVideoFrameCache(videoFrameCacheConfig) {
-        (0, Utils_1.logDebug)(`enableVideoFrameCache ${JSON.stringify(videoFrameCacheConfig)}`);
-        this.msgBridge.EnableVideoFrameCache(videoFrameCacheConfig);
-    }
-    disableVideoFrameCache(videoFrameCacheConfig) {
-        (0, Utils_1.logDebug)(`disableVideoFrameCache ${JSON.stringify(videoFrameCacheConfig)}`);
-        this.msgBridge.DisableVideoFrameCache(videoFrameCacheConfig);
-    }
-    ensureRendererConfig(config) {
-        const { videoSourceType, uid, channelId } = config;
-        const emptyRenderConfig = {
-            renders: [],
-            shareVideoFrame: this.resizeShareVideoFrame(videoSourceType, channelId, uid),
-        };
-        const emptyUidMap = new Map([[uid, emptyRenderConfig]]);
-        const emptyChannelMap = new Map([[channelId, emptyUidMap]]);
-        const renderers = this.renderers;
-        const videoSourceMap = renderers.get(videoSourceType);
-        if (!videoSourceMap) {
-            renderers.set(videoSourceType, emptyChannelMap);
-            return emptyUidMap;
-        }
-        const channelMap = videoSourceMap.get(channelId);
-        if (!channelMap) {
-            videoSourceMap.set(channelId, emptyUidMap);
-            return emptyUidMap;
-        }
-        const renderConfig = channelMap === null || channelMap === void 0 ? void 0 : channelMap.get(uid);
-        if (!renderConfig) {
-            channelMap === null || channelMap === void 0 ? void 0 : channelMap.set(uid, emptyRenderConfig);
-            (0, Utils_1.logWarn)(`ensureRendererMap uid map for channelId:${channelId}  uid:${uid}`);
-            return emptyUidMap;
-        }
-        return channelMap;
-    }
-    resizeShareVideoFrame(videoSourceType, channelId, uid, width = 0, height = 0) {
-        return {
-            videoSourceType,
-            channelId,
-            uid,
-            yBuffer: Buffer.alloc(width * height),
-            uBuffer: Buffer.alloc((width * height) / 4),
-            vBuffer: Buffer.alloc((width * height) / 4),
-            width,
-            height,
-        };
-    }
-    updateVideoFrameCacheInMap(config, shareVideoFrame) {
-        let rendererConfigMap = this.ensureRendererConfig(config);
-        rendererConfigMap
-            ? // @ts-ignore
-                Object.assign(rendererConfigMap.get(config.uid), {
-                    shareVideoFrame,
-                })
-            : (0, Utils_1.logWarn)(`updateVideoFrameCacheInMap videoSourceType:${config.videoSourceType} channelId:${config.channelId} uid:${config.uid} rendererConfigMap is null`);
-    }
-}
-exports.RendererManager = RendererManager;
-const AgoraRendererManager = new RendererManager();
-Utils_1.AgoraEnv.AgoraRendererManager = AgoraRendererManager;
-exports.default = AgoraRendererManager;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RendererManager = void 0;
+const AgoraBase_1 = require("../Private/AgoraBase");
+const AgoraMediaBase_1 = require("../Private/AgoraMediaBase");
+const Types_1 = require("../Types");
+const Utils_1 = require("../Utils");
+const IRendererManager_1 = require("./IRendererManager");
+const WebGLRenderer_1 = __importDefault(require("./WebGLRenderer"));
+const YUVCanvasRenderer_1 = require("./YUVCanvasRenderer");
+/**
+ * @ignore
+ */
+class RendererManager extends IRendererManager_1.IRendererManager {
+    /**
+     * @ignore
+     */
+    isRendering = false;
+    renderFps;
+    /**
+     * @ignore
+     */
+    videoFrameUpdateInterval;
+    /**
+     * @ignore
+     */
+    renderers;
+    /**
+     * @ignore
+     */
+    renderMode;
+    /**
+     * @ignore
+     */
+    msgBridge;
+    /**
+     * @ignore
+     */
+    defaultRenderConfig;
+    constructor() {
+        super();
+        this.renderFps = 10;
+        this.renderers = new Map();
+        this.renderMode = this.checkWebglEnv()
+            ? Types_1.RENDER_MODE.WEBGL
+            : Types_1.RENDER_MODE.SOFTWARE;
+        this.msgBridge = Utils_1.AgoraEnv.AgoraElectronBridge;
+        this.defaultRenderConfig = {
+            rendererOptions: {
+                contentMode: AgoraMediaBase_1.RenderModeType.RenderModeFit,
+                mirror: false,
+            },
+        };
+    }
+    /**
+     * Sets the channel mode of the current audio file.
+     * In a stereo music file, the left and right channels can store different audio data. According to your needs, you can set the channel mode to original mode, left channel mode, right channel mode, or mixed channel mode. For example, in the KTV scenario, the left channel of the music file stores the musical accompaniment, and the right channel stores the singing voice. If you only need to listen to the accompaniment, call this method to set the channel mode of the music file to left channel mode; if you need to listen to the accompaniment and the singing voice at the same time, call this method to set the channel mode to mixed channel mode.Call this method after calling open .This method only applies to stereo audio files.
+     *
+     * @param mode The channel mode. See AudioDualMonoMode .
+     *
+     * @returns
+     * 0: Success.< 0: Failure.
+     */
+    setRenderMode(mode) {
+        this.renderMode = mode;
+        (0, Utils_1.logInfo)('setRenderMode:  new render mode will take effect only if new view bind to render');
+    }
+    /**
+     * @ignore
+     */
+    setFPS(fps) {
+        this.renderFps = fps;
+        this.restartRender();
+    }
+    /**
+     * @ignore
+     */
+    setRenderOption(view, contentMode = AgoraMediaBase_1.RenderModeType.RenderModeFit, mirror = false) {
+        if (!view) {
+            (0, Utils_1.logError)('setRenderOption: view not exist', view);
+        }
+        this.forEachStream(({ renders }) => {
+            renders?.forEach((render) => {
+                if (render.equalsElement(view)) {
+                    render.setRenderOption({ contentMode, mirror });
+                }
+            });
+        });
+    }
+    /**
+     * @ignore
+     */
+    setRenderOptionByConfig(rendererConfig) {
+        const { uid, channelId, rendererOptions, videoSourceType, } = (0, Utils_1.getDefaultRendererVideoConfig)(rendererConfig);
+        const renderList = this.getRenderers({ uid, channelId, videoSourceType });
+        renderList
+            ? renderList
+                .filter((renderItem) => {
+                if (rendererConfig.view) {
+                    return renderItem.equalsElement(rendererConfig.view);
+                }
+                else {
+                    return true;
+                }
+            })
+                .forEach((renderItem) => renderItem.setRenderOption(rendererOptions))
+            : (0, Utils_1.logWarn)(`RenderStreamType: ${videoSourceType} channelId:${channelId} uid:${uid} have no render view, you need to call this api after setView`);
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    /**
+     * @ignore
+     */
+    checkWebglEnv() {
+        let gl;
+        let canvas = document.createElement('canvas');
+        try {
+            gl =
+                canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+            (0, Utils_1.logInfo)('Your browser support webGL');
+        }
+        catch (e) {
+            (0, Utils_1.logWarn)('Your browser may not support webGL');
+            return false;
+        }
+        return !!gl;
+    }
+    /**
+     * @ignore
+     */
+    setupVideo(rendererVideoConfig) {
+        const formatConfig = (0, Utils_1.getDefaultRendererVideoConfig)(rendererVideoConfig);
+        const { uid, channelId, videoSourceType, rendererOptions, view } = formatConfig;
+        if (!formatConfig.view) {
+            (0, Utils_1.logWarn)('setupVideo->destroyRenderersByConfig, because of view is null');
+            this.destroyRenderersByConfig(videoSourceType, channelId, uid);
+            return -AgoraBase_1.ErrorCodeType.ErrInvalidArgument;
+        }
+        // ensure a render to RenderMap
+        const render = this.bindHTMLElementToRender(formatConfig, view);
+        // render config
+        render?.setRenderOption(rendererOptions);
+        // enable iris videoFrame
+        this.enableVideoFrameCache({
+            uid,
+            channelId,
+            videoSourceType,
+        });
+        // enable render
+        this.enableRender(true);
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    /**
+     * @ignore
+     */
+    setupLocalVideo(rendererConfig) {
+        const { videoSourceType } = rendererConfig;
+        if (videoSourceType === AgoraMediaBase_1.VideoSourceType.VideoSourceRemote) {
+            (0, Utils_1.logError)('setupLocalVideo videoSourceType error', videoSourceType);
+            return -AgoraBase_1.ErrorCodeType.ErrInvalidArgument;
+        }
+        this.setupVideo({ ...rendererConfig });
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    /**
+     * @ignore
+     */
+    setupRemoteVideo(rendererConfig) {
+        const { videoSourceType } = rendererConfig;
+        if (videoSourceType !== AgoraMediaBase_1.VideoSourceType.VideoSourceRemote) {
+            (0, Utils_1.logError)('setupRemoteVideo videoSourceType error', videoSourceType);
+            return -AgoraBase_1.ErrorCodeType.ErrInvalidArgument;
+        }
+        this.setupVideo({ ...rendererConfig });
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    /**
+     * Destroys a video renderer object.
+     *
+     * @param view The HTMLElement object to be destroyed.
+     */
+    destroyRendererByView(view) {
+        const renders = this.renderers;
+        renders.forEach((channelMap, videoSourceType) => {
+            channelMap.forEach((uidMap, channelId) => {
+                uidMap.forEach((renderConfig, uid) => {
+                    let hasRender = false;
+                    const remainRenders = renderConfig.renders?.filter((render) => {
+                        const isFilter = render.equalsElement(view);
+                        if (isFilter) {
+                            hasRender = true;
+                            render.unbind();
+                        }
+                        return !isFilter;
+                    });
+                    if (!hasRender) {
+                        return;
+                    }
+                    if (remainRenders?.length === 0 || !remainRenders) {
+                        this.disableVideoFrameCache({ uid, channelId, videoSourceType });
+                    }
+                    renderConfig.renders = remainRenders;
+                });
+            });
+        });
+    }
+    /**
+     * @ignore
+     */
+    destroyRenderersByConfig(videoSourceType, channelId, uid) {
+        const config = (0, Utils_1.formatConfigByVideoSourceType)(videoSourceType, channelId, uid);
+        videoSourceType = config.videoSourceType;
+        channelId = config.channelId;
+        uid = config.uid;
+        this.disableVideoFrameCache(config);
+        const uidMap = this.renderers.get(videoSourceType)?.get(channelId);
+        const renderMap = uidMap?.get(uid);
+        if (!renderMap) {
+            return;
+        }
+        renderMap.renders?.forEach((renderItem) => {
+            renderItem.unbind();
+        });
+        renderMap.renders = [];
+    }
+    /**
+     * @ignore
+     */
+    removeAllRenderer() {
+        const renderMap = this.forEachStream((renderConfig, videoFrameCacheConfig) => {
+            this.disableVideoFrameCache(videoFrameCacheConfig);
+            renderConfig.renders?.forEach((renderItem) => {
+                renderItem.unbind();
+            });
+            renderConfig.renders = [];
+        });
+        renderMap.clear();
+    }
+    /**
+     * @ignore
+     */
+    clear() {
+        this.stopRender();
+        this.removeAllRenderer();
+    }
+    /**
+     * Enables/Disables the local video capture.
+     * This method disables or re-enables the local video capture, and does not affect receiving the remote video stream.After calling enableVideo , the local video capture is enabled by default. You can call enableLocalVideo (false) to disable the local video capture. If you want to re-enable the local video capture, call enableLocalVideo(true).After the local video capturer is successfully disabled or re-enabled, the SDK triggers the onRemoteVideoStateChanged callback on the remote client.You can call this method either before or after joining a channel.This method enables the internal engine and is valid after leaving the channel.
+     *
+     * @param enabled Whether to enable the local video capture.true: (Default) Enable the local video capture.false: Disable the local video capture. Once the local video is disabled, the remote users cannot receive the video stream of the local user, while the local user can still receive the video streams of remote users. When set to false, this method does not require a local camera.
+     *
+     * @returns
+     * 0: Success.< 0: Failure.
+     */
+    enableRender(enabled = true) {
+        if (enabled && this.isRendering) {
+            //is already _isRendering
+        }
+        else if (enabled && !this.isRendering) {
+            this.startRenderer();
+        }
+        else {
+            this.stopRender();
+        }
+    }
+    /**
+     * @ignore
+     */
+    startRenderer() {
+        this.isRendering = true;
+        const renderFunc = (rendererItem, { videoSourceType, channelId, uid }) => {
+            const { renders } = rendererItem;
+            if (!renders || renders?.length === 0) {
+                return;
+            }
+            let finalResult = this.msgBridge.GetVideoFrame(rendererItem.shareVideoFrame);
+            switch (finalResult.ret) {
+                case 0:
+                    // GET_VIDEO_FRAME_CACHE_RETURN_TYPE::OK = 0,
+                    // everything is ok
+                    break;
+                case 1: {
+                    // GET_VIDEO_FRAME_CACHE_RETURN_TYPE::RESIZED
+                    const { width, height, yStride } = finalResult;
+                    const newShareVideoFrame = this.resizeShareVideoFrame(videoSourceType, channelId, uid, width, height, yStride);
+                    rendererItem.shareVideoFrame = newShareVideoFrame;
+                    finalResult = this.msgBridge.GetVideoFrame(newShareVideoFrame);
+                    break;
+                }
+                case 2:
+                    // GET_VIDEO_FRAME_CACHE_RETURN_TYPE::NO_CACHE
+                    // setupVideo/AgoraView render before initialize
+                    // this.enableVideoFrameCache({ videoSourceType, channelId, uid });
+                    break;
+                default:
+                    break;
+            }
+            if (finalResult.ret !== 0) {
+                (0, Utils_1.logWarn)('GetVideoFrame ret is', finalResult.ret, rendererItem);
+                return;
+            }
+            if (!finalResult.isNewFrame) {
+                (0, Utils_1.logDebug)('GetVideoFrame isNewFrame is false', rendererItem);
+                return;
+            }
+            const renderVideoFrame = rendererItem.shareVideoFrame;
+            if (renderVideoFrame.width > 0 && renderVideoFrame.height > 0) {
+                renders.forEach((renderItem) => {
+                    renderItem.drawFrame(rendererItem.shareVideoFrame);
+                });
+            }
+        };
+        this.videoFrameUpdateInterval = setInterval(() => {
+            this.forEachStream(renderFunc);
+        }, 1000 / this.renderFps);
+    }
+    /**
+     * @ignore
+     */
+    stopRender() {
+        this.isRendering = false;
+        if (this.videoFrameUpdateInterval) {
+            clearInterval(this.videoFrameUpdateInterval);
+            this.videoFrameUpdateInterval = undefined;
+        }
+    }
+    /**
+     * @ignore
+     */
+    restartRender() {
+        if (this.videoFrameUpdateInterval) {
+            this.stopRender();
+            this.startRenderer();
+            (0, Utils_1.logInfo)(`restartRender: Fps: ${this.renderFps} restartInterval`);
+        }
+    }
+    /**
+     * @ignore
+     */
+    createRenderer(failCallback) {
+        if (this.renderMode === Types_1.RENDER_MODE.SOFTWARE) {
+            return new YUVCanvasRenderer_1.YUVCanvasRenderer();
+        }
+        else {
+            return new WebGLRenderer_1.default(failCallback);
+        }
+    }
+    /**
+     * @ignore
+     */
+    getRender({ videoSourceType, channelId, uid, }) {
+        return this.renderers.get(videoSourceType)?.get(channelId)?.get(uid);
+    }
+    /**
+     * @ignore
+     */
+    getRenderers({ videoSourceType, channelId, uid, }) {
+        return (this.renderers.get(videoSourceType)?.get(channelId)?.get(uid)?.renders ||
+            []);
+    }
+    /**
+     * @ignore
+     */
+    bindHTMLElementToRender(config, view) {
+        this.ensureRendererConfig(config);
+        const renders = this.getRenderers(config);
+        const filterRenders = renders?.filter((render) => render.equalsElement(view)) || [];
+        const hasBeenAdd = filterRenders.length > 0;
+        if (hasBeenAdd) {
+            (0, Utils_1.logWarn)('bindHTMLElementToRender: this view has bind to render', filterRenders);
+            return filterRenders[0];
+        }
+        const renderer = this.createRenderer(() => {
+            const renderConfig = this.getRender(config);
+            if (!renderConfig) {
+                return;
+            }
+            renderConfig.renders = renders.filter((r) => r !== renderer);
+            const contentMode = renderer.contentMode;
+            renderer.unbind();
+            this.setRenderMode(Types_1.RENDER_MODE.SOFTWARE);
+            const newRender = this.createRenderer();
+            newRender.contentMode = contentMode;
+            newRender.bind(view);
+            renderConfig.renders.push(newRender);
+        });
+        renderer.bind(view);
+        renders.push(renderer);
+        return renderer;
+    }
+    /**
+     * @ignore
+     */
+    forEachStream(callbackfn) {
+        const renders = this.renderers;
+        renders.forEach((channelMap, videoSourceType) => {
+            channelMap.forEach((uidMap, channelId) => {
+                uidMap.forEach((renderConfig, uid) => {
+                    callbackfn(renderConfig, { videoSourceType, channelId, uid }, { channelMap, uidMap });
+                });
+            });
+        });
+        return renders;
+    }
+    /**
+     * @ignore
+     */
+    enableVideoFrameCache(videoFrameCacheConfig) {
+        (0, Utils_1.logDebug)(`enableVideoFrameCache ${JSON.stringify(videoFrameCacheConfig)}`);
+        this.msgBridge.EnableVideoFrameCache(videoFrameCacheConfig);
+    }
+    /**
+     * @ignore
+     */
+    disableVideoFrameCache(videoFrameCacheConfig) {
+        (0, Utils_1.logDebug)(`disableVideoFrameCache ${JSON.stringify(videoFrameCacheConfig)}`);
+        this.msgBridge.DisableVideoFrameCache(videoFrameCacheConfig);
+    }
+    /**
+     * @ignore
+     */
+    ensureRendererConfig(config) {
+        const { videoSourceType, uid, channelId } = config;
+        const emptyRenderConfig = {
+            renders: [],
+            shareVideoFrame: this.resizeShareVideoFrame(videoSourceType, channelId, uid),
+        };
+        const emptyUidMap = new Map([[uid, emptyRenderConfig]]);
+        const emptyChannelMap = new Map([[channelId, emptyUidMap]]);
+        const renderers = this.renderers;
+        const videoSourceMap = renderers.get(videoSourceType);
+        if (!videoSourceMap) {
+            renderers.set(videoSourceType, emptyChannelMap);
+            return emptyUidMap;
+        }
+        const channelMap = videoSourceMap.get(channelId);
+        if (!channelMap) {
+            videoSourceMap.set(channelId, emptyUidMap);
+            return emptyUidMap;
+        }
+        const renderConfig = channelMap?.get(uid);
+        if (!renderConfig) {
+            channelMap?.set(uid, emptyRenderConfig);
+            (0, Utils_1.logWarn)(`ensureRendererMap uid map for channelId:${channelId}  uid:${uid}`);
+            return emptyUidMap;
+        }
+        return channelMap;
+    }
+    /**
+     * @ignore
+     */
+    resizeShareVideoFrame(videoSourceType, channelId, uid, width = 0, height = 0, yStride = 0) {
+        return {
+            videoSourceType,
+            channelId,
+            uid,
+            yBuffer: Buffer.alloc(yStride * height),
+            uBuffer: Buffer.alloc((yStride * height) / 4),
+            vBuffer: Buffer.alloc((yStride * height) / 4),
+            width,
+            height,
+            yStride,
+        };
+    }
+    /**
+     * @ignore
+     */
+    updateVideoFrameCacheInMap(config, shareVideoFrame) {
+        let rendererConfigMap = this.ensureRendererConfig(config);
+        rendererConfigMap
+            ? Object.assign(rendererConfigMap.get(config.uid) ?? {}, {
+                shareVideoFrame,
+            })
+            : (0, Utils_1.logWarn)(`updateVideoFrameCacheInMap videoSourceType:${config.videoSourceType} channelId:${config.channelId} uid:${config.uid} rendererConfigMap is null`);
+    }
+}
+exports.RendererManager = RendererManager;