shengwang-electron-sdk 4.6.2-rc.1

package/ts/Renderer/YUVCanvasRenderer/index.ts

@@ -0,0 +1,80 @@
+import { VideoFrame } from '../../Private/AgoraMediaBase';
+import { RendererContext } from '../../Types';
+import { IRenderer } from '../IRenderer';
+
+const YUVBuffer = require('yuv-buffer');
+const YUVCanvas = require('yuv-canvas');
+
+export class YUVCanvasRenderer extends IRenderer {
+  private frameSink?: any;
+
+  public override bind(context: RendererContext) {
+    super.bind(context);
+    this.frameSink = YUVCanvas.attach(this.canvas, {
+      webGL: false,
+    });
+  }
+
+  public override drawFrame(
+    uid: number,
+    {
+      width,
+      height,
+      yStride,
+      uStride,
+      vStride,
+      yBuffer,
+      uBuffer,
+      vBuffer,
+      rotation,
+      alphaBuffer,
+    }: VideoFrame
+  ) {
+    this.rotateCanvas({ width, height, rotation });
+    this.updateRenderMode();
+
+    if (!this.frameSink) return;
+
+    const frame = YUVBuffer.frame(
+      YUVBuffer.format({
+        width,
+        height,
+        chromaWidth: width! / 2,
+        chromaHeight: height! / 2,
+        cropLeft: yStride! - width!,
+      }),
+      {
+        bytes: yBuffer,
+        stride: yStride,
+      },
+      {
+        bytes: uBuffer,
+        stride: uStride,
+      },
+      {
+        bytes: vBuffer,
+        stride: vStride,
+      }
+    );
+    if (
+      alphaBuffer &&
+      alphaBuffer.length > 0 &&
+      alphaBuffer.length === width! * height!
+    ) {
+      frame.a =
+        alphaBuffer instanceof Uint8Array
+          ? alphaBuffer
+          : new Uint8Array(alphaBuffer);
+    }
+    this.frameSink.drawFrame(frame);
+
+    super.drawFrame(uid);
+  }
+
+  protected override rotateCanvas({ width, height, rotation }: VideoFrame) {
+    super.rotateCanvas({ width, height, rotation });
+
+    if (!this.canvas) return;
+    this.canvas.style.transform += ` rotateZ(${rotation}deg)`;
+  }
+}

package/ts/Renderer/index.ts

@@ -0,0 +1 @@
+export * from './IRenderer';

package/ts/Types.ts

@@ -0,0 +1,254 @@
+import { VideoCanvas, VideoCodecType } from './Private/AgoraBase';
+import { VideoFrame } from './Private/AgoraMediaBase';
+import { RtcConnection } from './Private/IAgoraRtcEngineEx';
+import { CapabilityManager } from './Renderer/CapabilityManager';
+import { RendererCache } from './Renderer/RendererCache';
+import { RendererManager } from './Renderer/RendererManager';
+import { WebCodecsRendererCache } from './Renderer/WebCodecsRendererCache';
+
+/**
+ * @ignore
+ */
+export enum VideoFallbackStrategy {
+  /**
+   * @ignore
+   */
+  PerformancePriority = 0,
+  /**
+   * @ignore
+   */
+  BandwidthPriority = 1,
+}
+
+/**
+ * @ignore
+ */
+export interface AgoraEnvOptions {
+  /**
+   * @ignore
+   */
+  enableLogging?: boolean;
+  /**
+   * @ignore
+   */
+  enableDebugLogging?: boolean;
+  /**
+   * @ignore
+   */
+  webEnvReady?: boolean;
+  /**
+   * @ignore
+   */
+  enableWebCodecsDecoder: boolean;
+  /**
+   * @ignore
+   */
+  videoFallbackStrategy: VideoFallbackStrategy;
+  /**
+   * @ignore
+   */
+  maxDecodeRetryCount: number;
+  /**
+   * @ignore
+   */
+  enableArgusCounters: boolean;
+}
+
+/**
+ * @ignore
+ */
+export interface AgoraEnvType extends AgoraEnvOptions {
+  /**
+   * @ignore
+   */
+  AgoraRendererManager?: RendererManager;
+  /**
+   * @ignore
+   */
+  CapabilityManager?: CapabilityManager;
+}
+
+/**
+ * @ignore
+ */
+export enum RendererType {
+  /**
+   * @ignore
+   */
+  WEBGL = 1,
+  /**
+   * @ignore
+   */
+  SOFTWARE = 2,
+  /**
+   * @ignore
+   */
+  WEBCODECSRENDERER = 3,
+}
+
+export type RENDER_MODE = RendererType;
+
+export type RendererContext = VideoCanvas & RtcConnection;
+export type RendererCacheType = RendererCache | WebCodecsRendererCache;
+
+export type RendererCacheContext = Pick<
+  RendererContext,
+  | 'channelId'
+  | 'localUid'
+  | 'uid'
+  | 'sourceType'
+  | 'useWebCodecsDecoder'
+  | 'enableFps'
+  | 'position'
+  | 'enableAlphaMask'
+>;
+
+/**
+ * @ignore
+ */
+export interface Result {
+  /**
+   * @ignore
+   */
+  callApiReturnCode: number;
+  /**
+   * @ignore
+   */
+  callApiResult: any;
+}
+
+/**
+ * @ignore
+ */
+export interface IAgoraElectronBridge {
+  /**
+   * @ignore
+   */
+  OnEvent(
+    callbackName: string,
+    callback: (
+      event: string,
+      data: string,
+      buffer: Uint8Array[],
+      bufferLength: number[],
+      bufferCount: number
+    ) => void
+  ): void;
+
+  UnEvent(callbackName: string): void;
+
+  CallApi(
+    funcName: string,
+    params: any,
+    buffer?: (Uint8Array | undefined)[],
+    bufferCount?: number
+  ): Result;
+
+  InitializeEnv(): void;
+
+  ReleaseEnv(): void;
+
+  ReleaseRenderer(): void;
+
+  EnableVideoFrameCache(context: RendererCacheContext): void;
+
+  DisableVideoFrameCache(context: RendererCacheContext): void;
+
+  GetBuffer(ptr: number, length: number): Buffer;
+
+  GetVideoFrame(
+    context: RendererCacheContext,
+    videoFrame: VideoFrame,
+    advanceOptions: {
+      renderAlpha: boolean;
+      /**
+       * @ignore
+       */
+    }
+  ): {
+    ret: number;
+    /**
+     * @ignore
+     */
+    hasMoreFrame: boolean;
+  };
+
+  sendMsg: (
+    funcName: string,
+    params: any,
+    buffer?: Uint8Array[],
+    bufferCount?: number
+  ) => Result;
+}
+
+/**
+ * @ignore
+ */
+export enum IPCMessageType {
+  /**
+   * @ignore
+   */
+  AGORA_IPC_GET_GPU_INFO = 'AGORA_IPC_GET_GPU_INFO',
+}
+
+/**
+ * @ignore
+ */
+interface CodecMappingItem {
+  /**
+   * @ignore
+   */
+  codec: string;
+  /**
+   * @ignore
+   */
+  type: VideoCodecType;
+  /**
+   * @ignore
+   */
+  profile: string;
+}
+
+/**
+ * @ignore
+ */
+export const codecMapping: CodecMappingItem[] = [
+  {
+    codec: 'avc1.64e01f',
+    type: VideoCodecType.VideoCodecH264,
+    profile: 'h264',
+  },
+  {
+    codec: 'hvc1.1.6.L5.90',
+    type: VideoCodecType.VideoCodecH265,
+    profile: 'hevc',
+  },
+  { codec: 'vp8', type: VideoCodecType.VideoCodecVp8, profile: 'vp8' },
+  {
+    codec: 'vp09.00.50.08',
+    type: VideoCodecType.VideoCodecVp9,
+    profile: 'vp9',
+  },
+];
+
+/**
+ * @ignore
+ */
+export interface CodecConfigInfo {
+  /**
+   * @ignore
+   */
+  codecType: VideoCodecType | undefined;
+  /**
+   * @ignore
+   */
+  codedWidth: number | undefined;
+  /**
+   * @ignore
+   */
+  codedHeight: number | undefined;
+  /**
+   * @ignore
+   */
+  rotation: number | undefined;
+}

package/ts/Utils.ts

@@ -0,0 +1,198 @@
+import { AgoraEnvType, VideoFallbackStrategy } from './Types';
+
+/**
+ * @ignore
+ */
+export const TAG = '[Agora]: ';
+/**
+ * @ignore
+ */
+export const DEBUG_TAG = '[Agora Debug]: ';
+
+/**
+ * @ignore
+ */
+export function parseIntPtr2Number(value: number | string): number {
+  try {
+    let bigIntVal = BigInt(value);
+    if (bigIntVal > 2n ** 63n - 1n) {
+      bigIntVal -= 2n ** 64n;
+    }
+    return Number(bigIntVal);
+  } catch (e) {
+    return value as number;
+  }
+}
+
+/**
+ * @ignore
+ */
+export const logWarn = (msg: string, ...optParams: any[]) => {
+  if (!AgoraEnv.enableLogging) {
+    return;
+  }
+  console.warn(`${TAG} ${msg}`, ...optParams);
+};
+
+/**
+ * @ignore
+ */
+export const logError = (msg: string, ...optParams: any[]) => {
+  if (!AgoraEnv.enableLogging) {
+    return;
+  }
+  console.error(`${TAG} ${msg}`, ...optParams);
+};
+
+const getCurrentTime = () => {
+  const date = new Date();
+
+  const year = date.getFullYear().toString().slice(-2);
+  const month = (date.getMonth() + 1).toString().padStart(2, '0');
+  const day = date.getDate().toString().padStart(2, '0');
+
+  const hours = date.getHours().toString().padStart(2, '0');
+  const minutes = date.getMinutes().toString().padStart(2, '0');
+  const seconds = date.getSeconds().toString().padStart(2, '0');
+  const milliseconds = date.getMilliseconds().toString().padStart(3, '0');
+
+  return `${month}/${day}/${year} ${hours}:${minutes}:${seconds}:${milliseconds}`;
+};
+
+/**
+ * @ignore
+ */
+export const logInfo = (msg: string, ...optParams: any[]) => {
+  if (!AgoraEnv.enableLogging) {
+    return;
+  }
+  console.info(`[${getCurrentTime()}]${TAG} ${msg}`, ...optParams);
+};
+
+/**
+ * @ignore
+ */
+export const logDebug = (msg: string, ...optParams: any[]) => {
+  if (!AgoraEnv.enableLogging || !AgoraEnv.enableDebugLogging) {
+    return;
+  }
+  console.debug(`${DEBUG_TAG} ${msg}`, ...optParams);
+};
+
+/**
+ * @ignore
+ */
+export const objsKeysToLowerCase = (array: Array<any>) => {
+  array.forEach((obj) => {
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        const element = obj[key];
+        obj[key.toLocaleLowerCase()] = element;
+      }
+    }
+  });
+};
+
+/**
+ * @ignore
+ */
+export function classMix(...mixins: any[]): any {
+  class MixClass {
+    constructor() {
+      for (let mixin of mixins) {
+        copyProperties(this, new mixin()); // Copy instance properties
+      }
+    }
+  }
+
+  for (let mixin of mixins) {
+    copyProperties(MixClass, mixin); // Copy static properties
+    copyProperties(MixClass.prototype, mixin.prototype); // Copy prototype properties
+  }
+
+  return MixClass;
+}
+
+function copyProperties<T>(target: T, source: any) {
+  for (let key of Reflect.ownKeys(source)) {
+    if (key !== 'constructor' && key !== 'prototype' && key !== 'name') {
+      let desc = Object.getOwnPropertyDescriptor(source, key)!;
+      Object.defineProperty(target, key, desc);
+    }
+  }
+}
+
+/**
+ * @ignore
+ */
+export function isSupportWebGL(): boolean {
+  let flag = false;
+  const canvas: HTMLCanvasElement = document.createElement('canvas');
+  try {
+    const getContext = (
+      contextNames = ['webgl2', 'webgl', 'experimental-webgl']
+    ): WebGLRenderingContext | WebGLRenderingContext | null => {
+      for (let i = 0; i < contextNames.length; i++) {
+        const contextName = contextNames[i]!;
+        const context = canvas?.getContext(contextName);
+        if (context) {
+          return context as WebGLRenderingContext | WebGLRenderingContext;
+        }
+      }
+      return null;
+    };
+    let gl = getContext();
+    flag = !!gl;
+    gl?.getExtension('WEBGL_lose_context')?.loseContext();
+    gl = null;
+    logInfo('Your browser support webGL');
+  } catch (e) {
+    logWarn('Your browser may not support webGL');
+    flag = false;
+  }
+  return flag;
+}
+
+/**
+ * @ignore
+ */
+export function getContextByCanvas(
+  // eslint-disable-next-line auto-import/auto-import
+  canvas: OffscreenCanvas,
+  enableAlphaMask: boolean = false
+): WebGLRenderingContext | WebGL2RenderingContext | null {
+  const contextNames = ['webgl2', 'webgl', 'experimental-webgl'];
+
+  for (const contextName of contextNames) {
+    //@ts-ignore
+    const context = canvas.getContext(contextName, {
+      depth: true,
+      stencil: true,
+      alpha: enableAlphaMask,
+      antialias: false,
+      premultipliedAlpha: true,
+      preserveDrawingBuffer: !enableAlphaMask,
+      powerPreference: 'default',
+      failIfMajorPerformanceCaveat: false,
+    }) as WebGLRenderingContext | WebGL2RenderingContext | null;
+
+    if (context) {
+      return context;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * @ignore
+ */
+export const AgoraEnv: AgoraEnvType = {
+  enableLogging: true,
+  enableDebugLogging: false,
+  webEnvReady: true,
+  enableWebCodecsDecoder: false,
+  videoFallbackStrategy: VideoFallbackStrategy.PerformancePriority,
+  maxDecodeRetryCount: 50,
+  enableArgusCounters: true,
+};

package/types/AgoraSdk.d.ts

@@ -0,0 +1,30 @@
+import { IMediaPlayerCacheManager } from './Private/IAgoraMediaPlayer';
+import { IRtcEngineEx } from './Private/IAgoraRtcEngineEx';
+import { AgoraEnvOptions } from './Types';
+export * from './Private/AgoraBase';
+export * from './Private/AgoraMediaBase';
+export * from './Private/AgoraMediaPlayerTypes';
+export * from './Private/IAgoraLog';
+export * from './Private/IAgoraMediaEngine';
+export * from './Private/IAgoraMediaPlayer';
+export * from './Private/IAgoraMediaPlayerSource';
+export * from './Private/IAgoraMediaRecorder';
+export * from './Private/IAgoraMusicContentCenter';
+export * from './Private/IAgoraRhythmPlayer';
+export * from './Private/IAgoraRtcEngine';
+export * from './Private/IAgoraRtcEngineEx';
+export * from './Private/IAgoraSpatialAudio';
+export * from './Private/IAudioDeviceManager';
+export * from './Renderer';
+export * from './Types';
+export * from './Utils';
+/**
+ * @ignore
+ */
+export declare function createAgoraRtcEngine(options?: AgoraEnvOptions): IRtcEngineEx;
+/**
+ * @ignore
+ */
+export declare function getMediaPlayerCacheManager(): IMediaPlayerCacheManager;
+export default createAgoraRtcEngine;
+//# sourceMappingURL=AgoraSdk.d.ts.map

package/types/AgoraSdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgoraSdk.d.ts","sourceRoot":"","sources":["../ts/AgoraSdk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AAIxB;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,YAAY,CAG5E;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,wBAAwB,CAErE;AAED,eAAe,oBAAoB,CAAC"}

package/types/Decoder/gpu-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @ignore
+ */
+export type VideoDecodeAcceleratorSupportedProfile = {
+    codec: string;
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+};
+/**
+ * @ignore
+ */
+export declare class GpuInfo {
+    videoDecodeAcceleratorSupportedProfile: VideoDecodeAcceleratorSupportedProfile[];
+}
+/**
+ * @ignore
+ */
+export declare const getGpuInfoInternal: (callback: any) => void;
+//# sourceMappingURL=gpu-utils.d.ts.map

package/types/Decoder/gpu-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-utils.d.ts","sourceRoot":"","sources":["../../ts/Decoder/gpu-utils.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,MAAM,MAAM,sCAAsC,GAAG;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,qBAAa,OAAO;IAClB,sCAAsC,EAAE,sCAAsC,EAAE,CAC3E;CACN;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,aAAc,GAAG,KAAG,IAiElD,CAAC"}

package/types/Decoder/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="dom-webcodecs" />
+import { EncodedVideoFrameInfo } from '../Private/AgoraBase';
+import { WebCodecsRenderer } from '../Renderer/WebCodecsRenderer/index';
+import { RendererCacheContext } from '../Types';
+export declare class WebCodecsDecoder {
+    private _decoder;
+    private renderers;
+    private _cacheContext;
+    private pendingFrame;
+    private _currentCodecConfig;
+    private _base_ts;
+    private _base_ts_ntp;
+    private _last_ts_ntp;
+    private _decode_retry_count;
+    constructor(renders: WebCodecsRenderer[], onError: (e: any) => void, context: RendererCacheContext);
+    _output(frame: VideoFrame): void;
+    private _renderFrame;
+    renderAnimationFrame(): void;
+    decoderConfigure(frameInfo: EncodedVideoFrameInfo): void;
+    updateTimestamps(ts: number): void;
+    handleCodecIsChanged(frameInfo: EncodedVideoFrameInfo): void;
+    decodeFrame(imageBuffer: Uint8Array, frameInfo: EncodedVideoFrameInfo, ts: number): void;
+    reset(): void;
+    release(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/Decoder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../ts/Decoder/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,qBAAqB,EAAkB,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAmB,oBAAoB,EAAgB,MAAM,UAAU,CAAC;AAS/E,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,aAAa,CAAuB;IAE5C,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,mBAAmB,CAAgC;IAE3D,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,mBAAmB,CAAK;gBAG9B,OAAO,EAAE,iBAAiB,EAAE,EAC5B,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,EACzB,OAAO,EAAE,oBAAoB;IAc/B,OAAO,CAAC,KAAK,EAAE,UAAU;IAMzB,OAAO,CAAC,YAAY;IAapB,oBAAoB;IAcpB,gBAAgB,CAAC,SAAS,EAAE,qBAAqB;IA8BjD,gBAAgB,CAAC,EAAE,EAAE,MAAM;IAgB3B,oBAAoB,CAAC,SAAS,EAAE,qBAAqB;IAcrD,WAAW,CACT,WAAW,EAAE,UAAU,EACvB,SAAS,EAAE,qBAAqB,EAChC,EAAE,EAAE,MAAM;IAuDZ,KAAK;IAOL,OAAO;CASR"}