ezuikit-flv 1.0.0-alpha.0

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "ezuikit-flv",
+  "version": "1.0.0-alpha.0",
+  "main": "./index.js",
+  "types": "./types",
+  "files": [
+    "CHANGELOG.md",
+    "decoder.js",
+    "decoder.wasm",
+    "index.js",
+    "package.json",
+    "README.md",
+    "types"
+  ],
+  "dependencies": {
+    "@ezviz/ezmonitor": "^1.0.0",
+    "recordrtc": "5.6.2",
+    "screenfull": "5.1.0"
+  }
+}

package/types/audio/audioContextLoader.d.ts

@@ -0,0 +1,42 @@
+export default class AudioContextLoader extends Emitter {
+    constructor(player: any);
+    bufferList: any[];
+    player: any;
+    scriptNode: any;
+    hasInitScriptNode: boolean;
+    audioContextChannel: any;
+    audioContext: any;
+    gainNode: any;
+    audioBufferSourceNode: any;
+    mediaStreamAudioDestinationNode: any;
+    playing: boolean;
+    audioSyncVideoOption: {
+        diff: any;
+    };
+    audioInfo: {
+        encType: string;
+        channels: string;
+        sampleRate: string;
+    };
+    init: boolean;
+    hasAudio: boolean;
+    resetInit(): void;
+    destroy(): void;
+    updateAudioInfo(data: any): void;
+    get isPlaying(): boolean;
+    get isMute(): boolean;
+    get volume(): any;
+    get bufferSize(): number;
+    initScriptNode(): void;
+    mute(flag: any): void;
+    setVolume(volume: any): void;
+    closeAudio(): void;
+    audioEnabled(flag: any): void;
+    isStateRunning(): boolean;
+    isStateSuspended(): boolean;
+    clear(): void;
+    play(buffer: any, ts: any): void;
+    pause(): void;
+    resume(): void;
+}
+import Emitter from '../utils/emitter';

package/types/audio/index.d.ts

@@ -0,0 +1,5 @@
+export default class Audio {
+    static getLoaderFactory(): typeof AudioContextLoader;
+    constructor(player: any);
+}
+import AudioContextLoader from './audioContextLoader';

package/types/constant/index.d.ts

@@ -0,0 +1,263 @@
+export namespace PLAYER_PLAY_PROTOCOL {
+    let websocket: number;
+    let fetch: number;
+    let webrtc: number;
+}
+export namespace DEMUX_TYPE {
+    let flv: string;
+    let m7s: string;
+}
+export namespace FILE_SUFFIX {
+    let mp4: string;
+    let webm: string;
+}
+export const MEDIA_SOURCE_UPDATE_END_TIMEOUT: number;
+export namespace DEFAULT_PLAYER_OPTIONS {
+    export let videoBuffer: number;
+    export let videoBufferDelay: number;
+    export let scaleMode: number;
+    export let debug: boolean;
+    export let loadingTimeout: number;
+    export let heartTimeout: number;
+    export let timeout: number;
+    export let loadingTimeoutReplay: boolean;
+    export let heartTimeoutReplay: boolean;
+    export let loadingTimeoutReplayTimes: number;
+    export let heartTimeoutReplayTimes: number;
+    export let keepScreenOn: boolean;
+    export let isNotMute: boolean;
+    export let hasAudio: boolean;
+    export let hasVideo: boolean;
+    export let decoder: string;
+    export let url: string;
+    export let rotate: number;
+    export let forceNoOffscreen: boolean;
+    import protocol = PLAYER_PLAY_PROTOCOL.fetch;
+    export { protocol };
+    import demuxType = DEMUX_TYPE.flv;
+    export { demuxType };
+    export let useMSE: boolean;
+    export let autoWasm: boolean;
+    export let wasmDecodeErrorReplay: boolean;
+    export let openWebglAlignment: boolean;
+    export let wasmDecodeAudioSyncVideo: boolean;
+    export let useWebFullScreen: boolean;
+}
+export namespace WORKER_CMD_TYPE {
+    let init: string;
+    let initVideo: string;
+    let render: string;
+    let playAudio: string;
+    let initAudio: string;
+    let kBps: string;
+    let decode: string;
+    let audioCode: string;
+    let videoCode: string;
+    let wasmError: string;
+}
+export namespace WASM_ERROR {
+    let invalidNalUnitSize: string;
+}
+export namespace MEDIA_TYPE {
+    let audio: number;
+    let video: number;
+}
+export namespace FLV_MEDIA_TYPE {
+    let audio_1: number;
+    export { audio_1 as audio };
+    let video_1: number;
+    export { video_1 as video };
+}
+export namespace WORKER_SEND_TYPE {
+    let init_1: string;
+    export { init_1 as init };
+    let decode_1: string;
+    export { decode_1 as decode };
+    export let audioDecode: string;
+    export let videoDecode: string;
+    export let close: string;
+    export let updateConfig: string;
+}
+export namespace EVENTS {
+    export let fullscreen: string;
+    export let webFullscreen: string;
+    export let decoderWorkerInit: string;
+    export let play: string;
+    export let playing: string;
+    export let pause: string;
+    export let mute: string;
+    export let load: string;
+    export let loading: string;
+    export let videoInfo: string;
+    export let timeUpdate: string;
+    export let audioInfo: string;
+    export let log: string;
+    export let error: string;
+    let kBps_1: string;
+    export { kBps_1 as kBps };
+    let timeout_1: string;
+    export { timeout_1 as timeout };
+    export let delayTimeout: string;
+    let loadingTimeout_1: string;
+    export { loadingTimeout_1 as loadingTimeout };
+    export let stats: string;
+    export let performance: string;
+    export let buffer: string;
+    export let videoFrame: string;
+    export let start: string;
+    export let metadata: string;
+    export let resize: string;
+    export let streamEnd: string;
+    export let streamSuccess: string;
+    export let streamMessage: string;
+    export let streamError: string;
+    export let volumechange: string;
+    export let destroy: string;
+    export let mseSourceOpen: string;
+    export let mseSourceClose: string;
+    export let mseSourceBufferError: string;
+    export let mseSourceBufferBusy: string;
+    export let mseSourceBufferFull: string;
+    export let videoWaiting: string;
+    export let videoTimeUpdate: string;
+    export let videoSyncAudio: string;
+    export let playToRenderTimes: string;
+}
+export namespace FLV_EVENTS {
+    import load_1 = EVENTS.load;
+    export { load_1 as load };
+    import timeUpdate_1 = EVENTS.timeUpdate;
+    export { timeUpdate_1 as timeUpdate };
+    import videoInfo_1 = EVENTS.videoInfo;
+    export { videoInfo_1 as videoInfo };
+    import audioInfo_1 = EVENTS.audioInfo;
+    export { audioInfo_1 as audioInfo };
+    import error_1 = EVENTS.error;
+    export { error_1 as error };
+    import kBps_2 = EVENTS.kBps;
+    export { kBps_2 as kBps };
+    import log_1 = EVENTS.log;
+    export { log_1 as log };
+    import start_1 = EVENTS.start;
+    export { start_1 as start };
+    import timeout_2 = EVENTS.timeout;
+    export { timeout_2 as timeout };
+    import loadingTimeout_2 = EVENTS.loadingTimeout;
+    export { loadingTimeout_2 as loadingTimeout };
+    import delayTimeout_1 = EVENTS.delayTimeout;
+    export { delayTimeout_1 as delayTimeout };
+    let fullscreen_1: string;
+    export { fullscreen_1 as fullscreen };
+    import webFullscreen_1 = EVENTS.webFullscreen;
+    export { webFullscreen_1 as webFullscreen };
+    import play_1 = EVENTS.play;
+    export { play_1 as play };
+    import pause_1 = EVENTS.pause;
+    export { pause_1 as pause };
+    import mute_1 = EVENTS.mute;
+    export { mute_1 as mute };
+    import stats_1 = EVENTS.stats;
+    export { stats_1 as stats };
+    import volumechange_1 = EVENTS.volumechange;
+    export { volumechange_1 as volumechange };
+    import performance_1 = EVENTS.performance;
+    export { performance_1 as performance };
+    import playToRenderTimes_1 = EVENTS.playToRenderTimes;
+    export { playToRenderTimes_1 as playToRenderTimes };
+}
+export namespace EVENTS_ERROR {
+    export let playError: string;
+    export let fetchError: string;
+    export let websocketError: string;
+    export let webcodecsH265NotSupport: string;
+    export let webcodecsDecodeError: string;
+    export let webcodecsWidthOrHeightChange: string;
+    export let mediaSourceH265NotSupport: string;
+    import mediaSourceFull = EVENTS.mseSourceBufferFull;
+    export { mediaSourceFull };
+    import mseSourceBufferError_1 = EVENTS.mseSourceBufferError;
+    export { mseSourceBufferError_1 as mseSourceBufferError };
+    export let mediaSourceAppendBufferError: string;
+    export let mediaSourceBufferListLarge: string;
+    export let mediaSourceAppendBufferEndTimeout: string;
+    export let wasmDecodeError: string;
+    export let webglAlignmentError: string;
+}
+export namespace WEBSOCKET_STATUS {
+    export let notConnect: string;
+    export let open: string;
+    let close_1: string;
+    export { close_1 as close };
+    let error_2: string;
+    export { error_2 as error };
+}
+export namespace BUFFER_STATUS {
+    let empty: string;
+    let buffering: string;
+    let full: string;
+}
+export namespace SCREENSHOT_TYPE {
+    let download: string;
+    let base64: string;
+    let blob: string;
+}
+export const VIDEO_ENC_TYPE: {
+    7: string;
+    12: string;
+};
+export namespace VIDEO_ENC_CODE {
+    let h264: number;
+    let h265: number;
+}
+export const AUDIO_ENC_TYPE: {
+    10: string;
+    7: string;
+    8: string;
+};
+export namespace H265_NAL_TYPE {
+    let vps: number;
+    let sps: number;
+    let pps: number;
+}
+export const CONTROL_HEIGHT: 38;
+export namespace SCALE_MODE_TYPE {
+    let full_1: number;
+    export { full_1 as full };
+    export let auto: number;
+    export let fullAuto: number;
+}
+export namespace CANVAS_RENDER_TYPE {
+    let webcodecs: string;
+    let webgl: string;
+    let offscreen: string;
+}
+export namespace ENCODED_VIDEO_TYPE {
+    let key: string;
+    let delta: string;
+}
+export namespace MP4_CODECS {
+    let avc: string;
+    let hev: string;
+}
+export namespace MEDIA_SOURCE_STATE {
+    export let ended: string;
+    let open_1: string;
+    export { open_1 as open };
+    export let closed: string;
+}
+export const FRAG_DURATION: number;
+export const AUDIO_SYNC_VIDEO_DIFF: 1000;
+export namespace HOT_KEY {
+    let esc: number;
+    let arrowUp: number;
+    let arrowDown: number;
+}
+export namespace WCS_ERROR {
+    let keyframeIsRequiredError: string;
+    let canNotDecodeClosedCodec: string;
+}
+export namespace FETCH_ERROR {
+    let abortError1: string;
+    let abortError2: string;
+    let abort: string;
+}

package/types/control/index.d.ts

@@ -0,0 +1,4 @@
+export default class Control {
+    constructor(player: any);
+    player: any;
+}

package/types/control/observer.d.ts

@@ -0,0 +1,2 @@
+declare function _default(player: any, control: any): void;
+export default _default;

package/types/demux/commonLoader.d.ts

@@ -0,0 +1,19 @@
+export default class CommonLoader extends Emitter {
+    constructor(player: any);
+    player: any;
+    stopId: NodeJS.Timeout;
+    firstTimestamp: any;
+    startTimestamp: number;
+    delay: number;
+    bufferList: any[];
+    dropping: boolean;
+    destroy(): void;
+    getDelay(timestamp: any): number;
+    resetDelay(): void;
+    initInterval(): void;
+    _doDecode(payload: any, type: any, ts: any, isIFrame: any, cts: any): void;
+    _doDecoderDecode(data: any): void;
+    pushBuffer(payload: any, options: any): void;
+    close(): void;
+}
+import Emitter from '../utils/emitter';

package/types/demux/flvLoader.d.ts

@@ -0,0 +1,15 @@
+export default class FlvLoader extends CommonLoader {
+    input: Generator<number, void, unknown>;
+    flvDemux: (value: any) => void;
+    /**
+     * @param {Uint8Array} data
+     */
+    dispatch(data: Uint8Array): void;
+    _inputFlv(): Generator<number, void, unknown>;
+    /**
+     * @param {Generator<number, void, unknown>} input 数据片段
+     * @returns
+     */
+    dispatchFlvData(input: Generator<number, void, unknown>): (value: any) => void;
+}
+import CommonLoader from './commonLoader';

package/types/demux/index.d.ts

@@ -0,0 +1,5 @@
+export default class Demux {
+    static getLoaderFactory(type: any): typeof M7sLoader;
+    constructor(player: any);
+}
+import M7sLoader from './m7sLoader';

package/types/demux/m7sLoader.d.ts

@@ -0,0 +1,4 @@
+export default class M7sLoader extends CommonLoader {
+    dispatch(data: any): void;
+}
+import CommonLoader from './commonLoader';

package/types/flv-mse/flv.min.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: any;
+export = _exports;
+export const mpegts: any;

package/types/index.d.ts

@@ -0,0 +1,248 @@
+export default EzuikitFlv;
+/**
+ * @classdesc EzuikitFlv.js 播放flv直播流， 支持播放h264/h265的直播视频流
+ * @example
+ * const flv = new EzuikitFlv({container: "EleId"})
+ */
+declare class EzuikitFlv extends Emitter {
+    /**
+     * @description ERROR
+     * @static
+     * @member
+     * @example
+     * EzuikitFlv.ERROR.playError
+     */
+    static ERROR: {
+        playError: string;
+        fetchError: string;
+        websocketError: string;
+        webcodecsH265NotSupport: string;
+        webcodecsDecodeError: string;
+        webcodecsWidthOrHeightChange: string; /**
+         * @description 设置音量
+         * @param {number} value 音量 0～1
+         * @returns {void}
+         * @example
+         * flv.setVolume(0.5)
+         */
+        mediaSourceH265NotSupport: string;
+        mediaSourceFull: string;
+        mseSourceBufferError: string;
+        mediaSourceAppendBufferError: string;
+        mediaSourceBufferListLarge: string;
+        mediaSourceAppendBufferEndTimeout: string;
+        wasmDecodeError: string;
+        webglAlignmentError: string;
+    };
+    /** */
+    static TIMEOUT: {
+        loadingTimeout: string;
+        delayTimeout: string;
+    };
+    /**
+     * @constructor
+     * @param {FlvOptions} options
+     */
+    constructor(options: FlvOptions);
+    _opt: FlvOptions;
+    $container: any;
+    _loadingTimeoutReplayTimes: number;
+    _heartTimeoutReplayTimes: number;
+    events: Events;
+    /**
+     * @description 销毁
+     * @example
+     * flv.destroy()
+     */
+    destroy(): void;
+    player: Player;
+    /**
+     * @description 初始化播放
+     * @private
+     * @param {string | HTMLElement} $container
+     * @param {FlvOptions} options
+     * @return {void}
+     */
+    private _initPlayer;
+    /**
+     * @description 重置播放器
+     * @private
+     * @param {FlvOptions} options
+     */
+    private _resetPlayer;
+    /**
+     * @description 绑定事件
+     * @private
+     */
+    private _bindEvents;
+    /**
+     * @description 是否开启控制台调试打印
+     * @param {boolean} value true: 开启， false: 关闭
+     * @returns {void}
+     * @example
+     * flv.setDebug(false)
+     */
+    setDebug(value: boolean): void;
+    /**
+     * @description 关闭声音
+     * @returns {void}
+     * @example
+     * flv.closeSound()
+     */
+    closeSound(): void;
+    /**
+     * @description 开启声音 默认音量 0.5
+     * @returns {void}
+     * @example
+     * flv.openSound() //
+     */
+    openSound(): void;
+    /**
+     * @description 设置音量
+     * @param {number} value 音量 0～1
+     * @returns {void}
+     * @example
+     * flv.setVolume(0.5)
+     */
+    setVolume(value: number): void;
+    /**
+     * @description 获取音量， 音量 0～1
+     * @returns {number}
+     * @example
+     * flv.getVolume()
+     */
+    getVolume(): number;
+    /**
+     * @description 音频回复
+     * @returns {void}
+     * @example
+     * flv.audioResume()
+     */
+    audioResume(): void;
+    /**
+     * @description 设置超时时长, 单位秒 在连接成功之前和播放中途,如果超过设定时长无数据返回,则回调timeout事件
+     * @private
+     * @param {number} time 设置超时时长, 单位秒
+     * @returns {void}
+     * @example
+     * flv.setTimeout(3)
+     */
+    private setTimeout;
+    /**
+     * @description 设置渲染的模式 (video 不支持)
+     * @private
+     * @param {0 | 1 | 2} type 0: 完全填充canvas区域; 1: 等比缩放, 最大边填充 ; 2: 等比缩放后,最小边填充，完全填充canvas区域,画面不被拉伸,没有黑边,但画面显示不全
+     * @returns {Promise}
+     * @example
+     * flv.setScaleMode(1)
+     */
+    private setScaleMode;
+    /**
+     * @description 暂停
+     * @returns {Promise<unknown>}
+     * @example
+     * flv.pause()
+     */
+    pause(): Promise<unknown>;
+    /**
+     * @description 关闭视频,不释放底层资源
+     * @private
+     * @returns {void}
+     * @example
+     * flv.close()
+     */
+    private close;
+    /**
+     * @description 清理画布为黑色背景
+     * @private
+     * @returns {void}
+     * @example
+     * flv.clearView()
+     */
+    private clearView;
+    /**
+     * @description 播放
+     * @param {object=} options
+     * @returns {Promise}
+     * @example
+     * flv.play()
+     */
+    play(options?: object | undefined): Promise<any>;
+    /**
+     * @description 播放
+     * @private
+     * @param {string} url
+     * @param {object=} options
+     * @returns {Promise<unknown>}
+     */
+    private _play;
+    /**
+     * @description 重新调整视图大小
+     * @private
+     * @example
+     * flv.resize()
+     */
+    private resize;
+    /**
+     * @description 设置最大缓冲时长，单位秒，播放器会自动消除延迟。
+     * @private
+     * @param {number} time  大缓冲时长 s
+     * @example
+     * flv.setBufferTime(3)
+     */
+    private setBufferTime;
+    /**
+     * @description 设置旋转角度，支持，0(默认), 90, 180, 270 四个值。
+     * @returns {Promise}
+     * @param {number} deg
+     * @example
+     * flv.setRotate(90) // 旋转90度
+     */
+    setRotate(deg: number): Promise<any>;
+    /**
+     * @description 返回是否加载完毕
+     * @private
+     * @returns {boolean}
+     */
+    private hasLoaded;
+    /**
+     * @description 开启屏幕常亮，在手机浏览器上
+     * @returns {void}
+     * @example
+     * flv.setKeepScreenOn()
+     */
+    setKeepScreenOn(): void;
+    /**
+     * @description 全屏(取消全屏)播放视频
+     * @private
+     * @param {Boolean} flag
+     */
+    private _setFullscreen;
+    /**
+     * @description 全屏播放视频
+     * @example
+     * flv.fullScreen() // 全屏
+     */
+    fullScreen(): void;
+    /**
+     * @description 取消全屏播放视频
+     * @example
+     * flv.cancelFullScreen() // 全屏
+     */
+    cancelFullScreen(): void;
+    /**
+     * @description 获取播放器的状态
+     * @returns {PlayerState} 播放器的状态
+     * @example
+     * flv.getState()
+     */
+    getState(): PlayerState;
+    /**
+     * @description 获取版本
+     * @returns {string}
+     */
+    getVersion(): string;
+}
+import Emitter from './utils/emitter';
+import Events from './utils/events';
+import Player from './player';

package/types/player/base-player.d.ts

@@ -0,0 +1,46 @@
+export default class BasePlayer extends Emitter {
+    constructor(container: any, options: any, Video: any);
+    $container: any;
+    _opt: any;
+    debug: Debug;
+    _loading: boolean;
+    _playing: boolean;
+    _hasLoaded: boolean;
+    _checkHeartTimeout: any;
+    _checkLoadingTimeout: any;
+    _checkStatsInterval: any;
+    _startBpsTime: any;
+    _isPlayingBeforePageHidden: boolean;
+    _stats: {
+        buf: number;
+        fps: number;
+        abps: number;
+        vbps: number;
+        ts: number;
+    };
+    _times: {
+        playInitStart: string;
+        playStart: string;
+        streamStart: string;
+        streamResponse: string;
+        demuxStart: string;
+        decodeStart: string;
+        videoStart: string;
+        playTimestamp: string;
+        streamTimestamp: string;
+        streamResponseTimestamp: string;
+        demuxTimestamp: string;
+        decodeTimestamp: string;
+        videoTimestamp: string;
+        allTimestamp: string;
+    };
+    _videoTimestamp: number;
+    _audioTimestamp: number;
+    events: Events;
+    video: any;
+    control: Control;
+}
+import Emitter from '../utils/emitter';
+import Debug from '../utils/debug';
+import Events from '../utils/events';
+import Control from '../control';

package/types/player/commonLoader.d.ts

@@ -0,0 +1,16 @@
+export default class CommonLoader extends Emitter {
+    init: boolean;
+    resetInit(): void;
+    videoInfo: {
+        width: string;
+        height: string;
+        encType: string;
+        encTypeCode: string;
+    };
+    destroy(): void;
+    updateVideoInfo(data: any): void;
+    play(): void;
+    pause(): void;
+    clearView(): void;
+}
+import Emitter from '../utils/emitter';