lemon-mse 0.1.6 → 0.1.8

package/dist/es/flv.d.ts

@@ -1,6 +1,14 @@
 export { Flv }
+/** 并非所有事件都可用 */
+export type EventTypes =  'loadstart' | 'loadeddata'|'play'|'pause'|'ended'
+|'error'|'playing'|'seeking'|'seeked'|'timeupdate'|'waiting'|'canplay'
+|'canplaythrough'|'durationchange'|'volumechange' |'ratechange'
+|'video_resize'|'definition_change'|'user_action'|'rotate'
+|'definition_change'|'retry'|'replay'|'destroy'|'mini_state_change'
+|'cssFullscreen_change'|'fullscreen_change'|'blur'|'focus'|'complete'
+|'autoplay_started'|'autoplay_was_prevented'|'ready'|'pip_change'
 
-declare class Flv {
+declare class Flv extends EventEmitter<EventTypes> {
     static isSupported(mediaType: ('video' | 'audio') | null): boolean;
     static enableLogger(): void;
     static disableLogger(): void;
@@ -35,7 +43,7 @@ declare class Flv {
         speed: any;
         avgSpeed: number;
     };
-    getStats(): Stats;
+    getStats(): K.Stats;
     bufferInfo(maxHole?: number): {
         start: number;
         end: number;
@@ -216,9 +224,43 @@ declare namespace K {
         audioTrack: AudioTrack;
         metadataTrack: MetadataTrack;
     };
+    export class FlvFixer {
+        constructor(videoTrack: any, audioTrack: any, metadataTrack: any);
+        videoTrack: any;
+        audioTrack: any;
+        metadataTrack: any;
+        _baseDts: number;
+        _baseDtsInited: boolean;
+        _audioNextPts: any;
+        _videoNextDts: any;
+        _audioTimestampBreak: number;
+        _videoTimestampBreak: number;
+        _lastVideoDuration: number;
+        _keyFrameInNextChunk: boolean;
+        _lastAudioExceptionGapDot: number;
+        _lastAudioExceptionOverlapDot: number;
+        _lastAudioExceptionLargeGapDot: number;
+        _lastVideoExceptionLargeGapDot: number;
+        _lastVideoExceptionChunkFirstDtsDot: number;
+        /**
+         * @param {number} startTime 点播seek到的时间点
+         * @param {boolean} discontinuity 是否换流
+         * @param {boolean} contiguous 前后chunk时间戳是否连续
+         */
+        fix(startTime?: number, discontinuity?: boolean, contiguous?: boolean): void;
+        _videoLastSample: any;
+        _fixVideo(videoTrack: any): void;
+        _fixAudio(audioTrack: any): void;
+        _calculateBaseDts(audioTrack: any, videoTrack: any): boolean;
+        _resetBaseDtsWhenStreamBreaked(): void;
+        _doFixAudioInternal(audioTrack: any, samples: any, timescale: any): void;
+        _getG711Duration(track: any): number;
+        _getSilentFrame(track: any): Uint8Array;
+    }
+    
 
 
-    declare class SeiService {
+    class SeiService {
         constructor(emitter: any);
         _seiSet: Set<any>;
         emitter: any;
@@ -286,9 +328,9 @@ declare namespace K {
         baseMediaDecodeTime: number;
         baseDts: number;
         duration: number;
-        warnings: any[];
-        /** @type {import('./video-sample').VideoSample[]} */
-        samples: import('./video-sample').VideoSample[];
+        warnings: any[]; 
+        // VideoSample
+        samples: any[];
         /** @type {Uint8Array[]} */
         pps: Uint8Array[];
         /** @type {Uint8Array[]} */
@@ -399,7 +441,7 @@ declare namespace K {
         reset(): void;
         hasSample(): boolean;
     }
-    declare class Sample {
+    class Sample {
         constructor(data: any, pts: number);
         time: number;
         data: any;
@@ -407,4 +449,139 @@ declare namespace K {
         pts: number;
     }
 
-}
+}
+
+
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ */
+declare class EventEmitter<
+  EventTypes extends E.ValidEventTypes = string | symbol,
+  Context extends any = any
+> {
+  static prefixed: string | boolean;
+
+  /**
+   * Return an array listing the events for which the emitter has registered
+   * listeners.
+   */
+  eventNames(): Array<E.EventNames<EventTypes>>;
+
+  /**
+   * Return the listeners registered for a given event.
+   */
+  listeners<T extends E.EventNames<EventTypes>>(
+    event: T
+  ): Array<E.EventListener<EventTypes, T>>;
+
+  /**
+   * Return the number of listeners listening to a given event.
+   */
+  listenerCount(event: E.EventNames<EventTypes>): number;
+
+  /**
+   * Calls each of the listeners registered for a given event.
+   */
+  emit<T extends E.EventNames<EventTypes>>(
+    event: T,
+    ...args: E.EventArgs<EventTypes, T>
+  ): boolean;
+
+  /**
+   * Add a listener for a given event.
+   */
+  on<T extends E.EventNames<EventTypes>>(
+    event: T,
+    fn: E.EventListener<EventTypes, T>,
+    context?: Context
+  ): this;
+  addListener<T extends E.EventNames<EventTypes>>(
+    event: T,
+    fn: E.EventListener<EventTypes, T>,
+    context?: Context
+  ): this;
+
+  /**
+   * Add a one-time listener for a given event.
+   */
+  once<T extends E.EventNames<EventTypes>>(
+    event: T,
+    fn: E.EventListener<EventTypes, T>,
+    context?: Context
+  ): this;
+
+  /**
+   * Remove the listeners of a given event.
+   */
+  removeListener<T extends E.EventNames<EventTypes>>(
+    event: T,
+    fn?: E.EventListener<EventTypes, T>,
+    context?: Context,
+    once?: boolean
+  ): this;
+  off<T extends E.EventNames<EventTypes>>(
+    event: T,
+    fn?: E.EventListener<EventTypes, T>,
+    context?: Context,
+    once?: boolean
+  ): this;
+
+  /**
+   * Remove all listeners, or those of the specified event.
+   */
+  removeAllListeners(event?: E.EventNames<EventTypes>): this;
+}
+
+declare namespace E {
+  export interface ListenerFn<Args extends any[] = any[]> {
+    (...args: Args): void;
+  }
+
+  export interface EventEmitterStatic {
+    new <
+      EventTypes extends ValidEventTypes = string | symbol,
+      Context = any
+    >(): EventEmitter<EventTypes, Context>;
+  }
+
+  /**
+   * `object` should be in either of the following forms:
+   * ```
+   * interface EventTypes {
+   *   'event-with-parameters': any[]
+   *   'event-with-example-handler': (...args: any[]) => void
+   * }
+   * ```
+   */
+  export type ValidEventTypes = string | symbol | object;
+
+  export type EventNames<T extends ValidEventTypes> = T extends string | symbol
+    ? T
+    : keyof T;
+
+  export type ArgumentMap<T extends object> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => void
+      ? Parameters<T[K]>
+      : T[K] extends any[]
+      ? T[K]
+      : any[];
+  };
+
+  export type EventListener<
+    T extends ValidEventTypes,
+    K extends EventNames<T>
+  > = T extends string | symbol
+    ? (...args: any[]) => void
+    : (
+        ...args: ArgumentMap<Exclude<T, string | symbol>>[Extract<K, keyof T>]
+      ) => void;
+
+  export type EventArgs<
+    T extends ValidEventTypes,
+    K extends EventNames<T>
+  > = Parameters<EventListener<T, K>>;
+
+  export const EventEmitter: EventEmitterStatic;
+}
+