2023-10-14 01:22:50 +08:00

2838 lines
94 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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 players
* 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 { }