agora-electron-sdk 0.0.0-dev.1

package/js/Decoder/gpu-utils.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGpuInfoInternal = exports.GpuInfo = void 0;
+//@ts-ignore
+const electron_1 = require("electron");
+/**
+ * @ignore
+ */
+class GpuInfo {
+    constructor() {
+        this.videoDecodeAcceleratorSupportedProfile = [];
+    }
+}
+exports.GpuInfo = GpuInfo;
+/**
+ * @ignore
+ */
+const getGpuInfoInternal = (callback) => {
+    //@ts-ignore
+    if (process.type === 'renderer') {
+        console.error('getGpuInfoInternal should be called in main process');
+        return;
+    }
+    const gpuPage = new electron_1.BrowserWindow({
+        show: false,
+        webPreferences: { offscreen: true },
+    });
+    gpuPage.loadURL('chrome://gpu');
+    let executeJavaScriptText = `` +
+        `let videoAccelerationInfo = [];` +
+        `let nodeList = document.querySelector('info-view')?.shadowRoot?.querySelector('#video-acceleration-info info-view-table')?.shadowRoot?.querySelectorAll('#info-view-table info-view-table-row') || [];` +
+        `for (node of nodeList) {` +
+        `  videoAccelerationInfo.push({` +
+        `     title: node.shadowRoot.querySelector('#title')?.innerText,` +
+        `     value: node.shadowRoot.querySelector('#value')?.innerText,` +
+        ` })` +
+        `}` +
+        `JSON.stringify(videoAccelerationInfo)`;
+    gpuPage.webContents
+        .executeJavaScript(executeJavaScriptText)
+        .then((result) => {
+        if (!result) {
+            console.error('Failed to get GPU info, chrome://gpu is not available in this environment.');
+        }
+        let filterResult = JSON.parse(result).filter((item) => {
+            return item.title.indexOf('Decode') !== -1;
+        });
+        let convertResult = [];
+        const resolutionPattern = /(\d+)x(\d+) to (\d+)x(\d+)/;
+        for (const profile of filterResult) {
+            const match = profile.value.match(resolutionPattern);
+            if (!match) {
+                continue;
+            }
+            const [_resolution, minWidth, minHeight, maxWidth, maxHeight] = match;
+            convertResult.push({
+                codec: profile.title,
+                minWidth: minWidth ? Number(minWidth) : 0,
+                maxWidth: maxWidth ? Number(maxWidth) : 0,
+                minHeight: minHeight ? Number(minHeight) : 0,
+                maxHeight: maxHeight ? Number(maxHeight) : 0,
+            });
+        }
+        typeof callback === 'function' && callback(convertResult);
+    })
+        .catch((error) => {
+        console.error('Failed to get GPU info, please import agora-electron-sdk in main process', error);
+        typeof callback === 'function' && callback(error);
+    })
+        .finally(() => {
+        gpuPage.close();
+    });
+};
+exports.getGpuInfoInternal = getGpuInfoInternal;

package/js/Decoder/index.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebCodecsDecoder = void 0;
+const AgoraBase_1 = require("../Private/AgoraBase");
+const Types_1 = require("../Types");
+const Utils_1 = require("../Utils");
+const frameTypeMapping = {
+    [AgoraBase_1.VideoFrameType.VideoFrameTypeDeltaFrame]: 'delta',
+    [AgoraBase_1.VideoFrameType.VideoFrameTypeKeyFrame]: 'key',
+    [AgoraBase_1.VideoFrameType.VideoFrameTypeDroppableFrame]: 'delta', // this is a workaround for the issue that the frameType is not correct
+};
+class WebCodecsDecoder {
+    constructor(renders, onError, context) {
+        this.renderers = [];
+        // eslint-disable-next-line auto-import/auto-import
+        this.pendingFrame = null;
+        this._currentCodecConfig = null;
+        this._base_ts = 0;
+        this._base_ts_ntp = 1;
+        this._last_ts_ntp = 1;
+        this._decode_retry_count = 0;
+        this.renderers = renders;
+        this._cacheContext = context;
+        this._decoder = new VideoDecoder({
+            // @ts-ignore
+            output: this._output.bind(this),
+            error: (e) => {
+                onError(e);
+            },
+        });
+    }
+    // eslint-disable-next-line auto-import/auto-import
+    _output(frame) {
+        // Schedule the frame to be rendered.
+        this._renderFrame(frame);
+    }
+    // eslint-disable-next-line auto-import/auto-import
+    _renderFrame(frame) {
+        if (!this.pendingFrame) {
+            // Schedule rendering in the next animation frame.
+            // eslint-disable-next-line auto-import/auto-import
+            requestAnimationFrame(this.renderAnimationFrame.bind(this));
+        }
+        else {
+            // Close the current pending frame before replacing it.
+            this.pendingFrame.close();
+        }
+        // Set or replace the pending frame.
+        this.pendingFrame = frame;
+    }
+    renderAnimationFrame() {
+        for (let renderer of this.renderers) {
+            if (renderer.rendererType !== Types_1.RendererType.WEBCODECSRENDERER) {
+                continue;
+            }
+            renderer.drawFrame(this.pendingFrame, this._currentCodecConfig);
+            this.pendingFrame = null;
+        }
+    }
+    decoderConfigure(frameInfo) {
+        this.pendingFrame = null;
+        // @ts-ignore
+        let codec = Utils_1.AgoraEnv.CapabilityManager?.frameCodecMapping[frameInfo.codecType]
+            ?.codec;
+        if (!codec) {
+            Utils_1.AgoraEnv.AgoraRendererManager?.handleWebCodecsFallback(this._cacheContext);
+            throw new Error(`codec ${frameInfo.codecType} is not in frameCodecMapping,failed to configure decoder, fallback to native decoder`);
+        }
+        this._currentCodecConfig = {
+            codecType: frameInfo.codecType,
+            codedWidth: frameInfo.width,
+            codedHeight: frameInfo.height,
+            rotation: frameInfo.rotation,
+        };
+        this._decoder.configure({
+            codec: codec,
+            codedWidth: frameInfo.width,
+            codedHeight: frameInfo.height,
+        });
+        (0, Utils_1.logInfo)(`configure decoder: codedWidth: ${frameInfo.width}, codedHeight: ${frameInfo.height},codec: ${codec}`);
+    }
+    updateTimestamps(ts) {
+        if (this._base_ts !== 0) {
+            if (ts > this._base_ts) {
+                this._last_ts_ntp =
+                    this._base_ts_ntp + Math.floor(((ts - this._base_ts) * 1000) / 90);
+            }
+            else {
+                this._base_ts = ts;
+                this._last_ts_ntp++;
+                this._base_ts_ntp = this._last_ts_ntp;
+            }
+        }
+        else {
+            this._base_ts = ts;
+            this._last_ts_ntp = 1;
+        }
+    }
+    handleCodecIsChanged(frameInfo) {
+        if (this._currentCodecConfig?.codecType !== frameInfo.codecType ||
+            this._currentCodecConfig?.codedWidth !== frameInfo.width ||
+            this._currentCodecConfig?.codedHeight !== frameInfo.height ||
+            this._currentCodecConfig?.rotation !== frameInfo.rotation) {
+            (0, Utils_1.logInfo)('frameInfo has changed, reconfigure decoder');
+            this._decoder.reset();
+            this.decoderConfigure(frameInfo);
+        }
+    }
+    // @ts-ignore
+    decodeFrame(imageBuffer, frameInfo, ts) {
+        try {
+            this.handleCodecIsChanged(frameInfo);
+        }
+        catch (error) {
+            (0, Utils_1.logInfo)(error);
+            return;
+        }
+        if (!imageBuffer) {
+            (0, Utils_1.logDebug)('imageBuffer is empty, skip decode frame');
+            return;
+        }
+        let frameType;
+        if (frameInfo.frameType !== undefined) {
+            // @ts-ignore
+            frameType = frameTypeMapping[frameInfo.frameType];
+        }
+        if (!frameType) {
+            (0, Utils_1.logDebug)('frameType is not in frameTypeMapping, skip decode frame');
+            return;
+        }
+        this.updateTimestamps(ts);
+        try {
+            this._decoder.decode(new EncodedVideoChunk({
+                data: imageBuffer,
+                timestamp: this._last_ts_ntp,
+                // @ts-ignore
+                type: frameType,
+                // @ts-ignore
+                transfer: [imageBuffer.buffer],
+            }));
+            this._decode_retry_count = 0;
+        }
+        catch (e) {
+            /// There are some cases that the decoder failed to decode the frame, we will retry for a few times
+            /// If the decoder still failed to decode the frame, we will fallback to native decoder
+            /// The retry count is defined in AgoraEnv.maxDecodeRetryCount
+            /// The retry count will be reset to 0 when the decoder successfully decode a frame
+            if (this._decode_retry_count >= Utils_1.AgoraEnv.maxDecodeRetryCount) {
+                Utils_1.AgoraEnv.AgoraRendererManager?.handleWebCodecsFallback(this._cacheContext);
+                throw new Error(`failed to decode frame over ${this._decode_retry_count} times, fallback to native decoder`);
+            }
+            this._decode_retry_count++;
+        }
+    }
+    reset() {
+        this._base_ts = 0;
+        this._base_ts_ntp = 1;
+        this._last_ts_ntp = 1;
+        this._decoder.reset();
+    }
+    release() {
+        try {
+            if (this.pendingFrame) {
+                this.pendingFrame.close();
+            }
+            this._decoder.close();
+        }
+        catch (e) { }
+        this.pendingFrame = null;
+    }
+}
+exports.WebCodecsDecoder = WebCodecsDecoder;