mirror of
https://github.com/Wcowin/Mkdocs-Wcowin.git
synced 2025-07-20 17:06:34 +00:00
2838 lines
94 KiB
TypeScript
2838 lines
94 KiB
TypeScript
declare class AbrController implements ComponentAPI {
|
||
protected hls: Hls;
|
||
private lastLoadedFragLevel;
|
||
private _nextAutoLevel;
|
||
private timer?;
|
||
private onCheck;
|
||
private fragCurrent;
|
||
private partCurrent;
|
||
private bitrateTestDelay;
|
||
readonly bwEstimator: EwmaBandWidthEstimator;
|
||
constructor(hls: Hls);
|
||
protected registerListeners(): void;
|
||
protected unregisterListeners(): void;
|
||
destroy(): void;
|
||
protected onFragLoading(event: Events.FRAG_LOADING, data: FragLoadingData): void;
|
||
protected onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData): void;
|
||
private _abandonRulesCheck;
|
||
protected onFragLoaded(event: Events.FRAG_LOADED, { frag, part }: FragLoadedData): void;
|
||
protected onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData): void;
|
||
protected onError(event: Events.ERROR, data: ErrorData): void;
|
||
clearTimer(): void;
|
||
get nextAutoLevel(): number;
|
||
private getNextABRAutoLevel;
|
||
private findBestLevel;
|
||
set nextAutoLevel(nextLevel: number);
|
||
}
|
||
|
||
export declare type ABRControllerConfig = {
|
||
abrEwmaFastLive: number;
|
||
abrEwmaSlowLive: number;
|
||
abrEwmaFastVoD: number;
|
||
abrEwmaSlowVoD: number;
|
||
abrEwmaDefaultEstimate: number;
|
||
abrBandWidthFactor: number;
|
||
abrBandWidthUpFactor: number;
|
||
abrMaxWithRealBitrate: boolean;
|
||
maxStarvationDelay: number;
|
||
maxLoadingDelay: number;
|
||
};
|
||
|
||
export declare class AttrList {
|
||
[key: string]: any;
|
||
constructor(attrs: string | Record<string, any>);
|
||
decimalInteger(attrName: string): number;
|
||
hexadecimalInteger(attrName: string): Uint8Array | null;
|
||
hexadecimalIntegerAsNumber(attrName: string): number;
|
||
decimalFloatingPoint(attrName: string): number;
|
||
optionalFloat(attrName: string, defaultValue: number): number;
|
||
enumeratedString(attrName: string): string | undefined;
|
||
bool(attrName: string): boolean;
|
||
decimalResolution(attrName: string): {
|
||
width: number;
|
||
height: number;
|
||
} | undefined;
|
||
static parseAttrList(input: string): Record<string, any>;
|
||
}
|
||
|
||
export declare type AudioPlaylistType = 'AUDIO';
|
||
|
||
declare class AudioStreamController extends BaseStreamController implements NetworkComponentAPI {
|
||
private videoBuffer;
|
||
private videoTrackCC;
|
||
private waitingVideoCC;
|
||
private audioSwitch;
|
||
private trackId;
|
||
private waitingData;
|
||
private mainDetails;
|
||
private bufferFlushed;
|
||
constructor(hls: Hls, fragmentTracker: FragmentTracker);
|
||
protected onHandlerDestroying(): void;
|
||
private _registerListeners;
|
||
private _unregisterListeners;
|
||
onInitPtsFound(event: Events.INIT_PTS_FOUND, { frag, id, initPTS }: InitPTSFoundData): void;
|
||
startLoad(startPosition: number): void;
|
||
doTick(): void;
|
||
clearWaitingFragment(): void;
|
||
protected onTickEnd(): void;
|
||
private doTickIdle;
|
||
protected getMaxBufferLength(): number;
|
||
onMediaDetaching(): void;
|
||
onAudioTracksUpdated(event: Events.AUDIO_TRACKS_UPDATED, { audioTracks }: AudioTracksUpdatedData): void;
|
||
onAudioTrackSwitching(event: Events.AUDIO_TRACK_SWITCHING, data: AudioTrackSwitchingData): void;
|
||
onManifestLoading(): void;
|
||
onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData): void;
|
||
onAudioTrackLoaded(event: Events.AUDIO_TRACK_LOADED, data: TrackLoadedData): void;
|
||
_handleFragmentLoadProgress(data: FragLoadedData): void;
|
||
protected _handleFragmentLoadComplete(fragLoadedData: FragLoadedData): void;
|
||
onBufferReset(): void;
|
||
onBufferCreated(event: Events.BUFFER_CREATED, data: BufferCreatedData): void;
|
||
onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData): void;
|
||
private onError;
|
||
private onBufferFlushed;
|
||
private _handleTransmuxComplete;
|
||
private _bufferInitSegment;
|
||
protected loadFragment(frag: Fragment, trackDetails: LevelDetails, targetBufferTime: number): void;
|
||
private completeAudioSwitch;
|
||
}
|
||
|
||
declare class AudioTrackController extends BasePlaylistController {
|
||
private tracks;
|
||
private groupId;
|
||
private tracksInGroup;
|
||
private trackId;
|
||
private trackName;
|
||
private selectDefaultTrack;
|
||
constructor(hls: Hls);
|
||
private registerListeners;
|
||
private unregisterListeners;
|
||
destroy(): void;
|
||
protected onManifestLoading(): void;
|
||
protected onManifestParsed(event: Events.MANIFEST_PARSED, data: ManifestParsedData): void;
|
||
protected onAudioTrackLoaded(event: Events.AUDIO_TRACK_LOADED, data: AudioTrackLoadedData): void;
|
||
protected onLevelLoading(event: Events.LEVEL_LOADING, data: LevelLoadingData): void;
|
||
protected onLevelSwitching(event: Events.LEVEL_SWITCHING, data: LevelSwitchingData): void;
|
||
private switchLevel;
|
||
protected onError(event: Events.ERROR, data: ErrorData): void;
|
||
get audioTracks(): MediaPlaylist[];
|
||
get audioTrack(): number;
|
||
set audioTrack(newId: number);
|
||
private setAudioTrack;
|
||
private selectInitialTrack;
|
||
private findTrackId;
|
||
protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters): void;
|
||
}
|
||
|
||
export declare interface AudioTrackLoadedData extends TrackLoadedData {
|
||
}
|
||
|
||
export declare interface AudioTracksUpdatedData {
|
||
audioTracks: MediaPlaylist[];
|
||
}
|
||
|
||
export declare interface AudioTrackSwitchedData {
|
||
id: number;
|
||
}
|
||
|
||
export declare interface AudioTrackSwitchingData {
|
||
id: number;
|
||
name: string;
|
||
groupId: string;
|
||
type: MediaPlaylistType | 'main';
|
||
url: string;
|
||
}
|
||
|
||
export declare interface BackBufferData {
|
||
bufferEnd: number;
|
||
}
|
||
|
||
declare class BasePlaylistController implements NetworkComponentAPI {
|
||
protected hls: Hls;
|
||
protected timer: number;
|
||
protected canLoad: boolean;
|
||
protected retryCount: number;
|
||
protected log: (msg: any) => void;
|
||
protected warn: (msg: any) => void;
|
||
constructor(hls: Hls, logPrefix: string);
|
||
destroy(): void;
|
||
protected onError(event: Events.ERROR, data: ErrorData): void;
|
||
protected clearTimer(): void;
|
||
startLoad(): void;
|
||
stopLoad(): void;
|
||
protected switchParams(playlistUri: string, previous?: LevelDetails): HlsUrlParameters | undefined;
|
||
protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters): void;
|
||
protected shouldLoadTrack(track: MediaPlaylist): boolean;
|
||
protected playlistLoaded(index: number, data: LevelLoadedData | AudioTrackLoadedData | TrackLoadedData, previousDetails?: LevelDetails): void;
|
||
private getDeliveryDirectives;
|
||
protected retryLoadingOrFail(errorEvent: ErrorData): boolean;
|
||
}
|
||
|
||
export declare class BaseSegment {
|
||
private _byteRange;
|
||
private _url;
|
||
readonly baseurl: string;
|
||
relurl?: string;
|
||
elementaryStreams: ElementaryStreams;
|
||
constructor(baseurl: string);
|
||
setByteRange(value: string, previous?: BaseSegment): void;
|
||
get byteRange(): number[];
|
||
get byteRangeStartOffset(): number;
|
||
get byteRangeEndOffset(): number;
|
||
get url(): string;
|
||
set url(value: string);
|
||
}
|
||
|
||
declare class BaseStreamController extends TaskLoop implements NetworkComponentAPI {
|
||
protected hls: Hls;
|
||
protected fragPrevious: Fragment | null;
|
||
protected fragCurrent: Fragment | null;
|
||
protected fragmentTracker: FragmentTracker;
|
||
protected transmuxer: TransmuxerInterface | null;
|
||
protected _state: string;
|
||
protected media?: any;
|
||
protected mediaBuffer?: any;
|
||
protected config: HlsConfig;
|
||
protected bitrateTest: boolean;
|
||
protected lastCurrentTime: number;
|
||
protected nextLoadPosition: number;
|
||
protected startPosition: number;
|
||
protected loadedmetadata: boolean;
|
||
protected fragLoadError: number;
|
||
protected retryDate: number;
|
||
protected levels: Array<Level> | null;
|
||
protected fragmentLoader: FragmentLoader;
|
||
protected levelLastLoaded: number | null;
|
||
protected startFragRequested: boolean;
|
||
protected decrypter: Decrypter;
|
||
protected initPTS: Array<number>;
|
||
protected onvseeking: EventListener | null;
|
||
protected onvended: EventListener | null;
|
||
private readonly logPrefix;
|
||
protected log: (msg: any) => void;
|
||
protected warn: (msg: any) => void;
|
||
constructor(hls: Hls, fragmentTracker: FragmentTracker, logPrefix: string);
|
||
protected doTick(): void;
|
||
protected onTickEnd(): void;
|
||
startLoad(startPosition: number): void;
|
||
stopLoad(): void;
|
||
protected _streamEnded(bufferInfo: any, levelDetails: any): boolean;
|
||
protected onMediaAttached(event: Events.MEDIA_ATTACHED, data: MediaAttachingData): void;
|
||
protected onMediaDetaching(): void;
|
||
protected onMediaSeeking(): void;
|
||
protected onMediaEnded(): void;
|
||
onKeyLoaded(event: Events.KEY_LOADED, data: KeyLoadedData): void;
|
||
protected onHandlerDestroying(): void;
|
||
protected onHandlerDestroyed(): void;
|
||
protected loadKey(frag: Fragment, details: LevelDetails): void;
|
||
protected loadFragment(frag: Fragment, levelDetails: LevelDetails, targetBufferTime: number): void;
|
||
private _loadFragForPlayback;
|
||
protected flushMainBuffer(startOffset: number, endOffset: number, type?: SourceBufferName | null): void;
|
||
protected _loadInitSegment(frag: Fragment): void;
|
||
protected fragContextChanged(frag: Fragment | null): boolean;
|
||
protected fragBufferedComplete(frag: Fragment, part: Part | null): void;
|
||
protected _handleFragmentLoadComplete(fragLoadedEndData: PartsLoadedData): void;
|
||
protected _handleFragmentLoadProgress(frag: FragLoadedData): void;
|
||
protected _doFragLoad(frag: Fragment, details?: LevelDetails, targetBufferTime?: number | null, progressCallback?: FragmentLoadProgressCallback): Promise<PartsLoadedData | FragLoadedData | null>;
|
||
private doFragPartsLoad;
|
||
private handleFragLoadError;
|
||
protected _handleTransmuxerFlush(chunkMeta: ChunkMetadata): void;
|
||
protected getCurrentContext(chunkMeta: ChunkMetadata): {
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
level: Level;
|
||
} | null;
|
||
protected bufferFragmentData(data: RemuxedTrack, frag: Fragment, part: Part | null, chunkMeta: ChunkMetadata): void;
|
||
protected flushBufferGap(frag: Fragment): void;
|
||
protected getFwdBufferInfo(bufferable: Bufferable, type: PlaylistLevelType): {
|
||
len: number;
|
||
start: number;
|
||
end: number;
|
||
nextStart?: number;
|
||
} | null;
|
||
protected getMaxBufferLength(levelBitrate?: number): number;
|
||
protected reduceMaxBufferLength(threshold?: number): boolean;
|
||
protected getNextFragment(pos: number, levelDetails: LevelDetails): Fragment | null;
|
||
getNextPart(partList: Part[], frag: Fragment, targetBufferTime: number): number;
|
||
private loadedEndOfParts;
|
||
protected getInitialLiveFragment(levelDetails: LevelDetails, fragments: Array<Fragment>): Fragment | null;
|
||
protected getFragmentAtPosition(bufferEnd: number, end: number, levelDetails: LevelDetails): Fragment | null;
|
||
protected synchronizeToLiveEdge(levelDetails: LevelDetails): void;
|
||
protected alignPlaylists(details: LevelDetails, previousDetails?: LevelDetails): number;
|
||
protected waitForCdnTuneIn(details: LevelDetails): boolean;
|
||
protected setStartPosition(details: LevelDetails, sliding: number): void;
|
||
protected getLoadPosition(): number;
|
||
private handleFragLoadAborted;
|
||
protected resetFragmentLoading(frag: Fragment): void;
|
||
protected onFragmentOrKeyLoadError(filterType: PlaylistLevelType, data: ErrorData): void;
|
||
protected afterBufferFlushed(media: Bufferable, bufferType: SourceBufferName, playlistType: PlaylistLevelType): void;
|
||
protected resetLoadingState(): void;
|
||
protected resetLiveStartWhenNotLoaded(level: number): boolean;
|
||
private updateLevelTiming;
|
||
protected resetTransmuxer(): void;
|
||
set state(nextState: string);
|
||
get state(): string;
|
||
}
|
||
|
||
declare type Bufferable = {
|
||
buffered: TimeRanges;
|
||
};
|
||
|
||
export declare interface BufferAppendedData {
|
||
type: SourceBufferName;
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
chunkMeta: ChunkMetadata;
|
||
parent: PlaylistLevelType;
|
||
timeRanges: Partial<Record<SourceBufferName, TimeRanges>>;
|
||
}
|
||
|
||
export declare interface BufferAppendingData {
|
||
type: SourceBufferName;
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
chunkMeta: ChunkMetadata;
|
||
parent: PlaylistLevelType;
|
||
data: Uint8Array;
|
||
}
|
||
|
||
export declare interface BufferCodecsData {
|
||
video?: Track;
|
||
audio?: Track;
|
||
}
|
||
|
||
declare class BufferController implements ComponentAPI {
|
||
private details;
|
||
private _objectUrl;
|
||
private operationQueue;
|
||
private listeners;
|
||
private hls;
|
||
bufferCodecEventsExpected: number;
|
||
private _bufferCodecEventsTotal;
|
||
media: HTMLMediaElement | null;
|
||
mediaSource: MediaSource | null;
|
||
appendError: number;
|
||
tracks: TrackSet;
|
||
pendingTracks: TrackSet;
|
||
sourceBuffer: SourceBuffers;
|
||
constructor(hls: Hls);
|
||
hasSourceTypes(): boolean;
|
||
destroy(): void;
|
||
protected registerListeners(): void;
|
||
protected unregisterListeners(): void;
|
||
private _initSourceBuffer;
|
||
protected onManifestParsed(event: Events.MANIFEST_PARSED, data: ManifestParsedData): void;
|
||
protected onMediaAttaching(event: Events.MEDIA_ATTACHING, data: MediaAttachingData): void;
|
||
protected onMediaDetaching(): void;
|
||
protected onBufferReset(): void;
|
||
protected onBufferCodecs(event: Events.BUFFER_CODECS, data: BufferCodecsData): void;
|
||
protected appendChangeType(type: any, mimeType: any): void;
|
||
protected onBufferAppending(event: Events.BUFFER_APPENDING, eventData: BufferAppendingData): void;
|
||
protected onBufferFlushing(event: Events.BUFFER_FLUSHING, data: BufferFlushingData): void;
|
||
protected onFragParsed(event: Events.FRAG_PARSED, data: FragParsedData): void;
|
||
private onFragChanged;
|
||
protected onBufferEos(event: Events.BUFFER_EOS, data: BufferEOSData): void;
|
||
protected onLevelUpdated(event: Events.LEVEL_UPDATED, { details }: LevelUpdatedData): void;
|
||
flushBackBuffer(): void;
|
||
/**
|
||
* Update Media Source duration to current level duration or override to Infinity if configuration parameter
|
||
* 'liveDurationInfinity` is set to `true`
|
||
* More details: https://github.com/video-dev/hls.js/issues/355
|
||
*/
|
||
private updateMediaElementDuration;
|
||
updateSeekableRange(levelDetails: any): void;
|
||
protected checkPendingTracks(): void;
|
||
protected createSourceBuffers(tracks: TrackSet): void;
|
||
private _onMediaSourceOpen;
|
||
private _onMediaSourceClose;
|
||
private _onMediaSourceEnded;
|
||
private _onSBUpdateStart;
|
||
private _onSBUpdateEnd;
|
||
private _onSBUpdateError;
|
||
private removeExecutor;
|
||
private appendExecutor;
|
||
private blockBuffers;
|
||
private getSourceBufferTypes;
|
||
private addBufferListener;
|
||
private removeBufferListeners;
|
||
}
|
||
|
||
export declare type BufferControllerConfig = {
|
||
appendErrorMaxRetry: number;
|
||
backBufferLength: number;
|
||
liveDurationInfinity: boolean;
|
||
liveBackBufferLength: number | null;
|
||
};
|
||
|
||
export declare interface BufferCreatedData {
|
||
tracks: TrackSet;
|
||
}
|
||
|
||
export declare interface BufferEOSData {
|
||
type?: SourceBufferName;
|
||
}
|
||
|
||
export declare interface BufferFlushedData {
|
||
type: SourceBufferName;
|
||
}
|
||
|
||
export declare interface BufferFlushingData {
|
||
startOffset: number;
|
||
endOffset: number;
|
||
endOffsetSubtitles?: number;
|
||
type: SourceBufferName | null;
|
||
}
|
||
|
||
declare class CapLevelController implements ComponentAPI {
|
||
autoLevelCapping: number;
|
||
firstLevel: number;
|
||
media: HTMLVideoElement | null;
|
||
restrictedLevels: Array<number>;
|
||
timer: number | undefined;
|
||
private hls;
|
||
private streamController?;
|
||
clientRect: {
|
||
width: number;
|
||
height: number;
|
||
} | null;
|
||
constructor(hls: Hls);
|
||
setStreamController(streamController: StreamController): void;
|
||
destroy(): void;
|
||
protected registerListeners(): void;
|
||
protected unregisterListener(): void;
|
||
protected onFpsDropLevelCapping(event: Events.FPS_DROP_LEVEL_CAPPING, data: FPSDropLevelCappingData): void;
|
||
protected onMediaAttaching(event: Events.MEDIA_ATTACHING, data: MediaAttachingData): void;
|
||
protected onManifestParsed(event: Events.MANIFEST_PARSED, data: ManifestParsedData): void;
|
||
protected onBufferCodecs(event: Events.BUFFER_CODECS, data: BufferCodecsData): void;
|
||
protected onMediaDetaching(): void;
|
||
detectPlayerSize(): void;
|
||
getMaxLevel(capLevelIndex: number): number;
|
||
startCapping(): void;
|
||
stopCapping(): void;
|
||
getDimensions(): {
|
||
width: number;
|
||
height: number;
|
||
};
|
||
get mediaWidth(): number;
|
||
get mediaHeight(): number;
|
||
static get contentScaleFactor(): number;
|
||
static isLevelAllowed(level: number, restrictedLevels?: Array<number>): boolean;
|
||
static getMaxLevelByMediaSize(levels: Array<Level>, width: number, height: number): number;
|
||
}
|
||
|
||
export declare type CapLevelControllerConfig = {
|
||
capLevelToPlayerSize: boolean;
|
||
};
|
||
|
||
/**
|
||
* Keep a CEA-608 screen of 32x15 styled characters
|
||
* @constructor
|
||
*/
|
||
declare class CaptionScreen {
|
||
rows: Row[];
|
||
currRow: number;
|
||
nrRollUpRows: number | null;
|
||
lastOutputScreen: CaptionScreen | null;
|
||
logger: CaptionsLogger;
|
||
constructor(logger: CaptionsLogger);
|
||
reset(): void;
|
||
equals(other: CaptionScreen): boolean;
|
||
copy(other: CaptionScreen): void;
|
||
isEmpty(): boolean;
|
||
backSpace(): void;
|
||
clearToEndOfRow(): void;
|
||
/**
|
||
* Insert a character (without styling) in the current row.
|
||
*/
|
||
insertChar(char: number): void;
|
||
setPen(styles: Partial<PenStyles>): void;
|
||
moveCursor(relPos: number): void;
|
||
setCursor(absPos: number): void;
|
||
setPAC(pacData: PACData): void;
|
||
/**
|
||
* Set background/extra foreground, but first do back_space, and then insert space (backwards compatibility).
|
||
*/
|
||
setBkgData(bkgData: Partial<PenStyles>): void;
|
||
setRollUpRows(nrRows: number | null): void;
|
||
rollUp(): void;
|
||
/**
|
||
* Get all non-empty rows with as unicode text.
|
||
*/
|
||
getDisplayText(asOneRow?: boolean): string;
|
||
getTextAndFormat(): Row[];
|
||
}
|
||
|
||
declare class CaptionsLogger {
|
||
time: number | null;
|
||
verboseLevel: VerboseLevel;
|
||
log(severity: VerboseLevel, msg: string): void;
|
||
}
|
||
|
||
export declare class ChunkMetadata {
|
||
readonly level: number;
|
||
readonly sn: number;
|
||
readonly part: number;
|
||
readonly id: number;
|
||
readonly size: number;
|
||
readonly partial: boolean;
|
||
readonly transmuxing: HlsChunkPerformanceTiming;
|
||
readonly buffering: {
|
||
[key in SourceBufferName]: HlsChunkPerformanceTiming;
|
||
};
|
||
constructor(level: number, sn: number, id: number, size?: number, part?: number, partial?: boolean);
|
||
}
|
||
|
||
/**
|
||
* CMCD
|
||
*/
|
||
declare interface CMCD {
|
||
/**
|
||
* Encoded bitrate
|
||
*
|
||
* The encoded bitrate of the audio or video object being requested. This may not be known precisely by the player; however,
|
||
* it MAY be estimated based upon playlist/manifest declarations. If the playlist declares both peak and average bitrate values,
|
||
* the peak value should be transmitted.
|
||
*
|
||
* Integer kbps
|
||
*/
|
||
br?: number;
|
||
/**
|
||
* Object duration
|
||
*
|
||
* The playback duration in milliseconds of the object being requested. If a partial segment is being requested, then this value
|
||
* MUST indicate the playback duration of that part and not that of its parent segment. This value can be an approximation of the
|
||
* estimated duration if the explicit value is not known.
|
||
*
|
||
* Integer milliseconds
|
||
*/
|
||
d?: number;
|
||
/**
|
||
* Object type
|
||
*
|
||
* The media type of the current object being requested:
|
||
* - `m` = text file, such as a manifest or playlist
|
||
* - `a` = audio only
|
||
* - `v` = video only
|
||
* - `av` = muxed audio and video
|
||
* - `i` = init segment
|
||
* - `c` = caption or subtitle
|
||
* - `tt` = ISOBMFF timed text track
|
||
* - `k` = cryptographic key, license or certificate.
|
||
* - `o` = other
|
||
*
|
||
* If the object type being requested is unknown, then this key MUST NOT be used.
|
||
*/
|
||
ot?: CMCDObjectType;
|
||
/**
|
||
* Top bitrate
|
||
*
|
||
* The highest bitrate rendition in the manifest or playlist that the client is allowed to play, given current codec, licensing and
|
||
* sizing constraints.
|
||
*
|
||
* Integer Kbps
|
||
*/
|
||
tb?: number;
|
||
/**
|
||
* Buffer length
|
||
*
|
||
* The buffer length associated with the media object being requested. This value MUST be rounded to the nearest 100 ms. This key SHOULD only be
|
||
* sent with an object type of ‘a’, ‘v’ or ‘av’.
|
||
*
|
||
* Integer milliseconds
|
||
*/
|
||
bl?: number;
|
||
/**
|
||
* Deadline
|
||
*
|
||
* Deadline from the request time until the first sample of this Segment/Object needs to be available in order to not create a buffer underrun or
|
||
* any other playback problems. This value MUST be rounded to the nearest 100ms. For a playback rate of 1, this may be equivalent to the player’s
|
||
* remaining buffer length.
|
||
*
|
||
* Integer milliseconds
|
||
*/
|
||
dl?: number;
|
||
/**
|
||
* Measured mtp CMCD throughput
|
||
*
|
||
* The throughput between client and server, as measured by the client and MUST be rounded to the nearest 100 kbps. This value, however derived,
|
||
* SHOULD be the value that the client is using to make its next Adaptive Bitrate switching decision. If the client is connected to multiple
|
||
* servers concurrently, it must take care to report only the throughput measured against the receiving server. If the client has multiple concurrent
|
||
* connections to the server, then the intent is that this value communicates the aggregate throughput the client sees across all those connections.
|
||
*
|
||
* Integer kbps
|
||
*/
|
||
mtp?: number;
|
||
/**
|
||
* Next object request
|
||
*
|
||
* Relative path of the next object to be requested. This can be used to trigger pre-fetching by the CDN. This MUST be a path relative to the current
|
||
* request. This string MUST be URLEncoded. The client SHOULD NOT depend upon any pre-fetch action being taken - it is merely a request for such a
|
||
* pre-fetch to take place.
|
||
*
|
||
* String
|
||
*/
|
||
nor?: string;
|
||
/**
|
||
* Next range request
|
||
*
|
||
* If the next request will be a partial object request, then this string denotes the byte range to be requested. If the ‘nor’ field is not set, then the
|
||
* object is assumed to match the object currently being requested. The client SHOULD NOT depend upon any pre-fetch action being taken – it is merely a
|
||
* request for such a pre-fetch to take place. Formatting is similar to the HTTP Range header, except that the unit MUST be ‘byte’, the ‘Range:’ prefix is
|
||
* NOT required and specifying multiple ranges is NOT allowed. Valid combinations are:
|
||
*
|
||
* - `"\<range-start\>-"`
|
||
* - `"\<range-start\>-\<range-end\>"`
|
||
* - `"-\<suffix-length\>"`
|
||
*
|
||
* String
|
||
*/
|
||
nrr?: string;
|
||
/**
|
||
* Startup
|
||
*
|
||
* Key is included without a value if the object is needed urgently due to startup, seeking or recovery after a buffer-empty event. The media SHOULD not be
|
||
* rendering when this request is made. This key MUST not be sent if it is FALSE.
|
||
*
|
||
* Boolean
|
||
*/
|
||
su?: boolean;
|
||
/**
|
||
* Content ID
|
||
*
|
||
* A unique string identifying the current content. Maximum length is 64 characters. This value is consistent across multiple different
|
||
* sessions and devices and is defined and updated at the discretion of the service provider.
|
||
*
|
||
* String
|
||
*/
|
||
cid?: string;
|
||
/**
|
||
* Playback rate
|
||
*
|
||
* `1` if real-time, `2` if double speed, `0` if not playing. SHOULD only be sent if not equal to `1`.
|
||
*
|
||
* Decimal
|
||
*/
|
||
pr?: number;
|
||
/**
|
||
* Streaming format
|
||
*
|
||
* The streaming format that defines the current request.
|
||
*
|
||
* - `d` = MPEG DASH
|
||
* - `h` = HTTP Live Streaming (HLS)
|
||
* - `s` = Smooth Streaming
|
||
* - `o` = other
|
||
*
|
||
* If the streaming format being requested is unknown, then this key MUST NOT be used.
|
||
*/
|
||
sf?: CMCDStreamingFormat;
|
||
/**
|
||
* Session ID
|
||
*
|
||
* A GUID identifying the current playback session. A playback session typically ties together segments belonging to a single media asset.
|
||
* Maximum length is 64 characters. It is RECOMMENDED to conform to the UUID specification.
|
||
*
|
||
* String
|
||
*/
|
||
sid?: string;
|
||
/**
|
||
* Stream type
|
||
* - `v` = all segments are available – e.g., VOD
|
||
* - `l` = segments become available over time – e.g., LIVE
|
||
*/
|
||
st?: CMCDStreamType;
|
||
/**
|
||
* CMCD version
|
||
*
|
||
* The version of this specification used for interpreting the defined key names and values. If this key is omitted, the client and server MUST
|
||
* interpret the values as being defined by version 1. Client SHOULD omit this field if the version is 1.
|
||
*
|
||
* Integer
|
||
*/
|
||
v?: number;
|
||
/**
|
||
* Buffer starvation
|
||
*
|
||
* Key is included without a value if the buffer was starved at some point between the prior request and this object request,
|
||
* resulting in the player being in a rebuffering state and the video or audio playback being stalled. This key MUST NOT be
|
||
* sent if the buffer was not starved since the prior request.
|
||
*
|
||
* If the object type `ot` key is sent along with this key, then the `bs` key refers to the buffer associated with the particular
|
||
* object type. If no object type is communicated, then the buffer state applies to the current session.
|
||
*
|
||
* Boolean
|
||
*/
|
||
bs?: boolean;
|
||
/**
|
||
* Requested maximum throughput
|
||
*
|
||
* The requested maximum throughput that the client considers sufficient for delivery of the asset. Values MUST be rounded to the
|
||
* nearest 100kbps. For example, a client would indicate that the current segment, encoded at 2Mbps, is to be delivered at no more
|
||
* than 10Mbps, by using rtp=10000.
|
||
*
|
||
* Note: This can benefit clients by preventing buffer saturation through over-delivery and can also deliver a community benefit
|
||
* through fair-share delivery. The concept is that each client receives the throughput necessary for great performance, but no more.
|
||
* The CDN may not support the rtp feature.
|
||
*
|
||
* Integer kbps
|
||
*/
|
||
rtp?: number;
|
||
}
|
||
|
||
/**
|
||
* Controller to deal with Common Media Client Data (CMCD)
|
||
* @see https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf
|
||
*/
|
||
declare class CMCDController implements ComponentAPI {
|
||
private hls;
|
||
private config;
|
||
private media?;
|
||
private sid?;
|
||
private cid?;
|
||
private useHeaders;
|
||
private initialized;
|
||
private starved;
|
||
private buffering;
|
||
private audioBuffer?;
|
||
private videoBuffer?;
|
||
constructor(hls: Hls);
|
||
private registerListeners;
|
||
private unregisterListeners;
|
||
destroy(): void;
|
||
private onMediaAttached;
|
||
private onMediaDetached;
|
||
private onBufferCreated;
|
||
private onWaiting;
|
||
private onPlaying;
|
||
/**
|
||
* Create baseline CMCD data
|
||
*/
|
||
private createData;
|
||
/**
|
||
* Apply CMCD data to a request.
|
||
*/
|
||
private apply;
|
||
/**
|
||
* Apply CMCD data to a manifest request.
|
||
*/
|
||
private applyPlaylistData;
|
||
/**
|
||
* Apply CMCD data to a segment request
|
||
*/
|
||
private applyFragmentData;
|
||
/**
|
||
* The CMCD object type.
|
||
*/
|
||
private getObjectType;
|
||
/**
|
||
* Get the highest bitrate.
|
||
*/
|
||
private getTopBandwidth;
|
||
/**
|
||
* Get the buffer length for a media type in milliseconds
|
||
*/
|
||
private getBufferLength;
|
||
/**
|
||
* Create a playlist loader
|
||
*/
|
||
private createPlaylistLoader;
|
||
/**
|
||
* Create a playlist loader
|
||
*/
|
||
private createFragmentLoader;
|
||
/**
|
||
* Generate a random v4 UUI
|
||
*
|
||
* @returns {string}
|
||
*/
|
||
static uuid(): string;
|
||
/**
|
||
* Serialize a CMCD data object according to the rules defined in the
|
||
* section 3.2 of
|
||
* [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
|
||
*/
|
||
static serialize(data: CMCD): string;
|
||
/**
|
||
* Convert a CMCD data object to request headers according to the rules
|
||
* defined in the section 2.1 and 3.2 of
|
||
* [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
|
||
*/
|
||
static toHeaders(data: CMCD): Partial<CMCDHeaders>;
|
||
/**
|
||
* Convert a CMCD data object to query args according to the rules
|
||
* defined in the section 2.2 and 3.2 of
|
||
* [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
|
||
*/
|
||
static toQuery(data: CMCD): string;
|
||
/**
|
||
* Append query args to a uri.
|
||
*/
|
||
static appendQueryToUri(uri: any, query: any): any;
|
||
}
|
||
|
||
export declare type CMCDControllerConfig = {
|
||
sessionId?: string;
|
||
contentId?: string;
|
||
useHeaders?: boolean;
|
||
};
|
||
|
||
/**
|
||
* CMCD Headers
|
||
*/
|
||
declare interface CMCDHeaders {
|
||
'CMCD-Object': string;
|
||
'CMCD-Request': string;
|
||
'CMCD-Session': string;
|
||
'CMCD-Status': string;
|
||
}
|
||
|
||
/**
|
||
* CMCD Object Type
|
||
*/
|
||
declare enum CMCDObjectType {
|
||
MANIFEST = "m",
|
||
AUDIO = "a",
|
||
VIDEO = "v",
|
||
MUXED = "av",
|
||
INIT = "i",
|
||
CAPTION = "c",
|
||
TIMED_TEXT = "tt",
|
||
KEY = "k",
|
||
OTHER = "o"
|
||
}
|
||
|
||
/**
|
||
* CMCD Streaming Format
|
||
*/
|
||
declare enum CMCDStreamingFormat {
|
||
DASH = "d",
|
||
HLS = "h",
|
||
SMOOTH = "s",
|
||
OTHER = "o"
|
||
}
|
||
|
||
/**
|
||
* CMCD Streaming Type
|
||
*/
|
||
declare enum CMCDStreamType {
|
||
VOD = "v",
|
||
LIVE = "l"
|
||
}
|
||
|
||
declare interface ComponentAPI {
|
||
destroy(): void;
|
||
}
|
||
|
||
export declare interface CuesInterface {
|
||
newCue(track: TextTrack | null, startTime: number, endTime: number, captionScreen: CaptionScreen): VTTCue[];
|
||
}
|
||
|
||
export declare interface CuesParsedData {
|
||
type: 'captions' | 'subtitles';
|
||
cues: any;
|
||
track: string;
|
||
}
|
||
|
||
declare class Decrypter {
|
||
private logEnabled;
|
||
private observer;
|
||
private config;
|
||
private removePKCS7Padding;
|
||
private subtle;
|
||
private softwareDecrypter;
|
||
private key;
|
||
private fastAesKey;
|
||
private remainderData;
|
||
private currentIV;
|
||
private currentResult;
|
||
constructor(observer: HlsEventEmitter, config: HlsConfig, { removePKCS7Padding }?: {
|
||
removePKCS7Padding?: boolean | undefined;
|
||
});
|
||
destroy(): void;
|
||
isSync(): boolean;
|
||
flush(): Uint8Array | void;
|
||
reset(): void;
|
||
decrypt(data: Uint8Array | ArrayBuffer, key: ArrayBuffer, iv: ArrayBuffer, callback: (decryptedData: ArrayBuffer) => void): void;
|
||
softwareDecrypt(data: Uint8Array, key: ArrayBuffer, iv: ArrayBuffer): ArrayBuffer | null;
|
||
webCryptoDecrypt(data: Uint8Array, key: ArrayBuffer, iv: ArrayBuffer): Promise<ArrayBuffer>;
|
||
private onWebCryptoError;
|
||
private getValidChunk;
|
||
private logOnce;
|
||
}
|
||
|
||
export declare type DRMSystemOptions = {
|
||
audioRobustness?: string;
|
||
videoRobustness?: string;
|
||
};
|
||
|
||
export declare interface ElementaryStreamInfo {
|
||
startPTS: number;
|
||
endPTS: number;
|
||
startDTS: number;
|
||
endDTS: number;
|
||
partial?: boolean;
|
||
}
|
||
|
||
export declare type ElementaryStreams = Record<ElementaryStreamTypes, ElementaryStreamInfo | null>;
|
||
|
||
export declare enum ElementaryStreamTypes {
|
||
AUDIO = "audio",
|
||
VIDEO = "video",
|
||
AUDIOVIDEO = "audiovideo"
|
||
}
|
||
|
||
/**
|
||
* Controller to deal with encrypted media extensions (EME)
|
||
* @see https://developer.mozilla.org/en-US/docs/Web/API/Encrypted_Media_Extensions_API
|
||
*
|
||
* @class
|
||
* @constructor
|
||
*/
|
||
declare class EMEController implements ComponentAPI {
|
||
private hls;
|
||
private _widevineLicenseUrl?;
|
||
private _licenseXhrSetup?;
|
||
private _licenseResponseCallback?;
|
||
private _emeEnabled;
|
||
private _requestMediaKeySystemAccess;
|
||
private _drmSystemOptions;
|
||
private _config;
|
||
private _mediaKeysList;
|
||
private _media;
|
||
private _hasSetMediaKeys;
|
||
private _requestLicenseFailureCount;
|
||
private mediaKeysPromise;
|
||
private _onMediaEncrypted;
|
||
/**
|
||
* @constructs
|
||
* @param {Hls} hls Our Hls.js instance
|
||
*/
|
||
constructor(hls: Hls);
|
||
destroy(): void;
|
||
private _registerListeners;
|
||
private _unregisterListeners;
|
||
/**
|
||
* @param {string} keySystem Identifier for the key-system, see `KeySystems` enum
|
||
* @returns {string} License server URL for key-system (if any configured, otherwise causes error)
|
||
* @throws if a unsupported keysystem is passed
|
||
*/
|
||
getLicenseServerUrl(keySystem: KeySystems): string;
|
||
/**
|
||
* Requests access object and adds it to our list upon success
|
||
* @private
|
||
* @param {string} keySystem System ID (see `KeySystems`)
|
||
* @param {Array<string>} audioCodecs List of required audio codecs to support
|
||
* @param {Array<string>} videoCodecs List of required video codecs to support
|
||
* @throws When a unsupported KeySystem is passed
|
||
*/
|
||
private _attemptKeySystemAccess;
|
||
get requestMediaKeySystemAccess(): MediaKeyFunc;
|
||
/**
|
||
* Handles obtaining access to a key-system
|
||
* @private
|
||
* @param {string} keySystem
|
||
* @param {MediaKeySystemAccess} mediaKeySystemAccess https://developer.mozilla.org/en-US/docs/Web/API/MediaKeySystemAccess
|
||
*/
|
||
private _onMediaKeySystemAccessObtained;
|
||
/**
|
||
* Handles key-creation (represents access to CDM). We are going to create key-sessions upon this
|
||
* for all existing keys where no session exists yet.
|
||
*
|
||
* @private
|
||
*/
|
||
private _onMediaKeysCreated;
|
||
/**
|
||
* @private
|
||
* @param {*} keySession
|
||
*/
|
||
private _onNewMediaKeySession;
|
||
/**
|
||
* @private
|
||
* @param {MediaKeySession} keySession
|
||
* @param {ArrayBuffer} message
|
||
*/
|
||
private _onKeySessionMessage;
|
||
/**
|
||
* @private
|
||
* @param e {MediaEncryptedEvent}
|
||
*/
|
||
private onMediaEncrypted;
|
||
/**
|
||
* @private
|
||
*/
|
||
private _attemptSetMediaKeys;
|
||
/**
|
||
* @private
|
||
*/
|
||
private _generateRequestWithPreferredKeySession;
|
||
/**
|
||
* @private
|
||
* @param {string} url License server URL
|
||
* @param {ArrayBuffer} keyMessage Message data issued by key-system
|
||
* @param {function} callback Called when XHR has succeeded
|
||
* @returns {XMLHttpRequest} Unsent (but opened state) XHR object
|
||
* @throws if XMLHttpRequest construction failed
|
||
*/
|
||
private _createLicenseXhr;
|
||
/**
|
||
* @private
|
||
* @param {XMLHttpRequest} xhr
|
||
* @param {string} url License server URL
|
||
* @param {ArrayBuffer} keyMessage Message data issued by key-system
|
||
* @param {function} callback Called when XHR has succeeded
|
||
*/
|
||
private _onLicenseRequestReadyStageChange;
|
||
/**
|
||
* @private
|
||
* @param {MediaKeysListItem} keysListItem
|
||
* @param {ArrayBuffer} keyMessage
|
||
* @returns {ArrayBuffer} Challenge data posted to license server
|
||
* @throws if KeySystem is unsupported
|
||
*/
|
||
private _generateLicenseRequestChallenge;
|
||
/**
|
||
* @private
|
||
* @param keyMessage
|
||
* @param callback
|
||
*/
|
||
private _requestLicense;
|
||
onMediaAttached(event: Events.MEDIA_ATTACHED, data: MediaAttachedData): void;
|
||
onMediaDetached(): void;
|
||
onManifestParsed(event: Events.MANIFEST_PARSED, data: ManifestParsedData): void;
|
||
}
|
||
|
||
export declare type EMEControllerConfig = {
|
||
licenseXhrSetup?: (xhr: XMLHttpRequest, url: string) => void;
|
||
licenseResponseCallback?: (xhr: XMLHttpRequest, url: string) => ArrayBuffer;
|
||
emeEnabled: boolean;
|
||
widevineLicenseUrl?: string;
|
||
drmSystemOptions: DRMSystemOptions;
|
||
requestMediaKeySystemAccessFunc: MediaKeyFunc | null;
|
||
};
|
||
|
||
export declare interface ErrorData {
|
||
type: ErrorTypes;
|
||
details: ErrorDetails;
|
||
fatal: boolean;
|
||
buffer?: number;
|
||
bytes?: number;
|
||
context?: PlaylistLoaderContext;
|
||
error?: Error;
|
||
event?: keyof HlsListeners | 'demuxerWorker';
|
||
frag?: Fragment;
|
||
level?: number | undefined;
|
||
levelRetry?: boolean;
|
||
loader?: Loader<LoaderContext>;
|
||
networkDetails?: any;
|
||
mimeType?: string;
|
||
reason?: string;
|
||
response?: LoaderResponse;
|
||
url?: string;
|
||
parent?: PlaylistLevelType;
|
||
err?: {
|
||
message: string;
|
||
};
|
||
}
|
||
|
||
/**
|
||
* @enum {ErrorDetails}
|
||
* @typedef {string} ErrorDetail
|
||
*/
|
||
export declare enum ErrorDetails {
|
||
KEY_SYSTEM_NO_KEYS = "keySystemNoKeys",
|
||
KEY_SYSTEM_NO_ACCESS = "keySystemNoAccess",
|
||
KEY_SYSTEM_NO_SESSION = "keySystemNoSession",
|
||
KEY_SYSTEM_LICENSE_REQUEST_FAILED = "keySystemLicenseRequestFailed",
|
||
KEY_SYSTEM_NO_INIT_DATA = "keySystemNoInitData",
|
||
MANIFEST_LOAD_ERROR = "manifestLoadError",
|
||
MANIFEST_LOAD_TIMEOUT = "manifestLoadTimeOut",
|
||
MANIFEST_PARSING_ERROR = "manifestParsingError",
|
||
MANIFEST_INCOMPATIBLE_CODECS_ERROR = "manifestIncompatibleCodecsError",
|
||
LEVEL_EMPTY_ERROR = "levelEmptyError",
|
||
LEVEL_LOAD_ERROR = "levelLoadError",
|
||
LEVEL_LOAD_TIMEOUT = "levelLoadTimeOut",
|
||
LEVEL_SWITCH_ERROR = "levelSwitchError",
|
||
AUDIO_TRACK_LOAD_ERROR = "audioTrackLoadError",
|
||
AUDIO_TRACK_LOAD_TIMEOUT = "audioTrackLoadTimeOut",
|
||
SUBTITLE_LOAD_ERROR = "subtitleTrackLoadError",
|
||
SUBTITLE_TRACK_LOAD_TIMEOUT = "subtitleTrackLoadTimeOut",
|
||
FRAG_LOAD_ERROR = "fragLoadError",
|
||
FRAG_LOAD_TIMEOUT = "fragLoadTimeOut",
|
||
FRAG_DECRYPT_ERROR = "fragDecryptError",
|
||
FRAG_PARSING_ERROR = "fragParsingError",
|
||
REMUX_ALLOC_ERROR = "remuxAllocError",
|
||
KEY_LOAD_ERROR = "keyLoadError",
|
||
KEY_LOAD_TIMEOUT = "keyLoadTimeOut",
|
||
BUFFER_ADD_CODEC_ERROR = "bufferAddCodecError",
|
||
BUFFER_INCOMPATIBLE_CODECS_ERROR = "bufferIncompatibleCodecsError",
|
||
BUFFER_APPEND_ERROR = "bufferAppendError",
|
||
BUFFER_APPENDING_ERROR = "bufferAppendingError",
|
||
BUFFER_STALLED_ERROR = "bufferStalledError",
|
||
BUFFER_FULL_ERROR = "bufferFullError",
|
||
BUFFER_SEEK_OVER_HOLE = "bufferSeekOverHole",
|
||
BUFFER_NUDGE_ON_STALL = "bufferNudgeOnStall",
|
||
INTERNAL_EXCEPTION = "internalException",
|
||
INTERNAL_ABORTED = "aborted",
|
||
UNKNOWN = "unknown"
|
||
}
|
||
|
||
export declare enum ErrorTypes {
|
||
NETWORK_ERROR = "networkError",
|
||
MEDIA_ERROR = "mediaError",
|
||
KEY_SYSTEM_ERROR = "keySystemError",
|
||
MUX_ERROR = "muxError",
|
||
OTHER_ERROR = "otherError"
|
||
}
|
||
|
||
/**
|
||
* @readonly
|
||
* @enum {string}
|
||
*/
|
||
export declare enum Events {
|
||
MEDIA_ATTACHING = "hlsMediaAttaching",
|
||
MEDIA_ATTACHED = "hlsMediaAttached",
|
||
MEDIA_DETACHING = "hlsMediaDetaching",
|
||
MEDIA_DETACHED = "hlsMediaDetached",
|
||
BUFFER_RESET = "hlsBufferReset",
|
||
BUFFER_CODECS = "hlsBufferCodecs",
|
||
BUFFER_CREATED = "hlsBufferCreated",
|
||
BUFFER_APPENDING = "hlsBufferAppending",
|
||
BUFFER_APPENDED = "hlsBufferAppended",
|
||
BUFFER_EOS = "hlsBufferEos",
|
||
BUFFER_FLUSHING = "hlsBufferFlushing",
|
||
BUFFER_FLUSHED = "hlsBufferFlushed",
|
||
MANIFEST_LOADING = "hlsManifestLoading",
|
||
MANIFEST_LOADED = "hlsManifestLoaded",
|
||
MANIFEST_PARSED = "hlsManifestParsed",
|
||
LEVEL_SWITCHING = "hlsLevelSwitching",
|
||
LEVEL_SWITCHED = "hlsLevelSwitched",
|
||
LEVEL_LOADING = "hlsLevelLoading",
|
||
LEVEL_LOADED = "hlsLevelLoaded",
|
||
LEVEL_UPDATED = "hlsLevelUpdated",
|
||
LEVEL_PTS_UPDATED = "hlsLevelPtsUpdated",
|
||
LEVELS_UPDATED = "hlsLevelsUpdated",
|
||
AUDIO_TRACKS_UPDATED = "hlsAudioTracksUpdated",
|
||
AUDIO_TRACK_SWITCHING = "hlsAudioTrackSwitching",
|
||
AUDIO_TRACK_SWITCHED = "hlsAudioTrackSwitched",
|
||
AUDIO_TRACK_LOADING = "hlsAudioTrackLoading",
|
||
AUDIO_TRACK_LOADED = "hlsAudioTrackLoaded",
|
||
SUBTITLE_TRACKS_UPDATED = "hlsSubtitleTracksUpdated",
|
||
SUBTITLE_TRACKS_CLEARED = "hlsSubtitleTracksCleared",
|
||
SUBTITLE_TRACK_SWITCH = "hlsSubtitleTrackSwitch",
|
||
SUBTITLE_TRACK_LOADING = "hlsSubtitleTrackLoading",
|
||
SUBTITLE_TRACK_LOADED = "hlsSubtitleTrackLoaded",
|
||
SUBTITLE_FRAG_PROCESSED = "hlsSubtitleFragProcessed",
|
||
CUES_PARSED = "hlsCuesParsed",
|
||
NON_NATIVE_TEXT_TRACKS_FOUND = "hlsNonNativeTextTracksFound",
|
||
INIT_PTS_FOUND = "hlsInitPtsFound",
|
||
FRAG_LOADING = "hlsFragLoading",
|
||
FRAG_LOAD_EMERGENCY_ABORTED = "hlsFragLoadEmergencyAborted",
|
||
FRAG_LOADED = "hlsFragLoaded",
|
||
FRAG_DECRYPTED = "hlsFragDecrypted",
|
||
FRAG_PARSING_INIT_SEGMENT = "hlsFragParsingInitSegment",
|
||
FRAG_PARSING_USERDATA = "hlsFragParsingUserdata",
|
||
FRAG_PARSING_METADATA = "hlsFragParsingMetadata",
|
||
FRAG_PARSED = "hlsFragParsed",
|
||
FRAG_BUFFERED = "hlsFragBuffered",
|
||
FRAG_CHANGED = "hlsFragChanged",
|
||
FPS_DROP = "hlsFpsDrop",
|
||
FPS_DROP_LEVEL_CAPPING = "hlsFpsDropLevelCapping",
|
||
ERROR = "hlsError",
|
||
DESTROYING = "hlsDestroying",
|
||
KEY_LOADING = "hlsKeyLoading",
|
||
KEY_LOADED = "hlsKeyLoaded",
|
||
LIVE_BACK_BUFFER_REACHED = "hlsLiveBackBufferReached",
|
||
BACK_BUFFER_REACHED = "hlsBackBufferReached"
|
||
}
|
||
|
||
declare class EwmaBandWidthEstimator {
|
||
private defaultEstimate_;
|
||
private minWeight_;
|
||
private minDelayMs_;
|
||
private slow_;
|
||
private fast_;
|
||
constructor(slow: number, fast: number, defaultEstimate: number);
|
||
update(slow: number, fast: number): void;
|
||
sample(durationMs: number, numBytes: number): void;
|
||
canEstimate(): boolean;
|
||
getEstimate(): number;
|
||
destroy(): void;
|
||
}
|
||
|
||
declare type ExtendedSourceBuffer = SourceBuffer & {
|
||
ended?: boolean;
|
||
changeType?: (type: string) => void;
|
||
};
|
||
|
||
declare class FPSController implements ComponentAPI {
|
||
private hls;
|
||
private isVideoPlaybackQualityAvailable;
|
||
private timer?;
|
||
private media;
|
||
private lastTime;
|
||
private lastDroppedFrames;
|
||
private lastDecodedFrames;
|
||
private streamController;
|
||
constructor(hls: Hls);
|
||
setStreamController(streamController: StreamController): void;
|
||
protected registerListeners(): void;
|
||
protected unregisterListeners(): void;
|
||
destroy(): void;
|
||
protected onMediaAttaching(event: Events.MEDIA_ATTACHING, data: MediaAttachingData): void;
|
||
checkFPS(video: HTMLVideoElement, decodedFrames: number, droppedFrames: number): void;
|
||
checkFPSInterval(): void;
|
||
}
|
||
|
||
export declare type FPSControllerConfig = {
|
||
capLevelOnFPSDrop: boolean;
|
||
fpsDroppedMonitoringPeriod: number;
|
||
fpsDroppedMonitoringThreshold: number;
|
||
};
|
||
|
||
export declare interface FPSDropData {
|
||
currentDropped: number;
|
||
currentDecoded: number;
|
||
totalDroppedFrames: number;
|
||
}
|
||
|
||
export declare interface FPSDropLevelCappingData {
|
||
droppedLevel: number;
|
||
level: number;
|
||
}
|
||
|
||
export declare interface FragBufferedData {
|
||
stats: LoadStats;
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
id: string;
|
||
}
|
||
|
||
export declare interface FragChangedData {
|
||
frag: Fragment;
|
||
}
|
||
|
||
export declare interface FragDecryptedData {
|
||
frag: Fragment;
|
||
payload: ArrayBuffer;
|
||
stats: {
|
||
tstart: number;
|
||
tdecrypt: number;
|
||
};
|
||
}
|
||
|
||
export declare interface FragLoadedData {
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
payload: ArrayBuffer;
|
||
networkDetails: unknown;
|
||
}
|
||
|
||
export declare interface FragLoadEmergencyAbortedData {
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
stats: LoaderStats;
|
||
}
|
||
|
||
export declare interface FragLoadingData {
|
||
frag: Fragment;
|
||
part?: Part;
|
||
targetBufferTime: number | null;
|
||
}
|
||
|
||
export declare class Fragment extends BaseSegment {
|
||
private _decryptdata;
|
||
rawProgramDateTime: string | null;
|
||
programDateTime: number | null;
|
||
tagList: Array<string[]>;
|
||
duration: number;
|
||
sn: number | 'initSegment';
|
||
levelkey?: LevelKey;
|
||
readonly type: PlaylistLevelType;
|
||
loader: Loader<FragmentLoaderContext> | null;
|
||
level: number;
|
||
cc: number;
|
||
startPTS?: number;
|
||
endPTS?: number;
|
||
appendedPTS?: number;
|
||
startDTS: number;
|
||
endDTS: number;
|
||
start: number;
|
||
deltaPTS?: number;
|
||
maxStartPTS?: number;
|
||
minEndPTS?: number;
|
||
stats: LoadStats;
|
||
urlId: number;
|
||
data?: Uint8Array;
|
||
bitrateTest: boolean;
|
||
title: string | null;
|
||
initSegment: Fragment | null;
|
||
constructor(type: PlaylistLevelType, baseurl: string);
|
||
get decryptdata(): LevelKey | null;
|
||
get end(): number;
|
||
get endProgramDateTime(): number | null;
|
||
get encrypted(): boolean;
|
||
/**
|
||
* Utility method for parseLevelPlaylist to create an initialization vector for a given segment
|
||
* @param {number} segmentNumber - segment number to generate IV with
|
||
* @returns {Uint8Array}
|
||
*/
|
||
createInitializationVector(segmentNumber: number): Uint8Array;
|
||
/**
|
||
* Utility method for parseLevelPlaylist to get a fragment's decryption data from the currently parsed encryption key data
|
||
* @param levelkey - a playlist's encryption info
|
||
* @param segmentNumber - the fragment's segment number
|
||
* @returns {LevelKey} - an object to be applied as a fragment's decryptdata
|
||
*/
|
||
setDecryptDataFromLevelKey(levelkey: LevelKey, segmentNumber: number): LevelKey;
|
||
setElementaryStreamInfo(type: ElementaryStreamTypes, startPTS: number, endPTS: number, startDTS: number, endDTS: number, partial?: boolean): void;
|
||
clearElementaryStreamInfo(): void;
|
||
}
|
||
|
||
declare class FragmentLoader {
|
||
private readonly config;
|
||
private loader;
|
||
private partLoadTimeout;
|
||
constructor(config: HlsConfig);
|
||
destroy(): void;
|
||
abort(): void;
|
||
load(frag: Fragment, onProgress?: FragmentLoadProgressCallback): Promise<FragLoadedData>;
|
||
loadPart(frag: Fragment, part: Part, onProgress: FragmentLoadProgressCallback): Promise<FragLoadedData>;
|
||
private updateStatsFromPart;
|
||
private resetLoader;
|
||
}
|
||
|
||
export declare type FragmentLoaderConfig = {
|
||
fLoader?: FragmentLoaderConstructor;
|
||
fragLoadingTimeOut: number;
|
||
fragLoadingMaxRetry: number;
|
||
fragLoadingRetryDelay: number;
|
||
fragLoadingMaxRetryTimeout: number;
|
||
};
|
||
|
||
export declare interface FragmentLoaderConstructor {
|
||
new (confg: HlsConfig): Loader<FragmentLoaderContext>;
|
||
}
|
||
|
||
export declare interface FragmentLoaderContext extends LoaderContext {
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
}
|
||
|
||
declare type FragmentLoadProgressCallback = (result: FragLoadedData) => void;
|
||
|
||
declare enum FragmentState {
|
||
NOT_LOADED = "NOT_LOADED",
|
||
BACKTRACKED = "BACKTRACKED",
|
||
APPENDING = "APPENDING",
|
||
PARTIAL = "PARTIAL",
|
||
OK = "OK"
|
||
}
|
||
|
||
declare class FragmentTracker implements ComponentAPI {
|
||
private activeFragment;
|
||
private activeParts;
|
||
private fragments;
|
||
private timeRanges;
|
||
private bufferPadding;
|
||
private hls;
|
||
constructor(hls: Hls);
|
||
private _registerListeners;
|
||
private _unregisterListeners;
|
||
destroy(): void;
|
||
/**
|
||
* Return a Fragment with an appended range that matches the position and levelType.
|
||
* If not found any Fragment, return null
|
||
*/
|
||
getAppendedFrag(position: number, levelType: PlaylistLevelType): Fragment | Part | null;
|
||
/**
|
||
* Return a buffered Fragment that matches the position and levelType.
|
||
* A buffered Fragment is one whose loading, parsing and appending is done (completed or "partial" meaning aborted).
|
||
* If not found any Fragment, return null
|
||
*/
|
||
getBufferedFrag(position: number, levelType: PlaylistLevelType): Fragment | null;
|
||
/**
|
||
* Partial fragments effected by coded frame eviction will be removed
|
||
* The browser will unload parts of the buffer to free up memory for new buffer data
|
||
* Fragments will need to be reloaded when the buffer is freed up, removing partial fragments will allow them to reload(since there might be parts that are still playable)
|
||
*/
|
||
detectEvictedFragments(elementaryStream: SourceBufferName, timeRange: TimeRanges, playlistType?: PlaylistLevelType): void;
|
||
/**
|
||
* Checks if the fragment passed in is loaded in the buffer properly
|
||
* Partially loaded fragments will be registered as a partial fragment
|
||
*/
|
||
private detectPartialFragments;
|
||
fragBuffered(frag: Fragment): void;
|
||
private getBufferedTimes;
|
||
/**
|
||
* Gets the partial fragment for a certain time
|
||
*/
|
||
getPartialFragment(time: number): Fragment | null;
|
||
getState(fragment: Fragment): FragmentState;
|
||
backtrack(frag: Fragment, data?: FragLoadedData): FragLoadedData | null;
|
||
getBacktrackData(fragment: Fragment): FragLoadedData | null;
|
||
private isTimeBuffered;
|
||
private onFragLoaded;
|
||
private onBufferAppended;
|
||
private onFragBuffered;
|
||
private hasFragment;
|
||
removeFragmentsInRange(start: number, end: number, playlistType: PlaylistLevelType): void;
|
||
removeFragment(fragment: Fragment): void;
|
||
removeAllFragments(): void;
|
||
}
|
||
|
||
export declare interface FragParsedData {
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
}
|
||
|
||
export declare interface FragParsingInitSegmentData {
|
||
}
|
||
|
||
export declare interface FragParsingMetadataData {
|
||
id: string;
|
||
frag: Fragment;
|
||
samples: MetadataSample[];
|
||
}
|
||
|
||
export declare interface FragParsingUserdataData {
|
||
id: string;
|
||
frag: Fragment;
|
||
samples: UserdataSample[];
|
||
}
|
||
|
||
/**
|
||
* @module Hls
|
||
* @class
|
||
* @constructor
|
||
*/
|
||
declare class Hls implements HlsEventEmitter {
|
||
private static defaultConfig?;
|
||
readonly config: HlsConfig;
|
||
readonly userConfig: Partial<HlsConfig>;
|
||
private coreComponents;
|
||
private networkControllers;
|
||
private _emitter;
|
||
private _autoLevelCapping;
|
||
private abrController;
|
||
private bufferController;
|
||
private capLevelController;
|
||
private latencyController;
|
||
private levelController;
|
||
private streamController;
|
||
private audioTrackController;
|
||
private subtitleTrackController;
|
||
private emeController;
|
||
private cmcdController;
|
||
private _media;
|
||
private url;
|
||
static get version(): string;
|
||
static isSupported(): boolean;
|
||
static get Events(): typeof Events;
|
||
static get ErrorTypes(): typeof ErrorTypes;
|
||
static get ErrorDetails(): typeof ErrorDetails;
|
||
static get DefaultConfig(): HlsConfig;
|
||
/**
|
||
* @type {HlsConfig}
|
||
*/
|
||
static set DefaultConfig(defaultConfig: HlsConfig);
|
||
/**
|
||
* Creates an instance of an HLS client that can attach to exactly one `HTMLMediaElement`.
|
||
*
|
||
* @constructs Hls
|
||
* @param {HlsConfig} config
|
||
*/
|
||
constructor(userConfig?: Partial<HlsConfig>);
|
||
createController(ControllerClass: any, fragmentTracker: any, components: any): any;
|
||
on<E extends keyof HlsListeners, Context = undefined>(event: E, listener: HlsListeners[E], context?: Context): void;
|
||
once<E extends keyof HlsListeners, Context = undefined>(event: E, listener: HlsListeners[E], context?: Context): void;
|
||
removeAllListeners<E extends keyof HlsListeners>(event?: E | undefined): void;
|
||
off<E extends keyof HlsListeners, Context = undefined>(event: E, listener?: HlsListeners[E] | undefined, context?: Context, once?: boolean | undefined): void;
|
||
listeners<E extends keyof HlsListeners>(event: E): HlsListeners[E][];
|
||
emit<E extends keyof HlsListeners>(event: E, name: E, eventObject: Parameters<HlsListeners[E]>[1]): boolean;
|
||
trigger<E extends keyof HlsListeners>(event: E, eventObject: Parameters<HlsListeners[E]>[1]): boolean;
|
||
listenerCount<E extends keyof HlsListeners>(event: E): number;
|
||
/**
|
||
* Dispose of the instance
|
||
*/
|
||
destroy(): void;
|
||
/**
|
||
* Attaches Hls.js to a media element
|
||
* @param {HTMLMediaElement} media
|
||
*/
|
||
attachMedia(media: HTMLMediaElement): void;
|
||
/**
|
||
* Detach Hls.js from the media
|
||
*/
|
||
detachMedia(): void;
|
||
/**
|
||
* Set the source URL. Can be relative or absolute.
|
||
* @param {string} url
|
||
*/
|
||
loadSource(url: string): void;
|
||
/**
|
||
* Start loading data from the stream source.
|
||
* Depending on default config, client starts loading automatically when a source is set.
|
||
*
|
||
* @param {number} startPosition Set the start position to stream from
|
||
* @default -1 None (from earliest point)
|
||
*/
|
||
startLoad(startPosition?: number): void;
|
||
/**
|
||
* Stop loading of any stream data.
|
||
*/
|
||
stopLoad(): void;
|
||
/**
|
||
* Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
|
||
*/
|
||
swapAudioCodec(): void;
|
||
/**
|
||
* When the media-element fails, this allows to detach and then re-attach it
|
||
* as one call (convenience method).
|
||
*
|
||
* Automatic recovery of media-errors by this process is configurable.
|
||
*/
|
||
recoverMediaError(): void;
|
||
removeLevel(levelIndex: any, urlId?: number): void;
|
||
/**
|
||
* @type {Level[]}
|
||
*/
|
||
get levels(): Array<Level>;
|
||
/**
|
||
* Index of quality level currently played
|
||
* @type {number}
|
||
*/
|
||
get currentLevel(): number;
|
||
/**
|
||
* Set quality level index immediately .
|
||
* This will flush the current buffer to replace the quality asap.
|
||
* That means playback will interrupt at least shortly to re-buffer and re-sync eventually.
|
||
* @type {number} -1 for automatic level selection
|
||
*/
|
||
set currentLevel(newLevel: number);
|
||
/**
|
||
* Index of next quality level loaded as scheduled by stream controller.
|
||
* @type {number}
|
||
*/
|
||
get nextLevel(): number;
|
||
/**
|
||
* Set quality level index for next loaded data.
|
||
* This will switch the video quality asap, without interrupting playback.
|
||
* May abort current loading of data, and flush parts of buffer (outside currently played fragment region).
|
||
* @type {number} -1 for automatic level selection
|
||
*/
|
||
set nextLevel(newLevel: number);
|
||
/**
|
||
* Return the quality level of the currently or last (of none is loaded currently) segment
|
||
* @type {number}
|
||
*/
|
||
get loadLevel(): number;
|
||
/**
|
||
* Set quality level index for next loaded data in a conservative way.
|
||
* This will switch the quality without flushing, but interrupt current loading.
|
||
* Thus the moment when the quality switch will appear in effect will only be after the already existing buffer.
|
||
* @type {number} newLevel -1 for automatic level selection
|
||
*/
|
||
set loadLevel(newLevel: number);
|
||
/**
|
||
* get next quality level loaded
|
||
* @type {number}
|
||
*/
|
||
get nextLoadLevel(): number;
|
||
/**
|
||
* Set quality level of next loaded segment in a fully "non-destructive" way.
|
||
* Same as `loadLevel` but will wait for next switch (until current loading is done).
|
||
* @type {number} level
|
||
*/
|
||
set nextLoadLevel(level: number);
|
||
/**
|
||
* Return "first level": like a default level, if not set,
|
||
* falls back to index of first level referenced in manifest
|
||
* @type {number}
|
||
*/
|
||
get firstLevel(): number;
|
||
/**
|
||
* Sets "first-level", see getter.
|
||
* @type {number}
|
||
*/
|
||
set firstLevel(newLevel: number);
|
||
/**
|
||
* Return start level (level of first fragment that will be played back)
|
||
* if not overrided by user, first level appearing in manifest will be used as start level
|
||
* if -1 : automatic start level selection, playback will start from level matching download bandwidth
|
||
* (determined from download of first segment)
|
||
* @type {number}
|
||
*/
|
||
get startLevel(): number;
|
||
/**
|
||
* set start level (level of first fragment that will be played back)
|
||
* if not overrided by user, first level appearing in manifest will be used as start level
|
||
* if -1 : automatic start level selection, playback will start from level matching download bandwidth
|
||
* (determined from download of first segment)
|
||
* @type {number} newLevel
|
||
*/
|
||
set startLevel(newLevel: number);
|
||
/**
|
||
* Get the current setting for capLevelToPlayerSize
|
||
*
|
||
* @type {boolean}
|
||
*/
|
||
get capLevelToPlayerSize(): boolean;
|
||
/**
|
||
* set dynamically set capLevelToPlayerSize against (`CapLevelController`)
|
||
*
|
||
* @type {boolean}
|
||
*/
|
||
set capLevelToPlayerSize(shouldStartCapping: boolean);
|
||
/**
|
||
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
||
* @type {number}
|
||
*/
|
||
get autoLevelCapping(): number;
|
||
/**
|
||
* get bandwidth estimate
|
||
* @type {number}
|
||
*/
|
||
get bandwidthEstimate(): number;
|
||
/**
|
||
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
||
* @type {number}
|
||
*/
|
||
set autoLevelCapping(newLevel: number);
|
||
/**
|
||
* True when automatic level selection enabled
|
||
* @type {boolean}
|
||
*/
|
||
get autoLevelEnabled(): boolean;
|
||
/**
|
||
* Level set manually (if any)
|
||
* @type {number}
|
||
*/
|
||
get manualLevel(): number;
|
||
/**
|
||
* min level selectable in auto mode according to config.minAutoBitrate
|
||
* @type {number}
|
||
*/
|
||
get minAutoLevel(): number;
|
||
/**
|
||
* max level selectable in auto mode according to autoLevelCapping
|
||
* @type {number}
|
||
*/
|
||
get maxAutoLevel(): number;
|
||
/**
|
||
* next automatically selected quality level
|
||
* @type {number}
|
||
*/
|
||
get nextAutoLevel(): number;
|
||
/**
|
||
* this setter is used to force next auto level.
|
||
* this is useful to force a switch down in auto mode:
|
||
* in case of load error on level N, hls.js can set nextAutoLevel to N-1 for example)
|
||
* forced value is valid for one fragment. upon succesful frag loading at forced level,
|
||
* this value will be resetted to -1 by ABR controller.
|
||
* @type {number}
|
||
*/
|
||
set nextAutoLevel(nextLevel: number);
|
||
/**
|
||
* @type {AudioTrack[]}
|
||
*/
|
||
get audioTracks(): Array<MediaPlaylist>;
|
||
/**
|
||
* index of the selected audio track (index in audio track lists)
|
||
* @type {number}
|
||
*/
|
||
get audioTrack(): number;
|
||
/**
|
||
* selects an audio track, based on its index in audio track lists
|
||
* @type {number}
|
||
*/
|
||
set audioTrack(audioTrackId: number);
|
||
/**
|
||
* get alternate subtitle tracks list from playlist
|
||
* @type {MediaPlaylist[]}
|
||
*/
|
||
get subtitleTracks(): Array<MediaPlaylist>;
|
||
/**
|
||
* index of the selected subtitle track (index in subtitle track lists)
|
||
* @type {number}
|
||
*/
|
||
get subtitleTrack(): number;
|
||
get media(): HTMLMediaElement | null;
|
||
/**
|
||
* select an subtitle track, based on its index in subtitle track lists
|
||
* @type {number}
|
||
*/
|
||
set subtitleTrack(subtitleTrackId: number);
|
||
/**
|
||
* @type {boolean}
|
||
*/
|
||
get subtitleDisplay(): boolean;
|
||
/**
|
||
* Enable/disable subtitle display rendering
|
||
* @type {boolean}
|
||
*/
|
||
set subtitleDisplay(value: boolean);
|
||
/**
|
||
* get mode for Low-Latency HLS loading
|
||
* @type {boolean}
|
||
*/
|
||
get lowLatencyMode(): boolean;
|
||
/**
|
||
* Enable/disable Low-Latency HLS part playlist and segment loading, and start live streams at playlist PART-HOLD-BACK rather than HOLD-BACK.
|
||
* @type {boolean}
|
||
*/
|
||
set lowLatencyMode(mode: boolean);
|
||
/**
|
||
* position (in seconds) of live sync point (ie edge of live position minus safety delay defined by ```hls.config.liveSyncDuration```)
|
||
* @type {number}
|
||
*/
|
||
get liveSyncPosition(): number | null;
|
||
/**
|
||
* estimated position (in seconds) of live edge (ie edge of live playlist plus time sync playlist advanced)
|
||
* returns 0 before first playlist is loaded
|
||
* @type {number}
|
||
*/
|
||
get latency(): number;
|
||
/**
|
||
* maximum distance from the edge before the player seeks forward to ```hls.liveSyncPosition```
|
||
* configured using ```liveMaxLatencyDurationCount``` (multiple of target duration) or ```liveMaxLatencyDuration```
|
||
* returns 0 before first playlist is loaded
|
||
* @type {number}
|
||
*/
|
||
get maxLatency(): number;
|
||
/**
|
||
* target distance from the edge as calculated by the latency controller
|
||
* @type {number}
|
||
*/
|
||
get targetLatency(): number | null;
|
||
/**
|
||
* the rate at which the edge of the current live playlist is advancing or 1 if there is none
|
||
* @type {number}
|
||
*/
|
||
get drift(): number | null;
|
||
/**
|
||
* set to true when startLoad is called before MANIFEST_PARSED event
|
||
* @type {boolean}
|
||
*/
|
||
get forceStartLoad(): boolean;
|
||
}
|
||
export default Hls;
|
||
|
||
export declare interface HlsChunkPerformanceTiming extends HlsPerformanceTiming {
|
||
executeStart: number;
|
||
executeEnd: number;
|
||
}
|
||
|
||
export declare type HlsConfig = {
|
||
debug: boolean | ILogger;
|
||
enableWorker: boolean;
|
||
enableSoftwareAES: boolean;
|
||
minAutoBitrate: number;
|
||
loader: {
|
||
new (confg: HlsConfig): Loader<LoaderContext>;
|
||
};
|
||
fetchSetup?: (context: LoaderContext, initParams: any) => Request;
|
||
xhrSetup?: (xhr: XMLHttpRequest, url: string) => void;
|
||
audioStreamController?: typeof AudioStreamController;
|
||
audioTrackController?: typeof AudioTrackController;
|
||
subtitleStreamController?: typeof SubtitleStreamController;
|
||
subtitleTrackController?: typeof SubtitleTrackController;
|
||
timelineController?: typeof TimelineController;
|
||
emeController?: typeof EMEController;
|
||
cmcd?: CMCDControllerConfig;
|
||
cmcdController?: typeof CMCDController;
|
||
abrController: typeof AbrController;
|
||
bufferController: typeof BufferController;
|
||
capLevelController: typeof CapLevelController;
|
||
fpsController: typeof FPSController;
|
||
progressive: boolean;
|
||
lowLatencyMode: boolean;
|
||
} & ABRControllerConfig & BufferControllerConfig & CapLevelControllerConfig & EMEControllerConfig & FPSControllerConfig & FragmentLoaderConfig & LevelControllerConfig & MP4RemuxerConfig & PlaylistLoaderConfig & StreamControllerConfig & LatencyControllerConfig & TimelineControllerConfig & TSDemuxerConfig;
|
||
|
||
export declare interface HlsEventEmitter {
|
||
on<E extends keyof HlsListeners, Context = undefined>(event: E, listener: HlsListeners[E], context?: Context): void;
|
||
once<E extends keyof HlsListeners, Context = undefined>(event: E, listener: HlsListeners[E], context?: Context): void;
|
||
removeAllListeners<E extends keyof HlsListeners>(event?: E): void;
|
||
off<E extends keyof HlsListeners, Context = undefined>(event: E, listener?: HlsListeners[E], context?: Context, once?: boolean): void;
|
||
listeners<E extends keyof HlsListeners>(event: E): HlsListeners[E][];
|
||
emit<E extends keyof HlsListeners>(event: E, name: E, eventObject: Parameters<HlsListeners[E]>[1]): boolean;
|
||
listenerCount<E extends keyof HlsListeners>(event: E): number;
|
||
}
|
||
|
||
export declare interface HlsListeners {
|
||
[Events.MEDIA_ATTACHING]: (event: Events.MEDIA_ATTACHING, data: MediaAttachingData) => void;
|
||
[Events.MEDIA_ATTACHED]: (event: Events.MEDIA_ATTACHED, data: MediaAttachedData) => void;
|
||
[Events.MEDIA_DETACHING]: (event: Events.MEDIA_DETACHING) => void;
|
||
[Events.MEDIA_DETACHED]: (event: Events.MEDIA_DETACHED) => void;
|
||
[Events.BUFFER_RESET]: (event: Events.BUFFER_RESET) => void;
|
||
[Events.BUFFER_CODECS]: (event: Events.BUFFER_CODECS, data: BufferCodecsData) => void;
|
||
[Events.BUFFER_CREATED]: (event: Events.BUFFER_CREATED, data: BufferCreatedData) => void;
|
||
[Events.BUFFER_APPENDING]: (event: Events.BUFFER_APPENDING, data: BufferAppendingData) => void;
|
||
[Events.BUFFER_APPENDED]: (event: Events.BUFFER_APPENDED, data: BufferAppendedData) => void;
|
||
[Events.BUFFER_EOS]: (event: Events.BUFFER_EOS, data: BufferEOSData) => void;
|
||
[Events.BUFFER_FLUSHING]: (event: Events.BUFFER_FLUSHING, data: BufferFlushingData) => void;
|
||
[Events.BUFFER_FLUSHED]: (event: Events.BUFFER_FLUSHED, data: BufferFlushedData) => void;
|
||
[Events.MANIFEST_LOADING]: (event: Events.MANIFEST_LOADING, data: ManifestLoadingData) => void;
|
||
[Events.MANIFEST_LOADED]: (event: Events.MANIFEST_LOADED, data: ManifestLoadedData) => void;
|
||
[Events.MANIFEST_PARSED]: (event: Events.MANIFEST_PARSED, data: ManifestParsedData) => void;
|
||
[Events.LEVEL_SWITCHING]: (event: Events.LEVEL_SWITCHING, data: LevelSwitchingData) => void;
|
||
[Events.LEVEL_SWITCHED]: (event: Events.LEVEL_SWITCHED, data: LevelSwitchedData) => void;
|
||
[Events.LEVEL_LOADING]: (event: Events.LEVEL_LOADING, data: LevelLoadingData) => void;
|
||
[Events.LEVEL_LOADED]: (event: Events.LEVEL_LOADED, data: LevelLoadedData) => void;
|
||
[Events.LEVEL_UPDATED]: (event: Events.LEVEL_UPDATED, data: LevelUpdatedData) => void;
|
||
[Events.LEVEL_PTS_UPDATED]: (event: Events.LEVEL_PTS_UPDATED, data: LevelPTSUpdatedData) => void;
|
||
[Events.LEVELS_UPDATED]: (event: Events.LEVELS_UPDATED, data: LevelsUpdatedData) => void;
|
||
[Events.AUDIO_TRACKS_UPDATED]: (event: Events.AUDIO_TRACKS_UPDATED, data: AudioTracksUpdatedData) => void;
|
||
[Events.AUDIO_TRACK_SWITCHING]: (event: Events.AUDIO_TRACK_SWITCHING, data: AudioTrackSwitchingData) => void;
|
||
[Events.AUDIO_TRACK_SWITCHED]: (event: Events.AUDIO_TRACK_SWITCHED, data: AudioTrackSwitchedData) => void;
|
||
[Events.AUDIO_TRACK_LOADING]: (event: Events.AUDIO_TRACK_LOADING, data: TrackLoadingData) => void;
|
||
[Events.AUDIO_TRACK_LOADED]: (event: Events.AUDIO_TRACK_LOADED, data: AudioTrackLoadedData) => void;
|
||
[Events.SUBTITLE_TRACKS_UPDATED]: (event: Events.SUBTITLE_TRACKS_UPDATED, data: SubtitleTracksUpdatedData) => void;
|
||
[Events.SUBTITLE_TRACKS_CLEARED]: (event: Events.SUBTITLE_TRACKS_CLEARED) => void;
|
||
[Events.SUBTITLE_TRACK_SWITCH]: (event: Events.SUBTITLE_TRACK_SWITCH, data: SubtitleTrackSwitchData) => void;
|
||
[Events.SUBTITLE_TRACK_LOADING]: (event: Events.SUBTITLE_TRACK_LOADING, data: TrackLoadingData) => void;
|
||
[Events.SUBTITLE_TRACK_LOADED]: (event: Events.SUBTITLE_TRACK_LOADED, data: SubtitleTrackLoadedData) => void;
|
||
[Events.SUBTITLE_FRAG_PROCESSED]: (event: Events.SUBTITLE_FRAG_PROCESSED, data: SubtitleFragProcessedData) => void;
|
||
[Events.CUES_PARSED]: (event: Events.CUES_PARSED, data: CuesParsedData) => void;
|
||
[Events.NON_NATIVE_TEXT_TRACKS_FOUND]: (event: Events.NON_NATIVE_TEXT_TRACKS_FOUND, data: NonNativeTextTracksData) => void;
|
||
[Events.INIT_PTS_FOUND]: (event: Events.INIT_PTS_FOUND, data: InitPTSFoundData) => void;
|
||
[Events.FRAG_LOADING]: (event: Events.FRAG_LOADING, data: FragLoadingData) => void;
|
||
[Events.FRAG_LOAD_EMERGENCY_ABORTED]: (event: Events.FRAG_LOAD_EMERGENCY_ABORTED, data: FragLoadEmergencyAbortedData) => void;
|
||
[Events.FRAG_LOADED]: (event: Events.FRAG_LOADED, data: FragLoadedData) => void;
|
||
[Events.FRAG_DECRYPTED]: (event: Events.FRAG_DECRYPTED, data: FragDecryptedData) => void;
|
||
[Events.FRAG_PARSING_INIT_SEGMENT]: (event: Events.FRAG_PARSING_INIT_SEGMENT, data: FragParsingInitSegmentData) => void;
|
||
[Events.FRAG_PARSING_USERDATA]: (event: Events.FRAG_PARSING_USERDATA, data: FragParsingUserdataData) => void;
|
||
[Events.FRAG_PARSING_METADATA]: (event: Events.FRAG_PARSING_METADATA, data: FragParsingMetadataData) => void;
|
||
[Events.FRAG_PARSED]: (event: Events.FRAG_PARSED, data: FragParsedData) => void;
|
||
[Events.FRAG_BUFFERED]: (event: Events.FRAG_BUFFERED, data: FragBufferedData) => void;
|
||
[Events.FRAG_CHANGED]: (event: Events.FRAG_CHANGED, data: FragChangedData) => void;
|
||
[Events.FPS_DROP]: (event: Events.FPS_DROP, data: FPSDropData) => void;
|
||
[Events.FPS_DROP_LEVEL_CAPPING]: (event: Events.FPS_DROP_LEVEL_CAPPING, data: FPSDropLevelCappingData) => void;
|
||
[Events.ERROR]: (event: Events.ERROR, data: ErrorData) => void;
|
||
[Events.DESTROYING]: (event: Events.DESTROYING) => void;
|
||
[Events.KEY_LOADING]: (event: Events.KEY_LOADING, data: KeyLoadingData) => void;
|
||
[Events.KEY_LOADED]: (event: Events.KEY_LOADED, data: KeyLoadedData) => void;
|
||
[Events.LIVE_BACK_BUFFER_REACHED]: (event: Events.LIVE_BACK_BUFFER_REACHED, data: LiveBackBufferData) => void;
|
||
[Events.BACK_BUFFER_REACHED]: (event: Events.BACK_BUFFER_REACHED, data: BackBufferData) => void;
|
||
}
|
||
|
||
export declare interface HlsPerformanceTiming {
|
||
start: number;
|
||
end: number;
|
||
}
|
||
|
||
export declare interface HlsProgressivePerformanceTiming extends HlsPerformanceTiming {
|
||
first: number;
|
||
}
|
||
|
||
export declare enum HlsSkip {
|
||
No = "",
|
||
Yes = "YES",
|
||
v2 = "v2"
|
||
}
|
||
|
||
export declare class HlsUrlParameters {
|
||
msn?: number;
|
||
part?: number;
|
||
skip?: HlsSkip;
|
||
constructor(msn?: number, part?: number, skip?: HlsSkip);
|
||
addDirectives(uri: string): string | never;
|
||
}
|
||
|
||
declare interface ILogFunction {
|
||
(message?: any, ...optionalParams: any[]): void;
|
||
}
|
||
|
||
declare interface ILogger {
|
||
trace: ILogFunction;
|
||
debug: ILogFunction;
|
||
log: ILogFunction;
|
||
warn: ILogFunction;
|
||
info: ILogFunction;
|
||
error: ILogFunction;
|
||
}
|
||
|
||
export declare interface InitPTSFoundData {
|
||
id: string;
|
||
frag: Fragment;
|
||
initPTS: number;
|
||
timescale: number;
|
||
}
|
||
|
||
declare interface InitSegmentData {
|
||
tracks?: TrackSet;
|
||
initPTS: number | undefined;
|
||
timescale: number | undefined;
|
||
}
|
||
|
||
export declare interface KeyLoadedData {
|
||
frag: Fragment;
|
||
}
|
||
|
||
export declare interface KeyLoadingData {
|
||
frag: Fragment;
|
||
}
|
||
|
||
/**
|
||
* @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMediaKeySystemAccess
|
||
*/
|
||
export declare enum KeySystems {
|
||
WIDEVINE = "com.widevine.alpha",
|
||
PLAYREADY = "com.microsoft.playready"
|
||
}
|
||
|
||
export declare type LatencyControllerConfig = {
|
||
liveSyncDurationCount: number;
|
||
liveMaxLatencyDurationCount: number;
|
||
liveSyncDuration?: number;
|
||
liveMaxLatencyDuration?: number;
|
||
maxLiveSyncPlaybackRate: number;
|
||
};
|
||
|
||
export declare class Level {
|
||
readonly attrs: LevelAttributes;
|
||
readonly audioCodec: string | undefined;
|
||
readonly bitrate: number;
|
||
readonly codecSet: string;
|
||
readonly height: number;
|
||
readonly id: number;
|
||
readonly name: string | undefined;
|
||
readonly videoCodec: string | undefined;
|
||
readonly width: number;
|
||
readonly unknownCodecs: string[] | undefined;
|
||
audioGroupIds?: string[];
|
||
details?: LevelDetails;
|
||
fragmentError: number;
|
||
loadError: number;
|
||
loaded?: {
|
||
bytes: number;
|
||
duration: number;
|
||
};
|
||
realBitrate: number;
|
||
textGroupIds?: string[];
|
||
url: string[];
|
||
private _urlId;
|
||
constructor(data: LevelParsed);
|
||
get maxBitrate(): number;
|
||
get uri(): string;
|
||
get urlId(): number;
|
||
set urlId(value: number);
|
||
}
|
||
|
||
export declare interface LevelAttributes extends AttrList {
|
||
AUDIO?: string;
|
||
AUTOSELECT?: string;
|
||
'AVERAGE-BANDWIDTH'?: string;
|
||
BANDWIDTH?: string;
|
||
BYTERANGE?: string;
|
||
'CLOSED-CAPTIONS'?: string;
|
||
CODECS?: string;
|
||
DEFAULT?: string;
|
||
FORCED?: string;
|
||
'FRAME-RATE'?: string;
|
||
LANGUAGE?: string;
|
||
NAME?: string;
|
||
'PROGRAM-ID'?: string;
|
||
RESOLUTION?: string;
|
||
SUBTITLES?: string;
|
||
TYPE?: string;
|
||
URI?: string;
|
||
}
|
||
|
||
export declare type LevelControllerConfig = {
|
||
startLevel?: number;
|
||
};
|
||
|
||
export declare class LevelDetails {
|
||
PTSKnown: boolean;
|
||
alignedSliding: boolean;
|
||
averagetargetduration?: number;
|
||
endCC: number;
|
||
endSN: number;
|
||
fragments: Fragment[];
|
||
fragmentHint?: Fragment;
|
||
partList: Part[] | null;
|
||
live: boolean;
|
||
ageHeader: number;
|
||
advancedDateTime?: number;
|
||
updated: boolean;
|
||
advanced: boolean;
|
||
availabilityDelay?: number;
|
||
misses: number;
|
||
needSidxRanges: boolean;
|
||
startCC: number;
|
||
startSN: number;
|
||
startTimeOffset: number | null;
|
||
targetduration: number;
|
||
totalduration: number;
|
||
type: string | null;
|
||
url: string;
|
||
m3u8: string;
|
||
version: number | null;
|
||
canBlockReload: boolean;
|
||
canSkipUntil: number;
|
||
canSkipDateRanges: boolean;
|
||
skippedSegments: number;
|
||
recentlyRemovedDateranges?: string[];
|
||
partHoldBack: number;
|
||
holdBack: number;
|
||
partTarget: number;
|
||
preloadHint?: AttrList;
|
||
renditionReports?: AttrList[];
|
||
tuneInGoal: number;
|
||
deltaUpdateFailed?: boolean;
|
||
driftStartTime: number;
|
||
driftEndTime: number;
|
||
driftStart: number;
|
||
driftEnd: number;
|
||
constructor(baseUrl: any);
|
||
reloaded(previous: LevelDetails | undefined): void;
|
||
get hasProgramDateTime(): boolean;
|
||
get levelTargetDuration(): number;
|
||
get drift(): number;
|
||
get edge(): number;
|
||
get partEnd(): number;
|
||
get fragmentEnd(): number;
|
||
get age(): number;
|
||
get lastPartIndex(): number;
|
||
get lastPartSn(): number;
|
||
}
|
||
|
||
export declare class LevelKey {
|
||
private _uri;
|
||
method: string | null;
|
||
keyFormat: string | null;
|
||
keyFormatVersions: string | null;
|
||
keyID: string | null;
|
||
key: Uint8Array | null;
|
||
iv: Uint8Array | null;
|
||
static fromURL(baseUrl: string, relativeUrl: string): LevelKey;
|
||
static fromURI(uri: string): LevelKey;
|
||
private constructor();
|
||
get uri(): string | null;
|
||
}
|
||
|
||
export declare interface LevelLoadedData {
|
||
details: LevelDetails;
|
||
id: number;
|
||
level: number;
|
||
networkDetails: any;
|
||
stats: LoaderStats;
|
||
deliveryDirectives: HlsUrlParameters | null;
|
||
}
|
||
|
||
export declare interface LevelLoadingData {
|
||
id: number;
|
||
level: number;
|
||
url: string;
|
||
deliveryDirectives: HlsUrlParameters | null;
|
||
}
|
||
|
||
export declare interface LevelParsed {
|
||
attrs: LevelAttributes;
|
||
audioCodec?: string;
|
||
bitrate: number;
|
||
details?: LevelDetails;
|
||
height?: number;
|
||
id?: number;
|
||
level?: number;
|
||
name: string;
|
||
textCodec?: string;
|
||
unknownCodecs?: string[];
|
||
url: string;
|
||
videoCodec?: string;
|
||
width?: number;
|
||
}
|
||
|
||
export declare interface LevelPTSUpdatedData {
|
||
details: LevelDetails;
|
||
level: Level;
|
||
drift: number;
|
||
type: string;
|
||
frag: Fragment;
|
||
start: number;
|
||
end: number;
|
||
}
|
||
|
||
export declare interface LevelsUpdatedData {
|
||
levels: Array<Level>;
|
||
}
|
||
|
||
export declare interface LevelSwitchedData {
|
||
level: number;
|
||
}
|
||
|
||
export declare interface LevelSwitchingData extends Omit<Level, '_urlId'> {
|
||
level: number;
|
||
}
|
||
|
||
export declare interface LevelUpdatedData {
|
||
details: LevelDetails;
|
||
level: number;
|
||
}
|
||
|
||
/**
|
||
* Deprecated; please use BackBufferData
|
||
*/
|
||
export declare interface LiveBackBufferData extends BackBufferData {
|
||
}
|
||
|
||
export declare interface Loader<T extends LoaderContext> {
|
||
destroy(): void;
|
||
abort(): void;
|
||
load(context: LoaderContext, config: LoaderConfiguration, callbacks: LoaderCallbacks<T>): void;
|
||
/**
|
||
* `getCacheAge()` is called by hls.js to get the duration that a given object
|
||
* has been sitting in a cache proxy when playing live. If implemented,
|
||
* this should return a value in seconds.
|
||
*
|
||
* For HTTP based loaders, this should return the contents of the "age" header.
|
||
*
|
||
* @returns time object being lodaded
|
||
*/
|
||
getCacheAge?: () => number | null;
|
||
context: T;
|
||
stats: LoaderStats;
|
||
}
|
||
|
||
export declare interface LoaderCallbacks<T extends LoaderContext> {
|
||
onSuccess: LoaderOnSuccess<T>;
|
||
onError: LoaderOnError<T>;
|
||
onTimeout: LoaderOnTimeout<T>;
|
||
onAbort?: LoaderOnAbort<T>;
|
||
onProgress?: LoaderOnProgress<T>;
|
||
}
|
||
|
||
export declare interface LoaderConfiguration {
|
||
maxRetry: number;
|
||
timeout: number;
|
||
retryDelay: number;
|
||
maxRetryDelay: number;
|
||
highWaterMark: number;
|
||
}
|
||
|
||
export declare interface LoaderContext {
|
||
url: string;
|
||
responseType: string;
|
||
headers?: Record<string, string>;
|
||
rangeStart?: number;
|
||
rangeEnd?: number;
|
||
progressData?: boolean;
|
||
}
|
||
|
||
export declare type LoaderOnAbort<T extends LoaderContext> = (stats: LoaderStats, context: T, networkDetails: any) => void;
|
||
|
||
export declare type LoaderOnError<T extends LoaderContext> = (error: {
|
||
code: number;
|
||
text: string;
|
||
}, context: T, networkDetails: any) => void;
|
||
|
||
export declare type LoaderOnProgress<T extends LoaderContext> = (stats: LoaderStats, context: T, data: string | ArrayBuffer, networkDetails: any) => void;
|
||
|
||
export declare type LoaderOnSuccess<T extends LoaderContext> = (response: LoaderResponse, stats: LoaderStats, context: T, networkDetails: any) => void;
|
||
|
||
export declare type LoaderOnTimeout<T extends LoaderContext> = (stats: LoaderStats, context: T, networkDetails: any) => void;
|
||
|
||
export declare interface LoaderResponse {
|
||
url: string;
|
||
data: string | ArrayBuffer;
|
||
}
|
||
|
||
export declare interface LoaderStats {
|
||
aborted: boolean;
|
||
loaded: number;
|
||
retry: number;
|
||
total: number;
|
||
chunkCount: number;
|
||
bwEstimate: number;
|
||
loading: HlsProgressivePerformanceTiming;
|
||
parsing: HlsPerformanceTiming;
|
||
buffering: HlsProgressivePerformanceTiming;
|
||
}
|
||
|
||
export declare class LoadStats implements LoaderStats {
|
||
aborted: boolean;
|
||
loaded: number;
|
||
retry: number;
|
||
total: number;
|
||
chunkCount: number;
|
||
bwEstimate: number;
|
||
loading: HlsProgressivePerformanceTiming;
|
||
parsing: HlsPerformanceTiming;
|
||
buffering: HlsProgressivePerformanceTiming;
|
||
}
|
||
|
||
export declare type MainPlaylistType = AudioPlaylistType | 'VIDEO';
|
||
|
||
export declare interface ManifestLoadedData {
|
||
audioTracks: MediaPlaylist[];
|
||
captions?: MediaPlaylist[];
|
||
levels: LevelParsed[];
|
||
networkDetails: any;
|
||
sessionData: Record<string, AttrList> | null;
|
||
stats: LoaderStats;
|
||
subtitles?: MediaPlaylist[];
|
||
url: string;
|
||
}
|
||
|
||
export declare interface ManifestLoadingData {
|
||
url: string;
|
||
}
|
||
|
||
export declare interface ManifestParsedData {
|
||
levels: Level[];
|
||
audioTracks: MediaPlaylist[];
|
||
subtitleTracks: MediaPlaylist[];
|
||
firstLevel: number;
|
||
stats: LoaderStats;
|
||
audio: boolean;
|
||
video: boolean;
|
||
altAudio: boolean;
|
||
}
|
||
|
||
export declare interface MediaAttachedData {
|
||
media: HTMLMediaElement;
|
||
}
|
||
|
||
export declare interface MediaAttachingData {
|
||
media: HTMLMediaElement;
|
||
}
|
||
|
||
export declare type MediaKeyFunc = (keySystem: KeySystems, supportedConfigurations: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess>;
|
||
|
||
export declare interface MediaPlaylist extends LevelParsed {
|
||
autoselect: boolean;
|
||
default: boolean;
|
||
forced: boolean;
|
||
groupId?: string;
|
||
id: number;
|
||
instreamId?: string;
|
||
lang?: string;
|
||
name: string;
|
||
type: MediaPlaylistType | 'main';
|
||
}
|
||
|
||
export declare type MediaPlaylistType = MainPlaylistType | SubtitlePlaylistType;
|
||
|
||
export declare interface MetadataSample {
|
||
pts: number;
|
||
dts: number;
|
||
len?: number;
|
||
data: Uint8Array;
|
||
}
|
||
|
||
export declare type MP4RemuxerConfig = {
|
||
stretchShortVideoTrack: boolean;
|
||
maxAudioFramesDrift: number;
|
||
};
|
||
|
||
declare interface NetworkComponentAPI extends ComponentAPI {
|
||
startLoad(startPosition: number): void;
|
||
stopLoad(): void;
|
||
}
|
||
|
||
export declare interface NonNativeTextTrack {
|
||
_id?: string;
|
||
label: any;
|
||
kind: string;
|
||
default: boolean;
|
||
closedCaptions?: MediaPlaylist;
|
||
subtitleTrack?: MediaPlaylist;
|
||
}
|
||
|
||
export declare interface NonNativeTextTracksData {
|
||
tracks: Array<NonNativeTextTrack>;
|
||
}
|
||
|
||
declare interface PACData {
|
||
row: number;
|
||
indent: number | null;
|
||
color: string | null;
|
||
underline: boolean;
|
||
italics: boolean;
|
||
}
|
||
|
||
export declare class Part extends BaseSegment {
|
||
readonly fragOffset: number;
|
||
readonly duration: number;
|
||
readonly gap: boolean;
|
||
readonly independent: boolean;
|
||
readonly relurl: string;
|
||
readonly fragment: Fragment;
|
||
readonly index: number;
|
||
stats: LoadStats;
|
||
constructor(partAttrs: AttrList, frag: Fragment, baseurl: string, index: number, previous?: Part);
|
||
get start(): number;
|
||
get end(): number;
|
||
get loaded(): boolean;
|
||
}
|
||
|
||
declare interface PartsLoadedData {
|
||
frag: Fragment;
|
||
part: Part | null;
|
||
partsLoaded?: FragLoadedData[];
|
||
}
|
||
|
||
declare class PenState {
|
||
foreground: string;
|
||
underline: boolean;
|
||
italics: boolean;
|
||
background: string;
|
||
flash: boolean;
|
||
constructor(foreground?: string, underline?: boolean, italics?: boolean, background?: string, flash?: boolean);
|
||
reset(): void;
|
||
setStyles(styles: Partial<PenStyles>): void;
|
||
isDefault(): boolean;
|
||
equals(other: PenState): boolean;
|
||
copy(newPenState: PenState): void;
|
||
toString(): string;
|
||
}
|
||
|
||
declare type PenStyles = {
|
||
foreground: string | null;
|
||
underline: boolean;
|
||
italics: boolean;
|
||
background: string;
|
||
flash: boolean;
|
||
};
|
||
|
||
export declare enum PlaylistContextType {
|
||
MANIFEST = "manifest",
|
||
LEVEL = "level",
|
||
AUDIO_TRACK = "audioTrack",
|
||
SUBTITLE_TRACK = "subtitleTrack"
|
||
}
|
||
|
||
export declare enum PlaylistLevelType {
|
||
MAIN = "main",
|
||
AUDIO = "audio",
|
||
SUBTITLE = "subtitle"
|
||
}
|
||
|
||
export declare type PlaylistLoaderConfig = {
|
||
pLoader?: PlaylistLoaderConstructor;
|
||
manifestLoadingTimeOut: number;
|
||
manifestLoadingMaxRetry: number;
|
||
manifestLoadingRetryDelay: number;
|
||
manifestLoadingMaxRetryTimeout: number;
|
||
levelLoadingTimeOut: number;
|
||
levelLoadingMaxRetry: number;
|
||
levelLoadingRetryDelay: number;
|
||
levelLoadingMaxRetryTimeout: number;
|
||
};
|
||
|
||
export declare interface PlaylistLoaderConstructor {
|
||
new (confg: HlsConfig): Loader<PlaylistLoaderContext>;
|
||
}
|
||
|
||
export declare interface PlaylistLoaderContext extends LoaderContext {
|
||
loader?: Loader<PlaylistLoaderContext>;
|
||
type: PlaylistContextType;
|
||
level: number | null;
|
||
id: number | null;
|
||
groupId: string | null;
|
||
isSidxRequest?: boolean;
|
||
levelDetails?: LevelDetails;
|
||
deliveryDirectives: HlsUrlParameters | null;
|
||
}
|
||
|
||
declare interface RemuxedMetadata {
|
||
samples: MetadataSample[];
|
||
}
|
||
|
||
declare interface RemuxedTrack {
|
||
data1: Uint8Array;
|
||
data2?: Uint8Array;
|
||
startPTS: number;
|
||
endPTS: number;
|
||
startDTS: number;
|
||
endDTS: number;
|
||
type: SourceBufferName;
|
||
hasAudio: boolean;
|
||
hasVideo: boolean;
|
||
independent?: boolean;
|
||
firstKeyFrame?: number;
|
||
nb: number;
|
||
transferredData1?: ArrayBuffer;
|
||
transferredData2?: ArrayBuffer;
|
||
dropped?: number;
|
||
}
|
||
|
||
declare interface RemuxedUserdata {
|
||
samples: UserdataSample[];
|
||
}
|
||
|
||
declare interface RemuxerResult {
|
||
audio?: RemuxedTrack;
|
||
video?: RemuxedTrack;
|
||
text?: RemuxedUserdata;
|
||
id3?: RemuxedMetadata;
|
||
initSegment?: InitSegmentData;
|
||
independent?: boolean;
|
||
}
|
||
|
||
/**
|
||
* CEA-608 row consisting of NR_COLS instances of StyledUnicodeChar.
|
||
* @constructor
|
||
*/
|
||
declare class Row {
|
||
chars: StyledUnicodeChar[];
|
||
pos: number;
|
||
currPenState: PenState;
|
||
cueStartTime?: number;
|
||
logger: CaptionsLogger;
|
||
constructor(logger: CaptionsLogger);
|
||
equals(other: Row): boolean;
|
||
copy(other: Row): void;
|
||
isEmpty(): boolean;
|
||
/**
|
||
* Set the cursor to a valid column.
|
||
*/
|
||
setCursor(absPos: number): void;
|
||
/**
|
||
* Move the cursor relative to current position.
|
||
*/
|
||
moveCursor(relPos: number): void;
|
||
/**
|
||
* Backspace, move one step back and clear character.
|
||
*/
|
||
backSpace(): void;
|
||
insertChar(byte: number): void;
|
||
clearFromPos(startPos: number): void;
|
||
clear(): void;
|
||
clearToEndOfRow(): void;
|
||
getTextString(): string;
|
||
setPenStyles(styles: Partial<PenStyles>): void;
|
||
}
|
||
|
||
export declare type SourceBufferName = 'video' | 'audio' | 'audiovideo';
|
||
|
||
declare type SourceBuffers = Partial<Record<SourceBufferName, ExtendedSourceBuffer>>;
|
||
|
||
declare class StreamController extends BaseStreamController implements NetworkComponentAPI {
|
||
private audioCodecSwap;
|
||
private gapController;
|
||
private level;
|
||
private _forceStartLoad;
|
||
private altAudio;
|
||
private audioOnly;
|
||
private fragPlaying;
|
||
private onvplaying;
|
||
private onvseeked;
|
||
private fragLastKbps;
|
||
private stalled;
|
||
private couldBacktrack;
|
||
private audioCodecSwitch;
|
||
private videoBuffer;
|
||
constructor(hls: Hls, fragmentTracker: FragmentTracker);
|
||
private _registerListeners;
|
||
protected _unregisterListeners(): void;
|
||
protected onHandlerDestroying(): void;
|
||
startLoad(startPosition: number): void;
|
||
stopLoad(): void;
|
||
protected doTick(): void;
|
||
protected onTickEnd(): void;
|
||
private doTickIdle;
|
||
protected loadFragment(frag: Fragment, levelDetails: LevelDetails, targetBufferTime: number): void;
|
||
private getAppendedFrag;
|
||
private getBufferedFrag;
|
||
private followingBufferedFrag;
|
||
immediateLevelSwitch(): void;
|
||
/**
|
||
* try to switch ASAP without breaking video playback:
|
||
* in order to ensure smooth but quick level switching,
|
||
* we need to find the next flushable buffer range
|
||
* we should take into account new segment fetch time
|
||
*/
|
||
nextLevelSwitch(): void;
|
||
private abortCurrentFrag;
|
||
protected flushMainBuffer(startOffset: number, endOffset: number): void;
|
||
protected onMediaAttached(event: Events.MEDIA_ATTACHED, data: MediaAttachedData): void;
|
||
protected onMediaDetaching(): void;
|
||
private onMediaPlaying;
|
||
private onMediaSeeked;
|
||
private onManifestLoading;
|
||
private onManifestParsed;
|
||
private onLevelLoading;
|
||
private onLevelLoaded;
|
||
protected _handleFragmentLoadProgress(data: FragLoadedData): void;
|
||
private onAudioTrackSwitching;
|
||
private onAudioTrackSwitched;
|
||
private onBufferCreated;
|
||
private onFragBuffered;
|
||
private onError;
|
||
private checkBuffer;
|
||
private onFragLoadEmergencyAborted;
|
||
private onBufferFlushed;
|
||
private onLevelsUpdated;
|
||
swapAudioCodec(): void;
|
||
/**
|
||
* Seeks to the set startPosition if not equal to the mediaElement's current time.
|
||
* @private
|
||
*/
|
||
private seekToStartPos;
|
||
private _getAudioCodec;
|
||
private _loadBitrateTestFrag;
|
||
private _handleTransmuxComplete;
|
||
private _bufferInitSegment;
|
||
private backtrack;
|
||
private checkFragmentChanged;
|
||
get nextLevel(): number;
|
||
get currentLevel(): number;
|
||
get nextBufferedFrag(): Fragment | null;
|
||
get forceStartLoad(): boolean;
|
||
}
|
||
|
||
export declare type StreamControllerConfig = {
|
||
autoStartLoad: boolean;
|
||
startPosition: number;
|
||
defaultAudioCodec?: string;
|
||
initialLiveManifestSize: number;
|
||
maxBufferLength: number;
|
||
maxBufferSize: number;
|
||
maxBufferHole: number;
|
||
highBufferWatchdogPeriod: number;
|
||
nudgeOffset: number;
|
||
nudgeMaxRetry: number;
|
||
maxFragLookUpTolerance: number;
|
||
maxMaxBufferLength: number;
|
||
startFragPrefetch: boolean;
|
||
testBandwidth: boolean;
|
||
};
|
||
|
||
/**
|
||
* Unicode character with styling and background.
|
||
* @constructor
|
||
*/
|
||
declare class StyledUnicodeChar {
|
||
uchar: string;
|
||
penState: PenState;
|
||
constructor(uchar?: string, foreground?: string, underline?: boolean, italics?: boolean, background?: string, flash?: boolean);
|
||
reset(): void;
|
||
setChar(uchar: string, newPenState: PenState): void;
|
||
setPenState(newPenState: PenState): void;
|
||
equals(other: StyledUnicodeChar): boolean;
|
||
copy(newChar: StyledUnicodeChar): void;
|
||
isEmpty(): boolean;
|
||
}
|
||
|
||
declare interface SubtitleFragProcessed {
|
||
success: boolean;
|
||
frag: Fragment;
|
||
}
|
||
|
||
export declare interface SubtitleFragProcessedData {
|
||
success: boolean;
|
||
frag: Fragment;
|
||
error?: Error;
|
||
}
|
||
|
||
export declare type SubtitlePlaylistType = 'SUBTITLES' | 'CLOSED-CAPTIONS';
|
||
|
||
declare class SubtitleStreamController extends BaseStreamController implements NetworkComponentAPI {
|
||
protected levels: Array<Level>;
|
||
private currentTrackId;
|
||
private tracksBuffered;
|
||
private mainDetails;
|
||
constructor(hls: Hls, fragmentTracker: FragmentTracker);
|
||
protected onHandlerDestroying(): void;
|
||
private _registerListeners;
|
||
private _unregisterListeners;
|
||
startLoad(): void;
|
||
onManifestLoading(): void;
|
||
onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData): void;
|
||
onSubtitleFragProcessed(event: Events.SUBTITLE_FRAG_PROCESSED, data: SubtitleFragProcessed): void;
|
||
onBufferFlushing(event: Events.BUFFER_FLUSHING, data: BufferFlushingData): void;
|
||
onError(event: Events.ERROR, data: ErrorData): void;
|
||
onSubtitleTracksUpdated(event: Events.SUBTITLE_TRACKS_UPDATED, { subtitleTracks }: SubtitleTracksUpdatedData): void;
|
||
onSubtitleTrackSwitch(event: Events.SUBTITLE_TRACK_SWITCH, data: TrackSwitchedData): void;
|
||
onSubtitleTrackLoaded(event: Events.SUBTITLE_TRACK_LOADED, data: TrackLoadedData): void;
|
||
_handleFragmentLoadComplete(fragLoadedData: FragLoadedData): void;
|
||
doTick(): void;
|
||
protected loadFragment(frag: Fragment, levelDetails: LevelDetails, targetBufferTime: number): void;
|
||
get mediaBufferTimeRanges(): TimeRange[];
|
||
}
|
||
|
||
declare class SubtitleTrackController extends BasePlaylistController {
|
||
private media;
|
||
private tracks;
|
||
private groupId;
|
||
private tracksInGroup;
|
||
private trackId;
|
||
private selectDefaultTrack;
|
||
private queuedDefaultTrack;
|
||
private trackChangeListener;
|
||
private asyncPollTrackChange;
|
||
private useTextTrackPolling;
|
||
private subtitlePollingInterval;
|
||
subtitleDisplay: boolean;
|
||
constructor(hls: Hls);
|
||
destroy(): void;
|
||
private registerListeners;
|
||
private unregisterListeners;
|
||
protected onMediaAttached(event: Events.MEDIA_ATTACHED, data: MediaAttachedData): void;
|
||
private pollTrackChange;
|
||
protected onMediaDetaching(): void;
|
||
protected onManifestLoading(): void;
|
||
protected onManifestParsed(event: Events.MANIFEST_PARSED, data: ManifestParsedData): void;
|
||
protected onSubtitleTrackLoaded(event: Events.SUBTITLE_TRACK_LOADED, data: TrackLoadedData): void;
|
||
protected onLevelLoading(event: Events.LEVEL_LOADING, data: LevelLoadingData): void;
|
||
protected onLevelSwitching(event: Events.LEVEL_SWITCHING, data: LevelSwitchingData): void;
|
||
private switchLevel;
|
||
private findTrackId;
|
||
protected onError(event: Events.ERROR, data: ErrorData): void;
|
||
/** get alternate subtitle tracks list from playlist **/
|
||
get subtitleTracks(): MediaPlaylist[];
|
||
/** get/set index of the selected subtitle track (based on index in subtitle track lists) **/
|
||
get subtitleTrack(): number;
|
||
set subtitleTrack(newId: number);
|
||
protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters): void;
|
||
/**
|
||
* Disables the old subtitleTrack and sets current mode on the next subtitleTrack.
|
||
* This operates on the DOM textTracks.
|
||
* A value of -1 will disable all subtitle tracks.
|
||
*/
|
||
private toggleTrackModes;
|
||
/**
|
||
* This method is responsible for validating the subtitle index and periodically reloading if live.
|
||
* Dispatches the SUBTITLE_TRACK_SWITCH event, which instructs the subtitle-stream-controller to load the selected track.
|
||
*/
|
||
private setSubtitleTrack;
|
||
private onTextTracksChanged;
|
||
}
|
||
|
||
export declare interface SubtitleTrackLoadedData extends TrackLoadedData {
|
||
}
|
||
|
||
export declare interface SubtitleTracksUpdatedData {
|
||
subtitleTracks: MediaPlaylist[];
|
||
}
|
||
|
||
export declare interface SubtitleTrackSwitchData {
|
||
id: number;
|
||
name?: string;
|
||
groupId?: string;
|
||
type?: MediaPlaylistType | 'main';
|
||
url?: string;
|
||
}
|
||
|
||
/**
|
||
* Sub-class specialization of EventHandler base class.
|
||
*
|
||
* TaskLoop allows to schedule a task function being called (optionnaly repeatedly) on the main loop,
|
||
* scheduled asynchroneously, avoiding recursive calls in the same tick.
|
||
*
|
||
* The task itself is implemented in `doTick`. It can be requested and called for single execution
|
||
* using the `tick` method.
|
||
*
|
||
* It will be assured that the task execution method (`tick`) only gets called once per main loop "tick",
|
||
* no matter how often it gets requested for execution. Execution in further ticks will be scheduled accordingly.
|
||
*
|
||
* If further execution requests have already been scheduled on the next tick, it can be checked with `hasNextTick`,
|
||
* and cancelled with `clearNextTick`.
|
||
*
|
||
* The task can be scheduled as an interval repeatedly with a period as parameter (see `setInterval`, `clearInterval`).
|
||
*
|
||
* Sub-classes need to implement the `doTick` method which will effectively have the task execution routine.
|
||
*
|
||
* Further explanations:
|
||
*
|
||
* The baseclass has a `tick` method that will schedule the doTick call. It may be called synchroneously
|
||
* only for a stack-depth of one. On re-entrant calls, sub-sequent calls are scheduled for next main loop ticks.
|
||
*
|
||
* When the task execution (`tick` method) is called in re-entrant way this is detected and
|
||
* we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
|
||
* task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
|
||
*/
|
||
declare class TaskLoop {
|
||
private readonly _boundTick;
|
||
private _tickTimer;
|
||
private _tickInterval;
|
||
private _tickCallCount;
|
||
constructor();
|
||
destroy(): void;
|
||
protected onHandlerDestroying(): void;
|
||
protected onHandlerDestroyed(): void;
|
||
/**
|
||
* @returns {boolean}
|
||
*/
|
||
hasInterval(): boolean;
|
||
/**
|
||
* @returns {boolean}
|
||
*/
|
||
hasNextTick(): boolean;
|
||
/**
|
||
* @param {number} millis Interval time (ms)
|
||
* @returns {boolean} True when interval has been scheduled, false when already scheduled (no effect)
|
||
*/
|
||
setInterval(millis: number): boolean;
|
||
/**
|
||
* @returns {boolean} True when interval was cleared, false when none was set (no effect)
|
||
*/
|
||
clearInterval(): boolean;
|
||
/**
|
||
* @returns {boolean} True when timeout was cleared, false when none was set (no effect)
|
||
*/
|
||
clearNextTick(): boolean;
|
||
/**
|
||
* Will call the subclass doTick implementation in this main loop tick
|
||
* or in the next one (via setTimeout(,0)) in case it has already been called
|
||
* in this tick (in case this is a re-entrant call).
|
||
*/
|
||
tick(): void;
|
||
tickImmediate(): void;
|
||
/**
|
||
* For subclass to implement task logic
|
||
* @abstract
|
||
*/
|
||
protected doTick(): void;
|
||
}
|
||
|
||
declare class TimelineController implements ComponentAPI {
|
||
private hls;
|
||
private media;
|
||
private config;
|
||
private enabled;
|
||
private Cues;
|
||
private textTracks;
|
||
private tracks;
|
||
private initPTS;
|
||
private timescale;
|
||
private unparsedVttFrags;
|
||
private captionsTracks;
|
||
private nonNativeCaptionsTracks;
|
||
private cea608Parser1;
|
||
private cea608Parser2;
|
||
private lastSn;
|
||
private prevCC;
|
||
private vttCCs;
|
||
private captionsProperties;
|
||
constructor(hls: Hls);
|
||
destroy(): void;
|
||
addCues(trackName: string, startTime: number, endTime: number, screen: CaptionScreen, cueRanges: Array<[number, number]>): void;
|
||
private onInitPtsFound;
|
||
private getExistingTrack;
|
||
createCaptionsTrack(trackName: string): void;
|
||
private createNativeTrack;
|
||
private createNonNativeTrack;
|
||
private createTextTrack;
|
||
private onMediaAttaching;
|
||
private onMediaDetaching;
|
||
private onManifestLoading;
|
||
private _cleanTracks;
|
||
private onSubtitleTracksUpdated;
|
||
private onManifestLoaded;
|
||
private onFragLoading;
|
||
private onFragLoaded;
|
||
private _parseIMSC1;
|
||
private _parseVTTs;
|
||
private _fallbackToIMSC1;
|
||
private _appendCues;
|
||
private onFragDecrypted;
|
||
private onSubtitleTracksCleared;
|
||
private onFragParsingUserdata;
|
||
onBufferFlushing(event: Events.BUFFER_FLUSHING, { startOffset, endOffset, endOffsetSubtitles, type }: BufferFlushingData): void;
|
||
private extractCea608Data;
|
||
}
|
||
|
||
export declare type TimelineControllerConfig = {
|
||
cueHandler: CuesInterface;
|
||
enableCEA708Captions: boolean;
|
||
enableWebVTT: boolean;
|
||
enableIMSC1: boolean;
|
||
captionsTextTrack1Label: string;
|
||
captionsTextTrack1LanguageCode: string;
|
||
captionsTextTrack2Label: string;
|
||
captionsTextTrack2LanguageCode: string;
|
||
captionsTextTrack3Label: string;
|
||
captionsTextTrack3LanguageCode: string;
|
||
captionsTextTrack4Label: string;
|
||
captionsTextTrack4LanguageCode: string;
|
||
renderTextTracksNatively: boolean;
|
||
};
|
||
|
||
declare interface TimeRange {
|
||
start: number;
|
||
end: number;
|
||
}
|
||
|
||
export declare interface Track {
|
||
id: 'audio' | 'main';
|
||
buffer?: SourceBuffer;
|
||
container: string;
|
||
codec?: string;
|
||
initSegment?: Uint8Array;
|
||
levelCodec?: string;
|
||
metadata?: any;
|
||
}
|
||
|
||
export declare interface TrackLoadedData {
|
||
details: LevelDetails;
|
||
id: number;
|
||
groupId: string;
|
||
networkDetails: any;
|
||
stats: LoaderStats;
|
||
deliveryDirectives: HlsUrlParameters | null;
|
||
}
|
||
|
||
export declare interface TrackLoadingData {
|
||
id: number;
|
||
groupId: string;
|
||
url: string;
|
||
deliveryDirectives: HlsUrlParameters | null;
|
||
}
|
||
|
||
export declare interface TrackSet {
|
||
audio?: Track;
|
||
video?: Track;
|
||
audiovideo?: Track;
|
||
}
|
||
|
||
declare interface TrackSwitchedData {
|
||
id: number;
|
||
}
|
||
|
||
declare class TransmuxerInterface {
|
||
private hls;
|
||
private id;
|
||
private observer;
|
||
private frag;
|
||
private part;
|
||
private worker;
|
||
private onwmsg?;
|
||
private transmuxer;
|
||
private onTransmuxComplete;
|
||
private onFlush;
|
||
constructor(hls: Hls, id: PlaylistLevelType, onTransmuxComplete: (transmuxResult: TransmuxerResult) => void, onFlush: (chunkMeta: ChunkMetadata) => void);
|
||
destroy(): void;
|
||
push(data: ArrayBuffer, initSegmentData: Uint8Array | undefined, audioCodec: string | undefined, videoCodec: string | undefined, frag: Fragment, part: Part | null, duration: number, accurateTimeOffset: boolean, chunkMeta: ChunkMetadata, defaultInitPTS?: number): void;
|
||
flush(chunkMeta: ChunkMetadata): void;
|
||
private handleFlushResult;
|
||
private onWorkerMessage;
|
||
private configureTransmuxer;
|
||
private handleTransmuxComplete;
|
||
}
|
||
|
||
declare interface TransmuxerResult {
|
||
remuxResult: RemuxerResult;
|
||
chunkMeta: ChunkMetadata;
|
||
}
|
||
|
||
export declare type TSDemuxerConfig = {
|
||
forceKeyFrameOnDiscontinuity: boolean;
|
||
};
|
||
|
||
export declare interface UserdataSample {
|
||
pts: number;
|
||
bytes: Uint8Array;
|
||
}
|
||
|
||
declare enum VerboseLevel {
|
||
ERROR = 0,
|
||
TEXT = 1,
|
||
WARNING = 2,
|
||
INFO = 2,
|
||
DEBUG = 3,
|
||
DATA = 3
|
||
}
|
||
|
||
export { }
|