mirror of https://bitbucket.org/ausocean/av.git
mjpeg-player: added m3u hls.js code
Added original hls.js code for m3u loading and parsing which will be modified to work with our mjpeg player.
This commit is contained in:
Trek H
parent
ddd7b5750d
commit
42ccdd1ef7
|
|
@ -0,0 +1,264 @@
|
|||
/**
|
||||
* HLS config
|
||||
*/
|
||||
|
||||
import AbrController from './controller/abr-controller';
|
||||
import BufferController from './controller/buffer-controller';
|
||||
import CapLevelController from './controller/cap-level-controller';
|
||||
import FPSController from './controller/fps-controller';
|
||||
import XhrLoader from './utils/xhr-loader';
|
||||
// import FetchLoader from './utils/fetch-loader';
|
||||
|
||||
import AudioTrackController from './controller/audio-track-controller';
|
||||
import AudioStreamController from './controller/audio-stream-controller';
|
||||
|
||||
import * as Cues from './utils/cues';
|
||||
import TimelineController from './controller/timeline-controller';
|
||||
import SubtitleTrackController from './controller/subtitle-track-controller';
|
||||
import { SubtitleStreamController } from './controller/subtitle-stream-controller';
|
||||
import EMEController from './controller/eme-controller';
|
||||
import { requestMediaKeySystemAccess, MediaKeyFunc } from './utils/mediakeys-helper';
|
||||
|
||||
type ABRControllerConfig = {
|
||||
abrEwmaFastLive: number,
|
||||
abrEwmaSlowLive: number,
|
||||
abrEwmaFastVoD: number,
|
||||
abrEwmaSlowVoD: number,
|
||||
abrEwmaDefaultEstimate: number,
|
||||
abrBandWidthFactor: number,
|
||||
abrBandWidthUpFactor: number,
|
||||
abrMaxWithRealBitrate: boolean,
|
||||
maxStarvationDelay: number,
|
||||
maxLoadingDelay: number,
|
||||
};
|
||||
|
||||
export type BufferControllerConfig = {
|
||||
appendErrorMaxRetry: number,
|
||||
liveDurationInfinity: boolean,
|
||||
liveBackBufferLength: number,
|
||||
};
|
||||
|
||||
type CapLevelControllerConfig = {
|
||||
capLevelToPlayerSize: boolean
|
||||
};
|
||||
|
||||
export type EMEControllerConfig = {
|
||||
licenseXhrSetup?: (xhr: XMLHttpRequest, url: string) => void,
|
||||
emeEnabled: boolean,
|
||||
widevineLicenseUrl?: string,
|
||||
requestMediaKeySystemAccessFunc: MediaKeyFunc | null,
|
||||
};
|
||||
|
||||
type FragmentLoaderConfig = {
|
||||
fLoader: any, // TODO(typescript-loader): Once Loader is typed fill this in
|
||||
|
||||
fragLoadingTimeOut: number,
|
||||
fragLoadingMaxRetry: number,
|
||||
fragLoadingRetryDelay: number,
|
||||
fragLoadingMaxRetryTimeout: number,
|
||||
};
|
||||
|
||||
type FPSControllerConfig = {
|
||||
capLevelOnFPSDrop: boolean,
|
||||
fpsDroppedMonitoringPeriod: number,
|
||||
fpsDroppedMonitoringThreshold: number,
|
||||
};
|
||||
|
||||
type LevelControllerConfig = {
|
||||
startLevel?: number
|
||||
};
|
||||
|
||||
type MP4RemuxerConfig = {
|
||||
stretchShortVideoTrack: boolean,
|
||||
maxAudioFramesDrift: number,
|
||||
};
|
||||
|
||||
type PlaylistLoaderConfig = {
|
||||
pLoader: any, // TODO(typescript-loader): Once Loader is typed fill this in
|
||||
|
||||
manifestLoadingTimeOut: number,
|
||||
manifestLoadingMaxRetry: number,
|
||||
manifestLoadingRetryDelay: number,
|
||||
manifestLoadingMaxRetryTimeout: number,
|
||||
|
||||
levelLoadingTimeOut: number,
|
||||
levelLoadingMaxRetry: number,
|
||||
levelLoadingRetryDelay: number,
|
||||
levelLoadingMaxRetryTimeout: number
|
||||
};
|
||||
|
||||
type StreamControllerConfig = {
|
||||
autoStartLoad: boolean,
|
||||
startPosition: number,
|
||||
defaultAudioCodec?: string,
|
||||
initialLiveManifestSize: number,
|
||||
maxBufferLength: number,
|
||||
maxBufferSize: number,
|
||||
maxBufferHole: number,
|
||||
|
||||
lowBufferWatchdogPeriod: number,
|
||||
highBufferWatchdogPeriod: number,
|
||||
nudgeOffset: number,
|
||||
nudgeMaxRetry: number,
|
||||
maxFragLookUpTolerance: number,
|
||||
liveSyncDurationCount: number,
|
||||
liveMaxLatencyDurationCount: number,
|
||||
liveSyncDuration?: number,
|
||||
liveMaxLatencyDuration?: number,
|
||||
maxMaxBufferLength: number,
|
||||
|
||||
startFragPrefetch: boolean,
|
||||
};
|
||||
|
||||
type TimelineControllerConfig = {
|
||||
cueHandler: any, // TODO(typescript-cues): Type once file is done
|
||||
enableCEA708Captions: boolean,
|
||||
enableWebVTT: boolean,
|
||||
captionsTextTrack1Label: string,
|
||||
captionsTextTrack1LanguageCode: string,
|
||||
captionsTextTrack2Label: string,
|
||||
captionsTextTrack2LanguageCode: string,
|
||||
};
|
||||
|
||||
type TSDemuxerConfig = {
|
||||
forceKeyFrameOnDiscontinuity: boolean,
|
||||
};
|
||||
|
||||
export type HlsConfig =
|
||||
{
|
||||
debug: boolean,
|
||||
enableWorker: boolean,
|
||||
enableSoftwareAES: boolean,
|
||||
minAutoBitrate: number,
|
||||
loader: any, // TODO(typescript-xhrloader): Type once XHR is done
|
||||
xhrSetup?: (xhr: XMLHttpRequest, url: string) => void,
|
||||
|
||||
// Alt Audio
|
||||
audioStreamController?: any, // TODO(typescript-audiostreamcontroller): Type once file is done
|
||||
audioTrackController?: any, // TODO(typescript-audiotrackcontroller): Type once file is done
|
||||
// Subtitle
|
||||
subtitleStreamController?: any, // TODO(typescript-subtitlestreamcontroller): Type once file is done
|
||||
subtitleTrackController?: any, // TODO(typescript-subtitletrackcontroller): Type once file is done
|
||||
timelineController?: any, // TODO(typescript-timelinecontroller): Type once file is done
|
||||
// EME
|
||||
emeController?: typeof EMEController,
|
||||
|
||||
abrController: any, // TODO(typescript-abrcontroller): Type once file is done
|
||||
bufferController: typeof BufferController,
|
||||
capLevelController: any, // TODO(typescript-caplevelcontroller): Type once file is done
|
||||
fpsController: any, // TODO(typescript-fpscontroller): Type once file is done
|
||||
} &
|
||||
ABRControllerConfig &
|
||||
BufferControllerConfig &
|
||||
CapLevelControllerConfig &
|
||||
EMEControllerConfig &
|
||||
FPSControllerConfig &
|
||||
FragmentLoaderConfig &
|
||||
LevelControllerConfig &
|
||||
MP4RemuxerConfig &
|
||||
PlaylistLoaderConfig &
|
||||
StreamControllerConfig &
|
||||
Partial<TimelineControllerConfig> &
|
||||
TSDemuxerConfig;
|
||||
|
||||
// If possible, keep hlsDefaultConfig shallow
|
||||
// It is cloned whenever a new Hls instance is created, by keeping the config
|
||||
// shallow the properties are cloned, and we don't end up manipulating the default
|
||||
export const hlsDefaultConfig: HlsConfig = {
|
||||
autoStartLoad: true, // used by stream-controller
|
||||
startPosition: -1, // used by stream-controller
|
||||
defaultAudioCodec: void 0, // used by stream-controller
|
||||
debug: false, // used by logger
|
||||
capLevelOnFPSDrop: false, // used by fps-controller
|
||||
capLevelToPlayerSize: false, // used by cap-level-controller
|
||||
initialLiveManifestSize: 1, // used by stream-controller
|
||||
maxBufferLength: 30, // used by stream-controller
|
||||
maxBufferSize: 60 * 1000 * 1000, // used by stream-controller
|
||||
maxBufferHole: 0.5, // used by stream-controller
|
||||
|
||||
lowBufferWatchdogPeriod: 0.5, // used by stream-controller
|
||||
highBufferWatchdogPeriod: 3, // used by stream-controller
|
||||
nudgeOffset: 0.1, // used by stream-controller
|
||||
nudgeMaxRetry: 3, // used by stream-controller
|
||||
maxFragLookUpTolerance: 0.25, // used by stream-controller
|
||||
liveSyncDurationCount: 3, // used by stream-controller
|
||||
liveMaxLatencyDurationCount: Infinity, // used by stream-controller
|
||||
liveSyncDuration: void 0, // used by stream-controller
|
||||
liveMaxLatencyDuration: void 0, // used by stream-controller
|
||||
liveDurationInfinity: false, // used by buffer-controller
|
||||
liveBackBufferLength: Infinity, // used by buffer-controller
|
||||
maxMaxBufferLength: 600, // used by stream-controller
|
||||
enableWorker: true, // used by demuxer
|
||||
enableSoftwareAES: true, // used by decrypter
|
||||
manifestLoadingTimeOut: 10000, // used by playlist-loader
|
||||
manifestLoadingMaxRetry: 1, // used by playlist-loader
|
||||
manifestLoadingRetryDelay: 1000, // used by playlist-loader
|
||||
manifestLoadingMaxRetryTimeout: 64000, // used by playlist-loader
|
||||
startLevel: void 0, // used by level-controller
|
||||
levelLoadingTimeOut: 10000, // used by playlist-loader
|
||||
levelLoadingMaxRetry: 4, // used by playlist-loader
|
||||
levelLoadingRetryDelay: 1000, // used by playlist-loader
|
||||
levelLoadingMaxRetryTimeout: 64000, // used by playlist-loader
|
||||
fragLoadingTimeOut: 20000, // used by fragment-loader
|
||||
fragLoadingMaxRetry: 6, // used by fragment-loader
|
||||
fragLoadingRetryDelay: 1000, // used by fragment-loader
|
||||
fragLoadingMaxRetryTimeout: 64000, // used by fragment-loader
|
||||
startFragPrefetch: false, // used by stream-controller
|
||||
fpsDroppedMonitoringPeriod: 5000, // used by fps-controller
|
||||
fpsDroppedMonitoringThreshold: 0.2, // used by fps-controller
|
||||
appendErrorMaxRetry: 3, // used by buffer-controller
|
||||
loader: XhrLoader,
|
||||
// loader: FetchLoader,
|
||||
fLoader: void 0, // used by fragment-loader
|
||||
pLoader: void 0, // used by playlist-loader
|
||||
xhrSetup: void 0, // used by xhr-loader
|
||||
licenseXhrSetup: void 0, // used by eme-controller
|
||||
// fetchSetup: void 0,
|
||||
abrController: AbrController,
|
||||
bufferController: BufferController,
|
||||
capLevelController: CapLevelController,
|
||||
fpsController: FPSController,
|
||||
stretchShortVideoTrack: false, // used by mp4-remuxer
|
||||
maxAudioFramesDrift: 1, // used by mp4-remuxer
|
||||
forceKeyFrameOnDiscontinuity: true, // used by ts-demuxer
|
||||
abrEwmaFastLive: 3, // used by abr-controller
|
||||
abrEwmaSlowLive: 9, // used by abr-controller
|
||||
abrEwmaFastVoD: 3, // used by abr-controller
|
||||
abrEwmaSlowVoD: 9, // used by abr-controller
|
||||
abrEwmaDefaultEstimate: 5e5, // 500 kbps // used by abr-controller
|
||||
abrBandWidthFactor: 0.95, // used by abr-controller
|
||||
abrBandWidthUpFactor: 0.7, // used by abr-controller
|
||||
abrMaxWithRealBitrate: false, // used by abr-controller
|
||||
maxStarvationDelay: 4, // used by abr-controller
|
||||
maxLoadingDelay: 4, // used by abr-controller
|
||||
minAutoBitrate: 0, // used by hls
|
||||
emeEnabled: false, // used by eme-controller
|
||||
widevineLicenseUrl: void 0, // used by eme-controller
|
||||
requestMediaKeySystemAccessFunc: requestMediaKeySystemAccess, // used by eme-controller
|
||||
|
||||
// Dynamic Modules
|
||||
...timelineConfig(),
|
||||
subtitleStreamController: (__USE_SUBTITLES__) ? SubtitleStreamController : void 0,
|
||||
subtitleTrackController: (__USE_SUBTITLES__) ? SubtitleTrackController : void 0,
|
||||
timelineController: (__USE_SUBTITLES__) ? TimelineController : void 0,
|
||||
audioStreamController: (__USE_ALT_AUDIO__) ? AudioStreamController : void 0,
|
||||
audioTrackController: (__USE_ALT_AUDIO__) ? AudioTrackController : void 0,
|
||||
emeController: (__USE_EME_DRM__) ? EMEController : void 0
|
||||
};
|
||||
|
||||
function timelineConfig (): TimelineControllerConfig {
|
||||
if (!__USE_SUBTITLES__) {
|
||||
// intentionally doing this over returning Partial<TimelineControllerConfig> above
|
||||
// this has the added nice property of still requiring the object below to completely define all props.
|
||||
return {} as any;
|
||||
}
|
||||
return {
|
||||
cueHandler: Cues, // used by timeline-controller
|
||||
enableCEA708Captions: true, // used by timeline-controller
|
||||
enableWebVTT: true, // used by timeline-controller
|
||||
captionsTextTrack1Label: 'English', // used by timeline-controller
|
||||
captionsTextTrack1LanguageCode: 'en', // used by timeline-controller
|
||||
captionsTextTrack2Label: 'Spanish', // used by timeline-controller
|
||||
captionsTextTrack2LanguageCode: 'es' // used by timeline-controller
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,90 @@
|
|||
/*
|
||||
*
|
||||
* All objects in the event handling chain should inherit from this class
|
||||
*
|
||||
*/
|
||||
|
||||
import { logger } from './utils/logger';
|
||||
import { ErrorTypes, ErrorDetails } from './errors';
|
||||
import Event from './events';
|
||||
import Hls from './hls';
|
||||
|
||||
const FORBIDDEN_EVENT_NAMES = {
|
||||
'hlsEventGeneric': true,
|
||||
'hlsHandlerDestroying': true,
|
||||
'hlsHandlerDestroyed': true
|
||||
};
|
||||
|
||||
class EventHandler {
|
||||
hls: Hls;
|
||||
handledEvents: any[];
|
||||
useGenericHandler: boolean;
|
||||
|
||||
constructor (hls: Hls, ...events: any[]) {
|
||||
this.hls = hls;
|
||||
this.onEvent = this.onEvent.bind(this);
|
||||
this.handledEvents = events;
|
||||
this.useGenericHandler = true;
|
||||
|
||||
this.registerListeners();
|
||||
}
|
||||
|
||||
destroy () {
|
||||
this.onHandlerDestroying();
|
||||
this.unregisterListeners();
|
||||
this.onHandlerDestroyed();
|
||||
}
|
||||
|
||||
protected onHandlerDestroying () {}
|
||||
protected onHandlerDestroyed () {}
|
||||
|
||||
isEventHandler () {
|
||||
return typeof this.handledEvents === 'object' && this.handledEvents.length && typeof this.onEvent === 'function';
|
||||
}
|
||||
|
||||
registerListeners () {
|
||||
if (this.isEventHandler()) {
|
||||
this.handledEvents.forEach(function (event) {
|
||||
if (FORBIDDEN_EVENT_NAMES[event]) {
|
||||
throw new Error('Forbidden event-name: ' + event);
|
||||
}
|
||||
|
||||
this.hls.on(event, this.onEvent);
|
||||
}, this);
|
||||
}
|
||||
}
|
||||
|
||||
unregisterListeners () {
|
||||
if (this.isEventHandler()) {
|
||||
this.handledEvents.forEach(function (event) {
|
||||
this.hls.off(event, this.onEvent);
|
||||
}, this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* arguments: event (string), data (any)
|
||||
*/
|
||||
onEvent (event: string, data: any) {
|
||||
this.onEventGeneric(event, data);
|
||||
}
|
||||
|
||||
onEventGeneric (event: string, data: any) {
|
||||
let eventToFunction = function (event: string, data: any) {
|
||||
let funcName = 'on' + event.replace('hls', '');
|
||||
if (typeof this[funcName] !== 'function') {
|
||||
throw new Error(`Event ${event} has no generic handler in this ${this.constructor.name} class (tried ${funcName})`);
|
||||
}
|
||||
|
||||
return this[funcName].bind(this, data);
|
||||
};
|
||||
try {
|
||||
eventToFunction.call(this, event, data).call();
|
||||
} catch (err) {
|
||||
logger.error(`An internal error happened while handling event ${event}. Error message: "${err.message}". Here is a stacktrace:`, err);
|
||||
this.hls.trigger(Event.ERROR, { type: ErrorTypes.OTHER_ERROR, details: ErrorDetails.INTERNAL_EXCEPTION, fatal: false, event: event, err: err });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default EventHandler;
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
/**
|
||||
* @readonly
|
||||
* @enum {string}
|
||||
*/
|
||||
const HlsEvents = {
|
||||
// fired before MediaSource is attaching to media element - data: { media }
|
||||
MEDIA_ATTACHING: 'hlsMediaAttaching',
|
||||
// fired when MediaSource has been succesfully attached to media element - data: { }
|
||||
MEDIA_ATTACHED: 'hlsMediaAttached',
|
||||
// fired before detaching MediaSource from media element - data: { }
|
||||
MEDIA_DETACHING: 'hlsMediaDetaching',
|
||||
// fired when MediaSource has been detached from media element - data: { }
|
||||
MEDIA_DETACHED: 'hlsMediaDetached',
|
||||
// fired when we buffer is going to be reset - data: { }
|
||||
BUFFER_RESET: 'hlsBufferReset',
|
||||
// fired when we know about the codecs that we need buffers for to push into - data: {tracks : { container, codec, levelCodec, initSegment, metadata }}
|
||||
BUFFER_CODECS: 'hlsBufferCodecs',
|
||||
// fired when sourcebuffers have been created - data: { tracks : tracks }
|
||||
BUFFER_CREATED: 'hlsBufferCreated',
|
||||
// fired when we append a segment to the buffer - data: { segment: segment object }
|
||||
BUFFER_APPENDING: 'hlsBufferAppending',
|
||||
// fired when we are done with appending a media segment to the buffer - data : { parent : segment parent that triggered BUFFER_APPENDING, pending : nb of segments waiting for appending for this segment parent}
|
||||
BUFFER_APPENDED: 'hlsBufferAppended',
|
||||
// fired when the stream is finished and we want to notify the media buffer that there will be no more data - data: { }
|
||||
BUFFER_EOS: 'hlsBufferEos',
|
||||
// fired when the media buffer should be flushed - data { startOffset, endOffset }
|
||||
BUFFER_FLUSHING: 'hlsBufferFlushing',
|
||||
// fired when the media buffer has been flushed - data: { }
|
||||
BUFFER_FLUSHED: 'hlsBufferFlushed',
|
||||
// fired to signal that a manifest loading starts - data: { url : manifestURL}
|
||||
MANIFEST_LOADING: 'hlsManifestLoading',
|
||||
// fired after manifest has been loaded - data: { levels : [available quality levels], audioTracks : [ available audio tracks], url : manifestURL, stats : { trequest, tfirst, tload, mtime}}
|
||||
MANIFEST_LOADED: 'hlsManifestLoaded',
|
||||
// fired after manifest has been parsed - data: { levels : [available quality levels], firstLevel : index of first quality level appearing in Manifest}
|
||||
MANIFEST_PARSED: 'hlsManifestParsed',
|
||||
// fired when a level switch is requested - data: { level : id of new level }
|
||||
LEVEL_SWITCHING: 'hlsLevelSwitching',
|
||||
// fired when a level switch is effective - data: { level : id of new level }
|
||||
LEVEL_SWITCHED: 'hlsLevelSwitched',
|
||||
// fired when a level playlist loading starts - data: { url : level URL, level : id of level being loaded}
|
||||
LEVEL_LOADING: 'hlsLevelLoading',
|
||||
// fired when a level playlist loading finishes - data: { details : levelDetails object, level : id of loaded level, stats : { trequest, tfirst, tload, mtime} }
|
||||
LEVEL_LOADED: 'hlsLevelLoaded',
|
||||
// fired when a level's details have been updated based on previous details, after it has been loaded - data: { details : levelDetails object, level : id of updated level }
|
||||
LEVEL_UPDATED: 'hlsLevelUpdated',
|
||||
// fired when a level's PTS information has been updated after parsing a fragment - data: { details : levelDetails object, level : id of updated level, drift: PTS drift observed when parsing last fragment }
|
||||
LEVEL_PTS_UPDATED: 'hlsLevelPtsUpdated',
|
||||
// fired to notify that audio track lists has been updated - data: { audioTracks : audioTracks }
|
||||
AUDIO_TRACKS_UPDATED: 'hlsAudioTracksUpdated',
|
||||
// fired when an audio track switching is requested - data: { id : audio track id }
|
||||
AUDIO_TRACK_SWITCHING: 'hlsAudioTrackSwitching',
|
||||
// fired when an audio track switch actually occurs - data: { id : audio track id }
|
||||
AUDIO_TRACK_SWITCHED: 'hlsAudioTrackSwitched',
|
||||
// fired when an audio track loading starts - data: { url : audio track URL, id : audio track id }
|
||||
AUDIO_TRACK_LOADING: 'hlsAudioTrackLoading',
|
||||
// fired when an audio track loading finishes - data: { details : levelDetails object, id : audio track id, stats : { trequest, tfirst, tload, mtime } }
|
||||
AUDIO_TRACK_LOADED: 'hlsAudioTrackLoaded',
|
||||
// fired to notify that subtitle track lists has been updated - data: { subtitleTracks : subtitleTracks }
|
||||
SUBTITLE_TRACKS_UPDATED: 'hlsSubtitleTracksUpdated',
|
||||
// fired when an subtitle track switch occurs - data: { id : subtitle track id }
|
||||
SUBTITLE_TRACK_SWITCH: 'hlsSubtitleTrackSwitch',
|
||||
// fired when a subtitle track loading starts - data: { url : subtitle track URL, id : subtitle track id }
|
||||
SUBTITLE_TRACK_LOADING: 'hlsSubtitleTrackLoading',
|
||||
// fired when a subtitle track loading finishes - data: { details : levelDetails object, id : subtitle track id, stats : { trequest, tfirst, tload, mtime } }
|
||||
SUBTITLE_TRACK_LOADED: 'hlsSubtitleTrackLoaded',
|
||||
// fired when a subtitle fragment has been processed - data: { success : boolean, frag : the processed frag }
|
||||
SUBTITLE_FRAG_PROCESSED: 'hlsSubtitleFragProcessed',
|
||||
// fired when the first timestamp is found - data: { id : demuxer id, initPTS: initPTS, frag : fragment object }
|
||||
INIT_PTS_FOUND: 'hlsInitPtsFound',
|
||||
// fired when a fragment loading starts - data: { frag : fragment object }
|
||||
FRAG_LOADING: 'hlsFragLoading',
|
||||
// fired when a fragment loading is progressing - data: { frag : fragment object, { trequest, tfirst, loaded } }
|
||||
FRAG_LOAD_PROGRESS: 'hlsFragLoadProgress',
|
||||
// Identifier for fragment load aborting for emergency switch down - data: { frag : fragment object }
|
||||
FRAG_LOAD_EMERGENCY_ABORTED: 'hlsFragLoadEmergencyAborted',
|
||||
// fired when a fragment loading is completed - data: { frag : fragment object, payload : fragment payload, stats : { trequest, tfirst, tload, length } }
|
||||
FRAG_LOADED: 'hlsFragLoaded',
|
||||
// fired when a fragment has finished decrypting - data: { id : demuxer id, frag: fragment object, payload : fragment payload, stats : { tstart, tdecrypt } }
|
||||
FRAG_DECRYPTED: 'hlsFragDecrypted',
|
||||
// fired when Init Segment has been extracted from fragment - data: { id : demuxer id, frag: fragment object, moov : moov MP4 box, codecs : codecs found while parsing fragment }
|
||||
FRAG_PARSING_INIT_SEGMENT: 'hlsFragParsingInitSegment',
|
||||
// fired when parsing sei text is completed - data: { id : demuxer id, frag: fragment object, samples : [ sei samples pes ] }
|
||||
FRAG_PARSING_USERDATA: 'hlsFragParsingUserdata',
|
||||
// fired when parsing id3 is completed - data: { id : demuxer id, frag: fragment object, samples : [ id3 samples pes ] }
|
||||
FRAG_PARSING_METADATA: 'hlsFragParsingMetadata',
|
||||
// fired when data have been extracted from fragment - data: { id : demuxer id, frag: fragment object, data1 : moof MP4 box or TS fragments, data2 : mdat MP4 box or null}
|
||||
FRAG_PARSING_DATA: 'hlsFragParsingData',
|
||||
// fired when fragment parsing is completed - data: { id : demuxer id, frag: fragment object }
|
||||
FRAG_PARSED: 'hlsFragParsed',
|
||||
// fired when fragment remuxed MP4 boxes have all been appended into SourceBuffer - data: { id : demuxer id, frag : fragment object, stats : { trequest, tfirst, tload, tparsed, tbuffered, length, bwEstimate } }
|
||||
FRAG_BUFFERED: 'hlsFragBuffered',
|
||||
// fired when fragment matching with current media position is changing - data : { id : demuxer id, frag : fragment object }
|
||||
FRAG_CHANGED: 'hlsFragChanged',
|
||||
// Identifier for a FPS drop event - data: { curentDropped, currentDecoded, totalDroppedFrames }
|
||||
FPS_DROP: 'hlsFpsDrop',
|
||||
// triggered when FPS drop triggers auto level capping - data: { level, droppedlevel }
|
||||
FPS_DROP_LEVEL_CAPPING: 'hlsFpsDropLevelCapping',
|
||||
// Identifier for an error event - data: { type : error type, details : error details, fatal : if true, hls.js cannot/will not try to recover, if false, hls.js will try to recover,other error specific data }
|
||||
ERROR: 'hlsError',
|
||||
// fired when hls.js instance starts destroying. Different from MEDIA_DETACHED as one could want to detach and reattach a media to the instance of hls.js to handle mid-rolls for example - data: { }
|
||||
DESTROYING: 'hlsDestroying',
|
||||
// fired when a decrypt key loading starts - data: { frag : fragment object }
|
||||
KEY_LOADING: 'hlsKeyLoading',
|
||||
// fired when a decrypt key loading is completed - data: { frag : fragment object, payload : key payload, stats : { trequest, tfirst, tload, length } }
|
||||
KEY_LOADED: 'hlsKeyLoaded',
|
||||
// fired upon stream controller state transitions - data: { previousState, nextState }
|
||||
STREAM_STATE_TRANSITION: 'hlsStreamStateTransition'
|
||||
};
|
||||
|
||||
export default HlsEvents;
|
||||
|
|
@ -0,0 +1,674 @@
|
|||
import * as URLToolkit from 'url-toolkit';
|
||||
|
||||
import {
|
||||
ErrorTypes,
|
||||
ErrorDetails
|
||||
} from './errors';
|
||||
|
||||
import PlaylistLoader from './loader/playlist-loader';
|
||||
import FragmentLoader from './loader/fragment-loader';
|
||||
import KeyLoader from './loader/key-loader';
|
||||
|
||||
import { FragmentTracker } from './controller/fragment-tracker';
|
||||
import StreamController from './controller/stream-controller';
|
||||
import LevelController from './controller/level-controller';
|
||||
import ID3TrackController from './controller/id3-track-controller';
|
||||
|
||||
import { isSupported } from './is-supported';
|
||||
import { logger, enableLogs } from './utils/logger';
|
||||
import { hlsDefaultConfig, HlsConfig } from './config';
|
||||
|
||||
import HlsEvents from './events';
|
||||
|
||||
import { Observer } from './observer';
|
||||
|
||||
/**
|
||||
* @module Hls
|
||||
* @class
|
||||
* @constructor
|
||||
*/
|
||||
export default class Hls extends Observer {
|
||||
public static defaultConfig?: HlsConfig;
|
||||
public config: HlsConfig;
|
||||
|
||||
private _autoLevelCapping: number;
|
||||
private abrController: any;
|
||||
private capLevelController: any;
|
||||
private levelController: any;
|
||||
private streamController: any;
|
||||
private networkControllers: any[];
|
||||
private audioTrackController: any;
|
||||
private subtitleTrackController: any;
|
||||
private emeController: any;
|
||||
private coreComponents: any[];
|
||||
private media: HTMLMediaElement | null = null;
|
||||
private url: string | null = null;
|
||||
|
||||
/**
|
||||
* @type {string}
|
||||
*/
|
||||
static get version (): string {
|
||||
return __VERSION__;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {boolean}
|
||||
*/
|
||||
static isSupported (): boolean {
|
||||
return isSupported();
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsEvents}
|
||||
*/
|
||||
static get Events () {
|
||||
return HlsEvents;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsErrorTypes}
|
||||
*/
|
||||
static get ErrorTypes () {
|
||||
return ErrorTypes;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsErrorDetails}
|
||||
*/
|
||||
static get ErrorDetails () {
|
||||
return ErrorDetails;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsConfig}
|
||||
*/
|
||||
static get DefaultConfig (): HlsConfig {
|
||||
if (!Hls.defaultConfig) {
|
||||
return hlsDefaultConfig;
|
||||
}
|
||||
|
||||
return Hls.defaultConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsConfig}
|
||||
*/
|
||||
static set DefaultConfig (defaultConfig: HlsConfig) {
|
||||
Hls.defaultConfig = defaultConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an instance of an HLS client that can attach to exactly one `HTMLMediaElement`.
|
||||
*
|
||||
* @constructs Hls
|
||||
* @param {HlsConfig} config
|
||||
*/
|
||||
constructor (userConfig: Partial<HlsConfig> = {}) {
|
||||
super();
|
||||
|
||||
const defaultConfig = Hls.DefaultConfig;
|
||||
|
||||
if ((userConfig.liveSyncDurationCount || userConfig.liveMaxLatencyDurationCount) && (userConfig.liveSyncDuration || userConfig.liveMaxLatencyDuration)) {
|
||||
throw new Error('Illegal hls.js config: don\'t mix up liveSyncDurationCount/liveMaxLatencyDurationCount and liveSyncDuration/liveMaxLatencyDuration');
|
||||
}
|
||||
|
||||
// Shallow clone
|
||||
this.config = {
|
||||
...defaultConfig,
|
||||
...userConfig
|
||||
};
|
||||
|
||||
const { config } = this;
|
||||
|
||||
if (config.liveMaxLatencyDurationCount !== void 0 && config.liveMaxLatencyDurationCount <= config.liveSyncDurationCount) {
|
||||
throw new Error('Illegal hls.js config: "liveMaxLatencyDurationCount" must be gt "liveSyncDurationCount"');
|
||||
}
|
||||
|
||||
if (config.liveMaxLatencyDuration !== void 0 && (config.liveSyncDuration === void 0 || config.liveMaxLatencyDuration <= config.liveSyncDuration)) {
|
||||
throw new Error('Illegal hls.js config: "liveMaxLatencyDuration" must be gt "liveSyncDuration"');
|
||||
}
|
||||
|
||||
enableLogs(config.debug);
|
||||
|
||||
this._autoLevelCapping = -1;
|
||||
|
||||
// core controllers and network loaders
|
||||
|
||||
/**
|
||||
* @member {AbrController} abrController
|
||||
*/
|
||||
const abrController = this.abrController = new config.abrController(this); // eslint-disable-line new-cap
|
||||
const bufferController = new config.bufferController(this); // eslint-disable-line new-cap
|
||||
const capLevelController = this.capLevelController = new config.capLevelController(this); // eslint-disable-line new-cap
|
||||
const fpsController = new config.fpsController(this); // eslint-disable-line new-cap
|
||||
const playListLoader = new PlaylistLoader(this);
|
||||
const fragmentLoader = new FragmentLoader(this);
|
||||
const keyLoader = new KeyLoader(this);
|
||||
const id3TrackController = new ID3TrackController(this);
|
||||
|
||||
// network controllers
|
||||
|
||||
/**
|
||||
* @member {LevelController} levelController
|
||||
*/
|
||||
const levelController = this.levelController = new LevelController(this);
|
||||
|
||||
// FIXME: FragmentTracker must be defined before StreamController because the order of event handling is important
|
||||
const fragmentTracker = new FragmentTracker(this);
|
||||
|
||||
/**
|
||||
* @member {StreamController} streamController
|
||||
*/
|
||||
const streamController = this.streamController = new StreamController(this, fragmentTracker);
|
||||
|
||||
let networkControllers = [levelController, streamController];
|
||||
|
||||
// optional audio stream controller
|
||||
/**
|
||||
* @var {ICoreComponent | Controller}
|
||||
*/
|
||||
let Controller = config.audioStreamController;
|
||||
if (Controller) {
|
||||
networkControllers.push(new Controller(this, fragmentTracker));
|
||||
}
|
||||
|
||||
/**
|
||||
* @member {INetworkController[]} networkControllers
|
||||
*/
|
||||
this.networkControllers = networkControllers;
|
||||
|
||||
/**
|
||||
* @var {ICoreComponent[]}
|
||||
*/
|
||||
const coreComponents = [
|
||||
playListLoader,
|
||||
fragmentLoader,
|
||||
keyLoader,
|
||||
abrController,
|
||||
bufferController,
|
||||
capLevelController,
|
||||
fpsController,
|
||||
id3TrackController,
|
||||
fragmentTracker
|
||||
];
|
||||
|
||||
// optional audio track and subtitle controller
|
||||
Controller = config.audioTrackController;
|
||||
if (Controller) {
|
||||
const audioTrackController = new Controller(this);
|
||||
|
||||
/**
|
||||
* @member {AudioTrackController} audioTrackController
|
||||
*/
|
||||
this.audioTrackController = audioTrackController;
|
||||
coreComponents.push(audioTrackController);
|
||||
}
|
||||
|
||||
Controller = config.subtitleTrackController;
|
||||
if (Controller) {
|
||||
const subtitleTrackController = new Controller(this);
|
||||
|
||||
/**
|
||||
* @member {SubtitleTrackController} subtitleTrackController
|
||||
*/
|
||||
this.subtitleTrackController = subtitleTrackController;
|
||||
networkControllers.push(subtitleTrackController);
|
||||
}
|
||||
|
||||
Controller = config.emeController;
|
||||
if (Controller) {
|
||||
const emeController = new Controller(this);
|
||||
|
||||
/**
|
||||
* @member {EMEController} emeController
|
||||
*/
|
||||
this.emeController = emeController;
|
||||
coreComponents.push(emeController);
|
||||
}
|
||||
|
||||
// optional subtitle controllers
|
||||
Controller = config.subtitleStreamController;
|
||||
if (Controller) {
|
||||
networkControllers.push(new Controller(this, fragmentTracker));
|
||||
}
|
||||
Controller = config.timelineController;
|
||||
if (Controller) {
|
||||
coreComponents.push(new Controller(this));
|
||||
}
|
||||
|
||||
/**
|
||||
* @member {ICoreComponent[]}
|
||||
*/
|
||||
this.coreComponents = coreComponents;
|
||||
}
|
||||
|
||||
/**
|
||||
* Dispose of the instance
|
||||
*/
|
||||
destroy () {
|
||||
logger.log('destroy');
|
||||
this.trigger(HlsEvents.DESTROYING);
|
||||
this.detachMedia();
|
||||
this.coreComponents.concat(this.networkControllers).forEach(component => {
|
||||
component.destroy();
|
||||
});
|
||||
this.url = null;
|
||||
this.removeAllListeners();
|
||||
this._autoLevelCapping = -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Attach a media element
|
||||
* @param {HTMLMediaElement} media
|
||||
*/
|
||||
attachMedia (media: HTMLMediaElement) {
|
||||
logger.log('attachMedia');
|
||||
this.media = media;
|
||||
this.trigger(HlsEvents.MEDIA_ATTACHING, { media: media });
|
||||
}
|
||||
|
||||
/**
|
||||
* Detach from the media
|
||||
*/
|
||||
detachMedia () {
|
||||
logger.log('detachMedia');
|
||||
this.trigger(HlsEvents.MEDIA_DETACHING);
|
||||
this.media = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the source URL. Can be relative or absolute.
|
||||
* @param {string} url
|
||||
*/
|
||||
loadSource (url: string) {
|
||||
url = URLToolkit.buildAbsoluteURL(window.location.href, url, { alwaysNormalize: true });
|
||||
logger.log(`loadSource:${url}`);
|
||||
this.url = url;
|
||||
// when attaching to a source URL, trigger a playlist load
|
||||
this.trigger(HlsEvents.MANIFEST_LOADING, { url: url });
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 = -1) {
|
||||
logger.log(`startLoad(${startPosition})`);
|
||||
this.networkControllers.forEach(controller => {
|
||||
controller.startLoad(startPosition);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop loading of any stream data.
|
||||
*/
|
||||
stopLoad () {
|
||||
logger.log('stopLoad');
|
||||
this.networkControllers.forEach(controller => {
|
||||
controller.stopLoad();
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
|
||||
*/
|
||||
swapAudioCodec () {
|
||||
logger.log('swapAudioCodec');
|
||||
this.streamController.swapAudioCodec();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 () {
|
||||
logger.log('recoverMediaError');
|
||||
let media = this.media;
|
||||
this.detachMedia();
|
||||
if (media) {
|
||||
this.attachMedia(media);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {QualityLevel[]}
|
||||
*/
|
||||
// todo(typescript-levelController)
|
||||
get levels (): any[] {
|
||||
return this.levelController.levels;
|
||||
}
|
||||
|
||||
/**
|
||||
* Index of quality level currently played
|
||||
* @type {number}
|
||||
*/
|
||||
get currentLevel (): number {
|
||||
return this.streamController.currentLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
logger.log(`set currentLevel:${newLevel}`);
|
||||
this.loadLevel = newLevel;
|
||||
this.streamController.immediateLevelSwitch();
|
||||
}
|
||||
|
||||
/**
|
||||
* Index of next quality level loaded as scheduled by stream controller.
|
||||
* @type {number}
|
||||
*/
|
||||
get nextLevel (): number {
|
||||
return this.streamController.nextLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
logger.log(`set nextLevel:${newLevel}`);
|
||||
this.levelController.manualLevel = newLevel;
|
||||
this.streamController.nextLevelSwitch();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the quality level of the currently or last (of none is loaded currently) segment
|
||||
* @type {number}
|
||||
*/
|
||||
get loadLevel (): number {
|
||||
return this.levelController.level;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
logger.log(`set loadLevel:${newLevel}`);
|
||||
this.levelController.manualLevel = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* get next quality level loaded
|
||||
* @type {number}
|
||||
*/
|
||||
get nextLoadLevel (): number {
|
||||
return this.levelController.nextLoadLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
this.levelController.nextLoadLevel = level;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
return Math.max(this.levelController.firstLevel, this.minAutoLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets "first-level", see getter.
|
||||
* @type {number}
|
||||
*/
|
||||
set firstLevel (newLevel: number) {
|
||||
logger.log(`set firstLevel:${newLevel}`);
|
||||
this.levelController.firstLevel = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
return this.levelController.startLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
logger.log(`set startLevel:${newLevel}`);
|
||||
// if not in automatic start level detection, ensure startLevel is greater than minAutoLevel
|
||||
if (newLevel !== -1) {
|
||||
newLevel = Math.max(newLevel, this.minAutoLevel);
|
||||
}
|
||||
|
||||
this.levelController.startLevel = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* set dynamically set capLevelToPlayerSize against (`CapLevelController`)
|
||||
*
|
||||
* @type {boolean}
|
||||
*/
|
||||
set capLevelToPlayerSize (shouldStartCapping: boolean) {
|
||||
const newCapLevelToPlayerSize = !!shouldStartCapping;
|
||||
|
||||
if (newCapLevelToPlayerSize !== this.config.capLevelToPlayerSize) {
|
||||
if (newCapLevelToPlayerSize) {
|
||||
this.capLevelController.startCapping(); // If capping occurs, nextLevelSwitch will happen based on size.
|
||||
} else {
|
||||
this.capLevelController.stopCapping();
|
||||
this.autoLevelCapping = -1;
|
||||
this.streamController.nextLevelSwitch(); // Now we're uncapped, get the next level asap.
|
||||
}
|
||||
|
||||
this.config.capLevelToPlayerSize = newCapLevelToPlayerSize;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
||||
* @type {number}
|
||||
*/
|
||||
get autoLevelCapping (): number {
|
||||
return this._autoLevelCapping;
|
||||
}
|
||||
|
||||
/**
|
||||
* get bandwidth estimate
|
||||
* @type {number}
|
||||
*/
|
||||
get bandwidthEstimate (): number {
|
||||
const bwEstimator = this.abrController._bwEstimator;
|
||||
return bwEstimator ? bwEstimator.getEstimate() : NaN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
||||
* @type {number}
|
||||
*/
|
||||
set autoLevelCapping (newLevel: number) {
|
||||
logger.log(`set autoLevelCapping:${newLevel}`);
|
||||
this._autoLevelCapping = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* True when automatic level selection enabled
|
||||
* @type {boolean}
|
||||
*/
|
||||
get autoLevelEnabled (): boolean {
|
||||
return (this.levelController.manualLevel === -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Level set manually (if any)
|
||||
* @type {number}
|
||||
*/
|
||||
get manualLevel (): number {
|
||||
return this.levelController.manualLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* min level selectable in auto mode according to config.minAutoBitrate
|
||||
* @type {number}
|
||||
*/
|
||||
get minAutoLevel (): number {
|
||||
const { levels, config: { minAutoBitrate } } = this;
|
||||
const len = levels ? levels.length : 0;
|
||||
|
||||
for (let i = 0; i < len; i++) {
|
||||
const levelNextBitrate = levels[i].realBitrate
|
||||
? Math.max(levels[i].realBitrate, levels[i].bitrate)
|
||||
: levels[i].bitrate;
|
||||
|
||||
if (levelNextBitrate > minAutoBitrate) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* max level selectable in auto mode according to autoLevelCapping
|
||||
* @type {number}
|
||||
*/
|
||||
get maxAutoLevel (): number {
|
||||
const { levels, autoLevelCapping } = this;
|
||||
|
||||
let maxAutoLevel;
|
||||
if (autoLevelCapping === -1 && levels && levels.length) {
|
||||
maxAutoLevel = levels.length - 1;
|
||||
} else {
|
||||
maxAutoLevel = autoLevelCapping;
|
||||
}
|
||||
|
||||
return maxAutoLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* next automatically selected quality level
|
||||
* @type {number}
|
||||
*/
|
||||
get nextAutoLevel (): number {
|
||||
// ensure next auto level is between min and max auto level
|
||||
return Math.min(Math.max(this.abrController.nextAutoLevel, this.minAutoLevel), this.maxAutoLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
this.abrController.nextAutoLevel = Math.max(this.minAutoLevel, nextLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {AudioTrack[]}
|
||||
*/
|
||||
// todo(typescript-audioTrackController)
|
||||
get audioTracks (): any[] {
|
||||
const audioTrackController = this.audioTrackController;
|
||||
return audioTrackController ? audioTrackController.audioTracks : [];
|
||||
}
|
||||
|
||||
/**
|
||||
* index of the selected audio track (index in audio track lists)
|
||||
* @type {number}
|
||||
*/
|
||||
get audioTrack (): number {
|
||||
const audioTrackController = this.audioTrackController;
|
||||
return audioTrackController ? audioTrackController.audioTrack : -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* selects an audio track, based on its index in audio track lists
|
||||
* @type {number}
|
||||
*/
|
||||
set audioTrack (audioTrackId: number) {
|
||||
const audioTrackController = this.audioTrackController;
|
||||
if (audioTrackController) {
|
||||
audioTrackController.audioTrack = audioTrackId;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {Seconds}
|
||||
*/
|
||||
get liveSyncPosition (): number {
|
||||
return this.streamController.liveSyncPosition;
|
||||
}
|
||||
|
||||
/**
|
||||
* get alternate subtitle tracks list from playlist
|
||||
* @type {SubtitleTrack[]}
|
||||
*/
|
||||
// todo(typescript-subtitleTrackController)
|
||||
get subtitleTracks (): any[] {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
return subtitleTrackController ? subtitleTrackController.subtitleTracks : [];
|
||||
}
|
||||
|
||||
/**
|
||||
* index of the selected subtitle track (index in subtitle track lists)
|
||||
* @type {number}
|
||||
*/
|
||||
get subtitleTrack (): number {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
return subtitleTrackController ? subtitleTrackController.subtitleTrack : -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* select an subtitle track, based on its index in subtitle track lists
|
||||
* @type {number}
|
||||
*/
|
||||
set subtitleTrack (subtitleTrackId: number) {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
if (subtitleTrackController) {
|
||||
subtitleTrackController.subtitleTrack = subtitleTrackId;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {boolean}
|
||||
*/
|
||||
get subtitleDisplay (): boolean {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
return subtitleTrackController ? subtitleTrackController.subtitleDisplay : false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enable/disable subtitle display rendering
|
||||
* @type {boolean}
|
||||
*/
|
||||
set subtitleDisplay (value: boolean) {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
if (subtitleTrackController) {
|
||||
subtitleTrackController.subtitleDisplay = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
/*
|
||||
* Fragment Loader
|
||||
*/
|
||||
|
||||
import Event from '../events';
|
||||
import EventHandler from '../event-handler';
|
||||
import { ErrorTypes, ErrorDetails } from '../errors';
|
||||
import { logger } from '../utils/logger';
|
||||
|
||||
class FragmentLoader extends EventHandler {
|
||||
constructor (hls) {
|
||||
super(hls, Event.FRAG_LOADING);
|
||||
this.loaders = {};
|
||||
}
|
||||
|
||||
destroy () {
|
||||
let loaders = this.loaders;
|
||||
for (let loaderName in loaders) {
|
||||
let loader = loaders[loaderName];
|
||||
if (loader) {
|
||||
loader.destroy();
|
||||
}
|
||||
}
|
||||
this.loaders = {};
|
||||
|
||||
super.destroy();
|
||||
}
|
||||
|
||||
onFragLoading (data) {
|
||||
const frag = data.frag,
|
||||
type = frag.type,
|
||||
loaders = this.loaders,
|
||||
config = this.hls.config,
|
||||
FragmentILoader = config.fLoader,
|
||||
DefaultILoader = config.loader;
|
||||
|
||||
// reset fragment state
|
||||
frag.loaded = 0;
|
||||
|
||||
let loader = loaders[type];
|
||||
if (loader) {
|
||||
logger.warn(`abort previous fragment loader for type: ${type}`);
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
loader = loaders[type] = frag.loader =
|
||||
config.fLoader ? new FragmentILoader(config) : new DefaultILoader(config);
|
||||
|
||||
let loaderContext, loaderConfig, loaderCallbacks;
|
||||
|
||||
loaderContext = { url: frag.url, frag: frag, responseType: 'arraybuffer', progressData: false };
|
||||
|
||||
let start = frag.byteRangeStartOffset,
|
||||
end = frag.byteRangeEndOffset;
|
||||
|
||||
if (Number.isFinite(start) && Number.isFinite(end)) {
|
||||
loaderContext.rangeStart = start;
|
||||
loaderContext.rangeEnd = end;
|
||||
}
|
||||
|
||||
loaderConfig = {
|
||||
timeout: config.fragLoadingTimeOut,
|
||||
maxRetry: 0,
|
||||
retryDelay: 0,
|
||||
maxRetryDelay: config.fragLoadingMaxRetryTimeout
|
||||
};
|
||||
|
||||
loaderCallbacks = {
|
||||
onSuccess: this.loadsuccess.bind(this),
|
||||
onError: this.loaderror.bind(this),
|
||||
onTimeout: this.loadtimeout.bind(this),
|
||||
onProgress: this.loadprogress.bind(this)
|
||||
};
|
||||
|
||||
loader.load(loaderContext, loaderConfig, loaderCallbacks);
|
||||
}
|
||||
|
||||
loadsuccess (response, stats, context, networkDetails = null) {
|
||||
let payload = response.data, frag = context.frag;
|
||||
// detach fragment loader on load success
|
||||
frag.loader = undefined;
|
||||
this.loaders[frag.type] = undefined;
|
||||
this.hls.trigger(Event.FRAG_LOADED, { payload: payload, frag: frag, stats: stats, networkDetails: networkDetails });
|
||||
}
|
||||
|
||||
loaderror (response, context, networkDetails = null) {
|
||||
const frag = context.frag;
|
||||
let loader = frag.loader;
|
||||
if (loader) {
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
this.loaders[frag.type] = undefined;
|
||||
this.hls.trigger(Event.ERROR, { type: ErrorTypes.NETWORK_ERROR, details: ErrorDetails.FRAG_LOAD_ERROR, fatal: false, frag: context.frag, response: response, networkDetails: networkDetails });
|
||||
}
|
||||
|
||||
loadtimeout (stats, context, networkDetails = null) {
|
||||
const frag = context.frag;
|
||||
let loader = frag.loader;
|
||||
if (loader) {
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
this.loaders[frag.type] = undefined;
|
||||
this.hls.trigger(Event.ERROR, { type: ErrorTypes.NETWORK_ERROR, details: ErrorDetails.FRAG_LOAD_TIMEOUT, fatal: false, frag: context.frag, networkDetails: networkDetails });
|
||||
}
|
||||
|
||||
// data will be used for progressive parsing
|
||||
loadprogress (stats, context, data, networkDetails = null) { // jshint ignore:line
|
||||
let frag = context.frag;
|
||||
frag.loaded = stats.loaded;
|
||||
this.hls.trigger(Event.FRAG_LOAD_PROGRESS, { frag: frag, stats: stats, networkDetails: networkDetails });
|
||||
}
|
||||
}
|
||||
|
||||
export default FragmentLoader;
|
||||
|
|
@ -0,0 +1,201 @@
|
|||
|
||||
import { buildAbsoluteURL } from 'url-toolkit';
|
||||
import { logger } from '../utils/logger';
|
||||
import LevelKey from './level-key';
|
||||
import { PlaylistLevelType } from '../types/loader';
|
||||
|
||||
export enum ElementaryStreamTypes {
|
||||
AUDIO = 'audio',
|
||||
VIDEO = 'video',
|
||||
}
|
||||
|
||||
export default class Fragment {
|
||||
private _url: string | null = null;
|
||||
private _byteRange: number[] | null = null;
|
||||
private _decryptdata: LevelKey | null = null;
|
||||
|
||||
// Holds the types of data this fragment supports
|
||||
private _elementaryStreams: Record<ElementaryStreamTypes, boolean> = {
|
||||
[ElementaryStreamTypes.AUDIO]: false,
|
||||
[ElementaryStreamTypes.VIDEO]: false
|
||||
};
|
||||
|
||||
// deltaPTS tracks the change in presentation timestamp between fragments
|
||||
public deltaPTS: number = 0;
|
||||
|
||||
public rawProgramDateTime: string | null = null;
|
||||
public programDateTime: number | null = null;
|
||||
public title: string | null = null;
|
||||
public tagList: Array<string[]> = [];
|
||||
|
||||
// TODO: Move at least baseurl to constructor.
|
||||
// Currently we do a two-pass construction as use the Fragment class almost like a object for holding parsing state.
|
||||
// It may make more sense to just use a POJO to keep state during the parsing phase.
|
||||
// Have Fragment be the representation once we have a known state?
|
||||
// Something to think on.
|
||||
|
||||
// Discontinuity Counter
|
||||
public cc!: number;
|
||||
|
||||
public type!: PlaylistLevelType;
|
||||
// relurl is the portion of the URL that comes from inside the playlist.
|
||||
public relurl!: string;
|
||||
// baseurl is the URL to the playlist
|
||||
public baseurl!: string;
|
||||
// EXTINF has to be present for a m3u8 to be considered valid
|
||||
public duration!: number;
|
||||
// When this segment starts in the timeline
|
||||
public start!: number;
|
||||
// sn notates the sequence number for a segment, and if set to a string can be 'initSegment'
|
||||
public sn: number | 'initSegment' = 0;
|
||||
|
||||
public urlId: number = 0;
|
||||
// level matches this fragment to a index playlist
|
||||
public level: number = 0;
|
||||
// levelkey is the EXT-X-KEY that applies to this segment for decryption
|
||||
// core difference from the private field _decryptdata is the lack of the initialized IV
|
||||
// _decryptdata will set the IV for this segment based on the segment number in the fragment
|
||||
public levelkey?: LevelKey;
|
||||
|
||||
// TODO(typescript-xhrloader)
|
||||
public loader: any;
|
||||
|
||||
// setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
|
||||
setByteRange (value: string, previousFrag?: Fragment) {
|
||||
const params = value.split('@', 2);
|
||||
const byteRange: number[] = [];
|
||||
if (params.length === 1) {
|
||||
byteRange[0] = previousFrag ? previousFrag.byteRangeEndOffset : 0;
|
||||
} else {
|
||||
byteRange[0] = parseInt(params[1]);
|
||||
}
|
||||
byteRange[1] = parseInt(params[0]) + byteRange[0];
|
||||
this._byteRange = byteRange;
|
||||
}
|
||||
|
||||
get url () {
|
||||
if (!this._url && this.relurl) {
|
||||
this._url = buildAbsoluteURL(this.baseurl, this.relurl, { alwaysNormalize: true });
|
||||
}
|
||||
|
||||
return this._url;
|
||||
}
|
||||
|
||||
set url (value) {
|
||||
this._url = value;
|
||||
}
|
||||
|
||||
get byteRange (): number[] {
|
||||
if (!this._byteRange) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return this._byteRange;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
*/
|
||||
get byteRangeStartOffset () {
|
||||
return this.byteRange[0];
|
||||
}
|
||||
|
||||
get byteRangeEndOffset () {
|
||||
return this.byteRange[1];
|
||||
}
|
||||
|
||||
get decryptdata (): LevelKey | null {
|
||||
if (!this.levelkey && !this._decryptdata) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!this._decryptdata && this.levelkey) {
|
||||
let sn = this.sn;
|
||||
if (typeof sn !== 'number') {
|
||||
// We are fetching decryption data for a initialization segment
|
||||
// If the segment was encrypted with AES-128
|
||||
// It must have an IV defined. We cannot substitute the Segment Number in.
|
||||
if (this.levelkey && this.levelkey.method === 'AES-128' && !this.levelkey.iv) {
|
||||
logger.warn(`missing IV for initialization segment with method="${this.levelkey.method}" - compliance issue`);
|
||||
}
|
||||
|
||||
/*
|
||||
Be converted to a Number.
|
||||
'initSegment' will become NaN.
|
||||
NaN, which when converted through ToInt32() -> +0.
|
||||
---
|
||||
Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
|
||||
*/
|
||||
sn = 0;
|
||||
}
|
||||
this._decryptdata = this.setDecryptDataFromLevelKey(this.levelkey, sn);
|
||||
}
|
||||
|
||||
return this._decryptdata;
|
||||
}
|
||||
|
||||
get endProgramDateTime () {
|
||||
if (this.programDateTime === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!Number.isFinite(this.programDateTime)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
let duration = !Number.isFinite(this.duration) ? 0 : this.duration;
|
||||
|
||||
return this.programDateTime + (duration * 1000);
|
||||
}
|
||||
|
||||
get encrypted () {
|
||||
return !!((this.decryptdata && this.decryptdata.uri !== null) && (this.decryptdata.key === null));
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {ElementaryStreamTypes} type
|
||||
*/
|
||||
addElementaryStream (type: ElementaryStreamTypes) {
|
||||
this._elementaryStreams[type] = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {ElementaryStreamTypes} type
|
||||
*/
|
||||
hasElementaryStream (type: ElementaryStreamTypes) {
|
||||
return this._elementaryStreams[type] === true;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
let uint8View = new Uint8Array(16);
|
||||
|
||||
for (let i = 12; i < 16; i++) {
|
||||
uint8View[i] = (segmentNumber >> 8 * (15 - i)) & 0xff;
|
||||
}
|
||||
|
||||
return uint8View;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 {
|
||||
let decryptdata = levelkey;
|
||||
|
||||
if (levelkey && levelkey.method && levelkey.uri && !levelkey.iv) {
|
||||
decryptdata = new LevelKey(levelkey.baseuri, levelkey.reluri);
|
||||
decryptdata.method = levelkey.method;
|
||||
decryptdata.iv = this.createInitializationVector(segmentNumber);
|
||||
}
|
||||
|
||||
return decryptdata;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
import { buildAbsoluteURL } from 'url-toolkit';
|
||||
|
||||
export default class LevelKey {
|
||||
private _uri: string | null = null;
|
||||
|
||||
public baseuri: string;
|
||||
public reluri: string;
|
||||
public method: string | null = null;
|
||||
public key: Uint8Array | null = null;
|
||||
public iv: Uint8Array | null = null;
|
||||
|
||||
constructor (baseURI: string, relativeURI: string) {
|
||||
this.baseuri = baseURI;
|
||||
this.reluri = relativeURI;
|
||||
}
|
||||
|
||||
get uri () {
|
||||
if (!this._uri && this.reluri) {
|
||||
this._uri = buildAbsoluteURL(this.baseuri, this.reluri, { alwaysNormalize: true });
|
||||
}
|
||||
|
||||
return this._uri;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
export default class Level {
|
||||
constructor (baseUrl) {
|
||||
// Please keep properties in alphabetical order
|
||||
this.endCC = 0;
|
||||
this.endSN = 0;
|
||||
this.fragments = [];
|
||||
this.initSegment = null;
|
||||
this.live = true;
|
||||
this.needSidxRanges = false;
|
||||
this.startCC = 0;
|
||||
this.startSN = 0;
|
||||
this.startTimeOffset = null;
|
||||
this.targetduration = 0;
|
||||
this.totalduration = 0;
|
||||
this.type = null;
|
||||
this.url = baseUrl;
|
||||
this.version = null;
|
||||
}
|
||||
|
||||
get hasProgramDateTime () {
|
||||
return !!(this.fragments[0] && Number.isFinite(this.fragments[0].programDateTime));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,370 @@
|
|||
import * as URLToolkit from 'url-toolkit';
|
||||
|
||||
import Fragment from './fragment';
|
||||
import Level from './level';
|
||||
import LevelKey from './level-key';
|
||||
|
||||
import AttrList from '../utils/attr-list';
|
||||
import { logger } from '../utils/logger';
|
||||
import { isCodecType, CodecType } from '../utils/codecs';
|
||||
import { MediaPlaylist, AudioGroup, MediaPlaylistType } from '../types/media-playlist';
|
||||
import { PlaylistLevelType } from '../types/loader';
|
||||
|
||||
/**
|
||||
* M3U8 parser
|
||||
* @module
|
||||
*/
|
||||
|
||||
// https://regex101.com is your friend
|
||||
const MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\n\r]*)[\r\n]+([^\r\n]+)/g;
|
||||
const MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
|
||||
|
||||
const LEVEL_PLAYLIST_REGEX_FAST = new RegExp([
|
||||
/#EXTINF:\s*(\d*(?:\.\d+)?)(?:,(.*)\s+)?/.source, // duration (#EXTINF:<duration>,<title>), group 1 => duration, group 2 => title
|
||||
/|(?!#)([\S+ ?]+)/.source, // segment URI, group 3 => the URI (note newline is not eaten)
|
||||
/|#EXT-X-BYTERANGE:*(.+)/.source, // next segment's byterange, group 4 => range spec (x@y)
|
||||
/|#EXT-X-PROGRAM-DATE-TIME:(.+)/.source, // next segment's program date/time group 5 => the datetime spec
|
||||
/|#.*/.source // All other non-segment oriented tags will match with all groups empty
|
||||
].join(''), 'g');
|
||||
|
||||
const LEVEL_PLAYLIST_REGEX_SLOW = /(?:(?:#(EXTM3U))|(?:#EXT-X-(PLAYLIST-TYPE):(.+))|(?:#EXT-X-(MEDIA-SEQUENCE): *(\d+))|(?:#EXT-X-(TARGETDURATION): *(\d+))|(?:#EXT-X-(KEY):(.+))|(?:#EXT-X-(START):(.+))|(?:#EXT-X-(ENDLIST))|(?:#EXT-X-(DISCONTINUITY-SEQ)UENCE:(\d+))|(?:#EXT-X-(DIS)CONTINUITY))|(?:#EXT-X-(VERSION):(\d+))|(?:#EXT-X-(MAP):(.+))|(?:(#)([^:]*):(.*))|(?:(#)(.*))(?:.*)\r?\n?/;
|
||||
|
||||
const MP4_REGEX_SUFFIX = /\.(mp4|m4s|m4v|m4a)$/i;
|
||||
|
||||
export default class M3U8Parser {
|
||||
static findGroup (groups: Array<AudioGroup>, mediaGroupId: string): AudioGroup | undefined {
|
||||
for (let i = 0; i < groups.length; i++) {
|
||||
const group = groups[i];
|
||||
if (group.id === mediaGroupId) {
|
||||
return group;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static convertAVC1ToAVCOTI (codec) {
|
||||
let avcdata = codec.split('.');
|
||||
let result;
|
||||
if (avcdata.length > 2) {
|
||||
result = avcdata.shift() + '.';
|
||||
result += parseInt(avcdata.shift()).toString(16);
|
||||
result += ('000' + parseInt(avcdata.shift()).toString(16)).substr(-4);
|
||||
} else {
|
||||
result = codec;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static resolve (url, baseUrl) {
|
||||
return URLToolkit.buildAbsoluteURL(baseUrl, url, { alwaysNormalize: true });
|
||||
}
|
||||
|
||||
static parseMasterPlaylist (string: string, baseurl: string) {
|
||||
// TODO(typescript-level)
|
||||
let levels: Array<any> = [];
|
||||
MASTER_PLAYLIST_REGEX.lastIndex = 0;
|
||||
|
||||
// TODO(typescript-level)
|
||||
function setCodecs (codecs: Array<string>, level: any) {
|
||||
['video', 'audio'].forEach((type: CodecType) => {
|
||||
const filtered = codecs.filter((codec) => isCodecType(codec, type));
|
||||
if (filtered.length) {
|
||||
const preferred = filtered.filter((codec) => {
|
||||
return codec.lastIndexOf('avc1', 0) === 0 || codec.lastIndexOf('mp4a', 0) === 0;
|
||||
});
|
||||
level[`${type}Codec`] = preferred.length > 0 ? preferred[0] : filtered[0];
|
||||
|
||||
// remove from list
|
||||
codecs = codecs.filter((codec) => filtered.indexOf(codec) === -1);
|
||||
}
|
||||
});
|
||||
|
||||
level.unknownCodecs = codecs;
|
||||
}
|
||||
|
||||
let result: RegExpExecArray | null;
|
||||
while ((result = MASTER_PLAYLIST_REGEX.exec(string)) != null) {
|
||||
// TODO(typescript-level)
|
||||
const level: any = {};
|
||||
|
||||
const attrs = level.attrs = new AttrList(result[1]);
|
||||
level.url = M3U8Parser.resolve(result[2], baseurl);
|
||||
|
||||
const resolution = attrs.decimalResolution('RESOLUTION');
|
||||
if (resolution) {
|
||||
level.width = resolution.width;
|
||||
level.height = resolution.height;
|
||||
}
|
||||
level.bitrate = attrs.decimalInteger('AVERAGE-BANDWIDTH') || attrs.decimalInteger('BANDWIDTH');
|
||||
level.name = attrs.NAME;
|
||||
|
||||
setCodecs([].concat((attrs.CODECS || '').split(/[ ,]+/)), level);
|
||||
|
||||
if (level.videoCodec && level.videoCodec.indexOf('avc1') !== -1) {
|
||||
level.videoCodec = M3U8Parser.convertAVC1ToAVCOTI(level.videoCodec);
|
||||
}
|
||||
|
||||
levels.push(level);
|
||||
}
|
||||
return levels;
|
||||
}
|
||||
|
||||
static parseMasterPlaylistMedia (string: string, baseurl: string, type: MediaPlaylistType, audioGroups: Array<AudioGroup> = []): Array<MediaPlaylist> {
|
||||
let result: RegExpExecArray | null;
|
||||
let medias: Array<MediaPlaylist> = [];
|
||||
let id = 0;
|
||||
MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0;
|
||||
while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) {
|
||||
const attrs = new AttrList(result[1]);
|
||||
if (attrs.TYPE === type) {
|
||||
const media: MediaPlaylist = {
|
||||
id: id++,
|
||||
groupId: attrs['GROUP-ID'],
|
||||
name: attrs.NAME || attrs.LANGUAGE,
|
||||
type,
|
||||
default: (attrs.DEFAULT === 'YES'),
|
||||
autoselect: (attrs.AUTOSELECT === 'YES'),
|
||||
forced: (attrs.FORCED === 'YES'),
|
||||
lang: attrs.LANGUAGE
|
||||
};
|
||||
|
||||
if (attrs.URI) {
|
||||
media.url = M3U8Parser.resolve(attrs.URI, baseurl);
|
||||
}
|
||||
|
||||
if (audioGroups.length) {
|
||||
// If there are audio groups signalled in the manifest, let's look for a matching codec string for this track
|
||||
const groupCodec = M3U8Parser.findGroup(audioGroups, media.groupId);
|
||||
|
||||
// If we don't find the track signalled, lets use the first audio groups codec we have
|
||||
// Acting as a best guess
|
||||
media.audioCodec = groupCodec ? groupCodec.codec : audioGroups[0].codec;
|
||||
}
|
||||
|
||||
medias.push(media);
|
||||
}
|
||||
}
|
||||
return medias;
|
||||
}
|
||||
|
||||
static parseLevelPlaylist (string: string, baseurl: string, id: number, type: PlaylistLevelType, levelUrlId: number) {
|
||||
let currentSN = 0;
|
||||
let totalduration = 0;
|
||||
let level = new Level(baseurl);
|
||||
let discontinuityCounter = 0;
|
||||
let prevFrag: Fragment | null = null;
|
||||
let frag: Fragment | null = new Fragment();
|
||||
let result: RegExpExecArray | RegExpMatchArray | null;
|
||||
let i: number;
|
||||
let levelkey: LevelKey | undefined;
|
||||
|
||||
let firstPdtIndex = null;
|
||||
|
||||
LEVEL_PLAYLIST_REGEX_FAST.lastIndex = 0;
|
||||
|
||||
while ((result = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) !== null) {
|
||||
const duration = result[1];
|
||||
if (duration) { // INF
|
||||
frag.duration = parseFloat(duration);
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
const title = (' ' + result[2]).slice(1);
|
||||
frag.title = title || null;
|
||||
frag.tagList.push(title ? [ 'INF', duration, title ] : [ 'INF', duration ]);
|
||||
} else if (result[3]) { // url
|
||||
if (Number.isFinite(frag.duration)) {
|
||||
const sn = currentSN++;
|
||||
frag.type = type;
|
||||
frag.start = totalduration;
|
||||
if (levelkey) {
|
||||
frag.levelkey = levelkey;
|
||||
}
|
||||
frag.sn = sn;
|
||||
frag.level = id;
|
||||
frag.cc = discontinuityCounter;
|
||||
frag.urlId = levelUrlId;
|
||||
frag.baseurl = baseurl;
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
frag.relurl = (' ' + result[3]).slice(1);
|
||||
assignProgramDateTime(frag, prevFrag);
|
||||
|
||||
level.fragments.push(frag);
|
||||
prevFrag = frag;
|
||||
totalduration += frag.duration;
|
||||
|
||||
frag = new Fragment();
|
||||
}
|
||||
} else if (result[4]) { // X-BYTERANGE
|
||||
const data = (' ' + result[4]).slice(1);
|
||||
if (prevFrag) {
|
||||
frag.setByteRange(data, prevFrag);
|
||||
} else {
|
||||
frag.setByteRange(data);
|
||||
}
|
||||
} else if (result[5]) { // PROGRAM-DATE-TIME
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
frag.rawProgramDateTime = (' ' + result[5]).slice(1);
|
||||
frag.tagList.push(['PROGRAM-DATE-TIME', frag.rawProgramDateTime]);
|
||||
if (firstPdtIndex === null) {
|
||||
firstPdtIndex = level.fragments.length;
|
||||
}
|
||||
} else {
|
||||
result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW);
|
||||
if (!result) {
|
||||
logger.warn('No matches on slow regex match for level playlist!');
|
||||
continue;
|
||||
}
|
||||
for (i = 1; i < result.length; i++) {
|
||||
if (typeof result[i] !== 'undefined') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
const value1 = (' ' + result[i + 1]).slice(1);
|
||||
const value2 = (' ' + result[i + 2]).slice(1);
|
||||
|
||||
switch (result[i]) {
|
||||
case '#':
|
||||
frag.tagList.push(value2 ? [ value1, value2 ] : [ value1 ]);
|
||||
break;
|
||||
case 'PLAYLIST-TYPE':
|
||||
level.type = value1.toUpperCase();
|
||||
break;
|
||||
case 'MEDIA-SEQUENCE':
|
||||
currentSN = level.startSN = parseInt(value1);
|
||||
break;
|
||||
case 'TARGETDURATION':
|
||||
level.targetduration = parseFloat(value1);
|
||||
break;
|
||||
case 'VERSION':
|
||||
level.version = parseInt(value1);
|
||||
break;
|
||||
case 'EXTM3U':
|
||||
break;
|
||||
case 'ENDLIST':
|
||||
level.live = false;
|
||||
break;
|
||||
case 'DIS':
|
||||
discontinuityCounter++;
|
||||
frag.tagList.push(['DIS']);
|
||||
break;
|
||||
case 'DISCONTINUITY-SEQ':
|
||||
discontinuityCounter = parseInt(value1);
|
||||
break;
|
||||
case 'KEY': {
|
||||
// https://tools.ietf.org/html/draft-pantos-http-live-streaming-08#section-3.4.4
|
||||
const decryptparams = value1;
|
||||
const keyAttrs = new AttrList(decryptparams);
|
||||
const decryptmethod = keyAttrs.enumeratedString('METHOD');
|
||||
const decrypturi = keyAttrs.URI;
|
||||
const decryptiv = keyAttrs.hexadecimalInteger('IV');
|
||||
|
||||
if (decryptmethod) {
|
||||
levelkey = new LevelKey(baseurl, decrypturi);
|
||||
if ((decrypturi) && (['AES-128', 'SAMPLE-AES', 'SAMPLE-AES-CENC'].indexOf(decryptmethod) >= 0)) {
|
||||
levelkey.method = decryptmethod;
|
||||
levelkey.key = null;
|
||||
// Initialization Vector (IV)
|
||||
levelkey.iv = decryptiv;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'START': {
|
||||
const startAttrs = new AttrList(value1);
|
||||
const startTimeOffset = startAttrs.decimalFloatingPoint('TIME-OFFSET');
|
||||
// TIME-OFFSET can be 0
|
||||
if (Number.isFinite(startTimeOffset)) {
|
||||
level.startTimeOffset = startTimeOffset;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'MAP': {
|
||||
const mapAttrs = new AttrList(value1);
|
||||
frag.relurl = mapAttrs.URI;
|
||||
if (mapAttrs.BYTERANGE) {
|
||||
frag.setByteRange(mapAttrs.BYTERANGE);
|
||||
}
|
||||
frag.baseurl = baseurl;
|
||||
frag.level = id;
|
||||
frag.type = type;
|
||||
frag.sn = 'initSegment';
|
||||
level.initSegment = frag;
|
||||
frag = new Fragment();
|
||||
frag.rawProgramDateTime = level.initSegment.rawProgramDateTime;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
logger.warn(`line parsed but not handled: ${result}`);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
frag = prevFrag;
|
||||
// logger.log('found ' + level.fragments.length + ' fragments');
|
||||
if (frag && !frag.relurl) {
|
||||
level.fragments.pop();
|
||||
totalduration -= frag.duration;
|
||||
}
|
||||
level.totalduration = totalduration;
|
||||
level.averagetargetduration = totalduration / level.fragments.length;
|
||||
level.endSN = currentSN - 1;
|
||||
level.startCC = level.fragments[0] ? level.fragments[0].cc : 0;
|
||||
level.endCC = discontinuityCounter;
|
||||
|
||||
if (!level.initSegment && level.fragments.length) {
|
||||
// this is a bit lurky but HLS really has no other way to tell us
|
||||
// if the fragments are TS or MP4, except if we download them :/
|
||||
// but this is to be able to handle SIDX.
|
||||
if (level.fragments.every((frag) => MP4_REGEX_SUFFIX.test(frag.relurl))) {
|
||||
logger.warn('MP4 fragments found but no init segment (probably no MAP, incomplete M3U8), trying to fetch SIDX');
|
||||
|
||||
frag = new Fragment();
|
||||
frag.relurl = level.fragments[0].relurl;
|
||||
frag.baseurl = baseurl;
|
||||
frag.level = id;
|
||||
frag.type = type;
|
||||
frag.sn = 'initSegment';
|
||||
|
||||
level.initSegment = frag;
|
||||
level.needSidxRanges = true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Backfill any missing PDT values
|
||||
"If the first EXT-X-PROGRAM-DATE-TIME tag in a Playlist appears after
|
||||
one or more Media Segment URIs, the client SHOULD extrapolate
|
||||
backward from that tag (using EXTINF durations and/or media
|
||||
timestamps) to associate dates with those segments."
|
||||
* We have already extrapolated forward, but all fragments up to the first instance of PDT do not have their PDTs
|
||||
* computed.
|
||||
*/
|
||||
if (firstPdtIndex) {
|
||||
backfillProgramDateTimes(level.fragments, firstPdtIndex);
|
||||
}
|
||||
|
||||
return level;
|
||||
}
|
||||
}
|
||||
|
||||
function backfillProgramDateTimes (fragments, startIndex) {
|
||||
let fragPrev = fragments[startIndex];
|
||||
for (let i = startIndex - 1; i >= 0; i--) {
|
||||
const frag = fragments[i];
|
||||
frag.programDateTime = fragPrev.programDateTime - (frag.duration * 1000);
|
||||
fragPrev = frag;
|
||||
}
|
||||
}
|
||||
|
||||
function assignProgramDateTime (frag, prevFrag) {
|
||||
if (frag.rawProgramDateTime) {
|
||||
frag.programDateTime = Date.parse(frag.rawProgramDateTime);
|
||||
} else if (prevFrag && prevFrag.programDateTime) {
|
||||
frag.programDateTime = prevFrag.endProgramDateTime;
|
||||
}
|
||||
|
||||
if (!Number.isFinite(frag.programDateTime)) {
|
||||
frag.programDateTime = null;
|
||||
frag.rawProgramDateTime = null;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,530 @@
|
|||
/**
|
||||
* PlaylistLoader - delegate for media manifest/playlist loading tasks. Takes care of parsing media to internal data-models.
|
||||
*
|
||||
* Once loaded, dispatches events with parsed data-models of manifest/levels/audio/subtitle tracks.
|
||||
*
|
||||
* Uses loader(s) set in config to do actual internal loading of resource tasks.
|
||||
*
|
||||
* @module
|
||||
*
|
||||
*/
|
||||
|
||||
import Event from '../events';
|
||||
import EventHandler from '../event-handler';
|
||||
import { ErrorTypes, ErrorDetails } from '../errors';
|
||||
import { logger } from '../utils/logger';
|
||||
import { Loader, PlaylistContextType, PlaylistLoaderContext, PlaylistLevelType, LoaderCallbacks, LoaderResponse, LoaderStats, LoaderConfiguration } from '../types/loader';
|
||||
import MP4Demuxer from '../demux/mp4demuxer';
|
||||
import M3U8Parser from './m3u8-parser';
|
||||
import { AudioGroup } from '../types/media-playlist';
|
||||
|
||||
const { performance } = window;
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*/
|
||||
class PlaylistLoader extends EventHandler {
|
||||
private loaders: Partial<Record<PlaylistContextType, Loader<PlaylistLoaderContext>>> = {};
|
||||
|
||||
/**
|
||||
* @constructs
|
||||
* @param {Hls} hls
|
||||
*/
|
||||
constructor (hls) {
|
||||
super(hls,
|
||||
Event.MANIFEST_LOADING,
|
||||
Event.LEVEL_LOADING,
|
||||
Event.AUDIO_TRACK_LOADING,
|
||||
Event.SUBTITLE_TRACK_LOADING);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {PlaylistContextType} type
|
||||
* @returns {boolean}
|
||||
*/
|
||||
static canHaveQualityLevels (type: PlaylistContextType): boolean {
|
||||
return (type !== PlaylistContextType.AUDIO_TRACK &&
|
||||
type !== PlaylistContextType.SUBTITLE_TRACK);
|
||||
}
|
||||
|
||||
/**
|
||||
* Map context.type to LevelType
|
||||
* @param {PlaylistLoaderContext} context
|
||||
* @returns {LevelType}
|
||||
*/
|
||||
static mapContextToLevelType (context: PlaylistLoaderContext): PlaylistLevelType {
|
||||
const { type } = context;
|
||||
|
||||
switch (type) {
|
||||
case PlaylistContextType.AUDIO_TRACK:
|
||||
return PlaylistLevelType.AUDIO;
|
||||
case PlaylistContextType.SUBTITLE_TRACK:
|
||||
return PlaylistLevelType.SUBTITLE;
|
||||
default:
|
||||
return PlaylistLevelType.MAIN;
|
||||
}
|
||||
}
|
||||
|
||||
static getResponseUrl (response: LoaderResponse, context: PlaylistLoaderContext): string {
|
||||
let url = response.url;
|
||||
// responseURL not supported on some browsers (it is used to detect URL redirection)
|
||||
// data-uri mode also not supported (but no need to detect redirection)
|
||||
if (url === undefined || url.indexOf('data:') === 0) {
|
||||
// fallback to initial URL
|
||||
url = context.url;
|
||||
}
|
||||
return url;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns defaults or configured loader-type overloads (pLoader and loader config params)
|
||||
* Default loader is XHRLoader (see utils)
|
||||
* @param {PlaylistLoaderContext} context
|
||||
* @returns {Loader} or other compatible configured overload
|
||||
*/
|
||||
createInternalLoader (context: PlaylistLoaderContext): Loader<PlaylistLoaderContext> {
|
||||
const config = this.hls.config;
|
||||
const PLoader = config.pLoader;
|
||||
const Loader = config.loader;
|
||||
// TODO(typescript-config): Verify once config is typed that InternalLoader always returns a Loader
|
||||
const InternalLoader = PLoader || Loader;
|
||||
|
||||
const loader = new InternalLoader(config);
|
||||
|
||||
// TODO - Do we really need to assign the instance or if the dep has been lost
|
||||
context.loader = loader;
|
||||
this.loaders[context.type] = loader;
|
||||
|
||||
return loader;
|
||||
}
|
||||
|
||||
getInternalLoader (context: PlaylistLoaderContext): Loader<PlaylistLoaderContext> | undefined {
|
||||
return this.loaders[context.type];
|
||||
}
|
||||
|
||||
resetInternalLoader (contextType: PlaylistContextType) {
|
||||
if (this.loaders[contextType]) {
|
||||
delete this.loaders[contextType];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Call `destroy` on all internal loader instances mapped (one per context type)
|
||||
*/
|
||||
destroyInternalLoaders () {
|
||||
for (let contextType in this.loaders) {
|
||||
let loader = this.loaders[contextType];
|
||||
if (loader) {
|
||||
loader.destroy();
|
||||
}
|
||||
|
||||
this.resetInternalLoader(contextType as PlaylistContextType);
|
||||
}
|
||||
}
|
||||
|
||||
destroy () {
|
||||
this.destroyInternalLoaders();
|
||||
|
||||
super.destroy();
|
||||
}
|
||||
|
||||
onManifestLoading (data: { url: string; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.MANIFEST,
|
||||
level: 0,
|
||||
id: null,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
onLevelLoading (data: { url: string; level: number | null; id: number | null; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.LEVEL,
|
||||
level: data.level,
|
||||
id: data.id,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
onAudioTrackLoading (data: { url: string; id: number | null; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.AUDIO_TRACK,
|
||||
level: null,
|
||||
id: data.id,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
onSubtitleTrackLoading (data: { url: string; id: number | null; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.SUBTITLE_TRACK,
|
||||
level: null,
|
||||
id: data.id,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
load (context: PlaylistLoaderContext): boolean {
|
||||
const config = this.hls.config;
|
||||
|
||||
logger.debug(`Loading playlist of type ${context.type}, level: ${context.level}, id: ${context.id}`);
|
||||
|
||||
// Check if a loader for this context already exists
|
||||
let loader = this.getInternalLoader(context);
|
||||
if (loader) {
|
||||
const loaderContext = loader.context;
|
||||
if (loaderContext && loaderContext.url === context.url) { // same URL can't overlap
|
||||
logger.trace('playlist request ongoing');
|
||||
return false;
|
||||
} else {
|
||||
logger.warn(`aborting previous loader for type: ${context.type}`);
|
||||
loader.abort();
|
||||
}
|
||||
}
|
||||
|
||||
let maxRetry: number;
|
||||
let timeout: number;
|
||||
let retryDelay: number;
|
||||
let maxRetryDelay: number;
|
||||
|
||||
// apply different configs for retries depending on
|
||||
// context (manifest, level, audio/subs playlist)
|
||||
switch (context.type) {
|
||||
case PlaylistContextType.MANIFEST:
|
||||
maxRetry = config.manifestLoadingMaxRetry;
|
||||
timeout = config.manifestLoadingTimeOut;
|
||||
retryDelay = config.manifestLoadingRetryDelay;
|
||||
maxRetryDelay = config.manifestLoadingMaxRetryTimeout;
|
||||
break;
|
||||
case PlaylistContextType.LEVEL:
|
||||
// Disable internal loader retry logic, since we are managing retries in Level Controller
|
||||
maxRetry = 0;
|
||||
maxRetryDelay = 0;
|
||||
retryDelay = 0;
|
||||
timeout = config.levelLoadingTimeOut;
|
||||
// TODO Introduce retry settings for audio-track and subtitle-track, it should not use level retry config
|
||||
break;
|
||||
default:
|
||||
maxRetry = config.levelLoadingMaxRetry;
|
||||
timeout = config.levelLoadingTimeOut;
|
||||
retryDelay = config.levelLoadingRetryDelay;
|
||||
maxRetryDelay = config.levelLoadingMaxRetryTimeout;
|
||||
break;
|
||||
}
|
||||
|
||||
loader = this.createInternalLoader(context);
|
||||
|
||||
const loaderConfig: LoaderConfiguration = {
|
||||
timeout,
|
||||
maxRetry,
|
||||
retryDelay,
|
||||
maxRetryDelay
|
||||
};
|
||||
|
||||
const loaderCallbacks: LoaderCallbacks<PlaylistLoaderContext> = {
|
||||
onSuccess: this.loadsuccess.bind(this),
|
||||
onError: this.loaderror.bind(this),
|
||||
onTimeout: this.loadtimeout.bind(this)
|
||||
};
|
||||
|
||||
logger.debug(`Calling internal loader delegate for URL: ${context.url}`);
|
||||
loader.load(context, loaderConfig, loaderCallbacks);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
loadsuccess (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown = null) {
|
||||
if (context.isSidxRequest) {
|
||||
this._handleSidxRequest(response, context);
|
||||
this._handlePlaylistLoaded(response, stats, context, networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
this.resetInternalLoader(context.type);
|
||||
if (typeof response.data !== 'string') {
|
||||
throw new Error('expected responseType of "text" for PlaylistLoader');
|
||||
}
|
||||
|
||||
const string = response.data;
|
||||
|
||||
stats.tload = performance.now();
|
||||
// stats.mtime = new Date(target.getResponseHeader('Last-Modified'));
|
||||
|
||||
// Validate if it is an M3U8 at all
|
||||
if (string.indexOf('#EXTM3U') !== 0) {
|
||||
this._handleManifestParsingError(response, context, 'no EXTM3U delimiter', networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if chunk-list or master. handle empty chunk list case (first EXTINF not signaled, but TARGETDURATION present)
|
||||
if (string.indexOf('#EXTINF:') > 0 || string.indexOf('#EXT-X-TARGETDURATION:') > 0) {
|
||||
this._handleTrackOrLevelPlaylist(response, stats, context, networkDetails);
|
||||
} else {
|
||||
this._handleMasterPlaylist(response, stats, context, networkDetails);
|
||||
}
|
||||
}
|
||||
|
||||
loaderror (response: LoaderResponse, context: PlaylistLoaderContext, networkDetails = null) {
|
||||
this._handleNetworkError(context, networkDetails, false, response);
|
||||
}
|
||||
|
||||
loadtimeout (stats: LoaderStats, context: PlaylistLoaderContext, networkDetails = null) {
|
||||
this._handleNetworkError(context, networkDetails, true);
|
||||
}
|
||||
|
||||
// TODO(typescript-config): networkDetails can currently be a XHR or Fetch impl,
|
||||
// but with custom loaders it could be generic investigate this further when config is typed
|
||||
_handleMasterPlaylist (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown) {
|
||||
const hls = this.hls;
|
||||
const string = response.data as string;
|
||||
|
||||
const url = PlaylistLoader.getResponseUrl(response, context);
|
||||
const levels = M3U8Parser.parseMasterPlaylist(string, url);
|
||||
if (!levels.length) {
|
||||
this._handleManifestParsingError(response, context, 'no level found in manifest', networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
// multi level playlist, parse level info
|
||||
const audioGroups: Array<AudioGroup> = levels.map(level => ({
|
||||
id: level.attrs.AUDIO,
|
||||
codec: level.audioCodec
|
||||
}));
|
||||
|
||||
const audioTracks = M3U8Parser.parseMasterPlaylistMedia(string, url, 'AUDIO', audioGroups);
|
||||
const subtitles = M3U8Parser.parseMasterPlaylistMedia(string, url, 'SUBTITLES');
|
||||
|
||||
if (audioTracks.length) {
|
||||
// check if we have found an audio track embedded in main playlist (audio track without URI attribute)
|
||||
let embeddedAudioFound = false;
|
||||
audioTracks.forEach(audioTrack => {
|
||||
if (!audioTrack.url) {
|
||||
embeddedAudioFound = true;
|
||||
}
|
||||
});
|
||||
|
||||
// if no embedded audio track defined, but audio codec signaled in quality level,
|
||||
// we need to signal this main audio track this could happen with playlists with
|
||||
// alt audio rendition in which quality levels (main)
|
||||
// contains both audio+video. but with mixed audio track not signaled
|
||||
if (embeddedAudioFound === false && levels[0].audioCodec && !levels[0].attrs.AUDIO) {
|
||||
logger.log('audio codec signaled in quality level, but no embedded audio track signaled, create one');
|
||||
audioTracks.unshift({
|
||||
type: 'main',
|
||||
name: 'main',
|
||||
default: false,
|
||||
autoselect: false,
|
||||
forced: false,
|
||||
id: -1
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
hls.trigger(Event.MANIFEST_LOADED, {
|
||||
levels,
|
||||
audioTracks,
|
||||
subtitles,
|
||||
url,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
}
|
||||
|
||||
_handleTrackOrLevelPlaylist (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown) {
|
||||
const hls = this.hls;
|
||||
|
||||
const { id, level, type } = context;
|
||||
|
||||
const url = PlaylistLoader.getResponseUrl(response, context);
|
||||
|
||||
// if the values are null, they will result in the else conditional
|
||||
const levelUrlId = Number.isFinite(id as number) ? id as number : 0;
|
||||
const levelId = Number.isFinite(level as number) ? level as number : levelUrlId;
|
||||
|
||||
const levelType = PlaylistLoader.mapContextToLevelType(context);
|
||||
const levelDetails = M3U8Parser.parseLevelPlaylist(response.data as string, url, levelId, levelType, levelUrlId);
|
||||
|
||||
// set stats on level structure
|
||||
// TODO(jstackhouse): why? mixing concerns, is it just treated as value bag?
|
||||
(levelDetails as any).tload = stats.tload;
|
||||
|
||||
// We have done our first request (Manifest-type) and receive
|
||||
// not a master playlist but a chunk-list (track/level)
|
||||
// We fire the manifest-loaded event anyway with the parsed level-details
|
||||
// by creating a single-level structure for it.
|
||||
if (type === PlaylistContextType.MANIFEST) {
|
||||
const singleLevel = {
|
||||
url,
|
||||
details: levelDetails
|
||||
};
|
||||
|
||||
hls.trigger(Event.MANIFEST_LOADED, {
|
||||
levels: [singleLevel],
|
||||
audioTracks: [],
|
||||
url,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
}
|
||||
|
||||
// save parsing time
|
||||
stats.tparsed = performance.now();
|
||||
|
||||
// in case we need SIDX ranges
|
||||
// return early after calling load for
|
||||
// the SIDX box.
|
||||
if (levelDetails.needSidxRanges) {
|
||||
const sidxUrl = levelDetails.initSegment.url;
|
||||
this.load({
|
||||
url: sidxUrl,
|
||||
isSidxRequest: true,
|
||||
type,
|
||||
level,
|
||||
levelDetails,
|
||||
id,
|
||||
rangeStart: 0,
|
||||
rangeEnd: 2048,
|
||||
responseType: 'arraybuffer'
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// extend the context with the new levelDetails property
|
||||
context.levelDetails = levelDetails;
|
||||
|
||||
this._handlePlaylistLoaded(response, stats, context, networkDetails);
|
||||
}
|
||||
|
||||
_handleSidxRequest (response: LoaderResponse, context: PlaylistLoaderContext) {
|
||||
if (typeof response.data === 'string') {
|
||||
throw new Error('sidx request must be made with responseType of array buffer');
|
||||
}
|
||||
|
||||
const sidxInfo = MP4Demuxer.parseSegmentIndex(new Uint8Array(response.data));
|
||||
// if provided fragment does not contain sidx, early return
|
||||
if (!sidxInfo) {
|
||||
return;
|
||||
}
|
||||
const sidxReferences = sidxInfo.references;
|
||||
const levelDetails = context.levelDetails;
|
||||
sidxReferences.forEach((segmentRef, index) => {
|
||||
const segRefInfo = segmentRef.info;
|
||||
if (!levelDetails) {
|
||||
return;
|
||||
}
|
||||
const frag = levelDetails.fragments[index];
|
||||
if (frag.byteRange.length === 0) {
|
||||
frag.setByteRange(String(1 + segRefInfo.end - segRefInfo.start) + '@' + String(segRefInfo.start));
|
||||
}
|
||||
});
|
||||
|
||||
if (levelDetails) {
|
||||
levelDetails.initSegment.setByteRange(String(sidxInfo.moovEndOffset) + '@0');
|
||||
}
|
||||
}
|
||||
|
||||
_handleManifestParsingError (response: LoaderResponse, context: PlaylistLoaderContext, reason: string, networkDetails: unknown) {
|
||||
this.hls.trigger(Event.ERROR, {
|
||||
type: ErrorTypes.NETWORK_ERROR,
|
||||
details: ErrorDetails.MANIFEST_PARSING_ERROR,
|
||||
fatal: true,
|
||||
url: response.url,
|
||||
reason,
|
||||
networkDetails
|
||||
});
|
||||
}
|
||||
|
||||
_handleNetworkError (context: PlaylistLoaderContext, networkDetails: unknown, timeout: boolean = false, response: LoaderResponse | null = null) {
|
||||
logger.info(`A network error occured while loading a ${context.type}-type playlist`);
|
||||
|
||||
let details;
|
||||
let fatal;
|
||||
|
||||
const loader = this.getInternalLoader(context);
|
||||
|
||||
switch (context.type) {
|
||||
case PlaylistContextType.MANIFEST:
|
||||
details = (timeout ? ErrorDetails.MANIFEST_LOAD_TIMEOUT : ErrorDetails.MANIFEST_LOAD_ERROR);
|
||||
fatal = true;
|
||||
break;
|
||||
case PlaylistContextType.LEVEL:
|
||||
details = (timeout ? ErrorDetails.LEVEL_LOAD_TIMEOUT : ErrorDetails.LEVEL_LOAD_ERROR);
|
||||
fatal = false;
|
||||
break;
|
||||
case PlaylistContextType.AUDIO_TRACK:
|
||||
details = (timeout ? ErrorDetails.AUDIO_TRACK_LOAD_TIMEOUT : ErrorDetails.AUDIO_TRACK_LOAD_ERROR);
|
||||
fatal = false;
|
||||
break;
|
||||
default:
|
||||
// details = ...?
|
||||
fatal = false;
|
||||
}
|
||||
|
||||
if (loader) {
|
||||
loader.abort();
|
||||
this.resetInternalLoader(context.type);
|
||||
}
|
||||
|
||||
// TODO(typescript-events): when error events are handled, type this
|
||||
let errorData: any = {
|
||||
type: ErrorTypes.NETWORK_ERROR,
|
||||
details,
|
||||
fatal,
|
||||
url: context.url,
|
||||
loader,
|
||||
context,
|
||||
networkDetails
|
||||
};
|
||||
|
||||
if (response) {
|
||||
errorData.response = response;
|
||||
}
|
||||
|
||||
this.hls.trigger(Event.ERROR, errorData);
|
||||
}
|
||||
|
||||
_handlePlaylistLoaded (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown) {
|
||||
const { type, level, id, levelDetails } = context;
|
||||
|
||||
if (!levelDetails || !levelDetails.targetduration) {
|
||||
this._handleManifestParsingError(response, context, 'invalid target duration', networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
const canHaveLevels = PlaylistLoader.canHaveQualityLevels(context.type);
|
||||
if (canHaveLevels) {
|
||||
this.hls.trigger(Event.LEVEL_LOADED, {
|
||||
details: levelDetails,
|
||||
level: level || 0,
|
||||
id: id || 0,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
} else {
|
||||
switch (type) {
|
||||
case PlaylistContextType.AUDIO_TRACK:
|
||||
this.hls.trigger(Event.AUDIO_TRACK_LOADED, {
|
||||
details: levelDetails,
|
||||
id,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
break;
|
||||
case PlaylistContextType.SUBTITLE_TRACK:
|
||||
this.hls.trigger(Event.SUBTITLE_TRACK_LOADED, {
|
||||
details: levelDetails,
|
||||
id,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default PlaylistLoader;
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
import { EventEmitter } from 'eventemitter3';
|
||||
|
||||
/**
|
||||
* Simple adapter sub-class of Nodejs-like EventEmitter.
|
||||
*/
|
||||
export class Observer extends EventEmitter {
|
||||
/**
|
||||
* We simply want to pass along the event-name itself
|
||||
* in every call to a handler, which is the purpose of our `trigger` method
|
||||
* extending the standard API.
|
||||
*/
|
||||
trigger (event: string, ...data: Array<any>): void {
|
||||
this.emit(event, event, ...data);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
import Level from '../loader/level';
|
||||
|
||||
export interface LoaderContext {
|
||||
// target URL
|
||||
url: string
|
||||
// loader response type (arraybuffer or default response type for playlist)
|
||||
responseType: string
|
||||
// start byte range offset
|
||||
rangeStart?: number
|
||||
// end byte range offset
|
||||
rangeEnd?: number
|
||||
// true if onProgress should report partial chunk of loaded content
|
||||
progressData?: boolean
|
||||
}
|
||||
|
||||
export interface LoaderConfiguration {
|
||||
// Max number of load retries
|
||||
maxRetry: number
|
||||
// Timeout after which `onTimeOut` callback will be triggered
|
||||
// (if loading is still not finished after that delay)
|
||||
timeout: number
|
||||
// Delay between an I/O error and following connection retry (ms).
|
||||
// This to avoid spamming the server
|
||||
retryDelay: number
|
||||
// max connection retry delay (ms)
|
||||
maxRetryDelay: number
|
||||
}
|
||||
|
||||
export interface LoaderResponse {
|
||||
url: string,
|
||||
// TODO(jstackhouse): SharedArrayBuffer, es2017 extension to TS
|
||||
data: string | ArrayBuffer
|
||||
}
|
||||
|
||||
export interface LoaderStats {
|
||||
// performance.now() just after load() has been called
|
||||
trequest: number
|
||||
// performance.now() of first received byte
|
||||
tfirst: number
|
||||
// performance.now() on load complete
|
||||
tload: number
|
||||
// performance.now() on parse completion
|
||||
tparsed: number
|
||||
// number of loaded bytes
|
||||
loaded: number
|
||||
// total number of bytes
|
||||
total: number
|
||||
}
|
||||
|
||||
type LoaderOnSuccess < T extends LoaderContext > = (
|
||||
response: LoaderResponse,
|
||||
stats: LoaderStats,
|
||||
context: T,
|
||||
networkDetails: any
|
||||
) => void;
|
||||
|
||||
type LoaderOnProgress < T extends LoaderContext > = (
|
||||
stats: LoaderStats,
|
||||
context: T,
|
||||
data: string | ArrayBuffer,
|
||||
networkDetails: any,
|
||||
) => void;
|
||||
|
||||
type LoaderOnError < T extends LoaderContext > = (
|
||||
error: {
|
||||
// error status code
|
||||
code: number,
|
||||
// error description
|
||||
text: string,
|
||||
},
|
||||
context: T,
|
||||
networkDetails: any,
|
||||
) => void;
|
||||
|
||||
type LoaderOnTimeout < T extends LoaderContext > = (
|
||||
stats: LoaderStats,
|
||||
context: T,
|
||||
) => void;
|
||||
|
||||
export interface LoaderCallbacks<T extends LoaderContext>{
|
||||
onSuccess: LoaderOnSuccess<T>,
|
||||
onError: LoaderOnError<T>,
|
||||
onTimeout: LoaderOnTimeout<T>,
|
||||
onProgress?: LoaderOnProgress<T>,
|
||||
}
|
||||
|
||||
export interface Loader<T extends LoaderContext> {
|
||||
destroy(): void
|
||||
abort(): void
|
||||
load(
|
||||
context: LoaderContext,
|
||||
config: LoaderConfiguration,
|
||||
callbacks: LoaderCallbacks<T>,
|
||||
): void
|
||||
|
||||
context: T
|
||||
}
|
||||
|
||||
/**
|
||||
* `type` property values for this loaders' context object
|
||||
* @enum
|
||||
*
|
||||
*/
|
||||
export enum PlaylistContextType {
|
||||
MANIFEST = 'manifest',
|
||||
LEVEL = 'level',
|
||||
AUDIO_TRACK = 'audioTrack',
|
||||
SUBTITLE_TRACK= 'subtitleTrack'
|
||||
}
|
||||
|
||||
/**
|
||||
* @enum {string}
|
||||
*/
|
||||
export enum PlaylistLevelType {
|
||||
MAIN = 'main',
|
||||
AUDIO = 'audio',
|
||||
SUBTITLE = 'subtitle'
|
||||
}
|
||||
|
||||
export interface PlaylistLoaderContext extends LoaderContext {
|
||||
loader?: Loader<PlaylistLoaderContext>
|
||||
|
||||
type: PlaylistContextType
|
||||
// the level index to load
|
||||
level: number | null
|
||||
// TODO: what is id?
|
||||
id: number | null
|
||||
// defines if the loader is handling a sidx request for the playlist
|
||||
isSidxRequest?: boolean
|
||||
// internal reprsentation of a parsed m3u8 level playlist
|
||||
levelDetails?: Level
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/; // eslint-disable-line no-useless-escape
|
||||
const ATTR_LIST_REGEX = /\s*(.+?)\s*=((?:\".*?\")|.*?)(?:,|$)/g; // eslint-disable-line no-useless-escape
|
||||
|
||||
// adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
|
||||
class AttrList {
|
||||
constructor (attrs) {
|
||||
if (typeof attrs === 'string') {
|
||||
attrs = AttrList.parseAttrList(attrs);
|
||||
}
|
||||
|
||||
for (let attr in attrs) {
|
||||
if (attrs.hasOwnProperty(attr)) {
|
||||
this[attr] = attrs[attr];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
decimalInteger (attrName) {
|
||||
const intValue = parseInt(this[attrName], 10);
|
||||
if (intValue > Number.MAX_SAFE_INTEGER) {
|
||||
return Infinity;
|
||||
}
|
||||
|
||||
return intValue;
|
||||
}
|
||||
|
||||
hexadecimalInteger (attrName) {
|
||||
if (this[attrName]) {
|
||||
let stringValue = (this[attrName] || '0x').slice(2);
|
||||
stringValue = ((stringValue.length & 1) ? '0' : '') + stringValue;
|
||||
|
||||
const value = new Uint8Array(stringValue.length / 2);
|
||||
for (let i = 0; i < stringValue.length / 2; i++) {
|
||||
value[i] = parseInt(stringValue.slice(i * 2, i * 2 + 2), 16);
|
||||
}
|
||||
|
||||
return value;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
hexadecimalIntegerAsNumber (attrName) {
|
||||
const intValue = parseInt(this[attrName], 16);
|
||||
if (intValue > Number.MAX_SAFE_INTEGER) {
|
||||
return Infinity;
|
||||
}
|
||||
|
||||
return intValue;
|
||||
}
|
||||
|
||||
decimalFloatingPoint (attrName) {
|
||||
return parseFloat(this[attrName]);
|
||||
}
|
||||
|
||||
enumeratedString (attrName) {
|
||||
return this[attrName];
|
||||
}
|
||||
|
||||
decimalResolution (attrName) {
|
||||
const res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);
|
||||
if (res === null) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return {
|
||||
width: parseInt(res[1], 10),
|
||||
height: parseInt(res[2], 10)
|
||||
};
|
||||
}
|
||||
|
||||
static parseAttrList (input) {
|
||||
let match, attrs = {};
|
||||
ATTR_LIST_REGEX.lastIndex = 0;
|
||||
while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
|
||||
let value = match[2], quote = '"';
|
||||
|
||||
if (value.indexOf(quote) === 0 &&
|
||||
value.lastIndexOf(quote) === (value.length - 1)) {
|
||||
value = value.slice(1, -1);
|
||||
}
|
||||
|
||||
attrs[match[1]] = value;
|
||||
}
|
||||
return attrs;
|
||||
}
|
||||
}
|
||||
|
||||
export default AttrList;
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
// from http://mp4ra.org/codecs.html
|
||||
const sampleEntryCodesISO = {
|
||||
audio: {
|
||||
'a3ds': true,
|
||||
'ac-3': true,
|
||||
'ac-4': true,
|
||||
'alac': true,
|
||||
'alaw': true,
|
||||
'dra1': true,
|
||||
'dts+': true,
|
||||
'dts-': true,
|
||||
'dtsc': true,
|
||||
'dtse': true,
|
||||
'dtsh': true,
|
||||
'ec-3': true,
|
||||
'enca': true,
|
||||
'g719': true,
|
||||
'g726': true,
|
||||
'm4ae': true,
|
||||
'mha1': true,
|
||||
'mha2': true,
|
||||
'mhm1': true,
|
||||
'mhm2': true,
|
||||
'mlpa': true,
|
||||
'mp4a': true,
|
||||
'raw ': true,
|
||||
'Opus': true,
|
||||
'samr': true,
|
||||
'sawb': true,
|
||||
'sawp': true,
|
||||
'sevc': true,
|
||||
'sqcp': true,
|
||||
'ssmv': true,
|
||||
'twos': true,
|
||||
'ulaw': true
|
||||
},
|
||||
video: {
|
||||
'avc1': true,
|
||||
'avc2': true,
|
||||
'avc3': true,
|
||||
'avc4': true,
|
||||
'avcp': true,
|
||||
'drac': true,
|
||||
'dvav': true,
|
||||
'dvhe': true,
|
||||
'encv': true,
|
||||
'hev1': true,
|
||||
'hvc1': true,
|
||||
'mjp2': true,
|
||||
'mp4v': true,
|
||||
'mvc1': true,
|
||||
'mvc2': true,
|
||||
'mvc3': true,
|
||||
'mvc4': true,
|
||||
'resv': true,
|
||||
'rv60': true,
|
||||
's263': true,
|
||||
'svc1': true,
|
||||
'svc2': true,
|
||||
'vc-1': true,
|
||||
'vp08': true,
|
||||
'vp09': true
|
||||
}
|
||||
};
|
||||
|
||||
export type CodecType = 'audio' | 'video';
|
||||
|
||||
function isCodecType (codec: string, type: CodecType): boolean {
|
||||
const typeCodes = sampleEntryCodesISO[type];
|
||||
return !!typeCodes && typeCodes[codec.slice(0, 4)] === true;
|
||||
}
|
||||
|
||||
function isCodecSupportedInMp4 (codec: string, type: CodecType): boolean {
|
||||
return MediaSource.isTypeSupported(`${type || 'video'}/mp4;codecs="${codec}"`);
|
||||
}
|
||||
|
||||
export { isCodecType, isCodecSupportedInMp4 };
|
||||
|
|
@ -0,0 +1,167 @@
|
|||
/**
|
||||
* XHR based logger
|
||||
*/
|
||||
|
||||
import { logger } from '../utils/logger';
|
||||
|
||||
const { performance, XMLHttpRequest } = window;
|
||||
|
||||
class XhrLoader {
|
||||
constructor (config) {
|
||||
if (config && config.xhrSetup) {
|
||||
this.xhrSetup = config.xhrSetup;
|
||||
}
|
||||
}
|
||||
|
||||
destroy () {
|
||||
this.abort();
|
||||
this.loader = null;
|
||||
}
|
||||
|
||||
abort () {
|
||||
let loader = this.loader;
|
||||
if (loader && loader.readyState !== 4) {
|
||||
this.stats.aborted = true;
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
window.clearTimeout(this.requestTimeout);
|
||||
this.requestTimeout = null;
|
||||
window.clearTimeout(this.retryTimeout);
|
||||
this.retryTimeout = null;
|
||||
}
|
||||
|
||||
load (context, config, callbacks) {
|
||||
this.context = context;
|
||||
this.config = config;
|
||||
this.callbacks = callbacks;
|
||||
this.stats = { trequest: performance.now(), retry: 0 };
|
||||
this.retryDelay = config.retryDelay;
|
||||
this.loadInternal();
|
||||
}
|
||||
|
||||
loadInternal () {
|
||||
let xhr, context = this.context;
|
||||
xhr = this.loader = new XMLHttpRequest();
|
||||
|
||||
let stats = this.stats;
|
||||
stats.tfirst = 0;
|
||||
stats.loaded = 0;
|
||||
const xhrSetup = this.xhrSetup;
|
||||
|
||||
try {
|
||||
if (xhrSetup) {
|
||||
try {
|
||||
xhrSetup(xhr, context.url);
|
||||
} catch (e) {
|
||||
// fix xhrSetup: (xhr, url) => {xhr.setRequestHeader("Content-Language", "test");}
|
||||
// not working, as xhr.setRequestHeader expects xhr.readyState === OPEN
|
||||
xhr.open('GET', context.url, true);
|
||||
xhrSetup(xhr, context.url);
|
||||
}
|
||||
}
|
||||
if (!xhr.readyState) {
|
||||
xhr.open('GET', context.url, true);
|
||||
}
|
||||
} catch (e) {
|
||||
// IE11 throws an exception on xhr.open if attempting to access an HTTP resource over HTTPS
|
||||
this.callbacks.onError({ code: xhr.status, text: e.message }, context, xhr);
|
||||
return;
|
||||
}
|
||||
|
||||
if (context.rangeEnd) {
|
||||
xhr.setRequestHeader('Range', 'bytes=' + context.rangeStart + '-' + (context.rangeEnd - 1));
|
||||
}
|
||||
|
||||
xhr.onreadystatechange = this.readystatechange.bind(this);
|
||||
xhr.onprogress = this.loadprogress.bind(this);
|
||||
xhr.responseType = context.responseType;
|
||||
|
||||
// setup timeout before we perform request
|
||||
this.requestTimeout = window.setTimeout(this.loadtimeout.bind(this), this.config.timeout);
|
||||
xhr.send();
|
||||
}
|
||||
|
||||
readystatechange (event) {
|
||||
let xhr = event.currentTarget,
|
||||
readyState = xhr.readyState,
|
||||
stats = this.stats,
|
||||
context = this.context,
|
||||
config = this.config;
|
||||
|
||||
// don't proceed if xhr has been aborted
|
||||
if (stats.aborted) {
|
||||
return;
|
||||
}
|
||||
|
||||
// >= HEADERS_RECEIVED
|
||||
if (readyState >= 2) {
|
||||
// clear xhr timeout and rearm it if readyState less than 4
|
||||
window.clearTimeout(this.requestTimeout);
|
||||
if (stats.tfirst === 0) {
|
||||
stats.tfirst = Math.max(performance.now(), stats.trequest);
|
||||
}
|
||||
|
||||
if (readyState === 4) {
|
||||
let status = xhr.status;
|
||||
// http status between 200 to 299 are all successful
|
||||
if (status >= 200 && status < 300) {
|
||||
stats.tload = Math.max(stats.tfirst, performance.now());
|
||||
let data, len;
|
||||
if (context.responseType === 'arraybuffer') {
|
||||
data = xhr.response;
|
||||
len = data.byteLength;
|
||||
} else {
|
||||
data = xhr.responseText;
|
||||
len = data.length;
|
||||
}
|
||||
stats.loaded = stats.total = len;
|
||||
let response = { url: xhr.responseURL, data: data };
|
||||
this.callbacks.onSuccess(response, stats, context, xhr);
|
||||
} else {
|
||||
// if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
|
||||
if (stats.retry >= config.maxRetry || (status >= 400 && status < 499)) {
|
||||
logger.error(`${status} while loading ${context.url}`);
|
||||
this.callbacks.onError({ code: status, text: xhr.statusText }, context, xhr);
|
||||
} else {
|
||||
// retry
|
||||
logger.warn(`${status} while loading ${context.url}, retrying in ${this.retryDelay}...`);
|
||||
// aborts and resets internal state
|
||||
this.destroy();
|
||||
// schedule retry
|
||||
this.retryTimeout = window.setTimeout(this.loadInternal.bind(this), this.retryDelay);
|
||||
// set exponential backoff
|
||||
this.retryDelay = Math.min(2 * this.retryDelay, config.maxRetryDelay);
|
||||
stats.retry++;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// readyState >= 2 AND readyState !==4 (readyState = HEADERS_RECEIVED || LOADING) rearm timeout as xhr not finished yet
|
||||
this.requestTimeout = window.setTimeout(this.loadtimeout.bind(this), config.timeout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
loadtimeout () {
|
||||
logger.warn(`timeout while loading ${this.context.url}`);
|
||||
this.callbacks.onTimeout(this.stats, this.context, null);
|
||||
}
|
||||
|
||||
loadprogress (event) {
|
||||
let xhr = event.currentTarget,
|
||||
stats = this.stats;
|
||||
|
||||
stats.loaded = event.loaded;
|
||||
if (event.lengthComputable) {
|
||||
stats.total = event.total;
|
||||
}
|
||||
|
||||
let onProgress = this.callbacks.onProgress;
|
||||
if (onProgress) {
|
||||
// third arg is to provide on progress data
|
||||
onProgress(stats, this.context, null, xhr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default XhrLoader;
|
||||
Loading…
Reference in New Issue