|
|
@@ -1,32965 +0,0 @@
|
|
|
-import "./chunk-Y2F7D3TJ.js";
|
|
|
-
|
|
|
-// ../../../../ZhiYi/uni-app/uni-app-demo/node_modules/hls.js/dist/hls.mjs
|
|
|
-var isFiniteNumber = Number.isFinite || function(value) {
|
|
|
- return typeof value === "number" && isFinite(value);
|
|
|
-};
|
|
|
-var isSafeInteger = Number.isSafeInteger || function(value) {
|
|
|
- return typeof value === "number" && Math.abs(value) <= MAX_SAFE_INTEGER;
|
|
|
-};
|
|
|
-var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
|
|
|
-var ErrorTypes = function(ErrorTypes2) {
|
|
|
- ErrorTypes2["NETWORK_ERROR"] = "networkError";
|
|
|
- ErrorTypes2["MEDIA_ERROR"] = "mediaError";
|
|
|
- ErrorTypes2["KEY_SYSTEM_ERROR"] = "keySystemError";
|
|
|
- ErrorTypes2["MUX_ERROR"] = "muxError";
|
|
|
- ErrorTypes2["OTHER_ERROR"] = "otherError";
|
|
|
- return ErrorTypes2;
|
|
|
-}({});
|
|
|
-var ErrorDetails = function(ErrorDetails2) {
|
|
|
- ErrorDetails2["KEY_SYSTEM_NO_KEYS"] = "keySystemNoKeys";
|
|
|
- ErrorDetails2["KEY_SYSTEM_NO_ACCESS"] = "keySystemNoAccess";
|
|
|
- ErrorDetails2["KEY_SYSTEM_NO_SESSION"] = "keySystemNoSession";
|
|
|
- ErrorDetails2["KEY_SYSTEM_NO_CONFIGURED_LICENSE"] = "keySystemNoConfiguredLicense";
|
|
|
- ErrorDetails2["KEY_SYSTEM_LICENSE_REQUEST_FAILED"] = "keySystemLicenseRequestFailed";
|
|
|
- ErrorDetails2["KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED"] = "keySystemServerCertificateRequestFailed";
|
|
|
- ErrorDetails2["KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED"] = "keySystemServerCertificateUpdateFailed";
|
|
|
- ErrorDetails2["KEY_SYSTEM_SESSION_UPDATE_FAILED"] = "keySystemSessionUpdateFailed";
|
|
|
- ErrorDetails2["KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED"] = "keySystemStatusOutputRestricted";
|
|
|
- ErrorDetails2["KEY_SYSTEM_STATUS_INTERNAL_ERROR"] = "keySystemStatusInternalError";
|
|
|
- ErrorDetails2["KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR"] = "keySystemDestroyMediaKeysError";
|
|
|
- ErrorDetails2["KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR"] = "keySystemDestroyCloseSessionError";
|
|
|
- ErrorDetails2["KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR"] = "keySystemDestroyRemoveSessionError";
|
|
|
- ErrorDetails2["MANIFEST_LOAD_ERROR"] = "manifestLoadError";
|
|
|
- ErrorDetails2["MANIFEST_LOAD_TIMEOUT"] = "manifestLoadTimeOut";
|
|
|
- ErrorDetails2["MANIFEST_PARSING_ERROR"] = "manifestParsingError";
|
|
|
- ErrorDetails2["MANIFEST_INCOMPATIBLE_CODECS_ERROR"] = "manifestIncompatibleCodecsError";
|
|
|
- ErrorDetails2["LEVEL_EMPTY_ERROR"] = "levelEmptyError";
|
|
|
- ErrorDetails2["LEVEL_LOAD_ERROR"] = "levelLoadError";
|
|
|
- ErrorDetails2["LEVEL_LOAD_TIMEOUT"] = "levelLoadTimeOut";
|
|
|
- ErrorDetails2["LEVEL_PARSING_ERROR"] = "levelParsingError";
|
|
|
- ErrorDetails2["LEVEL_SWITCH_ERROR"] = "levelSwitchError";
|
|
|
- ErrorDetails2["AUDIO_TRACK_LOAD_ERROR"] = "audioTrackLoadError";
|
|
|
- ErrorDetails2["AUDIO_TRACK_LOAD_TIMEOUT"] = "audioTrackLoadTimeOut";
|
|
|
- ErrorDetails2["SUBTITLE_LOAD_ERROR"] = "subtitleTrackLoadError";
|
|
|
- ErrorDetails2["SUBTITLE_TRACK_LOAD_TIMEOUT"] = "subtitleTrackLoadTimeOut";
|
|
|
- ErrorDetails2["FRAG_LOAD_ERROR"] = "fragLoadError";
|
|
|
- ErrorDetails2["FRAG_LOAD_TIMEOUT"] = "fragLoadTimeOut";
|
|
|
- ErrorDetails2["FRAG_DECRYPT_ERROR"] = "fragDecryptError";
|
|
|
- ErrorDetails2["FRAG_PARSING_ERROR"] = "fragParsingError";
|
|
|
- ErrorDetails2["FRAG_GAP"] = "fragGap";
|
|
|
- ErrorDetails2["REMUX_ALLOC_ERROR"] = "remuxAllocError";
|
|
|
- ErrorDetails2["KEY_LOAD_ERROR"] = "keyLoadError";
|
|
|
- ErrorDetails2["KEY_LOAD_TIMEOUT"] = "keyLoadTimeOut";
|
|
|
- ErrorDetails2["BUFFER_ADD_CODEC_ERROR"] = "bufferAddCodecError";
|
|
|
- ErrorDetails2["BUFFER_INCOMPATIBLE_CODECS_ERROR"] = "bufferIncompatibleCodecsError";
|
|
|
- ErrorDetails2["BUFFER_APPEND_ERROR"] = "bufferAppendError";
|
|
|
- ErrorDetails2["BUFFER_APPENDING_ERROR"] = "bufferAppendingError";
|
|
|
- ErrorDetails2["BUFFER_STALLED_ERROR"] = "bufferStalledError";
|
|
|
- ErrorDetails2["BUFFER_FULL_ERROR"] = "bufferFullError";
|
|
|
- ErrorDetails2["BUFFER_SEEK_OVER_HOLE"] = "bufferSeekOverHole";
|
|
|
- ErrorDetails2["BUFFER_NUDGE_ON_STALL"] = "bufferNudgeOnStall";
|
|
|
- ErrorDetails2["ASSET_LIST_LOAD_ERROR"] = "assetListLoadError";
|
|
|
- ErrorDetails2["ASSET_LIST_LOAD_TIMEOUT"] = "assetListLoadTimeout";
|
|
|
- ErrorDetails2["ASSET_LIST_PARSING_ERROR"] = "assetListParsingError";
|
|
|
- ErrorDetails2["INTERSTITIAL_ASSET_ITEM_ERROR"] = "interstitialAssetItemError";
|
|
|
- ErrorDetails2["INTERNAL_EXCEPTION"] = "internalException";
|
|
|
- ErrorDetails2["INTERNAL_ABORTED"] = "aborted";
|
|
|
- ErrorDetails2["ATTACH_MEDIA_ERROR"] = "attachMediaError";
|
|
|
- ErrorDetails2["UNKNOWN"] = "unknown";
|
|
|
- return ErrorDetails2;
|
|
|
-}({});
|
|
|
-var Events = function(Events2) {
|
|
|
- Events2["MEDIA_ATTACHING"] = "hlsMediaAttaching";
|
|
|
- Events2["MEDIA_ATTACHED"] = "hlsMediaAttached";
|
|
|
- Events2["MEDIA_DETACHING"] = "hlsMediaDetaching";
|
|
|
- Events2["MEDIA_DETACHED"] = "hlsMediaDetached";
|
|
|
- Events2["MEDIA_ENDED"] = "hlsMediaEnded";
|
|
|
- Events2["STALL_RESOLVED"] = "hlsStallResolved";
|
|
|
- Events2["BUFFER_RESET"] = "hlsBufferReset";
|
|
|
- Events2["BUFFER_CODECS"] = "hlsBufferCodecs";
|
|
|
- Events2["BUFFER_CREATED"] = "hlsBufferCreated";
|
|
|
- Events2["BUFFER_APPENDING"] = "hlsBufferAppending";
|
|
|
- Events2["BUFFER_APPENDED"] = "hlsBufferAppended";
|
|
|
- Events2["BUFFER_EOS"] = "hlsBufferEos";
|
|
|
- Events2["BUFFERED_TO_END"] = "hlsBufferedToEnd";
|
|
|
- Events2["BUFFER_FLUSHING"] = "hlsBufferFlushing";
|
|
|
- Events2["BUFFER_FLUSHED"] = "hlsBufferFlushed";
|
|
|
- Events2["MANIFEST_LOADING"] = "hlsManifestLoading";
|
|
|
- Events2["MANIFEST_LOADED"] = "hlsManifestLoaded";
|
|
|
- Events2["MANIFEST_PARSED"] = "hlsManifestParsed";
|
|
|
- Events2["LEVEL_SWITCHING"] = "hlsLevelSwitching";
|
|
|
- Events2["LEVEL_SWITCHED"] = "hlsLevelSwitched";
|
|
|
- Events2["LEVEL_LOADING"] = "hlsLevelLoading";
|
|
|
- Events2["LEVEL_LOADED"] = "hlsLevelLoaded";
|
|
|
- Events2["LEVEL_UPDATED"] = "hlsLevelUpdated";
|
|
|
- Events2["LEVEL_PTS_UPDATED"] = "hlsLevelPtsUpdated";
|
|
|
- Events2["LEVELS_UPDATED"] = "hlsLevelsUpdated";
|
|
|
- Events2["AUDIO_TRACKS_UPDATED"] = "hlsAudioTracksUpdated";
|
|
|
- Events2["AUDIO_TRACK_SWITCHING"] = "hlsAudioTrackSwitching";
|
|
|
- Events2["AUDIO_TRACK_SWITCHED"] = "hlsAudioTrackSwitched";
|
|
|
- Events2["AUDIO_TRACK_LOADING"] = "hlsAudioTrackLoading";
|
|
|
- Events2["AUDIO_TRACK_LOADED"] = "hlsAudioTrackLoaded";
|
|
|
- Events2["AUDIO_TRACK_UPDATED"] = "hlsAudioTrackUpdated";
|
|
|
- Events2["SUBTITLE_TRACKS_UPDATED"] = "hlsSubtitleTracksUpdated";
|
|
|
- Events2["SUBTITLE_TRACKS_CLEARED"] = "hlsSubtitleTracksCleared";
|
|
|
- Events2["SUBTITLE_TRACK_SWITCH"] = "hlsSubtitleTrackSwitch";
|
|
|
- Events2["SUBTITLE_TRACK_LOADING"] = "hlsSubtitleTrackLoading";
|
|
|
- Events2["SUBTITLE_TRACK_LOADED"] = "hlsSubtitleTrackLoaded";
|
|
|
- Events2["SUBTITLE_TRACK_UPDATED"] = "hlsSubtitleTrackUpdated";
|
|
|
- Events2["SUBTITLE_FRAG_PROCESSED"] = "hlsSubtitleFragProcessed";
|
|
|
- Events2["CUES_PARSED"] = "hlsCuesParsed";
|
|
|
- Events2["NON_NATIVE_TEXT_TRACKS_FOUND"] = "hlsNonNativeTextTracksFound";
|
|
|
- Events2["INIT_PTS_FOUND"] = "hlsInitPtsFound";
|
|
|
- Events2["FRAG_LOADING"] = "hlsFragLoading";
|
|
|
- Events2["FRAG_LOAD_EMERGENCY_ABORTED"] = "hlsFragLoadEmergencyAborted";
|
|
|
- Events2["FRAG_LOADED"] = "hlsFragLoaded";
|
|
|
- Events2["FRAG_DECRYPTED"] = "hlsFragDecrypted";
|
|
|
- Events2["FRAG_PARSING_INIT_SEGMENT"] = "hlsFragParsingInitSegment";
|
|
|
- Events2["FRAG_PARSING_USERDATA"] = "hlsFragParsingUserdata";
|
|
|
- Events2["FRAG_PARSING_METADATA"] = "hlsFragParsingMetadata";
|
|
|
- Events2["FRAG_PARSED"] = "hlsFragParsed";
|
|
|
- Events2["FRAG_BUFFERED"] = "hlsFragBuffered";
|
|
|
- Events2["FRAG_CHANGED"] = "hlsFragChanged";
|
|
|
- Events2["FPS_DROP"] = "hlsFpsDrop";
|
|
|
- Events2["FPS_DROP_LEVEL_CAPPING"] = "hlsFpsDropLevelCapping";
|
|
|
- Events2["MAX_AUTO_LEVEL_UPDATED"] = "hlsMaxAutoLevelUpdated";
|
|
|
- Events2["ERROR"] = "hlsError";
|
|
|
- Events2["DESTROYING"] = "hlsDestroying";
|
|
|
- Events2["KEY_LOADING"] = "hlsKeyLoading";
|
|
|
- Events2["KEY_LOADED"] = "hlsKeyLoaded";
|
|
|
- Events2["LIVE_BACK_BUFFER_REACHED"] = "hlsLiveBackBufferReached";
|
|
|
- Events2["BACK_BUFFER_REACHED"] = "hlsBackBufferReached";
|
|
|
- Events2["STEERING_MANIFEST_LOADED"] = "hlsSteeringManifestLoaded";
|
|
|
- Events2["ASSET_LIST_LOADING"] = "hlsAssetListLoading";
|
|
|
- Events2["ASSET_LIST_LOADED"] = "hlsAssetListLoaded";
|
|
|
- Events2["INTERSTITIALS_UPDATED"] = "hlsInterstitialsUpdated";
|
|
|
- Events2["INTERSTITIALS_BUFFERED_TO_BOUNDARY"] = "hlsInterstitialsBufferedToBoundary";
|
|
|
- Events2["INTERSTITIAL_ASSET_PLAYER_CREATED"] = "hlsInterstitialAssetPlayerCreated";
|
|
|
- Events2["INTERSTITIAL_STARTED"] = "hlsInterstitialStarted";
|
|
|
- Events2["INTERSTITIAL_ASSET_STARTED"] = "hlsInterstitialAssetStarted";
|
|
|
- Events2["INTERSTITIAL_ASSET_ENDED"] = "hlsInterstitialAssetEnded";
|
|
|
- Events2["INTERSTITIAL_ASSET_ERROR"] = "hlsInterstitialAssetError";
|
|
|
- Events2["INTERSTITIAL_ENDED"] = "hlsInterstitialEnded";
|
|
|
- Events2["INTERSTITIALS_PRIMARY_RESUMED"] = "hlsInterstitialsPrimaryResumed";
|
|
|
- Events2["PLAYOUT_LIMIT_REACHED"] = "hlsPlayoutLimitReached";
|
|
|
- Events2["EVENT_CUE_ENTER"] = "hlsEventCueEnter";
|
|
|
- return Events2;
|
|
|
-}({});
|
|
|
-var PlaylistContextType = {
|
|
|
- MANIFEST: "manifest",
|
|
|
- LEVEL: "level",
|
|
|
- AUDIO_TRACK: "audioTrack",
|
|
|
- SUBTITLE_TRACK: "subtitleTrack"
|
|
|
-};
|
|
|
-var PlaylistLevelType = {
|
|
|
- MAIN: "main",
|
|
|
- AUDIO: "audio",
|
|
|
- SUBTITLE: "subtitle"
|
|
|
-};
|
|
|
-var EWMA = class {
|
|
|
- // About half of the estimated value will be from the last |halfLife| samples by weight.
|
|
|
- constructor(halfLife, estimate = 0, weight = 0) {
|
|
|
- this.halfLife = void 0;
|
|
|
- this.alpha_ = void 0;
|
|
|
- this.estimate_ = void 0;
|
|
|
- this.totalWeight_ = void 0;
|
|
|
- this.halfLife = halfLife;
|
|
|
- this.alpha_ = halfLife ? Math.exp(Math.log(0.5) / halfLife) : 0;
|
|
|
- this.estimate_ = estimate;
|
|
|
- this.totalWeight_ = weight;
|
|
|
- }
|
|
|
- sample(weight, value) {
|
|
|
- const adjAlpha = Math.pow(this.alpha_, weight);
|
|
|
- this.estimate_ = value * (1 - adjAlpha) + adjAlpha * this.estimate_;
|
|
|
- this.totalWeight_ += weight;
|
|
|
- }
|
|
|
- getTotalWeight() {
|
|
|
- return this.totalWeight_;
|
|
|
- }
|
|
|
- getEstimate() {
|
|
|
- if (this.alpha_) {
|
|
|
- const zeroFactor = 1 - Math.pow(this.alpha_, this.totalWeight_);
|
|
|
- if (zeroFactor) {
|
|
|
- return this.estimate_ / zeroFactor;
|
|
|
- }
|
|
|
- }
|
|
|
- return this.estimate_;
|
|
|
- }
|
|
|
-};
|
|
|
-var EwmaBandWidthEstimator = class {
|
|
|
- constructor(slow, fast, defaultEstimate, defaultTTFB = 100) {
|
|
|
- this.defaultEstimate_ = void 0;
|
|
|
- this.minWeight_ = void 0;
|
|
|
- this.minDelayMs_ = void 0;
|
|
|
- this.slow_ = void 0;
|
|
|
- this.fast_ = void 0;
|
|
|
- this.defaultTTFB_ = void 0;
|
|
|
- this.ttfb_ = void 0;
|
|
|
- this.defaultEstimate_ = defaultEstimate;
|
|
|
- this.minWeight_ = 1e-3;
|
|
|
- this.minDelayMs_ = 50;
|
|
|
- this.slow_ = new EWMA(slow);
|
|
|
- this.fast_ = new EWMA(fast);
|
|
|
- this.defaultTTFB_ = defaultTTFB;
|
|
|
- this.ttfb_ = new EWMA(slow);
|
|
|
- }
|
|
|
- update(slow, fast) {
|
|
|
- const {
|
|
|
- slow_,
|
|
|
- fast_,
|
|
|
- ttfb_
|
|
|
- } = this;
|
|
|
- if (slow_.halfLife !== slow) {
|
|
|
- this.slow_ = new EWMA(slow, slow_.getEstimate(), slow_.getTotalWeight());
|
|
|
- }
|
|
|
- if (fast_.halfLife !== fast) {
|
|
|
- this.fast_ = new EWMA(fast, fast_.getEstimate(), fast_.getTotalWeight());
|
|
|
- }
|
|
|
- if (ttfb_.halfLife !== slow) {
|
|
|
- this.ttfb_ = new EWMA(slow, ttfb_.getEstimate(), ttfb_.getTotalWeight());
|
|
|
- }
|
|
|
- }
|
|
|
- sample(durationMs, numBytes) {
|
|
|
- durationMs = Math.max(durationMs, this.minDelayMs_);
|
|
|
- const numBits = 8 * numBytes;
|
|
|
- const durationS = durationMs / 1e3;
|
|
|
- const bandwidthInBps = numBits / durationS;
|
|
|
- this.fast_.sample(durationS, bandwidthInBps);
|
|
|
- this.slow_.sample(durationS, bandwidthInBps);
|
|
|
- }
|
|
|
- sampleTTFB(ttfb) {
|
|
|
- const seconds = ttfb / 1e3;
|
|
|
- const weight = Math.sqrt(2) * Math.exp(-Math.pow(seconds, 2) / 2);
|
|
|
- this.ttfb_.sample(weight, Math.max(ttfb, 5));
|
|
|
- }
|
|
|
- canEstimate() {
|
|
|
- return this.fast_.getTotalWeight() >= this.minWeight_;
|
|
|
- }
|
|
|
- getEstimate() {
|
|
|
- if (this.canEstimate()) {
|
|
|
- return Math.min(this.fast_.getEstimate(), this.slow_.getEstimate());
|
|
|
- } else {
|
|
|
- return this.defaultEstimate_;
|
|
|
- }
|
|
|
- }
|
|
|
- getEstimateTTFB() {
|
|
|
- if (this.ttfb_.getTotalWeight() >= this.minWeight_) {
|
|
|
- return this.ttfb_.getEstimate();
|
|
|
- } else {
|
|
|
- return this.defaultTTFB_;
|
|
|
- }
|
|
|
- }
|
|
|
- get defaultEstimate() {
|
|
|
- return this.defaultEstimate_;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- }
|
|
|
-};
|
|
|
-function _defineProperty(e, r, t) {
|
|
|
- return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
|
|
|
- value: t,
|
|
|
- enumerable: true,
|
|
|
- configurable: true,
|
|
|
- writable: true
|
|
|
- }) : e[r] = t, e;
|
|
|
-}
|
|
|
-function _extends() {
|
|
|
- return _extends = Object.assign ? Object.assign.bind() : function(n) {
|
|
|
- for (var e = 1; e < arguments.length; e++) {
|
|
|
- var t = arguments[e];
|
|
|
- for (var r in t)
|
|
|
- ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
|
|
|
- }
|
|
|
- return n;
|
|
|
- }, _extends.apply(null, arguments);
|
|
|
-}
|
|
|
-function ownKeys(e, r) {
|
|
|
- var t = Object.keys(e);
|
|
|
- if (Object.getOwnPropertySymbols) {
|
|
|
- var o = Object.getOwnPropertySymbols(e);
|
|
|
- r && (o = o.filter(function(r2) {
|
|
|
- return Object.getOwnPropertyDescriptor(e, r2).enumerable;
|
|
|
- })), t.push.apply(t, o);
|
|
|
- }
|
|
|
- return t;
|
|
|
-}
|
|
|
-function _objectSpread2(e) {
|
|
|
- for (var r = 1; r < arguments.length; r++) {
|
|
|
- var t = null != arguments[r] ? arguments[r] : {};
|
|
|
- r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
|
|
|
- _defineProperty(e, r2, t[r2]);
|
|
|
- }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
|
|
|
- Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
|
|
|
- });
|
|
|
- }
|
|
|
- return e;
|
|
|
-}
|
|
|
-function _toPrimitive(t, r) {
|
|
|
- if ("object" != typeof t || !t)
|
|
|
- return t;
|
|
|
- var e = t[Symbol.toPrimitive];
|
|
|
- if (void 0 !== e) {
|
|
|
- var i = e.call(t, r);
|
|
|
- if ("object" != typeof i)
|
|
|
- return i;
|
|
|
- throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
|
- }
|
|
|
- return ("string" === r ? String : Number)(t);
|
|
|
-}
|
|
|
-function _toPropertyKey(t) {
|
|
|
- var i = _toPrimitive(t, "string");
|
|
|
- return "symbol" == typeof i ? i : i + "";
|
|
|
-}
|
|
|
-var Logger = class {
|
|
|
- constructor(label, logger2) {
|
|
|
- this.trace = void 0;
|
|
|
- this.debug = void 0;
|
|
|
- this.log = void 0;
|
|
|
- this.warn = void 0;
|
|
|
- this.info = void 0;
|
|
|
- this.error = void 0;
|
|
|
- const lb = `[${label}]:`;
|
|
|
- this.trace = noop;
|
|
|
- this.debug = logger2.debug.bind(null, lb);
|
|
|
- this.log = logger2.log.bind(null, lb);
|
|
|
- this.warn = logger2.warn.bind(null, lb);
|
|
|
- this.info = logger2.info.bind(null, lb);
|
|
|
- this.error = logger2.error.bind(null, lb);
|
|
|
- }
|
|
|
-};
|
|
|
-var noop = function noop2() {
|
|
|
-};
|
|
|
-var fakeLogger = {
|
|
|
- trace: noop,
|
|
|
- debug: noop,
|
|
|
- log: noop,
|
|
|
- warn: noop,
|
|
|
- info: noop,
|
|
|
- error: noop
|
|
|
-};
|
|
|
-function createLogger() {
|
|
|
- return _extends({}, fakeLogger);
|
|
|
-}
|
|
|
-function consolePrintFn(type, id) {
|
|
|
- const func = self.console[type];
|
|
|
- return func ? func.bind(self.console, `${id ? "[" + id + "] " : ""}[${type}] >`) : noop;
|
|
|
-}
|
|
|
-function getLoggerFn(key, debugConfig, id) {
|
|
|
- return debugConfig[key] ? debugConfig[key].bind(debugConfig) : consolePrintFn(key, id);
|
|
|
-}
|
|
|
-var exportedLogger = createLogger();
|
|
|
-function enableLogs(debugConfig, context, id) {
|
|
|
- const newLogger = createLogger();
|
|
|
- if (typeof console === "object" && debugConfig === true || typeof debugConfig === "object") {
|
|
|
- const keys = [
|
|
|
- // Remove out from list here to hard-disable a log-level
|
|
|
- // 'trace',
|
|
|
- "debug",
|
|
|
- "log",
|
|
|
- "info",
|
|
|
- "warn",
|
|
|
- "error"
|
|
|
- ];
|
|
|
- keys.forEach((key) => {
|
|
|
- newLogger[key] = getLoggerFn(key, debugConfig, id);
|
|
|
- });
|
|
|
- try {
|
|
|
- newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.13"}`);
|
|
|
- } catch (e) {
|
|
|
- return createLogger();
|
|
|
- }
|
|
|
- keys.forEach((key) => {
|
|
|
- exportedLogger[key] = getLoggerFn(key, debugConfig);
|
|
|
- });
|
|
|
- } else {
|
|
|
- _extends(exportedLogger, newLogger);
|
|
|
- }
|
|
|
- return newLogger;
|
|
|
-}
|
|
|
-var logger = exportedLogger;
|
|
|
-function getMediaSource(preferManagedMediaSource = true) {
|
|
|
- if (typeof self === "undefined")
|
|
|
- return void 0;
|
|
|
- const mms = (preferManagedMediaSource || !self.MediaSource) && self.ManagedMediaSource;
|
|
|
- return mms || self.MediaSource || self.WebKitMediaSource;
|
|
|
-}
|
|
|
-function isManagedMediaSource(source) {
|
|
|
- return typeof self !== "undefined" && source === self.ManagedMediaSource;
|
|
|
-}
|
|
|
-function isCompatibleTrackChange(currentTracks, requiredTracks) {
|
|
|
- const trackNames = Object.keys(currentTracks);
|
|
|
- const requiredTrackNames = Object.keys(requiredTracks);
|
|
|
- const trackCount = trackNames.length;
|
|
|
- const requiredTrackCount = requiredTrackNames.length;
|
|
|
- return !trackCount || !requiredTrackCount || trackCount === requiredTrackCount && !trackNames.some((name) => requiredTrackNames.indexOf(name) === -1);
|
|
|
-}
|
|
|
-function utf8ArrayToStr(array, exitOnNull = false) {
|
|
|
- if (typeof TextDecoder !== "undefined") {
|
|
|
- const decoder = new TextDecoder("utf-8");
|
|
|
- const decoded = decoder.decode(array);
|
|
|
- if (exitOnNull) {
|
|
|
- const idx = decoded.indexOf("\0");
|
|
|
- return idx !== -1 ? decoded.substring(0, idx) : decoded;
|
|
|
- }
|
|
|
- return decoded.replace(/\0/g, "");
|
|
|
- }
|
|
|
- const len = array.length;
|
|
|
- let c;
|
|
|
- let char2;
|
|
|
- let char3;
|
|
|
- let out = "";
|
|
|
- let i = 0;
|
|
|
- while (i < len) {
|
|
|
- c = array[i++];
|
|
|
- if (c === 0 && exitOnNull) {
|
|
|
- return out;
|
|
|
- } else if (c === 0 || c === 3) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- switch (c >> 4) {
|
|
|
- case 0:
|
|
|
- case 1:
|
|
|
- case 2:
|
|
|
- case 3:
|
|
|
- case 4:
|
|
|
- case 5:
|
|
|
- case 6:
|
|
|
- case 7:
|
|
|
- out += String.fromCharCode(c);
|
|
|
- break;
|
|
|
- case 12:
|
|
|
- case 13:
|
|
|
- char2 = array[i++];
|
|
|
- out += String.fromCharCode((c & 31) << 6 | char2 & 63);
|
|
|
- break;
|
|
|
- case 14:
|
|
|
- char2 = array[i++];
|
|
|
- char3 = array[i++];
|
|
|
- out += String.fromCharCode((c & 15) << 12 | (char2 & 63) << 6 | (char3 & 63) << 0);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return out;
|
|
|
-}
|
|
|
-function arrayToHex(array) {
|
|
|
- let str = "";
|
|
|
- for (let i = 0; i < array.length; i++) {
|
|
|
- let h = array[i].toString(16);
|
|
|
- if (h.length < 2) {
|
|
|
- h = "0" + h;
|
|
|
- }
|
|
|
- str += h;
|
|
|
- }
|
|
|
- return str;
|
|
|
-}
|
|
|
-function hexToArrayBuffer(str) {
|
|
|
- return Uint8Array.from(str.replace(/^0x/, "").replace(/([\da-fA-F]{2}) ?/g, "0x$1 ").replace(/ +$/, "").split(" ")).buffer;
|
|
|
-}
|
|
|
-function getDefaultExportFromCjs(x) {
|
|
|
- return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
|
|
|
-}
|
|
|
-var urlToolkit = { exports: {} };
|
|
|
-var hasRequiredUrlToolkit;
|
|
|
-function requireUrlToolkit() {
|
|
|
- if (hasRequiredUrlToolkit)
|
|
|
- return urlToolkit.exports;
|
|
|
- hasRequiredUrlToolkit = 1;
|
|
|
- (function(module, exports) {
|
|
|
- (function(root) {
|
|
|
- var URL_REGEX = /^(?=((?:[a-zA-Z0-9+\-.]+:)?))\1(?=((?:\/\/[^\/?#]*)?))\2(?=((?:(?:[^?#\/]*\/)*[^;?#\/]*)?))\3((?:;[^?#]*)?)(\?[^#]*)?(#[^]*)?$/;
|
|
|
- var FIRST_SEGMENT_REGEX = /^(?=([^\/?#]*))\1([^]*)$/;
|
|
|
- var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
|
|
|
- var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/)[^\/]*(?=\/)/g;
|
|
|
- var URLToolkit = {
|
|
|
- // If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
|
|
|
- // E.g
|
|
|
- // With opts.alwaysNormalize = false (default, spec compliant)
|
|
|
- // http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
|
|
|
- // With opts.alwaysNormalize = true (not spec compliant)
|
|
|
- // http://a.com/b/cd + /e/f/../g => http://a.com/e/g
|
|
|
- buildAbsoluteURL: function(baseURL, relativeURL, opts) {
|
|
|
- opts = opts || {};
|
|
|
- baseURL = baseURL.trim();
|
|
|
- relativeURL = relativeURL.trim();
|
|
|
- if (!relativeURL) {
|
|
|
- if (!opts.alwaysNormalize) {
|
|
|
- return baseURL;
|
|
|
- }
|
|
|
- var basePartsForNormalise = URLToolkit.parseURL(baseURL);
|
|
|
- if (!basePartsForNormalise) {
|
|
|
- throw new Error("Error trying to parse base URL.");
|
|
|
- }
|
|
|
- basePartsForNormalise.path = URLToolkit.normalizePath(
|
|
|
- basePartsForNormalise.path
|
|
|
- );
|
|
|
- return URLToolkit.buildURLFromParts(basePartsForNormalise);
|
|
|
- }
|
|
|
- var relativeParts = URLToolkit.parseURL(relativeURL);
|
|
|
- if (!relativeParts) {
|
|
|
- throw new Error("Error trying to parse relative URL.");
|
|
|
- }
|
|
|
- if (relativeParts.scheme) {
|
|
|
- if (!opts.alwaysNormalize) {
|
|
|
- return relativeURL;
|
|
|
- }
|
|
|
- relativeParts.path = URLToolkit.normalizePath(relativeParts.path);
|
|
|
- return URLToolkit.buildURLFromParts(relativeParts);
|
|
|
- }
|
|
|
- var baseParts = URLToolkit.parseURL(baseURL);
|
|
|
- if (!baseParts) {
|
|
|
- throw new Error("Error trying to parse base URL.");
|
|
|
- }
|
|
|
- if (!baseParts.netLoc && baseParts.path && baseParts.path[0] !== "/") {
|
|
|
- var pathParts = FIRST_SEGMENT_REGEX.exec(baseParts.path);
|
|
|
- baseParts.netLoc = pathParts[1];
|
|
|
- baseParts.path = pathParts[2];
|
|
|
- }
|
|
|
- if (baseParts.netLoc && !baseParts.path) {
|
|
|
- baseParts.path = "/";
|
|
|
- }
|
|
|
- var builtParts = {
|
|
|
- // 2c) Otherwise, the embedded URL inherits the scheme of
|
|
|
- // the base URL.
|
|
|
- scheme: baseParts.scheme,
|
|
|
- netLoc: relativeParts.netLoc,
|
|
|
- path: null,
|
|
|
- params: relativeParts.params,
|
|
|
- query: relativeParts.query,
|
|
|
- fragment: relativeParts.fragment
|
|
|
- };
|
|
|
- if (!relativeParts.netLoc) {
|
|
|
- builtParts.netLoc = baseParts.netLoc;
|
|
|
- if (relativeParts.path[0] !== "/") {
|
|
|
- if (!relativeParts.path) {
|
|
|
- builtParts.path = baseParts.path;
|
|
|
- if (!relativeParts.params) {
|
|
|
- builtParts.params = baseParts.params;
|
|
|
- if (!relativeParts.query) {
|
|
|
- builtParts.query = baseParts.query;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- var baseURLPath = baseParts.path;
|
|
|
- var newPath = baseURLPath.substring(0, baseURLPath.lastIndexOf("/") + 1) + relativeParts.path;
|
|
|
- builtParts.path = URLToolkit.normalizePath(newPath);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (builtParts.path === null) {
|
|
|
- builtParts.path = opts.alwaysNormalize ? URLToolkit.normalizePath(relativeParts.path) : relativeParts.path;
|
|
|
- }
|
|
|
- return URLToolkit.buildURLFromParts(builtParts);
|
|
|
- },
|
|
|
- parseURL: function(url) {
|
|
|
- var parts = URL_REGEX.exec(url);
|
|
|
- if (!parts) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return {
|
|
|
- scheme: parts[1] || "",
|
|
|
- netLoc: parts[2] || "",
|
|
|
- path: parts[3] || "",
|
|
|
- params: parts[4] || "",
|
|
|
- query: parts[5] || "",
|
|
|
- fragment: parts[6] || ""
|
|
|
- };
|
|
|
- },
|
|
|
- normalizePath: function(path) {
|
|
|
- path = path.split("").reverse().join("").replace(SLASH_DOT_REGEX, "");
|
|
|
- while (path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, "")).length) {
|
|
|
- }
|
|
|
- return path.split("").reverse().join("");
|
|
|
- },
|
|
|
- buildURLFromParts: function(parts) {
|
|
|
- return parts.scheme + parts.netLoc + parts.path + parts.params + parts.query + parts.fragment;
|
|
|
- }
|
|
|
- };
|
|
|
- module.exports = URLToolkit;
|
|
|
- })();
|
|
|
- })(urlToolkit);
|
|
|
- return urlToolkit.exports;
|
|
|
-}
|
|
|
-var urlToolkitExports = requireUrlToolkit();
|
|
|
-var LoadStats = class {
|
|
|
- constructor() {
|
|
|
- this.aborted = false;
|
|
|
- this.loaded = 0;
|
|
|
- this.retry = 0;
|
|
|
- this.total = 0;
|
|
|
- this.chunkCount = 0;
|
|
|
- this.bwEstimate = 0;
|
|
|
- this.loading = {
|
|
|
- start: 0,
|
|
|
- first: 0,
|
|
|
- end: 0
|
|
|
- };
|
|
|
- this.parsing = {
|
|
|
- start: 0,
|
|
|
- end: 0
|
|
|
- };
|
|
|
- this.buffering = {
|
|
|
- start: 0,
|
|
|
- first: 0,
|
|
|
- end: 0
|
|
|
- };
|
|
|
- }
|
|
|
-};
|
|
|
-var ElementaryStreamTypes = {
|
|
|
- AUDIO: "audio",
|
|
|
- VIDEO: "video",
|
|
|
- AUDIOVIDEO: "audiovideo"
|
|
|
-};
|
|
|
-var BaseSegment = class {
|
|
|
- constructor(base) {
|
|
|
- this._byteRange = null;
|
|
|
- this._url = null;
|
|
|
- this._stats = null;
|
|
|
- this._streams = null;
|
|
|
- this.base = void 0;
|
|
|
- this.relurl = void 0;
|
|
|
- if (typeof base === "string") {
|
|
|
- base = {
|
|
|
- url: base
|
|
|
- };
|
|
|
- }
|
|
|
- this.base = base;
|
|
|
- makeEnumerable(this, "stats");
|
|
|
- }
|
|
|
- // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
|
|
|
- setByteRange(value, previous) {
|
|
|
- const params = value.split("@", 2);
|
|
|
- let start;
|
|
|
- if (params.length === 1) {
|
|
|
- start = (previous == null ? void 0 : previous.byteRangeEndOffset) || 0;
|
|
|
- } else {
|
|
|
- start = parseInt(params[1]);
|
|
|
- }
|
|
|
- this._byteRange = [start, parseInt(params[0]) + start];
|
|
|
- }
|
|
|
- get baseurl() {
|
|
|
- return this.base.url;
|
|
|
- }
|
|
|
- get byteRange() {
|
|
|
- if (this._byteRange === null) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- return this._byteRange;
|
|
|
- }
|
|
|
- get byteRangeStartOffset() {
|
|
|
- return this.byteRange[0];
|
|
|
- }
|
|
|
- get byteRangeEndOffset() {
|
|
|
- return this.byteRange[1];
|
|
|
- }
|
|
|
- get elementaryStreams() {
|
|
|
- if (this._streams === null) {
|
|
|
- this._streams = {
|
|
|
- [ElementaryStreamTypes.AUDIO]: null,
|
|
|
- [ElementaryStreamTypes.VIDEO]: null,
|
|
|
- [ElementaryStreamTypes.AUDIOVIDEO]: null
|
|
|
- };
|
|
|
- }
|
|
|
- return this._streams;
|
|
|
- }
|
|
|
- set elementaryStreams(value) {
|
|
|
- this._streams = value;
|
|
|
- }
|
|
|
- get hasStats() {
|
|
|
- return this._stats !== null;
|
|
|
- }
|
|
|
- get hasStreams() {
|
|
|
- return this._streams !== null;
|
|
|
- }
|
|
|
- get stats() {
|
|
|
- if (this._stats === null) {
|
|
|
- this._stats = new LoadStats();
|
|
|
- }
|
|
|
- return this._stats;
|
|
|
- }
|
|
|
- set stats(value) {
|
|
|
- this._stats = value;
|
|
|
- }
|
|
|
- get url() {
|
|
|
- if (!this._url && this.baseurl && this.relurl) {
|
|
|
- this._url = urlToolkitExports.buildAbsoluteURL(this.baseurl, this.relurl, {
|
|
|
- alwaysNormalize: true
|
|
|
- });
|
|
|
- }
|
|
|
- return this._url || "";
|
|
|
- }
|
|
|
- set url(value) {
|
|
|
- this._url = value;
|
|
|
- }
|
|
|
- clearElementaryStreamInfo() {
|
|
|
- const {
|
|
|
- elementaryStreams
|
|
|
- } = this;
|
|
|
- elementaryStreams[ElementaryStreamTypes.AUDIO] = null;
|
|
|
- elementaryStreams[ElementaryStreamTypes.VIDEO] = null;
|
|
|
- elementaryStreams[ElementaryStreamTypes.AUDIOVIDEO] = null;
|
|
|
- }
|
|
|
-};
|
|
|
-function isMediaFragment(frag) {
|
|
|
- return frag.sn !== "initSegment";
|
|
|
-}
|
|
|
-var Fragment = class extends BaseSegment {
|
|
|
- constructor(type, base) {
|
|
|
- super(base);
|
|
|
- this._decryptdata = null;
|
|
|
- this._programDateTime = null;
|
|
|
- this._ref = null;
|
|
|
- this._bitrate = void 0;
|
|
|
- this.rawProgramDateTime = null;
|
|
|
- this.tagList = [];
|
|
|
- this.duration = 0;
|
|
|
- this.sn = 0;
|
|
|
- this.levelkeys = void 0;
|
|
|
- this.type = void 0;
|
|
|
- this.loader = null;
|
|
|
- this.keyLoader = null;
|
|
|
- this.level = -1;
|
|
|
- this.cc = 0;
|
|
|
- this.startPTS = void 0;
|
|
|
- this.endPTS = void 0;
|
|
|
- this.startDTS = void 0;
|
|
|
- this.endDTS = void 0;
|
|
|
- this.start = 0;
|
|
|
- this.playlistOffset = 0;
|
|
|
- this.deltaPTS = void 0;
|
|
|
- this.maxStartPTS = void 0;
|
|
|
- this.minEndPTS = void 0;
|
|
|
- this.data = void 0;
|
|
|
- this.bitrateTest = false;
|
|
|
- this.title = null;
|
|
|
- this.initSegment = null;
|
|
|
- this.endList = void 0;
|
|
|
- this.gap = void 0;
|
|
|
- this.urlId = 0;
|
|
|
- this.type = type;
|
|
|
- }
|
|
|
- get byteLength() {
|
|
|
- if (this.hasStats) {
|
|
|
- const total = this.stats.total;
|
|
|
- if (total) {
|
|
|
- return total;
|
|
|
- }
|
|
|
- }
|
|
|
- if (this.byteRange.length) {
|
|
|
- const start = this.byteRange[0];
|
|
|
- const end = this.byteRange[1];
|
|
|
- if (isFiniteNumber(start) && isFiniteNumber(end)) {
|
|
|
- return end - start;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- get bitrate() {
|
|
|
- if (this.byteLength) {
|
|
|
- return this.byteLength * 8 / this.duration;
|
|
|
- }
|
|
|
- if (this._bitrate) {
|
|
|
- return this._bitrate;
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- set bitrate(value) {
|
|
|
- this._bitrate = value;
|
|
|
- }
|
|
|
- get decryptdata() {
|
|
|
- var _this$_decryptdata;
|
|
|
- const {
|
|
|
- levelkeys
|
|
|
- } = this;
|
|
|
- if (!levelkeys || levelkeys.NONE) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (levelkeys.identity) {
|
|
|
- if (!this._decryptdata) {
|
|
|
- this._decryptdata = levelkeys.identity.getDecryptData(this.sn);
|
|
|
- }
|
|
|
- } else if (!((_this$_decryptdata = this._decryptdata) != null && _this$_decryptdata.keyId)) {
|
|
|
- const keyFormats = Object.keys(levelkeys);
|
|
|
- if (keyFormats.length === 1) {
|
|
|
- const levelKey = this._decryptdata = levelkeys[keyFormats[0]] || null;
|
|
|
- if (levelKey) {
|
|
|
- this._decryptdata = levelKey.getDecryptData(this.sn, levelkeys);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return this._decryptdata;
|
|
|
- }
|
|
|
- get end() {
|
|
|
- return this.start + this.duration;
|
|
|
- }
|
|
|
- get endProgramDateTime() {
|
|
|
- if (this.programDateTime === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const duration = !isFiniteNumber(this.duration) ? 0 : this.duration;
|
|
|
- return this.programDateTime + duration * 1e3;
|
|
|
- }
|
|
|
- get encrypted() {
|
|
|
- var _this$_decryptdata2;
|
|
|
- if ((_this$_decryptdata2 = this._decryptdata) != null && _this$_decryptdata2.encrypted) {
|
|
|
- return true;
|
|
|
- } else if (this.levelkeys) {
|
|
|
- var _this$levelkeys$keyFo;
|
|
|
- const keyFormats = Object.keys(this.levelkeys);
|
|
|
- const len = keyFormats.length;
|
|
|
- if (len > 1 || len === 1 && (_this$levelkeys$keyFo = this.levelkeys[keyFormats[0]]) != null && _this$levelkeys$keyFo.encrypted) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- get programDateTime() {
|
|
|
- if (this._programDateTime === null && this.rawProgramDateTime) {
|
|
|
- this.programDateTime = Date.parse(this.rawProgramDateTime);
|
|
|
- }
|
|
|
- return this._programDateTime;
|
|
|
- }
|
|
|
- set programDateTime(value) {
|
|
|
- if (!isFiniteNumber(value)) {
|
|
|
- this._programDateTime = this.rawProgramDateTime = null;
|
|
|
- return;
|
|
|
- }
|
|
|
- this._programDateTime = value;
|
|
|
- }
|
|
|
- get ref() {
|
|
|
- if (!isMediaFragment(this)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (!this._ref) {
|
|
|
- this._ref = {
|
|
|
- base: this.base,
|
|
|
- start: this.start,
|
|
|
- duration: this.duration,
|
|
|
- sn: this.sn,
|
|
|
- programDateTime: this.programDateTime
|
|
|
- };
|
|
|
- }
|
|
|
- return this._ref;
|
|
|
- }
|
|
|
- addStart(value) {
|
|
|
- this.setStart(this.start + value);
|
|
|
- }
|
|
|
- setStart(value) {
|
|
|
- this.start = value;
|
|
|
- if (this._ref) {
|
|
|
- this._ref.start = value;
|
|
|
- }
|
|
|
- }
|
|
|
- setDuration(value) {
|
|
|
- this.duration = value;
|
|
|
- if (this._ref) {
|
|
|
- this._ref.duration = value;
|
|
|
- }
|
|
|
- }
|
|
|
- setKeyFormat(keyFormat) {
|
|
|
- const levelkeys = this.levelkeys;
|
|
|
- if (levelkeys) {
|
|
|
- var _this$_decryptdata3;
|
|
|
- const key = levelkeys[keyFormat];
|
|
|
- if (key && !((_this$_decryptdata3 = this._decryptdata) != null && _this$_decryptdata3.keyId)) {
|
|
|
- this._decryptdata = key.getDecryptData(this.sn, levelkeys);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- abortRequests() {
|
|
|
- var _this$loader, _this$keyLoader;
|
|
|
- (_this$loader = this.loader) == null || _this$loader.abort();
|
|
|
- (_this$keyLoader = this.keyLoader) == null || _this$keyLoader.abort();
|
|
|
- }
|
|
|
- setElementaryStreamInfo(type, startPTS, endPTS, startDTS, endDTS, partial = false) {
|
|
|
- const {
|
|
|
- elementaryStreams
|
|
|
- } = this;
|
|
|
- const info = elementaryStreams[type];
|
|
|
- if (!info) {
|
|
|
- elementaryStreams[type] = {
|
|
|
- startPTS,
|
|
|
- endPTS,
|
|
|
- startDTS,
|
|
|
- endDTS,
|
|
|
- partial
|
|
|
- };
|
|
|
- return;
|
|
|
- }
|
|
|
- info.startPTS = Math.min(info.startPTS, startPTS);
|
|
|
- info.endPTS = Math.max(info.endPTS, endPTS);
|
|
|
- info.startDTS = Math.min(info.startDTS, startDTS);
|
|
|
- info.endDTS = Math.max(info.endDTS, endDTS);
|
|
|
- }
|
|
|
-};
|
|
|
-var Part = class extends BaseSegment {
|
|
|
- constructor(partAttrs, frag, base, index, previous) {
|
|
|
- super(base);
|
|
|
- this.fragOffset = 0;
|
|
|
- this.duration = 0;
|
|
|
- this.gap = false;
|
|
|
- this.independent = false;
|
|
|
- this.relurl = void 0;
|
|
|
- this.fragment = void 0;
|
|
|
- this.index = void 0;
|
|
|
- this.duration = partAttrs.decimalFloatingPoint("DURATION");
|
|
|
- this.gap = partAttrs.bool("GAP");
|
|
|
- this.independent = partAttrs.bool("INDEPENDENT");
|
|
|
- this.relurl = partAttrs.enumeratedString("URI");
|
|
|
- this.fragment = frag;
|
|
|
- this.index = index;
|
|
|
- const byteRange = partAttrs.enumeratedString("BYTERANGE");
|
|
|
- if (byteRange) {
|
|
|
- this.setByteRange(byteRange, previous);
|
|
|
- }
|
|
|
- if (previous) {
|
|
|
- this.fragOffset = previous.fragOffset + previous.duration;
|
|
|
- }
|
|
|
- }
|
|
|
- get start() {
|
|
|
- return this.fragment.start + this.fragOffset;
|
|
|
- }
|
|
|
- get end() {
|
|
|
- return this.start + this.duration;
|
|
|
- }
|
|
|
- get loaded() {
|
|
|
- const {
|
|
|
- elementaryStreams
|
|
|
- } = this;
|
|
|
- return !!(elementaryStreams.audio || elementaryStreams.video || elementaryStreams.audiovideo);
|
|
|
- }
|
|
|
-};
|
|
|
-function getOwnPropertyDescriptorFromPrototypeChain(object, property) {
|
|
|
- const prototype = Object.getPrototypeOf(object);
|
|
|
- if (prototype) {
|
|
|
- const propertyDescriptor = Object.getOwnPropertyDescriptor(prototype, property);
|
|
|
- if (propertyDescriptor) {
|
|
|
- return propertyDescriptor;
|
|
|
- }
|
|
|
- return getOwnPropertyDescriptorFromPrototypeChain(prototype, property);
|
|
|
- }
|
|
|
-}
|
|
|
-function makeEnumerable(object, property) {
|
|
|
- const d = getOwnPropertyDescriptorFromPrototypeChain(object, property);
|
|
|
- if (d) {
|
|
|
- d.enumerable = true;
|
|
|
- Object.defineProperty(object, property, d);
|
|
|
- }
|
|
|
-}
|
|
|
-var UINT32_MAX$1 = Math.pow(2, 32) - 1;
|
|
|
-var push = [].push;
|
|
|
-var RemuxerTrackIdConfig = {
|
|
|
- video: 1,
|
|
|
- audio: 2,
|
|
|
- id3: 3,
|
|
|
- text: 4
|
|
|
-};
|
|
|
-function bin2str(data) {
|
|
|
- return String.fromCharCode.apply(null, data);
|
|
|
-}
|
|
|
-function readUint16(buffer, offset) {
|
|
|
- const val = buffer[offset] << 8 | buffer[offset + 1];
|
|
|
- return val < 0 ? 65536 + val : val;
|
|
|
-}
|
|
|
-function readUint32(buffer, offset) {
|
|
|
- const val = readSint32(buffer, offset);
|
|
|
- return val < 0 ? 4294967296 + val : val;
|
|
|
-}
|
|
|
-function readUint64(buffer, offset) {
|
|
|
- let result = readUint32(buffer, offset);
|
|
|
- result *= Math.pow(2, 32);
|
|
|
- result += readUint32(buffer, offset + 4);
|
|
|
- return result;
|
|
|
-}
|
|
|
-function readSint32(buffer, offset) {
|
|
|
- return buffer[offset] << 24 | buffer[offset + 1] << 16 | buffer[offset + 2] << 8 | buffer[offset + 3];
|
|
|
-}
|
|
|
-function hasMoofData(data) {
|
|
|
- const end = data.byteLength;
|
|
|
- for (let i = 0; i < end; ) {
|
|
|
- const size = readUint32(data, i);
|
|
|
- if (size > 8 && data[i + 4] === 109 && data[i + 5] === 111 && data[i + 6] === 111 && data[i + 7] === 102) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- i = size > 1 ? i + size : end;
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function findBox(data, path) {
|
|
|
- const results = [];
|
|
|
- if (!path.length) {
|
|
|
- return results;
|
|
|
- }
|
|
|
- const end = data.byteLength;
|
|
|
- for (let i = 0; i < end; ) {
|
|
|
- const size = readUint32(data, i);
|
|
|
- const type = bin2str(data.subarray(i + 4, i + 8));
|
|
|
- const endbox = size > 1 ? i + size : end;
|
|
|
- if (type === path[0]) {
|
|
|
- if (path.length === 1) {
|
|
|
- results.push(data.subarray(i + 8, endbox));
|
|
|
- } else {
|
|
|
- const subresults = findBox(data.subarray(i + 8, endbox), path.slice(1));
|
|
|
- if (subresults.length) {
|
|
|
- push.apply(results, subresults);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- i = endbox;
|
|
|
- }
|
|
|
- return results;
|
|
|
-}
|
|
|
-function parseSegmentIndex(sidx) {
|
|
|
- const references = [];
|
|
|
- const version2 = sidx[0];
|
|
|
- let index = 8;
|
|
|
- const timescale = readUint32(sidx, index);
|
|
|
- index += 4;
|
|
|
- let earliestPresentationTime = 0;
|
|
|
- let firstOffset = 0;
|
|
|
- if (version2 === 0) {
|
|
|
- earliestPresentationTime = readUint32(sidx, index);
|
|
|
- firstOffset = readUint32(sidx, index + 4);
|
|
|
- index += 8;
|
|
|
- } else {
|
|
|
- earliestPresentationTime = readUint64(sidx, index);
|
|
|
- firstOffset = readUint64(sidx, index + 8);
|
|
|
- index += 16;
|
|
|
- }
|
|
|
- index += 2;
|
|
|
- let startByte = sidx.length + firstOffset;
|
|
|
- const referencesCount = readUint16(sidx, index);
|
|
|
- index += 2;
|
|
|
- for (let i = 0; i < referencesCount; i++) {
|
|
|
- let referenceIndex = index;
|
|
|
- const referenceInfo = readUint32(sidx, referenceIndex);
|
|
|
- referenceIndex += 4;
|
|
|
- const referenceSize = referenceInfo & 2147483647;
|
|
|
- const referenceType = (referenceInfo & 2147483648) >>> 31;
|
|
|
- if (referenceType === 1) {
|
|
|
- logger.warn("SIDX has hierarchical references (not supported)");
|
|
|
- return null;
|
|
|
- }
|
|
|
- const subsegmentDuration = readUint32(sidx, referenceIndex);
|
|
|
- referenceIndex += 4;
|
|
|
- references.push({
|
|
|
- referenceSize,
|
|
|
- subsegmentDuration,
|
|
|
- // unscaled
|
|
|
- info: {
|
|
|
- duration: subsegmentDuration / timescale,
|
|
|
- start: startByte,
|
|
|
- end: startByte + referenceSize - 1
|
|
|
- }
|
|
|
- });
|
|
|
- startByte += referenceSize;
|
|
|
- referenceIndex += 4;
|
|
|
- index = referenceIndex;
|
|
|
- }
|
|
|
- return {
|
|
|
- earliestPresentationTime,
|
|
|
- timescale,
|
|
|
- version: version2,
|
|
|
- referencesCount,
|
|
|
- references
|
|
|
- };
|
|
|
-}
|
|
|
-function parseInitSegment(initSegment) {
|
|
|
- const result = [];
|
|
|
- const traks = findBox(initSegment, ["moov", "trak"]);
|
|
|
- for (let i = 0; i < traks.length; i++) {
|
|
|
- const trak = traks[i];
|
|
|
- const tkhd = findBox(trak, ["tkhd"])[0];
|
|
|
- if (tkhd) {
|
|
|
- let version2 = tkhd[0];
|
|
|
- const trackId = readUint32(tkhd, version2 === 0 ? 12 : 20);
|
|
|
- const mdhd = findBox(trak, ["mdia", "mdhd"])[0];
|
|
|
- if (mdhd) {
|
|
|
- version2 = mdhd[0];
|
|
|
- const timescale = readUint32(mdhd, version2 === 0 ? 12 : 20);
|
|
|
- const hdlr = findBox(trak, ["mdia", "hdlr"])[0];
|
|
|
- if (hdlr) {
|
|
|
- const hdlrType = bin2str(hdlr.subarray(8, 12));
|
|
|
- const type = {
|
|
|
- soun: ElementaryStreamTypes.AUDIO,
|
|
|
- vide: ElementaryStreamTypes.VIDEO
|
|
|
- }[hdlrType];
|
|
|
- const stsdBox = findBox(trak, ["mdia", "minf", "stbl", "stsd"])[0];
|
|
|
- const stsd = parseStsd(stsdBox);
|
|
|
- if (type) {
|
|
|
- result[trackId] = {
|
|
|
- timescale,
|
|
|
- type,
|
|
|
- stsd
|
|
|
- };
|
|
|
- result[type] = _objectSpread2({
|
|
|
- timescale,
|
|
|
- id: trackId
|
|
|
- }, stsd);
|
|
|
- } else {
|
|
|
- result[trackId] = {
|
|
|
- timescale,
|
|
|
- type: hdlrType,
|
|
|
- stsd
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const trex = findBox(initSegment, ["moov", "mvex", "trex"]);
|
|
|
- trex.forEach((trex2) => {
|
|
|
- const trackId = readUint32(trex2, 4);
|
|
|
- const track = result[trackId];
|
|
|
- if (track) {
|
|
|
- track.default = {
|
|
|
- duration: readUint32(trex2, 12),
|
|
|
- flags: readUint32(trex2, 20)
|
|
|
- };
|
|
|
- }
|
|
|
- });
|
|
|
- return result;
|
|
|
-}
|
|
|
-function parseStsd(stsd) {
|
|
|
- const sampleEntries = stsd.subarray(8);
|
|
|
- const sampleEntriesEnd = sampleEntries.subarray(8 + 78);
|
|
|
- const fourCC = bin2str(sampleEntries.subarray(4, 8));
|
|
|
- let codec = fourCC;
|
|
|
- let supplemental;
|
|
|
- const encrypted = fourCC === "enca" || fourCC === "encv";
|
|
|
- if (encrypted) {
|
|
|
- const encBox = findBox(sampleEntries, [fourCC])[0];
|
|
|
- const encBoxChildren = encBox.subarray(fourCC === "enca" ? 28 : 78);
|
|
|
- const sinfs = findBox(encBoxChildren, ["sinf"]);
|
|
|
- sinfs.forEach((sinf) => {
|
|
|
- const schm = findBox(sinf, ["schm"])[0];
|
|
|
- if (schm) {
|
|
|
- const scheme = bin2str(schm.subarray(4, 8));
|
|
|
- if (scheme === "cbcs" || scheme === "cenc") {
|
|
|
- const frma = findBox(sinf, ["frma"])[0];
|
|
|
- if (frma) {
|
|
|
- codec = bin2str(frma);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- const codecFourCC = codec;
|
|
|
- switch (codec) {
|
|
|
- case "avc1":
|
|
|
- case "avc2":
|
|
|
- case "avc3":
|
|
|
- case "avc4": {
|
|
|
- const avcCBox = findBox(sampleEntriesEnd, ["avcC"])[0];
|
|
|
- if (avcCBox && avcCBox.length > 3) {
|
|
|
- codec += "." + toHex(avcCBox[1]) + toHex(avcCBox[2]) + toHex(avcCBox[3]);
|
|
|
- supplemental = parseSupplementalDoViCodec(codecFourCC === "avc1" ? "dva1" : "dvav", sampleEntriesEnd);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "mp4a": {
|
|
|
- const codecBox = findBox(sampleEntries, [fourCC])[0];
|
|
|
- const esdsBox = findBox(codecBox.subarray(28), ["esds"])[0];
|
|
|
- if (esdsBox && esdsBox.length > 7) {
|
|
|
- let i = 4;
|
|
|
- if (esdsBox[i++] !== 3) {
|
|
|
- break;
|
|
|
- }
|
|
|
- i = skipBERInteger(esdsBox, i);
|
|
|
- i += 2;
|
|
|
- const flags = esdsBox[i++];
|
|
|
- if (flags & 128) {
|
|
|
- i += 2;
|
|
|
- }
|
|
|
- if (flags & 64) {
|
|
|
- i += esdsBox[i++];
|
|
|
- }
|
|
|
- if (esdsBox[i++] !== 4) {
|
|
|
- break;
|
|
|
- }
|
|
|
- i = skipBERInteger(esdsBox, i);
|
|
|
- const objectType = esdsBox[i++];
|
|
|
- if (objectType === 64) {
|
|
|
- codec += "." + toHex(objectType);
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- i += 12;
|
|
|
- if (esdsBox[i++] !== 5) {
|
|
|
- break;
|
|
|
- }
|
|
|
- i = skipBERInteger(esdsBox, i);
|
|
|
- const firstByte = esdsBox[i++];
|
|
|
- let audioObjectType = (firstByte & 248) >> 3;
|
|
|
- if (audioObjectType === 31) {
|
|
|
- audioObjectType += 1 + ((firstByte & 7) << 3) + ((esdsBox[i] & 224) >> 5);
|
|
|
- }
|
|
|
- codec += "." + audioObjectType;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "hvc1":
|
|
|
- case "hev1": {
|
|
|
- const hvcCBox = findBox(sampleEntriesEnd, ["hvcC"])[0];
|
|
|
- if (hvcCBox && hvcCBox.length > 12) {
|
|
|
- const profileByte = hvcCBox[1];
|
|
|
- const profileSpace = ["", "A", "B", "C"][profileByte >> 6];
|
|
|
- const generalProfileIdc = profileByte & 31;
|
|
|
- const profileCompat = readUint32(hvcCBox, 2);
|
|
|
- const tierFlag = (profileByte & 32) >> 5 ? "H" : "L";
|
|
|
- const levelIDC = hvcCBox[12];
|
|
|
- const constraintIndicator = hvcCBox.subarray(6, 12);
|
|
|
- codec += "." + profileSpace + generalProfileIdc;
|
|
|
- codec += "." + reverse32BitInt(profileCompat).toString(16).toUpperCase();
|
|
|
- codec += "." + tierFlag + levelIDC;
|
|
|
- let constraintString = "";
|
|
|
- for (let i = constraintIndicator.length; i--; ) {
|
|
|
- const byte = constraintIndicator[i];
|
|
|
- if (byte || constraintString) {
|
|
|
- const encodedByte = byte.toString(16).toUpperCase();
|
|
|
- constraintString = "." + encodedByte + constraintString;
|
|
|
- }
|
|
|
- }
|
|
|
- codec += constraintString;
|
|
|
- }
|
|
|
- supplemental = parseSupplementalDoViCodec(codecFourCC == "hev1" ? "dvhe" : "dvh1", sampleEntriesEnd);
|
|
|
- break;
|
|
|
- }
|
|
|
- case "dvh1":
|
|
|
- case "dvhe":
|
|
|
- case "dvav":
|
|
|
- case "dva1":
|
|
|
- case "dav1": {
|
|
|
- codec = parseSupplementalDoViCodec(codec, sampleEntriesEnd) || codec;
|
|
|
- break;
|
|
|
- }
|
|
|
- case "vp09": {
|
|
|
- const vpcCBox = findBox(sampleEntriesEnd, ["vpcC"])[0];
|
|
|
- if (vpcCBox && vpcCBox.length > 6) {
|
|
|
- const profile = vpcCBox[4];
|
|
|
- const level = vpcCBox[5];
|
|
|
- const bitDepth = vpcCBox[6] >> 4 & 15;
|
|
|
- codec += "." + addLeadingZero(profile) + "." + addLeadingZero(level) + "." + addLeadingZero(bitDepth);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "av01": {
|
|
|
- const av1CBox = findBox(sampleEntriesEnd, ["av1C"])[0];
|
|
|
- if (av1CBox && av1CBox.length > 2) {
|
|
|
- const profile = av1CBox[1] >>> 5;
|
|
|
- const level = av1CBox[1] & 31;
|
|
|
- const tierFlag = av1CBox[2] >>> 7 ? "H" : "M";
|
|
|
- const highBitDepth = (av1CBox[2] & 64) >> 6;
|
|
|
- const twelveBit = (av1CBox[2] & 32) >> 5;
|
|
|
- const bitDepth = profile === 2 && highBitDepth ? twelveBit ? 12 : 10 : highBitDepth ? 10 : 8;
|
|
|
- const monochrome = (av1CBox[2] & 16) >> 4;
|
|
|
- const chromaSubsamplingX = (av1CBox[2] & 8) >> 3;
|
|
|
- const chromaSubsamplingY = (av1CBox[2] & 4) >> 2;
|
|
|
- const chromaSamplePosition = av1CBox[2] & 3;
|
|
|
- const colorPrimaries = 1;
|
|
|
- const transferCharacteristics = 1;
|
|
|
- const matrixCoefficients = 1;
|
|
|
- const videoFullRangeFlag = 0;
|
|
|
- codec += "." + profile + "." + addLeadingZero(level) + tierFlag + "." + addLeadingZero(bitDepth) + "." + monochrome + "." + chromaSubsamplingX + chromaSubsamplingY + chromaSamplePosition + "." + addLeadingZero(colorPrimaries) + "." + addLeadingZero(transferCharacteristics) + "." + addLeadingZero(matrixCoefficients) + "." + videoFullRangeFlag;
|
|
|
- supplemental = parseSupplementalDoViCodec("dav1", sampleEntriesEnd);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- codec,
|
|
|
- encrypted,
|
|
|
- supplemental
|
|
|
- };
|
|
|
-}
|
|
|
-function parseSupplementalDoViCodec(fourCC, sampleEntriesEnd) {
|
|
|
- const dvvCResult = findBox(sampleEntriesEnd, ["dvvC"]);
|
|
|
- const dvXCBox = dvvCResult.length ? dvvCResult[0] : findBox(sampleEntriesEnd, ["dvcC"])[0];
|
|
|
- if (dvXCBox) {
|
|
|
- const doViProfile = dvXCBox[2] >> 1 & 127;
|
|
|
- const doViLevel = dvXCBox[2] << 5 & 32 | dvXCBox[3] >> 3 & 31;
|
|
|
- return fourCC + "." + addLeadingZero(doViProfile) + "." + addLeadingZero(doViLevel);
|
|
|
- }
|
|
|
-}
|
|
|
-function reverse32BitInt(val) {
|
|
|
- let result = 0;
|
|
|
- for (let i = 0; i < 32; i++) {
|
|
|
- result |= (val >> i & 1) << 32 - 1 - i;
|
|
|
- }
|
|
|
- return result >>> 0;
|
|
|
-}
|
|
|
-function skipBERInteger(bytes, i) {
|
|
|
- const limit = i + 5;
|
|
|
- while (bytes[i++] & 128 && i < limit) {
|
|
|
- }
|
|
|
- return i;
|
|
|
-}
|
|
|
-function toHex(x) {
|
|
|
- return ("0" + x.toString(16).toUpperCase()).slice(-2);
|
|
|
-}
|
|
|
-function addLeadingZero(num) {
|
|
|
- return (num < 10 ? "0" : "") + num;
|
|
|
-}
|
|
|
-function patchEncyptionData(initSegment, decryptdata) {
|
|
|
- if (!initSegment || !decryptdata) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const keyId = decryptdata.keyId;
|
|
|
- if (keyId && decryptdata.isCommonEncryption) {
|
|
|
- applyToTencBoxes(initSegment, (tenc, isAudio) => {
|
|
|
- const tencKeyId = tenc.subarray(8, 24);
|
|
|
- if (!tencKeyId.some((b) => b !== 0)) {
|
|
|
- logger.log(`[eme] Patching keyId in 'enc${isAudio ? "a" : "v"}>sinf>>tenc' box: ${arrayToHex(tencKeyId)} -> ${arrayToHex(keyId)}`);
|
|
|
- tenc.set(keyId, 8);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
-}
|
|
|
-function parseKeyIdsFromTenc(initSegment) {
|
|
|
- const keyIds = [];
|
|
|
- applyToTencBoxes(initSegment, (tenc) => keyIds.push(tenc.subarray(8, 24)));
|
|
|
- return keyIds;
|
|
|
-}
|
|
|
-function applyToTencBoxes(initSegment, predicate) {
|
|
|
- const traks = findBox(initSegment, ["moov", "trak"]);
|
|
|
- traks.forEach((trak) => {
|
|
|
- const stsd = findBox(trak, ["mdia", "minf", "stbl", "stsd"])[0];
|
|
|
- if (!stsd)
|
|
|
- return;
|
|
|
- const sampleEntries = stsd.subarray(8);
|
|
|
- let encBoxes = findBox(sampleEntries, ["enca"]);
|
|
|
- const isAudio = encBoxes.length > 0;
|
|
|
- if (!isAudio) {
|
|
|
- encBoxes = findBox(sampleEntries, ["encv"]);
|
|
|
- }
|
|
|
- encBoxes.forEach((enc) => {
|
|
|
- const encBoxChildren = isAudio ? enc.subarray(28) : enc.subarray(78);
|
|
|
- const sinfBoxes = findBox(encBoxChildren, ["sinf"]);
|
|
|
- sinfBoxes.forEach((sinf) => {
|
|
|
- const tenc = parseSinf(sinf);
|
|
|
- if (tenc) {
|
|
|
- predicate(tenc, isAudio);
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-}
|
|
|
-function parseSinf(sinf) {
|
|
|
- const schm = findBox(sinf, ["schm"])[0];
|
|
|
- if (schm) {
|
|
|
- const scheme = bin2str(schm.subarray(4, 8));
|
|
|
- if (scheme === "cbcs" || scheme === "cenc") {
|
|
|
- const tenc = findBox(sinf, ["schi", "tenc"])[0];
|
|
|
- if (tenc) {
|
|
|
- return tenc;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function getSampleData(data, initData, logger2) {
|
|
|
- const tracks = {};
|
|
|
- const trafs = findBox(data, ["moof", "traf"]);
|
|
|
- for (let i = 0; i < trafs.length; i++) {
|
|
|
- const traf = trafs[i];
|
|
|
- const tfhd = findBox(traf, ["tfhd"])[0];
|
|
|
- const id = readUint32(tfhd, 4);
|
|
|
- const track = initData[id];
|
|
|
- if (!track) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- tracks[id] || (tracks[id] = {
|
|
|
- start: NaN,
|
|
|
- duration: 0,
|
|
|
- sampleCount: 0,
|
|
|
- timescale: track.timescale,
|
|
|
- type: track.type
|
|
|
- });
|
|
|
- const trackTimes = tracks[id];
|
|
|
- const tfdt = findBox(traf, ["tfdt"])[0];
|
|
|
- if (tfdt) {
|
|
|
- const version2 = tfdt[0];
|
|
|
- let baseTime = readUint32(tfdt, 4);
|
|
|
- if (version2 === 1) {
|
|
|
- if (baseTime === UINT32_MAX$1) {
|
|
|
- logger2.warn(`[mp4-demuxer]: Ignoring assumed invalid signed 64-bit track fragment decode time`);
|
|
|
- } else {
|
|
|
- baseTime *= UINT32_MAX$1 + 1;
|
|
|
- baseTime += readUint32(tfdt, 8);
|
|
|
- }
|
|
|
- }
|
|
|
- if (isFiniteNumber(baseTime) && (!isFiniteNumber(trackTimes.start) || baseTime < trackTimes.start)) {
|
|
|
- trackTimes.start = baseTime;
|
|
|
- }
|
|
|
- }
|
|
|
- const trackDefault = track.default;
|
|
|
- const tfhdFlags = readUint32(tfhd, 0) | (trackDefault == null ? void 0 : trackDefault.flags);
|
|
|
- let defaultSampleDuration = (trackDefault == null ? void 0 : trackDefault.duration) || 0;
|
|
|
- if (tfhdFlags & 8) {
|
|
|
- if (tfhdFlags & 2) {
|
|
|
- defaultSampleDuration = readUint32(tfhd, 12);
|
|
|
- } else {
|
|
|
- defaultSampleDuration = readUint32(tfhd, 8);
|
|
|
- }
|
|
|
- }
|
|
|
- const truns = findBox(traf, ["trun"]);
|
|
|
- let sampleDTS = trackTimes.start || 0;
|
|
|
- let rawDuration = 0;
|
|
|
- let sampleDuration = defaultSampleDuration;
|
|
|
- for (let j = 0; j < truns.length; j++) {
|
|
|
- const trun = truns[j];
|
|
|
- const sampleCount = readUint32(trun, 4);
|
|
|
- const sampleIndex = trackTimes.sampleCount;
|
|
|
- trackTimes.sampleCount += sampleCount;
|
|
|
- const dataOffsetPresent = trun[3] & 1;
|
|
|
- const firstSampleFlagsPresent = trun[3] & 4;
|
|
|
- const sampleDurationPresent = trun[2] & 1;
|
|
|
- const sampleSizePresent = trun[2] & 2;
|
|
|
- const sampleFlagsPresent = trun[2] & 4;
|
|
|
- const sampleCompositionTimeOffsetPresent = trun[2] & 8;
|
|
|
- let offset = 8;
|
|
|
- let remaining = sampleCount;
|
|
|
- if (dataOffsetPresent) {
|
|
|
- offset += 4;
|
|
|
- }
|
|
|
- if (firstSampleFlagsPresent && sampleCount) {
|
|
|
- const isNonSyncSample = trun[offset + 1] & 1;
|
|
|
- if (!isNonSyncSample && trackTimes.keyFrameIndex === void 0) {
|
|
|
- trackTimes.keyFrameIndex = sampleIndex;
|
|
|
- }
|
|
|
- offset += 4;
|
|
|
- if (sampleDurationPresent) {
|
|
|
- sampleDuration = readUint32(trun, offset);
|
|
|
- offset += 4;
|
|
|
- } else {
|
|
|
- sampleDuration = defaultSampleDuration;
|
|
|
- }
|
|
|
- if (sampleSizePresent) {
|
|
|
- offset += 4;
|
|
|
- }
|
|
|
- if (sampleCompositionTimeOffsetPresent) {
|
|
|
- offset += 4;
|
|
|
- }
|
|
|
- sampleDTS += sampleDuration;
|
|
|
- rawDuration += sampleDuration;
|
|
|
- remaining--;
|
|
|
- }
|
|
|
- while (remaining--) {
|
|
|
- if (sampleDurationPresent) {
|
|
|
- sampleDuration = readUint32(trun, offset);
|
|
|
- offset += 4;
|
|
|
- } else {
|
|
|
- sampleDuration = defaultSampleDuration;
|
|
|
- }
|
|
|
- if (sampleSizePresent) {
|
|
|
- offset += 4;
|
|
|
- }
|
|
|
- if (sampleFlagsPresent) {
|
|
|
- const isNonSyncSample = trun[offset + 1] & 1;
|
|
|
- if (!isNonSyncSample) {
|
|
|
- if (trackTimes.keyFrameIndex === void 0) {
|
|
|
- trackTimes.keyFrameIndex = trackTimes.sampleCount - (remaining + 1);
|
|
|
- trackTimes.keyFrameStart = sampleDTS;
|
|
|
- }
|
|
|
- }
|
|
|
- offset += 4;
|
|
|
- }
|
|
|
- if (sampleCompositionTimeOffsetPresent) {
|
|
|
- offset += 4;
|
|
|
- }
|
|
|
- sampleDTS += sampleDuration;
|
|
|
- rawDuration += sampleDuration;
|
|
|
- }
|
|
|
- if (!rawDuration && defaultSampleDuration) {
|
|
|
- rawDuration += defaultSampleDuration * sampleCount;
|
|
|
- }
|
|
|
- }
|
|
|
- trackTimes.duration += rawDuration;
|
|
|
- }
|
|
|
- if (!Object.keys(tracks).some((trackId) => tracks[trackId].duration)) {
|
|
|
- let sidxMinStart = Infinity;
|
|
|
- let sidxMaxEnd = 0;
|
|
|
- const sidxs = findBox(data, ["sidx"]);
|
|
|
- for (let i = 0; i < sidxs.length; i++) {
|
|
|
- const sidx = parseSegmentIndex(sidxs[i]);
|
|
|
- if (sidx != null && sidx.references) {
|
|
|
- sidxMinStart = Math.min(sidxMinStart, sidx.earliestPresentationTime / sidx.timescale);
|
|
|
- const subSegmentDuration = sidx.references.reduce((dur, ref) => dur + ref.info.duration || 0, 0);
|
|
|
- sidxMaxEnd = Math.max(sidxMaxEnd, subSegmentDuration + sidx.earliestPresentationTime / sidx.timescale);
|
|
|
- }
|
|
|
- }
|
|
|
- if (sidxMaxEnd && isFiniteNumber(sidxMaxEnd)) {
|
|
|
- Object.keys(tracks).forEach((trackId) => {
|
|
|
- if (!tracks[trackId].duration) {
|
|
|
- tracks[trackId].duration = sidxMaxEnd * tracks[trackId].timescale - tracks[trackId].start;
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- return tracks;
|
|
|
-}
|
|
|
-function segmentValidRange(data) {
|
|
|
- const segmentedRange = {
|
|
|
- valid: null,
|
|
|
- remainder: null
|
|
|
- };
|
|
|
- const moofs = findBox(data, ["moof"]);
|
|
|
- if (moofs.length < 2) {
|
|
|
- segmentedRange.remainder = data;
|
|
|
- return segmentedRange;
|
|
|
- }
|
|
|
- const last = moofs[moofs.length - 1];
|
|
|
- segmentedRange.valid = data.slice(0, last.byteOffset - 8);
|
|
|
- segmentedRange.remainder = data.slice(last.byteOffset - 8);
|
|
|
- return segmentedRange;
|
|
|
-}
|
|
|
-function appendUint8Array(data1, data2) {
|
|
|
- const temp = new Uint8Array(data1.length + data2.length);
|
|
|
- temp.set(data1);
|
|
|
- temp.set(data2, data1.length);
|
|
|
- return temp;
|
|
|
-}
|
|
|
-function parseSamples(timeOffset, track) {
|
|
|
- const seiSamples = [];
|
|
|
- const videoData = track.samples;
|
|
|
- const timescale = track.timescale;
|
|
|
- const trackId = track.id;
|
|
|
- let isHEVCFlavor = false;
|
|
|
- const moofs = findBox(videoData, ["moof"]);
|
|
|
- moofs.map((moof) => {
|
|
|
- const moofOffset = moof.byteOffset - 8;
|
|
|
- const trafs = findBox(moof, ["traf"]);
|
|
|
- trafs.map((traf) => {
|
|
|
- const baseTime = findBox(traf, ["tfdt"]).map((tfdt) => {
|
|
|
- const version2 = tfdt[0];
|
|
|
- let result = readUint32(tfdt, 4);
|
|
|
- if (version2 === 1) {
|
|
|
- result *= Math.pow(2, 32);
|
|
|
- result += readUint32(tfdt, 8);
|
|
|
- }
|
|
|
- return result / timescale;
|
|
|
- })[0];
|
|
|
- if (baseTime !== void 0) {
|
|
|
- timeOffset = baseTime;
|
|
|
- }
|
|
|
- return findBox(traf, ["tfhd"]).map((tfhd) => {
|
|
|
- const id = readUint32(tfhd, 4);
|
|
|
- const tfhdFlags = readUint32(tfhd, 0) & 16777215;
|
|
|
- const baseDataOffsetPresent = (tfhdFlags & 1) !== 0;
|
|
|
- const sampleDescriptionIndexPresent = (tfhdFlags & 2) !== 0;
|
|
|
- const defaultSampleDurationPresent = (tfhdFlags & 8) !== 0;
|
|
|
- let defaultSampleDuration = 0;
|
|
|
- const defaultSampleSizePresent = (tfhdFlags & 16) !== 0;
|
|
|
- let defaultSampleSize = 0;
|
|
|
- const defaultSampleFlagsPresent = (tfhdFlags & 32) !== 0;
|
|
|
- let tfhdOffset = 8;
|
|
|
- if (id === trackId) {
|
|
|
- if (baseDataOffsetPresent) {
|
|
|
- tfhdOffset += 8;
|
|
|
- }
|
|
|
- if (sampleDescriptionIndexPresent) {
|
|
|
- tfhdOffset += 4;
|
|
|
- }
|
|
|
- if (defaultSampleDurationPresent) {
|
|
|
- defaultSampleDuration = readUint32(tfhd, tfhdOffset);
|
|
|
- tfhdOffset += 4;
|
|
|
- }
|
|
|
- if (defaultSampleSizePresent) {
|
|
|
- defaultSampleSize = readUint32(tfhd, tfhdOffset);
|
|
|
- tfhdOffset += 4;
|
|
|
- }
|
|
|
- if (defaultSampleFlagsPresent) {
|
|
|
- tfhdOffset += 4;
|
|
|
- }
|
|
|
- if (track.type === "video") {
|
|
|
- isHEVCFlavor = isHEVC(track.codec);
|
|
|
- }
|
|
|
- findBox(traf, ["trun"]).map((trun) => {
|
|
|
- const version2 = trun[0];
|
|
|
- const flags = readUint32(trun, 0) & 16777215;
|
|
|
- const dataOffsetPresent = (flags & 1) !== 0;
|
|
|
- let dataOffset = 0;
|
|
|
- const firstSampleFlagsPresent = (flags & 4) !== 0;
|
|
|
- const sampleDurationPresent = (flags & 256) !== 0;
|
|
|
- let sampleDuration = 0;
|
|
|
- const sampleSizePresent = (flags & 512) !== 0;
|
|
|
- let sampleSize = 0;
|
|
|
- const sampleFlagsPresent = (flags & 1024) !== 0;
|
|
|
- const sampleCompositionOffsetsPresent = (flags & 2048) !== 0;
|
|
|
- let compositionOffset = 0;
|
|
|
- const sampleCount = readUint32(trun, 4);
|
|
|
- let trunOffset = 8;
|
|
|
- if (dataOffsetPresent) {
|
|
|
- dataOffset = readUint32(trun, trunOffset);
|
|
|
- trunOffset += 4;
|
|
|
- }
|
|
|
- if (firstSampleFlagsPresent) {
|
|
|
- trunOffset += 4;
|
|
|
- }
|
|
|
- let sampleOffset = dataOffset + moofOffset;
|
|
|
- for (let ix = 0; ix < sampleCount; ix++) {
|
|
|
- if (sampleDurationPresent) {
|
|
|
- sampleDuration = readUint32(trun, trunOffset);
|
|
|
- trunOffset += 4;
|
|
|
- } else {
|
|
|
- sampleDuration = defaultSampleDuration;
|
|
|
- }
|
|
|
- if (sampleSizePresent) {
|
|
|
- sampleSize = readUint32(trun, trunOffset);
|
|
|
- trunOffset += 4;
|
|
|
- } else {
|
|
|
- sampleSize = defaultSampleSize;
|
|
|
- }
|
|
|
- if (sampleFlagsPresent) {
|
|
|
- trunOffset += 4;
|
|
|
- }
|
|
|
- if (sampleCompositionOffsetsPresent) {
|
|
|
- if (version2 === 0) {
|
|
|
- compositionOffset = readUint32(trun, trunOffset);
|
|
|
- } else {
|
|
|
- compositionOffset = readSint32(trun, trunOffset);
|
|
|
- }
|
|
|
- trunOffset += 4;
|
|
|
- }
|
|
|
- if (track.type === ElementaryStreamTypes.VIDEO) {
|
|
|
- let naluTotalSize = 0;
|
|
|
- while (naluTotalSize < sampleSize) {
|
|
|
- const naluSize = readUint32(videoData, sampleOffset);
|
|
|
- sampleOffset += 4;
|
|
|
- if (isSEIMessage(isHEVCFlavor, videoData[sampleOffset])) {
|
|
|
- const data = videoData.subarray(sampleOffset, sampleOffset + naluSize);
|
|
|
- parseSEIMessageFromNALu(data, isHEVCFlavor ? 2 : 1, timeOffset + compositionOffset / timescale, seiSamples);
|
|
|
- }
|
|
|
- sampleOffset += naluSize;
|
|
|
- naluTotalSize += naluSize + 4;
|
|
|
- }
|
|
|
- }
|
|
|
- timeOffset += sampleDuration / timescale;
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
- return seiSamples;
|
|
|
-}
|
|
|
-function isHEVC(codec) {
|
|
|
- if (!codec) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const baseCodec = codec.substring(0, 4);
|
|
|
- return baseCodec === "hvc1" || baseCodec === "hev1" || // Dolby Vision
|
|
|
- baseCodec === "dvh1" || baseCodec === "dvhe";
|
|
|
-}
|
|
|
-function isSEIMessage(isHEVCFlavor, naluHeader) {
|
|
|
- if (isHEVCFlavor) {
|
|
|
- const naluType = naluHeader >> 1 & 63;
|
|
|
- return naluType === 39 || naluType === 40;
|
|
|
- } else {
|
|
|
- const naluType = naluHeader & 31;
|
|
|
- return naluType === 6;
|
|
|
- }
|
|
|
-}
|
|
|
-function parseSEIMessageFromNALu(unescapedData, headerSize, pts, samples) {
|
|
|
- const data = discardEPB(unescapedData);
|
|
|
- let seiPtr = 0;
|
|
|
- seiPtr += headerSize;
|
|
|
- let payloadType = 0;
|
|
|
- let payloadSize = 0;
|
|
|
- let b = 0;
|
|
|
- while (seiPtr < data.length) {
|
|
|
- payloadType = 0;
|
|
|
- do {
|
|
|
- if (seiPtr >= data.length) {
|
|
|
- break;
|
|
|
- }
|
|
|
- b = data[seiPtr++];
|
|
|
- payloadType += b;
|
|
|
- } while (b === 255);
|
|
|
- payloadSize = 0;
|
|
|
- do {
|
|
|
- if (seiPtr >= data.length) {
|
|
|
- break;
|
|
|
- }
|
|
|
- b = data[seiPtr++];
|
|
|
- payloadSize += b;
|
|
|
- } while (b === 255);
|
|
|
- const leftOver = data.length - seiPtr;
|
|
|
- let payPtr = seiPtr;
|
|
|
- if (payloadSize < leftOver) {
|
|
|
- seiPtr += payloadSize;
|
|
|
- } else if (payloadSize > leftOver) {
|
|
|
- logger.error(`Malformed SEI payload. ${payloadSize} is too small, only ${leftOver} bytes left to parse.`);
|
|
|
- break;
|
|
|
- }
|
|
|
- if (payloadType === 4) {
|
|
|
- const countryCode = data[payPtr++];
|
|
|
- if (countryCode === 181) {
|
|
|
- const providerCode = readUint16(data, payPtr);
|
|
|
- payPtr += 2;
|
|
|
- if (providerCode === 49) {
|
|
|
- const userStructure = readUint32(data, payPtr);
|
|
|
- payPtr += 4;
|
|
|
- if (userStructure === 1195456820) {
|
|
|
- const userDataType = data[payPtr++];
|
|
|
- if (userDataType === 3) {
|
|
|
- const firstByte = data[payPtr++];
|
|
|
- const totalCCs = 31 & firstByte;
|
|
|
- const enabled = 64 & firstByte;
|
|
|
- const totalBytes = enabled ? 2 + totalCCs * 3 : 0;
|
|
|
- const byteArray = new Uint8Array(totalBytes);
|
|
|
- if (enabled) {
|
|
|
- byteArray[0] = firstByte;
|
|
|
- for (let i = 1; i < totalBytes; i++) {
|
|
|
- byteArray[i] = data[payPtr++];
|
|
|
- }
|
|
|
- }
|
|
|
- samples.push({
|
|
|
- type: userDataType,
|
|
|
- payloadType,
|
|
|
- pts,
|
|
|
- bytes: byteArray
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (payloadType === 5) {
|
|
|
- if (payloadSize > 16) {
|
|
|
- const uuidStrArray = [];
|
|
|
- for (let i = 0; i < 16; i++) {
|
|
|
- const _b = data[payPtr++].toString(16);
|
|
|
- uuidStrArray.push(_b.length == 1 ? "0" + _b : _b);
|
|
|
- if (i === 3 || i === 5 || i === 7 || i === 9) {
|
|
|
- uuidStrArray.push("-");
|
|
|
- }
|
|
|
- }
|
|
|
- const length = payloadSize - 16;
|
|
|
- const userDataBytes = new Uint8Array(length);
|
|
|
- for (let i = 0; i < length; i++) {
|
|
|
- userDataBytes[i] = data[payPtr++];
|
|
|
- }
|
|
|
- samples.push({
|
|
|
- payloadType,
|
|
|
- pts,
|
|
|
- uuid: uuidStrArray.join(""),
|
|
|
- userData: utf8ArrayToStr(userDataBytes),
|
|
|
- userDataBytes
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function discardEPB(data) {
|
|
|
- const length = data.byteLength;
|
|
|
- const EPBPositions = [];
|
|
|
- let i = 1;
|
|
|
- while (i < length - 2) {
|
|
|
- if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 3) {
|
|
|
- EPBPositions.push(i + 2);
|
|
|
- i += 2;
|
|
|
- } else {
|
|
|
- i++;
|
|
|
- }
|
|
|
- }
|
|
|
- if (EPBPositions.length === 0) {
|
|
|
- return data;
|
|
|
- }
|
|
|
- const newLength = length - EPBPositions.length;
|
|
|
- const newData = new Uint8Array(newLength);
|
|
|
- let sourceIndex = 0;
|
|
|
- for (i = 0; i < newLength; sourceIndex++, i++) {
|
|
|
- if (sourceIndex === EPBPositions[0]) {
|
|
|
- sourceIndex++;
|
|
|
- EPBPositions.shift();
|
|
|
- }
|
|
|
- newData[i] = data[sourceIndex];
|
|
|
- }
|
|
|
- return newData;
|
|
|
-}
|
|
|
-function parseEmsg(data) {
|
|
|
- const version2 = data[0];
|
|
|
- let schemeIdUri = "";
|
|
|
- let value = "";
|
|
|
- let timeScale = 0;
|
|
|
- let presentationTimeDelta = 0;
|
|
|
- let presentationTime = 0;
|
|
|
- let eventDuration = 0;
|
|
|
- let id = 0;
|
|
|
- let offset = 0;
|
|
|
- if (version2 === 0) {
|
|
|
- while (bin2str(data.subarray(offset, offset + 1)) !== "\0") {
|
|
|
- schemeIdUri += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- }
|
|
|
- schemeIdUri += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- while (bin2str(data.subarray(offset, offset + 1)) !== "\0") {
|
|
|
- value += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- }
|
|
|
- value += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- timeScale = readUint32(data, 12);
|
|
|
- presentationTimeDelta = readUint32(data, 16);
|
|
|
- eventDuration = readUint32(data, 20);
|
|
|
- id = readUint32(data, 24);
|
|
|
- offset = 28;
|
|
|
- } else if (version2 === 1) {
|
|
|
- offset += 4;
|
|
|
- timeScale = readUint32(data, offset);
|
|
|
- offset += 4;
|
|
|
- const leftPresentationTime = readUint32(data, offset);
|
|
|
- offset += 4;
|
|
|
- const rightPresentationTime = readUint32(data, offset);
|
|
|
- offset += 4;
|
|
|
- presentationTime = 2 ** 32 * leftPresentationTime + rightPresentationTime;
|
|
|
- if (!isSafeInteger(presentationTime)) {
|
|
|
- presentationTime = Number.MAX_SAFE_INTEGER;
|
|
|
- logger.warn("Presentation time exceeds safe integer limit and wrapped to max safe integer in parsing emsg box");
|
|
|
- }
|
|
|
- eventDuration = readUint32(data, offset);
|
|
|
- offset += 4;
|
|
|
- id = readUint32(data, offset);
|
|
|
- offset += 4;
|
|
|
- while (bin2str(data.subarray(offset, offset + 1)) !== "\0") {
|
|
|
- schemeIdUri += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- }
|
|
|
- schemeIdUri += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- while (bin2str(data.subarray(offset, offset + 1)) !== "\0") {
|
|
|
- value += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- }
|
|
|
- value += bin2str(data.subarray(offset, offset + 1));
|
|
|
- offset += 1;
|
|
|
- }
|
|
|
- const payload = data.subarray(offset, data.byteLength);
|
|
|
- return {
|
|
|
- schemeIdUri,
|
|
|
- value,
|
|
|
- timeScale,
|
|
|
- presentationTime,
|
|
|
- presentationTimeDelta,
|
|
|
- eventDuration,
|
|
|
- id,
|
|
|
- payload
|
|
|
- };
|
|
|
-}
|
|
|
-function mp4Box(type, ...payload) {
|
|
|
- const len = payload.length;
|
|
|
- let size = 8;
|
|
|
- let i = len;
|
|
|
- while (i--) {
|
|
|
- size += payload[i].byteLength;
|
|
|
- }
|
|
|
- const result = new Uint8Array(size);
|
|
|
- result[0] = size >> 24 & 255;
|
|
|
- result[1] = size >> 16 & 255;
|
|
|
- result[2] = size >> 8 & 255;
|
|
|
- result[3] = size & 255;
|
|
|
- result.set(type, 4);
|
|
|
- for (i = 0, size = 8; i < len; i++) {
|
|
|
- result.set(payload[i], size);
|
|
|
- size += payload[i].byteLength;
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-function mp4pssh(systemId, keyids, data) {
|
|
|
- if (systemId.byteLength !== 16) {
|
|
|
- throw new RangeError("Invalid system id");
|
|
|
- }
|
|
|
- let version2;
|
|
|
- let kids;
|
|
|
- {
|
|
|
- version2 = 0;
|
|
|
- kids = new Uint8Array();
|
|
|
- }
|
|
|
- let kidCount;
|
|
|
- if (version2 > 0) {
|
|
|
- kidCount = new Uint8Array(4);
|
|
|
- if (keyids.length > 0) {
|
|
|
- new DataView(kidCount.buffer).setUint32(0, keyids.length, false);
|
|
|
- }
|
|
|
- } else {
|
|
|
- kidCount = new Uint8Array();
|
|
|
- }
|
|
|
- const dataSize = new Uint8Array(4);
|
|
|
- if (data.byteLength > 0) {
|
|
|
- new DataView(dataSize.buffer).setUint32(0, data.byteLength, false);
|
|
|
- }
|
|
|
- return mp4Box(
|
|
|
- [112, 115, 115, 104],
|
|
|
- new Uint8Array([
|
|
|
- version2,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0
|
|
|
- // Flags
|
|
|
- ]),
|
|
|
- systemId,
|
|
|
- // 16 bytes
|
|
|
- kidCount,
|
|
|
- kids,
|
|
|
- dataSize,
|
|
|
- data
|
|
|
- );
|
|
|
-}
|
|
|
-function parseMultiPssh(initData) {
|
|
|
- const results = [];
|
|
|
- if (initData instanceof ArrayBuffer) {
|
|
|
- const length = initData.byteLength;
|
|
|
- let offset = 0;
|
|
|
- while (offset + 32 < length) {
|
|
|
- const view2 = new DataView(initData, offset);
|
|
|
- const pssh = parsePssh(view2);
|
|
|
- results.push(pssh);
|
|
|
- offset += pssh.size;
|
|
|
- }
|
|
|
- }
|
|
|
- return results;
|
|
|
-}
|
|
|
-function parsePssh(view2) {
|
|
|
- const size = view2.getUint32(0);
|
|
|
- const offset = view2.byteOffset;
|
|
|
- const length = view2.byteLength;
|
|
|
- if (length < size) {
|
|
|
- return {
|
|
|
- offset,
|
|
|
- size: length
|
|
|
- };
|
|
|
- }
|
|
|
- const type = view2.getUint32(4);
|
|
|
- if (type !== 1886614376) {
|
|
|
- return {
|
|
|
- offset,
|
|
|
- size
|
|
|
- };
|
|
|
- }
|
|
|
- const version2 = view2.getUint32(8) >>> 24;
|
|
|
- if (version2 !== 0 && version2 !== 1) {
|
|
|
- return {
|
|
|
- offset,
|
|
|
- size
|
|
|
- };
|
|
|
- }
|
|
|
- const buffer = view2.buffer;
|
|
|
- const systemId = arrayToHex(new Uint8Array(buffer, offset + 12, 16));
|
|
|
- let kids = null;
|
|
|
- let data = null;
|
|
|
- let dataSizeOffset = 0;
|
|
|
- if (version2 === 0) {
|
|
|
- dataSizeOffset = 28;
|
|
|
- } else {
|
|
|
- const kidCounts = view2.getUint32(28);
|
|
|
- if (!kidCounts || length < 32 + kidCounts * 16) {
|
|
|
- return {
|
|
|
- offset,
|
|
|
- size
|
|
|
- };
|
|
|
- }
|
|
|
- kids = [];
|
|
|
- for (let i = 0; i < kidCounts; i++) {
|
|
|
- kids.push(new Uint8Array(buffer, offset + 32 + i * 16, 16));
|
|
|
- }
|
|
|
- dataSizeOffset = 32 + kidCounts * 16;
|
|
|
- }
|
|
|
- if (!dataSizeOffset) {
|
|
|
- return {
|
|
|
- offset,
|
|
|
- size
|
|
|
- };
|
|
|
- }
|
|
|
- const dataSizeOrKidCount = view2.getUint32(dataSizeOffset);
|
|
|
- if (size - 32 < dataSizeOrKidCount) {
|
|
|
- return {
|
|
|
- offset,
|
|
|
- size
|
|
|
- };
|
|
|
- }
|
|
|
- data = new Uint8Array(buffer, offset + dataSizeOffset + 4, dataSizeOrKidCount);
|
|
|
- return {
|
|
|
- version: version2,
|
|
|
- systemId,
|
|
|
- kids,
|
|
|
- data,
|
|
|
- offset,
|
|
|
- size
|
|
|
- };
|
|
|
-}
|
|
|
-var userAgentHevcSupportIsInaccurate = () => {
|
|
|
- return /\(Windows.+Firefox\//i.test(navigator.userAgent);
|
|
|
-};
|
|
|
-var sampleEntryCodesISO = {
|
|
|
- audio: {
|
|
|
- a3ds: 1,
|
|
|
- "ac-3": 0.95,
|
|
|
- "ac-4": 1,
|
|
|
- alac: 0.9,
|
|
|
- alaw: 1,
|
|
|
- dra1: 1,
|
|
|
- "dts+": 1,
|
|
|
- "dts-": 1,
|
|
|
- dtsc: 1,
|
|
|
- dtse: 1,
|
|
|
- dtsh: 1,
|
|
|
- "ec-3": 0.9,
|
|
|
- enca: 1,
|
|
|
- fLaC: 0.9,
|
|
|
- // MP4-RA listed codec entry for FLAC
|
|
|
- flac: 0.9,
|
|
|
- // legacy browser codec name for FLAC
|
|
|
- FLAC: 0.9,
|
|
|
- // some manifests may list "FLAC" with Apple's tools
|
|
|
- g719: 1,
|
|
|
- g726: 1,
|
|
|
- m4ae: 1,
|
|
|
- mha1: 1,
|
|
|
- mha2: 1,
|
|
|
- mhm1: 1,
|
|
|
- mhm2: 1,
|
|
|
- mlpa: 1,
|
|
|
- mp4a: 1,
|
|
|
- "raw ": 1,
|
|
|
- Opus: 1,
|
|
|
- opus: 1,
|
|
|
- // browsers expect this to be lowercase despite MP4RA says 'Opus'
|
|
|
- samr: 1,
|
|
|
- sawb: 1,
|
|
|
- sawp: 1,
|
|
|
- sevc: 1,
|
|
|
- sqcp: 1,
|
|
|
- ssmv: 1,
|
|
|
- twos: 1,
|
|
|
- ulaw: 1
|
|
|
- },
|
|
|
- video: {
|
|
|
- avc1: 1,
|
|
|
- avc2: 1,
|
|
|
- avc3: 1,
|
|
|
- avc4: 1,
|
|
|
- avcp: 1,
|
|
|
- av01: 0.8,
|
|
|
- dav1: 0.8,
|
|
|
- drac: 1,
|
|
|
- dva1: 1,
|
|
|
- dvav: 1,
|
|
|
- dvh1: 0.7,
|
|
|
- dvhe: 0.7,
|
|
|
- encv: 1,
|
|
|
- hev1: 0.75,
|
|
|
- hvc1: 0.75,
|
|
|
- mjp2: 1,
|
|
|
- mp4v: 1,
|
|
|
- mvc1: 1,
|
|
|
- mvc2: 1,
|
|
|
- mvc3: 1,
|
|
|
- mvc4: 1,
|
|
|
- resv: 1,
|
|
|
- rv60: 1,
|
|
|
- s263: 1,
|
|
|
- svc1: 1,
|
|
|
- svc2: 1,
|
|
|
- "vc-1": 1,
|
|
|
- vp08: 1,
|
|
|
- vp09: 0.9
|
|
|
- },
|
|
|
- text: {
|
|
|
- stpp: 1,
|
|
|
- wvtt: 1
|
|
|
- }
|
|
|
-};
|
|
|
-function isCodecType(codec, type) {
|
|
|
- const typeCodes = sampleEntryCodesISO[type];
|
|
|
- return !!typeCodes && !!typeCodes[codec.slice(0, 4)];
|
|
|
-}
|
|
|
-function areCodecsMediaSourceSupported(codecs, type, preferManagedMediaSource = true) {
|
|
|
- return !codecs.split(",").some((codec) => !isCodecMediaSourceSupported(codec, type, preferManagedMediaSource));
|
|
|
-}
|
|
|
-function isCodecMediaSourceSupported(codec, type, preferManagedMediaSource = true) {
|
|
|
- var _MediaSource$isTypeSu;
|
|
|
- const MediaSource = getMediaSource(preferManagedMediaSource);
|
|
|
- return (_MediaSource$isTypeSu = MediaSource == null ? void 0 : MediaSource.isTypeSupported(mimeTypeForCodec(codec, type))) != null ? _MediaSource$isTypeSu : false;
|
|
|
-}
|
|
|
-function mimeTypeForCodec(codec, type) {
|
|
|
- return `${type}/mp4;codecs=${codec}`;
|
|
|
-}
|
|
|
-function videoCodecPreferenceValue(videoCodec) {
|
|
|
- if (videoCodec) {
|
|
|
- const fourCC = videoCodec.substring(0, 4);
|
|
|
- return sampleEntryCodesISO.video[fourCC];
|
|
|
- }
|
|
|
- return 2;
|
|
|
-}
|
|
|
-function codecsSetSelectionPreferenceValue(codecSet) {
|
|
|
- const limitedHevcSupport = userAgentHevcSupportIsInaccurate();
|
|
|
- return codecSet.split(",").reduce((num, fourCC) => {
|
|
|
- const lowerPriority = limitedHevcSupport && isHEVC(fourCC);
|
|
|
- const preferenceValue = lowerPriority ? 9 : sampleEntryCodesISO.video[fourCC];
|
|
|
- if (preferenceValue) {
|
|
|
- return (preferenceValue * 2 + num) / (num ? 3 : 2);
|
|
|
- }
|
|
|
- return (sampleEntryCodesISO.audio[fourCC] + num) / (num ? 2 : 1);
|
|
|
- }, 0);
|
|
|
-}
|
|
|
-var CODEC_COMPATIBLE_NAMES = {};
|
|
|
-function getCodecCompatibleNameLower(lowerCaseCodec, preferManagedMediaSource = true) {
|
|
|
- if (CODEC_COMPATIBLE_NAMES[lowerCaseCodec]) {
|
|
|
- return CODEC_COMPATIBLE_NAMES[lowerCaseCodec];
|
|
|
- }
|
|
|
- const codecsToCheck = {
|
|
|
- // Idealy fLaC and Opus would be first (spec-compliant) but
|
|
|
- // some browsers will report that fLaC is supported then fail.
|
|
|
- // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
|
|
|
- flac: ["flac", "fLaC", "FLAC"],
|
|
|
- opus: ["opus", "Opus"],
|
|
|
- // Replace audio codec info if browser does not support mp4a.40.34,
|
|
|
- // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
|
|
|
- "mp4a.40.34": ["mp3"]
|
|
|
- }[lowerCaseCodec];
|
|
|
- for (let i = 0; i < codecsToCheck.length; i++) {
|
|
|
- var _getMediaSource;
|
|
|
- if (isCodecMediaSourceSupported(codecsToCheck[i], "audio", preferManagedMediaSource)) {
|
|
|
- CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
|
|
|
- return codecsToCheck[i];
|
|
|
- } else if (codecsToCheck[i] === "mp3" && (_getMediaSource = getMediaSource(preferManagedMediaSource)) != null && _getMediaSource.isTypeSupported("audio/mpeg")) {
|
|
|
- return "";
|
|
|
- }
|
|
|
- }
|
|
|
- return lowerCaseCodec;
|
|
|
-}
|
|
|
-var AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
|
|
|
-function getCodecCompatibleName(codec, preferManagedMediaSource = true) {
|
|
|
- return codec.replace(AUDIO_CODEC_REGEXP, (m) => getCodecCompatibleNameLower(m.toLowerCase(), preferManagedMediaSource));
|
|
|
-}
|
|
|
-function replaceVideoCodec(originalCodecs, newVideoCodec) {
|
|
|
- const codecs = [];
|
|
|
- if (originalCodecs) {
|
|
|
- const allCodecs = originalCodecs.split(",");
|
|
|
- for (let i = 0; i < allCodecs.length; i++) {
|
|
|
- if (!isCodecType(allCodecs[i], "video")) {
|
|
|
- codecs.push(allCodecs[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (newVideoCodec) {
|
|
|
- codecs.push(newVideoCodec);
|
|
|
- }
|
|
|
- return codecs.join(",");
|
|
|
-}
|
|
|
-function pickMostCompleteCodecName(parsedCodec, levelCodec) {
|
|
|
- if (parsedCodec && (parsedCodec.length > 4 || ["ac-3", "ec-3", "alac", "fLaC", "Opus"].indexOf(parsedCodec) !== -1)) {
|
|
|
- if (isCodecSupportedAsType(parsedCodec, "audio") || isCodecSupportedAsType(parsedCodec, "video")) {
|
|
|
- return parsedCodec;
|
|
|
- }
|
|
|
- }
|
|
|
- if (levelCodec) {
|
|
|
- const levelCodecs = levelCodec.split(",");
|
|
|
- if (levelCodecs.length > 1) {
|
|
|
- if (parsedCodec) {
|
|
|
- for (let i = levelCodecs.length; i--; ) {
|
|
|
- if (levelCodecs[i].substring(0, 4) === parsedCodec.substring(0, 4)) {
|
|
|
- return levelCodecs[i];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return levelCodecs[0];
|
|
|
- }
|
|
|
- }
|
|
|
- return levelCodec || parsedCodec;
|
|
|
-}
|
|
|
-function isCodecSupportedAsType(codec, type) {
|
|
|
- return isCodecType(codec, type) && isCodecMediaSourceSupported(codec, type);
|
|
|
-}
|
|
|
-function convertAVC1ToAVCOTI(videoCodecs) {
|
|
|
- const codecs = videoCodecs.split(",");
|
|
|
- for (let i = 0; i < codecs.length; i++) {
|
|
|
- const avcdata = codecs[i].split(".");
|
|
|
- if (avcdata.length > 2 && avcdata[0] === "avc1") {
|
|
|
- codecs[i] = `avc1.${parseInt(avcdata[1]).toString(16)}${("000" + parseInt(avcdata[2]).toString(16)).slice(-4)}`;
|
|
|
- }
|
|
|
- }
|
|
|
- return codecs.join(",");
|
|
|
-}
|
|
|
-function fillInMissingAV01Params(videoCodec) {
|
|
|
- if (videoCodec.startsWith("av01.")) {
|
|
|
- const av1params = videoCodec.split(".");
|
|
|
- const placeholders = ["0", "111", "01", "01", "01", "0"];
|
|
|
- for (let i = av1params.length; i > 4 && i < 10; i++) {
|
|
|
- av1params[i] = placeholders[i - 4];
|
|
|
- }
|
|
|
- return av1params.join(".");
|
|
|
- }
|
|
|
- return videoCodec;
|
|
|
-}
|
|
|
-function getM2TSSupportedAudioTypes(preferManagedMediaSource) {
|
|
|
- const MediaSource = getMediaSource(preferManagedMediaSource) || {
|
|
|
- isTypeSupported: () => false
|
|
|
- };
|
|
|
- return {
|
|
|
- mpeg: MediaSource.isTypeSupported("audio/mpeg"),
|
|
|
- mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
|
|
|
- ac3: MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"')
|
|
|
- };
|
|
|
-}
|
|
|
-function getCodecsForMimeType(mimeType) {
|
|
|
- return mimeType.replace(/^.+codecs=["']?([^"']+).*$/, "$1");
|
|
|
-}
|
|
|
-var supportedResult = {
|
|
|
- supported: true,
|
|
|
- powerEfficient: true,
|
|
|
- smooth: true
|
|
|
- // keySystemAccess: null,
|
|
|
-};
|
|
|
-var unsupportedResult = {
|
|
|
- supported: false,
|
|
|
- smooth: false,
|
|
|
- powerEfficient: false
|
|
|
- // keySystemAccess: null,
|
|
|
-};
|
|
|
-var SUPPORTED_INFO_DEFAULT = {
|
|
|
- supported: true,
|
|
|
- configurations: [],
|
|
|
- decodingInfoResults: [supportedResult]
|
|
|
-};
|
|
|
-function getUnsupportedResult(error, configurations) {
|
|
|
- return {
|
|
|
- supported: false,
|
|
|
- configurations,
|
|
|
- decodingInfoResults: [unsupportedResult],
|
|
|
- error
|
|
|
- };
|
|
|
-}
|
|
|
-function requiresMediaCapabilitiesDecodingInfo(level, audioTracksByGroup, currentVideoRange, currentFrameRate, currentBw, audioPreference) {
|
|
|
- const videoCodecs = level.videoCodec;
|
|
|
- const audioGroups = level.audioCodec ? level.audioGroups : null;
|
|
|
- const audioCodecPreference = audioPreference == null ? void 0 : audioPreference.audioCodec;
|
|
|
- const channelsPreference = audioPreference == null ? void 0 : audioPreference.channels;
|
|
|
- const maxChannels = channelsPreference ? parseInt(channelsPreference) : audioCodecPreference ? Infinity : 2;
|
|
|
- let audioChannels = null;
|
|
|
- if (audioGroups != null && audioGroups.length) {
|
|
|
- try {
|
|
|
- if (audioGroups.length === 1 && audioGroups[0]) {
|
|
|
- audioChannels = audioTracksByGroup.groups[audioGroups[0]].channels;
|
|
|
- } else {
|
|
|
- audioChannels = audioGroups.reduce((acc, groupId) => {
|
|
|
- if (groupId) {
|
|
|
- const audioTrackGroup = audioTracksByGroup.groups[groupId];
|
|
|
- if (!audioTrackGroup) {
|
|
|
- throw new Error(`Audio track group ${groupId} not found`);
|
|
|
- }
|
|
|
- Object.keys(audioTrackGroup.channels).forEach((key) => {
|
|
|
- acc[key] = (acc[key] || 0) + audioTrackGroup.channels[key];
|
|
|
- });
|
|
|
- }
|
|
|
- return acc;
|
|
|
- }, {
|
|
|
- 2: 0
|
|
|
- });
|
|
|
- }
|
|
|
- } catch (error) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return videoCodecs !== void 0 && // Force media capabilities check for HEVC to avoid failure on Windows
|
|
|
- (videoCodecs.split(",").some((videoCodec) => isHEVC(videoCodec)) || level.width > 1920 && level.height > 1088 || level.height > 1920 && level.width > 1088 || level.frameRate > Math.max(currentFrameRate, 30) || level.videoRange !== "SDR" && level.videoRange !== currentVideoRange || level.bitrate > Math.max(currentBw, 8e6)) || !!audioChannels && isFiniteNumber(maxChannels) && Object.keys(audioChannels).some((channels) => parseInt(channels) > maxChannels);
|
|
|
-}
|
|
|
-function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilities, cache = {}) {
|
|
|
- const videoCodecs = level.videoCodec;
|
|
|
- if (!videoCodecs && !level.audioCodec || !mediaCapabilities) {
|
|
|
- return Promise.resolve(SUPPORTED_INFO_DEFAULT);
|
|
|
- }
|
|
|
- const configurations = [];
|
|
|
- const videoDecodeList = makeVideoConfigurations(level);
|
|
|
- const videoCount = videoDecodeList.length;
|
|
|
- const audioDecodeList = makeAudioConfigurations(level, audioTracksByGroup, videoCount > 0);
|
|
|
- const audioCount = audioDecodeList.length;
|
|
|
- for (let i = videoCount || 1 * audioCount || 1; i--; ) {
|
|
|
- const configuration = {
|
|
|
- type: "media-source"
|
|
|
- };
|
|
|
- if (videoCount) {
|
|
|
- configuration.video = videoDecodeList[i % videoCount];
|
|
|
- }
|
|
|
- if (audioCount) {
|
|
|
- configuration.audio = audioDecodeList[i % audioCount];
|
|
|
- const audioBitrate = configuration.audio.bitrate;
|
|
|
- if (configuration.video && audioBitrate) {
|
|
|
- configuration.video.bitrate -= audioBitrate;
|
|
|
- }
|
|
|
- }
|
|
|
- configurations.push(configuration);
|
|
|
- }
|
|
|
- if (videoCodecs) {
|
|
|
- const ua = navigator.userAgent;
|
|
|
- if (videoCodecs.split(",").some((videoCodec) => isHEVC(videoCodec)) && userAgentHevcSupportIsInaccurate()) {
|
|
|
- return Promise.resolve(getUnsupportedResult(new Error(`Overriding Windows Firefox HEVC MediaCapabilities result based on user-agent string: (${ua})`), configurations));
|
|
|
- }
|
|
|
- }
|
|
|
- return Promise.all(configurations.map((configuration) => {
|
|
|
- const decodingInfoKey = getMediaDecodingInfoKey(configuration);
|
|
|
- return cache[decodingInfoKey] || (cache[decodingInfoKey] = mediaCapabilities.decodingInfo(configuration));
|
|
|
- })).then((decodingInfoResults) => ({
|
|
|
- supported: !decodingInfoResults.some((info) => !info.supported),
|
|
|
- configurations,
|
|
|
- decodingInfoResults
|
|
|
- })).catch((error) => ({
|
|
|
- supported: false,
|
|
|
- configurations,
|
|
|
- decodingInfoResults: [],
|
|
|
- error
|
|
|
- }));
|
|
|
-}
|
|
|
-function makeVideoConfigurations(level) {
|
|
|
- var _level$videoCodec;
|
|
|
- const videoCodecs = (_level$videoCodec = level.videoCodec) == null ? void 0 : _level$videoCodec.split(",");
|
|
|
- const bitrate = getVariantDecodingBitrate(level);
|
|
|
- const width = level.width || 640;
|
|
|
- const height = level.height || 480;
|
|
|
- const framerate = level.frameRate || 30;
|
|
|
- const videoRange = level.videoRange.toLowerCase();
|
|
|
- return videoCodecs ? videoCodecs.map((videoCodec) => {
|
|
|
- const videoConfiguration = {
|
|
|
- contentType: mimeTypeForCodec(fillInMissingAV01Params(videoCodec), "video"),
|
|
|
- width,
|
|
|
- height,
|
|
|
- bitrate,
|
|
|
- framerate
|
|
|
- };
|
|
|
- if (videoRange !== "sdr") {
|
|
|
- videoConfiguration.transferFunction = videoRange;
|
|
|
- }
|
|
|
- return videoConfiguration;
|
|
|
- }) : [];
|
|
|
-}
|
|
|
-function makeAudioConfigurations(level, audioTracksByGroup, hasVideo) {
|
|
|
- var _level$audioCodec;
|
|
|
- const audioCodecs = (_level$audioCodec = level.audioCodec) == null ? void 0 : _level$audioCodec.split(",");
|
|
|
- const combinedBitrate = getVariantDecodingBitrate(level);
|
|
|
- if (audioCodecs && level.audioGroups) {
|
|
|
- return level.audioGroups.reduce((configurations, audioGroupId) => {
|
|
|
- var _audioTracksByGroup$g;
|
|
|
- const tracks = audioGroupId ? (_audioTracksByGroup$g = audioTracksByGroup.groups[audioGroupId]) == null ? void 0 : _audioTracksByGroup$g.tracks : null;
|
|
|
- if (tracks) {
|
|
|
- return tracks.reduce((configs, audioTrack) => {
|
|
|
- if (audioTrack.groupId === audioGroupId) {
|
|
|
- const channelsNumber = parseFloat(audioTrack.channels || "");
|
|
|
- audioCodecs.forEach((audioCodec) => {
|
|
|
- const audioConfiguration = {
|
|
|
- contentType: mimeTypeForCodec(audioCodec, "audio"),
|
|
|
- bitrate: hasVideo ? estimatedAudioBitrate(audioCodec, combinedBitrate) : combinedBitrate
|
|
|
- };
|
|
|
- if (channelsNumber) {
|
|
|
- audioConfiguration.channels = "" + channelsNumber;
|
|
|
- }
|
|
|
- configs.push(audioConfiguration);
|
|
|
- });
|
|
|
- }
|
|
|
- return configs;
|
|
|
- }, configurations);
|
|
|
- }
|
|
|
- return configurations;
|
|
|
- }, []);
|
|
|
- }
|
|
|
- return [];
|
|
|
-}
|
|
|
-function estimatedAudioBitrate(audioCodec, levelBitrate) {
|
|
|
- if (levelBitrate <= 1) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- let audioBitrate = 128e3;
|
|
|
- if (audioCodec === "ec-3") {
|
|
|
- audioBitrate = 768e3;
|
|
|
- } else if (audioCodec === "ac-3") {
|
|
|
- audioBitrate = 64e4;
|
|
|
- }
|
|
|
- return Math.min(levelBitrate / 2, audioBitrate);
|
|
|
-}
|
|
|
-function getVariantDecodingBitrate(level) {
|
|
|
- return Math.ceil(Math.max(level.bitrate * 0.9, level.averageBitrate) / 1e3) * 1e3 || 1;
|
|
|
-}
|
|
|
-function getMediaDecodingInfoKey(config) {
|
|
|
- let key = "";
|
|
|
- const {
|
|
|
- audio,
|
|
|
- video
|
|
|
- } = config;
|
|
|
- if (video) {
|
|
|
- const codec = getCodecsForMimeType(video.contentType);
|
|
|
- key += `${codec}_r${video.height}x${video.width}f${Math.ceil(video.framerate)}${video.transferFunction || "sd"}_${Math.ceil(video.bitrate / 1e5)}`;
|
|
|
- }
|
|
|
- if (audio) {
|
|
|
- const codec = getCodecsForMimeType(audio.contentType);
|
|
|
- key += `${video ? "_" : ""}${codec}_c${audio.channels}`;
|
|
|
- }
|
|
|
- return key;
|
|
|
-}
|
|
|
-var HdcpLevels = ["NONE", "TYPE-0", "TYPE-1", null];
|
|
|
-function isHdcpLevel(value) {
|
|
|
- return HdcpLevels.indexOf(value) > -1;
|
|
|
-}
|
|
|
-var VideoRangeValues = ["SDR", "PQ", "HLG"];
|
|
|
-function isVideoRange(value) {
|
|
|
- return !!value && VideoRangeValues.indexOf(value) > -1;
|
|
|
-}
|
|
|
-var HlsSkip = {
|
|
|
- No: "",
|
|
|
- Yes: "YES",
|
|
|
- v2: "v2"
|
|
|
-};
|
|
|
-function getSkipValue(details) {
|
|
|
- const {
|
|
|
- canSkipUntil,
|
|
|
- canSkipDateRanges,
|
|
|
- age
|
|
|
- } = details;
|
|
|
- const playlistRecentEnough = age < canSkipUntil / 2;
|
|
|
- if (canSkipUntil && playlistRecentEnough) {
|
|
|
- if (canSkipDateRanges) {
|
|
|
- return HlsSkip.v2;
|
|
|
- }
|
|
|
- return HlsSkip.Yes;
|
|
|
- }
|
|
|
- return HlsSkip.No;
|
|
|
-}
|
|
|
-var HlsUrlParameters = class {
|
|
|
- constructor(msn, part, skip) {
|
|
|
- this.msn = void 0;
|
|
|
- this.part = void 0;
|
|
|
- this.skip = void 0;
|
|
|
- this.msn = msn;
|
|
|
- this.part = part;
|
|
|
- this.skip = skip;
|
|
|
- }
|
|
|
- addDirectives(uri) {
|
|
|
- const url = new self.URL(uri);
|
|
|
- if (this.msn !== void 0) {
|
|
|
- url.searchParams.set("_HLS_msn", this.msn.toString());
|
|
|
- }
|
|
|
- if (this.part !== void 0) {
|
|
|
- url.searchParams.set("_HLS_part", this.part.toString());
|
|
|
- }
|
|
|
- if (this.skip) {
|
|
|
- url.searchParams.set("_HLS_skip", this.skip);
|
|
|
- }
|
|
|
- return url.href;
|
|
|
- }
|
|
|
-};
|
|
|
-var Level = class {
|
|
|
- constructor(data) {
|
|
|
- this._attrs = void 0;
|
|
|
- this.audioCodec = void 0;
|
|
|
- this.bitrate = void 0;
|
|
|
- this.codecSet = void 0;
|
|
|
- this.url = void 0;
|
|
|
- this.frameRate = void 0;
|
|
|
- this.height = void 0;
|
|
|
- this.id = void 0;
|
|
|
- this.name = void 0;
|
|
|
- this.supplemental = void 0;
|
|
|
- this.videoCodec = void 0;
|
|
|
- this.width = void 0;
|
|
|
- this.details = void 0;
|
|
|
- this.fragmentError = 0;
|
|
|
- this.loadError = 0;
|
|
|
- this.loaded = void 0;
|
|
|
- this.realBitrate = 0;
|
|
|
- this.supportedPromise = void 0;
|
|
|
- this.supportedResult = void 0;
|
|
|
- this._avgBitrate = 0;
|
|
|
- this._audioGroups = void 0;
|
|
|
- this._subtitleGroups = void 0;
|
|
|
- this._urlId = 0;
|
|
|
- this.url = [data.url];
|
|
|
- this._attrs = [data.attrs];
|
|
|
- this.bitrate = data.bitrate;
|
|
|
- if (data.details) {
|
|
|
- this.details = data.details;
|
|
|
- }
|
|
|
- this.id = data.id || 0;
|
|
|
- this.name = data.name;
|
|
|
- this.width = data.width || 0;
|
|
|
- this.height = data.height || 0;
|
|
|
- this.frameRate = data.attrs.optionalFloat("FRAME-RATE", 0);
|
|
|
- this._avgBitrate = data.attrs.decimalInteger("AVERAGE-BANDWIDTH");
|
|
|
- this.audioCodec = data.audioCodec;
|
|
|
- this.videoCodec = data.videoCodec;
|
|
|
- this.codecSet = [data.videoCodec, data.audioCodec].filter((c) => !!c).map((s) => s.substring(0, 4)).join(",");
|
|
|
- if ("supplemental" in data) {
|
|
|
- var _data$supplemental;
|
|
|
- this.supplemental = data.supplemental;
|
|
|
- const supplementalVideo = (_data$supplemental = data.supplemental) == null ? void 0 : _data$supplemental.videoCodec;
|
|
|
- if (supplementalVideo && supplementalVideo !== data.videoCodec) {
|
|
|
- this.codecSet += `,${supplementalVideo.substring(0, 4)}`;
|
|
|
- }
|
|
|
- }
|
|
|
- this.addGroupId("audio", data.attrs.AUDIO);
|
|
|
- this.addGroupId("text", data.attrs.SUBTITLES);
|
|
|
- }
|
|
|
- get maxBitrate() {
|
|
|
- return Math.max(this.realBitrate, this.bitrate);
|
|
|
- }
|
|
|
- get averageBitrate() {
|
|
|
- return this._avgBitrate || this.realBitrate || this.bitrate;
|
|
|
- }
|
|
|
- get attrs() {
|
|
|
- return this._attrs[0];
|
|
|
- }
|
|
|
- get codecs() {
|
|
|
- return this.attrs.CODECS || "";
|
|
|
- }
|
|
|
- get pathwayId() {
|
|
|
- return this.attrs["PATHWAY-ID"] || ".";
|
|
|
- }
|
|
|
- get videoRange() {
|
|
|
- return this.attrs["VIDEO-RANGE"] || "SDR";
|
|
|
- }
|
|
|
- get score() {
|
|
|
- return this.attrs.optionalFloat("SCORE", 0);
|
|
|
- }
|
|
|
- get uri() {
|
|
|
- return this.url[0] || "";
|
|
|
- }
|
|
|
- hasAudioGroup(groupId) {
|
|
|
- return hasGroup(this._audioGroups, groupId);
|
|
|
- }
|
|
|
- hasSubtitleGroup(groupId) {
|
|
|
- return hasGroup(this._subtitleGroups, groupId);
|
|
|
- }
|
|
|
- get audioGroups() {
|
|
|
- return this._audioGroups;
|
|
|
- }
|
|
|
- get subtitleGroups() {
|
|
|
- return this._subtitleGroups;
|
|
|
- }
|
|
|
- addGroupId(type, groupId) {
|
|
|
- if (!groupId) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (type === "audio") {
|
|
|
- let audioGroups = this._audioGroups;
|
|
|
- if (!audioGroups) {
|
|
|
- audioGroups = this._audioGroups = [];
|
|
|
- }
|
|
|
- if (audioGroups.indexOf(groupId) === -1) {
|
|
|
- audioGroups.push(groupId);
|
|
|
- }
|
|
|
- } else if (type === "text") {
|
|
|
- let subtitleGroups = this._subtitleGroups;
|
|
|
- if (!subtitleGroups) {
|
|
|
- subtitleGroups = this._subtitleGroups = [];
|
|
|
- }
|
|
|
- if (subtitleGroups.indexOf(groupId) === -1) {
|
|
|
- subtitleGroups.push(groupId);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- // Deprecated methods (retained for backwards compatibility)
|
|
|
- get urlId() {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- set urlId(value) {
|
|
|
- }
|
|
|
- get audioGroupIds() {
|
|
|
- return this.audioGroups ? [this.audioGroupId] : void 0;
|
|
|
- }
|
|
|
- get textGroupIds() {
|
|
|
- return this.subtitleGroups ? [this.textGroupId] : void 0;
|
|
|
- }
|
|
|
- get audioGroupId() {
|
|
|
- var _this$audioGroups;
|
|
|
- return (_this$audioGroups = this.audioGroups) == null ? void 0 : _this$audioGroups[0];
|
|
|
- }
|
|
|
- get textGroupId() {
|
|
|
- var _this$subtitleGroups;
|
|
|
- return (_this$subtitleGroups = this.subtitleGroups) == null ? void 0 : _this$subtitleGroups[0];
|
|
|
- }
|
|
|
- addFallback() {
|
|
|
- }
|
|
|
-};
|
|
|
-function hasGroup(groups, groupId) {
|
|
|
- if (!groupId || !groups) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return groups.indexOf(groupId) !== -1;
|
|
|
-}
|
|
|
-function isHdrSupported() {
|
|
|
- if (typeof matchMedia === "function") {
|
|
|
- const mediaQueryList = matchMedia("(dynamic-range: high)");
|
|
|
- const badQuery = matchMedia("bad query");
|
|
|
- if (mediaQueryList.media !== badQuery.media) {
|
|
|
- return mediaQueryList.matches === true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function getVideoSelectionOptions(currentVideoRange, videoPreference) {
|
|
|
- let preferHDR = false;
|
|
|
- let allowedVideoRanges = [];
|
|
|
- if (currentVideoRange) {
|
|
|
- preferHDR = currentVideoRange !== "SDR";
|
|
|
- allowedVideoRanges = [currentVideoRange];
|
|
|
- }
|
|
|
- if (videoPreference) {
|
|
|
- allowedVideoRanges = videoPreference.allowedVideoRanges || VideoRangeValues.slice(0);
|
|
|
- const allowAutoPreferHDR = allowedVideoRanges.join("") !== "SDR" && !videoPreference.videoCodec;
|
|
|
- preferHDR = videoPreference.preferHDR !== void 0 ? videoPreference.preferHDR : allowAutoPreferHDR && isHdrSupported();
|
|
|
- if (!preferHDR) {
|
|
|
- allowedVideoRanges = ["SDR"];
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- preferHDR,
|
|
|
- allowedVideoRanges
|
|
|
- };
|
|
|
-}
|
|
|
-var omitCircularRefsReplacer = (replacer) => {
|
|
|
- const known = /* @__PURE__ */ new WeakSet();
|
|
|
- return (_, value) => {
|
|
|
- if (replacer) {
|
|
|
- value = replacer(_, value);
|
|
|
- }
|
|
|
- if (typeof value === "object" && value !== null) {
|
|
|
- if (known.has(value)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- known.add(value);
|
|
|
- }
|
|
|
- return value;
|
|
|
- };
|
|
|
-};
|
|
|
-var stringify = (object, replacer) => JSON.stringify(object, omitCircularRefsReplacer(replacer));
|
|
|
-function getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPreference, videoPreference) {
|
|
|
- const codecSets = Object.keys(codecTiers);
|
|
|
- const channelsPreference = audioPreference == null ? void 0 : audioPreference.channels;
|
|
|
- const audioCodecPreference = audioPreference == null ? void 0 : audioPreference.audioCodec;
|
|
|
- const videoCodecPreference = videoPreference == null ? void 0 : videoPreference.videoCodec;
|
|
|
- const preferStereo = channelsPreference && parseInt(channelsPreference) === 2;
|
|
|
- let hasStereo = false;
|
|
|
- let hasCurrentVideoRange = false;
|
|
|
- let minHeight = Infinity;
|
|
|
- let minFramerate = Infinity;
|
|
|
- let minBitrate = Infinity;
|
|
|
- let minIndex = Infinity;
|
|
|
- let selectedScore = 0;
|
|
|
- let videoRanges = [];
|
|
|
- const {
|
|
|
- preferHDR,
|
|
|
- allowedVideoRanges
|
|
|
- } = getVideoSelectionOptions(currentVideoRange, videoPreference);
|
|
|
- for (let i = codecSets.length; i--; ) {
|
|
|
- const tier = codecTiers[codecSets[i]];
|
|
|
- hasStereo || (hasStereo = tier.channels[2] > 0);
|
|
|
- minHeight = Math.min(minHeight, tier.minHeight);
|
|
|
- minFramerate = Math.min(minFramerate, tier.minFramerate);
|
|
|
- minBitrate = Math.min(minBitrate, tier.minBitrate);
|
|
|
- const matchingVideoRanges = allowedVideoRanges.filter((range) => tier.videoRanges[range] > 0);
|
|
|
- if (matchingVideoRanges.length > 0) {
|
|
|
- hasCurrentVideoRange = true;
|
|
|
- }
|
|
|
- }
|
|
|
- minHeight = isFiniteNumber(minHeight) ? minHeight : 0;
|
|
|
- minFramerate = isFiniteNumber(minFramerate) ? minFramerate : 0;
|
|
|
- const maxHeight = Math.max(1080, minHeight);
|
|
|
- const maxFramerate = Math.max(30, minFramerate);
|
|
|
- minBitrate = isFiniteNumber(minBitrate) ? minBitrate : currentBw;
|
|
|
- currentBw = Math.max(minBitrate, currentBw);
|
|
|
- if (!hasCurrentVideoRange) {
|
|
|
- currentVideoRange = void 0;
|
|
|
- }
|
|
|
- const hasMultipleSets = codecSets.length > 1;
|
|
|
- const codecSet = codecSets.reduce((selected, candidate) => {
|
|
|
- const candidateTier = codecTiers[candidate];
|
|
|
- if (candidate === selected) {
|
|
|
- return selected;
|
|
|
- }
|
|
|
- videoRanges = hasCurrentVideoRange ? allowedVideoRanges.filter((range) => candidateTier.videoRanges[range] > 0) : [];
|
|
|
- if (hasMultipleSets) {
|
|
|
- if (candidateTier.minBitrate > currentBw) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (!candidateTier.hasDefaultAudio) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `no renditions with default or auto-select sound found`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (audioCodecPreference && candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `audio codec preference "${audioCodecPreference}" not found`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (channelsPreference && !preferStereo) {
|
|
|
- if (!candidateTier.channels[channelsPreference]) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(candidateTier.channels)})`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- } else if ((!audioCodecPreference || preferStereo) && hasStereo && candidateTier.channels["2"] === 0) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `no renditions with stereo sound found`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (candidateTier.minHeight > maxHeight) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (candidateTier.minFramerate > maxFramerate) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (!videoRanges.some((range) => candidateTier.videoRanges[range] > 0)) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `no variants with VIDEO-RANGE of ${stringify(videoRanges)} found`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (videoCodecPreference && candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `video codec preference "${videoCodecPreference}" not found`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- if (candidateTier.maxScore < selectedScore) {
|
|
|
- logStartCodecCandidateIgnored(candidate, `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`);
|
|
|
- return selected;
|
|
|
- }
|
|
|
- }
|
|
|
- if (selected && (codecsSetSelectionPreferenceValue(candidate) >= codecsSetSelectionPreferenceValue(selected) || candidateTier.fragmentError > codecTiers[selected].fragmentError)) {
|
|
|
- return selected;
|
|
|
- }
|
|
|
- minIndex = candidateTier.minIndex;
|
|
|
- selectedScore = candidateTier.maxScore;
|
|
|
- return candidate;
|
|
|
- }, void 0);
|
|
|
- return {
|
|
|
- codecSet,
|
|
|
- videoRanges,
|
|
|
- preferHDR,
|
|
|
- minFramerate,
|
|
|
- minBitrate,
|
|
|
- minIndex
|
|
|
- };
|
|
|
-}
|
|
|
-function logStartCodecCandidateIgnored(codeSet, reason) {
|
|
|
- logger.log(`[abr] start candidates with "${codeSet}" ignored because ${reason}`);
|
|
|
-}
|
|
|
-function getAudioTracksByGroup(allAudioTracks) {
|
|
|
- return allAudioTracks.reduce((audioTracksByGroup, track) => {
|
|
|
- let trackGroup = audioTracksByGroup.groups[track.groupId];
|
|
|
- if (!trackGroup) {
|
|
|
- trackGroup = audioTracksByGroup.groups[track.groupId] = {
|
|
|
- tracks: [],
|
|
|
- channels: {
|
|
|
- 2: 0
|
|
|
- },
|
|
|
- hasDefault: false,
|
|
|
- hasAutoSelect: false
|
|
|
- };
|
|
|
- }
|
|
|
- trackGroup.tracks.push(track);
|
|
|
- const channelsKey = track.channels || "2";
|
|
|
- trackGroup.channels[channelsKey] = (trackGroup.channels[channelsKey] || 0) + 1;
|
|
|
- trackGroup.hasDefault = trackGroup.hasDefault || track.default;
|
|
|
- trackGroup.hasAutoSelect = trackGroup.hasAutoSelect || track.autoselect;
|
|
|
- if (trackGroup.hasDefault) {
|
|
|
- audioTracksByGroup.hasDefaultAudio = true;
|
|
|
- }
|
|
|
- if (trackGroup.hasAutoSelect) {
|
|
|
- audioTracksByGroup.hasAutoSelectAudio = true;
|
|
|
- }
|
|
|
- return audioTracksByGroup;
|
|
|
- }, {
|
|
|
- hasDefaultAudio: false,
|
|
|
- hasAutoSelectAudio: false,
|
|
|
- groups: {}
|
|
|
- });
|
|
|
-}
|
|
|
-function getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel) {
|
|
|
- return levels.slice(minAutoLevel, maxAutoLevel + 1).reduce((tiers, level, index) => {
|
|
|
- if (!level.codecSet) {
|
|
|
- return tiers;
|
|
|
- }
|
|
|
- const audioGroups = level.audioGroups;
|
|
|
- let tier = tiers[level.codecSet];
|
|
|
- if (!tier) {
|
|
|
- tiers[level.codecSet] = tier = {
|
|
|
- minBitrate: Infinity,
|
|
|
- minHeight: Infinity,
|
|
|
- minFramerate: Infinity,
|
|
|
- minIndex: index,
|
|
|
- maxScore: 0,
|
|
|
- videoRanges: {
|
|
|
- SDR: 0
|
|
|
- },
|
|
|
- channels: {
|
|
|
- "2": 0
|
|
|
- },
|
|
|
- hasDefaultAudio: !audioGroups,
|
|
|
- fragmentError: 0
|
|
|
- };
|
|
|
- }
|
|
|
- tier.minBitrate = Math.min(tier.minBitrate, level.bitrate);
|
|
|
- const lesserWidthOrHeight = Math.min(level.height, level.width);
|
|
|
- tier.minHeight = Math.min(tier.minHeight, lesserWidthOrHeight);
|
|
|
- tier.minFramerate = Math.min(tier.minFramerate, level.frameRate);
|
|
|
- tier.minIndex = Math.min(tier.minIndex, index);
|
|
|
- tier.maxScore = Math.max(tier.maxScore, level.score);
|
|
|
- tier.fragmentError += level.fragmentError;
|
|
|
- tier.videoRanges[level.videoRange] = (tier.videoRanges[level.videoRange] || 0) + 1;
|
|
|
- if (audioGroups) {
|
|
|
- audioGroups.forEach((audioGroupId) => {
|
|
|
- if (!audioGroupId) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const audioGroup = audioTracksByGroup.groups[audioGroupId];
|
|
|
- if (!audioGroup) {
|
|
|
- return;
|
|
|
- }
|
|
|
- tier.hasDefaultAudio = tier.hasDefaultAudio || audioTracksByGroup.hasDefaultAudio ? audioGroup.hasDefault : audioGroup.hasAutoSelect || !audioTracksByGroup.hasDefaultAudio && !audioTracksByGroup.hasAutoSelectAudio;
|
|
|
- Object.keys(audioGroup.channels).forEach((channels) => {
|
|
|
- tier.channels[channels] = (tier.channels[channels] || 0) + audioGroup.channels[channels];
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- return tiers;
|
|
|
- }, {});
|
|
|
-}
|
|
|
-function getBasicSelectionOption(option) {
|
|
|
- if (!option) {
|
|
|
- return option;
|
|
|
- }
|
|
|
- const {
|
|
|
- lang,
|
|
|
- assocLang,
|
|
|
- characteristics,
|
|
|
- channels,
|
|
|
- audioCodec
|
|
|
- } = option;
|
|
|
- return {
|
|
|
- lang,
|
|
|
- assocLang,
|
|
|
- characteristics,
|
|
|
- channels,
|
|
|
- audioCodec
|
|
|
- };
|
|
|
-}
|
|
|
-function findMatchingOption(option, tracks, matchPredicate) {
|
|
|
- if ("attrs" in option) {
|
|
|
- const index = tracks.indexOf(option);
|
|
|
- if (index !== -1) {
|
|
|
- return index;
|
|
|
- }
|
|
|
- }
|
|
|
- for (let i = 0; i < tracks.length; i++) {
|
|
|
- const track = tracks[i];
|
|
|
- if (matchesOption(option, track, matchPredicate)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
-}
|
|
|
-function matchesOption(option, track, matchPredicate) {
|
|
|
- const {
|
|
|
- groupId,
|
|
|
- name,
|
|
|
- lang,
|
|
|
- assocLang,
|
|
|
- default: isDefault
|
|
|
- } = option;
|
|
|
- const forced = option.forced;
|
|
|
- return (groupId === void 0 || track.groupId === groupId) && (name === void 0 || track.name === name) && (lang === void 0 || languagesMatch(lang, track.lang)) && (lang === void 0 || track.assocLang === assocLang) && (isDefault === void 0 || track.default === isDefault) && (forced === void 0 || track.forced === forced) && (!("characteristics" in option) || characteristicsMatch(option.characteristics || "", track.characteristics)) && (matchPredicate === void 0 || matchPredicate(option, track));
|
|
|
-}
|
|
|
-function languagesMatch(languageA, languageB = "--") {
|
|
|
- if (languageA.length === languageB.length) {
|
|
|
- return languageA === languageB;
|
|
|
- }
|
|
|
- return languageA.startsWith(languageB) || languageB.startsWith(languageA);
|
|
|
-}
|
|
|
-function characteristicsMatch(characteristicsA, characteristicsB = "") {
|
|
|
- const arrA = characteristicsA.split(",");
|
|
|
- const arrB = characteristicsB.split(",");
|
|
|
- return arrA.length === arrB.length && !arrA.some((el) => arrB.indexOf(el) === -1);
|
|
|
-}
|
|
|
-function audioMatchPredicate(option, track) {
|
|
|
- const {
|
|
|
- audioCodec,
|
|
|
- channels
|
|
|
- } = option;
|
|
|
- return (audioCodec === void 0 || (track.audioCodec || "").substring(0, 4) === audioCodec.substring(0, 4)) && (channels === void 0 || channels === (track.channels || "2"));
|
|
|
-}
|
|
|
-function findClosestLevelWithAudioGroup(option, levels, allAudioTracks, searchIndex, matchPredicate) {
|
|
|
- const currentLevel = levels[searchIndex];
|
|
|
- const variants = levels.reduce((variantMap, level, index) => {
|
|
|
- const uri = level.uri;
|
|
|
- const renditions2 = variantMap[uri] || (variantMap[uri] = []);
|
|
|
- renditions2.push(index);
|
|
|
- return variantMap;
|
|
|
- }, {});
|
|
|
- const renditions = variants[currentLevel.uri];
|
|
|
- if (renditions.length > 1) {
|
|
|
- searchIndex = Math.max.apply(Math, renditions);
|
|
|
- }
|
|
|
- const currentVideoRange = currentLevel.videoRange;
|
|
|
- const currentFrameRate = currentLevel.frameRate;
|
|
|
- const currentVideoCodec = currentLevel.codecSet.substring(0, 4);
|
|
|
- const matchingVideo = searchDownAndUpList(levels, searchIndex, (level) => {
|
|
|
- if (level.videoRange !== currentVideoRange || level.frameRate !== currentFrameRate || level.codecSet.substring(0, 4) !== currentVideoCodec) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const audioGroups = level.audioGroups;
|
|
|
- const tracks = allAudioTracks.filter((track) => !audioGroups || audioGroups.indexOf(track.groupId) !== -1);
|
|
|
- return findMatchingOption(option, tracks, matchPredicate) > -1;
|
|
|
- });
|
|
|
- if (matchingVideo > -1) {
|
|
|
- return matchingVideo;
|
|
|
- }
|
|
|
- return searchDownAndUpList(levels, searchIndex, (level) => {
|
|
|
- const audioGroups = level.audioGroups;
|
|
|
- const tracks = allAudioTracks.filter((track) => !audioGroups || audioGroups.indexOf(track.groupId) !== -1);
|
|
|
- return findMatchingOption(option, tracks, matchPredicate) > -1;
|
|
|
- });
|
|
|
-}
|
|
|
-function searchDownAndUpList(arr, searchIndex, predicate) {
|
|
|
- for (let i = searchIndex; i > -1; i--) {
|
|
|
- if (predicate(arr[i])) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- for (let i = searchIndex + 1; i < arr.length; i++) {
|
|
|
- if (predicate(arr[i])) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
-}
|
|
|
-function useAlternateAudio(audioTrackUrl, hls) {
|
|
|
- var _hls$loadLevelObj;
|
|
|
- return !!audioTrackUrl && audioTrackUrl !== ((_hls$loadLevelObj = hls.loadLevelObj) == null ? void 0 : _hls$loadLevelObj.uri);
|
|
|
-}
|
|
|
-var AbrController = class extends Logger {
|
|
|
- constructor(_hls) {
|
|
|
- super("abr", _hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.lastLevelLoadSec = 0;
|
|
|
- this.lastLoadedFragLevel = -1;
|
|
|
- this.firstSelection = -1;
|
|
|
- this._nextAutoLevel = -1;
|
|
|
- this.nextAutoLevelKey = "";
|
|
|
- this.audioTracksByGroup = null;
|
|
|
- this.codecTiers = null;
|
|
|
- this.timer = -1;
|
|
|
- this.fragCurrent = null;
|
|
|
- this.partCurrent = null;
|
|
|
- this.bitrateTestDelay = 0;
|
|
|
- this.rebufferNotice = -1;
|
|
|
- this.supportedCache = {};
|
|
|
- this.bwEstimator = void 0;
|
|
|
- this._abandonRulesCheck = (levelLoaded) => {
|
|
|
- var _ref;
|
|
|
- const {
|
|
|
- fragCurrent: frag,
|
|
|
- partCurrent: part,
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- autoLevelEnabled,
|
|
|
- media
|
|
|
- } = hls;
|
|
|
- if (!frag || !media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const now2 = performance.now();
|
|
|
- const stats = part ? part.stats : frag.stats;
|
|
|
- const duration = part ? part.duration : frag.duration;
|
|
|
- const timeLoading = now2 - stats.loading.start;
|
|
|
- const minAutoLevel = hls.minAutoLevel;
|
|
|
- const loadingFragForLevel = frag.level;
|
|
|
- const currentAutoLevel = this._nextAutoLevel;
|
|
|
- if (stats.aborted || stats.loaded && stats.loaded === stats.total || loadingFragForLevel <= minAutoLevel) {
|
|
|
- this.clearTimer();
|
|
|
- this._nextAutoLevel = -1;
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!autoLevelEnabled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const fragBlockingSwitch = currentAutoLevel > -1 && currentAutoLevel !== loadingFragForLevel;
|
|
|
- const levelChange = !!levelLoaded || fragBlockingSwitch;
|
|
|
- if (!levelChange && (media.paused || !media.playbackRate || !media.readyState)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferInfo = hls.mainForwardBufferInfo;
|
|
|
- if (!levelChange && bufferInfo === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const ttfbEstimate = this.bwEstimator.getEstimateTTFB();
|
|
|
- const playbackRate = Math.abs(media.playbackRate);
|
|
|
- if (timeLoading <= Math.max(ttfbEstimate, 1e3 * (duration / (playbackRate * 2)))) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferStarvationDelay = bufferInfo ? bufferInfo.len / playbackRate : 0;
|
|
|
- const ttfb = stats.loading.first ? stats.loading.first - stats.loading.start : -1;
|
|
|
- const loadedFirstByte = stats.loaded && ttfb > -1;
|
|
|
- const bwEstimate = this.getBwEstimate();
|
|
|
- const levels = hls.levels;
|
|
|
- const level = levels[loadingFragForLevel];
|
|
|
- const expectedLen = Math.max(stats.loaded, Math.round(duration * (frag.bitrate || level.averageBitrate) / 8));
|
|
|
- let timeStreaming = loadedFirstByte ? timeLoading - ttfb : timeLoading;
|
|
|
- if (timeStreaming < 1 && loadedFirstByte) {
|
|
|
- timeStreaming = Math.min(timeLoading, stats.loaded * 8 / bwEstimate);
|
|
|
- }
|
|
|
- const loadRate = loadedFirstByte ? stats.loaded * 1e3 / timeStreaming : 0;
|
|
|
- const ttfbSeconds = ttfbEstimate / 1e3;
|
|
|
- const fragLoadedDelay = loadRate ? (expectedLen - stats.loaded) / loadRate : expectedLen * 8 / bwEstimate + ttfbSeconds;
|
|
|
- if (fragLoadedDelay <= bufferStarvationDelay) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const bwe = loadRate ? loadRate * 8 : bwEstimate;
|
|
|
- const live = ((_ref = (levelLoaded == null ? void 0 : levelLoaded.details) || this.hls.latestLevelDetails) == null ? void 0 : _ref.live) === true;
|
|
|
- const abrBandWidthUpFactor = this.hls.config.abrBandWidthUpFactor;
|
|
|
- let fragLevelNextLoadedDelay = Number.POSITIVE_INFINITY;
|
|
|
- let nextLoadLevel;
|
|
|
- for (nextLoadLevel = loadingFragForLevel - 1; nextLoadLevel > minAutoLevel; nextLoadLevel--) {
|
|
|
- const levelNextBitrate = levels[nextLoadLevel].maxBitrate;
|
|
|
- const requiresLevelLoad = !levels[nextLoadLevel].details || live;
|
|
|
- fragLevelNextLoadedDelay = this.getTimeToLoadFrag(ttfbSeconds, bwe, duration * levelNextBitrate, requiresLevelLoad);
|
|
|
- if (fragLevelNextLoadedDelay < Math.min(bufferStarvationDelay, duration + ttfbSeconds)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (fragLevelNextLoadedDelay >= fragLoadedDelay) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (fragLevelNextLoadedDelay > duration * 10) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (loadedFirstByte) {
|
|
|
- this.bwEstimator.sample(timeLoading - Math.min(ttfbEstimate, ttfb), stats.loaded);
|
|
|
- } else {
|
|
|
- this.bwEstimator.sampleTTFB(timeLoading);
|
|
|
- }
|
|
|
- const nextLoadLevelBitrate = levels[nextLoadLevel].maxBitrate;
|
|
|
- if (this.getBwEstimate() * abrBandWidthUpFactor > nextLoadLevelBitrate) {
|
|
|
- this.resetEstimator(nextLoadLevelBitrate);
|
|
|
- }
|
|
|
- const bestSwitchLevel = this.findBestLevel(nextLoadLevelBitrate, minAutoLevel, nextLoadLevel, 0, bufferStarvationDelay, 1, 1);
|
|
|
- if (bestSwitchLevel > -1) {
|
|
|
- nextLoadLevel = bestSwitchLevel;
|
|
|
- }
|
|
|
- this.warn(`Fragment ${frag.sn}${part ? " part " + part.index : ""} of level ${loadingFragForLevel} is loading too slowly;
|
|
|
- Fragment duration: ${frag.duration.toFixed(3)}
|
|
|
- Time to underbuffer: ${bufferStarvationDelay.toFixed(3)} s
|
|
|
- Estimated load time for current fragment: ${fragLoadedDelay.toFixed(3)} s
|
|
|
- Estimated load time for down switch fragment: ${fragLevelNextLoadedDelay.toFixed(3)} s
|
|
|
- TTFB estimate: ${ttfb | 0} ms
|
|
|
- Current BW estimate: ${isFiniteNumber(bwEstimate) ? bwEstimate | 0 : "Unknown"} bps
|
|
|
- New BW estimate: ${this.getBwEstimate() | 0} bps
|
|
|
- Switching to level ${nextLoadLevel} @ ${nextLoadLevelBitrate | 0} bps`);
|
|
|
- hls.nextLoadLevel = hls.nextAutoLevel = nextLoadLevel;
|
|
|
- this.clearTimer();
|
|
|
- const abortAndSwitch = () => {
|
|
|
- this.clearTimer();
|
|
|
- if (this.fragCurrent === frag && this.hls.loadLevel === nextLoadLevel && nextLoadLevel > 0) {
|
|
|
- const bufferStarvationDelay2 = this.getStarvationDelay();
|
|
|
- this.warn(`Aborting inflight request ${nextLoadLevel > 0 ? "and switching down" : ""}
|
|
|
- Fragment duration: ${frag.duration.toFixed(3)} s
|
|
|
- Time to underbuffer: ${bufferStarvationDelay2.toFixed(3)} s`);
|
|
|
- frag.abortRequests();
|
|
|
- this.fragCurrent = this.partCurrent = null;
|
|
|
- if (nextLoadLevel > minAutoLevel) {
|
|
|
- let lowestSwitchLevel = this.findBestLevel(this.hls.levels[minAutoLevel].bitrate, minAutoLevel, nextLoadLevel, 0, bufferStarvationDelay2, 1, 1);
|
|
|
- if (lowestSwitchLevel === -1) {
|
|
|
- lowestSwitchLevel = minAutoLevel;
|
|
|
- }
|
|
|
- this.hls.nextLoadLevel = this.hls.nextAutoLevel = lowestSwitchLevel;
|
|
|
- this.resetEstimator(this.hls.levels[lowestSwitchLevel].bitrate);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- if (fragBlockingSwitch || fragLoadedDelay > fragLevelNextLoadedDelay * 2) {
|
|
|
- abortAndSwitch();
|
|
|
- } else {
|
|
|
- this.timer = self.setInterval(abortAndSwitch, fragLevelNextLoadedDelay * 1e3);
|
|
|
- }
|
|
|
- hls.trigger(Events.FRAG_LOAD_EMERGENCY_ABORTED, {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- stats
|
|
|
- });
|
|
|
- };
|
|
|
- this.hls = _hls;
|
|
|
- this.bwEstimator = this.initEstimator();
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- resetEstimator(abrEwmaDefaultEstimate) {
|
|
|
- if (abrEwmaDefaultEstimate) {
|
|
|
- this.log(`setting initial bwe to ${abrEwmaDefaultEstimate}`);
|
|
|
- this.hls.config.abrEwmaDefaultEstimate = abrEwmaDefaultEstimate;
|
|
|
- }
|
|
|
- this.firstSelection = -1;
|
|
|
- this.bwEstimator = this.initEstimator();
|
|
|
- }
|
|
|
- initEstimator() {
|
|
|
- const config = this.hls.config;
|
|
|
- return new EwmaBandWidthEstimator(config.abrEwmaSlowVoD, config.abrEwmaFastVoD, config.abrEwmaDefaultEstimate);
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
|
|
|
- hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
|
|
|
- hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- hls.on(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
|
|
|
- hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.on(Events.MAX_AUTO_LEVEL_UPDATED, this.onMaxAutoLevelUpdated, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.FRAG_LOADING, this.onFragLoading, this);
|
|
|
- hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
|
|
|
- hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- hls.off(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
|
|
|
- hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.off(Events.MAX_AUTO_LEVEL_UPDATED, this.onMaxAutoLevelUpdated, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.clearTimer();
|
|
|
- this.hls = this._abandonRulesCheck = this.supportedCache = null;
|
|
|
- this.fragCurrent = this.partCurrent = null;
|
|
|
- }
|
|
|
- onManifestLoading(event, data) {
|
|
|
- this.lastLoadedFragLevel = -1;
|
|
|
- this.firstSelection = -1;
|
|
|
- this.lastLevelLoadSec = 0;
|
|
|
- this.supportedCache = {};
|
|
|
- this.fragCurrent = this.partCurrent = null;
|
|
|
- this.onLevelsUpdated();
|
|
|
- this.clearTimer();
|
|
|
- }
|
|
|
- onLevelsUpdated() {
|
|
|
- if (this.lastLoadedFragLevel > -1 && this.fragCurrent) {
|
|
|
- this.lastLoadedFragLevel = this.fragCurrent.level;
|
|
|
- }
|
|
|
- this._nextAutoLevel = -1;
|
|
|
- this.onMaxAutoLevelUpdated();
|
|
|
- this.codecTiers = null;
|
|
|
- this.audioTracksByGroup = null;
|
|
|
- }
|
|
|
- onMaxAutoLevelUpdated() {
|
|
|
- this.firstSelection = -1;
|
|
|
- this.nextAutoLevelKey = "";
|
|
|
- }
|
|
|
- onFragLoading(event, data) {
|
|
|
- const frag = data.frag;
|
|
|
- if (this.ignoreFragment(frag)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!frag.bitrateTest) {
|
|
|
- var _data$part;
|
|
|
- this.fragCurrent = frag;
|
|
|
- this.partCurrent = (_data$part = data.part) != null ? _data$part : null;
|
|
|
- }
|
|
|
- this.clearTimer();
|
|
|
- this.timer = self.setInterval(this._abandonRulesCheck, 100);
|
|
|
- }
|
|
|
- onLevelSwitching(event, data) {
|
|
|
- this.clearTimer();
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- if (data.fatal) {
|
|
|
- return;
|
|
|
- }
|
|
|
- switch (data.details) {
|
|
|
- case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
|
|
|
- case ErrorDetails.BUFFER_APPEND_ERROR:
|
|
|
- this.lastLoadedFragLevel = -1;
|
|
|
- this.firstSelection = -1;
|
|
|
- break;
|
|
|
- case ErrorDetails.FRAG_LOAD_TIMEOUT: {
|
|
|
- const frag = data.frag;
|
|
|
- const {
|
|
|
- fragCurrent,
|
|
|
- partCurrent: part
|
|
|
- } = this;
|
|
|
- if (frag && fragCurrent && frag.sn === fragCurrent.sn && frag.level === fragCurrent.level) {
|
|
|
- const now2 = performance.now();
|
|
|
- const stats = part ? part.stats : frag.stats;
|
|
|
- const timeLoading = now2 - stats.loading.start;
|
|
|
- const ttfb = stats.loading.first ? stats.loading.first - stats.loading.start : -1;
|
|
|
- const loadedFirstByte = stats.loaded && ttfb > -1;
|
|
|
- if (loadedFirstByte) {
|
|
|
- const ttfbEstimate = this.bwEstimator.getEstimateTTFB();
|
|
|
- this.bwEstimator.sample(timeLoading - Math.min(ttfbEstimate, ttfb), stats.loaded);
|
|
|
- } else {
|
|
|
- this.bwEstimator.sampleTTFB(timeLoading);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- getTimeToLoadFrag(timeToFirstByteSec, bandwidth, fragSizeBits, isSwitch) {
|
|
|
- const fragLoadSec = timeToFirstByteSec + fragSizeBits / bandwidth;
|
|
|
- const playlistLoadSec = isSwitch ? timeToFirstByteSec + this.lastLevelLoadSec : 0;
|
|
|
- return fragLoadSec + playlistLoadSec;
|
|
|
- }
|
|
|
- onLevelLoaded(event, data) {
|
|
|
- const config = this.hls.config;
|
|
|
- const {
|
|
|
- loading
|
|
|
- } = data.stats;
|
|
|
- const timeLoadingMs = loading.end - loading.first;
|
|
|
- if (isFiniteNumber(timeLoadingMs)) {
|
|
|
- this.lastLevelLoadSec = timeLoadingMs / 1e3;
|
|
|
- }
|
|
|
- if (data.details.live) {
|
|
|
- this.bwEstimator.update(config.abrEwmaSlowLive, config.abrEwmaFastLive);
|
|
|
- } else {
|
|
|
- this.bwEstimator.update(config.abrEwmaSlowVoD, config.abrEwmaFastVoD);
|
|
|
- }
|
|
|
- if (this.timer > -1) {
|
|
|
- this._abandonRulesCheck(data.levelInfo);
|
|
|
- }
|
|
|
- }
|
|
|
- onFragLoaded(event, {
|
|
|
- frag,
|
|
|
- part
|
|
|
- }) {
|
|
|
- const stats = part ? part.stats : frag.stats;
|
|
|
- if (frag.type === PlaylistLevelType.MAIN) {
|
|
|
- this.bwEstimator.sampleTTFB(stats.loading.first - stats.loading.start);
|
|
|
- }
|
|
|
- if (this.ignoreFragment(frag)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.clearTimer();
|
|
|
- if (frag.level === this._nextAutoLevel) {
|
|
|
- this._nextAutoLevel = -1;
|
|
|
- }
|
|
|
- this.firstSelection = -1;
|
|
|
- if (this.hls.config.abrMaxWithRealBitrate) {
|
|
|
- const duration = part ? part.duration : frag.duration;
|
|
|
- const level = this.hls.levels[frag.level];
|
|
|
- const loadedBytes = (level.loaded ? level.loaded.bytes : 0) + stats.loaded;
|
|
|
- const loadedDuration = (level.loaded ? level.loaded.duration : 0) + duration;
|
|
|
- level.loaded = {
|
|
|
- bytes: loadedBytes,
|
|
|
- duration: loadedDuration
|
|
|
- };
|
|
|
- level.realBitrate = Math.round(8 * loadedBytes / loadedDuration);
|
|
|
- }
|
|
|
- if (frag.bitrateTest) {
|
|
|
- const fragBufferedData = {
|
|
|
- stats,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- id: frag.type
|
|
|
- };
|
|
|
- this.onFragBuffered(Events.FRAG_BUFFERED, fragBufferedData);
|
|
|
- frag.bitrateTest = false;
|
|
|
- } else {
|
|
|
- this.lastLoadedFragLevel = frag.level;
|
|
|
- }
|
|
|
- }
|
|
|
- onFragBuffered(event, data) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part
|
|
|
- } = data;
|
|
|
- const stats = part != null && part.stats.loaded ? part.stats : frag.stats;
|
|
|
- if (stats.aborted) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.ignoreFragment(frag)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const processingMs = stats.parsing.end - stats.loading.start - Math.min(stats.loading.first - stats.loading.start, this.bwEstimator.getEstimateTTFB());
|
|
|
- this.bwEstimator.sample(processingMs, stats.loaded);
|
|
|
- stats.bwEstimate = this.getBwEstimate();
|
|
|
- if (frag.bitrateTest) {
|
|
|
- this.bitrateTestDelay = processingMs / 1e3;
|
|
|
- } else {
|
|
|
- this.bitrateTestDelay = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- ignoreFragment(frag) {
|
|
|
- return frag.type !== PlaylistLevelType.MAIN || frag.sn === "initSegment";
|
|
|
- }
|
|
|
- clearTimer() {
|
|
|
- if (this.timer > -1) {
|
|
|
- self.clearInterval(this.timer);
|
|
|
- this.timer = -1;
|
|
|
- }
|
|
|
- }
|
|
|
- get firstAutoLevel() {
|
|
|
- const {
|
|
|
- maxAutoLevel,
|
|
|
- minAutoLevel
|
|
|
- } = this.hls;
|
|
|
- const bwEstimate = this.getBwEstimate();
|
|
|
- const maxStartDelay = this.hls.config.maxStarvationDelay;
|
|
|
- const abrAutoLevel = this.findBestLevel(bwEstimate, minAutoLevel, maxAutoLevel, 0, maxStartDelay, 1, 1);
|
|
|
- if (abrAutoLevel > -1) {
|
|
|
- return abrAutoLevel;
|
|
|
- }
|
|
|
- const firstLevel = this.hls.firstLevel;
|
|
|
- const clamped = Math.min(Math.max(firstLevel, minAutoLevel), maxAutoLevel);
|
|
|
- this.warn(`Could not find best starting auto level. Defaulting to first in playlist ${firstLevel} clamped to ${clamped}`);
|
|
|
- return clamped;
|
|
|
- }
|
|
|
- get forcedAutoLevel() {
|
|
|
- if (this.nextAutoLevelKey) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- return this._nextAutoLevel;
|
|
|
- }
|
|
|
- // return next auto level
|
|
|
- get nextAutoLevel() {
|
|
|
- const forcedAutoLevel = this.forcedAutoLevel;
|
|
|
- const bwEstimator = this.bwEstimator;
|
|
|
- const useEstimate = bwEstimator.canEstimate();
|
|
|
- const loadedFirstFrag = this.lastLoadedFragLevel > -1;
|
|
|
- if (forcedAutoLevel !== -1 && (!useEstimate || !loadedFirstFrag || this.nextAutoLevelKey === this.getAutoLevelKey())) {
|
|
|
- return forcedAutoLevel;
|
|
|
- }
|
|
|
- const nextABRAutoLevel = useEstimate && loadedFirstFrag ? this.getNextABRAutoLevel() : this.firstAutoLevel;
|
|
|
- if (forcedAutoLevel !== -1) {
|
|
|
- const levels = this.hls.levels;
|
|
|
- if (levels.length > Math.max(forcedAutoLevel, nextABRAutoLevel) && levels[forcedAutoLevel].loadError <= levels[nextABRAutoLevel].loadError) {
|
|
|
- return forcedAutoLevel;
|
|
|
- }
|
|
|
- }
|
|
|
- this._nextAutoLevel = nextABRAutoLevel;
|
|
|
- this.nextAutoLevelKey = this.getAutoLevelKey();
|
|
|
- return nextABRAutoLevel;
|
|
|
- }
|
|
|
- getAutoLevelKey() {
|
|
|
- return `${this.getBwEstimate()}_${this.getStarvationDelay().toFixed(2)}`;
|
|
|
- }
|
|
|
- getNextABRAutoLevel() {
|
|
|
- const {
|
|
|
- fragCurrent,
|
|
|
- partCurrent,
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (hls.levels.length <= 1) {
|
|
|
- return hls.loadLevel;
|
|
|
- }
|
|
|
- const {
|
|
|
- maxAutoLevel,
|
|
|
- config,
|
|
|
- minAutoLevel
|
|
|
- } = hls;
|
|
|
- const currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
|
|
|
- const avgbw = this.getBwEstimate();
|
|
|
- const bufferStarvationDelay = this.getStarvationDelay();
|
|
|
- let bwFactor = config.abrBandWidthFactor;
|
|
|
- let bwUpFactor = config.abrBandWidthUpFactor;
|
|
|
- if (bufferStarvationDelay) {
|
|
|
- const _bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, 0, bwFactor, bwUpFactor);
|
|
|
- if (_bestLevel >= 0) {
|
|
|
- this.rebufferNotice = -1;
|
|
|
- return _bestLevel;
|
|
|
- }
|
|
|
- }
|
|
|
- let maxStarvationDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxStarvationDelay) : config.maxStarvationDelay;
|
|
|
- if (!bufferStarvationDelay) {
|
|
|
- const bitrateTestDelay = this.bitrateTestDelay;
|
|
|
- if (bitrateTestDelay) {
|
|
|
- const maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
|
|
|
- maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
|
|
|
- this.info(`bitrate test took ${Math.round(1e3 * bitrateTestDelay)}ms, set first fragment max fetchDuration to ${Math.round(1e3 * maxStarvationDelay)} ms`);
|
|
|
- bwFactor = bwUpFactor = 1;
|
|
|
- }
|
|
|
- }
|
|
|
- const bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, maxStarvationDelay, bwFactor, bwUpFactor);
|
|
|
- if (this.rebufferNotice !== bestLevel) {
|
|
|
- this.rebufferNotice = bestLevel;
|
|
|
- this.info(`${bufferStarvationDelay ? "rebuffering expected" : "buffer is empty"}, optimal quality level ${bestLevel}`);
|
|
|
- }
|
|
|
- if (bestLevel > -1) {
|
|
|
- return bestLevel;
|
|
|
- }
|
|
|
- const minLevel = hls.levels[minAutoLevel];
|
|
|
- const autoLevel = hls.loadLevelObj;
|
|
|
- if (autoLevel && (minLevel == null ? void 0 : minLevel.bitrate) < autoLevel.bitrate) {
|
|
|
- return minAutoLevel;
|
|
|
- }
|
|
|
- return hls.loadLevel;
|
|
|
- }
|
|
|
- getStarvationDelay() {
|
|
|
- const hls = this.hls;
|
|
|
- const media = hls.media;
|
|
|
- if (!media) {
|
|
|
- return Infinity;
|
|
|
- }
|
|
|
- const playbackRate = media && media.playbackRate !== 0 ? Math.abs(media.playbackRate) : 1;
|
|
|
- const bufferInfo = hls.mainForwardBufferInfo;
|
|
|
- return (bufferInfo ? bufferInfo.len : 0) / playbackRate;
|
|
|
- }
|
|
|
- getBwEstimate() {
|
|
|
- return this.bwEstimator.canEstimate() ? this.bwEstimator.getEstimate() : this.hls.config.abrEwmaDefaultEstimate;
|
|
|
- }
|
|
|
- findBestLevel(currentBw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, maxStarvationDelay, bwFactor, bwUpFactor) {
|
|
|
- var _this$hls$latestLevel;
|
|
|
- const maxFetchDuration = bufferStarvationDelay + maxStarvationDelay;
|
|
|
- const lastLoadedFragLevel = this.lastLoadedFragLevel;
|
|
|
- const selectionBaseLevel = lastLoadedFragLevel === -1 ? this.hls.firstLevel : lastLoadedFragLevel;
|
|
|
- const {
|
|
|
- fragCurrent,
|
|
|
- partCurrent
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- levels,
|
|
|
- allAudioTracks,
|
|
|
- loadLevel,
|
|
|
- config
|
|
|
- } = this.hls;
|
|
|
- if (levels.length === 1) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const level = levels[selectionBaseLevel];
|
|
|
- const live = !!((_this$hls$latestLevel = this.hls.latestLevelDetails) != null && _this$hls$latestLevel.live);
|
|
|
- const firstSelection = loadLevel === -1 || lastLoadedFragLevel === -1;
|
|
|
- let currentCodecSet;
|
|
|
- let currentVideoRange = "SDR";
|
|
|
- let currentFrameRate = (level == null ? void 0 : level.frameRate) || 0;
|
|
|
- const {
|
|
|
- audioPreference,
|
|
|
- videoPreference
|
|
|
- } = config;
|
|
|
- const audioTracksByGroup = this.audioTracksByGroup || (this.audioTracksByGroup = getAudioTracksByGroup(allAudioTracks));
|
|
|
- let minStartIndex = -1;
|
|
|
- if (firstSelection) {
|
|
|
- if (this.firstSelection !== -1) {
|
|
|
- return this.firstSelection;
|
|
|
- }
|
|
|
- const codecTiers = this.codecTiers || (this.codecTiers = getCodecTiers(levels, audioTracksByGroup, minAutoLevel, maxAutoLevel));
|
|
|
- const startTier = getStartCodecTier(codecTiers, currentVideoRange, currentBw, audioPreference, videoPreference);
|
|
|
- const {
|
|
|
- codecSet,
|
|
|
- videoRanges,
|
|
|
- minFramerate,
|
|
|
- minBitrate,
|
|
|
- minIndex,
|
|
|
- preferHDR
|
|
|
- } = startTier;
|
|
|
- minStartIndex = minIndex;
|
|
|
- currentCodecSet = codecSet;
|
|
|
- currentVideoRange = preferHDR ? videoRanges[videoRanges.length - 1] : videoRanges[0];
|
|
|
- currentFrameRate = minFramerate;
|
|
|
- currentBw = Math.max(currentBw, minBitrate);
|
|
|
- this.log(`picked start tier ${stringify(startTier)}`);
|
|
|
- } else {
|
|
|
- currentCodecSet = level == null ? void 0 : level.codecSet;
|
|
|
- currentVideoRange = level == null ? void 0 : level.videoRange;
|
|
|
- }
|
|
|
- const currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
|
|
|
- const ttfbEstimateSec = this.bwEstimator.getEstimateTTFB() / 1e3;
|
|
|
- const levelsSkipped = [];
|
|
|
- for (let i = maxAutoLevel; i >= minAutoLevel; i--) {
|
|
|
- var _levelInfo$supportedR;
|
|
|
- const levelInfo = levels[i];
|
|
|
- const upSwitch = i > selectionBaseLevel;
|
|
|
- if (!levelInfo) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (config.useMediaCapabilities && !levelInfo.supportedResult && !levelInfo.supportedPromise) {
|
|
|
- const mediaCapabilities = navigator.mediaCapabilities;
|
|
|
- if (typeof (mediaCapabilities == null ? void 0 : mediaCapabilities.decodingInfo) === "function" && requiresMediaCapabilitiesDecodingInfo(levelInfo, audioTracksByGroup, currentVideoRange, currentFrameRate, currentBw, audioPreference)) {
|
|
|
- levelInfo.supportedPromise = getMediaDecodingInfoPromise(levelInfo, audioTracksByGroup, mediaCapabilities, this.supportedCache);
|
|
|
- levelInfo.supportedPromise.then((decodingInfo) => {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- levelInfo.supportedResult = decodingInfo;
|
|
|
- const levels2 = this.hls.levels;
|
|
|
- const index = levels2.indexOf(levelInfo);
|
|
|
- if (decodingInfo.error) {
|
|
|
- this.warn(`MediaCapabilities decodingInfo error: "${decodingInfo.error}" for level ${index} ${stringify(decodingInfo)}`);
|
|
|
- } else if (!decodingInfo.supported) {
|
|
|
- this.warn(`Unsupported MediaCapabilities decodingInfo result for level ${index} ${stringify(decodingInfo)}`);
|
|
|
- if (index > -1 && levels2.length > 1) {
|
|
|
- this.log(`Removing unsupported level ${index}`);
|
|
|
- this.hls.removeLevel(index);
|
|
|
- if (this.hls.loadLevel === -1) {
|
|
|
- this.hls.nextLoadLevel = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (decodingInfo.decodingInfoResults.some((info) => info.smooth === false || info.powerEfficient === false)) {
|
|
|
- this.log(`MediaCapabilities decodingInfo for level ${index} not smooth or powerEfficient: ${stringify(decodingInfo)}`);
|
|
|
- }
|
|
|
- }).catch((error) => {
|
|
|
- this.warn(`Error handling MediaCapabilities decodingInfo: ${error}`);
|
|
|
- });
|
|
|
- } else {
|
|
|
- levelInfo.supportedResult = SUPPORTED_INFO_DEFAULT;
|
|
|
- }
|
|
|
- }
|
|
|
- if (currentCodecSet && levelInfo.codecSet !== currentCodecSet || currentVideoRange && levelInfo.videoRange !== currentVideoRange || upSwitch && currentFrameRate > levelInfo.frameRate || !upSwitch && currentFrameRate > 0 && currentFrameRate < levelInfo.frameRate || (_levelInfo$supportedR = levelInfo.supportedResult) != null && (_levelInfo$supportedR = _levelInfo$supportedR.decodingInfoResults) != null && _levelInfo$supportedR.some((info) => info.smooth === false)) {
|
|
|
- if (!firstSelection || i !== minStartIndex) {
|
|
|
- levelsSkipped.push(i);
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
- const levelDetails = levelInfo.details;
|
|
|
- const avgDuration = (partCurrent ? levelDetails == null ? void 0 : levelDetails.partTarget : levelDetails == null ? void 0 : levelDetails.averagetargetduration) || currentFragDuration;
|
|
|
- let adjustedbw;
|
|
|
- if (!upSwitch) {
|
|
|
- adjustedbw = bwFactor * currentBw;
|
|
|
- } else {
|
|
|
- adjustedbw = bwUpFactor * currentBw;
|
|
|
- }
|
|
|
- const bitrate = currentFragDuration && bufferStarvationDelay >= currentFragDuration * 2 && maxStarvationDelay === 0 ? levelInfo.averageBitrate : levelInfo.maxBitrate;
|
|
|
- const fetchDuration = this.getTimeToLoadFrag(ttfbEstimateSec, adjustedbw, bitrate * avgDuration, levelDetails === void 0);
|
|
|
- const canSwitchWithinTolerance = (
|
|
|
- // if adjusted bw is greater than level bitrate AND
|
|
|
- adjustedbw >= bitrate && // no level change, or new level has no error history
|
|
|
- (i === lastLoadedFragLevel || levelInfo.loadError === 0 && levelInfo.fragmentError === 0) && // fragment fetchDuration unknown OR live stream OR fragment fetchDuration less than max allowed fetch duration, then this level matches
|
|
|
- // we don't account for max Fetch Duration for live streams, this is to avoid switching down when near the edge of live sliding window ...
|
|
|
- // special case to support startLevel = -1 (bitrateTest) on live streams : in that case we should not exit loop so that findBestLevel will return -1
|
|
|
- (fetchDuration <= ttfbEstimateSec || !isFiniteNumber(fetchDuration) || live && !this.bitrateTestDelay || fetchDuration < maxFetchDuration)
|
|
|
- );
|
|
|
- if (canSwitchWithinTolerance) {
|
|
|
- const forcedAutoLevel = this.forcedAutoLevel;
|
|
|
- if (i !== loadLevel && (forcedAutoLevel === -1 || forcedAutoLevel !== loadLevel)) {
|
|
|
- if (levelsSkipped.length) {
|
|
|
- this.trace(`Skipped level(s) ${levelsSkipped.join(",")} of ${maxAutoLevel} max with CODECS and VIDEO-RANGE:"${levels[levelsSkipped[0]].codecs}" ${levels[levelsSkipped[0]].videoRange}; not compatible with "${currentCodecSet}" ${currentVideoRange}`);
|
|
|
- }
|
|
|
- this.info(`switch candidate:${selectionBaseLevel}->${i} adjustedbw(${Math.round(adjustedbw)})-bitrate=${Math.round(adjustedbw - bitrate)} ttfb:${ttfbEstimateSec.toFixed(1)} avgDuration:${avgDuration.toFixed(1)} maxFetchDuration:${maxFetchDuration.toFixed(1)} fetchDuration:${fetchDuration.toFixed(1)} firstSelection:${firstSelection} codecSet:${levelInfo.codecSet} videoRange:${levelInfo.videoRange} hls.loadLevel:${loadLevel}`);
|
|
|
- }
|
|
|
- if (firstSelection) {
|
|
|
- this.firstSelection = i;
|
|
|
- }
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- set nextAutoLevel(nextLevel) {
|
|
|
- const value = this.deriveNextAutoLevel(nextLevel);
|
|
|
- if (this._nextAutoLevel !== value) {
|
|
|
- this.nextAutoLevelKey = "";
|
|
|
- this._nextAutoLevel = value;
|
|
|
- }
|
|
|
- }
|
|
|
- deriveNextAutoLevel(nextLevel) {
|
|
|
- const {
|
|
|
- maxAutoLevel,
|
|
|
- minAutoLevel
|
|
|
- } = this.hls;
|
|
|
- return Math.min(Math.max(nextLevel, minAutoLevel), maxAutoLevel);
|
|
|
- }
|
|
|
-};
|
|
|
-var BinarySearch = {
|
|
|
- /**
|
|
|
- * Searches for an item in an array which matches a certain condition.
|
|
|
- * This requires the condition to only match one item in the array,
|
|
|
- * and for the array to be ordered.
|
|
|
- *
|
|
|
- * @param list The array to search.
|
|
|
- * @param comparisonFn
|
|
|
- * Called and provided a candidate item as the first argument.
|
|
|
- * Should return:
|
|
|
- * > -1 if the item should be located at a lower index than the provided item.
|
|
|
- * > 1 if the item should be located at a higher index than the provided item.
|
|
|
- * > 0 if the item is the item you're looking for.
|
|
|
- *
|
|
|
- * @returns the object if found, otherwise returns null
|
|
|
- */
|
|
|
- search: function(list, comparisonFn) {
|
|
|
- let minIndex = 0;
|
|
|
- let maxIndex = list.length - 1;
|
|
|
- let currentIndex = null;
|
|
|
- let currentElement = null;
|
|
|
- while (minIndex <= maxIndex) {
|
|
|
- currentIndex = (minIndex + maxIndex) / 2 | 0;
|
|
|
- currentElement = list[currentIndex];
|
|
|
- const comparisonResult = comparisonFn(currentElement);
|
|
|
- if (comparisonResult > 0) {
|
|
|
- minIndex = currentIndex + 1;
|
|
|
- } else if (comparisonResult < 0) {
|
|
|
- maxIndex = currentIndex - 1;
|
|
|
- } else {
|
|
|
- return currentElement;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
-};
|
|
|
-function findFragmentByPDT(fragments, PDTValue, maxFragLookUpTolerance) {
|
|
|
- if (PDTValue === null || !Array.isArray(fragments) || !fragments.length || !isFiniteNumber(PDTValue)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const startPDT = fragments[0].programDateTime;
|
|
|
- if (PDTValue < (startPDT || 0)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const endPDT = fragments[fragments.length - 1].endProgramDateTime;
|
|
|
- if (PDTValue >= (endPDT || 0)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- for (let seg = 0; seg < fragments.length; ++seg) {
|
|
|
- const frag = fragments[seg];
|
|
|
- if (pdtWithinToleranceTest(PDTValue, maxFragLookUpTolerance, frag)) {
|
|
|
- return frag;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function findFragmentByPTS(fragPrevious, fragments, bufferEnd = 0, maxFragLookUpTolerance = 0, nextFragLookupTolerance = 5e-3) {
|
|
|
- let fragNext = null;
|
|
|
- if (fragPrevious) {
|
|
|
- fragNext = fragments[1 + fragPrevious.sn - fragments[0].sn] || null;
|
|
|
- const bufferEdgeError = fragPrevious.endDTS - bufferEnd;
|
|
|
- if (bufferEdgeError > 0 && bufferEdgeError < 15e-7) {
|
|
|
- bufferEnd += 15e-7;
|
|
|
- }
|
|
|
- if (fragNext && fragPrevious.level !== fragNext.level && fragNext.end <= fragPrevious.end) {
|
|
|
- fragNext = fragments[2 + fragPrevious.sn - fragments[0].sn] || null;
|
|
|
- }
|
|
|
- } else if (bufferEnd === 0 && fragments[0].start === 0) {
|
|
|
- fragNext = fragments[0];
|
|
|
- }
|
|
|
- if (fragNext && ((!fragPrevious || fragPrevious.level === fragNext.level) && fragmentWithinToleranceTest(bufferEnd, maxFragLookUpTolerance, fragNext) === 0 || fragmentWithinFastStartSwitch(fragNext, fragPrevious, Math.min(nextFragLookupTolerance, maxFragLookUpTolerance)))) {
|
|
|
- return fragNext;
|
|
|
- }
|
|
|
- const foundFragment = BinarySearch.search(fragments, fragmentWithinToleranceTest.bind(null, bufferEnd, maxFragLookUpTolerance));
|
|
|
- if (foundFragment && (foundFragment !== fragPrevious || !fragNext)) {
|
|
|
- return foundFragment;
|
|
|
- }
|
|
|
- return fragNext;
|
|
|
-}
|
|
|
-function fragmentWithinFastStartSwitch(fragNext, fragPrevious, nextFragLookupTolerance) {
|
|
|
- if (fragPrevious && fragPrevious.start === 0 && fragPrevious.level < fragNext.level && (fragPrevious.endPTS || 0) > 0) {
|
|
|
- const firstDuration = fragPrevious.tagList.reduce((duration, tag) => {
|
|
|
- if (tag[0] === "INF") {
|
|
|
- duration += parseFloat(tag[1]);
|
|
|
- }
|
|
|
- return duration;
|
|
|
- }, nextFragLookupTolerance);
|
|
|
- return fragNext.start <= firstDuration;
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function fragmentWithinToleranceTest(bufferEnd = 0, maxFragLookUpTolerance = 0, candidate) {
|
|
|
- if (candidate.start <= bufferEnd && candidate.start + candidate.duration > bufferEnd) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const candidateLookupTolerance = Math.min(maxFragLookUpTolerance, candidate.duration + (candidate.deltaPTS ? candidate.deltaPTS : 0));
|
|
|
- if (candidate.start + candidate.duration - candidateLookupTolerance <= bufferEnd) {
|
|
|
- return 1;
|
|
|
- } else if (candidate.start - candidateLookupTolerance > bufferEnd && candidate.start) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-function pdtWithinToleranceTest(pdtBufferEnd, maxFragLookUpTolerance, candidate) {
|
|
|
- const candidateLookupTolerance = Math.min(maxFragLookUpTolerance, candidate.duration + (candidate.deltaPTS ? candidate.deltaPTS : 0)) * 1e3;
|
|
|
- const endProgramDateTime = candidate.endProgramDateTime || 0;
|
|
|
- return endProgramDateTime - candidateLookupTolerance > pdtBufferEnd;
|
|
|
-}
|
|
|
-function findNearestWithCC(details, cc, pos) {
|
|
|
- if (details) {
|
|
|
- if (details.startCC <= cc && details.endCC >= cc) {
|
|
|
- let fragments = details.fragments;
|
|
|
- const {
|
|
|
- fragmentHint
|
|
|
- } = details;
|
|
|
- if (fragmentHint) {
|
|
|
- fragments = fragments.concat(fragmentHint);
|
|
|
- }
|
|
|
- let closest;
|
|
|
- BinarySearch.search(fragments, (candidate) => {
|
|
|
- if (candidate.cc < cc) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- if (candidate.cc > cc) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- closest = candidate;
|
|
|
- if (candidate.end <= pos) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- if (candidate.start > pos) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- });
|
|
|
- return closest || null;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function isTimeoutError(error) {
|
|
|
- switch (error.details) {
|
|
|
- case ErrorDetails.FRAG_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.KEY_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.LEVEL_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.MANIFEST_LOAD_TIMEOUT:
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function isKeyError(error) {
|
|
|
- return error.details.startsWith("key");
|
|
|
-}
|
|
|
-function isUnusableKeyError(error) {
|
|
|
- return isKeyError(error) && !!error.frag && !error.frag.decryptdata;
|
|
|
-}
|
|
|
-function getRetryConfig(loadPolicy, error) {
|
|
|
- const isTimeout = isTimeoutError(error);
|
|
|
- return loadPolicy.default[`${isTimeout ? "timeout" : "error"}Retry`];
|
|
|
-}
|
|
|
-function getRetryDelay(retryConfig, retryCount) {
|
|
|
- const backoffFactor = retryConfig.backoff === "linear" ? 1 : Math.pow(2, retryCount);
|
|
|
- return Math.min(backoffFactor * retryConfig.retryDelayMs, retryConfig.maxRetryDelayMs);
|
|
|
-}
|
|
|
-function getLoaderConfigWithoutReties(loderConfig) {
|
|
|
- return _objectSpread2(_objectSpread2({}, loderConfig), {
|
|
|
- errorRetry: null,
|
|
|
- timeoutRetry: null
|
|
|
- });
|
|
|
-}
|
|
|
-function shouldRetry(retryConfig, retryCount, isTimeout, loaderResponse) {
|
|
|
- if (!retryConfig) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const httpStatus = loaderResponse == null ? void 0 : loaderResponse.code;
|
|
|
- const retry = retryCount < retryConfig.maxNumRetry && (retryForHttpStatus(httpStatus) || !!isTimeout);
|
|
|
- return retryConfig.shouldRetry ? retryConfig.shouldRetry(retryConfig, retryCount, isTimeout, loaderResponse, retry) : retry;
|
|
|
-}
|
|
|
-function retryForHttpStatus(httpStatus) {
|
|
|
- return offlineHttpStatus(httpStatus) || !!httpStatus && (httpStatus < 400 || httpStatus > 499);
|
|
|
-}
|
|
|
-function offlineHttpStatus(httpStatus) {
|
|
|
- return httpStatus === 0 && navigator.onLine === false;
|
|
|
-}
|
|
|
-var NetworkErrorAction = {
|
|
|
- DoNothing: 0,
|
|
|
- SendEndCallback: 1,
|
|
|
- SendAlternateToPenaltyBox: 2,
|
|
|
- RemoveAlternatePermanently: 3,
|
|
|
- InsertDiscontinuity: 4,
|
|
|
- RetryRequest: 5
|
|
|
-};
|
|
|
-var ErrorActionFlags = {
|
|
|
- None: 0,
|
|
|
- MoveAllAlternatesMatchingHost: 1,
|
|
|
- MoveAllAlternatesMatchingHDCP: 2,
|
|
|
- MoveAllAlternatesMatchingKey: 4,
|
|
|
- SwitchToSDR: 8
|
|
|
-};
|
|
|
-var ErrorController = class extends Logger {
|
|
|
- constructor(hls) {
|
|
|
- super("error-controller", hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.playlistError = 0;
|
|
|
- this.hls = hls;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- hls.off(Events.ERROR, this.onErrorOut, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.hls = null;
|
|
|
- }
|
|
|
- startLoad(startPosition) {
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- this.playlistError = 0;
|
|
|
- }
|
|
|
- getVariantLevelIndex(frag) {
|
|
|
- if ((frag == null ? void 0 : frag.type) === PlaylistLevelType.MAIN) {
|
|
|
- return frag.level;
|
|
|
- }
|
|
|
- return this.getVariantIndex();
|
|
|
- }
|
|
|
- getVariantIndex() {
|
|
|
- var _hls$loadLevelObj;
|
|
|
- const hls = this.hls;
|
|
|
- const currentLevel = hls.currentLevel;
|
|
|
- if ((_hls$loadLevelObj = hls.loadLevelObj) != null && _hls$loadLevelObj.details || currentLevel === -1) {
|
|
|
- return hls.loadLevel;
|
|
|
- }
|
|
|
- return currentLevel;
|
|
|
- }
|
|
|
- variantHasKey(level, keyInError) {
|
|
|
- if (level) {
|
|
|
- var _level$details;
|
|
|
- if ((_level$details = level.details) != null && _level$details.hasKey(keyInError)) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- const audioGroupsIds = level.audioGroups;
|
|
|
- if (audioGroupsIds) {
|
|
|
- const audioTracks = this.hls.allAudioTracks.filter((track) => audioGroupsIds.indexOf(track.groupId) >= 0);
|
|
|
- return audioTracks.some((track) => {
|
|
|
- var _track$details;
|
|
|
- return (_track$details = track.details) == null ? void 0 : _track$details.hasKey(keyInError);
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.playlistError = 0;
|
|
|
- }
|
|
|
- onLevelUpdated() {
|
|
|
- this.playlistError = 0;
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- var _data$frag;
|
|
|
- if (data.fatal) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const hls = this.hls;
|
|
|
- const context = data.context;
|
|
|
- switch (data.details) {
|
|
|
- case ErrorDetails.FRAG_LOAD_ERROR:
|
|
|
- case ErrorDetails.FRAG_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.KEY_LOAD_ERROR:
|
|
|
- case ErrorDetails.KEY_LOAD_TIMEOUT:
|
|
|
- data.errorAction = this.getFragRetryOrSwitchAction(data);
|
|
|
- return;
|
|
|
- case ErrorDetails.FRAG_PARSING_ERROR:
|
|
|
- if ((_data$frag = data.frag) != null && _data$frag.gap) {
|
|
|
- data.errorAction = createDoNothingErrorAction();
|
|
|
- return;
|
|
|
- }
|
|
|
- case ErrorDetails.FRAG_GAP:
|
|
|
- case ErrorDetails.FRAG_DECRYPT_ERROR: {
|
|
|
- data.errorAction = this.getFragRetryOrSwitchAction(data);
|
|
|
- data.errorAction.action = NetworkErrorAction.SendAlternateToPenaltyBox;
|
|
|
- return;
|
|
|
- }
|
|
|
- case ErrorDetails.LEVEL_EMPTY_ERROR:
|
|
|
- case ErrorDetails.LEVEL_PARSING_ERROR:
|
|
|
- {
|
|
|
- var _data$context;
|
|
|
- const levelIndex = data.parent === PlaylistLevelType.MAIN ? data.level : hls.loadLevel;
|
|
|
- if (data.details === ErrorDetails.LEVEL_EMPTY_ERROR && !!((_data$context = data.context) != null && (_data$context = _data$context.levelDetails) != null && _data$context.live)) {
|
|
|
- data.errorAction = this.getPlaylistRetryOrSwitchAction(data, levelIndex);
|
|
|
- } else {
|
|
|
- data.levelRetry = false;
|
|
|
- data.errorAction = this.getLevelSwitchAction(data, levelIndex);
|
|
|
- }
|
|
|
- }
|
|
|
- return;
|
|
|
- case ErrorDetails.LEVEL_LOAD_ERROR:
|
|
|
- case ErrorDetails.LEVEL_LOAD_TIMEOUT:
|
|
|
- if (typeof (context == null ? void 0 : context.level) === "number") {
|
|
|
- data.errorAction = this.getPlaylistRetryOrSwitchAction(data, context.level);
|
|
|
- }
|
|
|
- return;
|
|
|
- case ErrorDetails.AUDIO_TRACK_LOAD_ERROR:
|
|
|
- case ErrorDetails.AUDIO_TRACK_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.SUBTITLE_LOAD_ERROR:
|
|
|
- case ErrorDetails.SUBTITLE_TRACK_LOAD_TIMEOUT:
|
|
|
- if (context) {
|
|
|
- const level = hls.loadLevelObj;
|
|
|
- if (level && (context.type === PlaylistContextType.AUDIO_TRACK && level.hasAudioGroup(context.groupId) || context.type === PlaylistContextType.SUBTITLE_TRACK && level.hasSubtitleGroup(context.groupId))) {
|
|
|
- data.errorAction = this.getPlaylistRetryOrSwitchAction(data, hls.loadLevel);
|
|
|
- data.errorAction.action = NetworkErrorAction.SendAlternateToPenaltyBox;
|
|
|
- data.errorAction.flags = ErrorActionFlags.MoveAllAlternatesMatchingHost;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- return;
|
|
|
- case ErrorDetails.KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED:
|
|
|
- {
|
|
|
- data.errorAction = {
|
|
|
- action: NetworkErrorAction.SendAlternateToPenaltyBox,
|
|
|
- flags: ErrorActionFlags.MoveAllAlternatesMatchingHDCP
|
|
|
- };
|
|
|
- }
|
|
|
- return;
|
|
|
- case ErrorDetails.KEY_SYSTEM_SESSION_UPDATE_FAILED:
|
|
|
- case ErrorDetails.KEY_SYSTEM_STATUS_INTERNAL_ERROR:
|
|
|
- case ErrorDetails.KEY_SYSTEM_NO_SESSION:
|
|
|
- {
|
|
|
- data.errorAction = {
|
|
|
- action: NetworkErrorAction.SendAlternateToPenaltyBox,
|
|
|
- flags: ErrorActionFlags.MoveAllAlternatesMatchingKey
|
|
|
- };
|
|
|
- }
|
|
|
- return;
|
|
|
- case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
|
|
|
- case ErrorDetails.REMUX_ALLOC_ERROR:
|
|
|
- case ErrorDetails.BUFFER_APPEND_ERROR:
|
|
|
- if (!data.errorAction) {
|
|
|
- var _data$level;
|
|
|
- data.errorAction = this.getLevelSwitchAction(data, (_data$level = data.level) != null ? _data$level : hls.loadLevel);
|
|
|
- }
|
|
|
- return;
|
|
|
- case ErrorDetails.INTERNAL_EXCEPTION:
|
|
|
- case ErrorDetails.BUFFER_APPENDING_ERROR:
|
|
|
- case ErrorDetails.BUFFER_FULL_ERROR:
|
|
|
- case ErrorDetails.LEVEL_SWITCH_ERROR:
|
|
|
- case ErrorDetails.BUFFER_STALLED_ERROR:
|
|
|
- case ErrorDetails.BUFFER_SEEK_OVER_HOLE:
|
|
|
- case ErrorDetails.BUFFER_NUDGE_ON_STALL:
|
|
|
- data.errorAction = createDoNothingErrorAction();
|
|
|
- return;
|
|
|
- }
|
|
|
- if (data.type === ErrorTypes.KEY_SYSTEM_ERROR) {
|
|
|
- data.levelRetry = false;
|
|
|
- data.errorAction = createDoNothingErrorAction();
|
|
|
- }
|
|
|
- }
|
|
|
- getPlaylistRetryOrSwitchAction(data, levelIndex) {
|
|
|
- const hls = this.hls;
|
|
|
- const retryConfig = getRetryConfig(hls.config.playlistLoadPolicy, data);
|
|
|
- const retryCount = this.playlistError++;
|
|
|
- const retry = shouldRetry(retryConfig, retryCount, isTimeoutError(data), data.response);
|
|
|
- if (retry) {
|
|
|
- return {
|
|
|
- action: NetworkErrorAction.RetryRequest,
|
|
|
- flags: ErrorActionFlags.None,
|
|
|
- retryConfig,
|
|
|
- retryCount
|
|
|
- };
|
|
|
- }
|
|
|
- const errorAction = this.getLevelSwitchAction(data, levelIndex);
|
|
|
- if (retryConfig) {
|
|
|
- errorAction.retryConfig = retryConfig;
|
|
|
- errorAction.retryCount = retryCount;
|
|
|
- }
|
|
|
- return errorAction;
|
|
|
- }
|
|
|
- getFragRetryOrSwitchAction(data) {
|
|
|
- const hls = this.hls;
|
|
|
- const variantLevelIndex = this.getVariantLevelIndex(data.frag);
|
|
|
- const level = hls.levels[variantLevelIndex];
|
|
|
- const {
|
|
|
- fragLoadPolicy,
|
|
|
- keyLoadPolicy
|
|
|
- } = hls.config;
|
|
|
- const retryConfig = getRetryConfig(isKeyError(data) ? keyLoadPolicy : fragLoadPolicy, data);
|
|
|
- const fragmentErrors = hls.levels.reduce((acc, level2) => acc + level2.fragmentError, 0);
|
|
|
- if (level) {
|
|
|
- if (data.details !== ErrorDetails.FRAG_GAP) {
|
|
|
- level.fragmentError++;
|
|
|
- }
|
|
|
- if (!isUnusableKeyError(data)) {
|
|
|
- const retry = shouldRetry(retryConfig, fragmentErrors, isTimeoutError(data), data.response);
|
|
|
- if (retry) {
|
|
|
- return {
|
|
|
- action: NetworkErrorAction.RetryRequest,
|
|
|
- flags: ErrorActionFlags.None,
|
|
|
- retryConfig,
|
|
|
- retryCount: fragmentErrors
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const errorAction = this.getLevelSwitchAction(data, variantLevelIndex);
|
|
|
- if (retryConfig) {
|
|
|
- errorAction.retryConfig = retryConfig;
|
|
|
- errorAction.retryCount = fragmentErrors;
|
|
|
- }
|
|
|
- return errorAction;
|
|
|
- }
|
|
|
- getLevelSwitchAction(data, levelIndex) {
|
|
|
- const hls = this.hls;
|
|
|
- if (levelIndex === null || levelIndex === void 0) {
|
|
|
- levelIndex = hls.loadLevel;
|
|
|
- }
|
|
|
- const level = this.hls.levels[levelIndex];
|
|
|
- if (level) {
|
|
|
- var _data$frag2, _data$context2;
|
|
|
- const errorDetails = data.details;
|
|
|
- level.loadError++;
|
|
|
- if (errorDetails === ErrorDetails.BUFFER_APPEND_ERROR) {
|
|
|
- level.fragmentError++;
|
|
|
- }
|
|
|
- let nextLevel = -1;
|
|
|
- const {
|
|
|
- levels,
|
|
|
- loadLevel,
|
|
|
- minAutoLevel,
|
|
|
- maxAutoLevel
|
|
|
- } = hls;
|
|
|
- if (!hls.autoLevelEnabled && !hls.config.preserveManualLevelOnError) {
|
|
|
- hls.loadLevel = -1;
|
|
|
- }
|
|
|
- const fragErrorType = (_data$frag2 = data.frag) == null ? void 0 : _data$frag2.type;
|
|
|
- const isAudioCodecError = fragErrorType === PlaylistLevelType.AUDIO && errorDetails === ErrorDetails.FRAG_PARSING_ERROR || data.sourceBufferName === "audio" && (errorDetails === ErrorDetails.BUFFER_ADD_CODEC_ERROR || errorDetails === ErrorDetails.BUFFER_APPEND_ERROR);
|
|
|
- const findAudioCodecAlternate = isAudioCodecError && levels.some(({
|
|
|
- audioCodec
|
|
|
- }) => level.audioCodec !== audioCodec);
|
|
|
- const isVideoCodecError = data.sourceBufferName === "video" && (errorDetails === ErrorDetails.BUFFER_ADD_CODEC_ERROR || errorDetails === ErrorDetails.BUFFER_APPEND_ERROR);
|
|
|
- const findVideoCodecAlternate = isVideoCodecError && levels.some(({
|
|
|
- codecSet,
|
|
|
- audioCodec
|
|
|
- }) => level.codecSet !== codecSet && level.audioCodec === audioCodec);
|
|
|
- const {
|
|
|
- type: playlistErrorType,
|
|
|
- groupId: playlistErrorGroupId
|
|
|
- } = (_data$context2 = data.context) != null ? _data$context2 : {};
|
|
|
- for (let i = levels.length; i--; ) {
|
|
|
- const candidate = (i + loadLevel) % levels.length;
|
|
|
- if (candidate !== loadLevel && candidate >= minAutoLevel && candidate <= maxAutoLevel && levels[candidate].loadError === 0) {
|
|
|
- var _level$audioGroups, _level$subtitleGroups;
|
|
|
- const levelCandidate = levels[candidate];
|
|
|
- if (errorDetails === ErrorDetails.FRAG_GAP && fragErrorType === PlaylistLevelType.MAIN && data.frag) {
|
|
|
- const levelDetails = levels[candidate].details;
|
|
|
- if (levelDetails) {
|
|
|
- const fragCandidate = findFragmentByPTS(data.frag, levelDetails.fragments, data.frag.start);
|
|
|
- if (fragCandidate != null && fragCandidate.gap) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (playlistErrorType === PlaylistContextType.AUDIO_TRACK && levelCandidate.hasAudioGroup(playlistErrorGroupId) || playlistErrorType === PlaylistContextType.SUBTITLE_TRACK && levelCandidate.hasSubtitleGroup(playlistErrorGroupId)) {
|
|
|
- continue;
|
|
|
- } else if (fragErrorType === PlaylistLevelType.AUDIO && (_level$audioGroups = level.audioGroups) != null && _level$audioGroups.some((groupId) => levelCandidate.hasAudioGroup(groupId)) || fragErrorType === PlaylistLevelType.SUBTITLE && (_level$subtitleGroups = level.subtitleGroups) != null && _level$subtitleGroups.some((groupId) => levelCandidate.hasSubtitleGroup(groupId)) || findAudioCodecAlternate && level.audioCodec === levelCandidate.audioCodec || findVideoCodecAlternate && level.codecSet === levelCandidate.codecSet || !findAudioCodecAlternate && level.codecSet !== levelCandidate.codecSet) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- nextLevel = candidate;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (nextLevel > -1 && hls.loadLevel !== nextLevel) {
|
|
|
- data.levelRetry = true;
|
|
|
- this.playlistError = 0;
|
|
|
- return {
|
|
|
- action: NetworkErrorAction.SendAlternateToPenaltyBox,
|
|
|
- flags: ErrorActionFlags.None,
|
|
|
- nextAutoLevel: nextLevel
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- action: NetworkErrorAction.SendAlternateToPenaltyBox,
|
|
|
- flags: ErrorActionFlags.MoveAllAlternatesMatchingHost
|
|
|
- };
|
|
|
- }
|
|
|
- onErrorOut(event, data) {
|
|
|
- var _data$errorAction;
|
|
|
- switch ((_data$errorAction = data.errorAction) == null ? void 0 : _data$errorAction.action) {
|
|
|
- case NetworkErrorAction.DoNothing:
|
|
|
- break;
|
|
|
- case NetworkErrorAction.SendAlternateToPenaltyBox:
|
|
|
- this.sendAlternateToPenaltyBox(data);
|
|
|
- if (!data.errorAction.resolved && data.details !== ErrorDetails.FRAG_GAP) {
|
|
|
- data.fatal = true;
|
|
|
- } else if (/MediaSource readyState: ended/.test(data.error.message)) {
|
|
|
- this.warn(`MediaSource ended after "${data.sourceBufferName}" sourceBuffer append error. Attempting to recover from media error.`);
|
|
|
- this.hls.recoverMediaError();
|
|
|
- }
|
|
|
- break;
|
|
|
- case NetworkErrorAction.RetryRequest:
|
|
|
- break;
|
|
|
- }
|
|
|
- if (data.fatal) {
|
|
|
- this.hls.stopLoad();
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- sendAlternateToPenaltyBox(data) {
|
|
|
- const hls = this.hls;
|
|
|
- const errorAction = data.errorAction;
|
|
|
- if (!errorAction) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- flags
|
|
|
- } = errorAction;
|
|
|
- const nextAutoLevel = errorAction.nextAutoLevel;
|
|
|
- switch (flags) {
|
|
|
- case ErrorActionFlags.None:
|
|
|
- this.switchLevel(data, nextAutoLevel);
|
|
|
- break;
|
|
|
- case ErrorActionFlags.MoveAllAlternatesMatchingHDCP: {
|
|
|
- const levelIndex = this.getVariantLevelIndex(data.frag);
|
|
|
- const level = hls.levels[levelIndex];
|
|
|
- const restrictedHdcpLevel = level == null ? void 0 : level.attrs["HDCP-LEVEL"];
|
|
|
- errorAction.hdcpLevel = restrictedHdcpLevel;
|
|
|
- if (restrictedHdcpLevel === "NONE") {
|
|
|
- this.warn(`HDCP policy resticted output with HDCP-LEVEL=NONE`);
|
|
|
- } else if (restrictedHdcpLevel) {
|
|
|
- hls.maxHdcpLevel = HdcpLevels[HdcpLevels.indexOf(restrictedHdcpLevel) - 1];
|
|
|
- errorAction.resolved = true;
|
|
|
- this.warn(`Restricting playback to HDCP-LEVEL of "${hls.maxHdcpLevel}" or lower`);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- case ErrorActionFlags.MoveAllAlternatesMatchingKey: {
|
|
|
- const levelKey = data.decryptdata;
|
|
|
- if (levelKey) {
|
|
|
- const levels = this.hls.levels;
|
|
|
- const levelCountWithError = levels.length;
|
|
|
- for (let i = levelCountWithError; i--; ) {
|
|
|
- if (this.variantHasKey(levels[i], levelKey)) {
|
|
|
- var _levels$i$audioGroups, _data$frag3;
|
|
|
- this.log(`Banned key found in level ${i} (${levels[i].bitrate}bps) or audio group "${(_levels$i$audioGroups = levels[i].audioGroups) == null ? void 0 : _levels$i$audioGroups.join(",")}" (${(_data$frag3 = data.frag) == null ? void 0 : _data$frag3.type} fragment) ${arrayToHex(levelKey.keyId || [])}`);
|
|
|
- levels[i].fragmentError++;
|
|
|
- levels[i].loadError++;
|
|
|
- this.log(`Removing level ${i} with key error (${data.error})`);
|
|
|
- this.hls.removeLevel(i);
|
|
|
- }
|
|
|
- }
|
|
|
- const frag = data.frag;
|
|
|
- if (this.hls.levels.length < levelCountWithError) {
|
|
|
- errorAction.resolved = true;
|
|
|
- } else if (frag && frag.type !== PlaylistLevelType.MAIN) {
|
|
|
- const fragLevelKey = frag.decryptdata;
|
|
|
- if (fragLevelKey && !levelKey.matches(fragLevelKey)) {
|
|
|
- errorAction.resolved = true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!errorAction.resolved) {
|
|
|
- this.switchLevel(data, nextAutoLevel);
|
|
|
- }
|
|
|
- }
|
|
|
- switchLevel(data, levelIndex) {
|
|
|
- if (levelIndex !== void 0 && data.errorAction) {
|
|
|
- this.warn(`switching to level ${levelIndex} after ${data.details}`);
|
|
|
- this.hls.nextAutoLevel = levelIndex;
|
|
|
- data.errorAction.resolved = true;
|
|
|
- this.hls.nextLoadLevel = this.hls.nextAutoLevel;
|
|
|
- if (data.details === ErrorDetails.BUFFER_ADD_CODEC_ERROR && data.mimeType && data.sourceBufferName !== "audiovideo") {
|
|
|
- const codec = getCodecsForMimeType(data.mimeType);
|
|
|
- const levels = this.hls.levels;
|
|
|
- for (let i = levels.length; i--; ) {
|
|
|
- if (levels[i][`${data.sourceBufferName}Codec`] === codec) {
|
|
|
- this.log(`Removing level ${i} for ${data.details} ("${codec}" not supported)`);
|
|
|
- this.hls.removeLevel(i);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function createDoNothingErrorAction(resolved) {
|
|
|
- const errorAction = {
|
|
|
- action: NetworkErrorAction.DoNothing,
|
|
|
- flags: ErrorActionFlags.None
|
|
|
- };
|
|
|
- if (resolved) {
|
|
|
- errorAction.resolved = true;
|
|
|
- }
|
|
|
- return errorAction;
|
|
|
-}
|
|
|
-var FragmentState = {
|
|
|
- NOT_LOADED: "NOT_LOADED",
|
|
|
- APPENDING: "APPENDING",
|
|
|
- PARTIAL: "PARTIAL",
|
|
|
- OK: "OK"
|
|
|
-};
|
|
|
-var FragmentTracker = class {
|
|
|
- constructor(hls) {
|
|
|
- this.activePartLists = /* @__PURE__ */ Object.create(null);
|
|
|
- this.endListFragments = /* @__PURE__ */ Object.create(null);
|
|
|
- this.fragments = /* @__PURE__ */ Object.create(null);
|
|
|
- this.timeRanges = /* @__PURE__ */ Object.create(null);
|
|
|
- this.bufferPadding = 0.2;
|
|
|
- this.hls = void 0;
|
|
|
- this.hasGaps = false;
|
|
|
- this.hls = hls;
|
|
|
- this._registerListeners();
|
|
|
- }
|
|
|
- _registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (hls) {
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.BUFFER_APPENDED, this.onBufferAppended, this);
|
|
|
- hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
|
|
|
- }
|
|
|
- }
|
|
|
- _unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (hls) {
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.BUFFER_APPENDED, this.onBufferAppended, this);
|
|
|
- hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this._unregisterListeners();
|
|
|
- this.hls = // @ts-ignore
|
|
|
- this.fragments = // @ts-ignore
|
|
|
- this.activePartLists = // @ts-ignore
|
|
|
- this.endListFragments = this.timeRanges = null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Return a Fragment or Part with an appended range that matches the position and levelType
|
|
|
- * Otherwise, return null
|
|
|
- */
|
|
|
- getAppendedFrag(position, levelType) {
|
|
|
- const activeParts = this.activePartLists[levelType];
|
|
|
- if (activeParts) {
|
|
|
- for (let i = activeParts.length; i--; ) {
|
|
|
- const activePart = activeParts[i];
|
|
|
- if (!activePart) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if (activePart.start <= position && position <= activePart.end && activePart.loaded) {
|
|
|
- return activePart;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return this.getBufferedFrag(position, levelType);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Return a buffered Fragment that matches the position and levelType.
|
|
|
- * A buffered Fragment is one whose loading, parsing and appending is done (completed or "partial" meaning aborted).
|
|
|
- * If not found any Fragment, return null
|
|
|
- */
|
|
|
- getBufferedFrag(position, levelType) {
|
|
|
- return this.getFragAtPos(position, levelType, true);
|
|
|
- }
|
|
|
- getFragAtPos(position, levelType, buffered) {
|
|
|
- const {
|
|
|
- fragments
|
|
|
- } = this;
|
|
|
- const keys = Object.keys(fragments);
|
|
|
- for (let i = keys.length; i--; ) {
|
|
|
- const fragmentEntity = fragments[keys[i]];
|
|
|
- if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === levelType && (!buffered || fragmentEntity.buffered)) {
|
|
|
- const frag = fragmentEntity.body;
|
|
|
- if (frag.start <= position && position <= frag.end) {
|
|
|
- return frag;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Partial fragments effected by coded frame eviction will be removed
|
|
|
- * The browser will unload parts of the buffer to free up memory for new buffer data
|
|
|
- * Fragments will need to be reloaded when the buffer is freed up, removing partial fragments will allow them to reload(since there might be parts that are still playable)
|
|
|
- */
|
|
|
- detectEvictedFragments(elementaryStream, timeRange, playlistType, appendedPart, removeAppending) {
|
|
|
- if (this.timeRanges) {
|
|
|
- this.timeRanges[elementaryStream] = timeRange;
|
|
|
- }
|
|
|
- const appendedPartSn = (appendedPart == null ? void 0 : appendedPart.fragment.sn) || -1;
|
|
|
- Object.keys(this.fragments).forEach((key) => {
|
|
|
- const fragmentEntity = this.fragments[key];
|
|
|
- if (!fragmentEntity) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (appendedPartSn >= fragmentEntity.body.sn) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!fragmentEntity.buffered && (!fragmentEntity.loaded || removeAppending)) {
|
|
|
- if (fragmentEntity.body.type === playlistType) {
|
|
|
- this.removeFragment(fragmentEntity.body);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- const esData = fragmentEntity.range[elementaryStream];
|
|
|
- if (!esData) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (esData.time.length === 0) {
|
|
|
- this.removeFragment(fragmentEntity.body);
|
|
|
- return;
|
|
|
- }
|
|
|
- esData.time.some((time) => {
|
|
|
- const isNotBuffered = !this.isTimeBuffered(time.startPTS, time.endPTS, timeRange);
|
|
|
- if (isNotBuffered) {
|
|
|
- this.removeFragment(fragmentEntity.body);
|
|
|
- }
|
|
|
- return isNotBuffered;
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- /**
|
|
|
- * Checks if the fragment passed in is loaded in the buffer properly
|
|
|
- * Partially loaded fragments will be registered as a partial fragment
|
|
|
- */
|
|
|
- detectPartialFragments(data) {
|
|
|
- const timeRanges = this.timeRanges;
|
|
|
- if (!timeRanges || data.frag.sn === "initSegment") {
|
|
|
- return;
|
|
|
- }
|
|
|
- const frag = data.frag;
|
|
|
- const fragKey = getFragmentKey(frag);
|
|
|
- const fragmentEntity = this.fragments[fragKey];
|
|
|
- if (!fragmentEntity || fragmentEntity.buffered && frag.gap) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const isFragHint = !frag.relurl;
|
|
|
- Object.keys(timeRanges).forEach((elementaryStream) => {
|
|
|
- const streamInfo = frag.elementaryStreams[elementaryStream];
|
|
|
- if (!streamInfo) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const timeRange = timeRanges[elementaryStream];
|
|
|
- const partial = isFragHint || streamInfo.partial === true;
|
|
|
- fragmentEntity.range[elementaryStream] = this.getBufferedTimes(frag, data.part, partial, timeRange);
|
|
|
- });
|
|
|
- fragmentEntity.loaded = null;
|
|
|
- if (Object.keys(fragmentEntity.range).length) {
|
|
|
- fragmentEntity.buffered = true;
|
|
|
- const endList = fragmentEntity.body.endList = frag.endList || fragmentEntity.body.endList;
|
|
|
- if (endList) {
|
|
|
- this.endListFragments[fragmentEntity.body.type] = fragmentEntity;
|
|
|
- }
|
|
|
- if (!isPartial(fragmentEntity)) {
|
|
|
- this.removeParts(frag.sn - 1, frag.type);
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.removeFragment(fragmentEntity.body);
|
|
|
- }
|
|
|
- }
|
|
|
- removeParts(snToKeep, levelType) {
|
|
|
- const activeParts = this.activePartLists[levelType];
|
|
|
- if (!activeParts) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.activePartLists[levelType] = filterParts(activeParts, (part) => part.fragment.sn >= snToKeep);
|
|
|
- }
|
|
|
- fragBuffered(frag, force) {
|
|
|
- const fragKey = getFragmentKey(frag);
|
|
|
- let fragmentEntity = this.fragments[fragKey];
|
|
|
- if (!fragmentEntity && force) {
|
|
|
- fragmentEntity = this.fragments[fragKey] = {
|
|
|
- body: frag,
|
|
|
- appendedPTS: null,
|
|
|
- loaded: null,
|
|
|
- buffered: false,
|
|
|
- range: /* @__PURE__ */ Object.create(null)
|
|
|
- };
|
|
|
- if (frag.gap) {
|
|
|
- this.hasGaps = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (fragmentEntity) {
|
|
|
- fragmentEntity.loaded = null;
|
|
|
- fragmentEntity.buffered = true;
|
|
|
- }
|
|
|
- }
|
|
|
- getBufferedTimes(fragment, part, partial, timeRange) {
|
|
|
- const buffered = {
|
|
|
- time: [],
|
|
|
- partial
|
|
|
- };
|
|
|
- const startPTS = fragment.start;
|
|
|
- const endPTS = fragment.end;
|
|
|
- const minEndPTS = fragment.minEndPTS || endPTS;
|
|
|
- const maxStartPTS = fragment.maxStartPTS || startPTS;
|
|
|
- for (let i = 0; i < timeRange.length; i++) {
|
|
|
- const startTime = timeRange.start(i) - this.bufferPadding;
|
|
|
- const endTime = timeRange.end(i) + this.bufferPadding;
|
|
|
- if (maxStartPTS >= startTime && minEndPTS <= endTime) {
|
|
|
- buffered.time.push({
|
|
|
- startPTS: Math.max(startPTS, timeRange.start(i)),
|
|
|
- endPTS: Math.min(endPTS, timeRange.end(i))
|
|
|
- });
|
|
|
- break;
|
|
|
- } else if (startPTS < endTime && endPTS > startTime) {
|
|
|
- const start = Math.max(startPTS, timeRange.start(i));
|
|
|
- const end = Math.min(endPTS, timeRange.end(i));
|
|
|
- if (end > start) {
|
|
|
- buffered.partial = true;
|
|
|
- buffered.time.push({
|
|
|
- startPTS: start,
|
|
|
- endPTS: end
|
|
|
- });
|
|
|
- }
|
|
|
- } else if (endPTS <= startTime) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return buffered;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Gets the partial fragment for a certain time
|
|
|
- */
|
|
|
- getPartialFragment(time) {
|
|
|
- let bestFragment = null;
|
|
|
- let timePadding;
|
|
|
- let startTime;
|
|
|
- let endTime;
|
|
|
- let bestOverlap = 0;
|
|
|
- const {
|
|
|
- bufferPadding,
|
|
|
- fragments
|
|
|
- } = this;
|
|
|
- Object.keys(fragments).forEach((key) => {
|
|
|
- const fragmentEntity = fragments[key];
|
|
|
- if (!fragmentEntity) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (isPartial(fragmentEntity)) {
|
|
|
- startTime = fragmentEntity.body.start - bufferPadding;
|
|
|
- endTime = fragmentEntity.body.end + bufferPadding;
|
|
|
- if (time >= startTime && time <= endTime) {
|
|
|
- timePadding = Math.min(time - startTime, endTime - time);
|
|
|
- if (bestOverlap <= timePadding) {
|
|
|
- bestFragment = fragmentEntity.body;
|
|
|
- bestOverlap = timePadding;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- return bestFragment;
|
|
|
- }
|
|
|
- isEndListAppended(type) {
|
|
|
- const lastFragmentEntity = this.endListFragments[type];
|
|
|
- return lastFragmentEntity !== void 0 && (lastFragmentEntity.buffered || isPartial(lastFragmentEntity));
|
|
|
- }
|
|
|
- getState(fragment) {
|
|
|
- const fragKey = getFragmentKey(fragment);
|
|
|
- const fragmentEntity = this.fragments[fragKey];
|
|
|
- if (fragmentEntity) {
|
|
|
- if (!fragmentEntity.buffered) {
|
|
|
- return FragmentState.APPENDING;
|
|
|
- } else if (isPartial(fragmentEntity)) {
|
|
|
- return FragmentState.PARTIAL;
|
|
|
- } else {
|
|
|
- return FragmentState.OK;
|
|
|
- }
|
|
|
- }
|
|
|
- return FragmentState.NOT_LOADED;
|
|
|
- }
|
|
|
- isTimeBuffered(startPTS, endPTS, timeRange) {
|
|
|
- let startTime;
|
|
|
- let endTime;
|
|
|
- for (let i = 0; i < timeRange.length; i++) {
|
|
|
- startTime = timeRange.start(i) - this.bufferPadding;
|
|
|
- endTime = timeRange.end(i) + this.bufferPadding;
|
|
|
- if (startPTS >= startTime && endPTS <= endTime) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (endPTS <= startTime) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.removeAllFragments();
|
|
|
- }
|
|
|
- onFragLoaded(event, data) {
|
|
|
- if (data.frag.sn === "initSegment" || data.frag.bitrateTest) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const frag = data.frag;
|
|
|
- const loaded = data.part ? null : data;
|
|
|
- const fragKey = getFragmentKey(frag);
|
|
|
- this.fragments[fragKey] = {
|
|
|
- body: frag,
|
|
|
- appendedPTS: null,
|
|
|
- loaded,
|
|
|
- buffered: false,
|
|
|
- range: /* @__PURE__ */ Object.create(null)
|
|
|
- };
|
|
|
- }
|
|
|
- onBufferAppended(event, data) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- timeRanges,
|
|
|
- type
|
|
|
- } = data;
|
|
|
- if (frag.sn === "initSegment") {
|
|
|
- return;
|
|
|
- }
|
|
|
- const playlistType = frag.type;
|
|
|
- if (part) {
|
|
|
- let activeParts = this.activePartLists[playlistType];
|
|
|
- if (!activeParts) {
|
|
|
- this.activePartLists[playlistType] = activeParts = [];
|
|
|
- }
|
|
|
- activeParts.push(part);
|
|
|
- }
|
|
|
- this.timeRanges = timeRanges;
|
|
|
- const timeRange = timeRanges[type];
|
|
|
- this.detectEvictedFragments(type, timeRange, playlistType, part);
|
|
|
- }
|
|
|
- onFragBuffered(event, data) {
|
|
|
- this.detectPartialFragments(data);
|
|
|
- }
|
|
|
- hasFragment(fragment) {
|
|
|
- const fragKey = getFragmentKey(fragment);
|
|
|
- return !!this.fragments[fragKey];
|
|
|
- }
|
|
|
- hasFragments(type) {
|
|
|
- const {
|
|
|
- fragments
|
|
|
- } = this;
|
|
|
- const keys = Object.keys(fragments);
|
|
|
- if (!type) {
|
|
|
- return keys.length > 0;
|
|
|
- }
|
|
|
- for (let i = keys.length; i--; ) {
|
|
|
- const fragmentEntity = fragments[keys[i]];
|
|
|
- if ((fragmentEntity == null ? void 0 : fragmentEntity.body.type) === type) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- hasParts(type) {
|
|
|
- var _this$activePartLists;
|
|
|
- return !!((_this$activePartLists = this.activePartLists[type]) != null && _this$activePartLists.length);
|
|
|
- }
|
|
|
- removeFragmentsInRange(start, end, playlistType, withGapOnly, unbufferedOnly) {
|
|
|
- if (withGapOnly && !this.hasGaps) {
|
|
|
- return;
|
|
|
- }
|
|
|
- Object.keys(this.fragments).forEach((key) => {
|
|
|
- const fragmentEntity = this.fragments[key];
|
|
|
- if (!fragmentEntity) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const frag = fragmentEntity.body;
|
|
|
- if (frag.type !== playlistType || withGapOnly && !frag.gap) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (frag.start < end && frag.end > start && (fragmentEntity.buffered || unbufferedOnly)) {
|
|
|
- this.removeFragment(frag);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- removeFragment(fragment) {
|
|
|
- const fragKey = getFragmentKey(fragment);
|
|
|
- fragment.clearElementaryStreamInfo();
|
|
|
- const activeParts = this.activePartLists[fragment.type];
|
|
|
- if (activeParts) {
|
|
|
- const snToRemove = fragment.sn;
|
|
|
- this.activePartLists[fragment.type] = filterParts(activeParts, (part) => part.fragment.sn !== snToRemove);
|
|
|
- }
|
|
|
- delete this.fragments[fragKey];
|
|
|
- if (fragment.endList) {
|
|
|
- delete this.endListFragments[fragment.type];
|
|
|
- }
|
|
|
- }
|
|
|
- removeAllFragments() {
|
|
|
- var _this$hls;
|
|
|
- this.fragments = /* @__PURE__ */ Object.create(null);
|
|
|
- this.endListFragments = /* @__PURE__ */ Object.create(null);
|
|
|
- this.activePartLists = /* @__PURE__ */ Object.create(null);
|
|
|
- this.hasGaps = false;
|
|
|
- const partlist = (_this$hls = this.hls) == null || (_this$hls = _this$hls.latestLevelDetails) == null ? void 0 : _this$hls.partList;
|
|
|
- if (partlist) {
|
|
|
- partlist.forEach((part) => part.clearElementaryStreamInfo());
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function isPartial(fragmentEntity) {
|
|
|
- var _fragmentEntity$range, _fragmentEntity$range2, _fragmentEntity$range3;
|
|
|
- return fragmentEntity.buffered && !!(fragmentEntity.body.gap || (_fragmentEntity$range = fragmentEntity.range.video) != null && _fragmentEntity$range.partial || (_fragmentEntity$range2 = fragmentEntity.range.audio) != null && _fragmentEntity$range2.partial || (_fragmentEntity$range3 = fragmentEntity.range.audiovideo) != null && _fragmentEntity$range3.partial);
|
|
|
-}
|
|
|
-function getFragmentKey(fragment) {
|
|
|
- return `${fragment.type}_${fragment.level}_${fragment.sn}`;
|
|
|
-}
|
|
|
-function filterParts(partList, predicate) {
|
|
|
- return partList.filter((part) => {
|
|
|
- const keep = predicate(part);
|
|
|
- if (!keep) {
|
|
|
- part.clearElementaryStreamInfo();
|
|
|
- }
|
|
|
- return keep;
|
|
|
- });
|
|
|
-}
|
|
|
-var DecrypterAesMode = {
|
|
|
- cbc: 0,
|
|
|
- ctr: 1
|
|
|
-};
|
|
|
-var AESCrypto = class {
|
|
|
- constructor(subtle, iv, aesMode) {
|
|
|
- this.subtle = void 0;
|
|
|
- this.aesIV = void 0;
|
|
|
- this.aesMode = void 0;
|
|
|
- this.subtle = subtle;
|
|
|
- this.aesIV = iv;
|
|
|
- this.aesMode = aesMode;
|
|
|
- }
|
|
|
- decrypt(data, key) {
|
|
|
- switch (this.aesMode) {
|
|
|
- case DecrypterAesMode.cbc:
|
|
|
- return this.subtle.decrypt({
|
|
|
- name: "AES-CBC",
|
|
|
- iv: this.aesIV
|
|
|
- }, key, data);
|
|
|
- case DecrypterAesMode.ctr:
|
|
|
- return this.subtle.decrypt(
|
|
|
- {
|
|
|
- name: "AES-CTR",
|
|
|
- counter: this.aesIV,
|
|
|
- length: 64
|
|
|
- },
|
|
|
- //64 : NIST SP800-38A standard suggests that the counter should occupy half of the counter block
|
|
|
- key,
|
|
|
- data
|
|
|
- );
|
|
|
- default:
|
|
|
- throw new Error(`[AESCrypto] invalid aes mode ${this.aesMode}`);
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function removePadding(array) {
|
|
|
- const outputBytes = array.byteLength;
|
|
|
- const paddingBytes = outputBytes && new DataView(array.buffer).getUint8(outputBytes - 1);
|
|
|
- if (paddingBytes) {
|
|
|
- return array.slice(0, outputBytes - paddingBytes);
|
|
|
- }
|
|
|
- return array;
|
|
|
-}
|
|
|
-var AESDecryptor = class {
|
|
|
- constructor() {
|
|
|
- this.rcon = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
|
|
|
- this.subMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
|
|
|
- this.invSubMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
|
|
|
- this.sBox = new Uint32Array(256);
|
|
|
- this.invSBox = new Uint32Array(256);
|
|
|
- this.key = new Uint32Array(0);
|
|
|
- this.ksRows = 0;
|
|
|
- this.keySize = 0;
|
|
|
- this.keySchedule = void 0;
|
|
|
- this.invKeySchedule = void 0;
|
|
|
- this.initTable();
|
|
|
- }
|
|
|
- // Using view.getUint32() also swaps the byte order.
|
|
|
- uint8ArrayToUint32Array_(arrayBuffer) {
|
|
|
- const view2 = new DataView(arrayBuffer);
|
|
|
- const newArray = new Uint32Array(4);
|
|
|
- for (let i = 0; i < 4; i++) {
|
|
|
- newArray[i] = view2.getUint32(i * 4);
|
|
|
- }
|
|
|
- return newArray;
|
|
|
- }
|
|
|
- initTable() {
|
|
|
- const sBox = this.sBox;
|
|
|
- const invSBox = this.invSBox;
|
|
|
- const subMix = this.subMix;
|
|
|
- const subMix0 = subMix[0];
|
|
|
- const subMix1 = subMix[1];
|
|
|
- const subMix2 = subMix[2];
|
|
|
- const subMix3 = subMix[3];
|
|
|
- const invSubMix = this.invSubMix;
|
|
|
- const invSubMix0 = invSubMix[0];
|
|
|
- const invSubMix1 = invSubMix[1];
|
|
|
- const invSubMix2 = invSubMix[2];
|
|
|
- const invSubMix3 = invSubMix[3];
|
|
|
- const d = new Uint32Array(256);
|
|
|
- let x = 0;
|
|
|
- let xi = 0;
|
|
|
- let i = 0;
|
|
|
- for (i = 0; i < 256; i++) {
|
|
|
- if (i < 128) {
|
|
|
- d[i] = i << 1;
|
|
|
- } else {
|
|
|
- d[i] = i << 1 ^ 283;
|
|
|
- }
|
|
|
- }
|
|
|
- for (i = 0; i < 256; i++) {
|
|
|
- let sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
|
|
|
- sx = sx >>> 8 ^ sx & 255 ^ 99;
|
|
|
- sBox[x] = sx;
|
|
|
- invSBox[sx] = x;
|
|
|
- const x2 = d[x];
|
|
|
- const x4 = d[x2];
|
|
|
- const x8 = d[x4];
|
|
|
- let t = d[sx] * 257 ^ sx * 16843008;
|
|
|
- subMix0[x] = t << 24 | t >>> 8;
|
|
|
- subMix1[x] = t << 16 | t >>> 16;
|
|
|
- subMix2[x] = t << 8 | t >>> 24;
|
|
|
- subMix3[x] = t;
|
|
|
- t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
|
|
|
- invSubMix0[sx] = t << 24 | t >>> 8;
|
|
|
- invSubMix1[sx] = t << 16 | t >>> 16;
|
|
|
- invSubMix2[sx] = t << 8 | t >>> 24;
|
|
|
- invSubMix3[sx] = t;
|
|
|
- if (!x) {
|
|
|
- x = xi = 1;
|
|
|
- } else {
|
|
|
- x = x2 ^ d[d[d[x8 ^ x2]]];
|
|
|
- xi ^= d[d[xi]];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- expandKey(keyBuffer) {
|
|
|
- const key = this.uint8ArrayToUint32Array_(keyBuffer);
|
|
|
- let sameKey = true;
|
|
|
- let offset = 0;
|
|
|
- while (offset < key.length && sameKey) {
|
|
|
- sameKey = key[offset] === this.key[offset];
|
|
|
- offset++;
|
|
|
- }
|
|
|
- if (sameKey) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.key = key;
|
|
|
- const keySize = this.keySize = key.length;
|
|
|
- if (keySize !== 4 && keySize !== 6 && keySize !== 8) {
|
|
|
- throw new Error("Invalid aes key size=" + keySize);
|
|
|
- }
|
|
|
- const ksRows = this.ksRows = (keySize + 6 + 1) * 4;
|
|
|
- let ksRow;
|
|
|
- let invKsRow;
|
|
|
- const keySchedule = this.keySchedule = new Uint32Array(ksRows);
|
|
|
- const invKeySchedule = this.invKeySchedule = new Uint32Array(ksRows);
|
|
|
- const sbox = this.sBox;
|
|
|
- const rcon = this.rcon;
|
|
|
- const invSubMix = this.invSubMix;
|
|
|
- const invSubMix0 = invSubMix[0];
|
|
|
- const invSubMix1 = invSubMix[1];
|
|
|
- const invSubMix2 = invSubMix[2];
|
|
|
- const invSubMix3 = invSubMix[3];
|
|
|
- let prev;
|
|
|
- let t;
|
|
|
- for (ksRow = 0; ksRow < ksRows; ksRow++) {
|
|
|
- if (ksRow < keySize) {
|
|
|
- prev = keySchedule[ksRow] = key[ksRow];
|
|
|
- continue;
|
|
|
- }
|
|
|
- t = prev;
|
|
|
- if (ksRow % keySize === 0) {
|
|
|
- t = t << 8 | t >>> 24;
|
|
|
- t = sbox[t >>> 24] << 24 | sbox[t >>> 16 & 255] << 16 | sbox[t >>> 8 & 255] << 8 | sbox[t & 255];
|
|
|
- t ^= rcon[ksRow / keySize | 0] << 24;
|
|
|
- } else if (keySize > 6 && ksRow % keySize === 4) {
|
|
|
- t = sbox[t >>> 24] << 24 | sbox[t >>> 16 & 255] << 16 | sbox[t >>> 8 & 255] << 8 | sbox[t & 255];
|
|
|
- }
|
|
|
- keySchedule[ksRow] = prev = (keySchedule[ksRow - keySize] ^ t) >>> 0;
|
|
|
- }
|
|
|
- for (invKsRow = 0; invKsRow < ksRows; invKsRow++) {
|
|
|
- ksRow = ksRows - invKsRow;
|
|
|
- if (invKsRow & 3) {
|
|
|
- t = keySchedule[ksRow];
|
|
|
- } else {
|
|
|
- t = keySchedule[ksRow - 4];
|
|
|
- }
|
|
|
- if (invKsRow < 4 || ksRow <= 4) {
|
|
|
- invKeySchedule[invKsRow] = t;
|
|
|
- } else {
|
|
|
- invKeySchedule[invKsRow] = invSubMix0[sbox[t >>> 24]] ^ invSubMix1[sbox[t >>> 16 & 255]] ^ invSubMix2[sbox[t >>> 8 & 255]] ^ invSubMix3[sbox[t & 255]];
|
|
|
- }
|
|
|
- invKeySchedule[invKsRow] = invKeySchedule[invKsRow] >>> 0;
|
|
|
- }
|
|
|
- }
|
|
|
- // Adding this as a method greatly improves performance.
|
|
|
- networkToHostOrderSwap(word) {
|
|
|
- return word << 24 | (word & 65280) << 8 | (word & 16711680) >> 8 | word >>> 24;
|
|
|
- }
|
|
|
- decrypt(inputArrayBuffer, offset, aesIV) {
|
|
|
- const nRounds = this.keySize + 6;
|
|
|
- const invKeySchedule = this.invKeySchedule;
|
|
|
- const invSBOX = this.invSBox;
|
|
|
- const invSubMix = this.invSubMix;
|
|
|
- const invSubMix0 = invSubMix[0];
|
|
|
- const invSubMix1 = invSubMix[1];
|
|
|
- const invSubMix2 = invSubMix[2];
|
|
|
- const invSubMix3 = invSubMix[3];
|
|
|
- const initVector = this.uint8ArrayToUint32Array_(aesIV);
|
|
|
- let initVector0 = initVector[0];
|
|
|
- let initVector1 = initVector[1];
|
|
|
- let initVector2 = initVector[2];
|
|
|
- let initVector3 = initVector[3];
|
|
|
- const inputInt32 = new Int32Array(inputArrayBuffer);
|
|
|
- const outputInt32 = new Int32Array(inputInt32.length);
|
|
|
- let t0, t1, t2, t3;
|
|
|
- let s0, s1, s2, s3;
|
|
|
- let inputWords0, inputWords1, inputWords2, inputWords3;
|
|
|
- let ksRow, i;
|
|
|
- const swapWord = this.networkToHostOrderSwap;
|
|
|
- while (offset < inputInt32.length) {
|
|
|
- inputWords0 = swapWord(inputInt32[offset]);
|
|
|
- inputWords1 = swapWord(inputInt32[offset + 1]);
|
|
|
- inputWords2 = swapWord(inputInt32[offset + 2]);
|
|
|
- inputWords3 = swapWord(inputInt32[offset + 3]);
|
|
|
- s0 = inputWords0 ^ invKeySchedule[0];
|
|
|
- s1 = inputWords3 ^ invKeySchedule[1];
|
|
|
- s2 = inputWords2 ^ invKeySchedule[2];
|
|
|
- s3 = inputWords1 ^ invKeySchedule[3];
|
|
|
- ksRow = 4;
|
|
|
- for (i = 1; i < nRounds; i++) {
|
|
|
- t0 = invSubMix0[s0 >>> 24] ^ invSubMix1[s1 >> 16 & 255] ^ invSubMix2[s2 >> 8 & 255] ^ invSubMix3[s3 & 255] ^ invKeySchedule[ksRow];
|
|
|
- t1 = invSubMix0[s1 >>> 24] ^ invSubMix1[s2 >> 16 & 255] ^ invSubMix2[s3 >> 8 & 255] ^ invSubMix3[s0 & 255] ^ invKeySchedule[ksRow + 1];
|
|
|
- t2 = invSubMix0[s2 >>> 24] ^ invSubMix1[s3 >> 16 & 255] ^ invSubMix2[s0 >> 8 & 255] ^ invSubMix3[s1 & 255] ^ invKeySchedule[ksRow + 2];
|
|
|
- t3 = invSubMix0[s3 >>> 24] ^ invSubMix1[s0 >> 16 & 255] ^ invSubMix2[s1 >> 8 & 255] ^ invSubMix3[s2 & 255] ^ invKeySchedule[ksRow + 3];
|
|
|
- s0 = t0;
|
|
|
- s1 = t1;
|
|
|
- s2 = t2;
|
|
|
- s3 = t3;
|
|
|
- ksRow = ksRow + 4;
|
|
|
- }
|
|
|
- t0 = invSBOX[s0 >>> 24] << 24 ^ invSBOX[s1 >> 16 & 255] << 16 ^ invSBOX[s2 >> 8 & 255] << 8 ^ invSBOX[s3 & 255] ^ invKeySchedule[ksRow];
|
|
|
- t1 = invSBOX[s1 >>> 24] << 24 ^ invSBOX[s2 >> 16 & 255] << 16 ^ invSBOX[s3 >> 8 & 255] << 8 ^ invSBOX[s0 & 255] ^ invKeySchedule[ksRow + 1];
|
|
|
- t2 = invSBOX[s2 >>> 24] << 24 ^ invSBOX[s3 >> 16 & 255] << 16 ^ invSBOX[s0 >> 8 & 255] << 8 ^ invSBOX[s1 & 255] ^ invKeySchedule[ksRow + 2];
|
|
|
- t3 = invSBOX[s3 >>> 24] << 24 ^ invSBOX[s0 >> 16 & 255] << 16 ^ invSBOX[s1 >> 8 & 255] << 8 ^ invSBOX[s2 & 255] ^ invKeySchedule[ksRow + 3];
|
|
|
- outputInt32[offset] = swapWord(t0 ^ initVector0);
|
|
|
- outputInt32[offset + 1] = swapWord(t3 ^ initVector1);
|
|
|
- outputInt32[offset + 2] = swapWord(t2 ^ initVector2);
|
|
|
- outputInt32[offset + 3] = swapWord(t1 ^ initVector3);
|
|
|
- initVector0 = inputWords0;
|
|
|
- initVector1 = inputWords1;
|
|
|
- initVector2 = inputWords2;
|
|
|
- initVector3 = inputWords3;
|
|
|
- offset = offset + 4;
|
|
|
- }
|
|
|
- return outputInt32.buffer;
|
|
|
- }
|
|
|
-};
|
|
|
-var FastAESKey = class {
|
|
|
- constructor(subtle, key, aesMode) {
|
|
|
- this.subtle = void 0;
|
|
|
- this.key = void 0;
|
|
|
- this.aesMode = void 0;
|
|
|
- this.subtle = subtle;
|
|
|
- this.key = key;
|
|
|
- this.aesMode = aesMode;
|
|
|
- }
|
|
|
- expandKey() {
|
|
|
- const subtleAlgoName = getSubtleAlgoName(this.aesMode);
|
|
|
- return this.subtle.importKey("raw", this.key, {
|
|
|
- name: subtleAlgoName
|
|
|
- }, false, ["encrypt", "decrypt"]);
|
|
|
- }
|
|
|
-};
|
|
|
-function getSubtleAlgoName(aesMode) {
|
|
|
- switch (aesMode) {
|
|
|
- case DecrypterAesMode.cbc:
|
|
|
- return "AES-CBC";
|
|
|
- case DecrypterAesMode.ctr:
|
|
|
- return "AES-CTR";
|
|
|
- default:
|
|
|
- throw new Error(`[FastAESKey] invalid aes mode ${aesMode}`);
|
|
|
- }
|
|
|
-}
|
|
|
-var CHUNK_SIZE = 16;
|
|
|
-var Decrypter = class {
|
|
|
- constructor(config, {
|
|
|
- removePKCS7Padding = true
|
|
|
- } = {}) {
|
|
|
- this.logEnabled = true;
|
|
|
- this.removePKCS7Padding = void 0;
|
|
|
- this.subtle = null;
|
|
|
- this.softwareDecrypter = null;
|
|
|
- this.key = null;
|
|
|
- this.fastAesKey = null;
|
|
|
- this.remainderData = null;
|
|
|
- this.currentIV = null;
|
|
|
- this.currentResult = null;
|
|
|
- this.useSoftware = void 0;
|
|
|
- this.enableSoftwareAES = void 0;
|
|
|
- this.enableSoftwareAES = config.enableSoftwareAES;
|
|
|
- this.removePKCS7Padding = removePKCS7Padding;
|
|
|
- if (removePKCS7Padding) {
|
|
|
- try {
|
|
|
- const browserCrypto = self.crypto;
|
|
|
- if (browserCrypto) {
|
|
|
- this.subtle = browserCrypto.subtle || browserCrypto.webkitSubtle;
|
|
|
- }
|
|
|
- } catch (e) {
|
|
|
- }
|
|
|
- }
|
|
|
- this.useSoftware = !this.subtle;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.subtle = null;
|
|
|
- this.softwareDecrypter = null;
|
|
|
- this.key = null;
|
|
|
- this.fastAesKey = null;
|
|
|
- this.remainderData = null;
|
|
|
- this.currentIV = null;
|
|
|
- this.currentResult = null;
|
|
|
- }
|
|
|
- isSync() {
|
|
|
- return this.useSoftware;
|
|
|
- }
|
|
|
- flush() {
|
|
|
- const {
|
|
|
- currentResult,
|
|
|
- remainderData
|
|
|
- } = this;
|
|
|
- if (!currentResult || remainderData) {
|
|
|
- this.reset();
|
|
|
- return null;
|
|
|
- }
|
|
|
- const data = new Uint8Array(currentResult);
|
|
|
- this.reset();
|
|
|
- if (this.removePKCS7Padding) {
|
|
|
- return removePadding(data);
|
|
|
- }
|
|
|
- return data;
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.currentResult = null;
|
|
|
- this.currentIV = null;
|
|
|
- this.remainderData = null;
|
|
|
- if (this.softwareDecrypter) {
|
|
|
- this.softwareDecrypter = null;
|
|
|
- }
|
|
|
- }
|
|
|
- decrypt(data, key, iv, aesMode) {
|
|
|
- if (this.useSoftware) {
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- const dataView = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
|
|
|
- this.softwareDecrypt(dataView, key, iv, aesMode);
|
|
|
- const decryptResult = this.flush();
|
|
|
- if (decryptResult) {
|
|
|
- resolve(decryptResult.buffer);
|
|
|
- } else {
|
|
|
- reject(new Error("[softwareDecrypt] Failed to decrypt data"));
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- return this.webCryptoDecrypt(new Uint8Array(data), key, iv, aesMode);
|
|
|
- }
|
|
|
- // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
|
|
|
- // data is handled in the flush() call
|
|
|
- softwareDecrypt(data, key, iv, aesMode) {
|
|
|
- const {
|
|
|
- currentIV,
|
|
|
- currentResult,
|
|
|
- remainderData
|
|
|
- } = this;
|
|
|
- if (aesMode !== DecrypterAesMode.cbc || key.byteLength !== 16) {
|
|
|
- logger.warn("SoftwareDecrypt: can only handle AES-128-CBC");
|
|
|
- return null;
|
|
|
- }
|
|
|
- this.logOnce("JS AES decrypt");
|
|
|
- if (remainderData) {
|
|
|
- data = appendUint8Array(remainderData, data);
|
|
|
- this.remainderData = null;
|
|
|
- }
|
|
|
- const currentChunk = this.getValidChunk(data);
|
|
|
- if (!currentChunk.length) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (currentIV) {
|
|
|
- iv = currentIV;
|
|
|
- }
|
|
|
- let softwareDecrypter = this.softwareDecrypter;
|
|
|
- if (!softwareDecrypter) {
|
|
|
- softwareDecrypter = this.softwareDecrypter = new AESDecryptor();
|
|
|
- }
|
|
|
- softwareDecrypter.expandKey(key);
|
|
|
- const result = currentResult;
|
|
|
- this.currentResult = softwareDecrypter.decrypt(currentChunk.buffer, 0, iv);
|
|
|
- this.currentIV = currentChunk.slice(-16).buffer;
|
|
|
- if (!result) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- webCryptoDecrypt(data, key, iv, aesMode) {
|
|
|
- if (this.key !== key || !this.fastAesKey) {
|
|
|
- if (!this.subtle) {
|
|
|
- return Promise.resolve(this.onWebCryptoError(data, key, iv, aesMode));
|
|
|
- }
|
|
|
- this.key = key;
|
|
|
- this.fastAesKey = new FastAESKey(this.subtle, key, aesMode);
|
|
|
- }
|
|
|
- return this.fastAesKey.expandKey().then((aesKey) => {
|
|
|
- if (!this.subtle) {
|
|
|
- return Promise.reject(new Error("web crypto not initialized"));
|
|
|
- }
|
|
|
- this.logOnce("WebCrypto AES decrypt");
|
|
|
- const crypto2 = new AESCrypto(this.subtle, new Uint8Array(iv), aesMode);
|
|
|
- return crypto2.decrypt(data.buffer, aesKey);
|
|
|
- }).catch((err) => {
|
|
|
- logger.warn(`[decrypter]: WebCrypto Error, disable WebCrypto API, ${err.name}: ${err.message}`);
|
|
|
- return this.onWebCryptoError(data, key, iv, aesMode);
|
|
|
- });
|
|
|
- }
|
|
|
- onWebCryptoError(data, key, iv, aesMode) {
|
|
|
- const enableSoftwareAES = this.enableSoftwareAES;
|
|
|
- if (enableSoftwareAES) {
|
|
|
- this.useSoftware = true;
|
|
|
- this.logEnabled = true;
|
|
|
- this.softwareDecrypt(data, key, iv, aesMode);
|
|
|
- const decryptResult = this.flush();
|
|
|
- if (decryptResult) {
|
|
|
- return decryptResult.buffer;
|
|
|
- }
|
|
|
- }
|
|
|
- throw new Error("WebCrypto" + (enableSoftwareAES ? " and softwareDecrypt" : "") + ": failed to decrypt data");
|
|
|
- }
|
|
|
- getValidChunk(data) {
|
|
|
- let currentChunk = data;
|
|
|
- const splitPoint = data.length - data.length % CHUNK_SIZE;
|
|
|
- if (splitPoint !== data.length) {
|
|
|
- currentChunk = data.slice(0, splitPoint);
|
|
|
- this.remainderData = data.slice(splitPoint);
|
|
|
- }
|
|
|
- return currentChunk;
|
|
|
- }
|
|
|
- logOnce(msg) {
|
|
|
- if (!this.logEnabled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- logger.log(`[decrypter]: ${msg}`);
|
|
|
- this.logEnabled = false;
|
|
|
- }
|
|
|
-};
|
|
|
-var MIN_CHUNK_SIZE = Math.pow(2, 17);
|
|
|
-var FragmentLoader = class {
|
|
|
- constructor(config) {
|
|
|
- this.config = void 0;
|
|
|
- this.loader = null;
|
|
|
- this.partLoadTimeout = -1;
|
|
|
- this.config = config;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- if (this.loader) {
|
|
|
- this.loader.destroy();
|
|
|
- this.loader = null;
|
|
|
- }
|
|
|
- }
|
|
|
- abort() {
|
|
|
- if (this.loader) {
|
|
|
- this.loader.abort();
|
|
|
- }
|
|
|
- }
|
|
|
- load(frag, onProgress) {
|
|
|
- const url = frag.url;
|
|
|
- if (!url) {
|
|
|
- return Promise.reject(new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.FRAG_LOAD_ERROR,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- error: new Error(`Fragment does not have a ${url ? "part list" : "url"}`),
|
|
|
- networkDetails: null
|
|
|
- }));
|
|
|
- }
|
|
|
- this.abort();
|
|
|
- const config = this.config;
|
|
|
- const FragmentILoader = config.fLoader;
|
|
|
- const DefaultILoader = config.loader;
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- if (this.loader) {
|
|
|
- this.loader.destroy();
|
|
|
- }
|
|
|
- if (frag.gap) {
|
|
|
- if (frag.tagList.some((tags) => tags[0] === "GAP")) {
|
|
|
- reject(createGapLoadError(frag));
|
|
|
- return;
|
|
|
- } else {
|
|
|
- frag.gap = false;
|
|
|
- }
|
|
|
- }
|
|
|
- const loader = this.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
|
|
|
- const loaderContext = createLoaderContext(frag);
|
|
|
- frag.loader = loader;
|
|
|
- const loadPolicy = getLoaderConfigWithoutReties(config.fragLoadPolicy.default);
|
|
|
- const loaderConfig = {
|
|
|
- loadPolicy,
|
|
|
- timeout: loadPolicy.maxLoadTimeMs,
|
|
|
- maxRetry: 0,
|
|
|
- retryDelay: 0,
|
|
|
- maxRetryDelay: 0,
|
|
|
- highWaterMark: frag.sn === "initSegment" ? Infinity : MIN_CHUNK_SIZE
|
|
|
- };
|
|
|
- frag.stats = loader.stats;
|
|
|
- const callbacks = {
|
|
|
- onSuccess: (response, stats, context, networkDetails) => {
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- let payload = response.data;
|
|
|
- if (context.resetIV && frag.decryptdata) {
|
|
|
- frag.decryptdata.iv = new Uint8Array(payload.slice(0, 16));
|
|
|
- payload = payload.slice(16);
|
|
|
- }
|
|
|
- resolve({
|
|
|
- frag,
|
|
|
- part: null,
|
|
|
- payload,
|
|
|
- networkDetails
|
|
|
- });
|
|
|
- },
|
|
|
- onError: (response, context, networkDetails, stats) => {
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- reject(new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.FRAG_LOAD_ERROR,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- response: _objectSpread2({
|
|
|
- url,
|
|
|
- data: void 0
|
|
|
- }, response),
|
|
|
- error: new Error(`HTTP Error ${response.code} ${response.text}`),
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- }));
|
|
|
- },
|
|
|
- onAbort: (stats, context, networkDetails) => {
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- reject(new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.INTERNAL_ABORTED,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- error: new Error("Aborted"),
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- }));
|
|
|
- },
|
|
|
- onTimeout: (stats, context, networkDetails) => {
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- reject(new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.FRAG_LOAD_TIMEOUT,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- error: new Error(`Timeout after ${loaderConfig.timeout}ms`),
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- }));
|
|
|
- }
|
|
|
- };
|
|
|
- if (onProgress) {
|
|
|
- callbacks.onProgress = (stats, context, data, networkDetails) => onProgress({
|
|
|
- frag,
|
|
|
- part: null,
|
|
|
- payload: data,
|
|
|
- networkDetails
|
|
|
- });
|
|
|
- }
|
|
|
- loader.load(loaderContext, loaderConfig, callbacks);
|
|
|
- });
|
|
|
- }
|
|
|
- loadPart(frag, part, onProgress) {
|
|
|
- this.abort();
|
|
|
- const config = this.config;
|
|
|
- const FragmentILoader = config.fLoader;
|
|
|
- const DefaultILoader = config.loader;
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- if (this.loader) {
|
|
|
- this.loader.destroy();
|
|
|
- }
|
|
|
- if (frag.gap || part.gap) {
|
|
|
- reject(createGapLoadError(frag, part));
|
|
|
- return;
|
|
|
- }
|
|
|
- const loader = this.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
|
|
|
- const loaderContext = createLoaderContext(frag, part);
|
|
|
- frag.loader = loader;
|
|
|
- const loadPolicy = getLoaderConfigWithoutReties(config.fragLoadPolicy.default);
|
|
|
- const loaderConfig = {
|
|
|
- loadPolicy,
|
|
|
- timeout: loadPolicy.maxLoadTimeMs,
|
|
|
- maxRetry: 0,
|
|
|
- retryDelay: 0,
|
|
|
- maxRetryDelay: 0,
|
|
|
- highWaterMark: MIN_CHUNK_SIZE
|
|
|
- };
|
|
|
- part.stats = loader.stats;
|
|
|
- loader.load(loaderContext, loaderConfig, {
|
|
|
- onSuccess: (response, stats, context, networkDetails) => {
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- this.updateStatsFromPart(frag, part);
|
|
|
- const partLoadedData = {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- payload: response.data,
|
|
|
- networkDetails
|
|
|
- };
|
|
|
- onProgress(partLoadedData);
|
|
|
- resolve(partLoadedData);
|
|
|
- },
|
|
|
- onError: (response, context, networkDetails, stats) => {
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- reject(new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.FRAG_LOAD_ERROR,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- response: _objectSpread2({
|
|
|
- url: loaderContext.url,
|
|
|
- data: void 0
|
|
|
- }, response),
|
|
|
- error: new Error(`HTTP Error ${response.code} ${response.text}`),
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- }));
|
|
|
- },
|
|
|
- onAbort: (stats, context, networkDetails) => {
|
|
|
- frag.stats.aborted = part.stats.aborted;
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- reject(new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.INTERNAL_ABORTED,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- error: new Error("Aborted"),
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- }));
|
|
|
- },
|
|
|
- onTimeout: (stats, context, networkDetails) => {
|
|
|
- this.resetLoader(frag, loader);
|
|
|
- reject(new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.FRAG_LOAD_TIMEOUT,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- error: new Error(`Timeout after ${loaderConfig.timeout}ms`),
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- }));
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- updateStatsFromPart(frag, part) {
|
|
|
- const fragStats = frag.stats;
|
|
|
- const partStats = part.stats;
|
|
|
- const partTotal = partStats.total;
|
|
|
- fragStats.loaded += partStats.loaded;
|
|
|
- if (partTotal) {
|
|
|
- const estTotalParts = Math.round(frag.duration / part.duration);
|
|
|
- const estLoadedParts = Math.min(Math.round(fragStats.loaded / partTotal), estTotalParts);
|
|
|
- const estRemainingParts = estTotalParts - estLoadedParts;
|
|
|
- const estRemainingBytes = estRemainingParts * Math.round(fragStats.loaded / estLoadedParts);
|
|
|
- fragStats.total = fragStats.loaded + estRemainingBytes;
|
|
|
- } else {
|
|
|
- fragStats.total = Math.max(fragStats.loaded, fragStats.total);
|
|
|
- }
|
|
|
- const fragLoading = fragStats.loading;
|
|
|
- const partLoading = partStats.loading;
|
|
|
- if (fragLoading.start) {
|
|
|
- fragLoading.first += partLoading.first - partLoading.start;
|
|
|
- } else {
|
|
|
- fragLoading.start = partLoading.start;
|
|
|
- fragLoading.first = partLoading.first;
|
|
|
- }
|
|
|
- fragLoading.end = partLoading.end;
|
|
|
- }
|
|
|
- resetLoader(frag, loader) {
|
|
|
- frag.loader = null;
|
|
|
- if (this.loader === loader) {
|
|
|
- self.clearTimeout(this.partLoadTimeout);
|
|
|
- this.loader = null;
|
|
|
- }
|
|
|
- loader.destroy();
|
|
|
- }
|
|
|
-};
|
|
|
-function createLoaderContext(frag, part = null) {
|
|
|
- const segment = part || frag;
|
|
|
- const loaderContext = {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- responseType: "arraybuffer",
|
|
|
- url: segment.url,
|
|
|
- headers: {},
|
|
|
- rangeStart: 0,
|
|
|
- rangeEnd: 0
|
|
|
- };
|
|
|
- const start = segment.byteRangeStartOffset;
|
|
|
- const end = segment.byteRangeEndOffset;
|
|
|
- if (isFiniteNumber(start) && isFiniteNumber(end)) {
|
|
|
- var _frag$decryptdata;
|
|
|
- let byteRangeStart = start;
|
|
|
- let byteRangeEnd = end;
|
|
|
- if (frag.sn === "initSegment" && isMethodFullSegmentAesCbc((_frag$decryptdata = frag.decryptdata) == null ? void 0 : _frag$decryptdata.method)) {
|
|
|
- const fragmentLen = end - start;
|
|
|
- if (fragmentLen % 16) {
|
|
|
- byteRangeEnd = end + (16 - fragmentLen % 16);
|
|
|
- }
|
|
|
- if (start !== 0) {
|
|
|
- loaderContext.resetIV = true;
|
|
|
- byteRangeStart = start - 16;
|
|
|
- }
|
|
|
- }
|
|
|
- loaderContext.rangeStart = byteRangeStart;
|
|
|
- loaderContext.rangeEnd = byteRangeEnd;
|
|
|
- }
|
|
|
- return loaderContext;
|
|
|
-}
|
|
|
-function createGapLoadError(frag, part) {
|
|
|
- const error = new Error(`GAP ${frag.gap ? "tag" : "attribute"} found`);
|
|
|
- const errorData = {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_GAP,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- error,
|
|
|
- networkDetails: null
|
|
|
- };
|
|
|
- if (part) {
|
|
|
- errorData.part = part;
|
|
|
- }
|
|
|
- (part ? part : frag).stats.aborted = true;
|
|
|
- return new LoadError(errorData);
|
|
|
-}
|
|
|
-function isMethodFullSegmentAesCbc(method) {
|
|
|
- return method === "AES-128" || method === "AES-256";
|
|
|
-}
|
|
|
-var LoadError = class extends Error {
|
|
|
- constructor(data) {
|
|
|
- super(data.error.message);
|
|
|
- this.data = void 0;
|
|
|
- this.data = data;
|
|
|
- }
|
|
|
-};
|
|
|
-var TaskLoop = class extends Logger {
|
|
|
- constructor(label, logger2) {
|
|
|
- super(label, logger2);
|
|
|
- this._boundTick = void 0;
|
|
|
- this._tickTimer = null;
|
|
|
- this._tickInterval = null;
|
|
|
- this._tickCallCount = 0;
|
|
|
- this._boundTick = this.tick.bind(this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.onHandlerDestroying();
|
|
|
- this.onHandlerDestroyed();
|
|
|
- }
|
|
|
- onHandlerDestroying() {
|
|
|
- this.clearNextTick();
|
|
|
- this.clearInterval();
|
|
|
- }
|
|
|
- onHandlerDestroyed() {
|
|
|
- }
|
|
|
- hasInterval() {
|
|
|
- return !!this._tickInterval;
|
|
|
- }
|
|
|
- hasNextTick() {
|
|
|
- return !!this._tickTimer;
|
|
|
- }
|
|
|
- /**
|
|
|
- * @param millis - Interval time (ms)
|
|
|
- * @eturns True when interval has been scheduled, false when already scheduled (no effect)
|
|
|
- */
|
|
|
- setInterval(millis) {
|
|
|
- if (!this._tickInterval) {
|
|
|
- this._tickCallCount = 0;
|
|
|
- this._tickInterval = self.setInterval(this._boundTick, millis);
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- /**
|
|
|
- * @returns True when interval was cleared, false when none was set (no effect)
|
|
|
- */
|
|
|
- clearInterval() {
|
|
|
- if (this._tickInterval) {
|
|
|
- self.clearInterval(this._tickInterval);
|
|
|
- this._tickInterval = null;
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- /**
|
|
|
- * @returns True when timeout was cleared, false when none was set (no effect)
|
|
|
- */
|
|
|
- clearNextTick() {
|
|
|
- if (this._tickTimer) {
|
|
|
- self.clearTimeout(this._tickTimer);
|
|
|
- this._tickTimer = null;
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Will call the subclass doTick implementation in this main loop tick
|
|
|
- * or in the next one (via setTimeout(,0)) in case it has already been called
|
|
|
- * in this tick (in case this is a re-entrant call).
|
|
|
- */
|
|
|
- tick() {
|
|
|
- this._tickCallCount++;
|
|
|
- if (this._tickCallCount === 1) {
|
|
|
- this.doTick();
|
|
|
- if (this._tickCallCount > 1) {
|
|
|
- this.tickImmediate();
|
|
|
- }
|
|
|
- this._tickCallCount = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- tickImmediate() {
|
|
|
- this.clearNextTick();
|
|
|
- this._tickTimer = self.setTimeout(this._boundTick, 0);
|
|
|
- }
|
|
|
- /**
|
|
|
- * For subclass to implement task logic
|
|
|
- * @abstract
|
|
|
- */
|
|
|
- doTick() {
|
|
|
- }
|
|
|
-};
|
|
|
-var ChunkMetadata = class {
|
|
|
- constructor(level, sn, id, size = 0, part = -1, partial = false) {
|
|
|
- this.level = void 0;
|
|
|
- this.sn = void 0;
|
|
|
- this.part = void 0;
|
|
|
- this.id = void 0;
|
|
|
- this.size = void 0;
|
|
|
- this.partial = void 0;
|
|
|
- this.transmuxing = getNewPerformanceTiming();
|
|
|
- this.buffering = {
|
|
|
- audio: getNewPerformanceTiming(),
|
|
|
- video: getNewPerformanceTiming(),
|
|
|
- audiovideo: getNewPerformanceTiming()
|
|
|
- };
|
|
|
- this.level = level;
|
|
|
- this.sn = sn;
|
|
|
- this.id = id;
|
|
|
- this.size = size;
|
|
|
- this.part = part;
|
|
|
- this.partial = partial;
|
|
|
- }
|
|
|
-};
|
|
|
-function getNewPerformanceTiming() {
|
|
|
- return {
|
|
|
- start: 0,
|
|
|
- executeStart: 0,
|
|
|
- executeEnd: 0,
|
|
|
- end: 0
|
|
|
- };
|
|
|
-}
|
|
|
-var noopBuffered = {
|
|
|
- length: 0,
|
|
|
- start: () => 0,
|
|
|
- end: () => 0
|
|
|
-};
|
|
|
-var BufferHelper = class _BufferHelper {
|
|
|
- /**
|
|
|
- * Return true if `media`'s buffered include `position`
|
|
|
- */
|
|
|
- static isBuffered(media, position) {
|
|
|
- if (media) {
|
|
|
- const buffered = _BufferHelper.getBuffered(media);
|
|
|
- for (let i = buffered.length; i--; ) {
|
|
|
- if (position >= buffered.start(i) && position <= buffered.end(i)) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- static bufferedRanges(media) {
|
|
|
- if (media) {
|
|
|
- const timeRanges = _BufferHelper.getBuffered(media);
|
|
|
- return _BufferHelper.timeRangesToArray(timeRanges);
|
|
|
- }
|
|
|
- return [];
|
|
|
- }
|
|
|
- static timeRangesToArray(timeRanges) {
|
|
|
- const buffered = [];
|
|
|
- for (let i = 0; i < timeRanges.length; i++) {
|
|
|
- buffered.push({
|
|
|
- start: timeRanges.start(i),
|
|
|
- end: timeRanges.end(i)
|
|
|
- });
|
|
|
- }
|
|
|
- return buffered;
|
|
|
- }
|
|
|
- static bufferInfo(media, pos, maxHoleDuration) {
|
|
|
- if (media) {
|
|
|
- const buffered = _BufferHelper.bufferedRanges(media);
|
|
|
- if (buffered.length) {
|
|
|
- return _BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- len: 0,
|
|
|
- start: pos,
|
|
|
- end: pos,
|
|
|
- bufferedIndex: -1
|
|
|
- };
|
|
|
- }
|
|
|
- static bufferedInfo(buffered, pos, maxHoleDuration) {
|
|
|
- pos = Math.max(0, pos);
|
|
|
- if (buffered.length > 1) {
|
|
|
- buffered.sort((a, b) => a.start - b.start || b.end - a.end);
|
|
|
- }
|
|
|
- let bufferedIndex = -1;
|
|
|
- let buffered2 = [];
|
|
|
- if (maxHoleDuration) {
|
|
|
- for (let i = 0; i < buffered.length; i++) {
|
|
|
- if (pos >= buffered[i].start && pos <= buffered[i].end) {
|
|
|
- bufferedIndex = i;
|
|
|
- }
|
|
|
- const buf2len = buffered2.length;
|
|
|
- if (buf2len) {
|
|
|
- const buf2end = buffered2[buf2len - 1].end;
|
|
|
- if (buffered[i].start - buf2end < maxHoleDuration) {
|
|
|
- if (buffered[i].end > buf2end) {
|
|
|
- buffered2[buf2len - 1].end = buffered[i].end;
|
|
|
- }
|
|
|
- } else {
|
|
|
- buffered2.push(buffered[i]);
|
|
|
- }
|
|
|
- } else {
|
|
|
- buffered2.push(buffered[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- buffered2 = buffered;
|
|
|
- }
|
|
|
- let bufferLen = 0;
|
|
|
- let nextStart;
|
|
|
- let bufferStart = pos;
|
|
|
- let bufferEnd = pos;
|
|
|
- for (let i = 0; i < buffered2.length; i++) {
|
|
|
- const start = buffered2[i].start;
|
|
|
- const end = buffered2[i].end;
|
|
|
- if (bufferedIndex === -1 && pos >= start && pos <= end) {
|
|
|
- bufferedIndex = i;
|
|
|
- }
|
|
|
- if (pos + maxHoleDuration >= start && pos < end) {
|
|
|
- bufferStart = start;
|
|
|
- bufferEnd = end;
|
|
|
- bufferLen = bufferEnd - pos;
|
|
|
- } else if (pos + maxHoleDuration < start) {
|
|
|
- nextStart = start;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- len: bufferLen,
|
|
|
- start: bufferStart || 0,
|
|
|
- end: bufferEnd || 0,
|
|
|
- nextStart,
|
|
|
- buffered,
|
|
|
- bufferedIndex
|
|
|
- };
|
|
|
- }
|
|
|
- /**
|
|
|
- * Safe method to get buffered property.
|
|
|
- * SourceBuffer.buffered may throw if SourceBuffer is removed from it's MediaSource
|
|
|
- */
|
|
|
- static getBuffered(media) {
|
|
|
- try {
|
|
|
- return media.buffered || noopBuffered;
|
|
|
- } catch (e) {
|
|
|
- logger.log("failed to get media.buffered", e);
|
|
|
- return noopBuffered;
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var VARIABLE_REPLACEMENT_REGEX = /\{\$([a-zA-Z0-9-_]+)\}/g;
|
|
|
-function hasVariableReferences(str) {
|
|
|
- return VARIABLE_REPLACEMENT_REGEX.test(str);
|
|
|
-}
|
|
|
-function substituteVariables(parsed, value) {
|
|
|
- if (parsed.variableList !== null || parsed.hasVariableRefs) {
|
|
|
- const variableList = parsed.variableList;
|
|
|
- return value.replace(VARIABLE_REPLACEMENT_REGEX, (variableReference) => {
|
|
|
- const variableName = variableReference.substring(2, variableReference.length - 1);
|
|
|
- const variableValue = variableList == null ? void 0 : variableList[variableName];
|
|
|
- if (variableValue === void 0) {
|
|
|
- parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`Missing preceding EXT-X-DEFINE tag for Variable Reference: "${variableName}"`));
|
|
|
- return variableReference;
|
|
|
- }
|
|
|
- return variableValue;
|
|
|
- });
|
|
|
- }
|
|
|
- return value;
|
|
|
-}
|
|
|
-function addVariableDefinition(parsed, attr, parentUrl) {
|
|
|
- let variableList = parsed.variableList;
|
|
|
- if (!variableList) {
|
|
|
- parsed.variableList = variableList = {};
|
|
|
- }
|
|
|
- let NAME;
|
|
|
- let VALUE;
|
|
|
- if ("QUERYPARAM" in attr) {
|
|
|
- NAME = attr.QUERYPARAM;
|
|
|
- try {
|
|
|
- const searchParams = new self.URL(parentUrl).searchParams;
|
|
|
- if (searchParams.has(NAME)) {
|
|
|
- VALUE = searchParams.get(NAME);
|
|
|
- } else {
|
|
|
- throw new Error(`"${NAME}" does not match any query parameter in URI: "${parentUrl}"`);
|
|
|
- }
|
|
|
- } catch (error) {
|
|
|
- parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE QUERYPARAM: ${error.message}`));
|
|
|
- }
|
|
|
- } else {
|
|
|
- NAME = attr.NAME;
|
|
|
- VALUE = attr.VALUE;
|
|
|
- }
|
|
|
- if (NAME in variableList) {
|
|
|
- parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE duplicate Variable Name declarations: "${NAME}"`));
|
|
|
- } else {
|
|
|
- variableList[NAME] = VALUE || "";
|
|
|
- }
|
|
|
-}
|
|
|
-function importVariableDefinition(parsed, attr, sourceVariableList) {
|
|
|
- const IMPORT = attr.IMPORT;
|
|
|
- if (sourceVariableList && IMPORT in sourceVariableList) {
|
|
|
- let variableList = parsed.variableList;
|
|
|
- if (!variableList) {
|
|
|
- parsed.variableList = variableList = {};
|
|
|
- }
|
|
|
- variableList[IMPORT] = sourceVariableList[IMPORT];
|
|
|
- } else {
|
|
|
- parsed.playlistParsingError || (parsed.playlistParsingError = new Error(`EXT-X-DEFINE IMPORT attribute not found in Multivariant Playlist: "${IMPORT}"`));
|
|
|
- }
|
|
|
-}
|
|
|
-var DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
|
|
|
-var ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
|
|
|
-var AttrList = class _AttrList {
|
|
|
- constructor(attrs, parsed) {
|
|
|
- if (typeof attrs === "string") {
|
|
|
- attrs = _AttrList.parseAttrList(attrs, parsed);
|
|
|
- }
|
|
|
- _extends(this, attrs);
|
|
|
- }
|
|
|
- get clientAttrs() {
|
|
|
- return Object.keys(this).filter((attr) => attr.substring(0, 2) === "X-");
|
|
|
- }
|
|
|
- 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;
|
|
|
- }
|
|
|
- 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]);
|
|
|
- }
|
|
|
- optionalFloat(attrName, defaultValue) {
|
|
|
- const value = this[attrName];
|
|
|
- return value ? parseFloat(value) : defaultValue;
|
|
|
- }
|
|
|
- enumeratedString(attrName) {
|
|
|
- return this[attrName];
|
|
|
- }
|
|
|
- enumeratedStringList(attrName, dict) {
|
|
|
- const attrValue = this[attrName];
|
|
|
- return (attrValue ? attrValue.split(/[ ,]+/) : []).reduce((result, identifier) => {
|
|
|
- result[identifier.toLowerCase()] = true;
|
|
|
- return result;
|
|
|
- }, dict);
|
|
|
- }
|
|
|
- bool(attrName) {
|
|
|
- return this[attrName] === "YES";
|
|
|
- }
|
|
|
- decimalResolution(attrName) {
|
|
|
- const res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);
|
|
|
- if (res === null) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- return {
|
|
|
- width: parseInt(res[1], 10),
|
|
|
- height: parseInt(res[2], 10)
|
|
|
- };
|
|
|
- }
|
|
|
- static parseAttrList(input, parsed) {
|
|
|
- let match;
|
|
|
- const attrs = {};
|
|
|
- const quote = '"';
|
|
|
- ATTR_LIST_REGEX.lastIndex = 0;
|
|
|
- while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
|
|
|
- const name = match[1].trim();
|
|
|
- let value = match[2];
|
|
|
- const quotedString = value.indexOf(quote) === 0 && value.lastIndexOf(quote) === value.length - 1;
|
|
|
- let hexadecimalSequence = false;
|
|
|
- if (quotedString) {
|
|
|
- value = value.slice(1, -1);
|
|
|
- } else {
|
|
|
- switch (name) {
|
|
|
- case "IV":
|
|
|
- case "SCTE35-CMD":
|
|
|
- case "SCTE35-IN":
|
|
|
- case "SCTE35-OUT":
|
|
|
- hexadecimalSequence = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (parsed && (quotedString || hexadecimalSequence)) {
|
|
|
- {
|
|
|
- value = substituteVariables(parsed, value);
|
|
|
- }
|
|
|
- } else if (!hexadecimalSequence && !quotedString) {
|
|
|
- switch (name) {
|
|
|
- case "CLOSED-CAPTIONS":
|
|
|
- if (value === "NONE") {
|
|
|
- break;
|
|
|
- }
|
|
|
- case "ALLOWED-CPC":
|
|
|
- case "CLASS":
|
|
|
- case "ASSOC-LANGUAGE":
|
|
|
- case "AUDIO":
|
|
|
- case "BYTERANGE":
|
|
|
- case "CHANNELS":
|
|
|
- case "CHARACTERISTICS":
|
|
|
- case "CODECS":
|
|
|
- case "DATA-ID":
|
|
|
- case "END-DATE":
|
|
|
- case "GROUP-ID":
|
|
|
- case "ID":
|
|
|
- case "IMPORT":
|
|
|
- case "INSTREAM-ID":
|
|
|
- case "KEYFORMAT":
|
|
|
- case "KEYFORMATVERSIONS":
|
|
|
- case "LANGUAGE":
|
|
|
- case "NAME":
|
|
|
- case "PATHWAY-ID":
|
|
|
- case "QUERYPARAM":
|
|
|
- case "RECENTLY-REMOVED-DATERANGES":
|
|
|
- case "SERVER-URI":
|
|
|
- case "STABLE-RENDITION-ID":
|
|
|
- case "STABLE-VARIANT-ID":
|
|
|
- case "START-DATE":
|
|
|
- case "SUBTITLES":
|
|
|
- case "SUPPLEMENTAL-CODECS":
|
|
|
- case "URI":
|
|
|
- case "VALUE":
|
|
|
- case "VIDEO":
|
|
|
- case "X-ASSET-LIST":
|
|
|
- case "X-ASSET-URI":
|
|
|
- logger.warn(`${input}: attribute ${name} is missing quotes`);
|
|
|
- }
|
|
|
- }
|
|
|
- attrs[name] = value;
|
|
|
- }
|
|
|
- return attrs;
|
|
|
- }
|
|
|
-};
|
|
|
-var CLASS_INTERSTITIAL = "com.apple.hls.interstitial";
|
|
|
-function isDateRangeCueAttribute(attrName) {
|
|
|
- return attrName !== "ID" && attrName !== "CLASS" && attrName !== "CUE" && attrName !== "START-DATE" && attrName !== "DURATION" && attrName !== "END-DATE" && attrName !== "END-ON-NEXT";
|
|
|
-}
|
|
|
-function isSCTE35Attribute(attrName) {
|
|
|
- return attrName === "SCTE35-OUT" || attrName === "SCTE35-IN" || attrName === "SCTE35-CMD";
|
|
|
-}
|
|
|
-var DateRange = class {
|
|
|
- constructor(dateRangeAttr, dateRangeWithSameId, tagCount = 0) {
|
|
|
- var _dateRangeWithSameId$;
|
|
|
- this.attr = void 0;
|
|
|
- this.tagAnchor = void 0;
|
|
|
- this.tagOrder = void 0;
|
|
|
- this._startDate = void 0;
|
|
|
- this._endDate = void 0;
|
|
|
- this._dateAtEnd = void 0;
|
|
|
- this._cue = void 0;
|
|
|
- this._badValueForSameId = void 0;
|
|
|
- this.tagAnchor = (dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.tagAnchor) || null;
|
|
|
- this.tagOrder = (_dateRangeWithSameId$ = dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.tagOrder) != null ? _dateRangeWithSameId$ : tagCount;
|
|
|
- if (dateRangeWithSameId) {
|
|
|
- const previousAttr = dateRangeWithSameId.attr;
|
|
|
- for (const key in previousAttr) {
|
|
|
- if (Object.prototype.hasOwnProperty.call(dateRangeAttr, key) && dateRangeAttr[key] !== previousAttr[key]) {
|
|
|
- logger.warn(`DATERANGE tag attribute: "${key}" does not match for tags with ID: "${dateRangeAttr.ID}"`);
|
|
|
- this._badValueForSameId = key;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- dateRangeAttr = _extends(new AttrList({}), previousAttr, dateRangeAttr);
|
|
|
- }
|
|
|
- this.attr = dateRangeAttr;
|
|
|
- if (dateRangeWithSameId) {
|
|
|
- this._startDate = dateRangeWithSameId._startDate;
|
|
|
- this._cue = dateRangeWithSameId._cue;
|
|
|
- this._endDate = dateRangeWithSameId._endDate;
|
|
|
- this._dateAtEnd = dateRangeWithSameId._dateAtEnd;
|
|
|
- } else {
|
|
|
- this._startDate = new Date(dateRangeAttr["START-DATE"]);
|
|
|
- }
|
|
|
- if ("END-DATE" in this.attr) {
|
|
|
- const endDate = (dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.endDate) || new Date(this.attr["END-DATE"]);
|
|
|
- if (isFiniteNumber(endDate.getTime())) {
|
|
|
- this._endDate = endDate;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- get id() {
|
|
|
- return this.attr.ID;
|
|
|
- }
|
|
|
- get class() {
|
|
|
- return this.attr.CLASS;
|
|
|
- }
|
|
|
- get cue() {
|
|
|
- const _cue = this._cue;
|
|
|
- if (_cue === void 0) {
|
|
|
- return this._cue = this.attr.enumeratedStringList(this.attr.CUE ? "CUE" : "X-CUE", {
|
|
|
- pre: false,
|
|
|
- post: false,
|
|
|
- once: false
|
|
|
- });
|
|
|
- }
|
|
|
- return _cue;
|
|
|
- }
|
|
|
- get startTime() {
|
|
|
- const {
|
|
|
- tagAnchor
|
|
|
- } = this;
|
|
|
- if (tagAnchor === null || tagAnchor.programDateTime === null) {
|
|
|
- logger.warn(`Expected tagAnchor Fragment with PDT set for DateRange "${this.id}": ${tagAnchor}`);
|
|
|
- return NaN;
|
|
|
- }
|
|
|
- return tagAnchor.start + (this.startDate.getTime() - tagAnchor.programDateTime) / 1e3;
|
|
|
- }
|
|
|
- get startDate() {
|
|
|
- return this._startDate;
|
|
|
- }
|
|
|
- get endDate() {
|
|
|
- const dateAtEnd = this._endDate || this._dateAtEnd;
|
|
|
- if (dateAtEnd) {
|
|
|
- return dateAtEnd;
|
|
|
- }
|
|
|
- const duration = this.duration;
|
|
|
- if (duration !== null) {
|
|
|
- return this._dateAtEnd = new Date(this._startDate.getTime() + duration * 1e3);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- get duration() {
|
|
|
- if ("DURATION" in this.attr) {
|
|
|
- const duration = this.attr.decimalFloatingPoint("DURATION");
|
|
|
- if (isFiniteNumber(duration)) {
|
|
|
- return duration;
|
|
|
- }
|
|
|
- } else if (this._endDate) {
|
|
|
- return (this._endDate.getTime() - this._startDate.getTime()) / 1e3;
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- get plannedDuration() {
|
|
|
- if ("PLANNED-DURATION" in this.attr) {
|
|
|
- return this.attr.decimalFloatingPoint("PLANNED-DURATION");
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- get endOnNext() {
|
|
|
- return this.attr.bool("END-ON-NEXT");
|
|
|
- }
|
|
|
- get isInterstitial() {
|
|
|
- return this.class === CLASS_INTERSTITIAL;
|
|
|
- }
|
|
|
- get isValid() {
|
|
|
- return !!this.id && !this._badValueForSameId && isFiniteNumber(this.startDate.getTime()) && (this.duration === null || this.duration >= 0) && (!this.endOnNext || !!this.class) && (!this.attr.CUE || !this.cue.pre && !this.cue.post || this.cue.pre !== this.cue.post) && (!this.isInterstitial || "X-ASSET-URI" in this.attr || "X-ASSET-LIST" in this.attr);
|
|
|
- }
|
|
|
-};
|
|
|
-var DEFAULT_TARGET_DURATION = 10;
|
|
|
-var LevelDetails = class {
|
|
|
- constructor(baseUrl) {
|
|
|
- this.PTSKnown = false;
|
|
|
- this.alignedSliding = false;
|
|
|
- this.averagetargetduration = void 0;
|
|
|
- this.endCC = 0;
|
|
|
- this.endSN = 0;
|
|
|
- this.fragments = void 0;
|
|
|
- this.fragmentHint = void 0;
|
|
|
- this.partList = null;
|
|
|
- this.dateRanges = void 0;
|
|
|
- this.dateRangeTagCount = 0;
|
|
|
- this.live = true;
|
|
|
- this.requestScheduled = -1;
|
|
|
- this.ageHeader = 0;
|
|
|
- this.advancedDateTime = void 0;
|
|
|
- this.updated = true;
|
|
|
- this.advanced = true;
|
|
|
- this.misses = 0;
|
|
|
- this.startCC = 0;
|
|
|
- this.startSN = 0;
|
|
|
- this.startTimeOffset = null;
|
|
|
- this.targetduration = 0;
|
|
|
- this.totalduration = 0;
|
|
|
- this.type = null;
|
|
|
- this.url = void 0;
|
|
|
- this.m3u8 = "";
|
|
|
- this.version = null;
|
|
|
- this.canBlockReload = false;
|
|
|
- this.canSkipUntil = 0;
|
|
|
- this.canSkipDateRanges = false;
|
|
|
- this.skippedSegments = 0;
|
|
|
- this.recentlyRemovedDateranges = void 0;
|
|
|
- this.partHoldBack = 0;
|
|
|
- this.holdBack = 0;
|
|
|
- this.partTarget = 0;
|
|
|
- this.preloadHint = void 0;
|
|
|
- this.renditionReports = void 0;
|
|
|
- this.tuneInGoal = 0;
|
|
|
- this.deltaUpdateFailed = void 0;
|
|
|
- this.driftStartTime = 0;
|
|
|
- this.driftEndTime = 0;
|
|
|
- this.driftStart = 0;
|
|
|
- this.driftEnd = 0;
|
|
|
- this.encryptedFragments = void 0;
|
|
|
- this.playlistParsingError = null;
|
|
|
- this.variableList = null;
|
|
|
- this.hasVariableRefs = false;
|
|
|
- this.appliedTimelineOffset = void 0;
|
|
|
- this.fragments = [];
|
|
|
- this.encryptedFragments = [];
|
|
|
- this.dateRanges = {};
|
|
|
- this.url = baseUrl;
|
|
|
- }
|
|
|
- reloaded(previous) {
|
|
|
- if (!previous) {
|
|
|
- this.advanced = true;
|
|
|
- this.updated = true;
|
|
|
- return;
|
|
|
- }
|
|
|
- const partSnDiff = this.lastPartSn - previous.lastPartSn;
|
|
|
- const partIndexDiff = this.lastPartIndex - previous.lastPartIndex;
|
|
|
- this.updated = this.endSN !== previous.endSN || !!partIndexDiff || !!partSnDiff || !this.live;
|
|
|
- this.advanced = this.endSN > previous.endSN || partSnDiff > 0 || partSnDiff === 0 && partIndexDiff > 0;
|
|
|
- if (this.updated || this.advanced) {
|
|
|
- this.misses = Math.floor(previous.misses * 0.6);
|
|
|
- } else {
|
|
|
- this.misses = previous.misses + 1;
|
|
|
- }
|
|
|
- }
|
|
|
- hasKey(levelKey) {
|
|
|
- return this.encryptedFragments.some((frag) => {
|
|
|
- let decryptdata = frag.decryptdata;
|
|
|
- if (!decryptdata) {
|
|
|
- frag.setKeyFormat(levelKey.keyFormat);
|
|
|
- decryptdata = frag.decryptdata;
|
|
|
- }
|
|
|
- return !!decryptdata && levelKey.matches(decryptdata);
|
|
|
- });
|
|
|
- }
|
|
|
- get hasProgramDateTime() {
|
|
|
- if (this.fragments.length) {
|
|
|
- return isFiniteNumber(this.fragments[this.fragments.length - 1].programDateTime);
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- get levelTargetDuration() {
|
|
|
- return this.averagetargetduration || this.targetduration || DEFAULT_TARGET_DURATION;
|
|
|
- }
|
|
|
- get drift() {
|
|
|
- const runTime = this.driftEndTime - this.driftStartTime;
|
|
|
- if (runTime > 0) {
|
|
|
- const runDuration = this.driftEnd - this.driftStart;
|
|
|
- return runDuration * 1e3 / runTime;
|
|
|
- }
|
|
|
- return 1;
|
|
|
- }
|
|
|
- get edge() {
|
|
|
- return this.partEnd || this.fragmentEnd;
|
|
|
- }
|
|
|
- get partEnd() {
|
|
|
- var _this$partList;
|
|
|
- if ((_this$partList = this.partList) != null && _this$partList.length) {
|
|
|
- return this.partList[this.partList.length - 1].end;
|
|
|
- }
|
|
|
- return this.fragmentEnd;
|
|
|
- }
|
|
|
- get fragmentEnd() {
|
|
|
- if (this.fragments.length) {
|
|
|
- return this.fragments[this.fragments.length - 1].end;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- get fragmentStart() {
|
|
|
- if (this.fragments.length) {
|
|
|
- return this.fragments[0].start;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- get age() {
|
|
|
- if (this.advancedDateTime) {
|
|
|
- return Math.max(Date.now() - this.advancedDateTime, 0) / 1e3;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- get lastPartIndex() {
|
|
|
- var _this$partList2;
|
|
|
- if ((_this$partList2 = this.partList) != null && _this$partList2.length) {
|
|
|
- return this.partList[this.partList.length - 1].index;
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- get maxPartIndex() {
|
|
|
- const partList = this.partList;
|
|
|
- if (partList) {
|
|
|
- const lastIndex = this.lastPartIndex;
|
|
|
- if (lastIndex !== -1) {
|
|
|
- for (let i = partList.length; i--; ) {
|
|
|
- if (partList[i].index > lastIndex) {
|
|
|
- return partList[i].index;
|
|
|
- }
|
|
|
- }
|
|
|
- return lastIndex;
|
|
|
- }
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- get lastPartSn() {
|
|
|
- var _this$partList3;
|
|
|
- if ((_this$partList3 = this.partList) != null && _this$partList3.length) {
|
|
|
- return this.partList[this.partList.length - 1].fragment.sn;
|
|
|
- }
|
|
|
- return this.endSN;
|
|
|
- }
|
|
|
- get expired() {
|
|
|
- if (this.live && this.age && this.misses < 3) {
|
|
|
- const playlistWindowDuration = this.partEnd - this.fragmentStart;
|
|
|
- return this.age > Math.max(playlistWindowDuration, this.totalduration) + this.levelTargetDuration;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
-};
|
|
|
-function arrayValuesMatch(a, b) {
|
|
|
- if (a.length === b.length) {
|
|
|
- return !a.some((value, i) => value !== b[i]);
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function optionalArrayValuesMatch(a, b) {
|
|
|
- if (!a && !b) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (!a || !b) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return arrayValuesMatch(a, b);
|
|
|
-}
|
|
|
-function isFullSegmentEncryption(method) {
|
|
|
- return method === "AES-128" || method === "AES-256" || method === "AES-256-CTR";
|
|
|
-}
|
|
|
-function getAesModeFromFullSegmentMethod(method) {
|
|
|
- switch (method) {
|
|
|
- case "AES-128":
|
|
|
- case "AES-256":
|
|
|
- return DecrypterAesMode.cbc;
|
|
|
- case "AES-256-CTR":
|
|
|
- return DecrypterAesMode.ctr;
|
|
|
- default:
|
|
|
- throw new Error(`invalid full segment method ${method}`);
|
|
|
- }
|
|
|
-}
|
|
|
-function base64Decode(base64encodedStr) {
|
|
|
- return Uint8Array.from(atob(base64encodedStr), (c) => c.charCodeAt(0));
|
|
|
-}
|
|
|
-function strToUtf8array(str) {
|
|
|
- return Uint8Array.from(unescape(encodeURIComponent(str)), (c) => c.charCodeAt(0));
|
|
|
-}
|
|
|
-function getKeyIdBytes(str) {
|
|
|
- const keyIdbytes = strToUtf8array(str).subarray(0, 16);
|
|
|
- const paddedkeyIdbytes = new Uint8Array(16);
|
|
|
- paddedkeyIdbytes.set(keyIdbytes, 16 - keyIdbytes.length);
|
|
|
- return paddedkeyIdbytes;
|
|
|
-}
|
|
|
-function changeEndianness(keyId) {
|
|
|
- const swap = function swap2(array, from, to) {
|
|
|
- const cur = array[from];
|
|
|
- array[from] = array[to];
|
|
|
- array[to] = cur;
|
|
|
- };
|
|
|
- swap(keyId, 0, 3);
|
|
|
- swap(keyId, 1, 2);
|
|
|
- swap(keyId, 4, 5);
|
|
|
- swap(keyId, 6, 7);
|
|
|
-}
|
|
|
-function convertDataUriToArrayBytes(uri) {
|
|
|
- const colonsplit = uri.split(":");
|
|
|
- let keydata = null;
|
|
|
- if (colonsplit[0] === "data" && colonsplit.length === 2) {
|
|
|
- const semicolonsplit = colonsplit[1].split(";");
|
|
|
- const commasplit = semicolonsplit[semicolonsplit.length - 1].split(",");
|
|
|
- if (commasplit.length === 2) {
|
|
|
- const isbase64 = commasplit[0] === "base64";
|
|
|
- const data = commasplit[1];
|
|
|
- if (isbase64) {
|
|
|
- semicolonsplit.splice(-1, 1);
|
|
|
- keydata = base64Decode(data);
|
|
|
- } else {
|
|
|
- keydata = getKeyIdBytes(data);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return keydata;
|
|
|
-}
|
|
|
-var optionalSelf = typeof self !== "undefined" ? self : void 0;
|
|
|
-var KeySystems = {
|
|
|
- CLEARKEY: "org.w3.clearkey",
|
|
|
- FAIRPLAY: "com.apple.fps",
|
|
|
- PLAYREADY: "com.microsoft.playready",
|
|
|
- WIDEVINE: "com.widevine.alpha"
|
|
|
-};
|
|
|
-var KeySystemFormats = {
|
|
|
- CLEARKEY: "org.w3.clearkey",
|
|
|
- FAIRPLAY: "com.apple.streamingkeydelivery",
|
|
|
- PLAYREADY: "com.microsoft.playready",
|
|
|
- WIDEVINE: "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed"
|
|
|
-};
|
|
|
-function keySystemFormatToKeySystemDomain(format2) {
|
|
|
- switch (format2) {
|
|
|
- case KeySystemFormats.FAIRPLAY:
|
|
|
- return KeySystems.FAIRPLAY;
|
|
|
- case KeySystemFormats.PLAYREADY:
|
|
|
- return KeySystems.PLAYREADY;
|
|
|
- case KeySystemFormats.WIDEVINE:
|
|
|
- return KeySystems.WIDEVINE;
|
|
|
- case KeySystemFormats.CLEARKEY:
|
|
|
- return KeySystems.CLEARKEY;
|
|
|
- }
|
|
|
-}
|
|
|
-function keySystemDomainToKeySystemFormat(keySystem) {
|
|
|
- switch (keySystem) {
|
|
|
- case KeySystems.FAIRPLAY:
|
|
|
- return KeySystemFormats.FAIRPLAY;
|
|
|
- case KeySystems.PLAYREADY:
|
|
|
- return KeySystemFormats.PLAYREADY;
|
|
|
- case KeySystems.WIDEVINE:
|
|
|
- return KeySystemFormats.WIDEVINE;
|
|
|
- case KeySystems.CLEARKEY:
|
|
|
- return KeySystemFormats.CLEARKEY;
|
|
|
- }
|
|
|
-}
|
|
|
-function getKeySystemsForConfig(config) {
|
|
|
- const {
|
|
|
- drmSystems,
|
|
|
- widevineLicenseUrl
|
|
|
- } = config;
|
|
|
- const keySystemsToAttempt = drmSystems ? [KeySystems.FAIRPLAY, KeySystems.WIDEVINE, KeySystems.PLAYREADY, KeySystems.CLEARKEY].filter((keySystem) => !!drmSystems[keySystem]) : [];
|
|
|
- if (!keySystemsToAttempt[KeySystems.WIDEVINE] && widevineLicenseUrl) {
|
|
|
- keySystemsToAttempt.push(KeySystems.WIDEVINE);
|
|
|
- }
|
|
|
- return keySystemsToAttempt;
|
|
|
-}
|
|
|
-var requestMediaKeySystemAccess = function(_optionalSelf$navigat) {
|
|
|
- if (optionalSelf != null && (_optionalSelf$navigat = optionalSelf.navigator) != null && _optionalSelf$navigat.requestMediaKeySystemAccess) {
|
|
|
- return self.navigator.requestMediaKeySystemAccess.bind(self.navigator);
|
|
|
- } else {
|
|
|
- return null;
|
|
|
- }
|
|
|
-}();
|
|
|
-function getSupportedMediaKeySystemConfigurations(keySystem, audioCodecs, videoCodecs, drmSystemOptions) {
|
|
|
- let initDataTypes;
|
|
|
- switch (keySystem) {
|
|
|
- case KeySystems.FAIRPLAY:
|
|
|
- initDataTypes = ["cenc", "sinf"];
|
|
|
- break;
|
|
|
- case KeySystems.WIDEVINE:
|
|
|
- case KeySystems.PLAYREADY:
|
|
|
- initDataTypes = ["cenc"];
|
|
|
- break;
|
|
|
- case KeySystems.CLEARKEY:
|
|
|
- initDataTypes = ["cenc", "keyids"];
|
|
|
- break;
|
|
|
- default:
|
|
|
- throw new Error(`Unknown key-system: ${keySystem}`);
|
|
|
- }
|
|
|
- return createMediaKeySystemConfigurations(initDataTypes, audioCodecs, videoCodecs, drmSystemOptions);
|
|
|
-}
|
|
|
-function createMediaKeySystemConfigurations(initDataTypes, audioCodecs, videoCodecs, drmSystemOptions) {
|
|
|
- const baseConfig = {
|
|
|
- initDataTypes,
|
|
|
- persistentState: drmSystemOptions.persistentState || "optional",
|
|
|
- distinctiveIdentifier: drmSystemOptions.distinctiveIdentifier || "optional",
|
|
|
- sessionTypes: drmSystemOptions.sessionTypes || [drmSystemOptions.sessionType || "temporary"],
|
|
|
- audioCapabilities: audioCodecs.map((codec) => ({
|
|
|
- contentType: `audio/mp4; codecs=${codec}`,
|
|
|
- robustness: drmSystemOptions.audioRobustness || "",
|
|
|
- encryptionScheme: drmSystemOptions.audioEncryptionScheme || null
|
|
|
- })),
|
|
|
- videoCapabilities: videoCodecs.map((codec) => ({
|
|
|
- contentType: `video/mp4; codecs=${codec}`,
|
|
|
- robustness: drmSystemOptions.videoRobustness || "",
|
|
|
- encryptionScheme: drmSystemOptions.videoEncryptionScheme || null
|
|
|
- }))
|
|
|
- };
|
|
|
- return [baseConfig];
|
|
|
-}
|
|
|
-function isPersistentSessionType(drmSystemOptions) {
|
|
|
- var _drmSystemOptions$ses;
|
|
|
- return !!drmSystemOptions && (drmSystemOptions.sessionType === "persistent-license" || !!((_drmSystemOptions$ses = drmSystemOptions.sessionTypes) != null && _drmSystemOptions$ses.some((type) => type === "persistent-license")));
|
|
|
-}
|
|
|
-function parsePlayReadyWRM(keyBytes) {
|
|
|
- const keyBytesUtf16 = new Uint16Array(keyBytes.buffer, keyBytes.byteOffset, keyBytes.byteLength / 2);
|
|
|
- const keyByteStr = String.fromCharCode.apply(null, Array.from(keyBytesUtf16));
|
|
|
- const xmlKeyBytes = keyByteStr.substring(keyByteStr.indexOf("<"), keyByteStr.length);
|
|
|
- const parser = new DOMParser();
|
|
|
- const xmlDoc = parser.parseFromString(xmlKeyBytes, "text/xml");
|
|
|
- const keyData = xmlDoc.getElementsByTagName("KID")[0];
|
|
|
- if (keyData) {
|
|
|
- const keyId = keyData.childNodes[0] ? keyData.childNodes[0].nodeValue : keyData.getAttribute("VALUE");
|
|
|
- if (keyId) {
|
|
|
- const keyIdArray = base64Decode(keyId).subarray(0, 16);
|
|
|
- changeEndianness(keyIdArray);
|
|
|
- return keyIdArray;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-var keyUriToKeyIdMap = {};
|
|
|
-var LevelKey = class _LevelKey {
|
|
|
- static clearKeyUriToKeyIdMap() {
|
|
|
- keyUriToKeyIdMap = {};
|
|
|
- }
|
|
|
- static setKeyIdForUri(uri, keyId) {
|
|
|
- keyUriToKeyIdMap[uri] = keyId;
|
|
|
- }
|
|
|
- constructor(method, uri, format2, formatversions = [1], iv = null, keyId) {
|
|
|
- this.uri = void 0;
|
|
|
- this.method = void 0;
|
|
|
- this.keyFormat = void 0;
|
|
|
- this.keyFormatVersions = void 0;
|
|
|
- this.encrypted = void 0;
|
|
|
- this.isCommonEncryption = void 0;
|
|
|
- this.iv = null;
|
|
|
- this.key = null;
|
|
|
- this.keyId = null;
|
|
|
- this.pssh = null;
|
|
|
- this.method = method;
|
|
|
- this.uri = uri;
|
|
|
- this.keyFormat = format2;
|
|
|
- this.keyFormatVersions = formatversions;
|
|
|
- this.iv = iv;
|
|
|
- this.encrypted = method ? method !== "NONE" : false;
|
|
|
- this.isCommonEncryption = this.encrypted && !isFullSegmentEncryption(method);
|
|
|
- if (keyId != null && keyId.startsWith("0x")) {
|
|
|
- this.keyId = new Uint8Array(hexToArrayBuffer(keyId));
|
|
|
- }
|
|
|
- }
|
|
|
- matches(key) {
|
|
|
- return key.uri === this.uri && key.method === this.method && key.encrypted === this.encrypted && key.keyFormat === this.keyFormat && arrayValuesMatch(key.keyFormatVersions, this.keyFormatVersions) && optionalArrayValuesMatch(key.iv, this.iv) && optionalArrayValuesMatch(key.keyId, this.keyId);
|
|
|
- }
|
|
|
- isSupported() {
|
|
|
- if (this.method) {
|
|
|
- if (isFullSegmentEncryption(this.method) || this.method === "NONE") {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (this.keyFormat === "identity") {
|
|
|
- return this.method === "SAMPLE-AES";
|
|
|
- } else {
|
|
|
- switch (this.keyFormat) {
|
|
|
- case KeySystemFormats.FAIRPLAY:
|
|
|
- case KeySystemFormats.WIDEVINE:
|
|
|
- case KeySystemFormats.PLAYREADY:
|
|
|
- case KeySystemFormats.CLEARKEY:
|
|
|
- return ["SAMPLE-AES", "SAMPLE-AES-CENC", "SAMPLE-AES-CTR"].indexOf(this.method) !== -1;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- getDecryptData(sn, levelKeys) {
|
|
|
- if (!this.encrypted || !this.uri) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (isFullSegmentEncryption(this.method)) {
|
|
|
- let iv = this.iv;
|
|
|
- if (!iv) {
|
|
|
- if (typeof sn !== "number") {
|
|
|
- logger.warn(`missing IV for initialization segment with method="${this.method}" - compliance issue`);
|
|
|
- sn = 0;
|
|
|
- }
|
|
|
- iv = createInitializationVector(sn);
|
|
|
- }
|
|
|
- const decryptdata = new _LevelKey(this.method, this.uri, "identity", this.keyFormatVersions, iv);
|
|
|
- return decryptdata;
|
|
|
- }
|
|
|
- if (this.keyId) {
|
|
|
- const assignedKeyId = keyUriToKeyIdMap[this.uri];
|
|
|
- if (assignedKeyId && !arrayValuesMatch(this.keyId, assignedKeyId)) {
|
|
|
- _LevelKey.setKeyIdForUri(this.uri, this.keyId);
|
|
|
- }
|
|
|
- if (this.pssh) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- }
|
|
|
- const keyBytes = convertDataUriToArrayBytes(this.uri);
|
|
|
- if (keyBytes) {
|
|
|
- switch (this.keyFormat) {
|
|
|
- case KeySystemFormats.WIDEVINE:
|
|
|
- this.pssh = keyBytes;
|
|
|
- if (!this.keyId) {
|
|
|
- const results = parseMultiPssh(keyBytes.buffer);
|
|
|
- if (results.length) {
|
|
|
- var _psshData$kids;
|
|
|
- const psshData = results[0];
|
|
|
- this.keyId = (_psshData$kids = psshData.kids) != null && _psshData$kids.length ? psshData.kids[0] : null;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!this.keyId) {
|
|
|
- this.keyId = getKeyIdFromPlayReadyKey(levelKeys);
|
|
|
- }
|
|
|
- break;
|
|
|
- case KeySystemFormats.PLAYREADY: {
|
|
|
- const PlayReadyKeySystemUUID = new Uint8Array([154, 4, 240, 121, 152, 64, 66, 134, 171, 146, 230, 91, 224, 136, 95, 149]);
|
|
|
- this.pssh = mp4pssh(PlayReadyKeySystemUUID, null, keyBytes);
|
|
|
- this.keyId = parsePlayReadyWRM(keyBytes);
|
|
|
- break;
|
|
|
- }
|
|
|
- default: {
|
|
|
- let keydata = keyBytes.subarray(0, 16);
|
|
|
- if (keydata.length !== 16) {
|
|
|
- const padded = new Uint8Array(16);
|
|
|
- padded.set(keydata, 16 - keydata.length);
|
|
|
- keydata = padded;
|
|
|
- }
|
|
|
- this.keyId = keydata;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (!this.keyId || this.keyId.byteLength !== 16) {
|
|
|
- let keyId;
|
|
|
- keyId = getKeyIdFromWidevineKey(levelKeys);
|
|
|
- if (!keyId) {
|
|
|
- keyId = getKeyIdFromPlayReadyKey(levelKeys);
|
|
|
- if (!keyId) {
|
|
|
- keyId = keyUriToKeyIdMap[this.uri];
|
|
|
- }
|
|
|
- }
|
|
|
- if (keyId) {
|
|
|
- this.keyId = keyId;
|
|
|
- _LevelKey.setKeyIdForUri(this.uri, keyId);
|
|
|
- }
|
|
|
- }
|
|
|
- return this;
|
|
|
- }
|
|
|
-};
|
|
|
-function getKeyIdFromWidevineKey(levelKeys) {
|
|
|
- const widevineKey = levelKeys == null ? void 0 : levelKeys[KeySystemFormats.WIDEVINE];
|
|
|
- if (widevineKey) {
|
|
|
- return widevineKey.keyId;
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function getKeyIdFromPlayReadyKey(levelKeys) {
|
|
|
- const playReadyKey = levelKeys == null ? void 0 : levelKeys[KeySystemFormats.PLAYREADY];
|
|
|
- if (playReadyKey) {
|
|
|
- const playReadyKeyBytes = convertDataUriToArrayBytes(playReadyKey.uri);
|
|
|
- if (playReadyKeyBytes) {
|
|
|
- return parsePlayReadyWRM(playReadyKeyBytes);
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function createInitializationVector(segmentNumber) {
|
|
|
- const uint8View = new Uint8Array(16);
|
|
|
- for (let i = 12; i < 16; i++) {
|
|
|
- uint8View[i] = segmentNumber >> 8 * (15 - i) & 255;
|
|
|
- }
|
|
|
- return uint8View;
|
|
|
-}
|
|
|
-var MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\r\n]*)(?:[\r\n](?:#[^\r\n]*)?)*([^\r\n]+)|#EXT-X-(SESSION-DATA|SESSION-KEY|DEFINE|CONTENT-STEERING|START):([^\r\n]*)[\r\n]+/g;
|
|
|
-var MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
|
|
|
-var IS_MEDIA_PLAYLIST = /^#EXT(?:INF|-X-TARGETDURATION):/m;
|
|
|
-var LEVEL_PLAYLIST_REGEX_FAST = new RegExp([
|
|
|
- /#EXTINF:\s*(\d*(?:\.\d+)?)(?:,(.*)\s+)?/.source,
|
|
|
- // duration (#EXTINF:<duration>,<title>), group 1 => duration, group 2 => title
|
|
|
- /(?!#) *(\S[^\r\n]*)/.source,
|
|
|
- // segment URI, group 3 => the URI (note newline is not eaten)
|
|
|
- /#.*/.source
|
|
|
- // All other non-segment oriented tags will match with all groups empty
|
|
|
-].join("|"), "g");
|
|
|
-var LEVEL_PLAYLIST_REGEX_SLOW = new RegExp([/#EXT-X-(PROGRAM-DATE-TIME|BYTERANGE|DATERANGE|DEFINE|KEY|MAP|PART|PART-INF|PLAYLIST-TYPE|PRELOAD-HINT|RENDITION-REPORT|SERVER-CONTROL|SKIP|START):(.+)/.source, /#EXT-X-(BITRATE|DISCONTINUITY-SEQUENCE|MEDIA-SEQUENCE|TARGETDURATION|VERSION): *(\d+)/.source, /#EXT-X-(DISCONTINUITY|ENDLIST|GAP|INDEPENDENT-SEGMENTS)/.source, /(#)([^:]*):(.*)/.source, /(#)(.*)(?:.*)\r?\n?/.source].join("|"));
|
|
|
-var M3U8Parser = class _M3U8Parser {
|
|
|
- static findGroup(groups, mediaGroupId) {
|
|
|
- for (let i = 0; i < groups.length; i++) {
|
|
|
- const group = groups[i];
|
|
|
- if (group.id === mediaGroupId) {
|
|
|
- return group;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- static resolve(url, baseUrl) {
|
|
|
- return urlToolkitExports.buildAbsoluteURL(baseUrl, url, {
|
|
|
- alwaysNormalize: true
|
|
|
- });
|
|
|
- }
|
|
|
- static isMediaPlaylist(str) {
|
|
|
- return IS_MEDIA_PLAYLIST.test(str);
|
|
|
- }
|
|
|
- static parseMasterPlaylist(string, baseurl) {
|
|
|
- const hasVariableRefs = hasVariableReferences(string);
|
|
|
- const parsed = {
|
|
|
- contentSteering: null,
|
|
|
- levels: [],
|
|
|
- playlistParsingError: null,
|
|
|
- sessionData: null,
|
|
|
- sessionKeys: null,
|
|
|
- startTimeOffset: null,
|
|
|
- variableList: null,
|
|
|
- hasVariableRefs
|
|
|
- };
|
|
|
- const levelsWithKnownCodecs = [];
|
|
|
- MASTER_PLAYLIST_REGEX.lastIndex = 0;
|
|
|
- if (!string.startsWith("#EXTM3U")) {
|
|
|
- parsed.playlistParsingError = new Error("no EXTM3U delimiter");
|
|
|
- return parsed;
|
|
|
- }
|
|
|
- let result;
|
|
|
- while ((result = MASTER_PLAYLIST_REGEX.exec(string)) != null) {
|
|
|
- if (result[1]) {
|
|
|
- var _level$unknownCodecs;
|
|
|
- const attrs = new AttrList(result[1], parsed);
|
|
|
- const uri = substituteVariables(parsed, result[2]);
|
|
|
- const level = {
|
|
|
- attrs,
|
|
|
- bitrate: attrs.decimalInteger("BANDWIDTH") || attrs.decimalInteger("AVERAGE-BANDWIDTH"),
|
|
|
- name: attrs.NAME,
|
|
|
- url: _M3U8Parser.resolve(uri, baseurl)
|
|
|
- };
|
|
|
- const resolution = attrs.decimalResolution("RESOLUTION");
|
|
|
- if (resolution) {
|
|
|
- level.width = resolution.width;
|
|
|
- level.height = resolution.height;
|
|
|
- }
|
|
|
- setCodecs(attrs.CODECS, level);
|
|
|
- const supplementalCodecs = attrs["SUPPLEMENTAL-CODECS"];
|
|
|
- if (supplementalCodecs) {
|
|
|
- level.supplemental = {};
|
|
|
- setCodecs(supplementalCodecs, level.supplemental);
|
|
|
- }
|
|
|
- if (!((_level$unknownCodecs = level.unknownCodecs) != null && _level$unknownCodecs.length)) {
|
|
|
- levelsWithKnownCodecs.push(level);
|
|
|
- }
|
|
|
- parsed.levels.push(level);
|
|
|
- } else if (result[3]) {
|
|
|
- const tag = result[3];
|
|
|
- const attributes = result[4];
|
|
|
- switch (tag) {
|
|
|
- case "SESSION-DATA": {
|
|
|
- const sessionAttrs = new AttrList(attributes, parsed);
|
|
|
- const dataId = sessionAttrs["DATA-ID"];
|
|
|
- if (dataId) {
|
|
|
- if (parsed.sessionData === null) {
|
|
|
- parsed.sessionData = {};
|
|
|
- }
|
|
|
- parsed.sessionData[dataId] = sessionAttrs;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "SESSION-KEY": {
|
|
|
- const sessionKey = parseKey(attributes, baseurl, parsed);
|
|
|
- if (sessionKey.encrypted && sessionKey.isSupported()) {
|
|
|
- if (parsed.sessionKeys === null) {
|
|
|
- parsed.sessionKeys = [];
|
|
|
- }
|
|
|
- parsed.sessionKeys.push(sessionKey);
|
|
|
- } else {
|
|
|
- logger.warn(`[Keys] Ignoring invalid EXT-X-SESSION-KEY tag: "${attributes}"`);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "DEFINE": {
|
|
|
- {
|
|
|
- const variableAttributes = new AttrList(attributes, parsed);
|
|
|
- addVariableDefinition(parsed, variableAttributes, baseurl);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "CONTENT-STEERING": {
|
|
|
- const contentSteeringAttributes = new AttrList(attributes, parsed);
|
|
|
- parsed.contentSteering = {
|
|
|
- uri: _M3U8Parser.resolve(contentSteeringAttributes["SERVER-URI"], baseurl),
|
|
|
- pathwayId: contentSteeringAttributes["PATHWAY-ID"] || "."
|
|
|
- };
|
|
|
- break;
|
|
|
- }
|
|
|
- case "START": {
|
|
|
- parsed.startTimeOffset = parseStartTimeOffset(attributes);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const stripUnknownCodecLevels = levelsWithKnownCodecs.length > 0 && levelsWithKnownCodecs.length < parsed.levels.length;
|
|
|
- parsed.levels = stripUnknownCodecLevels ? levelsWithKnownCodecs : parsed.levels;
|
|
|
- if (parsed.levels.length === 0) {
|
|
|
- parsed.playlistParsingError = new Error("no levels found in manifest");
|
|
|
- }
|
|
|
- return parsed;
|
|
|
- }
|
|
|
- static parseMasterPlaylistMedia(string, baseurl, parsed) {
|
|
|
- let result;
|
|
|
- const results = {};
|
|
|
- const levels = parsed.levels;
|
|
|
- const groupsByType = {
|
|
|
- AUDIO: levels.map((level) => ({
|
|
|
- id: level.attrs.AUDIO,
|
|
|
- audioCodec: level.audioCodec
|
|
|
- })),
|
|
|
- SUBTITLES: levels.map((level) => ({
|
|
|
- id: level.attrs.SUBTITLES,
|
|
|
- textCodec: level.textCodec
|
|
|
- })),
|
|
|
- "CLOSED-CAPTIONS": []
|
|
|
- };
|
|
|
- let id = 0;
|
|
|
- MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0;
|
|
|
- while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) {
|
|
|
- const attrs = new AttrList(result[1], parsed);
|
|
|
- const type = attrs.TYPE;
|
|
|
- if (type) {
|
|
|
- const groups = groupsByType[type];
|
|
|
- const medias = results[type] || [];
|
|
|
- results[type] = medias;
|
|
|
- const lang = attrs.LANGUAGE;
|
|
|
- const assocLang = attrs["ASSOC-LANGUAGE"];
|
|
|
- const channels = attrs.CHANNELS;
|
|
|
- const characteristics = attrs.CHARACTERISTICS;
|
|
|
- const instreamId = attrs["INSTREAM-ID"];
|
|
|
- const media = {
|
|
|
- attrs,
|
|
|
- bitrate: 0,
|
|
|
- id: id++,
|
|
|
- groupId: attrs["GROUP-ID"] || "",
|
|
|
- name: attrs.NAME || lang || "",
|
|
|
- type,
|
|
|
- default: attrs.bool("DEFAULT"),
|
|
|
- autoselect: attrs.bool("AUTOSELECT"),
|
|
|
- forced: attrs.bool("FORCED"),
|
|
|
- lang,
|
|
|
- url: attrs.URI ? _M3U8Parser.resolve(attrs.URI, baseurl) : ""
|
|
|
- };
|
|
|
- if (assocLang) {
|
|
|
- media.assocLang = assocLang;
|
|
|
- }
|
|
|
- if (channels) {
|
|
|
- media.channels = channels;
|
|
|
- }
|
|
|
- if (characteristics) {
|
|
|
- media.characteristics = characteristics;
|
|
|
- }
|
|
|
- if (instreamId) {
|
|
|
- media.instreamId = instreamId;
|
|
|
- }
|
|
|
- if (groups != null && groups.length) {
|
|
|
- const groupCodec = _M3U8Parser.findGroup(groups, media.groupId) || groups[0];
|
|
|
- assignCodec(media, groupCodec, "audioCodec");
|
|
|
- assignCodec(media, groupCodec, "textCodec");
|
|
|
- }
|
|
|
- medias.push(media);
|
|
|
- }
|
|
|
- }
|
|
|
- return results;
|
|
|
- }
|
|
|
- static parseLevelPlaylist(string, baseurl, id, type, levelUrlId, multivariantVariableList) {
|
|
|
- var _LEVEL_PLAYLIST_REGEX;
|
|
|
- const base = {
|
|
|
- url: baseurl
|
|
|
- };
|
|
|
- const level = new LevelDetails(baseurl);
|
|
|
- const fragments = level.fragments;
|
|
|
- const programDateTimes = [];
|
|
|
- let currentInitSegment = null;
|
|
|
- let currentSN = 0;
|
|
|
- let currentPart = 0;
|
|
|
- let totalduration = 0;
|
|
|
- let discontinuityCounter = 0;
|
|
|
- let currentBitrate = 0;
|
|
|
- let prevFrag = null;
|
|
|
- let frag = new Fragment(type, base);
|
|
|
- let result;
|
|
|
- let i;
|
|
|
- let levelkeys;
|
|
|
- let firstPdtIndex = -1;
|
|
|
- let createNextFrag = false;
|
|
|
- let nextByteRange = null;
|
|
|
- let serverControlAttrs;
|
|
|
- LEVEL_PLAYLIST_REGEX_FAST.lastIndex = 0;
|
|
|
- level.m3u8 = string;
|
|
|
- level.hasVariableRefs = hasVariableReferences(string);
|
|
|
- if (((_LEVEL_PLAYLIST_REGEX = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) == null ? void 0 : _LEVEL_PLAYLIST_REGEX[0]) !== "#EXTM3U") {
|
|
|
- level.playlistParsingError = new Error("Missing format identifier #EXTM3U");
|
|
|
- return level;
|
|
|
- }
|
|
|
- while ((result = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) !== null) {
|
|
|
- if (createNextFrag) {
|
|
|
- createNextFrag = false;
|
|
|
- frag = new Fragment(type, base);
|
|
|
- frag.playlistOffset = totalduration;
|
|
|
- frag.setStart(totalduration);
|
|
|
- frag.sn = currentSN;
|
|
|
- frag.cc = discontinuityCounter;
|
|
|
- if (currentBitrate) {
|
|
|
- frag.bitrate = currentBitrate;
|
|
|
- }
|
|
|
- frag.level = id;
|
|
|
- if (currentInitSegment) {
|
|
|
- frag.initSegment = currentInitSegment;
|
|
|
- if (currentInitSegment.rawProgramDateTime) {
|
|
|
- frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
|
|
|
- currentInitSegment.rawProgramDateTime = null;
|
|
|
- }
|
|
|
- if (nextByteRange) {
|
|
|
- frag.setByteRange(nextByteRange);
|
|
|
- nextByteRange = null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const duration = result[1];
|
|
|
- if (duration) {
|
|
|
- frag.duration = parseFloat(duration);
|
|
|
- const title = (" " + result[2]).slice(1);
|
|
|
- frag.title = title || null;
|
|
|
- frag.tagList.push(title ? ["INF", duration, title] : ["INF", duration]);
|
|
|
- } else if (result[3]) {
|
|
|
- if (isFiniteNumber(frag.duration)) {
|
|
|
- frag.playlistOffset = totalduration;
|
|
|
- frag.setStart(totalduration);
|
|
|
- if (levelkeys) {
|
|
|
- setFragLevelKeys(frag, levelkeys, level);
|
|
|
- }
|
|
|
- frag.sn = currentSN;
|
|
|
- frag.level = id;
|
|
|
- frag.cc = discontinuityCounter;
|
|
|
- fragments.push(frag);
|
|
|
- const uri = (" " + result[3]).slice(1);
|
|
|
- frag.relurl = substituteVariables(level, uri);
|
|
|
- assignProgramDateTime(frag, prevFrag, programDateTimes);
|
|
|
- prevFrag = frag;
|
|
|
- totalduration += frag.duration;
|
|
|
- currentSN++;
|
|
|
- currentPart = 0;
|
|
|
- createNextFrag = true;
|
|
|
- }
|
|
|
- } 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 (result[i] !== void 0) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- const tag = (" " + result[i]).slice(1);
|
|
|
- const value1 = (" " + result[i + 1]).slice(1);
|
|
|
- const value2 = result[i + 2] ? (" " + result[i + 2]).slice(1) : null;
|
|
|
- switch (tag) {
|
|
|
- case "BYTERANGE":
|
|
|
- if (prevFrag) {
|
|
|
- frag.setByteRange(value1, prevFrag);
|
|
|
- } else {
|
|
|
- frag.setByteRange(value1);
|
|
|
- }
|
|
|
- break;
|
|
|
- case "PROGRAM-DATE-TIME":
|
|
|
- frag.rawProgramDateTime = value1;
|
|
|
- frag.tagList.push(["PROGRAM-DATE-TIME", value1]);
|
|
|
- if (firstPdtIndex === -1) {
|
|
|
- firstPdtIndex = fragments.length;
|
|
|
- }
|
|
|
- break;
|
|
|
- case "PLAYLIST-TYPE":
|
|
|
- if (level.type) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- }
|
|
|
- level.type = value1.toUpperCase();
|
|
|
- break;
|
|
|
- case "MEDIA-SEQUENCE":
|
|
|
- if (level.startSN !== 0) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- } else if (fragments.length > 0) {
|
|
|
- assignMustAppearBeforeSegmentsError(level, tag, result);
|
|
|
- }
|
|
|
- currentSN = level.startSN = parseInt(value1);
|
|
|
- break;
|
|
|
- case "SKIP": {
|
|
|
- if (level.skippedSegments) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- }
|
|
|
- const skipAttrs = new AttrList(value1, level);
|
|
|
- const skippedSegments = skipAttrs.decimalInteger("SKIPPED-SEGMENTS");
|
|
|
- if (isFiniteNumber(skippedSegments)) {
|
|
|
- level.skippedSegments += skippedSegments;
|
|
|
- for (let _i = skippedSegments; _i--; ) {
|
|
|
- fragments.push(null);
|
|
|
- }
|
|
|
- currentSN += skippedSegments;
|
|
|
- }
|
|
|
- const recentlyRemovedDateranges = skipAttrs.enumeratedString("RECENTLY-REMOVED-DATERANGES");
|
|
|
- if (recentlyRemovedDateranges) {
|
|
|
- level.recentlyRemovedDateranges = (level.recentlyRemovedDateranges || []).concat(recentlyRemovedDateranges.split(" "));
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "TARGETDURATION":
|
|
|
- if (level.targetduration !== 0) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- }
|
|
|
- level.targetduration = Math.max(parseInt(value1), 1);
|
|
|
- break;
|
|
|
- case "VERSION":
|
|
|
- if (level.version !== null) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- }
|
|
|
- level.version = parseInt(value1);
|
|
|
- break;
|
|
|
- case "INDEPENDENT-SEGMENTS":
|
|
|
- break;
|
|
|
- case "ENDLIST":
|
|
|
- if (!level.live) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- }
|
|
|
- level.live = false;
|
|
|
- break;
|
|
|
- case "#":
|
|
|
- if (value1 || value2) {
|
|
|
- frag.tagList.push(value2 ? [value1, value2] : [value1]);
|
|
|
- }
|
|
|
- break;
|
|
|
- case "DISCONTINUITY":
|
|
|
- discontinuityCounter++;
|
|
|
- frag.tagList.push(["DIS"]);
|
|
|
- break;
|
|
|
- case "GAP":
|
|
|
- frag.gap = true;
|
|
|
- frag.tagList.push([tag]);
|
|
|
- break;
|
|
|
- case "BITRATE":
|
|
|
- frag.tagList.push([tag, value1]);
|
|
|
- currentBitrate = parseInt(value1) * 1e3;
|
|
|
- if (isFiniteNumber(currentBitrate)) {
|
|
|
- frag.bitrate = currentBitrate;
|
|
|
- } else {
|
|
|
- currentBitrate = 0;
|
|
|
- }
|
|
|
- break;
|
|
|
- case "DATERANGE": {
|
|
|
- const dateRangeAttr = new AttrList(value1, level);
|
|
|
- const dateRange = new DateRange(dateRangeAttr, level.dateRanges[dateRangeAttr.ID], level.dateRangeTagCount);
|
|
|
- level.dateRangeTagCount++;
|
|
|
- if (dateRange.isValid || level.skippedSegments) {
|
|
|
- level.dateRanges[dateRange.id] = dateRange;
|
|
|
- } else {
|
|
|
- logger.warn(`Ignoring invalid DATERANGE tag: "${value1}"`);
|
|
|
- }
|
|
|
- frag.tagList.push(["EXT-X-DATERANGE", value1]);
|
|
|
- break;
|
|
|
- }
|
|
|
- case "DEFINE": {
|
|
|
- {
|
|
|
- const variableAttributes = new AttrList(value1, level);
|
|
|
- if ("IMPORT" in variableAttributes) {
|
|
|
- importVariableDefinition(level, variableAttributes, multivariantVariableList);
|
|
|
- } else {
|
|
|
- addVariableDefinition(level, variableAttributes, baseurl);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "DISCONTINUITY-SEQUENCE":
|
|
|
- if (level.startCC !== 0) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- } else if (fragments.length > 0) {
|
|
|
- assignMustAppearBeforeSegmentsError(level, tag, result);
|
|
|
- }
|
|
|
- level.startCC = discontinuityCounter = parseInt(value1);
|
|
|
- break;
|
|
|
- case "KEY": {
|
|
|
- const levelKey = parseKey(value1, baseurl, level);
|
|
|
- if (levelKey.isSupported()) {
|
|
|
- if (levelKey.method === "NONE") {
|
|
|
- levelkeys = void 0;
|
|
|
- break;
|
|
|
- }
|
|
|
- if (!levelkeys) {
|
|
|
- levelkeys = {};
|
|
|
- }
|
|
|
- const currentKey = levelkeys[levelKey.keyFormat];
|
|
|
- if (!(currentKey != null && currentKey.matches(levelKey))) {
|
|
|
- if (currentKey) {
|
|
|
- levelkeys = _extends({}, levelkeys);
|
|
|
- }
|
|
|
- levelkeys[levelKey.keyFormat] = levelKey;
|
|
|
- }
|
|
|
- } else {
|
|
|
- logger.warn(`[Keys] Ignoring unsupported EXT-X-KEY tag: "${value1}"${""}`);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "START":
|
|
|
- level.startTimeOffset = parseStartTimeOffset(value1);
|
|
|
- break;
|
|
|
- case "MAP": {
|
|
|
- const mapAttrs = new AttrList(value1, level);
|
|
|
- if (frag.duration) {
|
|
|
- const init = new Fragment(type, base);
|
|
|
- setInitSegment(init, mapAttrs, id, levelkeys);
|
|
|
- currentInitSegment = init;
|
|
|
- frag.initSegment = currentInitSegment;
|
|
|
- if (currentInitSegment.rawProgramDateTime && !frag.rawProgramDateTime) {
|
|
|
- frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
|
|
|
- }
|
|
|
- } else {
|
|
|
- const end = frag.byteRangeEndOffset;
|
|
|
- if (end) {
|
|
|
- const start = frag.byteRangeStartOffset;
|
|
|
- nextByteRange = `${end - start}@${start}`;
|
|
|
- } else {
|
|
|
- nextByteRange = null;
|
|
|
- }
|
|
|
- setInitSegment(frag, mapAttrs, id, levelkeys);
|
|
|
- currentInitSegment = frag;
|
|
|
- createNextFrag = true;
|
|
|
- }
|
|
|
- currentInitSegment.cc = discontinuityCounter;
|
|
|
- break;
|
|
|
- }
|
|
|
- case "SERVER-CONTROL": {
|
|
|
- if (serverControlAttrs) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- }
|
|
|
- serverControlAttrs = new AttrList(value1);
|
|
|
- level.canBlockReload = serverControlAttrs.bool("CAN-BLOCK-RELOAD");
|
|
|
- level.canSkipUntil = serverControlAttrs.optionalFloat("CAN-SKIP-UNTIL", 0);
|
|
|
- level.canSkipDateRanges = level.canSkipUntil > 0 && serverControlAttrs.bool("CAN-SKIP-DATERANGES");
|
|
|
- level.partHoldBack = serverControlAttrs.optionalFloat("PART-HOLD-BACK", 0);
|
|
|
- level.holdBack = serverControlAttrs.optionalFloat("HOLD-BACK", 0);
|
|
|
- break;
|
|
|
- }
|
|
|
- case "PART-INF": {
|
|
|
- if (level.partTarget) {
|
|
|
- assignMultipleMediaPlaylistTagOccuranceError(level, tag, result);
|
|
|
- }
|
|
|
- const partInfAttrs = new AttrList(value1);
|
|
|
- level.partTarget = partInfAttrs.decimalFloatingPoint("PART-TARGET");
|
|
|
- break;
|
|
|
- }
|
|
|
- case "PART": {
|
|
|
- let partList = level.partList;
|
|
|
- if (!partList) {
|
|
|
- partList = level.partList = [];
|
|
|
- }
|
|
|
- const previousFragmentPart = currentPart > 0 ? partList[partList.length - 1] : void 0;
|
|
|
- const index = currentPart++;
|
|
|
- const partAttrs = new AttrList(value1, level);
|
|
|
- const part = new Part(partAttrs, frag, base, index, previousFragmentPart);
|
|
|
- partList.push(part);
|
|
|
- frag.duration += part.duration;
|
|
|
- break;
|
|
|
- }
|
|
|
- case "PRELOAD-HINT": {
|
|
|
- const preloadHintAttrs = new AttrList(value1, level);
|
|
|
- level.preloadHint = preloadHintAttrs;
|
|
|
- break;
|
|
|
- }
|
|
|
- case "RENDITION-REPORT": {
|
|
|
- const renditionReportAttrs = new AttrList(value1, level);
|
|
|
- level.renditionReports = level.renditionReports || [];
|
|
|
- level.renditionReports.push(renditionReportAttrs);
|
|
|
- break;
|
|
|
- }
|
|
|
- default:
|
|
|
- logger.warn(`line parsed but not handled: ${result}`);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (prevFrag && !prevFrag.relurl) {
|
|
|
- fragments.pop();
|
|
|
- totalduration -= prevFrag.duration;
|
|
|
- if (level.partList) {
|
|
|
- level.fragmentHint = prevFrag;
|
|
|
- }
|
|
|
- } else if (level.partList) {
|
|
|
- assignProgramDateTime(frag, prevFrag, programDateTimes);
|
|
|
- frag.cc = discontinuityCounter;
|
|
|
- level.fragmentHint = frag;
|
|
|
- if (levelkeys) {
|
|
|
- setFragLevelKeys(frag, levelkeys, level);
|
|
|
- }
|
|
|
- }
|
|
|
- if (!level.targetduration) {
|
|
|
- level.playlistParsingError = new Error(`Missing Target Duration`);
|
|
|
- }
|
|
|
- const fragmentLength = fragments.length;
|
|
|
- const firstFragment = fragments[0];
|
|
|
- const lastFragment = fragments[fragmentLength - 1];
|
|
|
- totalduration += level.skippedSegments * level.targetduration;
|
|
|
- if (totalduration > 0 && fragmentLength && lastFragment) {
|
|
|
- level.averagetargetduration = totalduration / fragmentLength;
|
|
|
- const lastSn = lastFragment.sn;
|
|
|
- level.endSN = lastSn !== "initSegment" ? lastSn : 0;
|
|
|
- if (!level.live) {
|
|
|
- lastFragment.endList = true;
|
|
|
- }
|
|
|
- if (firstPdtIndex > 0) {
|
|
|
- backfillProgramDateTimes(fragments, firstPdtIndex);
|
|
|
- if (firstFragment) {
|
|
|
- programDateTimes.unshift(firstFragment);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (level.fragmentHint) {
|
|
|
- totalduration += level.fragmentHint.duration;
|
|
|
- }
|
|
|
- level.totalduration = totalduration;
|
|
|
- if (programDateTimes.length && level.dateRangeTagCount && firstFragment) {
|
|
|
- mapDateRanges(programDateTimes, level);
|
|
|
- }
|
|
|
- level.endCC = discontinuityCounter;
|
|
|
- return level;
|
|
|
- }
|
|
|
-};
|
|
|
-function mapDateRanges(programDateTimes, details) {
|
|
|
- let programDateTimeCount = programDateTimes.length;
|
|
|
- if (!programDateTimeCount) {
|
|
|
- if (details.hasProgramDateTime) {
|
|
|
- const lastFragment = details.fragments[details.fragments.length - 1];
|
|
|
- programDateTimes.push(lastFragment);
|
|
|
- programDateTimeCount++;
|
|
|
- } else {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const lastProgramDateTime = programDateTimes[programDateTimeCount - 1];
|
|
|
- const playlistEnd = details.live ? Infinity : details.totalduration;
|
|
|
- const dateRangeIds = Object.keys(details.dateRanges);
|
|
|
- for (let i = dateRangeIds.length; i--; ) {
|
|
|
- const dateRange = details.dateRanges[dateRangeIds[i]];
|
|
|
- const startDateTime = dateRange.startDate.getTime();
|
|
|
- dateRange.tagAnchor = lastProgramDateTime.ref;
|
|
|
- for (let j = programDateTimeCount; j--; ) {
|
|
|
- var _programDateTimes$j;
|
|
|
- if (((_programDateTimes$j = programDateTimes[j]) == null ? void 0 : _programDateTimes$j.sn) < details.startSN) {
|
|
|
- break;
|
|
|
- }
|
|
|
- const fragIndex = findFragmentWithStartDate(details, startDateTime, programDateTimes, j, playlistEnd);
|
|
|
- if (fragIndex !== -1) {
|
|
|
- dateRange.tagAnchor = details.fragments[fragIndex].ref;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function findFragmentWithStartDate(details, startDateTime, programDateTimes, index, endTime) {
|
|
|
- const pdtFragment = programDateTimes[index];
|
|
|
- if (pdtFragment) {
|
|
|
- const pdtStart = pdtFragment.programDateTime;
|
|
|
- if (startDateTime >= pdtStart || index === 0) {
|
|
|
- var _programDateTimes;
|
|
|
- const durationBetweenPdt = (((_programDateTimes = programDateTimes[index + 1]) == null ? void 0 : _programDateTimes.start) || endTime) - pdtFragment.start;
|
|
|
- if (startDateTime <= pdtStart + durationBetweenPdt * 1e3) {
|
|
|
- const startIndex = programDateTimes[index].sn - details.startSN;
|
|
|
- if (startIndex < 0) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- const fragments = details.fragments;
|
|
|
- if (fragments.length > programDateTimes.length) {
|
|
|
- const endSegment = programDateTimes[index + 1] || fragments[fragments.length - 1];
|
|
|
- const endIndex = endSegment.sn - details.startSN;
|
|
|
- for (let i = endIndex; i > startIndex; i--) {
|
|
|
- const fragStartDateTime = fragments[i].programDateTime;
|
|
|
- if (startDateTime >= fragStartDateTime && startDateTime < fragStartDateTime + fragments[i].duration * 1e3) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return startIndex;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
-}
|
|
|
-function parseKey(keyTagAttributes, baseurl, parsed) {
|
|
|
- var _keyAttrs$METHOD, _keyAttrs$KEYFORMAT;
|
|
|
- const keyAttrs = new AttrList(keyTagAttributes, parsed);
|
|
|
- const decryptmethod = (_keyAttrs$METHOD = keyAttrs.METHOD) != null ? _keyAttrs$METHOD : "";
|
|
|
- const decrypturi = keyAttrs.URI;
|
|
|
- const decryptiv = keyAttrs.hexadecimalInteger("IV");
|
|
|
- const decryptkeyformatversions = keyAttrs.KEYFORMATVERSIONS;
|
|
|
- const decryptkeyformat = (_keyAttrs$KEYFORMAT = keyAttrs.KEYFORMAT) != null ? _keyAttrs$KEYFORMAT : "identity";
|
|
|
- if (decrypturi && keyAttrs.IV && !decryptiv) {
|
|
|
- logger.error(`Invalid IV: ${keyAttrs.IV}`);
|
|
|
- }
|
|
|
- const resolvedUri = decrypturi ? M3U8Parser.resolve(decrypturi, baseurl) : "";
|
|
|
- const keyFormatVersions = (decryptkeyformatversions ? decryptkeyformatversions : "1").split("/").map(Number).filter(Number.isFinite);
|
|
|
- return new LevelKey(decryptmethod, resolvedUri, decryptkeyformat, keyFormatVersions, decryptiv, keyAttrs.KEYID);
|
|
|
-}
|
|
|
-function parseStartTimeOffset(startAttributes) {
|
|
|
- const startAttrs = new AttrList(startAttributes);
|
|
|
- const startTimeOffset = startAttrs.decimalFloatingPoint("TIME-OFFSET");
|
|
|
- if (isFiniteNumber(startTimeOffset)) {
|
|
|
- return startTimeOffset;
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function setCodecs(codecsAttributeValue, level) {
|
|
|
- let codecs = (codecsAttributeValue || "").split(/[ ,]+/).filter((c) => c);
|
|
|
- ["video", "audio", "text"].forEach((type) => {
|
|
|
- const filtered = codecs.filter((codec) => isCodecType(codec, type));
|
|
|
- if (filtered.length) {
|
|
|
- level[`${type}Codec`] = filtered.map((c) => c.split("/")[0]).join(",");
|
|
|
- codecs = codecs.filter((codec) => filtered.indexOf(codec) === -1);
|
|
|
- }
|
|
|
- });
|
|
|
- level.unknownCodecs = codecs;
|
|
|
-}
|
|
|
-function assignCodec(media, groupItem, codecProperty) {
|
|
|
- const codecValue = groupItem[codecProperty];
|
|
|
- if (codecValue) {
|
|
|
- media[codecProperty] = codecValue;
|
|
|
- }
|
|
|
-}
|
|
|
-function backfillProgramDateTimes(fragments, firstPdtIndex) {
|
|
|
- let fragPrev = fragments[firstPdtIndex];
|
|
|
- for (let i = firstPdtIndex; i--; ) {
|
|
|
- const frag = fragments[i];
|
|
|
- if (!frag) {
|
|
|
- return;
|
|
|
- }
|
|
|
- frag.programDateTime = fragPrev.programDateTime - frag.duration * 1e3;
|
|
|
- fragPrev = frag;
|
|
|
- }
|
|
|
-}
|
|
|
-function assignProgramDateTime(frag, prevFrag, programDateTimes) {
|
|
|
- if (frag.rawProgramDateTime) {
|
|
|
- programDateTimes.push(frag);
|
|
|
- } else if (prevFrag != null && prevFrag.programDateTime) {
|
|
|
- frag.programDateTime = prevFrag.endProgramDateTime;
|
|
|
- }
|
|
|
-}
|
|
|
-function setInitSegment(frag, mapAttrs, id, levelkeys) {
|
|
|
- frag.relurl = mapAttrs.URI;
|
|
|
- if (mapAttrs.BYTERANGE) {
|
|
|
- frag.setByteRange(mapAttrs.BYTERANGE);
|
|
|
- }
|
|
|
- frag.level = id;
|
|
|
- frag.sn = "initSegment";
|
|
|
- if (levelkeys) {
|
|
|
- frag.levelkeys = levelkeys;
|
|
|
- }
|
|
|
- frag.initSegment = null;
|
|
|
-}
|
|
|
-function setFragLevelKeys(frag, levelkeys, level) {
|
|
|
- frag.levelkeys = levelkeys;
|
|
|
- const {
|
|
|
- encryptedFragments
|
|
|
- } = level;
|
|
|
- if ((!encryptedFragments.length || encryptedFragments[encryptedFragments.length - 1].levelkeys !== levelkeys) && Object.keys(levelkeys).some((format2) => levelkeys[format2].isCommonEncryption)) {
|
|
|
- encryptedFragments.push(frag);
|
|
|
- }
|
|
|
-}
|
|
|
-function assignMultipleMediaPlaylistTagOccuranceError(level, tag, result) {
|
|
|
- level.playlistParsingError = new Error(`#EXT-X-${tag} must not appear more than once (${result[0]})`);
|
|
|
-}
|
|
|
-function assignMustAppearBeforeSegmentsError(level, tag, result) {
|
|
|
- level.playlistParsingError = new Error(`#EXT-X-${tag} must appear before the first Media Segment (${result[0]})`);
|
|
|
-}
|
|
|
-function updateFromToPTS(fragFrom, fragTo) {
|
|
|
- const fragToPTS = fragTo.startPTS;
|
|
|
- if (isFiniteNumber(fragToPTS)) {
|
|
|
- let duration = 0;
|
|
|
- let frag;
|
|
|
- if (fragTo.sn > fragFrom.sn) {
|
|
|
- duration = fragToPTS - fragFrom.start;
|
|
|
- frag = fragFrom;
|
|
|
- } else {
|
|
|
- duration = fragFrom.start - fragToPTS;
|
|
|
- frag = fragTo;
|
|
|
- }
|
|
|
- if (frag.duration !== duration) {
|
|
|
- frag.setDuration(duration);
|
|
|
- }
|
|
|
- } else if (fragTo.sn > fragFrom.sn) {
|
|
|
- const contiguous = fragFrom.cc === fragTo.cc;
|
|
|
- if (contiguous && fragFrom.minEndPTS) {
|
|
|
- fragTo.setStart(fragFrom.start + (fragFrom.minEndPTS - fragFrom.start));
|
|
|
- } else {
|
|
|
- fragTo.setStart(fragFrom.start + fragFrom.duration);
|
|
|
- }
|
|
|
- } else {
|
|
|
- fragTo.setStart(Math.max(fragFrom.start - fragTo.duration, 0));
|
|
|
- }
|
|
|
-}
|
|
|
-function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS, logger2) {
|
|
|
- const parsedMediaDuration = endPTS - startPTS;
|
|
|
- if (parsedMediaDuration <= 0) {
|
|
|
- logger2.warn("Fragment should have a positive duration", frag);
|
|
|
- endPTS = startPTS + frag.duration;
|
|
|
- endDTS = startDTS + frag.duration;
|
|
|
- }
|
|
|
- let maxStartPTS = startPTS;
|
|
|
- let minEndPTS = endPTS;
|
|
|
- const fragStartPts = frag.startPTS;
|
|
|
- const fragEndPts = frag.endPTS;
|
|
|
- if (isFiniteNumber(fragStartPts)) {
|
|
|
- const deltaPTS = Math.abs(fragStartPts - startPTS);
|
|
|
- if (details && deltaPTS > details.totalduration) {
|
|
|
- logger2.warn(`media timestamps and playlist times differ by ${deltaPTS}s for level ${frag.level} ${details.url}`);
|
|
|
- } else if (!isFiniteNumber(frag.deltaPTS)) {
|
|
|
- frag.deltaPTS = deltaPTS;
|
|
|
- } else {
|
|
|
- frag.deltaPTS = Math.max(deltaPTS, frag.deltaPTS);
|
|
|
- }
|
|
|
- maxStartPTS = Math.max(startPTS, fragStartPts);
|
|
|
- startPTS = Math.min(startPTS, fragStartPts);
|
|
|
- startDTS = frag.startDTS !== void 0 ? Math.min(startDTS, frag.startDTS) : startDTS;
|
|
|
- minEndPTS = Math.min(endPTS, fragEndPts);
|
|
|
- endPTS = Math.max(endPTS, fragEndPts);
|
|
|
- endDTS = frag.endDTS !== void 0 ? Math.max(endDTS, frag.endDTS) : endDTS;
|
|
|
- }
|
|
|
- const drift = startPTS - frag.start;
|
|
|
- if (frag.start !== 0) {
|
|
|
- frag.setStart(startPTS);
|
|
|
- }
|
|
|
- frag.setDuration(endPTS - frag.start);
|
|
|
- frag.startPTS = startPTS;
|
|
|
- frag.maxStartPTS = maxStartPTS;
|
|
|
- frag.startDTS = startDTS;
|
|
|
- frag.endPTS = endPTS;
|
|
|
- frag.minEndPTS = minEndPTS;
|
|
|
- frag.endDTS = endDTS;
|
|
|
- const sn = frag.sn;
|
|
|
- if (!details || sn < details.startSN || sn > details.endSN) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- let i;
|
|
|
- const fragIdx = sn - details.startSN;
|
|
|
- const fragments = details.fragments;
|
|
|
- fragments[fragIdx] = frag;
|
|
|
- for (i = fragIdx; i > 0; i--) {
|
|
|
- updateFromToPTS(fragments[i], fragments[i - 1]);
|
|
|
- }
|
|
|
- for (i = fragIdx; i < fragments.length - 1; i++) {
|
|
|
- updateFromToPTS(fragments[i], fragments[i + 1]);
|
|
|
- }
|
|
|
- if (details.fragmentHint) {
|
|
|
- updateFromToPTS(fragments[fragments.length - 1], details.fragmentHint);
|
|
|
- }
|
|
|
- details.PTSKnown = details.alignedSliding = true;
|
|
|
- return drift;
|
|
|
-}
|
|
|
-function mergeDetails(oldDetails, newDetails, logger2) {
|
|
|
- if (oldDetails === newDetails) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let currentInitSegment = null;
|
|
|
- const oldFragments = oldDetails.fragments;
|
|
|
- for (let i = oldFragments.length - 1; i >= 0; i--) {
|
|
|
- const oldInit = oldFragments[i].initSegment;
|
|
|
- if (oldInit) {
|
|
|
- currentInitSegment = oldInit;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (oldDetails.fragmentHint) {
|
|
|
- delete oldDetails.fragmentHint.endPTS;
|
|
|
- }
|
|
|
- let PTSFrag;
|
|
|
- mapFragmentIntersection(oldDetails, newDetails, (oldFrag, newFrag, newFragIndex, newFragments2) => {
|
|
|
- if ((!newDetails.startCC || newDetails.skippedSegments) && newFrag.cc !== oldFrag.cc) {
|
|
|
- const ccOffset = oldFrag.cc - newFrag.cc;
|
|
|
- for (let i = newFragIndex; i < newFragments2.length; i++) {
|
|
|
- newFragments2[i].cc += ccOffset;
|
|
|
- }
|
|
|
- newDetails.endCC = newFragments2[newFragments2.length - 1].cc;
|
|
|
- }
|
|
|
- if (isFiniteNumber(oldFrag.startPTS) && isFiniteNumber(oldFrag.endPTS)) {
|
|
|
- newFrag.setStart(newFrag.startPTS = oldFrag.startPTS);
|
|
|
- newFrag.startDTS = oldFrag.startDTS;
|
|
|
- newFrag.maxStartPTS = oldFrag.maxStartPTS;
|
|
|
- newFrag.endPTS = oldFrag.endPTS;
|
|
|
- newFrag.endDTS = oldFrag.endDTS;
|
|
|
- newFrag.minEndPTS = oldFrag.minEndPTS;
|
|
|
- newFrag.setDuration(oldFrag.endPTS - oldFrag.startPTS);
|
|
|
- if (newFrag.duration) {
|
|
|
- PTSFrag = newFrag;
|
|
|
- }
|
|
|
- newDetails.PTSKnown = newDetails.alignedSliding = true;
|
|
|
- }
|
|
|
- if (oldFrag.hasStreams) {
|
|
|
- newFrag.elementaryStreams = oldFrag.elementaryStreams;
|
|
|
- }
|
|
|
- newFrag.loader = oldFrag.loader;
|
|
|
- if (oldFrag.hasStats) {
|
|
|
- newFrag.stats = oldFrag.stats;
|
|
|
- }
|
|
|
- if (oldFrag.initSegment) {
|
|
|
- newFrag.initSegment = oldFrag.initSegment;
|
|
|
- currentInitSegment = oldFrag.initSegment;
|
|
|
- }
|
|
|
- });
|
|
|
- const newFragments = newDetails.fragments;
|
|
|
- const fragmentsToCheck = newDetails.fragmentHint ? newFragments.concat(newDetails.fragmentHint) : newFragments;
|
|
|
- if (currentInitSegment) {
|
|
|
- fragmentsToCheck.forEach((frag) => {
|
|
|
- var _currentInitSegment;
|
|
|
- if (frag && (!frag.initSegment || frag.initSegment.relurl === ((_currentInitSegment = currentInitSegment) == null ? void 0 : _currentInitSegment.relurl))) {
|
|
|
- frag.initSegment = currentInitSegment;
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- if (newDetails.skippedSegments) {
|
|
|
- newDetails.deltaUpdateFailed = newFragments.some((frag) => !frag);
|
|
|
- if (newDetails.deltaUpdateFailed) {
|
|
|
- logger2.warn("[level-helper] Previous playlist missing segments skipped in delta playlist");
|
|
|
- for (let i = newDetails.skippedSegments; i--; ) {
|
|
|
- newFragments.shift();
|
|
|
- }
|
|
|
- newDetails.startSN = newFragments[0].sn;
|
|
|
- } else {
|
|
|
- if (newDetails.canSkipDateRanges) {
|
|
|
- newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails, logger2);
|
|
|
- }
|
|
|
- const programDateTimes = oldDetails.fragments.filter((frag) => frag.rawProgramDateTime);
|
|
|
- if (oldDetails.hasProgramDateTime && !newDetails.hasProgramDateTime) {
|
|
|
- for (let i = 1; i < fragmentsToCheck.length; i++) {
|
|
|
- if (fragmentsToCheck[i].programDateTime === null) {
|
|
|
- assignProgramDateTime(fragmentsToCheck[i], fragmentsToCheck[i - 1], programDateTimes);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- mapDateRanges(programDateTimes, newDetails);
|
|
|
- }
|
|
|
- newDetails.endCC = newFragments[newFragments.length - 1].cc;
|
|
|
- }
|
|
|
- if (!newDetails.startCC) {
|
|
|
- var _fragPriorToNewStart$;
|
|
|
- const fragPriorToNewStart = getFragmentWithSN(oldDetails, newDetails.startSN - 1);
|
|
|
- newDetails.startCC = (_fragPriorToNewStart$ = fragPriorToNewStart == null ? void 0 : fragPriorToNewStart.cc) != null ? _fragPriorToNewStart$ : newFragments[0].cc;
|
|
|
- }
|
|
|
- mapPartIntersection(oldDetails.partList, newDetails.partList, (oldPart, newPart) => {
|
|
|
- newPart.elementaryStreams = oldPart.elementaryStreams;
|
|
|
- newPart.stats = oldPart.stats;
|
|
|
- });
|
|
|
- if (PTSFrag) {
|
|
|
- updateFragPTSDTS(newDetails, PTSFrag, PTSFrag.startPTS, PTSFrag.endPTS, PTSFrag.startDTS, PTSFrag.endDTS, logger2);
|
|
|
- } else {
|
|
|
- adjustSliding(oldDetails, newDetails);
|
|
|
- }
|
|
|
- if (newFragments.length) {
|
|
|
- newDetails.totalduration = newDetails.edge - newFragments[0].start;
|
|
|
- }
|
|
|
- newDetails.driftStartTime = oldDetails.driftStartTime;
|
|
|
- newDetails.driftStart = oldDetails.driftStart;
|
|
|
- const advancedDateTime = newDetails.advancedDateTime;
|
|
|
- if (newDetails.advanced && advancedDateTime) {
|
|
|
- const edge = newDetails.edge;
|
|
|
- if (!newDetails.driftStart) {
|
|
|
- newDetails.driftStartTime = advancedDateTime;
|
|
|
- newDetails.driftStart = edge;
|
|
|
- }
|
|
|
- newDetails.driftEndTime = advancedDateTime;
|
|
|
- newDetails.driftEnd = edge;
|
|
|
- } else {
|
|
|
- newDetails.driftEndTime = oldDetails.driftEndTime;
|
|
|
- newDetails.driftEnd = oldDetails.driftEnd;
|
|
|
- newDetails.advancedDateTime = oldDetails.advancedDateTime;
|
|
|
- }
|
|
|
- if (newDetails.requestScheduled === -1) {
|
|
|
- newDetails.requestScheduled = oldDetails.requestScheduled;
|
|
|
- }
|
|
|
-}
|
|
|
-function mergeDateRanges(oldDateRanges, newDetails, logger2) {
|
|
|
- const {
|
|
|
- dateRanges: deltaDateRanges,
|
|
|
- recentlyRemovedDateranges
|
|
|
- } = newDetails;
|
|
|
- const dateRanges = _extends({}, oldDateRanges);
|
|
|
- if (recentlyRemovedDateranges) {
|
|
|
- recentlyRemovedDateranges.forEach((id) => {
|
|
|
- delete dateRanges[id];
|
|
|
- });
|
|
|
- }
|
|
|
- const mergeIds = Object.keys(dateRanges);
|
|
|
- const mergeCount = mergeIds.length;
|
|
|
- if (!mergeCount) {
|
|
|
- return deltaDateRanges;
|
|
|
- }
|
|
|
- Object.keys(deltaDateRanges).forEach((id) => {
|
|
|
- const mergedDateRange = dateRanges[id];
|
|
|
- const dateRange = new DateRange(deltaDateRanges[id].attr, mergedDateRange);
|
|
|
- if (dateRange.isValid) {
|
|
|
- dateRanges[id] = dateRange;
|
|
|
- if (!mergedDateRange) {
|
|
|
- dateRange.tagOrder += mergeCount;
|
|
|
- }
|
|
|
- } else {
|
|
|
- logger2.warn(`Ignoring invalid Playlist Delta Update DATERANGE tag: "${stringify(deltaDateRanges[id].attr)}"`);
|
|
|
- }
|
|
|
- });
|
|
|
- return dateRanges;
|
|
|
-}
|
|
|
-function mapPartIntersection(oldParts, newParts, intersectionFn) {
|
|
|
- if (oldParts && newParts) {
|
|
|
- let delta = 0;
|
|
|
- for (let i = 0, len = oldParts.length; i <= len; i++) {
|
|
|
- const oldPart = oldParts[i];
|
|
|
- const newPart = newParts[i + delta];
|
|
|
- if (oldPart && newPart && oldPart.index === newPart.index && oldPart.fragment.sn === newPart.fragment.sn) {
|
|
|
- intersectionFn(oldPart, newPart);
|
|
|
- } else {
|
|
|
- delta--;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function mapFragmentIntersection(oldDetails, newDetails, intersectionFn) {
|
|
|
- const skippedSegments = newDetails.skippedSegments;
|
|
|
- const start = Math.max(oldDetails.startSN, newDetails.startSN) - newDetails.startSN;
|
|
|
- const end = (oldDetails.fragmentHint ? 1 : 0) + (skippedSegments ? newDetails.endSN : Math.min(oldDetails.endSN, newDetails.endSN)) - newDetails.startSN;
|
|
|
- const delta = newDetails.startSN - oldDetails.startSN;
|
|
|
- const newFrags = newDetails.fragmentHint ? newDetails.fragments.concat(newDetails.fragmentHint) : newDetails.fragments;
|
|
|
- const oldFrags = oldDetails.fragmentHint ? oldDetails.fragments.concat(oldDetails.fragmentHint) : oldDetails.fragments;
|
|
|
- for (let i = start; i <= end; i++) {
|
|
|
- const oldFrag = oldFrags[delta + i];
|
|
|
- let newFrag = newFrags[i];
|
|
|
- if (skippedSegments && !newFrag && oldFrag) {
|
|
|
- newFrag = newDetails.fragments[i] = oldFrag;
|
|
|
- }
|
|
|
- if (oldFrag && newFrag) {
|
|
|
- intersectionFn(oldFrag, newFrag, i, newFrags);
|
|
|
- const uriBefore = oldFrag.relurl;
|
|
|
- const uriAfter = newFrag.relurl;
|
|
|
- if (uriBefore && notEqualAfterStrippingQueries(uriBefore, uriAfter)) {
|
|
|
- newDetails.playlistParsingError = getSequenceError(`media sequence mismatch ${newFrag.sn}:`, oldDetails, newDetails, oldFrag, newFrag);
|
|
|
- return;
|
|
|
- } else if (oldFrag.cc !== newFrag.cc) {
|
|
|
- newDetails.playlistParsingError = getSequenceError(`discontinuity sequence mismatch (${oldFrag.cc}!=${newFrag.cc})`, oldDetails, newDetails, oldFrag, newFrag);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function getSequenceError(message, oldDetails, newDetails, oldFrag, newFrag) {
|
|
|
- return new Error(`${message} ${newFrag.url}
|
|
|
-Playlist starting @${oldDetails.startSN}
|
|
|
-${oldDetails.m3u8}
|
|
|
-
|
|
|
-Playlist starting @${newDetails.startSN}
|
|
|
-${newDetails.m3u8}`);
|
|
|
-}
|
|
|
-function adjustSliding(oldDetails, newDetails, matchingStableVariantOrRendition = true) {
|
|
|
- const delta = newDetails.startSN + newDetails.skippedSegments - oldDetails.startSN;
|
|
|
- const oldFragments = oldDetails.fragments;
|
|
|
- const advancedOrStable = delta >= 0;
|
|
|
- let sliding = 0;
|
|
|
- if (advancedOrStable && delta < oldFragments.length) {
|
|
|
- sliding = oldFragments[delta].start;
|
|
|
- } else if (advancedOrStable && newDetails.startSN === oldDetails.endSN + 1) {
|
|
|
- sliding = oldDetails.fragmentEnd;
|
|
|
- } else if (advancedOrStable && matchingStableVariantOrRendition) {
|
|
|
- sliding = oldDetails.fragmentStart + delta * newDetails.levelTargetDuration;
|
|
|
- } else if (!newDetails.skippedSegments && newDetails.fragmentStart === 0) {
|
|
|
- sliding = oldDetails.fragmentStart;
|
|
|
- } else {
|
|
|
- return;
|
|
|
- }
|
|
|
- addSliding(newDetails, sliding);
|
|
|
-}
|
|
|
-function addSliding(details, sliding) {
|
|
|
- if (sliding) {
|
|
|
- const fragments = details.fragments;
|
|
|
- for (let i = details.skippedSegments; i < fragments.length; i++) {
|
|
|
- fragments[i].addStart(sliding);
|
|
|
- }
|
|
|
- if (details.fragmentHint) {
|
|
|
- details.fragmentHint.addStart(sliding);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function computeReloadInterval(newDetails, distanceToLiveEdgeMs = Infinity) {
|
|
|
- let reloadInterval = 1e3 * newDetails.targetduration;
|
|
|
- if (newDetails.updated) {
|
|
|
- const fragments = newDetails.fragments;
|
|
|
- const liveEdgeMaxTargetDurations = 4;
|
|
|
- if (fragments.length && reloadInterval * liveEdgeMaxTargetDurations > distanceToLiveEdgeMs) {
|
|
|
- const lastSegmentDuration = fragments[fragments.length - 1].duration * 1e3;
|
|
|
- if (lastSegmentDuration < reloadInterval) {
|
|
|
- reloadInterval = lastSegmentDuration;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- reloadInterval /= 2;
|
|
|
- }
|
|
|
- return Math.round(reloadInterval);
|
|
|
-}
|
|
|
-function getFragmentWithSN(details, sn, fragCurrent) {
|
|
|
- if (!details) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- let fragment = details.fragments[sn - details.startSN];
|
|
|
- if (fragment) {
|
|
|
- return fragment;
|
|
|
- }
|
|
|
- fragment = details.fragmentHint;
|
|
|
- if (fragment && fragment.sn === sn) {
|
|
|
- return fragment;
|
|
|
- }
|
|
|
- if (sn < details.startSN && fragCurrent && fragCurrent.sn === sn) {
|
|
|
- return fragCurrent;
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function getPartWith(details, sn, partIndex) {
|
|
|
- if (!details) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return findPart(details.partList, sn, partIndex);
|
|
|
-}
|
|
|
-function findPart(partList, sn, partIndex) {
|
|
|
- if (partList) {
|
|
|
- for (let i = partList.length; i--; ) {
|
|
|
- const part = partList[i];
|
|
|
- if (part.index === partIndex && part.fragment.sn === sn) {
|
|
|
- return part;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function reassignFragmentLevelIndexes(levels) {
|
|
|
- levels.forEach((level, index) => {
|
|
|
- var _level$details;
|
|
|
- (_level$details = level.details) == null || _level$details.fragments.forEach((fragment) => {
|
|
|
- fragment.level = index;
|
|
|
- if (fragment.initSegment) {
|
|
|
- fragment.initSegment.level = index;
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
-}
|
|
|
-function notEqualAfterStrippingQueries(uriBefore, uriAfter) {
|
|
|
- if (uriBefore !== uriAfter && uriAfter) {
|
|
|
- return stripQuery(uriBefore) !== stripQuery(uriAfter);
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function stripQuery(uri) {
|
|
|
- return uri.replace(/\?[^?]*$/, "");
|
|
|
-}
|
|
|
-function findFirstFragWithCC(fragments, cc) {
|
|
|
- for (let i = 0, len = fragments.length; i < len; i++) {
|
|
|
- var _fragments$i;
|
|
|
- if (((_fragments$i = fragments[i]) == null ? void 0 : _fragments$i.cc) === cc) {
|
|
|
- return fragments[i];
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function shouldAlignOnDiscontinuities(refDetails, details) {
|
|
|
- if (refDetails) {
|
|
|
- if (details.startCC < refDetails.endCC && details.endCC > refDetails.startCC) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function adjustFragmentStart(frag, sliding) {
|
|
|
- const start = frag.start + sliding;
|
|
|
- frag.startPTS = start;
|
|
|
- frag.setStart(start);
|
|
|
- frag.endPTS = start + frag.duration;
|
|
|
-}
|
|
|
-function adjustSlidingStart(sliding, details) {
|
|
|
- const fragments = details.fragments;
|
|
|
- for (let i = 0, len = fragments.length; i < len; i++) {
|
|
|
- adjustFragmentStart(fragments[i], sliding);
|
|
|
- }
|
|
|
- if (details.fragmentHint) {
|
|
|
- adjustFragmentStart(details.fragmentHint, sliding);
|
|
|
- }
|
|
|
- details.alignedSliding = true;
|
|
|
-}
|
|
|
-function alignStream(switchDetails, details) {
|
|
|
- if (!switchDetails) {
|
|
|
- return;
|
|
|
- }
|
|
|
- alignDiscontinuities(details, switchDetails);
|
|
|
- if (!details.alignedSliding) {
|
|
|
- alignMediaPlaylistByPDT(details, switchDetails);
|
|
|
- }
|
|
|
- if (!details.alignedSliding && !details.skippedSegments) {
|
|
|
- adjustSliding(switchDetails, details, false);
|
|
|
- }
|
|
|
-}
|
|
|
-function alignDiscontinuities(details, refDetails) {
|
|
|
- if (!shouldAlignOnDiscontinuities(refDetails, details)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const targetCC = Math.min(refDetails.endCC, details.endCC);
|
|
|
- const refFrag = findFirstFragWithCC(refDetails.fragments, targetCC);
|
|
|
- const frag = findFirstFragWithCC(details.fragments, targetCC);
|
|
|
- if (!refFrag || !frag) {
|
|
|
- return;
|
|
|
- }
|
|
|
- logger.log(`Aligning playlist at start of dicontinuity sequence ${targetCC}`);
|
|
|
- const delta = refFrag.start - frag.start;
|
|
|
- adjustSlidingStart(delta, details);
|
|
|
-}
|
|
|
-function alignMediaPlaylistByPDT(details, refDetails) {
|
|
|
- if (!details.hasProgramDateTime || !refDetails.hasProgramDateTime) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const fragments = details.fragments;
|
|
|
- const refFragments = refDetails.fragments;
|
|
|
- if (!fragments.length || !refFragments.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let refFrag;
|
|
|
- let frag;
|
|
|
- const targetCC = Math.min(refDetails.endCC, details.endCC);
|
|
|
- if (refDetails.startCC < targetCC && details.startCC < targetCC) {
|
|
|
- refFrag = findFirstFragWithCC(refFragments, targetCC);
|
|
|
- frag = findFirstFragWithCC(fragments, targetCC);
|
|
|
- }
|
|
|
- if (!refFrag || !frag) {
|
|
|
- refFrag = refFragments[Math.floor(refFragments.length / 2)];
|
|
|
- frag = findFirstFragWithCC(fragments, refFrag.cc) || fragments[Math.floor(fragments.length / 2)];
|
|
|
- }
|
|
|
- const refPDT = refFrag.programDateTime;
|
|
|
- const targetPDT = frag.programDateTime;
|
|
|
- if (!refPDT || !targetPDT) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const delta = (targetPDT - refPDT) / 1e3 - (frag.start - refFrag.start);
|
|
|
- adjustSlidingStart(delta, details);
|
|
|
-}
|
|
|
-function addEventListener(el, type, listener) {
|
|
|
- removeEventListener(el, type, listener);
|
|
|
- el.addEventListener(type, listener);
|
|
|
-}
|
|
|
-function removeEventListener(el, type, listener) {
|
|
|
- el.removeEventListener(type, listener);
|
|
|
-}
|
|
|
-var TimeRanges = {
|
|
|
- toString: function(r) {
|
|
|
- let log = "";
|
|
|
- const len = r.length;
|
|
|
- for (let i = 0; i < len; i++) {
|
|
|
- log += `[${r.start(i).toFixed(3)}-${r.end(i).toFixed(3)}]`;
|
|
|
- }
|
|
|
- return log;
|
|
|
- }
|
|
|
-};
|
|
|
-var State = {
|
|
|
- STOPPED: "STOPPED",
|
|
|
- IDLE: "IDLE",
|
|
|
- KEY_LOADING: "KEY_LOADING",
|
|
|
- FRAG_LOADING: "FRAG_LOADING",
|
|
|
- FRAG_LOADING_WAITING_RETRY: "FRAG_LOADING_WAITING_RETRY",
|
|
|
- WAITING_TRACK: "WAITING_TRACK",
|
|
|
- PARSING: "PARSING",
|
|
|
- PARSED: "PARSED",
|
|
|
- ENDED: "ENDED",
|
|
|
- ERROR: "ERROR",
|
|
|
- WAITING_INIT_PTS: "WAITING_INIT_PTS",
|
|
|
- WAITING_LEVEL: "WAITING_LEVEL"
|
|
|
-};
|
|
|
-var BaseStreamController = class extends TaskLoop {
|
|
|
- constructor(hls, fragmentTracker, keyLoader, logPrefix, playlistType) {
|
|
|
- super(logPrefix, hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.fragPrevious = null;
|
|
|
- this.fragCurrent = null;
|
|
|
- this.fragmentTracker = void 0;
|
|
|
- this.transmuxer = null;
|
|
|
- this._state = State.STOPPED;
|
|
|
- this.playlistType = void 0;
|
|
|
- this.media = null;
|
|
|
- this.mediaBuffer = null;
|
|
|
- this.config = void 0;
|
|
|
- this.bitrateTest = false;
|
|
|
- this.lastCurrentTime = 0;
|
|
|
- this.nextLoadPosition = 0;
|
|
|
- this.startPosition = 0;
|
|
|
- this.startTimeOffset = null;
|
|
|
- this.retryDate = 0;
|
|
|
- this.levels = null;
|
|
|
- this.fragmentLoader = void 0;
|
|
|
- this.keyLoader = void 0;
|
|
|
- this.levelLastLoaded = null;
|
|
|
- this.startFragRequested = false;
|
|
|
- this.decrypter = void 0;
|
|
|
- this.initPTS = [];
|
|
|
- this.buffering = true;
|
|
|
- this.loadingParts = false;
|
|
|
- this.loopSn = void 0;
|
|
|
- this.onMediaSeeking = () => {
|
|
|
- const {
|
|
|
- config,
|
|
|
- fragCurrent,
|
|
|
- media,
|
|
|
- mediaBuffer,
|
|
|
- state
|
|
|
- } = this;
|
|
|
- const currentTime = media ? media.currentTime : 0;
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(mediaBuffer ? mediaBuffer : media, currentTime, config.maxBufferHole);
|
|
|
- const noFowardBuffer = !bufferInfo.len;
|
|
|
- this.log(`Media seeking to ${isFiniteNumber(currentTime) ? currentTime.toFixed(3) : currentTime}, state: ${state}, ${noFowardBuffer ? "out of" : "in"} buffer`);
|
|
|
- if (this.state === State.ENDED) {
|
|
|
- this.resetLoadingState();
|
|
|
- } else if (fragCurrent) {
|
|
|
- const tolerance = config.maxFragLookUpTolerance;
|
|
|
- const fragStartOffset = fragCurrent.start - tolerance;
|
|
|
- const fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
|
|
|
- if (noFowardBuffer || fragEndOffset < bufferInfo.start || fragStartOffset > bufferInfo.end) {
|
|
|
- const pastFragment = currentTime > fragEndOffset;
|
|
|
- if (currentTime < fragStartOffset || pastFragment) {
|
|
|
- if (pastFragment && fragCurrent.loader) {
|
|
|
- this.log(`Cancelling fragment load for seek (sn: ${fragCurrent.sn})`);
|
|
|
- fragCurrent.abortRequests();
|
|
|
- this.resetLoadingState();
|
|
|
- }
|
|
|
- this.fragPrevious = null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (media) {
|
|
|
- this.fragmentTracker.removeFragmentsInRange(currentTime, Infinity, this.playlistType, true);
|
|
|
- const lastCurrentTime = this.lastCurrentTime;
|
|
|
- if (currentTime > lastCurrentTime) {
|
|
|
- this.lastCurrentTime = currentTime;
|
|
|
- }
|
|
|
- if (!this.loadingParts) {
|
|
|
- const bufferEnd = Math.max(bufferInfo.end, currentTime);
|
|
|
- const shouldLoadParts = this.shouldLoadParts(this.getLevelDetails(), bufferEnd);
|
|
|
- if (shouldLoadParts) {
|
|
|
- this.log(`LL-Part loading ON after seeking to ${currentTime.toFixed(2)} with buffer @${bufferEnd.toFixed(2)}`);
|
|
|
- this.loadingParts = shouldLoadParts;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (!this.hls.hasEnoughToStart) {
|
|
|
- this.log(`Setting ${noFowardBuffer ? "startPosition" : "nextLoadPosition"} to ${currentTime} for seek without enough to start`);
|
|
|
- this.nextLoadPosition = currentTime;
|
|
|
- if (noFowardBuffer) {
|
|
|
- this.startPosition = currentTime;
|
|
|
- }
|
|
|
- }
|
|
|
- if (noFowardBuffer && this.state === State.IDLE) {
|
|
|
- this.tickImmediate();
|
|
|
- }
|
|
|
- };
|
|
|
- this.onMediaEnded = () => {
|
|
|
- this.log(`setting startPosition to 0 because media ended`);
|
|
|
- this.startPosition = this.lastCurrentTime = 0;
|
|
|
- };
|
|
|
- this.playlistType = playlistType;
|
|
|
- this.hls = hls;
|
|
|
- this.fragmentLoader = new FragmentLoader(hls.config);
|
|
|
- this.keyLoader = keyLoader;
|
|
|
- this.fragmentTracker = fragmentTracker;
|
|
|
- this.config = hls.config;
|
|
|
- this.decrypter = new Decrypter(hls.config);
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- doTick() {
|
|
|
- this.onTickEnd();
|
|
|
- }
|
|
|
- onTickEnd() {
|
|
|
- }
|
|
|
- startLoad(startPosition) {
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- if (this.state === State.STOPPED) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.fragmentLoader.abort();
|
|
|
- this.keyLoader.abort(this.playlistType);
|
|
|
- const frag = this.fragCurrent;
|
|
|
- if (frag != null && frag.loader) {
|
|
|
- frag.abortRequests();
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- }
|
|
|
- this.resetTransmuxer();
|
|
|
- this.fragCurrent = null;
|
|
|
- this.fragPrevious = null;
|
|
|
- this.clearInterval();
|
|
|
- this.clearNextTick();
|
|
|
- this.state = State.STOPPED;
|
|
|
- }
|
|
|
- get startPositionValue() {
|
|
|
- const {
|
|
|
- nextLoadPosition,
|
|
|
- startPosition
|
|
|
- } = this;
|
|
|
- if (startPosition === -1 && nextLoadPosition) {
|
|
|
- return nextLoadPosition;
|
|
|
- }
|
|
|
- return startPosition;
|
|
|
- }
|
|
|
- get bufferingEnabled() {
|
|
|
- return this.buffering;
|
|
|
- }
|
|
|
- pauseBuffering() {
|
|
|
- this.buffering = false;
|
|
|
- }
|
|
|
- resumeBuffering() {
|
|
|
- this.buffering = true;
|
|
|
- }
|
|
|
- get inFlightFrag() {
|
|
|
- return {
|
|
|
- frag: this.fragCurrent,
|
|
|
- state: this.state
|
|
|
- };
|
|
|
- }
|
|
|
- _streamEnded(bufferInfo, levelDetails) {
|
|
|
- if (levelDetails.live || !this.media) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const bufferEnd = bufferInfo.end || 0;
|
|
|
- const timelineStart = this.config.timelineOffset || 0;
|
|
|
- if (bufferEnd <= timelineStart) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const bufferedRanges = bufferInfo.buffered;
|
|
|
- if (this.config.maxBufferHole && bufferedRanges && bufferedRanges.length > 1) {
|
|
|
- bufferInfo = BufferHelper.bufferedInfo(bufferedRanges, bufferInfo.start, 0);
|
|
|
- }
|
|
|
- const nextStart = bufferInfo.nextStart;
|
|
|
- const hasSecondBufferedRange = nextStart && nextStart > timelineStart && nextStart < levelDetails.edge;
|
|
|
- if (hasSecondBufferedRange) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (this.media.currentTime < bufferInfo.start) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const partList = levelDetails.partList;
|
|
|
- if (partList != null && partList.length) {
|
|
|
- const lastPart = partList[partList.length - 1];
|
|
|
- const lastPartBuffered = BufferHelper.isBuffered(this.media, lastPart.start + lastPart.duration / 2);
|
|
|
- return lastPartBuffered;
|
|
|
- }
|
|
|
- const playlistType = levelDetails.fragments[levelDetails.fragments.length - 1].type;
|
|
|
- return this.fragmentTracker.isEndListAppended(playlistType);
|
|
|
- }
|
|
|
- getLevelDetails() {
|
|
|
- if (this.levels && this.levelLastLoaded !== null) {
|
|
|
- return this.levelLastLoaded.details;
|
|
|
- }
|
|
|
- }
|
|
|
- get timelineOffset() {
|
|
|
- const configuredTimelineOffset = this.config.timelineOffset;
|
|
|
- if (configuredTimelineOffset) {
|
|
|
- var _this$getLevelDetails;
|
|
|
- return ((_this$getLevelDetails = this.getLevelDetails()) == null ? void 0 : _this$getLevelDetails.appliedTimelineOffset) || configuredTimelineOffset;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- onMediaAttached(event, data) {
|
|
|
- const media = this.media = this.mediaBuffer = data.media;
|
|
|
- addEventListener(media, "seeking", this.onMediaSeeking);
|
|
|
- addEventListener(media, "ended", this.onMediaEnded);
|
|
|
- const config = this.config;
|
|
|
- if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
|
|
|
- this.startLoad(config.startPosition);
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- const transferringMedia = !!data.transferMedia;
|
|
|
- const media = this.media;
|
|
|
- if (media === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (media.ended) {
|
|
|
- this.log("MSE detaching and video ended, reset startPosition");
|
|
|
- this.startPosition = this.lastCurrentTime = 0;
|
|
|
- }
|
|
|
- removeEventListener(media, "seeking", this.onMediaSeeking);
|
|
|
- removeEventListener(media, "ended", this.onMediaEnded);
|
|
|
- if (this.keyLoader && !transferringMedia) {
|
|
|
- this.keyLoader.detach();
|
|
|
- }
|
|
|
- this.media = this.mediaBuffer = null;
|
|
|
- this.loopSn = void 0;
|
|
|
- if (transferringMedia) {
|
|
|
- this.resetLoadingState();
|
|
|
- this.resetTransmuxer();
|
|
|
- return;
|
|
|
- }
|
|
|
- this.loadingParts = false;
|
|
|
- this.fragmentTracker.removeAllFragments();
|
|
|
- this.stopLoad();
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.initPTS = [];
|
|
|
- this.levels = this.levelLastLoaded = this.fragCurrent = null;
|
|
|
- this.lastCurrentTime = this.startPosition = 0;
|
|
|
- this.startFragRequested = false;
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- }
|
|
|
- onManifestLoaded(event, data) {
|
|
|
- this.startTimeOffset = data.startTimeOffset;
|
|
|
- }
|
|
|
- onHandlerDestroying() {
|
|
|
- this.stopLoad();
|
|
|
- if (this.transmuxer) {
|
|
|
- this.transmuxer.destroy();
|
|
|
- this.transmuxer = null;
|
|
|
- }
|
|
|
- super.onHandlerDestroying();
|
|
|
- this.hls = this.onMediaSeeking = this.onMediaEnded = null;
|
|
|
- }
|
|
|
- onHandlerDestroyed() {
|
|
|
- this.state = State.STOPPED;
|
|
|
- if (this.fragmentLoader) {
|
|
|
- this.fragmentLoader.destroy();
|
|
|
- }
|
|
|
- if (this.keyLoader) {
|
|
|
- this.keyLoader.destroy();
|
|
|
- }
|
|
|
- if (this.decrypter) {
|
|
|
- this.decrypter.destroy();
|
|
|
- }
|
|
|
- this.hls = this.log = this.warn = this.decrypter = this.keyLoader = this.fragmentLoader = this.fragmentTracker = null;
|
|
|
- super.onHandlerDestroyed();
|
|
|
- }
|
|
|
- loadFragment(frag, level, targetBufferTime) {
|
|
|
- this.startFragRequested = true;
|
|
|
- this._loadFragForPlayback(frag, level, targetBufferTime);
|
|
|
- }
|
|
|
- _loadFragForPlayback(fragment, level, targetBufferTime) {
|
|
|
- const progressCallback = (data) => {
|
|
|
- const frag = data.frag;
|
|
|
- if (this.fragContextChanged(frag)) {
|
|
|
- this.warn(`${frag.type} sn: ${frag.sn}${data.part ? " part: " + data.part.index : ""} of ${this.fragInfo(frag, false, data.part)}) was dropped during download.`);
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- return;
|
|
|
- }
|
|
|
- frag.stats.chunkCount++;
|
|
|
- this._handleFragmentLoadProgress(data);
|
|
|
- };
|
|
|
- this._doFragLoad(fragment, level, targetBufferTime, progressCallback).then((data) => {
|
|
|
- if (!data) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const state = this.state;
|
|
|
- const frag = data.frag;
|
|
|
- if (this.fragContextChanged(frag)) {
|
|
|
- if (state === State.FRAG_LOADING || !this.fragCurrent && state === State.PARSING) {
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if ("payload" in data) {
|
|
|
- this.log(`Loaded ${frag.type} sn: ${frag.sn} of ${this.playlistLabel()} ${frag.level}`);
|
|
|
- this.hls.trigger(Events.FRAG_LOADED, data);
|
|
|
- }
|
|
|
- this._handleFragmentLoadComplete(data);
|
|
|
- }).catch((reason) => {
|
|
|
- if (this.state === State.STOPPED || this.state === State.ERROR) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.warn(`Frag error: ${(reason == null ? void 0 : reason.message) || reason}`);
|
|
|
- this.resetFragmentLoading(fragment);
|
|
|
- });
|
|
|
- }
|
|
|
- clearTrackerIfNeeded(frag) {
|
|
|
- var _this$mediaBuffer;
|
|
|
- const {
|
|
|
- fragmentTracker
|
|
|
- } = this;
|
|
|
- const fragState = fragmentTracker.getState(frag);
|
|
|
- if (fragState === FragmentState.APPENDING) {
|
|
|
- const playlistType = frag.type;
|
|
|
- const bufferedInfo = this.getFwdBufferInfo(this.mediaBuffer, playlistType);
|
|
|
- const minForwardBufferLength = Math.max(frag.duration, bufferedInfo ? bufferedInfo.len : this.config.maxBufferLength);
|
|
|
- const backtrackFragment = this.backtrackFragment;
|
|
|
- const backtracked = backtrackFragment ? frag.sn - backtrackFragment.sn : 0;
|
|
|
- if (backtracked === 1 || this.reduceMaxBufferLength(minForwardBufferLength, frag.duration)) {
|
|
|
- fragmentTracker.removeFragment(frag);
|
|
|
- }
|
|
|
- } else if (((_this$mediaBuffer = this.mediaBuffer) == null ? void 0 : _this$mediaBuffer.buffered.length) === 0) {
|
|
|
- fragmentTracker.removeAllFragments();
|
|
|
- } else if (fragmentTracker.hasParts(frag.type)) {
|
|
|
- fragmentTracker.detectPartialFragments({
|
|
|
- frag,
|
|
|
- part: null,
|
|
|
- stats: frag.stats,
|
|
|
- id: frag.type
|
|
|
- });
|
|
|
- if (fragmentTracker.getState(frag) === FragmentState.PARTIAL) {
|
|
|
- fragmentTracker.removeFragment(frag);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- checkLiveUpdate(details) {
|
|
|
- if (details.updated && !details.live) {
|
|
|
- const lastFragment = details.fragments[details.fragments.length - 1];
|
|
|
- this.fragmentTracker.detectPartialFragments({
|
|
|
- frag: lastFragment,
|
|
|
- part: null,
|
|
|
- stats: lastFragment.stats,
|
|
|
- id: lastFragment.type
|
|
|
- });
|
|
|
- }
|
|
|
- if (!details.fragments[0]) {
|
|
|
- details.deltaUpdateFailed = true;
|
|
|
- }
|
|
|
- }
|
|
|
- waitForLive(levelInfo) {
|
|
|
- const details = levelInfo.details;
|
|
|
- return (details == null ? void 0 : details.live) && details.type !== "EVENT" && (this.levelLastLoaded !== levelInfo || details.expired);
|
|
|
- }
|
|
|
- flushMainBuffer(startOffset, endOffset, type = null) {
|
|
|
- if (!(startOffset - endOffset)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const flushScope = {
|
|
|
- startOffset,
|
|
|
- endOffset,
|
|
|
- type
|
|
|
- };
|
|
|
- this.hls.trigger(Events.BUFFER_FLUSHING, flushScope);
|
|
|
- }
|
|
|
- _loadInitSegment(fragment, level) {
|
|
|
- this._doFragLoad(fragment, level).then((data) => {
|
|
|
- const frag = data == null ? void 0 : data.frag;
|
|
|
- if (!frag || this.fragContextChanged(frag) || !this.levels) {
|
|
|
- throw new Error("init load aborted");
|
|
|
- }
|
|
|
- return data;
|
|
|
- }).then((data) => {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- frag,
|
|
|
- payload
|
|
|
- } = data;
|
|
|
- const decryptData = frag.decryptdata;
|
|
|
- if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && isFullSegmentEncryption(decryptData.method)) {
|
|
|
- const startTime = self.performance.now();
|
|
|
- return this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch((err) => {
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_DECRYPT_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: err,
|
|
|
- reason: err.message,
|
|
|
- frag
|
|
|
- });
|
|
|
- throw err;
|
|
|
- }).then((decryptedData) => {
|
|
|
- const endTime = self.performance.now();
|
|
|
- hls.trigger(Events.FRAG_DECRYPTED, {
|
|
|
- frag,
|
|
|
- payload: decryptedData,
|
|
|
- stats: {
|
|
|
- tstart: startTime,
|
|
|
- tdecrypt: endTime
|
|
|
- }
|
|
|
- });
|
|
|
- data.payload = decryptedData;
|
|
|
- return this.completeInitSegmentLoad(data);
|
|
|
- });
|
|
|
- }
|
|
|
- return this.completeInitSegmentLoad(data);
|
|
|
- }).catch((reason) => {
|
|
|
- if (this.state === State.STOPPED || this.state === State.ERROR) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.warn(reason);
|
|
|
- this.resetFragmentLoading(fragment);
|
|
|
- });
|
|
|
- }
|
|
|
- completeInitSegmentLoad(data) {
|
|
|
- const {
|
|
|
- levels
|
|
|
- } = this;
|
|
|
- if (!levels) {
|
|
|
- throw new Error("init load aborted, missing levels");
|
|
|
- }
|
|
|
- const stats = data.frag.stats;
|
|
|
- if (this.state !== State.STOPPED) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- data.frag.data = new Uint8Array(data.payload);
|
|
|
- stats.parsing.start = stats.buffering.start = self.performance.now();
|
|
|
- stats.parsing.end = stats.buffering.end = self.performance.now();
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- unhandledEncryptionError(initSegment, frag) {
|
|
|
- var _tracks$audio, _tracks$video;
|
|
|
- const tracks = initSegment.tracks;
|
|
|
- if (tracks && !frag.encrypted && ((_tracks$audio = tracks.audio) != null && _tracks$audio.encrypted || (_tracks$video = tracks.video) != null && _tracks$video.encrypted) && (!this.config.emeEnabled || !this.keyLoader.emeController)) {
|
|
|
- const media = this.media;
|
|
|
- const error = new Error(`Encrypted track with no key in ${this.fragInfo(frag)} (media ${media ? "attached mediaKeys: " + media.mediaKeys : "detached"})`);
|
|
|
- this.warn(error.message);
|
|
|
- if (!media || media.mediaKeys) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_NO_KEYS,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- frag
|
|
|
- });
|
|
|
- this.resetTransmuxer();
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- fragContextChanged(frag) {
|
|
|
- const {
|
|
|
- fragCurrent
|
|
|
- } = this;
|
|
|
- return !frag || !fragCurrent || frag.sn !== fragCurrent.sn || frag.level !== fragCurrent.level;
|
|
|
- }
|
|
|
- fragBufferedComplete(frag, part) {
|
|
|
- const media = this.mediaBuffer ? this.mediaBuffer : this.media;
|
|
|
- this.log(`Buffered ${frag.type} sn: ${frag.sn}${part ? " part: " + part.index : ""} of ${this.fragInfo(frag, false, part)} > buffer:${media ? TimeRanges.toString(BufferHelper.getBuffered(media)) : "(detached)"})`);
|
|
|
- if (isMediaFragment(frag)) {
|
|
|
- var _this$levels;
|
|
|
- if (frag.type !== PlaylistLevelType.SUBTITLE) {
|
|
|
- const el = frag.elementaryStreams;
|
|
|
- if (!Object.keys(el).some((type) => !!el[type])) {
|
|
|
- this.state = State.IDLE;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const level = (_this$levels = this.levels) == null ? void 0 : _this$levels[frag.level];
|
|
|
- if (level != null && level.fragmentError) {
|
|
|
- this.log(`Resetting level fragment error count of ${level.fragmentError} on frag buffered`);
|
|
|
- level.fragmentError = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- _handleFragmentLoadComplete(fragLoadedEndData) {
|
|
|
- const {
|
|
|
- transmuxer
|
|
|
- } = this;
|
|
|
- if (!transmuxer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- partsLoaded
|
|
|
- } = fragLoadedEndData;
|
|
|
- const complete = !partsLoaded || partsLoaded.length === 0 || partsLoaded.some((fragLoaded) => !fragLoaded);
|
|
|
- const chunkMeta = new ChunkMetadata(frag.level, frag.sn, frag.stats.chunkCount + 1, 0, part ? part.index : -1, !complete);
|
|
|
- transmuxer.flush(chunkMeta);
|
|
|
- }
|
|
|
- _handleFragmentLoadProgress(frag) {
|
|
|
- }
|
|
|
- _doFragLoad(frag, level, targetBufferTime = null, progressCallback) {
|
|
|
- var _frag$decryptdata;
|
|
|
- this.fragCurrent = frag;
|
|
|
- const details = level.details;
|
|
|
- if (!this.levels || !details) {
|
|
|
- throw new Error(`frag load aborted, missing level${details ? "" : " detail"}s`);
|
|
|
- }
|
|
|
- let keyLoadingPromise = null;
|
|
|
- if (frag.encrypted && !((_frag$decryptdata = frag.decryptdata) != null && _frag$decryptdata.key)) {
|
|
|
- this.log(`Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.playlistLabel()} ${frag.level}`);
|
|
|
- this.state = State.KEY_LOADING;
|
|
|
- this.fragCurrent = frag;
|
|
|
- keyLoadingPromise = this.keyLoader.load(frag).then((keyLoadedData) => {
|
|
|
- if (!this.fragContextChanged(keyLoadedData.frag)) {
|
|
|
- this.hls.trigger(Events.KEY_LOADED, keyLoadedData);
|
|
|
- if (this.state === State.KEY_LOADING) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- return keyLoadedData;
|
|
|
- }
|
|
|
- });
|
|
|
- this.hls.trigger(Events.KEY_LOADING, {
|
|
|
- frag
|
|
|
- });
|
|
|
- if (this.fragCurrent === null) {
|
|
|
- this.log(`context changed in KEY_LOADING`);
|
|
|
- return Promise.resolve(null);
|
|
|
- }
|
|
|
- } else if (!frag.encrypted) {
|
|
|
- keyLoadingPromise = this.keyLoader.loadClear(frag, details.encryptedFragments, this.startFragRequested);
|
|
|
- if (keyLoadingPromise) {
|
|
|
- this.log(`[eme] blocking frag load until media-keys acquired`);
|
|
|
- }
|
|
|
- }
|
|
|
- const fragPrevious = this.fragPrevious;
|
|
|
- if (isMediaFragment(frag) && (!fragPrevious || frag.sn !== fragPrevious.sn)) {
|
|
|
- const shouldLoadParts = this.shouldLoadParts(level.details, frag.end);
|
|
|
- if (shouldLoadParts !== this.loadingParts) {
|
|
|
- this.log(`LL-Part loading ${shouldLoadParts ? "ON" : "OFF"} loading sn ${fragPrevious == null ? void 0 : fragPrevious.sn}->${frag.sn}`);
|
|
|
- this.loadingParts = shouldLoadParts;
|
|
|
- }
|
|
|
- }
|
|
|
- targetBufferTime = Math.max(frag.start, targetBufferTime || 0);
|
|
|
- if (this.loadingParts && isMediaFragment(frag)) {
|
|
|
- const partList = details.partList;
|
|
|
- if (partList && progressCallback) {
|
|
|
- if (targetBufferTime > details.fragmentEnd && details.fragmentHint) {
|
|
|
- frag = details.fragmentHint;
|
|
|
- }
|
|
|
- const partIndex = this.getNextPart(partList, frag, targetBufferTime);
|
|
|
- if (partIndex > -1) {
|
|
|
- const part = partList[partIndex];
|
|
|
- frag = this.fragCurrent = part.fragment;
|
|
|
- this.log(`Loading ${frag.type} sn: ${frag.sn} part: ${part.index} (${partIndex}/${partList.length - 1}) of ${this.fragInfo(frag, false, part)}) cc: ${frag.cc} [${details.startSN}-${details.endSN}], target: ${parseFloat(targetBufferTime.toFixed(3))}`);
|
|
|
- this.nextLoadPosition = part.start + part.duration;
|
|
|
- this.state = State.FRAG_LOADING;
|
|
|
- let _result;
|
|
|
- if (keyLoadingPromise) {
|
|
|
- _result = keyLoadingPromise.then((keyLoadedData) => {
|
|
|
- if (!keyLoadedData || this.fragContextChanged(keyLoadedData.frag)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return this.doFragPartsLoad(frag, part, level, progressCallback);
|
|
|
- }).catch((error) => this.handleFragLoadError(error));
|
|
|
- } else {
|
|
|
- _result = this.doFragPartsLoad(frag, part, level, progressCallback).catch((error) => this.handleFragLoadError(error));
|
|
|
- }
|
|
|
- this.hls.trigger(Events.FRAG_LOADING, {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- targetBufferTime
|
|
|
- });
|
|
|
- if (this.fragCurrent === null) {
|
|
|
- return Promise.reject(new Error(`frag load aborted, context changed in FRAG_LOADING parts`));
|
|
|
- }
|
|
|
- return _result;
|
|
|
- } else if (!frag.url || this.loadedEndOfParts(partList, targetBufferTime)) {
|
|
|
- return Promise.resolve(null);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (isMediaFragment(frag) && this.loadingParts) {
|
|
|
- var _details$partList;
|
|
|
- this.log(`LL-Part loading OFF after next part miss @${targetBufferTime.toFixed(2)} Check buffer at sn: ${frag.sn} loaded parts: ${(_details$partList = details.partList) == null ? void 0 : _details$partList.filter((p) => p.loaded).map((p) => `[${p.start}-${p.end}]`)}`);
|
|
|
- this.loadingParts = false;
|
|
|
- } else if (!frag.url) {
|
|
|
- return Promise.resolve(null);
|
|
|
- }
|
|
|
- this.log(`Loading ${frag.type} sn: ${frag.sn} of ${this.fragInfo(frag, false)}) cc: ${frag.cc} ${"[" + details.startSN + "-" + details.endSN + "]"}, target: ${parseFloat(targetBufferTime.toFixed(3))}`);
|
|
|
- if (isFiniteNumber(frag.sn) && !this.bitrateTest) {
|
|
|
- this.nextLoadPosition = frag.start + frag.duration;
|
|
|
- }
|
|
|
- this.state = State.FRAG_LOADING;
|
|
|
- const dataOnProgress = this.config.progressive;
|
|
|
- let result;
|
|
|
- if (dataOnProgress && keyLoadingPromise) {
|
|
|
- result = keyLoadingPromise.then((keyLoadedData) => {
|
|
|
- if (!keyLoadedData || this.fragContextChanged(keyLoadedData.frag)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return this.fragmentLoader.load(frag, progressCallback);
|
|
|
- }).catch((error) => this.handleFragLoadError(error));
|
|
|
- } else {
|
|
|
- result = Promise.all([this.fragmentLoader.load(frag, dataOnProgress ? progressCallback : void 0), keyLoadingPromise]).then(([fragLoadedData]) => {
|
|
|
- if (!dataOnProgress && progressCallback) {
|
|
|
- progressCallback(fragLoadedData);
|
|
|
- }
|
|
|
- return fragLoadedData;
|
|
|
- }).catch((error) => this.handleFragLoadError(error));
|
|
|
- }
|
|
|
- this.hls.trigger(Events.FRAG_LOADING, {
|
|
|
- frag,
|
|
|
- targetBufferTime
|
|
|
- });
|
|
|
- if (this.fragCurrent === null) {
|
|
|
- return Promise.reject(new Error(`frag load aborted, context changed in FRAG_LOADING`));
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- doFragPartsLoad(frag, fromPart, level, progressCallback) {
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- var _level$details;
|
|
|
- const partsLoaded = [];
|
|
|
- const initialPartList = (_level$details = level.details) == null ? void 0 : _level$details.partList;
|
|
|
- const loadPart = (part) => {
|
|
|
- this.fragmentLoader.loadPart(frag, part, progressCallback).then((partLoadedData) => {
|
|
|
- partsLoaded[part.index] = partLoadedData;
|
|
|
- const loadedPart = partLoadedData.part;
|
|
|
- this.hls.trigger(Events.FRAG_LOADED, partLoadedData);
|
|
|
- const nextPart = getPartWith(level.details, frag.sn, part.index + 1) || findPart(initialPartList, frag.sn, part.index + 1);
|
|
|
- if (nextPart) {
|
|
|
- loadPart(nextPart);
|
|
|
- } else {
|
|
|
- return resolve({
|
|
|
- frag,
|
|
|
- part: loadedPart,
|
|
|
- partsLoaded
|
|
|
- });
|
|
|
- }
|
|
|
- }).catch(reject);
|
|
|
- };
|
|
|
- loadPart(fromPart);
|
|
|
- });
|
|
|
- }
|
|
|
- handleFragLoadError(error) {
|
|
|
- if ("data" in error) {
|
|
|
- const data = error.data;
|
|
|
- if (data.frag && data.details === ErrorDetails.INTERNAL_ABORTED) {
|
|
|
- this.handleFragLoadAborted(data.frag, data.part);
|
|
|
- } else if (data.frag && data.type === ErrorTypes.KEY_SYSTEM_ERROR) {
|
|
|
- data.frag.abortRequests();
|
|
|
- this.resetStartWhenNotLoaded();
|
|
|
- this.resetFragmentLoading(data.frag);
|
|
|
- } else {
|
|
|
- this.hls.trigger(Events.ERROR, data);
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.INTERNAL_EXCEPTION,
|
|
|
- err: error,
|
|
|
- error,
|
|
|
- fatal: true
|
|
|
- });
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- _handleTransmuxerFlush(chunkMeta) {
|
|
|
- const context = this.getCurrentContext(chunkMeta);
|
|
|
- if (!context || this.state !== State.PARSING) {
|
|
|
- if (!this.fragCurrent && this.state !== State.STOPPED && this.state !== State.ERROR) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- level
|
|
|
- } = context;
|
|
|
- const now2 = self.performance.now();
|
|
|
- frag.stats.parsing.end = now2;
|
|
|
- if (part) {
|
|
|
- part.stats.parsing.end = now2;
|
|
|
- }
|
|
|
- const levelDetails = this.getLevelDetails();
|
|
|
- const loadingPartsAtEdge = levelDetails && frag.sn > levelDetails.endSN;
|
|
|
- const shouldLoadParts = loadingPartsAtEdge || this.shouldLoadParts(levelDetails, frag.end);
|
|
|
- if (shouldLoadParts !== this.loadingParts) {
|
|
|
- this.log(`LL-Part loading ${shouldLoadParts ? "ON" : "OFF"} after parsing segment ending @${frag.end.toFixed(2)}`);
|
|
|
- this.loadingParts = shouldLoadParts;
|
|
|
- }
|
|
|
- this.updateLevelTiming(frag, part, level, chunkMeta.partial);
|
|
|
- }
|
|
|
- shouldLoadParts(details, bufferEnd) {
|
|
|
- if (this.config.lowLatencyMode) {
|
|
|
- if (!details) {
|
|
|
- return this.loadingParts;
|
|
|
- }
|
|
|
- if (details.partList) {
|
|
|
- var _details$fragmentHint;
|
|
|
- const firstPart = details.partList[0];
|
|
|
- if (firstPart.fragment.type === PlaylistLevelType.SUBTITLE) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const safePartStart = firstPart.end + (((_details$fragmentHint = details.fragmentHint) == null ? void 0 : _details$fragmentHint.duration) || 0);
|
|
|
- if (bufferEnd >= safePartStart) {
|
|
|
- var _this$media;
|
|
|
- const playhead = this.hls.hasEnoughToStart ? ((_this$media = this.media) == null ? void 0 : _this$media.currentTime) || this.lastCurrentTime : this.getLoadPosition();
|
|
|
- if (playhead > firstPart.start - firstPart.fragment.duration) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- getCurrentContext(chunkMeta) {
|
|
|
- const {
|
|
|
- levels,
|
|
|
- fragCurrent
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- level: levelIndex,
|
|
|
- sn,
|
|
|
- part: partIndex
|
|
|
- } = chunkMeta;
|
|
|
- if (!(levels != null && levels[levelIndex])) {
|
|
|
- this.warn(`Levels object was unset while buffering fragment ${sn} of ${this.playlistLabel()} ${levelIndex}. The current chunk will not be buffered.`);
|
|
|
- return null;
|
|
|
- }
|
|
|
- const level = levels[levelIndex];
|
|
|
- const levelDetails = level.details;
|
|
|
- const part = partIndex > -1 ? getPartWith(levelDetails, sn, partIndex) : null;
|
|
|
- const frag = part ? part.fragment : getFragmentWithSN(levelDetails, sn, fragCurrent);
|
|
|
- if (!frag) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (fragCurrent && fragCurrent !== frag) {
|
|
|
- frag.stats = fragCurrent.stats;
|
|
|
- }
|
|
|
- return {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- level
|
|
|
- };
|
|
|
- }
|
|
|
- bufferFragmentData(data, frag, part, chunkMeta, noBacktracking) {
|
|
|
- if (this.state !== State.PARSING) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- data1,
|
|
|
- data2
|
|
|
- } = data;
|
|
|
- let buffer = data1;
|
|
|
- if (data2) {
|
|
|
- buffer = appendUint8Array(data1, data2);
|
|
|
- }
|
|
|
- if (!buffer.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const offsetTimestamp = this.initPTS[frag.cc];
|
|
|
- const offset = offsetTimestamp ? -offsetTimestamp.baseTime / offsetTimestamp.timescale : void 0;
|
|
|
- const segment = {
|
|
|
- type: data.type,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- chunkMeta,
|
|
|
- offset,
|
|
|
- parent: frag.type,
|
|
|
- data: buffer
|
|
|
- };
|
|
|
- this.hls.trigger(Events.BUFFER_APPENDING, segment);
|
|
|
- if (data.dropped && data.independent && !part) {
|
|
|
- if (noBacktracking) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.flushBufferGap(frag);
|
|
|
- }
|
|
|
- }
|
|
|
- flushBufferGap(frag) {
|
|
|
- const media = this.media;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!BufferHelper.isBuffered(media, media.currentTime)) {
|
|
|
- this.flushMainBuffer(0, frag.start);
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentTime = media.currentTime;
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
|
|
|
- const fragDuration = frag.duration;
|
|
|
- const segmentFraction = Math.min(this.config.maxFragLookUpTolerance * 2, fragDuration * 0.25);
|
|
|
- const start = Math.max(Math.min(frag.start - segmentFraction, bufferInfo.end - segmentFraction), currentTime + segmentFraction);
|
|
|
- if (frag.start - start > segmentFraction) {
|
|
|
- this.flushMainBuffer(start, frag.start);
|
|
|
- }
|
|
|
- }
|
|
|
- getFwdBufferInfo(bufferable, type) {
|
|
|
- var _this$media2;
|
|
|
- const pos = this.getLoadPosition();
|
|
|
- if (!isFiniteNumber(pos)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const backwardSeek = this.lastCurrentTime > pos;
|
|
|
- const maxBufferHole = backwardSeek || (_this$media2 = this.media) != null && _this$media2.paused ? 0 : this.config.maxBufferHole;
|
|
|
- return this.getFwdBufferInfoAtPos(bufferable, pos, type, maxBufferHole);
|
|
|
- }
|
|
|
- getFwdBufferInfoAtPos(bufferable, pos, type, maxBufferHole) {
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(bufferable, pos, maxBufferHole);
|
|
|
- if (bufferInfo.len === 0 && bufferInfo.nextStart !== void 0) {
|
|
|
- const bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
|
|
|
- if (bufferedFragAtPos && (bufferInfo.nextStart <= bufferedFragAtPos.end || bufferedFragAtPos.gap)) {
|
|
|
- const gapDuration = Math.max(Math.min(bufferInfo.nextStart, bufferedFragAtPos.end) - pos, maxBufferHole);
|
|
|
- return BufferHelper.bufferInfo(bufferable, pos, gapDuration);
|
|
|
- }
|
|
|
- }
|
|
|
- return bufferInfo;
|
|
|
- }
|
|
|
- getMaxBufferLength(levelBitrate) {
|
|
|
- const {
|
|
|
- config
|
|
|
- } = this;
|
|
|
- let maxBufLen;
|
|
|
- if (levelBitrate) {
|
|
|
- maxBufLen = Math.max(8 * config.maxBufferSize / levelBitrate, config.maxBufferLength);
|
|
|
- } else {
|
|
|
- maxBufLen = config.maxBufferLength;
|
|
|
- }
|
|
|
- return Math.min(maxBufLen, config.maxMaxBufferLength);
|
|
|
- }
|
|
|
- reduceMaxBufferLength(threshold, fragDuration) {
|
|
|
- const config = this.config;
|
|
|
- const minLength = Math.max(Math.min(threshold - fragDuration, config.maxBufferLength), fragDuration);
|
|
|
- const reducedLength = Math.max(threshold - fragDuration * 3, config.maxMaxBufferLength / 2, minLength);
|
|
|
- if (reducedLength >= minLength) {
|
|
|
- config.maxMaxBufferLength = reducedLength;
|
|
|
- this.warn(`Reduce max buffer length to ${reducedLength}s`);
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- getAppendedFrag(position, playlistType = PlaylistLevelType.MAIN) {
|
|
|
- const fragOrPart = this.fragmentTracker ? this.fragmentTracker.getAppendedFrag(position, playlistType) : null;
|
|
|
- if (fragOrPart && "fragment" in fragOrPart) {
|
|
|
- return fragOrPart.fragment;
|
|
|
- }
|
|
|
- return fragOrPart;
|
|
|
- }
|
|
|
- getNextFragment(pos, levelDetails) {
|
|
|
- const fragments = levelDetails.fragments;
|
|
|
- const fragLen = fragments.length;
|
|
|
- if (!fragLen) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const {
|
|
|
- config
|
|
|
- } = this;
|
|
|
- const start = fragments[0].start;
|
|
|
- const canLoadParts = config.lowLatencyMode && !!levelDetails.partList;
|
|
|
- let frag = null;
|
|
|
- if (levelDetails.live) {
|
|
|
- const initialLiveManifestSize = config.initialLiveManifestSize;
|
|
|
- if (fragLen < initialLiveManifestSize) {
|
|
|
- this.warn(`Not enough fragments to start playback (have: ${fragLen}, need: ${initialLiveManifestSize})`);
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (!levelDetails.PTSKnown && !this.startFragRequested && this.startPosition === -1 || pos < start) {
|
|
|
- var _frag;
|
|
|
- if (canLoadParts && !this.loadingParts) {
|
|
|
- this.log(`LL-Part loading ON for initial live fragment`);
|
|
|
- this.loadingParts = true;
|
|
|
- }
|
|
|
- frag = this.getInitialLiveFragment(levelDetails);
|
|
|
- const mainStart = this.hls.startPosition;
|
|
|
- const liveSyncPosition = this.hls.liveSyncPosition;
|
|
|
- const startPosition = frag ? (mainStart !== -1 && mainStart >= start ? mainStart : liveSyncPosition) || frag.start : pos;
|
|
|
- this.log(`Setting startPosition to ${startPosition} to match start frag at live edge. mainStart: ${mainStart} liveSyncPosition: ${liveSyncPosition} frag.start: ${(_frag = frag) == null ? void 0 : _frag.start}`);
|
|
|
- this.startPosition = this.nextLoadPosition = startPosition;
|
|
|
- }
|
|
|
- } else if (pos <= start) {
|
|
|
- frag = fragments[0];
|
|
|
- }
|
|
|
- if (!frag) {
|
|
|
- const end = this.loadingParts ? levelDetails.partEnd : levelDetails.fragmentEnd;
|
|
|
- frag = this.getFragmentAtPosition(pos, end, levelDetails);
|
|
|
- }
|
|
|
- let programFrag = this.filterReplacedPrimary(frag, levelDetails);
|
|
|
- if (!programFrag && frag) {
|
|
|
- const curSNIdx = frag.sn - levelDetails.startSN;
|
|
|
- programFrag = this.filterReplacedPrimary(fragments[curSNIdx + 1] || null, levelDetails);
|
|
|
- }
|
|
|
- return this.mapToInitFragWhenRequired(programFrag);
|
|
|
- }
|
|
|
- isLoopLoading(frag, targetBufferTime) {
|
|
|
- const trackerState = this.fragmentTracker.getState(frag);
|
|
|
- return (trackerState === FragmentState.OK || trackerState === FragmentState.PARTIAL && !!frag.gap) && this.nextLoadPosition > targetBufferTime;
|
|
|
- }
|
|
|
- getNextFragmentLoopLoading(frag, levelDetails, bufferInfo, playlistType, maxBufLen) {
|
|
|
- let nextFragment = null;
|
|
|
- if (frag.gap) {
|
|
|
- nextFragment = this.getNextFragment(this.nextLoadPosition, levelDetails);
|
|
|
- if (nextFragment && !nextFragment.gap && bufferInfo.nextStart) {
|
|
|
- const nextbufferInfo = this.getFwdBufferInfoAtPos(this.mediaBuffer ? this.mediaBuffer : this.media, bufferInfo.nextStart, playlistType, 0);
|
|
|
- if (nextbufferInfo !== null && bufferInfo.len + nextbufferInfo.len >= maxBufLen) {
|
|
|
- const sn = nextFragment.sn;
|
|
|
- if (this.loopSn !== sn) {
|
|
|
- this.log(`buffer full after gaps in "${playlistType}" playlist starting at sn: ${sn}`);
|
|
|
- this.loopSn = sn;
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.loopSn = void 0;
|
|
|
- return nextFragment;
|
|
|
- }
|
|
|
- get primaryPrefetch() {
|
|
|
- if (interstitialsEnabled(this.config)) {
|
|
|
- var _this$hls$interstitia;
|
|
|
- const playingInterstitial = (_this$hls$interstitia = this.hls.interstitialsManager) == null || (_this$hls$interstitia = _this$hls$interstitia.playingItem) == null ? void 0 : _this$hls$interstitia.event;
|
|
|
- if (playingInterstitial) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- filterReplacedPrimary(frag, details) {
|
|
|
- if (!frag) {
|
|
|
- return frag;
|
|
|
- }
|
|
|
- if (interstitialsEnabled(this.config) && frag.type !== PlaylistLevelType.SUBTITLE) {
|
|
|
- const interstitials = this.hls.interstitialsManager;
|
|
|
- const bufferingItem = interstitials == null ? void 0 : interstitials.bufferingItem;
|
|
|
- if (bufferingItem) {
|
|
|
- const bufferingInterstitial = bufferingItem.event;
|
|
|
- if (bufferingInterstitial) {
|
|
|
- if (bufferingInterstitial.appendInPlace || Math.abs(frag.start - bufferingItem.start) > 1 || bufferingItem.start === 0) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (frag.end <= bufferingItem.start && (details == null ? void 0 : details.live) === false) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (frag.start > bufferingItem.end && bufferingItem.nextEvent) {
|
|
|
- if (bufferingItem.nextEvent.appendInPlace || frag.start - bufferingItem.end > 1) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const playerQueue = interstitials == null ? void 0 : interstitials.playerQueue;
|
|
|
- if (playerQueue) {
|
|
|
- for (let i = playerQueue.length; i--; ) {
|
|
|
- const interstitial = playerQueue[i].interstitial;
|
|
|
- if (interstitial.appendInPlace && frag.start >= interstitial.startTime && frag.end <= interstitial.resumeTime) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return frag;
|
|
|
- }
|
|
|
- mapToInitFragWhenRequired(frag) {
|
|
|
- if (frag != null && frag.initSegment && !frag.initSegment.data && !this.bitrateTest) {
|
|
|
- return frag.initSegment;
|
|
|
- }
|
|
|
- return frag;
|
|
|
- }
|
|
|
- getNextPart(partList, frag, targetBufferTime) {
|
|
|
- let nextPart = -1;
|
|
|
- let contiguous = false;
|
|
|
- let independentAttrOmitted = true;
|
|
|
- for (let i = 0, len = partList.length; i < len; i++) {
|
|
|
- const part = partList[i];
|
|
|
- independentAttrOmitted = independentAttrOmitted && !part.independent;
|
|
|
- if (nextPart > -1 && targetBufferTime < part.start) {
|
|
|
- break;
|
|
|
- }
|
|
|
- const loaded = part.loaded;
|
|
|
- if (loaded) {
|
|
|
- nextPart = -1;
|
|
|
- } else if (contiguous || (part.independent || independentAttrOmitted) && part.fragment === frag) {
|
|
|
- if (part.fragment !== frag) {
|
|
|
- this.warn(`Need buffer at ${targetBufferTime} but next unloaded part starts at ${part.start}`);
|
|
|
- }
|
|
|
- nextPart = i;
|
|
|
- }
|
|
|
- contiguous = loaded;
|
|
|
- }
|
|
|
- return nextPart;
|
|
|
- }
|
|
|
- loadedEndOfParts(partList, targetBufferTime) {
|
|
|
- let part;
|
|
|
- for (let i = partList.length; i--; ) {
|
|
|
- part = partList[i];
|
|
|
- if (!part.loaded) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (targetBufferTime > part.start) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- /*
|
|
|
- This method is used find the best matching first fragment for a live playlist. This fragment is used to calculate the
|
|
|
- "sliding" of the playlist, which is its offset from the start of playback. After sliding we can compute the real
|
|
|
- start and end times for each fragment in the playlist (after which this method will not need to be called).
|
|
|
- */
|
|
|
- getInitialLiveFragment(levelDetails) {
|
|
|
- const fragments = levelDetails.fragments;
|
|
|
- const fragPrevious = this.fragPrevious;
|
|
|
- let frag = null;
|
|
|
- if (fragPrevious) {
|
|
|
- if (levelDetails.hasProgramDateTime) {
|
|
|
- this.log(`Live playlist, switching playlist, load frag with same PDT: ${fragPrevious.programDateTime}`);
|
|
|
- frag = findFragmentByPDT(fragments, fragPrevious.endProgramDateTime, this.config.maxFragLookUpTolerance);
|
|
|
- }
|
|
|
- if (!frag) {
|
|
|
- const targetSN = fragPrevious.sn + 1;
|
|
|
- if (targetSN >= levelDetails.startSN && targetSN <= levelDetails.endSN) {
|
|
|
- const fragNext = fragments[targetSN - levelDetails.startSN];
|
|
|
- if (fragPrevious.cc === fragNext.cc) {
|
|
|
- frag = fragNext;
|
|
|
- this.log(`Live playlist, switching playlist, load frag with next SN: ${frag.sn}`);
|
|
|
- }
|
|
|
- }
|
|
|
- if (!frag) {
|
|
|
- frag = findNearestWithCC(levelDetails, fragPrevious.cc, fragPrevious.end);
|
|
|
- if (frag) {
|
|
|
- this.log(`Live playlist, switching playlist, load frag with same CC: ${frag.sn}`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- const liveStart = this.hls.liveSyncPosition;
|
|
|
- if (liveStart !== null) {
|
|
|
- frag = this.getFragmentAtPosition(liveStart, this.bitrateTest ? levelDetails.fragmentEnd : levelDetails.edge, levelDetails);
|
|
|
- }
|
|
|
- }
|
|
|
- return frag;
|
|
|
- }
|
|
|
- /*
|
|
|
- This method finds the best matching fragment given the provided position.
|
|
|
- */
|
|
|
- getFragmentAtPosition(bufferEnd, end, levelDetails) {
|
|
|
- const {
|
|
|
- config
|
|
|
- } = this;
|
|
|
- let {
|
|
|
- fragPrevious
|
|
|
- } = this;
|
|
|
- let {
|
|
|
- fragments,
|
|
|
- endSN
|
|
|
- } = levelDetails;
|
|
|
- const {
|
|
|
- fragmentHint
|
|
|
- } = levelDetails;
|
|
|
- const {
|
|
|
- maxFragLookUpTolerance
|
|
|
- } = config;
|
|
|
- const partList = levelDetails.partList;
|
|
|
- const loadingParts = !!(this.loadingParts && partList != null && partList.length && fragmentHint);
|
|
|
- if (loadingParts && !this.bitrateTest && partList[partList.length - 1].fragment.sn === fragmentHint.sn) {
|
|
|
- fragments = fragments.concat(fragmentHint);
|
|
|
- endSN = fragmentHint.sn;
|
|
|
- }
|
|
|
- let frag;
|
|
|
- if (bufferEnd < end) {
|
|
|
- var _this$media3;
|
|
|
- const backwardSeek = bufferEnd < this.lastCurrentTime;
|
|
|
- const lookupTolerance = backwardSeek || bufferEnd > end - maxFragLookUpTolerance || (_this$media3 = this.media) != null && _this$media3.paused || !this.startFragRequested ? 0 : maxFragLookUpTolerance;
|
|
|
- frag = findFragmentByPTS(fragPrevious, fragments, bufferEnd, lookupTolerance);
|
|
|
- } else {
|
|
|
- frag = fragments[fragments.length - 1];
|
|
|
- }
|
|
|
- if (frag) {
|
|
|
- const curSNIdx = frag.sn - levelDetails.startSN;
|
|
|
- const fragState = this.fragmentTracker.getState(frag);
|
|
|
- if (fragState === FragmentState.OK || fragState === FragmentState.PARTIAL && frag.gap) {
|
|
|
- fragPrevious = frag;
|
|
|
- }
|
|
|
- if (fragPrevious && frag.sn === fragPrevious.sn && (!loadingParts || partList[0].fragment.sn > frag.sn || !levelDetails.live)) {
|
|
|
- const sameLevel = frag.level === fragPrevious.level;
|
|
|
- if (sameLevel) {
|
|
|
- const nextFrag = fragments[curSNIdx + 1];
|
|
|
- if (frag.sn < endSN && this.fragmentTracker.getState(nextFrag) !== FragmentState.OK) {
|
|
|
- frag = nextFrag;
|
|
|
- } else {
|
|
|
- frag = null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return frag;
|
|
|
- }
|
|
|
- alignPlaylists(details, previousDetails, switchDetails) {
|
|
|
- const length = details.fragments.length;
|
|
|
- if (!length) {
|
|
|
- this.warn(`No fragments in live playlist`);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const slidingStart = details.fragmentStart;
|
|
|
- const firstLevelLoad = !previousDetails;
|
|
|
- const aligned = details.alignedSliding && isFiniteNumber(slidingStart);
|
|
|
- if (firstLevelLoad || !aligned && !slidingStart) {
|
|
|
- alignStream(switchDetails, details);
|
|
|
- const alignedSlidingStart = details.fragmentStart;
|
|
|
- this.log(`Live playlist sliding: ${alignedSlidingStart.toFixed(2)} start-sn: ${previousDetails ? previousDetails.startSN : "na"}->${details.startSN} fragments: ${length}`);
|
|
|
- return alignedSlidingStart;
|
|
|
- }
|
|
|
- return slidingStart;
|
|
|
- }
|
|
|
- waitForCdnTuneIn(details) {
|
|
|
- const advancePartLimit = 3;
|
|
|
- return details.live && details.canBlockReload && details.partTarget && details.tuneInGoal > Math.max(details.partHoldBack, details.partTarget * advancePartLimit);
|
|
|
- }
|
|
|
- setStartPosition(details, sliding) {
|
|
|
- let startPosition = this.startPosition;
|
|
|
- if (startPosition < sliding) {
|
|
|
- startPosition = -1;
|
|
|
- }
|
|
|
- const timelineOffset = this.timelineOffset;
|
|
|
- if (startPosition === -1) {
|
|
|
- const offsetInMultivariantPlaylist = this.startTimeOffset !== null;
|
|
|
- const startTimeOffset = offsetInMultivariantPlaylist ? this.startTimeOffset : details.startTimeOffset;
|
|
|
- if (startTimeOffset !== null && isFiniteNumber(startTimeOffset)) {
|
|
|
- startPosition = sliding + startTimeOffset;
|
|
|
- if (startTimeOffset < 0) {
|
|
|
- startPosition += details.edge;
|
|
|
- }
|
|
|
- startPosition = Math.min(Math.max(sliding, startPosition), sliding + details.totalduration);
|
|
|
- this.log(`Setting startPosition to ${startPosition} for start time offset ${startTimeOffset} found in ${offsetInMultivariantPlaylist ? "multivariant" : "media"} playlist`);
|
|
|
- this.startPosition = startPosition;
|
|
|
- } else if (details.live) {
|
|
|
- startPosition = this.hls.liveSyncPosition || sliding;
|
|
|
- this.log(`Setting startPosition to -1 to start at live edge ${startPosition}`);
|
|
|
- this.startPosition = -1;
|
|
|
- } else {
|
|
|
- this.log(`setting startPosition to 0 by default`);
|
|
|
- this.startPosition = startPosition = 0;
|
|
|
- }
|
|
|
- this.lastCurrentTime = startPosition + timelineOffset;
|
|
|
- }
|
|
|
- this.nextLoadPosition = startPosition + timelineOffset;
|
|
|
- }
|
|
|
- getLoadPosition() {
|
|
|
- var _this$hls;
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- let pos = 0;
|
|
|
- if ((_this$hls = this.hls) != null && _this$hls.hasEnoughToStart && media) {
|
|
|
- pos = media.currentTime;
|
|
|
- } else if (this.nextLoadPosition >= 0) {
|
|
|
- pos = this.nextLoadPosition;
|
|
|
- }
|
|
|
- return pos;
|
|
|
- }
|
|
|
- handleFragLoadAborted(frag, part) {
|
|
|
- if (this.transmuxer && frag.type === this.playlistType && isMediaFragment(frag) && frag.stats.aborted) {
|
|
|
- this.log(`Fragment ${frag.sn}${part ? " part " + part.index : ""} of ${this.playlistLabel()} ${frag.level} was aborted`);
|
|
|
- this.resetFragmentLoading(frag);
|
|
|
- }
|
|
|
- }
|
|
|
- resetFragmentLoading(frag) {
|
|
|
- if (!this.fragCurrent || !this.fragContextChanged(frag) && this.state !== State.FRAG_LOADING_WAITING_RETRY) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- }
|
|
|
- onFragmentOrKeyLoadError(filterType, data) {
|
|
|
- var _this$hls$latestLevel;
|
|
|
- if (data.chunkMeta && !data.frag) {
|
|
|
- const context = this.getCurrentContext(data.chunkMeta);
|
|
|
- if (context) {
|
|
|
- data.frag = context.frag;
|
|
|
- }
|
|
|
- }
|
|
|
- const frag = data.frag;
|
|
|
- if (!frag || frag.type !== filterType || !this.levels) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.fragContextChanged(frag)) {
|
|
|
- var _this$fragCurrent;
|
|
|
- this.warn(`Frag load error must match current frag to retry ${frag.url} > ${(_this$fragCurrent = this.fragCurrent) == null ? void 0 : _this$fragCurrent.url}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const gapTagEncountered = data.details === ErrorDetails.FRAG_GAP;
|
|
|
- if (gapTagEncountered) {
|
|
|
- this.fragmentTracker.fragBuffered(frag, true);
|
|
|
- }
|
|
|
- const errorAction = data.errorAction;
|
|
|
- if (!errorAction) {
|
|
|
- this.state = State.ERROR;
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- action,
|
|
|
- flags,
|
|
|
- retryCount = 0,
|
|
|
- retryConfig
|
|
|
- } = errorAction;
|
|
|
- const couldRetry = !!retryConfig;
|
|
|
- const retry = couldRetry && action === NetworkErrorAction.RetryRequest;
|
|
|
- const noAlternate = couldRetry && !errorAction.resolved && flags === ErrorActionFlags.MoveAllAlternatesMatchingHost;
|
|
|
- const live = (_this$hls$latestLevel = this.hls.latestLevelDetails) == null ? void 0 : _this$hls$latestLevel.live;
|
|
|
- if (!retry && noAlternate && isMediaFragment(frag) && !frag.endList && live && !isUnusableKeyError(data)) {
|
|
|
- this.resetFragmentErrors(filterType);
|
|
|
- this.treatAsGap(frag);
|
|
|
- errorAction.resolved = true;
|
|
|
- } else if ((retry || noAlternate) && retryCount < retryConfig.maxNumRetry) {
|
|
|
- var _data$response;
|
|
|
- const offlineStatus = offlineHttpStatus((_data$response = data.response) == null ? void 0 : _data$response.code);
|
|
|
- const delay = getRetryDelay(retryConfig, retryCount);
|
|
|
- this.resetStartWhenNotLoaded();
|
|
|
- this.retryDate = self.performance.now() + delay;
|
|
|
- this.state = State.FRAG_LOADING_WAITING_RETRY;
|
|
|
- errorAction.resolved = true;
|
|
|
- if (offlineStatus) {
|
|
|
- this.log(`Waiting for connection (offline)`);
|
|
|
- this.retryDate = Infinity;
|
|
|
- data.reason = "offline";
|
|
|
- return;
|
|
|
- }
|
|
|
- this.warn(`Fragment ${frag.sn} of ${filterType} ${frag.level} errored with ${data.details}, retrying loading ${retryCount + 1}/${retryConfig.maxNumRetry} in ${delay}ms`);
|
|
|
- } else if (retryConfig) {
|
|
|
- this.resetFragmentErrors(filterType);
|
|
|
- if (retryCount < retryConfig.maxNumRetry) {
|
|
|
- if (!gapTagEncountered && action !== NetworkErrorAction.RemoveAlternatePermanently) {
|
|
|
- errorAction.resolved = true;
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.warn(`${data.details} reached or exceeded max retry (${retryCount})`);
|
|
|
- return;
|
|
|
- }
|
|
|
- } else if (action === NetworkErrorAction.SendAlternateToPenaltyBox) {
|
|
|
- this.state = State.WAITING_LEVEL;
|
|
|
- } else {
|
|
|
- this.state = State.ERROR;
|
|
|
- }
|
|
|
- this.tickImmediate();
|
|
|
- }
|
|
|
- checkRetryDate() {
|
|
|
- const now2 = self.performance.now();
|
|
|
- const retryDate = this.retryDate;
|
|
|
- const waitingForConnection = retryDate === Infinity;
|
|
|
- if (!retryDate || now2 >= retryDate || waitingForConnection && !offlineHttpStatus(0)) {
|
|
|
- if (waitingForConnection) {
|
|
|
- this.log(`Connection restored (online)`);
|
|
|
- }
|
|
|
- this.resetStartWhenNotLoaded();
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- }
|
|
|
- reduceLengthAndFlushBuffer(data) {
|
|
|
- if (this.state === State.PARSING || this.state === State.PARSED) {
|
|
|
- const frag = data.frag;
|
|
|
- const playlistType = data.parent;
|
|
|
- const bufferedInfo = this.getFwdBufferInfo(this.mediaBuffer, playlistType);
|
|
|
- const buffered = bufferedInfo && bufferedInfo.len > 0.5;
|
|
|
- if (buffered) {
|
|
|
- this.reduceMaxBufferLength(bufferedInfo.len, (frag == null ? void 0 : frag.duration) || 10);
|
|
|
- }
|
|
|
- const flushBuffer = !buffered;
|
|
|
- if (flushBuffer) {
|
|
|
- this.warn(`Buffer full error while media.currentTime (${this.getLoadPosition()}) is not buffered, flush ${playlistType} buffer`);
|
|
|
- }
|
|
|
- if (frag) {
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- this.nextLoadPosition = frag.start;
|
|
|
- }
|
|
|
- this.resetLoadingState();
|
|
|
- return flushBuffer;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- resetFragmentErrors(filterType) {
|
|
|
- if (filterType === PlaylistLevelType.AUDIO) {
|
|
|
- this.fragCurrent = null;
|
|
|
- }
|
|
|
- if (!this.hls.hasEnoughToStart) {
|
|
|
- this.startFragRequested = false;
|
|
|
- }
|
|
|
- if (this.state !== State.STOPPED) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- }
|
|
|
- afterBufferFlushed(media, bufferType, playlistType) {
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferedTimeRanges = BufferHelper.getBuffered(media);
|
|
|
- this.fragmentTracker.detectEvictedFragments(bufferType, bufferedTimeRanges, playlistType);
|
|
|
- if (this.state === State.ENDED) {
|
|
|
- this.resetLoadingState();
|
|
|
- }
|
|
|
- }
|
|
|
- resetLoadingState() {
|
|
|
- this.log("Reset loading state");
|
|
|
- this.fragCurrent = null;
|
|
|
- this.fragPrevious = null;
|
|
|
- if (this.state !== State.STOPPED) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- }
|
|
|
- resetStartWhenNotLoaded() {
|
|
|
- if (!this.hls.hasEnoughToStart) {
|
|
|
- this.startFragRequested = false;
|
|
|
- const level = this.levelLastLoaded;
|
|
|
- const details = level ? level.details : null;
|
|
|
- if (details != null && details.live) {
|
|
|
- this.log(`resetting startPosition for live start`);
|
|
|
- this.startPosition = -1;
|
|
|
- this.setStartPosition(details, details.fragmentStart);
|
|
|
- this.resetLoadingState();
|
|
|
- } else {
|
|
|
- this.nextLoadPosition = this.startPosition;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- resetWhenMissingContext(chunkMeta) {
|
|
|
- this.log(`Loading context changed while buffering sn ${chunkMeta.sn} of ${this.playlistLabel()} ${chunkMeta.level === -1 ? "<removed>" : chunkMeta.level}. This chunk will not be buffered.`);
|
|
|
- this.removeUnbufferedFrags();
|
|
|
- this.resetStartWhenNotLoaded();
|
|
|
- this.resetLoadingState();
|
|
|
- }
|
|
|
- removeUnbufferedFrags(start = 0) {
|
|
|
- this.fragmentTracker.removeFragmentsInRange(start, Infinity, this.playlistType, false, true);
|
|
|
- }
|
|
|
- updateLevelTiming(frag, part, level, partial) {
|
|
|
- const details = level.details;
|
|
|
- if (!details) {
|
|
|
- this.warn("level.details undefined");
|
|
|
- return;
|
|
|
- }
|
|
|
- const parsed = Object.keys(frag.elementaryStreams).reduce((result, type) => {
|
|
|
- const info = frag.elementaryStreams[type];
|
|
|
- if (info) {
|
|
|
- const parsedDuration = info.endPTS - info.startPTS;
|
|
|
- if (parsedDuration <= 0) {
|
|
|
- this.warn(`Could not parse fragment ${frag.sn} ${type} duration reliably (${parsedDuration})`);
|
|
|
- return result || false;
|
|
|
- }
|
|
|
- const drift = partial ? 0 : updateFragPTSDTS(details, frag, info.startPTS, info.endPTS, info.startDTS, info.endDTS, this);
|
|
|
- this.hls.trigger(Events.LEVEL_PTS_UPDATED, {
|
|
|
- details,
|
|
|
- level,
|
|
|
- drift,
|
|
|
- type,
|
|
|
- frag,
|
|
|
- start: info.startPTS,
|
|
|
- end: info.endPTS
|
|
|
- });
|
|
|
- return true;
|
|
|
- }
|
|
|
- return result;
|
|
|
- }, false);
|
|
|
- if (!parsed) {
|
|
|
- var _this$transmuxer;
|
|
|
- if (level.fragmentError === 0) {
|
|
|
- this.treatAsGap(frag, level);
|
|
|
- }
|
|
|
- if (((_this$transmuxer = this.transmuxer) == null ? void 0 : _this$transmuxer.error) === null) {
|
|
|
- const error = new Error(`Found no media in fragment ${frag.sn} of ${this.playlistLabel()} ${frag.level} resetting transmuxer to fallback to playlist timing`);
|
|
|
- this.warn(error.message);
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_PARSING_ERROR,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- frag,
|
|
|
- reason: `Found no media in msn ${frag.sn} of ${this.playlistLabel()} "${level.url}"`
|
|
|
- });
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.resetTransmuxer();
|
|
|
- }
|
|
|
- }
|
|
|
- this.state = State.PARSED;
|
|
|
- this.log(`Parsed ${frag.type} sn: ${frag.sn}${part ? " part: " + part.index : ""} of ${this.fragInfo(frag, false, part)})`);
|
|
|
- this.hls.trigger(Events.FRAG_PARSED, {
|
|
|
- frag,
|
|
|
- part
|
|
|
- });
|
|
|
- }
|
|
|
- playlistLabel() {
|
|
|
- return this.playlistType === PlaylistLevelType.MAIN ? "level" : "track";
|
|
|
- }
|
|
|
- fragInfo(frag, pts = true, part) {
|
|
|
- var _ref, _ref2;
|
|
|
- return `${this.playlistLabel()} ${frag.level} (${part ? "part" : "frag"}:[${((_ref = pts && !part ? frag.startPTS : (part || frag).start) != null ? _ref : NaN).toFixed(3)}-${((_ref2 = pts && !part ? frag.endPTS : (part || frag).end) != null ? _ref2 : NaN).toFixed(3)}]${part && frag.type === "main" ? "INDEPENDENT=" + (part.independent ? "YES" : "NO") : ""}`;
|
|
|
- }
|
|
|
- treatAsGap(frag, level) {
|
|
|
- if (level) {
|
|
|
- level.fragmentError++;
|
|
|
- }
|
|
|
- frag.gap = true;
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- this.fragmentTracker.fragBuffered(frag, true);
|
|
|
- }
|
|
|
- resetTransmuxer() {
|
|
|
- var _this$transmuxer2;
|
|
|
- (_this$transmuxer2 = this.transmuxer) == null || _this$transmuxer2.reset();
|
|
|
- }
|
|
|
- recoverWorkerError(data) {
|
|
|
- if (data.event === "demuxerWorker") {
|
|
|
- this.fragmentTracker.removeAllFragments();
|
|
|
- if (this.transmuxer) {
|
|
|
- this.transmuxer.destroy();
|
|
|
- this.transmuxer = null;
|
|
|
- }
|
|
|
- this.resetStartWhenNotLoaded();
|
|
|
- this.resetLoadingState();
|
|
|
- }
|
|
|
- }
|
|
|
- set state(nextState) {
|
|
|
- const previousState = this._state;
|
|
|
- if (previousState !== nextState) {
|
|
|
- this._state = nextState;
|
|
|
- this.log(`${previousState}->${nextState}`);
|
|
|
- }
|
|
|
- }
|
|
|
- get state() {
|
|
|
- return this._state;
|
|
|
- }
|
|
|
-};
|
|
|
-function interstitialsEnabled(config) {
|
|
|
- return !!config.interstitialsController && config.enableInterstitialPlayback !== false;
|
|
|
-}
|
|
|
-var ChunkCache = class {
|
|
|
- constructor() {
|
|
|
- this.chunks = [];
|
|
|
- this.dataLength = 0;
|
|
|
- }
|
|
|
- push(chunk) {
|
|
|
- this.chunks.push(chunk);
|
|
|
- this.dataLength += chunk.length;
|
|
|
- }
|
|
|
- flush() {
|
|
|
- const {
|
|
|
- chunks,
|
|
|
- dataLength
|
|
|
- } = this;
|
|
|
- let result;
|
|
|
- if (!chunks.length) {
|
|
|
- return new Uint8Array(0);
|
|
|
- } else if (chunks.length === 1) {
|
|
|
- result = chunks[0];
|
|
|
- } else {
|
|
|
- result = concatUint8Arrays(chunks, dataLength);
|
|
|
- }
|
|
|
- this.reset();
|
|
|
- return result;
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.chunks.length = 0;
|
|
|
- this.dataLength = 0;
|
|
|
- }
|
|
|
-};
|
|
|
-function concatUint8Arrays(chunks, dataLength) {
|
|
|
- const result = new Uint8Array(dataLength);
|
|
|
- let offset = 0;
|
|
|
- for (let i = 0; i < chunks.length; i++) {
|
|
|
- const chunk = chunks[i];
|
|
|
- result.set(chunk, offset);
|
|
|
- offset += chunk.length;
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-var eventemitter3 = { exports: {} };
|
|
|
-var hasRequiredEventemitter3;
|
|
|
-function requireEventemitter3() {
|
|
|
- if (hasRequiredEventemitter3)
|
|
|
- return eventemitter3.exports;
|
|
|
- hasRequiredEventemitter3 = 1;
|
|
|
- (function(module) {
|
|
|
- var has = Object.prototype.hasOwnProperty, prefix = "~";
|
|
|
- function Events2() {
|
|
|
- }
|
|
|
- if (Object.create) {
|
|
|
- Events2.prototype = /* @__PURE__ */ Object.create(null);
|
|
|
- if (!new Events2().__proto__)
|
|
|
- prefix = false;
|
|
|
- }
|
|
|
- function EE(fn, context, once) {
|
|
|
- this.fn = fn;
|
|
|
- this.context = context;
|
|
|
- this.once = once || false;
|
|
|
- }
|
|
|
- function addListener(emitter, event, fn, context, once) {
|
|
|
- if (typeof fn !== "function") {
|
|
|
- throw new TypeError("The listener must be a function");
|
|
|
- }
|
|
|
- var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
|
|
|
- if (!emitter._events[evt])
|
|
|
- emitter._events[evt] = listener, emitter._eventsCount++;
|
|
|
- else if (!emitter._events[evt].fn)
|
|
|
- emitter._events[evt].push(listener);
|
|
|
- else
|
|
|
- emitter._events[evt] = [emitter._events[evt], listener];
|
|
|
- return emitter;
|
|
|
- }
|
|
|
- function clearEvent(emitter, evt) {
|
|
|
- if (--emitter._eventsCount === 0)
|
|
|
- emitter._events = new Events2();
|
|
|
- else
|
|
|
- delete emitter._events[evt];
|
|
|
- }
|
|
|
- function EventEmitter2() {
|
|
|
- this._events = new Events2();
|
|
|
- this._eventsCount = 0;
|
|
|
- }
|
|
|
- EventEmitter2.prototype.eventNames = function eventNames() {
|
|
|
- var names = [], events, name;
|
|
|
- if (this._eventsCount === 0)
|
|
|
- return names;
|
|
|
- for (name in events = this._events) {
|
|
|
- if (has.call(events, name))
|
|
|
- names.push(prefix ? name.slice(1) : name);
|
|
|
- }
|
|
|
- if (Object.getOwnPropertySymbols) {
|
|
|
- return names.concat(Object.getOwnPropertySymbols(events));
|
|
|
- }
|
|
|
- return names;
|
|
|
- };
|
|
|
- EventEmitter2.prototype.listeners = function listeners(event) {
|
|
|
- var evt = prefix ? prefix + event : event, handlers = this._events[evt];
|
|
|
- if (!handlers)
|
|
|
- return [];
|
|
|
- if (handlers.fn)
|
|
|
- return [handlers.fn];
|
|
|
- for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
|
|
|
- ee[i] = handlers[i].fn;
|
|
|
- }
|
|
|
- return ee;
|
|
|
- };
|
|
|
- EventEmitter2.prototype.listenerCount = function listenerCount(event) {
|
|
|
- var evt = prefix ? prefix + event : event, listeners = this._events[evt];
|
|
|
- if (!listeners)
|
|
|
- return 0;
|
|
|
- if (listeners.fn)
|
|
|
- return 1;
|
|
|
- return listeners.length;
|
|
|
- };
|
|
|
- EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
|
|
|
- var evt = prefix ? prefix + event : event;
|
|
|
- if (!this._events[evt])
|
|
|
- return false;
|
|
|
- var listeners = this._events[evt], len = arguments.length, args, i;
|
|
|
- if (listeners.fn) {
|
|
|
- if (listeners.once)
|
|
|
- this.removeListener(event, listeners.fn, void 0, true);
|
|
|
- switch (len) {
|
|
|
- case 1:
|
|
|
- return listeners.fn.call(listeners.context), true;
|
|
|
- case 2:
|
|
|
- return listeners.fn.call(listeners.context, a1), true;
|
|
|
- case 3:
|
|
|
- return listeners.fn.call(listeners.context, a1, a2), true;
|
|
|
- case 4:
|
|
|
- return listeners.fn.call(listeners.context, a1, a2, a3), true;
|
|
|
- case 5:
|
|
|
- return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
|
|
|
- case 6:
|
|
|
- return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
|
|
|
- }
|
|
|
- for (i = 1, args = new Array(len - 1); i < len; i++) {
|
|
|
- args[i - 1] = arguments[i];
|
|
|
- }
|
|
|
- listeners.fn.apply(listeners.context, args);
|
|
|
- } else {
|
|
|
- var length = listeners.length, j;
|
|
|
- for (i = 0; i < length; i++) {
|
|
|
- if (listeners[i].once)
|
|
|
- this.removeListener(event, listeners[i].fn, void 0, true);
|
|
|
- switch (len) {
|
|
|
- case 1:
|
|
|
- listeners[i].fn.call(listeners[i].context);
|
|
|
- break;
|
|
|
- case 2:
|
|
|
- listeners[i].fn.call(listeners[i].context, a1);
|
|
|
- break;
|
|
|
- case 3:
|
|
|
- listeners[i].fn.call(listeners[i].context, a1, a2);
|
|
|
- break;
|
|
|
- case 4:
|
|
|
- listeners[i].fn.call(listeners[i].context, a1, a2, a3);
|
|
|
- break;
|
|
|
- default:
|
|
|
- if (!args)
|
|
|
- for (j = 1, args = new Array(len - 1); j < len; j++) {
|
|
|
- args[j - 1] = arguments[j];
|
|
|
- }
|
|
|
- listeners[i].fn.apply(listeners[i].context, args);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- EventEmitter2.prototype.on = function on(event, fn, context) {
|
|
|
- return addListener(this, event, fn, context, false);
|
|
|
- };
|
|
|
- EventEmitter2.prototype.once = function once(event, fn, context) {
|
|
|
- return addListener(this, event, fn, context, true);
|
|
|
- };
|
|
|
- EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
|
|
|
- var evt = prefix ? prefix + event : event;
|
|
|
- if (!this._events[evt])
|
|
|
- return this;
|
|
|
- if (!fn) {
|
|
|
- clearEvent(this, evt);
|
|
|
- return this;
|
|
|
- }
|
|
|
- var listeners = this._events[evt];
|
|
|
- if (listeners.fn) {
|
|
|
- if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
|
|
|
- clearEvent(this, evt);
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (var i = 0, events = [], length = listeners.length; i < length; i++) {
|
|
|
- if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
|
|
|
- events.push(listeners[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- if (events.length)
|
|
|
- this._events[evt] = events.length === 1 ? events[0] : events;
|
|
|
- else
|
|
|
- clearEvent(this, evt);
|
|
|
- }
|
|
|
- return this;
|
|
|
- };
|
|
|
- EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
|
|
|
- var evt;
|
|
|
- if (event) {
|
|
|
- evt = prefix ? prefix + event : event;
|
|
|
- if (this._events[evt])
|
|
|
- clearEvent(this, evt);
|
|
|
- } else {
|
|
|
- this._events = new Events2();
|
|
|
- this._eventsCount = 0;
|
|
|
- }
|
|
|
- return this;
|
|
|
- };
|
|
|
- EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
|
|
|
- EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
|
|
|
- EventEmitter2.prefixed = prefix;
|
|
|
- EventEmitter2.EventEmitter = EventEmitter2;
|
|
|
- {
|
|
|
- module.exports = EventEmitter2;
|
|
|
- }
|
|
|
- })(eventemitter3);
|
|
|
- return eventemitter3.exports;
|
|
|
-}
|
|
|
-var eventemitter3Exports = requireEventemitter3();
|
|
|
-var EventEmitter = getDefaultExportFromCjs(eventemitter3Exports);
|
|
|
-var version = "1.6.13";
|
|
|
-var workerStore = {};
|
|
|
-function hasUMDWorker() {
|
|
|
- return typeof __HLS_WORKER_BUNDLE__ === "function";
|
|
|
-}
|
|
|
-function injectWorker() {
|
|
|
- const workerContext = workerStore[version];
|
|
|
- if (workerContext) {
|
|
|
- workerContext.clientCount++;
|
|
|
- return workerContext;
|
|
|
- }
|
|
|
- const blob = new self.Blob([`var exports={};var module={exports:exports};function define(f){f()};define.amd=true;(${__HLS_WORKER_BUNDLE__.toString()})(true);`], {
|
|
|
- type: "text/javascript"
|
|
|
- });
|
|
|
- const objectURL = self.URL.createObjectURL(blob);
|
|
|
- const worker = new self.Worker(objectURL);
|
|
|
- const result = {
|
|
|
- worker,
|
|
|
- objectURL,
|
|
|
- clientCount: 1
|
|
|
- };
|
|
|
- workerStore[version] = result;
|
|
|
- return result;
|
|
|
-}
|
|
|
-function loadWorker(path) {
|
|
|
- const workerContext = workerStore[path];
|
|
|
- if (workerContext) {
|
|
|
- workerContext.clientCount++;
|
|
|
- return workerContext;
|
|
|
- }
|
|
|
- const scriptURL = new self.URL(path, self.location.href).href;
|
|
|
- const worker = new self.Worker(scriptURL);
|
|
|
- const result = {
|
|
|
- worker,
|
|
|
- scriptURL,
|
|
|
- clientCount: 1
|
|
|
- };
|
|
|
- workerStore[path] = result;
|
|
|
- return result;
|
|
|
-}
|
|
|
-function removeWorkerFromStore(path) {
|
|
|
- const workerContext = workerStore[path || version];
|
|
|
- if (workerContext) {
|
|
|
- const clientCount = workerContext.clientCount--;
|
|
|
- if (clientCount === 1) {
|
|
|
- const {
|
|
|
- worker,
|
|
|
- objectURL
|
|
|
- } = workerContext;
|
|
|
- delete workerStore[path || version];
|
|
|
- if (objectURL) {
|
|
|
- self.URL.revokeObjectURL(objectURL);
|
|
|
- }
|
|
|
- worker.terminate();
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function isId3Footer(data, offset) {
|
|
|
- if (offset + 10 <= data.length) {
|
|
|
- if (data[offset] === 51 && data[offset + 1] === 68 && data[offset + 2] === 73) {
|
|
|
- if (data[offset + 3] < 255 && data[offset + 4] < 255) {
|
|
|
- if (data[offset + 6] < 128 && data[offset + 7] < 128 && data[offset + 8] < 128 && data[offset + 9] < 128) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function isId3Header(data, offset) {
|
|
|
- if (offset + 10 <= data.length) {
|
|
|
- if (data[offset] === 73 && data[offset + 1] === 68 && data[offset + 2] === 51) {
|
|
|
- if (data[offset + 3] < 255 && data[offset + 4] < 255) {
|
|
|
- if (data[offset + 6] < 128 && data[offset + 7] < 128 && data[offset + 8] < 128 && data[offset + 9] < 128) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function readId3Size(data, offset) {
|
|
|
- let size = 0;
|
|
|
- size = (data[offset] & 127) << 21;
|
|
|
- size |= (data[offset + 1] & 127) << 14;
|
|
|
- size |= (data[offset + 2] & 127) << 7;
|
|
|
- size |= data[offset + 3] & 127;
|
|
|
- return size;
|
|
|
-}
|
|
|
-function getId3Data(data, offset) {
|
|
|
- const front = offset;
|
|
|
- let length = 0;
|
|
|
- while (isId3Header(data, offset)) {
|
|
|
- length += 10;
|
|
|
- const size = readId3Size(data, offset + 6);
|
|
|
- length += size;
|
|
|
- if (isId3Footer(data, offset + 10)) {
|
|
|
- length += 10;
|
|
|
- }
|
|
|
- offset += length;
|
|
|
- }
|
|
|
- if (length > 0) {
|
|
|
- return data.subarray(front, front + length);
|
|
|
- }
|
|
|
- return void 0;
|
|
|
-}
|
|
|
-function getAudioConfig(observer, data, offset, manifestCodec) {
|
|
|
- const adtsSamplingRates = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
|
|
|
- const byte2 = data[offset + 2];
|
|
|
- const adtsSamplingIndex = byte2 >> 2 & 15;
|
|
|
- if (adtsSamplingIndex > 12) {
|
|
|
- const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
|
|
|
- observer.emit(Events.ERROR, Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_PARSING_ERROR,
|
|
|
- fatal: true,
|
|
|
- error,
|
|
|
- reason: error.message
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- const adtsObjectType = (byte2 >> 6 & 3) + 1;
|
|
|
- const channelCount = data[offset + 3] >> 6 & 3 | (byte2 & 1) << 2;
|
|
|
- const codec = "mp4a.40." + adtsObjectType;
|
|
|
- const samplerate = adtsSamplingRates[adtsSamplingIndex];
|
|
|
- let aacSampleIndex = adtsSamplingIndex;
|
|
|
- if (adtsObjectType === 5 || adtsObjectType === 29) {
|
|
|
- aacSampleIndex -= 3;
|
|
|
- }
|
|
|
- const config = [adtsObjectType << 3 | (aacSampleIndex & 14) >> 1, (aacSampleIndex & 1) << 7 | channelCount << 3];
|
|
|
- logger.log(`manifest codec:${manifestCodec}, parsed codec:${codec}, channels:${channelCount}, rate:${samplerate} (ADTS object type:${adtsObjectType} sampling index:${adtsSamplingIndex})`);
|
|
|
- return {
|
|
|
- config,
|
|
|
- samplerate,
|
|
|
- channelCount,
|
|
|
- codec,
|
|
|
- parsedCodec: codec,
|
|
|
- manifestCodec
|
|
|
- };
|
|
|
-}
|
|
|
-function isHeaderPattern$1(data, offset) {
|
|
|
- return data[offset] === 255 && (data[offset + 1] & 246) === 240;
|
|
|
-}
|
|
|
-function getHeaderLength(data, offset) {
|
|
|
- return data[offset + 1] & 1 ? 7 : 9;
|
|
|
-}
|
|
|
-function getFullFrameLength(data, offset) {
|
|
|
- return (data[offset + 3] & 3) << 11 | data[offset + 4] << 3 | (data[offset + 5] & 224) >>> 5;
|
|
|
-}
|
|
|
-function canGetFrameLength(data, offset) {
|
|
|
- return offset + 5 < data.length;
|
|
|
-}
|
|
|
-function isHeader$1(data, offset) {
|
|
|
- return offset + 1 < data.length && isHeaderPattern$1(data, offset);
|
|
|
-}
|
|
|
-function canParse$1(data, offset) {
|
|
|
- return canGetFrameLength(data, offset) && isHeaderPattern$1(data, offset) && getFullFrameLength(data, offset) <= data.length - offset;
|
|
|
-}
|
|
|
-function probe$1(data, offset) {
|
|
|
- if (isHeader$1(data, offset)) {
|
|
|
- const headerLength = getHeaderLength(data, offset);
|
|
|
- if (offset + headerLength >= data.length) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const frameLength = getFullFrameLength(data, offset);
|
|
|
- if (frameLength <= headerLength) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const newOffset = offset + frameLength;
|
|
|
- return newOffset === data.length || isHeader$1(data, newOffset);
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-function initTrackConfig(track, observer, data, offset, audioCodec) {
|
|
|
- if (!track.samplerate) {
|
|
|
- const config = getAudioConfig(observer, data, offset, audioCodec);
|
|
|
- if (!config) {
|
|
|
- return;
|
|
|
- }
|
|
|
- _extends(track, config);
|
|
|
- }
|
|
|
-}
|
|
|
-function getFrameDuration(samplerate) {
|
|
|
- return 1024 * 9e4 / samplerate;
|
|
|
-}
|
|
|
-function parseFrameHeader(data, offset) {
|
|
|
- const headerLength = getHeaderLength(data, offset);
|
|
|
- if (offset + headerLength <= data.length) {
|
|
|
- const frameLength = getFullFrameLength(data, offset) - headerLength;
|
|
|
- if (frameLength > 0) {
|
|
|
- return {
|
|
|
- headerLength,
|
|
|
- frameLength
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function appendFrame$2(track, data, offset, pts, frameIndex) {
|
|
|
- const frameDuration = getFrameDuration(track.samplerate);
|
|
|
- const stamp = pts + frameIndex * frameDuration;
|
|
|
- const header = parseFrameHeader(data, offset);
|
|
|
- let unit;
|
|
|
- if (header) {
|
|
|
- const {
|
|
|
- frameLength,
|
|
|
- headerLength
|
|
|
- } = header;
|
|
|
- const _length = headerLength + frameLength;
|
|
|
- const missing = Math.max(0, offset + _length - data.length);
|
|
|
- if (missing) {
|
|
|
- unit = new Uint8Array(_length - headerLength);
|
|
|
- unit.set(data.subarray(offset + headerLength, data.length), 0);
|
|
|
- } else {
|
|
|
- unit = data.subarray(offset + headerLength, offset + _length);
|
|
|
- }
|
|
|
- const _sample = {
|
|
|
- unit,
|
|
|
- pts: stamp
|
|
|
- };
|
|
|
- if (!missing) {
|
|
|
- track.samples.push(_sample);
|
|
|
- }
|
|
|
- return {
|
|
|
- sample: _sample,
|
|
|
- length: _length,
|
|
|
- missing
|
|
|
- };
|
|
|
- }
|
|
|
- const length = data.length - offset;
|
|
|
- unit = new Uint8Array(length);
|
|
|
- unit.set(data.subarray(offset, data.length), 0);
|
|
|
- const sample = {
|
|
|
- unit,
|
|
|
- pts: stamp
|
|
|
- };
|
|
|
- return {
|
|
|
- sample,
|
|
|
- length,
|
|
|
- missing: -1
|
|
|
- };
|
|
|
-}
|
|
|
-function canParseId3(data, offset) {
|
|
|
- return isId3Header(data, offset) && readId3Size(data, offset + 6) + 10 <= data.length - offset;
|
|
|
-}
|
|
|
-function toArrayBuffer(view2) {
|
|
|
- if (view2 instanceof ArrayBuffer) {
|
|
|
- return view2;
|
|
|
- } else {
|
|
|
- if (view2.byteOffset == 0 && view2.byteLength == view2.buffer.byteLength) {
|
|
|
- return view2.buffer;
|
|
|
- }
|
|
|
- return new Uint8Array(view2).buffer;
|
|
|
- }
|
|
|
-}
|
|
|
-function toUint8(data, offset = 0, length = Infinity) {
|
|
|
- return view(data, offset, length, Uint8Array);
|
|
|
-}
|
|
|
-function view(data, offset, length, Type) {
|
|
|
- const buffer = unsafeGetArrayBuffer(data);
|
|
|
- let bytesPerElement = 1;
|
|
|
- if ("BYTES_PER_ELEMENT" in Type) {
|
|
|
- bytesPerElement = Type.BYTES_PER_ELEMENT;
|
|
|
- }
|
|
|
- const dataOffset = isArrayBufferView(data) ? data.byteOffset : 0;
|
|
|
- const dataEnd = (dataOffset + data.byteLength) / bytesPerElement;
|
|
|
- const rawStart = (dataOffset + offset) / bytesPerElement;
|
|
|
- const start = Math.floor(Math.max(0, Math.min(rawStart, dataEnd)));
|
|
|
- const end = Math.floor(Math.min(start + Math.max(length, 0), dataEnd));
|
|
|
- return new Type(buffer, start, end - start);
|
|
|
-}
|
|
|
-function unsafeGetArrayBuffer(view2) {
|
|
|
- if (view2 instanceof ArrayBuffer) {
|
|
|
- return view2;
|
|
|
- } else {
|
|
|
- return view2.buffer;
|
|
|
- }
|
|
|
-}
|
|
|
-function isArrayBufferView(obj) {
|
|
|
- return obj && obj.buffer instanceof ArrayBuffer && obj.byteLength !== void 0 && obj.byteOffset !== void 0;
|
|
|
-}
|
|
|
-function decodeId3ImageFrame(frame) {
|
|
|
- const metadataFrame = {
|
|
|
- key: frame.type,
|
|
|
- description: "",
|
|
|
- data: "",
|
|
|
- mimeType: null,
|
|
|
- pictureType: null
|
|
|
- };
|
|
|
- const utf8Encoding = 3;
|
|
|
- if (frame.size < 2) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- if (frame.data[0] !== utf8Encoding) {
|
|
|
- console.log("Ignore frame with unrecognized character encoding");
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- const mimeTypeEndIndex = frame.data.subarray(1).indexOf(0);
|
|
|
- if (mimeTypeEndIndex === -1) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- const mimeType = utf8ArrayToStr(toUint8(frame.data, 1, mimeTypeEndIndex));
|
|
|
- const pictureType = frame.data[2 + mimeTypeEndIndex];
|
|
|
- const descriptionEndIndex = frame.data.subarray(3 + mimeTypeEndIndex).indexOf(0);
|
|
|
- if (descriptionEndIndex === -1) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- const description = utf8ArrayToStr(toUint8(frame.data, 3 + mimeTypeEndIndex, descriptionEndIndex));
|
|
|
- let data;
|
|
|
- if (mimeType === "-->") {
|
|
|
- data = utf8ArrayToStr(toUint8(frame.data, 4 + mimeTypeEndIndex + descriptionEndIndex));
|
|
|
- } else {
|
|
|
- data = toArrayBuffer(frame.data.subarray(4 + mimeTypeEndIndex + descriptionEndIndex));
|
|
|
- }
|
|
|
- metadataFrame.mimeType = mimeType;
|
|
|
- metadataFrame.pictureType = pictureType;
|
|
|
- metadataFrame.description = description;
|
|
|
- metadataFrame.data = data;
|
|
|
- return metadataFrame;
|
|
|
-}
|
|
|
-function decodeId3PrivFrame(frame) {
|
|
|
- if (frame.size < 2) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- const owner = utf8ArrayToStr(frame.data, true);
|
|
|
- const privateData = new Uint8Array(frame.data.subarray(owner.length + 1));
|
|
|
- return {
|
|
|
- key: frame.type,
|
|
|
- info: owner,
|
|
|
- data: privateData.buffer
|
|
|
- };
|
|
|
-}
|
|
|
-function decodeId3TextFrame(frame) {
|
|
|
- if (frame.size < 2) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- if (frame.type === "TXXX") {
|
|
|
- let index = 1;
|
|
|
- const description = utf8ArrayToStr(frame.data.subarray(index), true);
|
|
|
- index += description.length + 1;
|
|
|
- const value = utf8ArrayToStr(frame.data.subarray(index));
|
|
|
- return {
|
|
|
- key: frame.type,
|
|
|
- info: description,
|
|
|
- data: value
|
|
|
- };
|
|
|
- }
|
|
|
- const text = utf8ArrayToStr(frame.data.subarray(1));
|
|
|
- return {
|
|
|
- key: frame.type,
|
|
|
- info: "",
|
|
|
- data: text
|
|
|
- };
|
|
|
-}
|
|
|
-function decodeId3UrlFrame(frame) {
|
|
|
- if (frame.type === "WXXX") {
|
|
|
- if (frame.size < 2) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- let index = 1;
|
|
|
- const description = utf8ArrayToStr(frame.data.subarray(index), true);
|
|
|
- index += description.length + 1;
|
|
|
- const value = utf8ArrayToStr(frame.data.subarray(index));
|
|
|
- return {
|
|
|
- key: frame.type,
|
|
|
- info: description,
|
|
|
- data: value
|
|
|
- };
|
|
|
- }
|
|
|
- const url = utf8ArrayToStr(frame.data);
|
|
|
- return {
|
|
|
- key: frame.type,
|
|
|
- info: "",
|
|
|
- data: url
|
|
|
- };
|
|
|
-}
|
|
|
-function decodeId3Frame(frame) {
|
|
|
- if (frame.type === "PRIV") {
|
|
|
- return decodeId3PrivFrame(frame);
|
|
|
- } else if (frame.type[0] === "W") {
|
|
|
- return decodeId3UrlFrame(frame);
|
|
|
- } else if (frame.type === "APIC") {
|
|
|
- return decodeId3ImageFrame(frame);
|
|
|
- }
|
|
|
- return decodeId3TextFrame(frame);
|
|
|
-}
|
|
|
-function getId3FrameData(data) {
|
|
|
- const type = String.fromCharCode(data[0], data[1], data[2], data[3]);
|
|
|
- const size = readId3Size(data, 4);
|
|
|
- const offset = 10;
|
|
|
- return {
|
|
|
- type,
|
|
|
- size,
|
|
|
- data: data.subarray(offset, offset + size)
|
|
|
- };
|
|
|
-}
|
|
|
-var HEADER_FOOTER_SIZE = 10;
|
|
|
-var FRAME_SIZE = 10;
|
|
|
-function getId3Frames(id3Data) {
|
|
|
- let offset = 0;
|
|
|
- const frames = [];
|
|
|
- while (isId3Header(id3Data, offset)) {
|
|
|
- const size = readId3Size(id3Data, offset + 6);
|
|
|
- if (id3Data[offset + 5] >> 6 & 1) {
|
|
|
- offset += HEADER_FOOTER_SIZE;
|
|
|
- }
|
|
|
- offset += HEADER_FOOTER_SIZE;
|
|
|
- const end = offset + size;
|
|
|
- while (offset + FRAME_SIZE < end) {
|
|
|
- const frameData = getId3FrameData(id3Data.subarray(offset));
|
|
|
- const frame = decodeId3Frame(frameData);
|
|
|
- if (frame) {
|
|
|
- frames.push(frame);
|
|
|
- }
|
|
|
- offset += frameData.size + HEADER_FOOTER_SIZE;
|
|
|
- }
|
|
|
- if (isId3Footer(id3Data, offset)) {
|
|
|
- offset += HEADER_FOOTER_SIZE;
|
|
|
- }
|
|
|
- }
|
|
|
- return frames;
|
|
|
-}
|
|
|
-function isId3TimestampFrame(frame) {
|
|
|
- return frame && frame.key === "PRIV" && frame.info === "com.apple.streaming.transportStreamTimestamp";
|
|
|
-}
|
|
|
-function readId3Timestamp(timeStampFrame) {
|
|
|
- if (timeStampFrame.data.byteLength === 8) {
|
|
|
- const data = new Uint8Array(timeStampFrame.data);
|
|
|
- const pts33Bit = data[3] & 1;
|
|
|
- let timestamp = (data[4] << 23) + (data[5] << 15) + (data[6] << 7) + data[7];
|
|
|
- timestamp /= 45;
|
|
|
- if (pts33Bit) {
|
|
|
- timestamp += 4772185884e-2;
|
|
|
- }
|
|
|
- return Math.round(timestamp);
|
|
|
- }
|
|
|
- return void 0;
|
|
|
-}
|
|
|
-function getId3Timestamp(data) {
|
|
|
- const frames = getId3Frames(data);
|
|
|
- for (let i = 0; i < frames.length; i++) {
|
|
|
- const frame = frames[i];
|
|
|
- if (isId3TimestampFrame(frame)) {
|
|
|
- return readId3Timestamp(frame);
|
|
|
- }
|
|
|
- }
|
|
|
- return void 0;
|
|
|
-}
|
|
|
-var MetadataSchema = function(MetadataSchema2) {
|
|
|
- MetadataSchema2["audioId3"] = "org.id3";
|
|
|
- MetadataSchema2["dateRange"] = "com.apple.quicktime.HLS";
|
|
|
- MetadataSchema2["emsg"] = "https://aomedia.org/emsg/ID3";
|
|
|
- MetadataSchema2["misbklv"] = "urn:misb:KLV:bin:1910.1";
|
|
|
- return MetadataSchema2;
|
|
|
-}({});
|
|
|
-function dummyTrack(type = "", inputTimeScale = 9e4) {
|
|
|
- return {
|
|
|
- type,
|
|
|
- id: -1,
|
|
|
- pid: -1,
|
|
|
- inputTimeScale,
|
|
|
- sequenceNumber: -1,
|
|
|
- samples: [],
|
|
|
- dropped: 0
|
|
|
- };
|
|
|
-}
|
|
|
-var BaseAudioDemuxer = class {
|
|
|
- constructor() {
|
|
|
- this._audioTrack = void 0;
|
|
|
- this._id3Track = void 0;
|
|
|
- this.frameIndex = 0;
|
|
|
- this.cachedData = null;
|
|
|
- this.basePTS = null;
|
|
|
- this.initPTS = null;
|
|
|
- this.lastPTS = null;
|
|
|
- }
|
|
|
- resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration) {
|
|
|
- this._id3Track = {
|
|
|
- type: "id3",
|
|
|
- id: 3,
|
|
|
- pid: -1,
|
|
|
- inputTimeScale: 9e4,
|
|
|
- sequenceNumber: 0,
|
|
|
- samples: [],
|
|
|
- dropped: 0
|
|
|
- };
|
|
|
- }
|
|
|
- resetTimeStamp(deaultTimestamp) {
|
|
|
- this.initPTS = deaultTimestamp;
|
|
|
- this.resetContiguity();
|
|
|
- }
|
|
|
- resetContiguity() {
|
|
|
- this.basePTS = null;
|
|
|
- this.lastPTS = null;
|
|
|
- this.frameIndex = 0;
|
|
|
- }
|
|
|
- canParse(data, offset) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- appendFrame(track, data, offset) {
|
|
|
- }
|
|
|
- // feed incoming data to the front of the parsing pipeline
|
|
|
- demux(data, timeOffset) {
|
|
|
- if (this.cachedData) {
|
|
|
- data = appendUint8Array(this.cachedData, data);
|
|
|
- this.cachedData = null;
|
|
|
- }
|
|
|
- let id3Data = getId3Data(data, 0);
|
|
|
- let offset = id3Data ? id3Data.length : 0;
|
|
|
- let lastDataIndex;
|
|
|
- const track = this._audioTrack;
|
|
|
- const id3Track = this._id3Track;
|
|
|
- const timestamp = id3Data ? getId3Timestamp(id3Data) : void 0;
|
|
|
- const length = data.length;
|
|
|
- if (this.basePTS === null || this.frameIndex === 0 && isFiniteNumber(timestamp)) {
|
|
|
- this.basePTS = initPTSFn(timestamp, timeOffset, this.initPTS);
|
|
|
- this.lastPTS = this.basePTS;
|
|
|
- }
|
|
|
- if (this.lastPTS === null) {
|
|
|
- this.lastPTS = this.basePTS;
|
|
|
- }
|
|
|
- if (id3Data && id3Data.length > 0) {
|
|
|
- id3Track.samples.push({
|
|
|
- pts: this.lastPTS,
|
|
|
- dts: this.lastPTS,
|
|
|
- data: id3Data,
|
|
|
- type: MetadataSchema.audioId3,
|
|
|
- duration: Number.POSITIVE_INFINITY
|
|
|
- });
|
|
|
- }
|
|
|
- while (offset < length) {
|
|
|
- if (this.canParse(data, offset)) {
|
|
|
- const frame = this.appendFrame(track, data, offset);
|
|
|
- if (frame) {
|
|
|
- this.frameIndex++;
|
|
|
- this.lastPTS = frame.sample.pts;
|
|
|
- offset += frame.length;
|
|
|
- lastDataIndex = offset;
|
|
|
- } else {
|
|
|
- offset = length;
|
|
|
- }
|
|
|
- } else if (canParseId3(data, offset)) {
|
|
|
- id3Data = getId3Data(data, offset);
|
|
|
- id3Track.samples.push({
|
|
|
- pts: this.lastPTS,
|
|
|
- dts: this.lastPTS,
|
|
|
- data: id3Data,
|
|
|
- type: MetadataSchema.audioId3,
|
|
|
- duration: Number.POSITIVE_INFINITY
|
|
|
- });
|
|
|
- offset += id3Data.length;
|
|
|
- lastDataIndex = offset;
|
|
|
- } else {
|
|
|
- offset++;
|
|
|
- }
|
|
|
- if (offset === length && lastDataIndex !== length) {
|
|
|
- const partialData = data.slice(lastDataIndex);
|
|
|
- if (this.cachedData) {
|
|
|
- this.cachedData = appendUint8Array(this.cachedData, partialData);
|
|
|
- } else {
|
|
|
- this.cachedData = partialData;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- audioTrack: track,
|
|
|
- videoTrack: dummyTrack(),
|
|
|
- id3Track,
|
|
|
- textTrack: dummyTrack()
|
|
|
- };
|
|
|
- }
|
|
|
- demuxSampleAes(data, keyData, timeOffset) {
|
|
|
- return Promise.reject(new Error(`[${this}] This demuxer does not support Sample-AES decryption`));
|
|
|
- }
|
|
|
- flush(timeOffset) {
|
|
|
- const cachedData = this.cachedData;
|
|
|
- if (cachedData) {
|
|
|
- this.cachedData = null;
|
|
|
- this.demux(cachedData, 0);
|
|
|
- }
|
|
|
- return {
|
|
|
- audioTrack: this._audioTrack,
|
|
|
- videoTrack: dummyTrack(),
|
|
|
- id3Track: this._id3Track,
|
|
|
- textTrack: dummyTrack()
|
|
|
- };
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.cachedData = null;
|
|
|
- this._audioTrack = this._id3Track = void 0;
|
|
|
- }
|
|
|
-};
|
|
|
-var initPTSFn = (timestamp, timeOffset, initPTS) => {
|
|
|
- if (isFiniteNumber(timestamp)) {
|
|
|
- return timestamp * 90;
|
|
|
- }
|
|
|
- const init90kHz = initPTS ? initPTS.baseTime * 9e4 / initPTS.timescale : 0;
|
|
|
- return timeOffset * 9e4 + init90kHz;
|
|
|
-};
|
|
|
-var chromeVersion$1 = null;
|
|
|
-var BitratesMap = [32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160];
|
|
|
-var SamplingRateMap = [44100, 48e3, 32e3, 22050, 24e3, 16e3, 11025, 12e3, 8e3];
|
|
|
-var SamplesCoefficients = [
|
|
|
- // MPEG 2.5
|
|
|
- [
|
|
|
- 0,
|
|
|
- // Reserved
|
|
|
- 72,
|
|
|
- // Layer3
|
|
|
- 144,
|
|
|
- // Layer2
|
|
|
- 12
|
|
|
- // Layer1
|
|
|
- ],
|
|
|
- // Reserved
|
|
|
- [
|
|
|
- 0,
|
|
|
- // Reserved
|
|
|
- 0,
|
|
|
- // Layer3
|
|
|
- 0,
|
|
|
- // Layer2
|
|
|
- 0
|
|
|
- // Layer1
|
|
|
- ],
|
|
|
- // MPEG 2
|
|
|
- [
|
|
|
- 0,
|
|
|
- // Reserved
|
|
|
- 72,
|
|
|
- // Layer3
|
|
|
- 144,
|
|
|
- // Layer2
|
|
|
- 12
|
|
|
- // Layer1
|
|
|
- ],
|
|
|
- // MPEG 1
|
|
|
- [
|
|
|
- 0,
|
|
|
- // Reserved
|
|
|
- 144,
|
|
|
- // Layer3
|
|
|
- 144,
|
|
|
- // Layer2
|
|
|
- 12
|
|
|
- // Layer1
|
|
|
- ]
|
|
|
-];
|
|
|
-var BytesInSlot = [
|
|
|
- 0,
|
|
|
- // Reserved
|
|
|
- 1,
|
|
|
- // Layer3
|
|
|
- 1,
|
|
|
- // Layer2
|
|
|
- 4
|
|
|
- // Layer1
|
|
|
-];
|
|
|
-function appendFrame$1(track, data, offset, pts, frameIndex) {
|
|
|
- if (offset + 24 > data.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const header = parseHeader(data, offset);
|
|
|
- if (header && offset + header.frameLength <= data.length) {
|
|
|
- const frameDuration = header.samplesPerFrame * 9e4 / header.sampleRate;
|
|
|
- const stamp = pts + frameIndex * frameDuration;
|
|
|
- const sample = {
|
|
|
- unit: data.subarray(offset, offset + header.frameLength),
|
|
|
- pts: stamp,
|
|
|
- dts: stamp
|
|
|
- };
|
|
|
- track.config = [];
|
|
|
- track.channelCount = header.channelCount;
|
|
|
- track.samplerate = header.sampleRate;
|
|
|
- track.samples.push(sample);
|
|
|
- return {
|
|
|
- sample,
|
|
|
- length: header.frameLength,
|
|
|
- missing: 0
|
|
|
- };
|
|
|
- }
|
|
|
-}
|
|
|
-function parseHeader(data, offset) {
|
|
|
- const mpegVersion = data[offset + 1] >> 3 & 3;
|
|
|
- const mpegLayer = data[offset + 1] >> 1 & 3;
|
|
|
- const bitRateIndex = data[offset + 2] >> 4 & 15;
|
|
|
- const sampleRateIndex = data[offset + 2] >> 2 & 3;
|
|
|
- if (mpegVersion !== 1 && bitRateIndex !== 0 && bitRateIndex !== 15 && sampleRateIndex !== 3) {
|
|
|
- const paddingBit = data[offset + 2] >> 1 & 1;
|
|
|
- const channelMode = data[offset + 3] >> 6;
|
|
|
- const columnInBitrates = mpegVersion === 3 ? 3 - mpegLayer : mpegLayer === 3 ? 3 : 4;
|
|
|
- const bitRate = BitratesMap[columnInBitrates * 14 + bitRateIndex - 1] * 1e3;
|
|
|
- const columnInSampleRates = mpegVersion === 3 ? 0 : mpegVersion === 2 ? 1 : 2;
|
|
|
- const sampleRate = SamplingRateMap[columnInSampleRates * 3 + sampleRateIndex];
|
|
|
- const channelCount = channelMode === 3 ? 1 : 2;
|
|
|
- const sampleCoefficient = SamplesCoefficients[mpegVersion][mpegLayer];
|
|
|
- const bytesInSlot = BytesInSlot[mpegLayer];
|
|
|
- const samplesPerFrame = sampleCoefficient * 8 * bytesInSlot;
|
|
|
- const frameLength = Math.floor(sampleCoefficient * bitRate / sampleRate + paddingBit) * bytesInSlot;
|
|
|
- if (chromeVersion$1 === null) {
|
|
|
- const userAgent = navigator.userAgent || "";
|
|
|
- const result = userAgent.match(/Chrome\/(\d+)/i);
|
|
|
- chromeVersion$1 = result ? parseInt(result[1]) : 0;
|
|
|
- }
|
|
|
- const needChromeFix = !!chromeVersion$1 && chromeVersion$1 <= 87;
|
|
|
- if (needChromeFix && mpegLayer === 2 && bitRate >= 224e3 && channelMode === 0) {
|
|
|
- data[offset + 3] = data[offset + 3] | 128;
|
|
|
- }
|
|
|
- return {
|
|
|
- sampleRate,
|
|
|
- channelCount,
|
|
|
- frameLength,
|
|
|
- samplesPerFrame
|
|
|
- };
|
|
|
- }
|
|
|
-}
|
|
|
-function isHeaderPattern(data, offset) {
|
|
|
- return data[offset] === 255 && (data[offset + 1] & 224) === 224 && (data[offset + 1] & 6) !== 0;
|
|
|
-}
|
|
|
-function isHeader(data, offset) {
|
|
|
- return offset + 1 < data.length && isHeaderPattern(data, offset);
|
|
|
-}
|
|
|
-function canParse(data, offset) {
|
|
|
- const headerSize = 4;
|
|
|
- return isHeaderPattern(data, offset) && headerSize <= data.length - offset;
|
|
|
-}
|
|
|
-function probe(data, offset) {
|
|
|
- if (offset + 1 < data.length && isHeaderPattern(data, offset)) {
|
|
|
- const headerLength = 4;
|
|
|
- const header = parseHeader(data, offset);
|
|
|
- let frameLength = headerLength;
|
|
|
- if (header != null && header.frameLength) {
|
|
|
- frameLength = header.frameLength;
|
|
|
- }
|
|
|
- const newOffset = offset + frameLength;
|
|
|
- return newOffset === data.length || isHeader(data, newOffset);
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-var AACDemuxer = class extends BaseAudioDemuxer {
|
|
|
- constructor(observer, config) {
|
|
|
- super();
|
|
|
- this.observer = void 0;
|
|
|
- this.config = void 0;
|
|
|
- this.observer = observer;
|
|
|
- this.config = config;
|
|
|
- }
|
|
|
- resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration) {
|
|
|
- super.resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration);
|
|
|
- this._audioTrack = {
|
|
|
- container: "audio/adts",
|
|
|
- type: "audio",
|
|
|
- id: 2,
|
|
|
- pid: -1,
|
|
|
- sequenceNumber: 0,
|
|
|
- segmentCodec: "aac",
|
|
|
- samples: [],
|
|
|
- manifestCodec: audioCodec,
|
|
|
- duration: trackDuration,
|
|
|
- inputTimeScale: 9e4,
|
|
|
- dropped: 0
|
|
|
- };
|
|
|
- }
|
|
|
- // Source for probe info - https://wiki.multimedia.cx/index.php?title=ADTS
|
|
|
- static probe(data, logger2) {
|
|
|
- if (!data) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const id3Data = getId3Data(data, 0);
|
|
|
- let offset = (id3Data == null ? void 0 : id3Data.length) || 0;
|
|
|
- if (probe(data, offset)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (let length = data.length; offset < length; offset++) {
|
|
|
- if (probe$1(data, offset)) {
|
|
|
- logger2.log("ADTS sync word found !");
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- canParse(data, offset) {
|
|
|
- return canParse$1(data, offset);
|
|
|
- }
|
|
|
- appendFrame(track, data, offset) {
|
|
|
- initTrackConfig(track, this.observer, data, offset, track.manifestCodec);
|
|
|
- const frame = appendFrame$2(track, data, offset, this.basePTS, this.frameIndex);
|
|
|
- if (frame && frame.missing === 0) {
|
|
|
- return frame;
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var getAudioBSID = (data, offset) => {
|
|
|
- let bsid = 0;
|
|
|
- let numBits = 5;
|
|
|
- offset += numBits;
|
|
|
- const temp = new Uint32Array(1);
|
|
|
- const mask = new Uint32Array(1);
|
|
|
- const byte = new Uint8Array(1);
|
|
|
- while (numBits > 0) {
|
|
|
- byte[0] = data[offset];
|
|
|
- const bits = Math.min(numBits, 8);
|
|
|
- const shift = 8 - bits;
|
|
|
- mask[0] = 4278190080 >>> 24 + shift << shift;
|
|
|
- temp[0] = (byte[0] & mask[0]) >> shift;
|
|
|
- bsid = !bsid ? temp[0] : bsid << bits | temp[0];
|
|
|
- offset += 1;
|
|
|
- numBits -= bits;
|
|
|
- }
|
|
|
- return bsid;
|
|
|
-};
|
|
|
-var AC3Demuxer = class extends BaseAudioDemuxer {
|
|
|
- constructor(observer) {
|
|
|
- super();
|
|
|
- this.observer = void 0;
|
|
|
- this.observer = observer;
|
|
|
- }
|
|
|
- resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration) {
|
|
|
- super.resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration);
|
|
|
- this._audioTrack = {
|
|
|
- container: "audio/ac-3",
|
|
|
- type: "audio",
|
|
|
- id: 2,
|
|
|
- pid: -1,
|
|
|
- sequenceNumber: 0,
|
|
|
- segmentCodec: "ac3",
|
|
|
- samples: [],
|
|
|
- manifestCodec: audioCodec,
|
|
|
- duration: trackDuration,
|
|
|
- inputTimeScale: 9e4,
|
|
|
- dropped: 0
|
|
|
- };
|
|
|
- }
|
|
|
- canParse(data, offset) {
|
|
|
- return offset + 64 < data.length;
|
|
|
- }
|
|
|
- appendFrame(track, data, offset) {
|
|
|
- const frameLength = appendFrame(track, data, offset, this.basePTS, this.frameIndex);
|
|
|
- if (frameLength !== -1) {
|
|
|
- const sample = track.samples[track.samples.length - 1];
|
|
|
- return {
|
|
|
- sample,
|
|
|
- length: frameLength,
|
|
|
- missing: 0
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- static probe(data) {
|
|
|
- if (!data) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const id3Data = getId3Data(data, 0);
|
|
|
- if (!id3Data) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const offset = id3Data.length;
|
|
|
- if (data[offset] === 11 && data[offset + 1] === 119 && getId3Timestamp(id3Data) !== void 0 && // check the bsid to confirm ac-3
|
|
|
- getAudioBSID(data, offset) < 16) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
-};
|
|
|
-function appendFrame(track, data, start, pts, frameIndex) {
|
|
|
- if (start + 8 > data.length) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- if (data[start] !== 11 || data[start + 1] !== 119) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- const samplingRateCode = data[start + 4] >> 6;
|
|
|
- if (samplingRateCode >= 3) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- const samplingRateMap = [48e3, 44100, 32e3];
|
|
|
- const sampleRate = samplingRateMap[samplingRateCode];
|
|
|
- const frameSizeCode = data[start + 4] & 63;
|
|
|
- const frameSizeMap = [64, 69, 96, 64, 70, 96, 80, 87, 120, 80, 88, 120, 96, 104, 144, 96, 105, 144, 112, 121, 168, 112, 122, 168, 128, 139, 192, 128, 140, 192, 160, 174, 240, 160, 175, 240, 192, 208, 288, 192, 209, 288, 224, 243, 336, 224, 244, 336, 256, 278, 384, 256, 279, 384, 320, 348, 480, 320, 349, 480, 384, 417, 576, 384, 418, 576, 448, 487, 672, 448, 488, 672, 512, 557, 768, 512, 558, 768, 640, 696, 960, 640, 697, 960, 768, 835, 1152, 768, 836, 1152, 896, 975, 1344, 896, 976, 1344, 1024, 1114, 1536, 1024, 1115, 1536, 1152, 1253, 1728, 1152, 1254, 1728, 1280, 1393, 1920, 1280, 1394, 1920];
|
|
|
- const frameLength = frameSizeMap[frameSizeCode * 3 + samplingRateCode] * 2;
|
|
|
- if (start + frameLength > data.length) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- const channelMode = data[start + 6] >> 5;
|
|
|
- let skipCount = 0;
|
|
|
- if (channelMode === 2) {
|
|
|
- skipCount += 2;
|
|
|
- } else {
|
|
|
- if (channelMode & 1 && channelMode !== 1) {
|
|
|
- skipCount += 2;
|
|
|
- }
|
|
|
- if (channelMode & 4) {
|
|
|
- skipCount += 2;
|
|
|
- }
|
|
|
- }
|
|
|
- const lfeon = (data[start + 6] << 8 | data[start + 7]) >> 12 - skipCount & 1;
|
|
|
- const channelsMap = [2, 1, 2, 3, 3, 4, 4, 5];
|
|
|
- const channelCount = channelsMap[channelMode] + lfeon;
|
|
|
- const bsid = data[start + 5] >> 3;
|
|
|
- const bsmod = data[start + 5] & 7;
|
|
|
- const config = new Uint8Array([samplingRateCode << 6 | bsid << 1 | bsmod >> 2, (bsmod & 3) << 6 | channelMode << 3 | lfeon << 2 | frameSizeCode >> 4, frameSizeCode << 4 & 224]);
|
|
|
- const frameDuration = 1536 / sampleRate * 9e4;
|
|
|
- const stamp = pts + frameIndex * frameDuration;
|
|
|
- const unit = data.subarray(start, start + frameLength);
|
|
|
- track.config = config;
|
|
|
- track.channelCount = channelCount;
|
|
|
- track.samplerate = sampleRate;
|
|
|
- track.samples.push({
|
|
|
- unit,
|
|
|
- pts: stamp
|
|
|
- });
|
|
|
- return frameLength;
|
|
|
-}
|
|
|
-var MP3Demuxer = class extends BaseAudioDemuxer {
|
|
|
- resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration) {
|
|
|
- super.resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration);
|
|
|
- this._audioTrack = {
|
|
|
- container: "audio/mpeg",
|
|
|
- type: "audio",
|
|
|
- id: 2,
|
|
|
- pid: -1,
|
|
|
- sequenceNumber: 0,
|
|
|
- segmentCodec: "mp3",
|
|
|
- samples: [],
|
|
|
- manifestCodec: audioCodec,
|
|
|
- duration: trackDuration,
|
|
|
- inputTimeScale: 9e4,
|
|
|
- dropped: 0
|
|
|
- };
|
|
|
- }
|
|
|
- static probe(data) {
|
|
|
- if (!data) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const id3Data = getId3Data(data, 0);
|
|
|
- let offset = (id3Data == null ? void 0 : id3Data.length) || 0;
|
|
|
- if (id3Data && data[offset] === 11 && data[offset + 1] === 119 && getId3Timestamp(id3Data) !== void 0 && // check the bsid to confirm ac-3 or ec-3 (not mp3)
|
|
|
- getAudioBSID(data, offset) <= 16) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (let length = data.length; offset < length; offset++) {
|
|
|
- if (probe(data, offset)) {
|
|
|
- logger.log("MPEG Audio sync word found !");
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- canParse(data, offset) {
|
|
|
- return canParse(data, offset);
|
|
|
- }
|
|
|
- appendFrame(track, data, offset) {
|
|
|
- if (this.basePTS === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- return appendFrame$1(track, data, offset, this.basePTS, this.frameIndex);
|
|
|
- }
|
|
|
-};
|
|
|
-var emsgSchemePattern = /\/emsg[-/]ID3/i;
|
|
|
-var MP4Demuxer = class {
|
|
|
- constructor(observer, config) {
|
|
|
- this.remainderData = null;
|
|
|
- this.timeOffset = 0;
|
|
|
- this.config = void 0;
|
|
|
- this.videoTrack = void 0;
|
|
|
- this.audioTrack = void 0;
|
|
|
- this.id3Track = void 0;
|
|
|
- this.txtTrack = void 0;
|
|
|
- this.config = config;
|
|
|
- }
|
|
|
- resetTimeStamp() {
|
|
|
- }
|
|
|
- resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration) {
|
|
|
- const videoTrack = this.videoTrack = dummyTrack("video", 1);
|
|
|
- const audioTrack = this.audioTrack = dummyTrack("audio", 1);
|
|
|
- const captionTrack = this.txtTrack = dummyTrack("text", 1);
|
|
|
- this.id3Track = dummyTrack("id3", 1);
|
|
|
- this.timeOffset = 0;
|
|
|
- if (!(initSegment != null && initSegment.byteLength)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const initData = parseInitSegment(initSegment);
|
|
|
- if (initData.video) {
|
|
|
- const {
|
|
|
- id,
|
|
|
- timescale,
|
|
|
- codec,
|
|
|
- supplemental
|
|
|
- } = initData.video;
|
|
|
- videoTrack.id = id;
|
|
|
- videoTrack.timescale = captionTrack.timescale = timescale;
|
|
|
- videoTrack.codec = codec;
|
|
|
- videoTrack.supplemental = supplemental;
|
|
|
- }
|
|
|
- if (initData.audio) {
|
|
|
- const {
|
|
|
- id,
|
|
|
- timescale,
|
|
|
- codec
|
|
|
- } = initData.audio;
|
|
|
- audioTrack.id = id;
|
|
|
- audioTrack.timescale = timescale;
|
|
|
- audioTrack.codec = codec;
|
|
|
- }
|
|
|
- captionTrack.id = RemuxerTrackIdConfig.text;
|
|
|
- videoTrack.sampleDuration = 0;
|
|
|
- videoTrack.duration = audioTrack.duration = trackDuration;
|
|
|
- }
|
|
|
- resetContiguity() {
|
|
|
- this.remainderData = null;
|
|
|
- }
|
|
|
- static probe(data) {
|
|
|
- return hasMoofData(data);
|
|
|
- }
|
|
|
- demux(data, timeOffset) {
|
|
|
- this.timeOffset = timeOffset;
|
|
|
- let videoSamples = data;
|
|
|
- const videoTrack = this.videoTrack;
|
|
|
- const textTrack = this.txtTrack;
|
|
|
- if (this.config.progressive) {
|
|
|
- if (this.remainderData) {
|
|
|
- videoSamples = appendUint8Array(this.remainderData, data);
|
|
|
- }
|
|
|
- const segmentedData = segmentValidRange(videoSamples);
|
|
|
- this.remainderData = segmentedData.remainder;
|
|
|
- videoTrack.samples = segmentedData.valid || new Uint8Array();
|
|
|
- } else {
|
|
|
- videoTrack.samples = videoSamples;
|
|
|
- }
|
|
|
- const id3Track = this.extractID3Track(videoTrack, timeOffset);
|
|
|
- textTrack.samples = parseSamples(timeOffset, videoTrack);
|
|
|
- return {
|
|
|
- videoTrack,
|
|
|
- audioTrack: this.audioTrack,
|
|
|
- id3Track,
|
|
|
- textTrack: this.txtTrack
|
|
|
- };
|
|
|
- }
|
|
|
- flush() {
|
|
|
- const timeOffset = this.timeOffset;
|
|
|
- const videoTrack = this.videoTrack;
|
|
|
- const textTrack = this.txtTrack;
|
|
|
- videoTrack.samples = this.remainderData || new Uint8Array();
|
|
|
- this.remainderData = null;
|
|
|
- const id3Track = this.extractID3Track(videoTrack, this.timeOffset);
|
|
|
- textTrack.samples = parseSamples(timeOffset, videoTrack);
|
|
|
- return {
|
|
|
- videoTrack,
|
|
|
- audioTrack: dummyTrack(),
|
|
|
- id3Track,
|
|
|
- textTrack: dummyTrack()
|
|
|
- };
|
|
|
- }
|
|
|
- extractID3Track(videoTrack, timeOffset) {
|
|
|
- const id3Track = this.id3Track;
|
|
|
- if (videoTrack.samples.length) {
|
|
|
- const emsgs = findBox(videoTrack.samples, ["emsg"]);
|
|
|
- if (emsgs) {
|
|
|
- emsgs.forEach((data) => {
|
|
|
- const emsgInfo = parseEmsg(data);
|
|
|
- if (emsgSchemePattern.test(emsgInfo.schemeIdUri)) {
|
|
|
- const pts = getEmsgStartTime(emsgInfo, timeOffset);
|
|
|
- let duration = emsgInfo.eventDuration === 4294967295 ? Number.POSITIVE_INFINITY : emsgInfo.eventDuration / emsgInfo.timeScale;
|
|
|
- if (duration <= 1e-3) {
|
|
|
- duration = Number.POSITIVE_INFINITY;
|
|
|
- }
|
|
|
- const payload = emsgInfo.payload;
|
|
|
- id3Track.samples.push({
|
|
|
- data: payload,
|
|
|
- len: payload.byteLength,
|
|
|
- dts: pts,
|
|
|
- pts,
|
|
|
- type: MetadataSchema.emsg,
|
|
|
- duration
|
|
|
- });
|
|
|
- } else if (this.config.enableEmsgKLVMetadata && emsgInfo.schemeIdUri.startsWith("urn:misb:KLV:bin:1910.1")) {
|
|
|
- const pts = getEmsgStartTime(emsgInfo, timeOffset);
|
|
|
- id3Track.samples.push({
|
|
|
- data: emsgInfo.payload,
|
|
|
- len: emsgInfo.payload.byteLength,
|
|
|
- dts: pts,
|
|
|
- pts,
|
|
|
- type: MetadataSchema.misbklv,
|
|
|
- duration: Number.POSITIVE_INFINITY
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- return id3Track;
|
|
|
- }
|
|
|
- demuxSampleAes(data, keyData, timeOffset) {
|
|
|
- return Promise.reject(new Error("The MP4 demuxer does not support SAMPLE-AES decryption"));
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.config = null;
|
|
|
- this.remainderData = null;
|
|
|
- this.videoTrack = this.audioTrack = this.id3Track = this.txtTrack = void 0;
|
|
|
- }
|
|
|
-};
|
|
|
-function getEmsgStartTime(emsgInfo, timeOffset) {
|
|
|
- return isFiniteNumber(emsgInfo.presentationTime) ? emsgInfo.presentationTime / emsgInfo.timeScale : timeOffset + emsgInfo.presentationTimeDelta / emsgInfo.timeScale;
|
|
|
-}
|
|
|
-var SampleAesDecrypter = class {
|
|
|
- constructor(observer, config, keyData) {
|
|
|
- this.keyData = void 0;
|
|
|
- this.decrypter = void 0;
|
|
|
- this.keyData = keyData;
|
|
|
- this.decrypter = new Decrypter(config, {
|
|
|
- removePKCS7Padding: false
|
|
|
- });
|
|
|
- }
|
|
|
- decryptBuffer(encryptedData) {
|
|
|
- return this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer, DecrypterAesMode.cbc);
|
|
|
- }
|
|
|
- // AAC - encrypt all full 16 bytes blocks starting from offset 16
|
|
|
- decryptAacSample(samples, sampleIndex, callback) {
|
|
|
- const curUnit = samples[sampleIndex].unit;
|
|
|
- if (curUnit.length <= 16) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const encryptedData = curUnit.subarray(16, curUnit.length - curUnit.length % 16);
|
|
|
- const encryptedBuffer = encryptedData.buffer.slice(encryptedData.byteOffset, encryptedData.byteOffset + encryptedData.length);
|
|
|
- this.decryptBuffer(encryptedBuffer).then((decryptedBuffer) => {
|
|
|
- const decryptedData = new Uint8Array(decryptedBuffer);
|
|
|
- curUnit.set(decryptedData, 16);
|
|
|
- if (!this.decrypter.isSync()) {
|
|
|
- this.decryptAacSamples(samples, sampleIndex + 1, callback);
|
|
|
- }
|
|
|
- }).catch(callback);
|
|
|
- }
|
|
|
- decryptAacSamples(samples, sampleIndex, callback) {
|
|
|
- for (; ; sampleIndex++) {
|
|
|
- if (sampleIndex >= samples.length) {
|
|
|
- callback();
|
|
|
- return;
|
|
|
- }
|
|
|
- if (samples[sampleIndex].unit.length < 32) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- this.decryptAacSample(samples, sampleIndex, callback);
|
|
|
- if (!this.decrypter.isSync()) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- // AVC - encrypt one 16 bytes block out of ten, starting from offset 32
|
|
|
- getAvcEncryptedData(decodedData) {
|
|
|
- const encryptedDataLen = Math.floor((decodedData.length - 48) / 160) * 16 + 16;
|
|
|
- const encryptedData = new Int8Array(encryptedDataLen);
|
|
|
- let outputPos = 0;
|
|
|
- for (let inputPos = 32; inputPos < decodedData.length - 16; inputPos += 160, outputPos += 16) {
|
|
|
- encryptedData.set(decodedData.subarray(inputPos, inputPos + 16), outputPos);
|
|
|
- }
|
|
|
- return encryptedData;
|
|
|
- }
|
|
|
- getAvcDecryptedUnit(decodedData, decryptedData) {
|
|
|
- const uint8DecryptedData = new Uint8Array(decryptedData);
|
|
|
- let inputPos = 0;
|
|
|
- for (let outputPos = 32; outputPos < decodedData.length - 16; outputPos += 160, inputPos += 16) {
|
|
|
- decodedData.set(uint8DecryptedData.subarray(inputPos, inputPos + 16), outputPos);
|
|
|
- }
|
|
|
- return decodedData;
|
|
|
- }
|
|
|
- decryptAvcSample(samples, sampleIndex, unitIndex, callback, curUnit) {
|
|
|
- const decodedData = discardEPB(curUnit.data);
|
|
|
- const encryptedData = this.getAvcEncryptedData(decodedData);
|
|
|
- this.decryptBuffer(encryptedData.buffer).then((decryptedBuffer) => {
|
|
|
- curUnit.data = this.getAvcDecryptedUnit(decodedData, decryptedBuffer);
|
|
|
- if (!this.decrypter.isSync()) {
|
|
|
- this.decryptAvcSamples(samples, sampleIndex, unitIndex + 1, callback);
|
|
|
- }
|
|
|
- }).catch(callback);
|
|
|
- }
|
|
|
- decryptAvcSamples(samples, sampleIndex, unitIndex, callback) {
|
|
|
- if (samples instanceof Uint8Array) {
|
|
|
- throw new Error("Cannot decrypt samples of type Uint8Array");
|
|
|
- }
|
|
|
- for (; ; sampleIndex++, unitIndex = 0) {
|
|
|
- if (sampleIndex >= samples.length) {
|
|
|
- callback();
|
|
|
- return;
|
|
|
- }
|
|
|
- const curUnits = samples[sampleIndex].units;
|
|
|
- for (; ; unitIndex++) {
|
|
|
- if (unitIndex >= curUnits.length) {
|
|
|
- break;
|
|
|
- }
|
|
|
- const curUnit = curUnits[unitIndex];
|
|
|
- if (curUnit.data.length <= 48 || curUnit.type !== 1 && curUnit.type !== 5) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- this.decryptAvcSample(samples, sampleIndex, unitIndex, callback, curUnit);
|
|
|
- if (!this.decrypter.isSync()) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var BaseVideoParser = class {
|
|
|
- constructor() {
|
|
|
- this.VideoSample = null;
|
|
|
- }
|
|
|
- createVideoSample(key, pts, dts) {
|
|
|
- return {
|
|
|
- key,
|
|
|
- frame: false,
|
|
|
- pts,
|
|
|
- dts,
|
|
|
- units: [],
|
|
|
- length: 0
|
|
|
- };
|
|
|
- }
|
|
|
- getLastNalUnit(samples) {
|
|
|
- var _VideoSample;
|
|
|
- let VideoSample = this.VideoSample;
|
|
|
- let lastUnit;
|
|
|
- if (!VideoSample || VideoSample.units.length === 0) {
|
|
|
- VideoSample = samples[samples.length - 1];
|
|
|
- }
|
|
|
- if ((_VideoSample = VideoSample) != null && _VideoSample.units) {
|
|
|
- const units = VideoSample.units;
|
|
|
- lastUnit = units[units.length - 1];
|
|
|
- }
|
|
|
- return lastUnit;
|
|
|
- }
|
|
|
- pushAccessUnit(VideoSample, videoTrack) {
|
|
|
- if (VideoSample.units.length && VideoSample.frame) {
|
|
|
- if (VideoSample.pts === void 0) {
|
|
|
- const samples = videoTrack.samples;
|
|
|
- const nbSamples = samples.length;
|
|
|
- if (nbSamples) {
|
|
|
- const lastSample = samples[nbSamples - 1];
|
|
|
- VideoSample.pts = lastSample.pts;
|
|
|
- VideoSample.dts = lastSample.dts;
|
|
|
- } else {
|
|
|
- videoTrack.dropped++;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- videoTrack.samples.push(VideoSample);
|
|
|
- }
|
|
|
- }
|
|
|
- parseNALu(track, array, endOfSegment) {
|
|
|
- const len = array.byteLength;
|
|
|
- let state = track.naluState || 0;
|
|
|
- const lastState = state;
|
|
|
- const units = [];
|
|
|
- let i = 0;
|
|
|
- let value;
|
|
|
- let overflow;
|
|
|
- let unitType;
|
|
|
- let lastUnitStart = -1;
|
|
|
- let lastUnitType = 0;
|
|
|
- if (state === -1) {
|
|
|
- lastUnitStart = 0;
|
|
|
- lastUnitType = this.getNALuType(array, 0);
|
|
|
- state = 0;
|
|
|
- i = 1;
|
|
|
- }
|
|
|
- while (i < len) {
|
|
|
- value = array[i++];
|
|
|
- if (!state) {
|
|
|
- state = value ? 0 : 1;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (state === 1) {
|
|
|
- state = value ? 0 : 2;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (!value) {
|
|
|
- state = 3;
|
|
|
- } else if (value === 1) {
|
|
|
- overflow = i - state - 1;
|
|
|
- if (lastUnitStart >= 0) {
|
|
|
- const unit = {
|
|
|
- data: array.subarray(lastUnitStart, overflow),
|
|
|
- type: lastUnitType
|
|
|
- };
|
|
|
- units.push(unit);
|
|
|
- } else {
|
|
|
- const lastUnit = this.getLastNalUnit(track.samples);
|
|
|
- if (lastUnit) {
|
|
|
- if (lastState && i <= 4 - lastState) {
|
|
|
- if (lastUnit.state) {
|
|
|
- lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
|
|
|
- }
|
|
|
- }
|
|
|
- if (overflow > 0) {
|
|
|
- lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
|
|
|
- lastUnit.state = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (i < len) {
|
|
|
- unitType = this.getNALuType(array, i);
|
|
|
- lastUnitStart = i;
|
|
|
- lastUnitType = unitType;
|
|
|
- state = 0;
|
|
|
- } else {
|
|
|
- state = -1;
|
|
|
- }
|
|
|
- } else {
|
|
|
- state = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- if (lastUnitStart >= 0 && state >= 0) {
|
|
|
- const unit = {
|
|
|
- data: array.subarray(lastUnitStart, len),
|
|
|
- type: lastUnitType,
|
|
|
- state
|
|
|
- };
|
|
|
- units.push(unit);
|
|
|
- }
|
|
|
- if (units.length === 0) {
|
|
|
- const lastUnit = this.getLastNalUnit(track.samples);
|
|
|
- if (lastUnit) {
|
|
|
- lastUnit.data = appendUint8Array(lastUnit.data, array);
|
|
|
- }
|
|
|
- }
|
|
|
- track.naluState = state;
|
|
|
- return units;
|
|
|
- }
|
|
|
-};
|
|
|
-var ExpGolomb = class {
|
|
|
- constructor(data) {
|
|
|
- this.data = void 0;
|
|
|
- this.bytesAvailable = void 0;
|
|
|
- this.word = void 0;
|
|
|
- this.bitsAvailable = void 0;
|
|
|
- this.data = data;
|
|
|
- this.bytesAvailable = data.byteLength;
|
|
|
- this.word = 0;
|
|
|
- this.bitsAvailable = 0;
|
|
|
- }
|
|
|
- // ():void
|
|
|
- loadWord() {
|
|
|
- const data = this.data;
|
|
|
- const bytesAvailable = this.bytesAvailable;
|
|
|
- const position = data.byteLength - bytesAvailable;
|
|
|
- const workingBytes = new Uint8Array(4);
|
|
|
- const availableBytes = Math.min(4, bytesAvailable);
|
|
|
- if (availableBytes === 0) {
|
|
|
- throw new Error("no bytes available");
|
|
|
- }
|
|
|
- workingBytes.set(data.subarray(position, position + availableBytes));
|
|
|
- this.word = new DataView(workingBytes.buffer).getUint32(0);
|
|
|
- this.bitsAvailable = availableBytes * 8;
|
|
|
- this.bytesAvailable -= availableBytes;
|
|
|
- }
|
|
|
- // (count:int):void
|
|
|
- skipBits(count) {
|
|
|
- let skipBytes;
|
|
|
- count = Math.min(count, this.bytesAvailable * 8 + this.bitsAvailable);
|
|
|
- if (this.bitsAvailable > count) {
|
|
|
- this.word <<= count;
|
|
|
- this.bitsAvailable -= count;
|
|
|
- } else {
|
|
|
- count -= this.bitsAvailable;
|
|
|
- skipBytes = count >> 3;
|
|
|
- count -= skipBytes << 3;
|
|
|
- this.bytesAvailable -= skipBytes;
|
|
|
- this.loadWord();
|
|
|
- this.word <<= count;
|
|
|
- this.bitsAvailable -= count;
|
|
|
- }
|
|
|
- }
|
|
|
- // (size:int):uint
|
|
|
- readBits(size) {
|
|
|
- let bits = Math.min(this.bitsAvailable, size);
|
|
|
- const valu = this.word >>> 32 - bits;
|
|
|
- if (size > 32) {
|
|
|
- logger.error("Cannot read more than 32 bits at a time");
|
|
|
- }
|
|
|
- this.bitsAvailable -= bits;
|
|
|
- if (this.bitsAvailable > 0) {
|
|
|
- this.word <<= bits;
|
|
|
- } else if (this.bytesAvailable > 0) {
|
|
|
- this.loadWord();
|
|
|
- } else {
|
|
|
- throw new Error("no bits available");
|
|
|
- }
|
|
|
- bits = size - bits;
|
|
|
- if (bits > 0 && this.bitsAvailable) {
|
|
|
- return valu << bits | this.readBits(bits);
|
|
|
- } else {
|
|
|
- return valu;
|
|
|
- }
|
|
|
- }
|
|
|
- // ():uint
|
|
|
- skipLZ() {
|
|
|
- let leadingZeroCount;
|
|
|
- for (leadingZeroCount = 0; leadingZeroCount < this.bitsAvailable; ++leadingZeroCount) {
|
|
|
- if ((this.word & 2147483648 >>> leadingZeroCount) !== 0) {
|
|
|
- this.word <<= leadingZeroCount;
|
|
|
- this.bitsAvailable -= leadingZeroCount;
|
|
|
- return leadingZeroCount;
|
|
|
- }
|
|
|
- }
|
|
|
- this.loadWord();
|
|
|
- return leadingZeroCount + this.skipLZ();
|
|
|
- }
|
|
|
- // ():void
|
|
|
- skipUEG() {
|
|
|
- this.skipBits(1 + this.skipLZ());
|
|
|
- }
|
|
|
- // ():void
|
|
|
- skipEG() {
|
|
|
- this.skipBits(1 + this.skipLZ());
|
|
|
- }
|
|
|
- // ():uint
|
|
|
- readUEG() {
|
|
|
- const clz = this.skipLZ();
|
|
|
- return this.readBits(clz + 1) - 1;
|
|
|
- }
|
|
|
- // ():int
|
|
|
- readEG() {
|
|
|
- const valu = this.readUEG();
|
|
|
- if (1 & valu) {
|
|
|
- return 1 + valu >>> 1;
|
|
|
- } else {
|
|
|
- return -1 * (valu >>> 1);
|
|
|
- }
|
|
|
- }
|
|
|
- // Some convenience functions
|
|
|
- // :Boolean
|
|
|
- readBoolean() {
|
|
|
- return this.readBits(1) === 1;
|
|
|
- }
|
|
|
- // ():int
|
|
|
- readUByte() {
|
|
|
- return this.readBits(8);
|
|
|
- }
|
|
|
- // ():int
|
|
|
- readUShort() {
|
|
|
- return this.readBits(16);
|
|
|
- }
|
|
|
- // ():int
|
|
|
- readUInt() {
|
|
|
- return this.readBits(32);
|
|
|
- }
|
|
|
-};
|
|
|
-var AvcVideoParser = class extends BaseVideoParser {
|
|
|
- parsePES(track, textTrack, pes, endOfSegment) {
|
|
|
- const units = this.parseNALu(track, pes.data, endOfSegment);
|
|
|
- let VideoSample = this.VideoSample;
|
|
|
- let push2;
|
|
|
- let spsfound = false;
|
|
|
- pes.data = null;
|
|
|
- if (VideoSample && units.length && !track.audFound) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- units.forEach((unit) => {
|
|
|
- var _VideoSample2, _VideoSample3;
|
|
|
- switch (unit.type) {
|
|
|
- case 1: {
|
|
|
- let iskey = false;
|
|
|
- push2 = true;
|
|
|
- const data = unit.data;
|
|
|
- if (spsfound && data.length > 4) {
|
|
|
- const sliceType = this.readSliceType(data);
|
|
|
- if (sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9) {
|
|
|
- iskey = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (iskey) {
|
|
|
- var _VideoSample;
|
|
|
- if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = this.VideoSample = null;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- VideoSample.frame = true;
|
|
|
- VideoSample.key = iskey;
|
|
|
- break;
|
|
|
- }
|
|
|
- case 5:
|
|
|
- push2 = true;
|
|
|
- if ((_VideoSample2 = VideoSample) != null && _VideoSample2.frame && !VideoSample.key) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = this.VideoSample = null;
|
|
|
- }
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- VideoSample.key = true;
|
|
|
- VideoSample.frame = true;
|
|
|
- break;
|
|
|
- case 6: {
|
|
|
- push2 = true;
|
|
|
- parseSEIMessageFromNALu(unit.data, 1, pes.pts, textTrack.samples);
|
|
|
- break;
|
|
|
- }
|
|
|
- case 7: {
|
|
|
- var _track$pixelRatio, _track$pixelRatio2;
|
|
|
- push2 = true;
|
|
|
- spsfound = true;
|
|
|
- const sps = unit.data;
|
|
|
- const config = this.readSPS(sps);
|
|
|
- if (!track.sps || track.width !== config.width || track.height !== config.height || ((_track$pixelRatio = track.pixelRatio) == null ? void 0 : _track$pixelRatio[0]) !== config.pixelRatio[0] || ((_track$pixelRatio2 = track.pixelRatio) == null ? void 0 : _track$pixelRatio2[1]) !== config.pixelRatio[1]) {
|
|
|
- track.width = config.width;
|
|
|
- track.height = config.height;
|
|
|
- track.pixelRatio = config.pixelRatio;
|
|
|
- track.sps = [sps];
|
|
|
- const codecarray = sps.subarray(1, 4);
|
|
|
- let codecstring = "avc1.";
|
|
|
- for (let i = 0; i < 3; i++) {
|
|
|
- let h = codecarray[i].toString(16);
|
|
|
- if (h.length < 2) {
|
|
|
- h = "0" + h;
|
|
|
- }
|
|
|
- codecstring += h;
|
|
|
- }
|
|
|
- track.codec = codecstring;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case 8:
|
|
|
- push2 = true;
|
|
|
- track.pps = [unit.data];
|
|
|
- break;
|
|
|
- case 9:
|
|
|
- push2 = true;
|
|
|
- track.audFound = true;
|
|
|
- if ((_VideoSample3 = VideoSample) != null && _VideoSample3.frame) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = null;
|
|
|
- }
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- break;
|
|
|
- case 12:
|
|
|
- push2 = true;
|
|
|
- break;
|
|
|
- default:
|
|
|
- push2 = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- if (VideoSample && push2) {
|
|
|
- const units2 = VideoSample.units;
|
|
|
- units2.push(unit);
|
|
|
- }
|
|
|
- });
|
|
|
- if (endOfSegment && VideoSample) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- this.VideoSample = null;
|
|
|
- }
|
|
|
- }
|
|
|
- getNALuType(data, offset) {
|
|
|
- return data[offset] & 31;
|
|
|
- }
|
|
|
- readSliceType(data) {
|
|
|
- const eg = new ExpGolomb(data);
|
|
|
- eg.readUByte();
|
|
|
- eg.readUEG();
|
|
|
- return eg.readUEG();
|
|
|
- }
|
|
|
- /**
|
|
|
- * The scaling list is optionally transmitted as part of a sequence parameter
|
|
|
- * set and is not relevant to transmuxing.
|
|
|
- * @param count the number of entries in this scaling list
|
|
|
- * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
|
|
|
- */
|
|
|
- skipScalingList(count, reader) {
|
|
|
- let lastScale = 8;
|
|
|
- let nextScale = 8;
|
|
|
- let deltaScale;
|
|
|
- for (let j = 0; j < count; j++) {
|
|
|
- if (nextScale !== 0) {
|
|
|
- deltaScale = reader.readEG();
|
|
|
- nextScale = (lastScale + deltaScale + 256) % 256;
|
|
|
- }
|
|
|
- lastScale = nextScale === 0 ? lastScale : nextScale;
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Read a sequence parameter set and return some interesting video
|
|
|
- * properties. A sequence parameter set is the H264 metadata that
|
|
|
- * describes the properties of upcoming video frames.
|
|
|
- * @returns an object with configuration parsed from the
|
|
|
- * sequence parameter set, including the dimensions of the
|
|
|
- * associated video frames.
|
|
|
- */
|
|
|
- readSPS(sps) {
|
|
|
- const eg = new ExpGolomb(sps);
|
|
|
- let frameCropLeftOffset = 0;
|
|
|
- let frameCropRightOffset = 0;
|
|
|
- let frameCropTopOffset = 0;
|
|
|
- let frameCropBottomOffset = 0;
|
|
|
- let numRefFramesInPicOrderCntCycle;
|
|
|
- let scalingListCount;
|
|
|
- let i;
|
|
|
- const readUByte = eg.readUByte.bind(eg);
|
|
|
- const readBits = eg.readBits.bind(eg);
|
|
|
- const readUEG = eg.readUEG.bind(eg);
|
|
|
- const readBoolean = eg.readBoolean.bind(eg);
|
|
|
- const skipBits = eg.skipBits.bind(eg);
|
|
|
- const skipEG = eg.skipEG.bind(eg);
|
|
|
- const skipUEG = eg.skipUEG.bind(eg);
|
|
|
- const skipScalingList = this.skipScalingList.bind(this);
|
|
|
- readUByte();
|
|
|
- const profileIdc = readUByte();
|
|
|
- readBits(5);
|
|
|
- skipBits(3);
|
|
|
- readUByte();
|
|
|
- skipUEG();
|
|
|
- if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
|
|
|
- const chromaFormatIdc = readUEG();
|
|
|
- if (chromaFormatIdc === 3) {
|
|
|
- skipBits(1);
|
|
|
- }
|
|
|
- skipUEG();
|
|
|
- skipUEG();
|
|
|
- skipBits(1);
|
|
|
- if (readBoolean()) {
|
|
|
- scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
|
|
|
- for (i = 0; i < scalingListCount; i++) {
|
|
|
- if (readBoolean()) {
|
|
|
- if (i < 6) {
|
|
|
- skipScalingList(16, eg);
|
|
|
- } else {
|
|
|
- skipScalingList(64, eg);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- skipUEG();
|
|
|
- const picOrderCntType = readUEG();
|
|
|
- if (picOrderCntType === 0) {
|
|
|
- readUEG();
|
|
|
- } else if (picOrderCntType === 1) {
|
|
|
- skipBits(1);
|
|
|
- skipEG();
|
|
|
- skipEG();
|
|
|
- numRefFramesInPicOrderCntCycle = readUEG();
|
|
|
- for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
|
|
|
- skipEG();
|
|
|
- }
|
|
|
- }
|
|
|
- skipUEG();
|
|
|
- skipBits(1);
|
|
|
- const picWidthInMbsMinus1 = readUEG();
|
|
|
- const picHeightInMapUnitsMinus1 = readUEG();
|
|
|
- const frameMbsOnlyFlag = readBits(1);
|
|
|
- if (frameMbsOnlyFlag === 0) {
|
|
|
- skipBits(1);
|
|
|
- }
|
|
|
- skipBits(1);
|
|
|
- if (readBoolean()) {
|
|
|
- frameCropLeftOffset = readUEG();
|
|
|
- frameCropRightOffset = readUEG();
|
|
|
- frameCropTopOffset = readUEG();
|
|
|
- frameCropBottomOffset = readUEG();
|
|
|
- }
|
|
|
- let pixelRatio = [1, 1];
|
|
|
- if (readBoolean()) {
|
|
|
- if (readBoolean()) {
|
|
|
- const aspectRatioIdc = readUByte();
|
|
|
- switch (aspectRatioIdc) {
|
|
|
- case 1:
|
|
|
- pixelRatio = [1, 1];
|
|
|
- break;
|
|
|
- case 2:
|
|
|
- pixelRatio = [12, 11];
|
|
|
- break;
|
|
|
- case 3:
|
|
|
- pixelRatio = [10, 11];
|
|
|
- break;
|
|
|
- case 4:
|
|
|
- pixelRatio = [16, 11];
|
|
|
- break;
|
|
|
- case 5:
|
|
|
- pixelRatio = [40, 33];
|
|
|
- break;
|
|
|
- case 6:
|
|
|
- pixelRatio = [24, 11];
|
|
|
- break;
|
|
|
- case 7:
|
|
|
- pixelRatio = [20, 11];
|
|
|
- break;
|
|
|
- case 8:
|
|
|
- pixelRatio = [32, 11];
|
|
|
- break;
|
|
|
- case 9:
|
|
|
- pixelRatio = [80, 33];
|
|
|
- break;
|
|
|
- case 10:
|
|
|
- pixelRatio = [18, 11];
|
|
|
- break;
|
|
|
- case 11:
|
|
|
- pixelRatio = [15, 11];
|
|
|
- break;
|
|
|
- case 12:
|
|
|
- pixelRatio = [64, 33];
|
|
|
- break;
|
|
|
- case 13:
|
|
|
- pixelRatio = [160, 99];
|
|
|
- break;
|
|
|
- case 14:
|
|
|
- pixelRatio = [4, 3];
|
|
|
- break;
|
|
|
- case 15:
|
|
|
- pixelRatio = [3, 2];
|
|
|
- break;
|
|
|
- case 16:
|
|
|
- pixelRatio = [2, 1];
|
|
|
- break;
|
|
|
- case 255: {
|
|
|
- pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
|
|
|
- height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
|
|
|
- pixelRatio
|
|
|
- };
|
|
|
- }
|
|
|
-};
|
|
|
-var HevcVideoParser = class extends BaseVideoParser {
|
|
|
- constructor(...args) {
|
|
|
- super(...args);
|
|
|
- this.initVPS = null;
|
|
|
- }
|
|
|
- parsePES(track, textTrack, pes, endOfSegment) {
|
|
|
- const units = this.parseNALu(track, pes.data, endOfSegment);
|
|
|
- let VideoSample = this.VideoSample;
|
|
|
- let push2;
|
|
|
- let spsfound = false;
|
|
|
- pes.data = null;
|
|
|
- if (VideoSample && units.length && !track.audFound) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- units.forEach((unit) => {
|
|
|
- var _VideoSample2, _VideoSample3;
|
|
|
- switch (unit.type) {
|
|
|
- case 0:
|
|
|
- case 1:
|
|
|
- case 2:
|
|
|
- case 3:
|
|
|
- case 4:
|
|
|
- case 5:
|
|
|
- case 6:
|
|
|
- case 7:
|
|
|
- case 8:
|
|
|
- case 9:
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- VideoSample.frame = true;
|
|
|
- push2 = true;
|
|
|
- break;
|
|
|
- case 16:
|
|
|
- case 17:
|
|
|
- case 18:
|
|
|
- case 21:
|
|
|
- push2 = true;
|
|
|
- if (spsfound) {
|
|
|
- var _VideoSample;
|
|
|
- if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = this.VideoSample = null;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- VideoSample.key = true;
|
|
|
- VideoSample.frame = true;
|
|
|
- break;
|
|
|
- case 19:
|
|
|
- case 20:
|
|
|
- push2 = true;
|
|
|
- if ((_VideoSample2 = VideoSample) != null && _VideoSample2.frame && !VideoSample.key) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = this.VideoSample = null;
|
|
|
- }
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- VideoSample.key = true;
|
|
|
- VideoSample.frame = true;
|
|
|
- break;
|
|
|
- case 39:
|
|
|
- push2 = true;
|
|
|
- parseSEIMessageFromNALu(
|
|
|
- unit.data,
|
|
|
- 2,
|
|
|
- // NALu header size
|
|
|
- pes.pts,
|
|
|
- textTrack.samples
|
|
|
- );
|
|
|
- break;
|
|
|
- case 32:
|
|
|
- push2 = true;
|
|
|
- if (!track.vps) {
|
|
|
- if (typeof track.params !== "object") {
|
|
|
- track.params = {};
|
|
|
- }
|
|
|
- track.params = _extends(track.params, this.readVPS(unit.data));
|
|
|
- this.initVPS = unit.data;
|
|
|
- }
|
|
|
- track.vps = [unit.data];
|
|
|
- break;
|
|
|
- case 33:
|
|
|
- push2 = true;
|
|
|
- spsfound = true;
|
|
|
- if (track.vps !== void 0 && track.vps[0] !== this.initVPS && track.sps !== void 0 && !this.matchSPS(track.sps[0], unit.data)) {
|
|
|
- this.initVPS = track.vps[0];
|
|
|
- track.sps = track.pps = void 0;
|
|
|
- }
|
|
|
- if (!track.sps) {
|
|
|
- const config = this.readSPS(unit.data);
|
|
|
- track.width = config.width;
|
|
|
- track.height = config.height;
|
|
|
- track.pixelRatio = config.pixelRatio;
|
|
|
- track.codec = config.codecString;
|
|
|
- track.sps = [];
|
|
|
- if (typeof track.params !== "object") {
|
|
|
- track.params = {};
|
|
|
- }
|
|
|
- for (const prop in config.params) {
|
|
|
- track.params[prop] = config.params[prop];
|
|
|
- }
|
|
|
- }
|
|
|
- this.pushParameterSet(track.sps, unit.data, track.vps);
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- VideoSample.key = true;
|
|
|
- break;
|
|
|
- case 34:
|
|
|
- push2 = true;
|
|
|
- if (typeof track.params === "object") {
|
|
|
- if (!track.pps) {
|
|
|
- track.pps = [];
|
|
|
- const config = this.readPPS(unit.data);
|
|
|
- for (const prop in config) {
|
|
|
- track.params[prop] = config[prop];
|
|
|
- }
|
|
|
- }
|
|
|
- this.pushParameterSet(track.pps, unit.data, track.vps);
|
|
|
- }
|
|
|
- break;
|
|
|
- case 35:
|
|
|
- push2 = true;
|
|
|
- track.audFound = true;
|
|
|
- if ((_VideoSample3 = VideoSample) != null && _VideoSample3.frame) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- VideoSample = null;
|
|
|
- }
|
|
|
- if (!VideoSample) {
|
|
|
- VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts);
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- push2 = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- if (VideoSample && push2) {
|
|
|
- const units2 = VideoSample.units;
|
|
|
- units2.push(unit);
|
|
|
- }
|
|
|
- });
|
|
|
- if (endOfSegment && VideoSample) {
|
|
|
- this.pushAccessUnit(VideoSample, track);
|
|
|
- this.VideoSample = null;
|
|
|
- }
|
|
|
- }
|
|
|
- pushParameterSet(parameterSets, data, vps) {
|
|
|
- if (vps && vps[0] === this.initVPS || !vps && !parameterSets.length) {
|
|
|
- parameterSets.push(data);
|
|
|
- }
|
|
|
- }
|
|
|
- getNALuType(data, offset) {
|
|
|
- return (data[offset] & 126) >>> 1;
|
|
|
- }
|
|
|
- ebsp2rbsp(arr) {
|
|
|
- const dst = new Uint8Array(arr.byteLength);
|
|
|
- let dstIdx = 0;
|
|
|
- for (let i = 0; i < arr.byteLength; i++) {
|
|
|
- if (i >= 2) {
|
|
|
- if (arr[i] === 3 && arr[i - 1] === 0 && arr[i - 2] === 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
- dst[dstIdx] = arr[i];
|
|
|
- dstIdx++;
|
|
|
- }
|
|
|
- return new Uint8Array(dst.buffer, 0, dstIdx);
|
|
|
- }
|
|
|
- pushAccessUnit(VideoSample, videoTrack) {
|
|
|
- super.pushAccessUnit(VideoSample, videoTrack);
|
|
|
- if (this.initVPS) {
|
|
|
- this.initVPS = null;
|
|
|
- }
|
|
|
- }
|
|
|
- readVPS(vps) {
|
|
|
- const eg = new ExpGolomb(vps);
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readBits(4);
|
|
|
- eg.skipBits(2);
|
|
|
- eg.readBits(6);
|
|
|
- const max_sub_layers_minus1 = eg.readBits(3);
|
|
|
- const temporal_id_nesting_flag = eg.readBoolean();
|
|
|
- return {
|
|
|
- numTemporalLayers: max_sub_layers_minus1 + 1,
|
|
|
- temporalIdNested: temporal_id_nesting_flag
|
|
|
- };
|
|
|
- }
|
|
|
- readSPS(sps) {
|
|
|
- const eg = new ExpGolomb(this.ebsp2rbsp(sps));
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readBits(4);
|
|
|
- const max_sub_layers_minus1 = eg.readBits(3);
|
|
|
- eg.readBoolean();
|
|
|
- const general_profile_space = eg.readBits(2);
|
|
|
- const general_tier_flag = eg.readBoolean();
|
|
|
- const general_profile_idc = eg.readBits(5);
|
|
|
- const general_profile_compatibility_flags_1 = eg.readUByte();
|
|
|
- const general_profile_compatibility_flags_2 = eg.readUByte();
|
|
|
- const general_profile_compatibility_flags_3 = eg.readUByte();
|
|
|
- const general_profile_compatibility_flags_4 = eg.readUByte();
|
|
|
- const general_constraint_indicator_flags_1 = eg.readUByte();
|
|
|
- const general_constraint_indicator_flags_2 = eg.readUByte();
|
|
|
- const general_constraint_indicator_flags_3 = eg.readUByte();
|
|
|
- const general_constraint_indicator_flags_4 = eg.readUByte();
|
|
|
- const general_constraint_indicator_flags_5 = eg.readUByte();
|
|
|
- const general_constraint_indicator_flags_6 = eg.readUByte();
|
|
|
- const general_level_idc = eg.readUByte();
|
|
|
- const sub_layer_profile_present_flags = [];
|
|
|
- const sub_layer_level_present_flags = [];
|
|
|
- for (let i = 0; i < max_sub_layers_minus1; i++) {
|
|
|
- sub_layer_profile_present_flags.push(eg.readBoolean());
|
|
|
- sub_layer_level_present_flags.push(eg.readBoolean());
|
|
|
- }
|
|
|
- if (max_sub_layers_minus1 > 0) {
|
|
|
- for (let i = max_sub_layers_minus1; i < 8; i++) {
|
|
|
- eg.readBits(2);
|
|
|
- }
|
|
|
- }
|
|
|
- for (let i = 0; i < max_sub_layers_minus1; i++) {
|
|
|
- if (sub_layer_profile_present_flags[i]) {
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- }
|
|
|
- if (sub_layer_level_present_flags[i]) {
|
|
|
- eg.readUByte();
|
|
|
- }
|
|
|
- }
|
|
|
- eg.readUEG();
|
|
|
- const chroma_format_idc = eg.readUEG();
|
|
|
- if (chroma_format_idc == 3) {
|
|
|
- eg.skipBits(1);
|
|
|
- }
|
|
|
- const pic_width_in_luma_samples = eg.readUEG();
|
|
|
- const pic_height_in_luma_samples = eg.readUEG();
|
|
|
- const conformance_window_flag = eg.readBoolean();
|
|
|
- let pic_left_offset = 0, pic_right_offset = 0, pic_top_offset = 0, pic_bottom_offset = 0;
|
|
|
- if (conformance_window_flag) {
|
|
|
- pic_left_offset += eg.readUEG();
|
|
|
- pic_right_offset += eg.readUEG();
|
|
|
- pic_top_offset += eg.readUEG();
|
|
|
- pic_bottom_offset += eg.readUEG();
|
|
|
- }
|
|
|
- const bit_depth_luma_minus8 = eg.readUEG();
|
|
|
- const bit_depth_chroma_minus8 = eg.readUEG();
|
|
|
- const log2_max_pic_order_cnt_lsb_minus4 = eg.readUEG();
|
|
|
- const sub_layer_ordering_info_present_flag = eg.readBoolean();
|
|
|
- for (let i = sub_layer_ordering_info_present_flag ? 0 : max_sub_layers_minus1; i <= max_sub_layers_minus1; i++) {
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- }
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- const scaling_list_enabled_flag = eg.readBoolean();
|
|
|
- if (scaling_list_enabled_flag) {
|
|
|
- const sps_scaling_list_data_present_flag = eg.readBoolean();
|
|
|
- if (sps_scaling_list_data_present_flag) {
|
|
|
- for (let sizeId = 0; sizeId < 4; sizeId++) {
|
|
|
- for (let matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
|
|
|
- const scaling_list_pred_mode_flag = eg.readBoolean();
|
|
|
- if (!scaling_list_pred_mode_flag) {
|
|
|
- eg.readUEG();
|
|
|
- } else {
|
|
|
- const coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
|
|
|
- if (sizeId > 1) {
|
|
|
- eg.readEG();
|
|
|
- }
|
|
|
- for (let i = 0; i < coefNum; i++) {
|
|
|
- eg.readEG();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- eg.readBoolean();
|
|
|
- eg.readBoolean();
|
|
|
- const pcm_enabled_flag = eg.readBoolean();
|
|
|
- if (pcm_enabled_flag) {
|
|
|
- eg.readUByte();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.readBoolean();
|
|
|
- }
|
|
|
- const num_short_term_ref_pic_sets = eg.readUEG();
|
|
|
- let num_delta_pocs = 0;
|
|
|
- for (let i = 0; i < num_short_term_ref_pic_sets; i++) {
|
|
|
- let inter_ref_pic_set_prediction_flag = false;
|
|
|
- if (i !== 0) {
|
|
|
- inter_ref_pic_set_prediction_flag = eg.readBoolean();
|
|
|
- }
|
|
|
- if (inter_ref_pic_set_prediction_flag) {
|
|
|
- if (i === num_short_term_ref_pic_sets) {
|
|
|
- eg.readUEG();
|
|
|
- }
|
|
|
- eg.readBoolean();
|
|
|
- eg.readUEG();
|
|
|
- let next_num_delta_pocs = 0;
|
|
|
- for (let j = 0; j <= num_delta_pocs; j++) {
|
|
|
- const used_by_curr_pic_flag = eg.readBoolean();
|
|
|
- let use_delta_flag = false;
|
|
|
- if (!used_by_curr_pic_flag) {
|
|
|
- use_delta_flag = eg.readBoolean();
|
|
|
- }
|
|
|
- if (used_by_curr_pic_flag || use_delta_flag) {
|
|
|
- next_num_delta_pocs++;
|
|
|
- }
|
|
|
- }
|
|
|
- num_delta_pocs = next_num_delta_pocs;
|
|
|
- } else {
|
|
|
- const num_negative_pics = eg.readUEG();
|
|
|
- const num_positive_pics = eg.readUEG();
|
|
|
- num_delta_pocs = num_negative_pics + num_positive_pics;
|
|
|
- for (let j = 0; j < num_negative_pics; j++) {
|
|
|
- eg.readUEG();
|
|
|
- eg.readBoolean();
|
|
|
- }
|
|
|
- for (let j = 0; j < num_positive_pics; j++) {
|
|
|
- eg.readUEG();
|
|
|
- eg.readBoolean();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const long_term_ref_pics_present_flag = eg.readBoolean();
|
|
|
- if (long_term_ref_pics_present_flag) {
|
|
|
- const num_long_term_ref_pics_sps = eg.readUEG();
|
|
|
- for (let i = 0; i < num_long_term_ref_pics_sps; i++) {
|
|
|
- for (let j = 0; j < log2_max_pic_order_cnt_lsb_minus4 + 4; j++) {
|
|
|
- eg.readBits(1);
|
|
|
- }
|
|
|
- eg.readBits(1);
|
|
|
- }
|
|
|
- }
|
|
|
- let min_spatial_segmentation_idc = 0;
|
|
|
- let sar_width = 1, sar_height = 1;
|
|
|
- let fps_fixed = true, fps_den = 1, fps_num = 0;
|
|
|
- eg.readBoolean();
|
|
|
- eg.readBoolean();
|
|
|
- let default_display_window_flag = false;
|
|
|
- const vui_parameters_present_flag = eg.readBoolean();
|
|
|
- if (vui_parameters_present_flag) {
|
|
|
- const aspect_ratio_info_present_flag = eg.readBoolean();
|
|
|
- if (aspect_ratio_info_present_flag) {
|
|
|
- const aspect_ratio_idc = eg.readUByte();
|
|
|
- const sar_width_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
|
|
|
- const sar_height_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
|
|
|
- if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
|
|
|
- sar_width = sar_width_table[aspect_ratio_idc - 1];
|
|
|
- sar_height = sar_height_table[aspect_ratio_idc - 1];
|
|
|
- } else if (aspect_ratio_idc === 255) {
|
|
|
- sar_width = eg.readBits(16);
|
|
|
- sar_height = eg.readBits(16);
|
|
|
- }
|
|
|
- }
|
|
|
- const overscan_info_present_flag = eg.readBoolean();
|
|
|
- if (overscan_info_present_flag) {
|
|
|
- eg.readBoolean();
|
|
|
- }
|
|
|
- const video_signal_type_present_flag = eg.readBoolean();
|
|
|
- if (video_signal_type_present_flag) {
|
|
|
- eg.readBits(3);
|
|
|
- eg.readBoolean();
|
|
|
- const colour_description_present_flag = eg.readBoolean();
|
|
|
- if (colour_description_present_flag) {
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- }
|
|
|
- }
|
|
|
- const chroma_loc_info_present_flag = eg.readBoolean();
|
|
|
- if (chroma_loc_info_present_flag) {
|
|
|
- eg.readUEG();
|
|
|
- eg.readUEG();
|
|
|
- }
|
|
|
- eg.readBoolean();
|
|
|
- eg.readBoolean();
|
|
|
- eg.readBoolean();
|
|
|
- default_display_window_flag = eg.readBoolean();
|
|
|
- if (default_display_window_flag) {
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- }
|
|
|
- const vui_timing_info_present_flag = eg.readBoolean();
|
|
|
- if (vui_timing_info_present_flag) {
|
|
|
- fps_den = eg.readBits(32);
|
|
|
- fps_num = eg.readBits(32);
|
|
|
- const vui_poc_proportional_to_timing_flag = eg.readBoolean();
|
|
|
- if (vui_poc_proportional_to_timing_flag) {
|
|
|
- eg.readUEG();
|
|
|
- }
|
|
|
- const vui_hrd_parameters_present_flag = eg.readBoolean();
|
|
|
- if (vui_hrd_parameters_present_flag) {
|
|
|
- const nal_hrd_parameters_present_flag = eg.readBoolean();
|
|
|
- const vcl_hrd_parameters_present_flag = eg.readBoolean();
|
|
|
- let sub_pic_hrd_params_present_flag = false;
|
|
|
- if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
|
|
|
- sub_pic_hrd_params_present_flag = eg.readBoolean();
|
|
|
- if (sub_pic_hrd_params_present_flag) {
|
|
|
- eg.readUByte();
|
|
|
- eg.readBits(5);
|
|
|
- eg.readBoolean();
|
|
|
- eg.readBits(5);
|
|
|
- }
|
|
|
- eg.readBits(4);
|
|
|
- eg.readBits(4);
|
|
|
- if (sub_pic_hrd_params_present_flag) {
|
|
|
- eg.readBits(4);
|
|
|
- }
|
|
|
- eg.readBits(5);
|
|
|
- eg.readBits(5);
|
|
|
- eg.readBits(5);
|
|
|
- }
|
|
|
- for (let i = 0; i <= max_sub_layers_minus1; i++) {
|
|
|
- fps_fixed = eg.readBoolean();
|
|
|
- const fixed_pic_rate_within_cvs_flag = fps_fixed || eg.readBoolean();
|
|
|
- let low_delay_hrd_flag = false;
|
|
|
- if (fixed_pic_rate_within_cvs_flag) {
|
|
|
- eg.readEG();
|
|
|
- } else {
|
|
|
- low_delay_hrd_flag = eg.readBoolean();
|
|
|
- }
|
|
|
- const cpb_cnt = low_delay_hrd_flag ? 1 : eg.readUEG() + 1;
|
|
|
- if (nal_hrd_parameters_present_flag) {
|
|
|
- for (let j = 0; j < cpb_cnt; j++) {
|
|
|
- eg.readUEG();
|
|
|
- eg.readUEG();
|
|
|
- if (sub_pic_hrd_params_present_flag) {
|
|
|
- eg.readUEG();
|
|
|
- eg.readUEG();
|
|
|
- }
|
|
|
- eg.skipBits(1);
|
|
|
- }
|
|
|
- }
|
|
|
- if (vcl_hrd_parameters_present_flag) {
|
|
|
- for (let j = 0; j < cpb_cnt; j++) {
|
|
|
- eg.readUEG();
|
|
|
- eg.readUEG();
|
|
|
- if (sub_pic_hrd_params_present_flag) {
|
|
|
- eg.readUEG();
|
|
|
- eg.readUEG();
|
|
|
- }
|
|
|
- eg.skipBits(1);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const bitstream_restriction_flag = eg.readBoolean();
|
|
|
- if (bitstream_restriction_flag) {
|
|
|
- eg.readBoolean();
|
|
|
- eg.readBoolean();
|
|
|
- eg.readBoolean();
|
|
|
- min_spatial_segmentation_idc = eg.readUEG();
|
|
|
- }
|
|
|
- }
|
|
|
- let width = pic_width_in_luma_samples, height = pic_height_in_luma_samples;
|
|
|
- if (conformance_window_flag) {
|
|
|
- let chroma_scale_w = 1, chroma_scale_h = 1;
|
|
|
- if (chroma_format_idc === 1) {
|
|
|
- chroma_scale_w = chroma_scale_h = 2;
|
|
|
- } else if (chroma_format_idc == 2) {
|
|
|
- chroma_scale_w = 2;
|
|
|
- }
|
|
|
- width = pic_width_in_luma_samples - chroma_scale_w * pic_right_offset - chroma_scale_w * pic_left_offset;
|
|
|
- height = pic_height_in_luma_samples - chroma_scale_h * pic_bottom_offset - chroma_scale_h * pic_top_offset;
|
|
|
- }
|
|
|
- const profile_space_string = general_profile_space ? ["A", "B", "C"][general_profile_space] : "";
|
|
|
- const profile_compatibility_buf = general_profile_compatibility_flags_1 << 24 | general_profile_compatibility_flags_2 << 16 | general_profile_compatibility_flags_3 << 8 | general_profile_compatibility_flags_4;
|
|
|
- let profile_compatibility_rev = 0;
|
|
|
- for (let i = 0; i < 32; i++) {
|
|
|
- profile_compatibility_rev = (profile_compatibility_rev | (profile_compatibility_buf >> i & 1) << 31 - i) >>> 0;
|
|
|
- }
|
|
|
- let profile_compatibility_flags_string = profile_compatibility_rev.toString(16);
|
|
|
- if (general_profile_idc === 1 && profile_compatibility_flags_string === "2") {
|
|
|
- profile_compatibility_flags_string = "6";
|
|
|
- }
|
|
|
- const tier_flag_string = general_tier_flag ? "H" : "L";
|
|
|
- return {
|
|
|
- codecString: `hvc1.${profile_space_string}${general_profile_idc}.${profile_compatibility_flags_string}.${tier_flag_string}${general_level_idc}.B0`,
|
|
|
- params: {
|
|
|
- general_tier_flag,
|
|
|
- general_profile_idc,
|
|
|
- general_profile_space,
|
|
|
- general_profile_compatibility_flags: [general_profile_compatibility_flags_1, general_profile_compatibility_flags_2, general_profile_compatibility_flags_3, general_profile_compatibility_flags_4],
|
|
|
- general_constraint_indicator_flags: [general_constraint_indicator_flags_1, general_constraint_indicator_flags_2, general_constraint_indicator_flags_3, general_constraint_indicator_flags_4, general_constraint_indicator_flags_5, general_constraint_indicator_flags_6],
|
|
|
- general_level_idc,
|
|
|
- bit_depth: bit_depth_luma_minus8 + 8,
|
|
|
- bit_depth_luma_minus8,
|
|
|
- bit_depth_chroma_minus8,
|
|
|
- min_spatial_segmentation_idc,
|
|
|
- chroma_format_idc,
|
|
|
- frame_rate: {
|
|
|
- fixed: fps_fixed,
|
|
|
- fps: fps_num / fps_den
|
|
|
- }
|
|
|
- },
|
|
|
- width,
|
|
|
- height,
|
|
|
- pixelRatio: [sar_width, sar_height]
|
|
|
- };
|
|
|
- }
|
|
|
- readPPS(pps) {
|
|
|
- const eg = new ExpGolomb(this.ebsp2rbsp(pps));
|
|
|
- eg.readUByte();
|
|
|
- eg.readUByte();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipBits(2);
|
|
|
- eg.skipBits(3);
|
|
|
- eg.skipBits(2);
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipUEG();
|
|
|
- eg.skipEG();
|
|
|
- eg.skipBits(2);
|
|
|
- const cu_qp_delta_enabled_flag = eg.readBoolean();
|
|
|
- if (cu_qp_delta_enabled_flag) {
|
|
|
- eg.skipUEG();
|
|
|
- }
|
|
|
- eg.skipEG();
|
|
|
- eg.skipEG();
|
|
|
- eg.skipBits(4);
|
|
|
- const tiles_enabled_flag = eg.readBoolean();
|
|
|
- const entropy_coding_sync_enabled_flag = eg.readBoolean();
|
|
|
- let parallelismType = 1;
|
|
|
- if (entropy_coding_sync_enabled_flag && tiles_enabled_flag) {
|
|
|
- parallelismType = 0;
|
|
|
- } else if (entropy_coding_sync_enabled_flag) {
|
|
|
- parallelismType = 3;
|
|
|
- } else if (tiles_enabled_flag) {
|
|
|
- parallelismType = 2;
|
|
|
- }
|
|
|
- return {
|
|
|
- parallelismType
|
|
|
- };
|
|
|
- }
|
|
|
- matchSPS(sps1, sps2) {
|
|
|
- return String.fromCharCode.apply(null, sps1).substr(3) === String.fromCharCode.apply(null, sps2).substr(3);
|
|
|
- }
|
|
|
-};
|
|
|
-var PACKET_LENGTH = 188;
|
|
|
-var TSDemuxer = class _TSDemuxer {
|
|
|
- constructor(observer, config, typeSupported, logger2) {
|
|
|
- this.logger = void 0;
|
|
|
- this.observer = void 0;
|
|
|
- this.config = void 0;
|
|
|
- this.typeSupported = void 0;
|
|
|
- this.sampleAes = null;
|
|
|
- this.pmtParsed = false;
|
|
|
- this.audioCodec = void 0;
|
|
|
- this.videoCodec = void 0;
|
|
|
- this._pmtId = -1;
|
|
|
- this._videoTrack = void 0;
|
|
|
- this._audioTrack = void 0;
|
|
|
- this._id3Track = void 0;
|
|
|
- this._txtTrack = void 0;
|
|
|
- this.aacOverFlow = null;
|
|
|
- this.remainderData = null;
|
|
|
- this.videoParser = void 0;
|
|
|
- this.observer = observer;
|
|
|
- this.config = config;
|
|
|
- this.typeSupported = typeSupported;
|
|
|
- this.logger = logger2;
|
|
|
- this.videoParser = null;
|
|
|
- }
|
|
|
- static probe(data, logger2) {
|
|
|
- const syncOffset = _TSDemuxer.syncOffset(data);
|
|
|
- if (syncOffset > 0) {
|
|
|
- logger2.warn(`MPEG2-TS detected but first sync word found @ offset ${syncOffset}`);
|
|
|
- }
|
|
|
- return syncOffset !== -1;
|
|
|
- }
|
|
|
- static syncOffset(data) {
|
|
|
- const length = data.length;
|
|
|
- let scanwindow = Math.min(PACKET_LENGTH * 5, length - PACKET_LENGTH) + 1;
|
|
|
- let i = 0;
|
|
|
- while (i < scanwindow) {
|
|
|
- let foundPat = false;
|
|
|
- let packetStart = -1;
|
|
|
- let tsPackets = 0;
|
|
|
- for (let j = i; j < length; j += PACKET_LENGTH) {
|
|
|
- if (data[j] === 71 && (length - j === PACKET_LENGTH || data[j + PACKET_LENGTH] === 71)) {
|
|
|
- tsPackets++;
|
|
|
- if (packetStart === -1) {
|
|
|
- packetStart = j;
|
|
|
- if (packetStart !== 0) {
|
|
|
- scanwindow = Math.min(packetStart + PACKET_LENGTH * 99, data.length - PACKET_LENGTH) + 1;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!foundPat) {
|
|
|
- foundPat = parsePID(data, j) === 0;
|
|
|
- }
|
|
|
- if (foundPat && tsPackets > 1 && (packetStart === 0 && tsPackets > 2 || j + PACKET_LENGTH > scanwindow)) {
|
|
|
- return packetStart;
|
|
|
- }
|
|
|
- } else if (tsPackets) {
|
|
|
- return -1;
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- i++;
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Creates a track model internal to demuxer used to drive remuxing input
|
|
|
- */
|
|
|
- static createTrack(type, duration) {
|
|
|
- return {
|
|
|
- container: type === "video" || type === "audio" ? "video/mp2t" : void 0,
|
|
|
- type,
|
|
|
- id: RemuxerTrackIdConfig[type],
|
|
|
- pid: -1,
|
|
|
- inputTimeScale: 9e4,
|
|
|
- sequenceNumber: 0,
|
|
|
- samples: [],
|
|
|
- dropped: 0,
|
|
|
- duration: type === "audio" ? duration : void 0
|
|
|
- };
|
|
|
- }
|
|
|
- /**
|
|
|
- * Initializes a new init segment on the demuxer/remuxer interface. Needed for discontinuities/track-switches (or at stream start)
|
|
|
- * Resets all internal track instances of the demuxer.
|
|
|
- */
|
|
|
- resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration) {
|
|
|
- this.pmtParsed = false;
|
|
|
- this._pmtId = -1;
|
|
|
- this._videoTrack = _TSDemuxer.createTrack("video");
|
|
|
- this._videoTrack.duration = trackDuration;
|
|
|
- this._audioTrack = _TSDemuxer.createTrack("audio", trackDuration);
|
|
|
- this._id3Track = _TSDemuxer.createTrack("id3");
|
|
|
- this._txtTrack = _TSDemuxer.createTrack("text");
|
|
|
- this._audioTrack.segmentCodec = "aac";
|
|
|
- this.videoParser = null;
|
|
|
- this.aacOverFlow = null;
|
|
|
- this.remainderData = null;
|
|
|
- this.audioCodec = audioCodec;
|
|
|
- this.videoCodec = videoCodec;
|
|
|
- }
|
|
|
- resetTimeStamp() {
|
|
|
- }
|
|
|
- resetContiguity() {
|
|
|
- const {
|
|
|
- _audioTrack,
|
|
|
- _videoTrack,
|
|
|
- _id3Track
|
|
|
- } = this;
|
|
|
- if (_audioTrack) {
|
|
|
- _audioTrack.pesData = null;
|
|
|
- }
|
|
|
- if (_videoTrack) {
|
|
|
- _videoTrack.pesData = null;
|
|
|
- }
|
|
|
- if (_id3Track) {
|
|
|
- _id3Track.pesData = null;
|
|
|
- }
|
|
|
- this.aacOverFlow = null;
|
|
|
- this.remainderData = null;
|
|
|
- }
|
|
|
- demux(data, timeOffset, isSampleAes = false, flush = false) {
|
|
|
- if (!isSampleAes) {
|
|
|
- this.sampleAes = null;
|
|
|
- }
|
|
|
- let pes;
|
|
|
- const videoTrack = this._videoTrack;
|
|
|
- const audioTrack = this._audioTrack;
|
|
|
- const id3Track = this._id3Track;
|
|
|
- const textTrack = this._txtTrack;
|
|
|
- let videoPid = videoTrack.pid;
|
|
|
- let videoData = videoTrack.pesData;
|
|
|
- let audioPid = audioTrack.pid;
|
|
|
- let id3Pid = id3Track.pid;
|
|
|
- let audioData = audioTrack.pesData;
|
|
|
- let id3Data = id3Track.pesData;
|
|
|
- let unknownPID = null;
|
|
|
- let pmtParsed = this.pmtParsed;
|
|
|
- let pmtId = this._pmtId;
|
|
|
- let len = data.length;
|
|
|
- if (this.remainderData) {
|
|
|
- data = appendUint8Array(this.remainderData, data);
|
|
|
- len = data.length;
|
|
|
- this.remainderData = null;
|
|
|
- }
|
|
|
- if (len < PACKET_LENGTH && !flush) {
|
|
|
- this.remainderData = data;
|
|
|
- return {
|
|
|
- audioTrack,
|
|
|
- videoTrack,
|
|
|
- id3Track,
|
|
|
- textTrack
|
|
|
- };
|
|
|
- }
|
|
|
- const syncOffset = Math.max(0, _TSDemuxer.syncOffset(data));
|
|
|
- len -= (len - syncOffset) % PACKET_LENGTH;
|
|
|
- if (len < data.byteLength && !flush) {
|
|
|
- this.remainderData = new Uint8Array(data.buffer, len, data.buffer.byteLength - len);
|
|
|
- }
|
|
|
- let tsPacketErrors = 0;
|
|
|
- for (let start = syncOffset; start < len; start += PACKET_LENGTH) {
|
|
|
- if (data[start] === 71) {
|
|
|
- const stt = !!(data[start + 1] & 64);
|
|
|
- const pid = parsePID(data, start);
|
|
|
- const atf = (data[start + 3] & 48) >> 4;
|
|
|
- let offset;
|
|
|
- if (atf > 1) {
|
|
|
- offset = start + 5 + data[start + 4];
|
|
|
- if (offset === start + PACKET_LENGTH) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- } else {
|
|
|
- offset = start + 4;
|
|
|
- }
|
|
|
- switch (pid) {
|
|
|
- case videoPid:
|
|
|
- if (stt) {
|
|
|
- if (videoData && (pes = parsePES(videoData, this.logger))) {
|
|
|
- this.readyVideoParser(videoTrack.segmentCodec);
|
|
|
- if (this.videoParser !== null) {
|
|
|
- this.videoParser.parsePES(videoTrack, textTrack, pes, false);
|
|
|
- }
|
|
|
- }
|
|
|
- videoData = {
|
|
|
- data: [],
|
|
|
- size: 0
|
|
|
- };
|
|
|
- }
|
|
|
- if (videoData) {
|
|
|
- videoData.data.push(data.subarray(offset, start + PACKET_LENGTH));
|
|
|
- videoData.size += start + PACKET_LENGTH - offset;
|
|
|
- }
|
|
|
- break;
|
|
|
- case audioPid:
|
|
|
- if (stt) {
|
|
|
- if (audioData && (pes = parsePES(audioData, this.logger))) {
|
|
|
- switch (audioTrack.segmentCodec) {
|
|
|
- case "aac":
|
|
|
- this.parseAACPES(audioTrack, pes);
|
|
|
- break;
|
|
|
- case "mp3":
|
|
|
- this.parseMPEGPES(audioTrack, pes);
|
|
|
- break;
|
|
|
- case "ac3":
|
|
|
- {
|
|
|
- this.parseAC3PES(audioTrack, pes);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- audioData = {
|
|
|
- data: [],
|
|
|
- size: 0
|
|
|
- };
|
|
|
- }
|
|
|
- if (audioData) {
|
|
|
- audioData.data.push(data.subarray(offset, start + PACKET_LENGTH));
|
|
|
- audioData.size += start + PACKET_LENGTH - offset;
|
|
|
- }
|
|
|
- break;
|
|
|
- case id3Pid:
|
|
|
- if (stt) {
|
|
|
- if (id3Data && (pes = parsePES(id3Data, this.logger))) {
|
|
|
- this.parseID3PES(id3Track, pes);
|
|
|
- }
|
|
|
- id3Data = {
|
|
|
- data: [],
|
|
|
- size: 0
|
|
|
- };
|
|
|
- }
|
|
|
- if (id3Data) {
|
|
|
- id3Data.data.push(data.subarray(offset, start + PACKET_LENGTH));
|
|
|
- id3Data.size += start + PACKET_LENGTH - offset;
|
|
|
- }
|
|
|
- break;
|
|
|
- case 0:
|
|
|
- if (stt) {
|
|
|
- offset += data[offset] + 1;
|
|
|
- }
|
|
|
- pmtId = this._pmtId = parsePAT(data, offset);
|
|
|
- break;
|
|
|
- case pmtId: {
|
|
|
- if (stt) {
|
|
|
- offset += data[offset] + 1;
|
|
|
- }
|
|
|
- const parsedPIDs = parsePMT(data, offset, this.typeSupported, isSampleAes, this.observer, this.logger);
|
|
|
- videoPid = parsedPIDs.videoPid;
|
|
|
- if (videoPid > 0) {
|
|
|
- videoTrack.pid = videoPid;
|
|
|
- videoTrack.segmentCodec = parsedPIDs.segmentVideoCodec;
|
|
|
- }
|
|
|
- audioPid = parsedPIDs.audioPid;
|
|
|
- if (audioPid > 0) {
|
|
|
- audioTrack.pid = audioPid;
|
|
|
- audioTrack.segmentCodec = parsedPIDs.segmentAudioCodec;
|
|
|
- }
|
|
|
- id3Pid = parsedPIDs.id3Pid;
|
|
|
- if (id3Pid > 0) {
|
|
|
- id3Track.pid = id3Pid;
|
|
|
- }
|
|
|
- if (unknownPID !== null && !pmtParsed) {
|
|
|
- this.logger.warn(`MPEG-TS PMT found at ${start} after unknown PID '${unknownPID}'. Backtracking to sync byte @${syncOffset} to parse all TS packets.`);
|
|
|
- unknownPID = null;
|
|
|
- start = syncOffset - 188;
|
|
|
- }
|
|
|
- pmtParsed = this.pmtParsed = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- case 17:
|
|
|
- case 8191:
|
|
|
- break;
|
|
|
- default:
|
|
|
- unknownPID = pid;
|
|
|
- break;
|
|
|
- }
|
|
|
- } else {
|
|
|
- tsPacketErrors++;
|
|
|
- }
|
|
|
- }
|
|
|
- if (tsPacketErrors > 0) {
|
|
|
- emitParsingError(this.observer, new Error(`Found ${tsPacketErrors} TS packet/s that do not start with 0x47`), void 0, this.logger);
|
|
|
- }
|
|
|
- videoTrack.pesData = videoData;
|
|
|
- audioTrack.pesData = audioData;
|
|
|
- id3Track.pesData = id3Data;
|
|
|
- const demuxResult = {
|
|
|
- audioTrack,
|
|
|
- videoTrack,
|
|
|
- id3Track,
|
|
|
- textTrack
|
|
|
- };
|
|
|
- if (flush) {
|
|
|
- this.extractRemainingSamples(demuxResult);
|
|
|
- }
|
|
|
- return demuxResult;
|
|
|
- }
|
|
|
- flush() {
|
|
|
- const {
|
|
|
- remainderData
|
|
|
- } = this;
|
|
|
- this.remainderData = null;
|
|
|
- let result;
|
|
|
- if (remainderData) {
|
|
|
- result = this.demux(remainderData, -1, false, true);
|
|
|
- } else {
|
|
|
- result = {
|
|
|
- videoTrack: this._videoTrack,
|
|
|
- audioTrack: this._audioTrack,
|
|
|
- id3Track: this._id3Track,
|
|
|
- textTrack: this._txtTrack
|
|
|
- };
|
|
|
- }
|
|
|
- this.extractRemainingSamples(result);
|
|
|
- if (this.sampleAes) {
|
|
|
- return this.decrypt(result, this.sampleAes);
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- extractRemainingSamples(demuxResult) {
|
|
|
- const {
|
|
|
- audioTrack,
|
|
|
- videoTrack,
|
|
|
- id3Track,
|
|
|
- textTrack
|
|
|
- } = demuxResult;
|
|
|
- const videoData = videoTrack.pesData;
|
|
|
- const audioData = audioTrack.pesData;
|
|
|
- const id3Data = id3Track.pesData;
|
|
|
- let pes;
|
|
|
- if (videoData && (pes = parsePES(videoData, this.logger))) {
|
|
|
- this.readyVideoParser(videoTrack.segmentCodec);
|
|
|
- if (this.videoParser !== null) {
|
|
|
- this.videoParser.parsePES(videoTrack, textTrack, pes, true);
|
|
|
- videoTrack.pesData = null;
|
|
|
- }
|
|
|
- } else {
|
|
|
- videoTrack.pesData = videoData;
|
|
|
- }
|
|
|
- if (audioData && (pes = parsePES(audioData, this.logger))) {
|
|
|
- switch (audioTrack.segmentCodec) {
|
|
|
- case "aac":
|
|
|
- this.parseAACPES(audioTrack, pes);
|
|
|
- break;
|
|
|
- case "mp3":
|
|
|
- this.parseMPEGPES(audioTrack, pes);
|
|
|
- break;
|
|
|
- case "ac3":
|
|
|
- {
|
|
|
- this.parseAC3PES(audioTrack, pes);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- audioTrack.pesData = null;
|
|
|
- } else {
|
|
|
- if (audioData != null && audioData.size) {
|
|
|
- this.logger.log("last AAC PES packet truncated,might overlap between fragments");
|
|
|
- }
|
|
|
- audioTrack.pesData = audioData;
|
|
|
- }
|
|
|
- if (id3Data && (pes = parsePES(id3Data, this.logger))) {
|
|
|
- this.parseID3PES(id3Track, pes);
|
|
|
- id3Track.pesData = null;
|
|
|
- } else {
|
|
|
- id3Track.pesData = id3Data;
|
|
|
- }
|
|
|
- }
|
|
|
- demuxSampleAes(data, keyData, timeOffset) {
|
|
|
- const demuxResult = this.demux(data, timeOffset, true, !this.config.progressive);
|
|
|
- const sampleAes = this.sampleAes = new SampleAesDecrypter(this.observer, this.config, keyData);
|
|
|
- return this.decrypt(demuxResult, sampleAes);
|
|
|
- }
|
|
|
- readyVideoParser(codec) {
|
|
|
- if (this.videoParser === null) {
|
|
|
- if (codec === "avc") {
|
|
|
- this.videoParser = new AvcVideoParser();
|
|
|
- } else if (codec === "hevc") {
|
|
|
- this.videoParser = new HevcVideoParser();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- decrypt(demuxResult, sampleAes) {
|
|
|
- return new Promise((resolve) => {
|
|
|
- const {
|
|
|
- audioTrack,
|
|
|
- videoTrack
|
|
|
- } = demuxResult;
|
|
|
- if (audioTrack.samples && audioTrack.segmentCodec === "aac") {
|
|
|
- sampleAes.decryptAacSamples(audioTrack.samples, 0, () => {
|
|
|
- if (videoTrack.samples) {
|
|
|
- sampleAes.decryptAvcSamples(videoTrack.samples, 0, 0, () => {
|
|
|
- resolve(demuxResult);
|
|
|
- });
|
|
|
- } else {
|
|
|
- resolve(demuxResult);
|
|
|
- }
|
|
|
- });
|
|
|
- } else if (videoTrack.samples) {
|
|
|
- sampleAes.decryptAvcSamples(videoTrack.samples, 0, 0, () => {
|
|
|
- resolve(demuxResult);
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- if (this.observer) {
|
|
|
- this.observer.removeAllListeners();
|
|
|
- }
|
|
|
- this.config = this.logger = this.observer = null;
|
|
|
- this.aacOverFlow = this.videoParser = this.remainderData = this.sampleAes = null;
|
|
|
- this._videoTrack = this._audioTrack = this._id3Track = this._txtTrack = void 0;
|
|
|
- }
|
|
|
- parseAACPES(track, pes) {
|
|
|
- let startOffset = 0;
|
|
|
- const aacOverFlow = this.aacOverFlow;
|
|
|
- let data = pes.data;
|
|
|
- if (aacOverFlow) {
|
|
|
- this.aacOverFlow = null;
|
|
|
- const frameMissingBytes = aacOverFlow.missing;
|
|
|
- const sampleLength = aacOverFlow.sample.unit.byteLength;
|
|
|
- if (frameMissingBytes === -1) {
|
|
|
- data = appendUint8Array(aacOverFlow.sample.unit, data);
|
|
|
- } else {
|
|
|
- const frameOverflowBytes = sampleLength - frameMissingBytes;
|
|
|
- aacOverFlow.sample.unit.set(data.subarray(0, frameMissingBytes), frameOverflowBytes);
|
|
|
- track.samples.push(aacOverFlow.sample);
|
|
|
- startOffset = aacOverFlow.missing;
|
|
|
- }
|
|
|
- }
|
|
|
- let offset;
|
|
|
- let len;
|
|
|
- for (offset = startOffset, len = data.length; offset < len - 1; offset++) {
|
|
|
- if (isHeader$1(data, offset)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (offset !== startOffset) {
|
|
|
- let reason;
|
|
|
- const recoverable = offset < len - 1;
|
|
|
- if (recoverable) {
|
|
|
- reason = `AAC PES did not start with ADTS header,offset:${offset}`;
|
|
|
- } else {
|
|
|
- reason = "No ADTS header found in AAC PES";
|
|
|
- }
|
|
|
- emitParsingError(this.observer, new Error(reason), recoverable, this.logger);
|
|
|
- if (!recoverable) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- initTrackConfig(track, this.observer, data, offset, this.audioCodec);
|
|
|
- let pts;
|
|
|
- if (pes.pts !== void 0) {
|
|
|
- pts = pes.pts;
|
|
|
- } else if (aacOverFlow) {
|
|
|
- const frameDuration = getFrameDuration(track.samplerate);
|
|
|
- pts = aacOverFlow.sample.pts + frameDuration;
|
|
|
- } else {
|
|
|
- this.logger.warn("[tsdemuxer]: AAC PES unknown PTS");
|
|
|
- return;
|
|
|
- }
|
|
|
- let frameIndex = 0;
|
|
|
- let frame;
|
|
|
- while (offset < len) {
|
|
|
- frame = appendFrame$2(track, data, offset, pts, frameIndex);
|
|
|
- offset += frame.length;
|
|
|
- if (!frame.missing) {
|
|
|
- frameIndex++;
|
|
|
- for (; offset < len - 1; offset++) {
|
|
|
- if (isHeader$1(data, offset)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.aacOverFlow = frame;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- parseMPEGPES(track, pes) {
|
|
|
- const data = pes.data;
|
|
|
- const length = data.length;
|
|
|
- let frameIndex = 0;
|
|
|
- let offset = 0;
|
|
|
- const pts = pes.pts;
|
|
|
- if (pts === void 0) {
|
|
|
- this.logger.warn("[tsdemuxer]: MPEG PES unknown PTS");
|
|
|
- return;
|
|
|
- }
|
|
|
- while (offset < length) {
|
|
|
- if (isHeader(data, offset)) {
|
|
|
- const frame = appendFrame$1(track, data, offset, pts, frameIndex);
|
|
|
- if (frame) {
|
|
|
- offset += frame.length;
|
|
|
- frameIndex++;
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- } else {
|
|
|
- offset++;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- parseAC3PES(track, pes) {
|
|
|
- {
|
|
|
- const data = pes.data;
|
|
|
- const pts = pes.pts;
|
|
|
- if (pts === void 0) {
|
|
|
- this.logger.warn("[tsdemuxer]: AC3 PES unknown PTS");
|
|
|
- return;
|
|
|
- }
|
|
|
- const length = data.length;
|
|
|
- let frameIndex = 0;
|
|
|
- let offset = 0;
|
|
|
- let parsed;
|
|
|
- while (offset < length && (parsed = appendFrame(track, data, offset, pts, frameIndex++)) > 0) {
|
|
|
- offset += parsed;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- parseID3PES(id3Track, pes) {
|
|
|
- if (pes.pts === void 0) {
|
|
|
- this.logger.warn("[tsdemuxer]: ID3 PES unknown PTS");
|
|
|
- return;
|
|
|
- }
|
|
|
- const id3Sample = _extends({}, pes, {
|
|
|
- type: this._videoTrack ? MetadataSchema.emsg : MetadataSchema.audioId3,
|
|
|
- duration: Number.POSITIVE_INFINITY
|
|
|
- });
|
|
|
- id3Track.samples.push(id3Sample);
|
|
|
- }
|
|
|
-};
|
|
|
-function parsePID(data, offset) {
|
|
|
- return ((data[offset + 1] & 31) << 8) + data[offset + 2];
|
|
|
-}
|
|
|
-function parsePAT(data, offset) {
|
|
|
- return (data[offset + 10] & 31) << 8 | data[offset + 11];
|
|
|
-}
|
|
|
-function parsePMT(data, offset, typeSupported, isSampleAes, observer, logger2) {
|
|
|
- const result = {
|
|
|
- audioPid: -1,
|
|
|
- videoPid: -1,
|
|
|
- id3Pid: -1,
|
|
|
- segmentVideoCodec: "avc",
|
|
|
- segmentAudioCodec: "aac"
|
|
|
- };
|
|
|
- const sectionLength = (data[offset + 1] & 15) << 8 | data[offset + 2];
|
|
|
- const tableEnd = offset + 3 + sectionLength - 4;
|
|
|
- const programInfoLength = (data[offset + 10] & 15) << 8 | data[offset + 11];
|
|
|
- offset += 12 + programInfoLength;
|
|
|
- while (offset < tableEnd) {
|
|
|
- const pid = parsePID(data, offset);
|
|
|
- const esInfoLength = (data[offset + 3] & 15) << 8 | data[offset + 4];
|
|
|
- switch (data[offset]) {
|
|
|
- case 207:
|
|
|
- if (!isSampleAes) {
|
|
|
- logEncryptedSamplesFoundInUnencryptedStream("ADTS AAC", logger2);
|
|
|
- break;
|
|
|
- }
|
|
|
- case 15:
|
|
|
- if (result.audioPid === -1) {
|
|
|
- result.audioPid = pid;
|
|
|
- }
|
|
|
- break;
|
|
|
- case 21:
|
|
|
- if (result.id3Pid === -1) {
|
|
|
- result.id3Pid = pid;
|
|
|
- }
|
|
|
- break;
|
|
|
- case 219:
|
|
|
- if (!isSampleAes) {
|
|
|
- logEncryptedSamplesFoundInUnencryptedStream("H.264", logger2);
|
|
|
- break;
|
|
|
- }
|
|
|
- case 27:
|
|
|
- if (result.videoPid === -1) {
|
|
|
- result.videoPid = pid;
|
|
|
- }
|
|
|
- break;
|
|
|
- case 3:
|
|
|
- case 4:
|
|
|
- if (!typeSupported.mpeg && !typeSupported.mp3) {
|
|
|
- logger2.log("MPEG audio found, not supported in this browser");
|
|
|
- } else if (result.audioPid === -1) {
|
|
|
- result.audioPid = pid;
|
|
|
- result.segmentAudioCodec = "mp3";
|
|
|
- }
|
|
|
- break;
|
|
|
- case 193:
|
|
|
- if (!isSampleAes) {
|
|
|
- logEncryptedSamplesFoundInUnencryptedStream("AC-3", logger2);
|
|
|
- break;
|
|
|
- }
|
|
|
- case 129:
|
|
|
- {
|
|
|
- if (!typeSupported.ac3) {
|
|
|
- logger2.log("AC-3 audio found, not supported in this browser");
|
|
|
- } else if (result.audioPid === -1) {
|
|
|
- result.audioPid = pid;
|
|
|
- result.segmentAudioCodec = "ac3";
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- case 6:
|
|
|
- if (result.audioPid === -1 && esInfoLength > 0) {
|
|
|
- let parsePos = offset + 5;
|
|
|
- let remaining = esInfoLength;
|
|
|
- while (remaining > 2) {
|
|
|
- const descriptorId = data[parsePos];
|
|
|
- switch (descriptorId) {
|
|
|
- case 106:
|
|
|
- {
|
|
|
- if (typeSupported.ac3 !== true) {
|
|
|
- logger2.log("AC-3 audio found, not supported in this browser for now");
|
|
|
- } else {
|
|
|
- result.audioPid = pid;
|
|
|
- result.segmentAudioCodec = "ac3";
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- const descriptorLen = data[parsePos + 1] + 2;
|
|
|
- parsePos += descriptorLen;
|
|
|
- remaining -= descriptorLen;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- case 194:
|
|
|
- case 135:
|
|
|
- emitParsingError(observer, new Error("Unsupported EC-3 in M2TS found"), void 0, logger2);
|
|
|
- return result;
|
|
|
- case 36:
|
|
|
- {
|
|
|
- if (result.videoPid === -1) {
|
|
|
- result.videoPid = pid;
|
|
|
- result.segmentVideoCodec = "hevc";
|
|
|
- logger2.log("HEVC in M2TS found");
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- offset += esInfoLength + 5;
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-function emitParsingError(observer, error, levelRetry, logger2) {
|
|
|
- logger2.warn(`parsing error: ${error.message}`);
|
|
|
- observer.emit(Events.ERROR, Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_PARSING_ERROR,
|
|
|
- fatal: false,
|
|
|
- levelRetry,
|
|
|
- error,
|
|
|
- reason: error.message
|
|
|
- });
|
|
|
-}
|
|
|
-function logEncryptedSamplesFoundInUnencryptedStream(type, logger2) {
|
|
|
- logger2.log(`${type} with AES-128-CBC encryption found in unencrypted stream`);
|
|
|
-}
|
|
|
-function parsePES(stream, logger2) {
|
|
|
- let i = 0;
|
|
|
- let frag;
|
|
|
- let pesLen;
|
|
|
- let pesHdrLen;
|
|
|
- let pesPts;
|
|
|
- let pesDts;
|
|
|
- const data = stream.data;
|
|
|
- if (!stream || stream.size === 0) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- while (data[0].length < 19 && data.length > 1) {
|
|
|
- data[0] = appendUint8Array(data[0], data[1]);
|
|
|
- data.splice(1, 1);
|
|
|
- }
|
|
|
- frag = data[0];
|
|
|
- const pesPrefix = (frag[0] << 16) + (frag[1] << 8) + frag[2];
|
|
|
- if (pesPrefix === 1) {
|
|
|
- pesLen = (frag[4] << 8) + frag[5];
|
|
|
- if (pesLen && pesLen > stream.size - 6) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const pesFlags = frag[7];
|
|
|
- if (pesFlags & 192) {
|
|
|
- pesPts = (frag[9] & 14) * 536870912 + // 1 << 29
|
|
|
- (frag[10] & 255) * 4194304 + // 1 << 22
|
|
|
- (frag[11] & 254) * 16384 + // 1 << 14
|
|
|
- (frag[12] & 255) * 128 + // 1 << 7
|
|
|
- (frag[13] & 254) / 2;
|
|
|
- if (pesFlags & 64) {
|
|
|
- pesDts = (frag[14] & 14) * 536870912 + // 1 << 29
|
|
|
- (frag[15] & 255) * 4194304 + // 1 << 22
|
|
|
- (frag[16] & 254) * 16384 + // 1 << 14
|
|
|
- (frag[17] & 255) * 128 + // 1 << 7
|
|
|
- (frag[18] & 254) / 2;
|
|
|
- if (pesPts - pesDts > 60 * 9e4) {
|
|
|
- logger2.warn(`${Math.round((pesPts - pesDts) / 9e4)}s delta between PTS and DTS, align them`);
|
|
|
- pesPts = pesDts;
|
|
|
- }
|
|
|
- } else {
|
|
|
- pesDts = pesPts;
|
|
|
- }
|
|
|
- }
|
|
|
- pesHdrLen = frag[8];
|
|
|
- let payloadStartOffset = pesHdrLen + 9;
|
|
|
- if (stream.size <= payloadStartOffset) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- stream.size -= payloadStartOffset;
|
|
|
- const pesData = new Uint8Array(stream.size);
|
|
|
- for (let j = 0, dataLen = data.length; j < dataLen; j++) {
|
|
|
- frag = data[j];
|
|
|
- let len = frag.byteLength;
|
|
|
- if (payloadStartOffset) {
|
|
|
- if (payloadStartOffset > len) {
|
|
|
- payloadStartOffset -= len;
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- frag = frag.subarray(payloadStartOffset);
|
|
|
- len -= payloadStartOffset;
|
|
|
- payloadStartOffset = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- pesData.set(frag, i);
|
|
|
- i += len;
|
|
|
- }
|
|
|
- if (pesLen) {
|
|
|
- pesLen -= pesHdrLen + 3;
|
|
|
- }
|
|
|
- return {
|
|
|
- data: pesData,
|
|
|
- pts: pesPts,
|
|
|
- dts: pesDts,
|
|
|
- len: pesLen
|
|
|
- };
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-var AAC = class {
|
|
|
- static getSilentFrame(codec, channelCount) {
|
|
|
- switch (codec) {
|
|
|
- case "mp4a.40.2":
|
|
|
- if (channelCount === 1) {
|
|
|
- return new Uint8Array([0, 200, 0, 128, 35, 128]);
|
|
|
- } else if (channelCount === 2) {
|
|
|
- return new Uint8Array([33, 0, 73, 144, 2, 25, 0, 35, 128]);
|
|
|
- } else if (channelCount === 3) {
|
|
|
- return new Uint8Array([0, 200, 0, 128, 32, 132, 1, 38, 64, 8, 100, 0, 142]);
|
|
|
- } else if (channelCount === 4) {
|
|
|
- return new Uint8Array([0, 200, 0, 128, 32, 132, 1, 38, 64, 8, 100, 0, 128, 44, 128, 8, 2, 56]);
|
|
|
- } else if (channelCount === 5) {
|
|
|
- return new Uint8Array([0, 200, 0, 128, 32, 132, 1, 38, 64, 8, 100, 0, 130, 48, 4, 153, 0, 33, 144, 2, 56]);
|
|
|
- } else if (channelCount === 6) {
|
|
|
- return new Uint8Array([0, 200, 0, 128, 32, 132, 1, 38, 64, 8, 100, 0, 130, 48, 4, 153, 0, 33, 144, 2, 0, 178, 0, 32, 8, 224]);
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- if (channelCount === 1) {
|
|
|
- return new Uint8Array([1, 64, 34, 128, 163, 78, 230, 128, 186, 8, 0, 0, 0, 28, 6, 241, 193, 10, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 94]);
|
|
|
- } else if (channelCount === 2) {
|
|
|
- return new Uint8Array([1, 64, 34, 128, 163, 94, 230, 128, 186, 8, 0, 0, 0, 0, 149, 0, 6, 241, 161, 10, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 94]);
|
|
|
- } else if (channelCount === 3) {
|
|
|
- return new Uint8Array([1, 64, 34, 128, 163, 94, 230, 128, 186, 8, 0, 0, 0, 0, 149, 0, 6, 241, 161, 10, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 94]);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- return void 0;
|
|
|
- }
|
|
|
-};
|
|
|
-var UINT32_MAX = Math.pow(2, 32) - 1;
|
|
|
-var MP4 = class _MP4 {
|
|
|
- static init() {
|
|
|
- _MP4.types = {
|
|
|
- avc1: [],
|
|
|
- // codingname
|
|
|
- avcC: [],
|
|
|
- hvc1: [],
|
|
|
- hvcC: [],
|
|
|
- btrt: [],
|
|
|
- dinf: [],
|
|
|
- dref: [],
|
|
|
- esds: [],
|
|
|
- ftyp: [],
|
|
|
- hdlr: [],
|
|
|
- mdat: [],
|
|
|
- mdhd: [],
|
|
|
- mdia: [],
|
|
|
- mfhd: [],
|
|
|
- minf: [],
|
|
|
- moof: [],
|
|
|
- moov: [],
|
|
|
- mp4a: [],
|
|
|
- ".mp3": [],
|
|
|
- dac3: [],
|
|
|
- "ac-3": [],
|
|
|
- mvex: [],
|
|
|
- mvhd: [],
|
|
|
- pasp: [],
|
|
|
- sdtp: [],
|
|
|
- stbl: [],
|
|
|
- stco: [],
|
|
|
- stsc: [],
|
|
|
- stsd: [],
|
|
|
- stsz: [],
|
|
|
- stts: [],
|
|
|
- tfdt: [],
|
|
|
- tfhd: [],
|
|
|
- traf: [],
|
|
|
- trak: [],
|
|
|
- trun: [],
|
|
|
- trex: [],
|
|
|
- tkhd: [],
|
|
|
- vmhd: [],
|
|
|
- smhd: []
|
|
|
- };
|
|
|
- let i;
|
|
|
- for (i in _MP4.types) {
|
|
|
- if (_MP4.types.hasOwnProperty(i)) {
|
|
|
- _MP4.types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
|
|
|
- }
|
|
|
- }
|
|
|
- const videoHdlr = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // pre_defined
|
|
|
- 118,
|
|
|
- 105,
|
|
|
- 100,
|
|
|
- 101,
|
|
|
- // handler_type: 'vide'
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 86,
|
|
|
- 105,
|
|
|
- 100,
|
|
|
- 101,
|
|
|
- 111,
|
|
|
- 72,
|
|
|
- 97,
|
|
|
- 110,
|
|
|
- 100,
|
|
|
- 108,
|
|
|
- 101,
|
|
|
- 114,
|
|
|
- 0
|
|
|
- // name: 'VideoHandler'
|
|
|
- ]);
|
|
|
- const audioHdlr = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // pre_defined
|
|
|
- 115,
|
|
|
- 111,
|
|
|
- 117,
|
|
|
- 110,
|
|
|
- // handler_type: 'soun'
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 83,
|
|
|
- 111,
|
|
|
- 117,
|
|
|
- 110,
|
|
|
- 100,
|
|
|
- 72,
|
|
|
- 97,
|
|
|
- 110,
|
|
|
- 100,
|
|
|
- 108,
|
|
|
- 101,
|
|
|
- 114,
|
|
|
- 0
|
|
|
- // name: 'SoundHandler'
|
|
|
- ]);
|
|
|
- _MP4.HDLR_TYPES = {
|
|
|
- video: videoHdlr,
|
|
|
- audio: audioHdlr
|
|
|
- };
|
|
|
- const dref = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // entry_count
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 12,
|
|
|
- // entry_size
|
|
|
- 117,
|
|
|
- 114,
|
|
|
- 108,
|
|
|
- 32,
|
|
|
- // 'url' type
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 1
|
|
|
- // entry_flags
|
|
|
- ]);
|
|
|
- const stco = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0
|
|
|
- // entry_count
|
|
|
- ]);
|
|
|
- _MP4.STTS = _MP4.STSC = _MP4.STCO = stco;
|
|
|
- _MP4.STSZ = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // sample_size
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0
|
|
|
- // sample_count
|
|
|
- ]);
|
|
|
- _MP4.VMHD = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // graphicsmode
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0
|
|
|
- // opcolor
|
|
|
- ]);
|
|
|
- _MP4.SMHD = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // balance
|
|
|
- 0,
|
|
|
- 0
|
|
|
- // reserved
|
|
|
- ]);
|
|
|
- _MP4.STSD = new Uint8Array([
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 1
|
|
|
- ]);
|
|
|
- const majorBrand = new Uint8Array([105, 115, 111, 109]);
|
|
|
- const avc1Brand = new Uint8Array([97, 118, 99, 49]);
|
|
|
- const minorVersion = new Uint8Array([0, 0, 0, 1]);
|
|
|
- _MP4.FTYP = _MP4.box(_MP4.types.ftyp, majorBrand, minorVersion, majorBrand, avc1Brand);
|
|
|
- _MP4.DINF = _MP4.box(_MP4.types.dinf, _MP4.box(_MP4.types.dref, dref));
|
|
|
- }
|
|
|
- static box(type, ...payload) {
|
|
|
- let size = 8;
|
|
|
- let i = payload.length;
|
|
|
- const len = i;
|
|
|
- while (i--) {
|
|
|
- size += payload[i].byteLength;
|
|
|
- }
|
|
|
- const result = new Uint8Array(size);
|
|
|
- result[0] = size >> 24 & 255;
|
|
|
- result[1] = size >> 16 & 255;
|
|
|
- result[2] = size >> 8 & 255;
|
|
|
- result[3] = size & 255;
|
|
|
- result.set(type, 4);
|
|
|
- for (i = 0, size = 8; i < len; i++) {
|
|
|
- result.set(payload[i], size);
|
|
|
- size += payload[i].byteLength;
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- static hdlr(type) {
|
|
|
- return _MP4.box(_MP4.types.hdlr, _MP4.HDLR_TYPES[type]);
|
|
|
- }
|
|
|
- static mdat(data) {
|
|
|
- return _MP4.box(_MP4.types.mdat, data);
|
|
|
- }
|
|
|
- static mdhd(timescale, duration) {
|
|
|
- duration *= timescale;
|
|
|
- const upperWordDuration = Math.floor(duration / (UINT32_MAX + 1));
|
|
|
- const lowerWordDuration = Math.floor(duration % (UINT32_MAX + 1));
|
|
|
- return _MP4.box(_MP4.types.mdhd, new Uint8Array([
|
|
|
- 1,
|
|
|
- // version 1
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 2,
|
|
|
- // creation_time
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 3,
|
|
|
- // modification_time
|
|
|
- timescale >> 24 & 255,
|
|
|
- timescale >> 16 & 255,
|
|
|
- timescale >> 8 & 255,
|
|
|
- timescale & 255,
|
|
|
- // timescale
|
|
|
- upperWordDuration >> 24,
|
|
|
- upperWordDuration >> 16 & 255,
|
|
|
- upperWordDuration >> 8 & 255,
|
|
|
- upperWordDuration & 255,
|
|
|
- lowerWordDuration >> 24,
|
|
|
- lowerWordDuration >> 16 & 255,
|
|
|
- lowerWordDuration >> 8 & 255,
|
|
|
- lowerWordDuration & 255,
|
|
|
- 85,
|
|
|
- 196,
|
|
|
- // 'und' language (undetermined)
|
|
|
- 0,
|
|
|
- 0
|
|
|
- ]));
|
|
|
- }
|
|
|
- static mdia(track) {
|
|
|
- return _MP4.box(_MP4.types.mdia, _MP4.mdhd(track.timescale || 0, track.duration || 0), _MP4.hdlr(track.type), _MP4.minf(track));
|
|
|
- }
|
|
|
- static mfhd(sequenceNumber) {
|
|
|
- return _MP4.box(_MP4.types.mfhd, new Uint8Array([
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- sequenceNumber >> 24,
|
|
|
- sequenceNumber >> 16 & 255,
|
|
|
- sequenceNumber >> 8 & 255,
|
|
|
- sequenceNumber & 255
|
|
|
- // sequence_number
|
|
|
- ]));
|
|
|
- }
|
|
|
- static minf(track) {
|
|
|
- if (track.type === "audio") {
|
|
|
- return _MP4.box(_MP4.types.minf, _MP4.box(_MP4.types.smhd, _MP4.SMHD), _MP4.DINF, _MP4.stbl(track));
|
|
|
- } else {
|
|
|
- return _MP4.box(_MP4.types.minf, _MP4.box(_MP4.types.vmhd, _MP4.VMHD), _MP4.DINF, _MP4.stbl(track));
|
|
|
- }
|
|
|
- }
|
|
|
- static moof(sn, baseMediaDecodeTime, track) {
|
|
|
- return _MP4.box(_MP4.types.moof, _MP4.mfhd(sn), _MP4.traf(track, baseMediaDecodeTime));
|
|
|
- }
|
|
|
- static moov(tracks) {
|
|
|
- let i = tracks.length;
|
|
|
- const boxes = [];
|
|
|
- while (i--) {
|
|
|
- boxes[i] = _MP4.trak(tracks[i]);
|
|
|
- }
|
|
|
- return _MP4.box.apply(null, [_MP4.types.moov, _MP4.mvhd(tracks[0].timescale || 0, tracks[0].duration || 0)].concat(boxes).concat(_MP4.mvex(tracks)));
|
|
|
- }
|
|
|
- static mvex(tracks) {
|
|
|
- let i = tracks.length;
|
|
|
- const boxes = [];
|
|
|
- while (i--) {
|
|
|
- boxes[i] = _MP4.trex(tracks[i]);
|
|
|
- }
|
|
|
- return _MP4.box.apply(null, [_MP4.types.mvex, ...boxes]);
|
|
|
- }
|
|
|
- static mvhd(timescale, duration) {
|
|
|
- duration *= timescale;
|
|
|
- const upperWordDuration = Math.floor(duration / (UINT32_MAX + 1));
|
|
|
- const lowerWordDuration = Math.floor(duration % (UINT32_MAX + 1));
|
|
|
- const bytes = new Uint8Array([
|
|
|
- 1,
|
|
|
- // version 1
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 2,
|
|
|
- // creation_time
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 3,
|
|
|
- // modification_time
|
|
|
- timescale >> 24 & 255,
|
|
|
- timescale >> 16 & 255,
|
|
|
- timescale >> 8 & 255,
|
|
|
- timescale & 255,
|
|
|
- // timescale
|
|
|
- upperWordDuration >> 24,
|
|
|
- upperWordDuration >> 16 & 255,
|
|
|
- upperWordDuration >> 8 & 255,
|
|
|
- upperWordDuration & 255,
|
|
|
- lowerWordDuration >> 24,
|
|
|
- lowerWordDuration >> 16 & 255,
|
|
|
- lowerWordDuration >> 8 & 255,
|
|
|
- lowerWordDuration & 255,
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // 1.0 rate
|
|
|
- 1,
|
|
|
- 0,
|
|
|
- // 1.0 volume
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 64,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // transformation: unity matrix
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // pre_defined
|
|
|
- 255,
|
|
|
- 255,
|
|
|
- 255,
|
|
|
- 255
|
|
|
- // next_track_ID
|
|
|
- ]);
|
|
|
- return _MP4.box(_MP4.types.mvhd, bytes);
|
|
|
- }
|
|
|
- static sdtp(track) {
|
|
|
- const samples = track.samples || [];
|
|
|
- const bytes = new Uint8Array(4 + samples.length);
|
|
|
- let i;
|
|
|
- let flags;
|
|
|
- for (i = 0; i < samples.length; i++) {
|
|
|
- flags = samples[i].flags;
|
|
|
- bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
|
|
|
- }
|
|
|
- return _MP4.box(_MP4.types.sdtp, bytes);
|
|
|
- }
|
|
|
- static stbl(track) {
|
|
|
- return _MP4.box(_MP4.types.stbl, _MP4.stsd(track), _MP4.box(_MP4.types.stts, _MP4.STTS), _MP4.box(_MP4.types.stsc, _MP4.STSC), _MP4.box(_MP4.types.stsz, _MP4.STSZ), _MP4.box(_MP4.types.stco, _MP4.STCO));
|
|
|
- }
|
|
|
- static avc1(track) {
|
|
|
- let sps = [];
|
|
|
- let pps = [];
|
|
|
- let i;
|
|
|
- let data;
|
|
|
- let len;
|
|
|
- for (i = 0; i < track.sps.length; i++) {
|
|
|
- data = track.sps[i];
|
|
|
- len = data.byteLength;
|
|
|
- sps.push(len >>> 8 & 255);
|
|
|
- sps.push(len & 255);
|
|
|
- sps = sps.concat(Array.prototype.slice.call(data));
|
|
|
- }
|
|
|
- for (i = 0; i < track.pps.length; i++) {
|
|
|
- data = track.pps[i];
|
|
|
- len = data.byteLength;
|
|
|
- pps.push(len >>> 8 & 255);
|
|
|
- pps.push(len & 255);
|
|
|
- pps = pps.concat(Array.prototype.slice.call(data));
|
|
|
- }
|
|
|
- const avcc = _MP4.box(_MP4.types.avcC, new Uint8Array([
|
|
|
- 1,
|
|
|
- // version
|
|
|
- sps[3],
|
|
|
- // profile
|
|
|
- sps[4],
|
|
|
- // profile compat
|
|
|
- sps[5],
|
|
|
- // level
|
|
|
- 252 | 3,
|
|
|
- // lengthSizeMinusOne, hard-coded to 4 bytes
|
|
|
- 224 | track.sps.length
|
|
|
- // 3bit reserved (111) + numOfSequenceParameterSets
|
|
|
- ].concat(sps).concat([
|
|
|
- track.pps.length
|
|
|
- // numOfPictureParameterSets
|
|
|
- ]).concat(pps)));
|
|
|
- const width = track.width;
|
|
|
- const height = track.height;
|
|
|
- const hSpacing = track.pixelRatio[0];
|
|
|
- const vSpacing = track.pixelRatio[1];
|
|
|
- return _MP4.box(
|
|
|
- _MP4.types.avc1,
|
|
|
- new Uint8Array([
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // data_reference_index
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // pre_defined
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // pre_defined
|
|
|
- width >> 8 & 255,
|
|
|
- width & 255,
|
|
|
- // width
|
|
|
- height >> 8 & 255,
|
|
|
- height & 255,
|
|
|
- // height
|
|
|
- 0,
|
|
|
- 72,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // horizresolution
|
|
|
- 0,
|
|
|
- 72,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // vertresolution
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // frame_count
|
|
|
- 18,
|
|
|
- 100,
|
|
|
- 97,
|
|
|
- 105,
|
|
|
- 108,
|
|
|
- // dailymotion/hls.js
|
|
|
- 121,
|
|
|
- 109,
|
|
|
- 111,
|
|
|
- 116,
|
|
|
- 105,
|
|
|
- 111,
|
|
|
- 110,
|
|
|
- 47,
|
|
|
- 104,
|
|
|
- 108,
|
|
|
- 115,
|
|
|
- 46,
|
|
|
- 106,
|
|
|
- 115,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // compressorname
|
|
|
- 0,
|
|
|
- 24,
|
|
|
- // depth = 24
|
|
|
- 17,
|
|
|
- 17
|
|
|
- ]),
|
|
|
- // pre_defined = -1
|
|
|
- avcc,
|
|
|
- _MP4.box(_MP4.types.btrt, new Uint8Array([
|
|
|
- 0,
|
|
|
- 28,
|
|
|
- 156,
|
|
|
- 128,
|
|
|
- // bufferSizeDB
|
|
|
- 0,
|
|
|
- 45,
|
|
|
- 198,
|
|
|
- 192,
|
|
|
- // maxBitrate
|
|
|
- 0,
|
|
|
- 45,
|
|
|
- 198,
|
|
|
- 192
|
|
|
- ])),
|
|
|
- // avgBitrate
|
|
|
- _MP4.box(_MP4.types.pasp, new Uint8Array([
|
|
|
- hSpacing >> 24,
|
|
|
- // hSpacing
|
|
|
- hSpacing >> 16 & 255,
|
|
|
- hSpacing >> 8 & 255,
|
|
|
- hSpacing & 255,
|
|
|
- vSpacing >> 24,
|
|
|
- // vSpacing
|
|
|
- vSpacing >> 16 & 255,
|
|
|
- vSpacing >> 8 & 255,
|
|
|
- vSpacing & 255
|
|
|
- ]))
|
|
|
- );
|
|
|
- }
|
|
|
- static esds(track) {
|
|
|
- const config = track.config;
|
|
|
- return new Uint8Array([
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- 3,
|
|
|
- // descriptor_type
|
|
|
- 25,
|
|
|
- // length
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // es_id
|
|
|
- 0,
|
|
|
- // stream_priority
|
|
|
- 4,
|
|
|
- // descriptor_type
|
|
|
- 17,
|
|
|
- // length
|
|
|
- 64,
|
|
|
- // codec : mpeg4_audio
|
|
|
- 21,
|
|
|
- // stream_type
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // buffer_size
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // maxBitrate
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // avgBitrate
|
|
|
- 5,
|
|
|
- // descriptor_type
|
|
|
- 2,
|
|
|
- // length
|
|
|
- ...config,
|
|
|
- 6,
|
|
|
- 1,
|
|
|
- 2
|
|
|
- // GASpecificConfig)); // length + audio config descriptor
|
|
|
- ]);
|
|
|
- }
|
|
|
- static audioStsd(track) {
|
|
|
- const samplerate = track.samplerate || 0;
|
|
|
- return new Uint8Array([
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // data_reference_index
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- track.channelCount || 0,
|
|
|
- // channelcount
|
|
|
- 0,
|
|
|
- 16,
|
|
|
- // sampleSize:16bits
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved2
|
|
|
- samplerate >> 8 & 255,
|
|
|
- samplerate & 255,
|
|
|
- //
|
|
|
- 0,
|
|
|
- 0
|
|
|
- ]);
|
|
|
- }
|
|
|
- static mp4a(track) {
|
|
|
- return _MP4.box(_MP4.types.mp4a, _MP4.audioStsd(track), _MP4.box(_MP4.types.esds, _MP4.esds(track)));
|
|
|
- }
|
|
|
- static mp3(track) {
|
|
|
- return _MP4.box(_MP4.types[".mp3"], _MP4.audioStsd(track));
|
|
|
- }
|
|
|
- static ac3(track) {
|
|
|
- return _MP4.box(_MP4.types["ac-3"], _MP4.audioStsd(track), _MP4.box(_MP4.types.dac3, track.config));
|
|
|
- }
|
|
|
- static stsd(track) {
|
|
|
- const {
|
|
|
- segmentCodec
|
|
|
- } = track;
|
|
|
- if (track.type === "audio") {
|
|
|
- if (segmentCodec === "aac") {
|
|
|
- return _MP4.box(_MP4.types.stsd, _MP4.STSD, _MP4.mp4a(track));
|
|
|
- }
|
|
|
- if (segmentCodec === "ac3" && track.config) {
|
|
|
- return _MP4.box(_MP4.types.stsd, _MP4.STSD, _MP4.ac3(track));
|
|
|
- }
|
|
|
- if (segmentCodec === "mp3" && track.codec === "mp3") {
|
|
|
- return _MP4.box(_MP4.types.stsd, _MP4.STSD, _MP4.mp3(track));
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (track.pps && track.sps) {
|
|
|
- if (segmentCodec === "avc") {
|
|
|
- return _MP4.box(_MP4.types.stsd, _MP4.STSD, _MP4.avc1(track));
|
|
|
- }
|
|
|
- if (segmentCodec === "hevc" && track.vps) {
|
|
|
- return _MP4.box(_MP4.types.stsd, _MP4.STSD, _MP4.hvc1(track));
|
|
|
- }
|
|
|
- } else {
|
|
|
- throw new Error(`video track missing pps or sps`);
|
|
|
- }
|
|
|
- }
|
|
|
- throw new Error(`unsupported ${track.type} segment codec (${segmentCodec}/${track.codec})`);
|
|
|
- }
|
|
|
- static tkhd(track) {
|
|
|
- const id = track.id;
|
|
|
- const duration = (track.duration || 0) * (track.timescale || 0);
|
|
|
- const width = track.width || 0;
|
|
|
- const height = track.height || 0;
|
|
|
- const upperWordDuration = Math.floor(duration / (UINT32_MAX + 1));
|
|
|
- const lowerWordDuration = Math.floor(duration % (UINT32_MAX + 1));
|
|
|
- return _MP4.box(_MP4.types.tkhd, new Uint8Array([
|
|
|
- 1,
|
|
|
- // version 1
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 7,
|
|
|
- // flags
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 2,
|
|
|
- // creation_time
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 3,
|
|
|
- // modification_time
|
|
|
- id >> 24 & 255,
|
|
|
- id >> 16 & 255,
|
|
|
- id >> 8 & 255,
|
|
|
- id & 255,
|
|
|
- // track_ID
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- upperWordDuration >> 24,
|
|
|
- upperWordDuration >> 16 & 255,
|
|
|
- upperWordDuration >> 8 & 255,
|
|
|
- upperWordDuration & 255,
|
|
|
- lowerWordDuration >> 24,
|
|
|
- lowerWordDuration >> 16 & 255,
|
|
|
- lowerWordDuration >> 8 & 255,
|
|
|
- lowerWordDuration & 255,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // layer
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // alternate_group
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // non-audio track volume
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 64,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // transformation: unity matrix
|
|
|
- width >> 8 & 255,
|
|
|
- width & 255,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // width
|
|
|
- height >> 8 & 255,
|
|
|
- height & 255,
|
|
|
- 0,
|
|
|
- 0
|
|
|
- // height
|
|
|
- ]));
|
|
|
- }
|
|
|
- static traf(track, baseMediaDecodeTime) {
|
|
|
- const sampleDependencyTable = _MP4.sdtp(track);
|
|
|
- const id = track.id;
|
|
|
- const upperWordBaseMediaDecodeTime = Math.floor(baseMediaDecodeTime / (UINT32_MAX + 1));
|
|
|
- const lowerWordBaseMediaDecodeTime = Math.floor(baseMediaDecodeTime % (UINT32_MAX + 1));
|
|
|
- return _MP4.box(
|
|
|
- _MP4.types.traf,
|
|
|
- _MP4.box(_MP4.types.tfhd, new Uint8Array([
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- id >> 24,
|
|
|
- id >> 16 & 255,
|
|
|
- id >> 8 & 255,
|
|
|
- id & 255
|
|
|
- // track_ID
|
|
|
- ])),
|
|
|
- _MP4.box(_MP4.types.tfdt, new Uint8Array([
|
|
|
- 1,
|
|
|
- // version 1
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- upperWordBaseMediaDecodeTime >> 24,
|
|
|
- upperWordBaseMediaDecodeTime >> 16 & 255,
|
|
|
- upperWordBaseMediaDecodeTime >> 8 & 255,
|
|
|
- upperWordBaseMediaDecodeTime & 255,
|
|
|
- lowerWordBaseMediaDecodeTime >> 24,
|
|
|
- lowerWordBaseMediaDecodeTime >> 16 & 255,
|
|
|
- lowerWordBaseMediaDecodeTime >> 8 & 255,
|
|
|
- lowerWordBaseMediaDecodeTime & 255
|
|
|
- ])),
|
|
|
- _MP4.trun(track, sampleDependencyTable.length + 16 + // tfhd
|
|
|
- 20 + // tfdt
|
|
|
- 8 + // traf header
|
|
|
- 16 + // mfhd
|
|
|
- 8 + // moof header
|
|
|
- 8),
|
|
|
- // mdat header
|
|
|
- sampleDependencyTable
|
|
|
- );
|
|
|
- }
|
|
|
- /**
|
|
|
- * Generate a track box.
|
|
|
- * @param track a track definition
|
|
|
- */
|
|
|
- static trak(track) {
|
|
|
- track.duration = track.duration || 4294967295;
|
|
|
- return _MP4.box(_MP4.types.trak, _MP4.tkhd(track), _MP4.mdia(track));
|
|
|
- }
|
|
|
- static trex(track) {
|
|
|
- const id = track.id;
|
|
|
- return _MP4.box(_MP4.types.trex, new Uint8Array([
|
|
|
- 0,
|
|
|
- // version 0
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // flags
|
|
|
- id >> 24,
|
|
|
- id >> 16 & 255,
|
|
|
- id >> 8 & 255,
|
|
|
- id & 255,
|
|
|
- // track_ID
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // default_sample_description_index
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // default_sample_duration
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // default_sample_size
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- 0,
|
|
|
- 1
|
|
|
- // default_sample_flags
|
|
|
- ]));
|
|
|
- }
|
|
|
- static trun(track, offset) {
|
|
|
- const samples = track.samples || [];
|
|
|
- const len = samples.length;
|
|
|
- const arraylen = 12 + 16 * len;
|
|
|
- const array = new Uint8Array(arraylen);
|
|
|
- let i;
|
|
|
- let sample;
|
|
|
- let duration;
|
|
|
- let size;
|
|
|
- let flags;
|
|
|
- let cts;
|
|
|
- offset += 8 + arraylen;
|
|
|
- array.set([
|
|
|
- track.type === "video" ? 1 : 0,
|
|
|
- // version 1 for video with signed-int sample_composition_time_offset
|
|
|
- 0,
|
|
|
- 15,
|
|
|
- 1,
|
|
|
- // flags
|
|
|
- len >>> 24 & 255,
|
|
|
- len >>> 16 & 255,
|
|
|
- len >>> 8 & 255,
|
|
|
- len & 255,
|
|
|
- // sample_count
|
|
|
- offset >>> 24 & 255,
|
|
|
- offset >>> 16 & 255,
|
|
|
- offset >>> 8 & 255,
|
|
|
- offset & 255
|
|
|
- // data_offset
|
|
|
- ], 0);
|
|
|
- for (i = 0; i < len; i++) {
|
|
|
- sample = samples[i];
|
|
|
- duration = sample.duration;
|
|
|
- size = sample.size;
|
|
|
- flags = sample.flags;
|
|
|
- cts = sample.cts;
|
|
|
- array.set([
|
|
|
- duration >>> 24 & 255,
|
|
|
- duration >>> 16 & 255,
|
|
|
- duration >>> 8 & 255,
|
|
|
- duration & 255,
|
|
|
- // sample_duration
|
|
|
- size >>> 24 & 255,
|
|
|
- size >>> 16 & 255,
|
|
|
- size >>> 8 & 255,
|
|
|
- size & 255,
|
|
|
- // sample_size
|
|
|
- flags.isLeading << 2 | flags.dependsOn,
|
|
|
- flags.isDependedOn << 6 | flags.hasRedundancy << 4 | flags.paddingValue << 1 | flags.isNonSync,
|
|
|
- flags.degradPrio & 240 << 8,
|
|
|
- flags.degradPrio & 15,
|
|
|
- // sample_flags
|
|
|
- cts >>> 24 & 255,
|
|
|
- cts >>> 16 & 255,
|
|
|
- cts >>> 8 & 255,
|
|
|
- cts & 255
|
|
|
- // sample_composition_time_offset
|
|
|
- ], 12 + 16 * i);
|
|
|
- }
|
|
|
- return _MP4.box(_MP4.types.trun, array);
|
|
|
- }
|
|
|
- static initSegment(tracks) {
|
|
|
- if (!_MP4.types) {
|
|
|
- _MP4.init();
|
|
|
- }
|
|
|
- const movie = _MP4.moov(tracks);
|
|
|
- const result = appendUint8Array(_MP4.FTYP, movie);
|
|
|
- return result;
|
|
|
- }
|
|
|
- static hvc1(track) {
|
|
|
- const ps = track.params;
|
|
|
- const units = [track.vps, track.sps, track.pps];
|
|
|
- const NALuLengthSize = 4;
|
|
|
- const config = new Uint8Array([1, ps.general_profile_space << 6 | (ps.general_tier_flag ? 32 : 0) | ps.general_profile_idc, ps.general_profile_compatibility_flags[0], ps.general_profile_compatibility_flags[1], ps.general_profile_compatibility_flags[2], ps.general_profile_compatibility_flags[3], ps.general_constraint_indicator_flags[0], ps.general_constraint_indicator_flags[1], ps.general_constraint_indicator_flags[2], ps.general_constraint_indicator_flags[3], ps.general_constraint_indicator_flags[4], ps.general_constraint_indicator_flags[5], ps.general_level_idc, 240 | ps.min_spatial_segmentation_idc >> 8, 255 & ps.min_spatial_segmentation_idc, 252 | ps.parallelismType, 252 | ps.chroma_format_idc, 248 | ps.bit_depth_luma_minus8, 248 | ps.bit_depth_chroma_minus8, 0, parseInt(ps.frame_rate.fps), NALuLengthSize - 1 | ps.temporal_id_nested << 2 | ps.num_temporal_layers << 3 | (ps.frame_rate.fixed ? 64 : 0), units.length]);
|
|
|
- let length = config.length;
|
|
|
- for (let i = 0; i < units.length; i += 1) {
|
|
|
- length += 3;
|
|
|
- for (let j = 0; j < units[i].length; j += 1) {
|
|
|
- length += 2 + units[i][j].length;
|
|
|
- }
|
|
|
- }
|
|
|
- const hvcC = new Uint8Array(length);
|
|
|
- hvcC.set(config, 0);
|
|
|
- length = config.length;
|
|
|
- const iMax = units.length - 1;
|
|
|
- for (let i = 0; i < units.length; i += 1) {
|
|
|
- hvcC.set(new Uint8Array([32 + i | (i === iMax ? 128 : 0), 0, units[i].length]), length);
|
|
|
- length += 3;
|
|
|
- for (let j = 0; j < units[i].length; j += 1) {
|
|
|
- hvcC.set(new Uint8Array([units[i][j].length >> 8, units[i][j].length & 255]), length);
|
|
|
- length += 2;
|
|
|
- hvcC.set(units[i][j], length);
|
|
|
- length += units[i][j].length;
|
|
|
- }
|
|
|
- }
|
|
|
- const hvcc = _MP4.box(_MP4.types.hvcC, hvcC);
|
|
|
- const width = track.width;
|
|
|
- const height = track.height;
|
|
|
- const hSpacing = track.pixelRatio[0];
|
|
|
- const vSpacing = track.pixelRatio[1];
|
|
|
- return _MP4.box(
|
|
|
- _MP4.types.hvc1,
|
|
|
- new Uint8Array([
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // data_reference_index
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // pre_defined
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // pre_defined
|
|
|
- width >> 8 & 255,
|
|
|
- width & 255,
|
|
|
- // width
|
|
|
- height >> 8 & 255,
|
|
|
- height & 255,
|
|
|
- // height
|
|
|
- 0,
|
|
|
- 72,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // horizresolution
|
|
|
- 0,
|
|
|
- 72,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // vertresolution
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // reserved
|
|
|
- 0,
|
|
|
- 1,
|
|
|
- // frame_count
|
|
|
- 18,
|
|
|
- 100,
|
|
|
- 97,
|
|
|
- 105,
|
|
|
- 108,
|
|
|
- // dailymotion/hls.js
|
|
|
- 121,
|
|
|
- 109,
|
|
|
- 111,
|
|
|
- 116,
|
|
|
- 105,
|
|
|
- 111,
|
|
|
- 110,
|
|
|
- 47,
|
|
|
- 104,
|
|
|
- 108,
|
|
|
- 115,
|
|
|
- 46,
|
|
|
- 106,
|
|
|
- 115,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- // compressorname
|
|
|
- 0,
|
|
|
- 24,
|
|
|
- // depth = 24
|
|
|
- 17,
|
|
|
- 17
|
|
|
- ]),
|
|
|
- // pre_defined = -1
|
|
|
- hvcc,
|
|
|
- _MP4.box(_MP4.types.btrt, new Uint8Array([
|
|
|
- 0,
|
|
|
- 28,
|
|
|
- 156,
|
|
|
- 128,
|
|
|
- // bufferSizeDB
|
|
|
- 0,
|
|
|
- 45,
|
|
|
- 198,
|
|
|
- 192,
|
|
|
- // maxBitrate
|
|
|
- 0,
|
|
|
- 45,
|
|
|
- 198,
|
|
|
- 192
|
|
|
- ])),
|
|
|
- // avgBitrate
|
|
|
- _MP4.box(_MP4.types.pasp, new Uint8Array([
|
|
|
- hSpacing >> 24,
|
|
|
- // hSpacing
|
|
|
- hSpacing >> 16 & 255,
|
|
|
- hSpacing >> 8 & 255,
|
|
|
- hSpacing & 255,
|
|
|
- vSpacing >> 24,
|
|
|
- // vSpacing
|
|
|
- vSpacing >> 16 & 255,
|
|
|
- vSpacing >> 8 & 255,
|
|
|
- vSpacing & 255
|
|
|
- ]))
|
|
|
- );
|
|
|
- }
|
|
|
-};
|
|
|
-MP4.types = void 0;
|
|
|
-MP4.HDLR_TYPES = void 0;
|
|
|
-MP4.STTS = void 0;
|
|
|
-MP4.STSC = void 0;
|
|
|
-MP4.STCO = void 0;
|
|
|
-MP4.STSZ = void 0;
|
|
|
-MP4.VMHD = void 0;
|
|
|
-MP4.SMHD = void 0;
|
|
|
-MP4.STSD = void 0;
|
|
|
-MP4.FTYP = void 0;
|
|
|
-MP4.DINF = void 0;
|
|
|
-var MPEG_TS_CLOCK_FREQ_HZ = 9e4;
|
|
|
-function toTimescaleFromBase(baseTime, destScale, srcBase = 1, round = false) {
|
|
|
- const result = baseTime * destScale * srcBase;
|
|
|
- return round ? Math.round(result) : result;
|
|
|
-}
|
|
|
-function toTimescaleFromScale(baseTime, destScale, srcScale = 1, round = false) {
|
|
|
- return toTimescaleFromBase(baseTime, destScale, 1 / srcScale, round);
|
|
|
-}
|
|
|
-function toMsFromMpegTsClock(baseTime, round = false) {
|
|
|
- return toTimescaleFromBase(baseTime, 1e3, 1 / MPEG_TS_CLOCK_FREQ_HZ, round);
|
|
|
-}
|
|
|
-function toMpegTsClockFromTimescale(baseTime, srcScale = 1) {
|
|
|
- return toTimescaleFromBase(baseTime, MPEG_TS_CLOCK_FREQ_HZ, 1 / srcScale);
|
|
|
-}
|
|
|
-function timestampToString(timestamp) {
|
|
|
- const {
|
|
|
- baseTime,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- } = timestamp;
|
|
|
- return `${baseTime / timescale} (${baseTime}/${timescale}) trackId: ${trackId}`;
|
|
|
-}
|
|
|
-var MAX_SILENT_FRAME_DURATION = 10 * 1e3;
|
|
|
-var AAC_SAMPLES_PER_FRAME = 1024;
|
|
|
-var MPEG_AUDIO_SAMPLE_PER_FRAME = 1152;
|
|
|
-var AC3_SAMPLES_PER_FRAME = 1536;
|
|
|
-var chromeVersion = null;
|
|
|
-var safariWebkitVersion = null;
|
|
|
-function createMp4Sample(isKeyframe, duration, size, cts) {
|
|
|
- return {
|
|
|
- duration,
|
|
|
- size,
|
|
|
- cts,
|
|
|
- flags: {
|
|
|
- isLeading: 0,
|
|
|
- isDependedOn: 0,
|
|
|
- hasRedundancy: 0,
|
|
|
- degradPrio: 0,
|
|
|
- dependsOn: isKeyframe ? 2 : 1,
|
|
|
- isNonSync: isKeyframe ? 0 : 1
|
|
|
- }
|
|
|
- };
|
|
|
-}
|
|
|
-var MP4Remuxer = class extends Logger {
|
|
|
- constructor(observer, config, typeSupported, logger2) {
|
|
|
- super("mp4-remuxer", logger2);
|
|
|
- this.observer = void 0;
|
|
|
- this.config = void 0;
|
|
|
- this.typeSupported = void 0;
|
|
|
- this.ISGenerated = false;
|
|
|
- this._initPTS = null;
|
|
|
- this._initDTS = null;
|
|
|
- this.nextVideoTs = null;
|
|
|
- this.nextAudioTs = null;
|
|
|
- this.videoSampleDuration = null;
|
|
|
- this.isAudioContiguous = false;
|
|
|
- this.isVideoContiguous = false;
|
|
|
- this.videoTrackConfig = void 0;
|
|
|
- this.observer = observer;
|
|
|
- this.config = config;
|
|
|
- this.typeSupported = typeSupported;
|
|
|
- this.ISGenerated = false;
|
|
|
- if (chromeVersion === null) {
|
|
|
- const userAgent = navigator.userAgent || "";
|
|
|
- const result = userAgent.match(/Chrome\/(\d+)/i);
|
|
|
- chromeVersion = result ? parseInt(result[1]) : 0;
|
|
|
- }
|
|
|
- if (safariWebkitVersion === null) {
|
|
|
- const result = navigator.userAgent.match(/Safari\/(\d+)/i);
|
|
|
- safariWebkitVersion = result ? parseInt(result[1]) : 0;
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.config = this.videoTrackConfig = this._initPTS = this._initDTS = null;
|
|
|
- }
|
|
|
- resetTimeStamp(defaultTimeStamp) {
|
|
|
- const initPTS = this._initPTS;
|
|
|
- if (!initPTS || !defaultTimeStamp || defaultTimeStamp.trackId !== initPTS.trackId || defaultTimeStamp.baseTime !== initPTS.baseTime || defaultTimeStamp.timescale !== initPTS.timescale) {
|
|
|
- this.log(`Reset initPTS: ${initPTS ? timestampToString(initPTS) : initPTS} > ${defaultTimeStamp ? timestampToString(defaultTimeStamp) : defaultTimeStamp}`);
|
|
|
- }
|
|
|
- this._initPTS = this._initDTS = defaultTimeStamp;
|
|
|
- }
|
|
|
- resetNextTimestamp() {
|
|
|
- this.log("reset next timestamp");
|
|
|
- this.isVideoContiguous = false;
|
|
|
- this.isAudioContiguous = false;
|
|
|
- }
|
|
|
- resetInitSegment() {
|
|
|
- this.log("ISGenerated flag reset");
|
|
|
- this.ISGenerated = false;
|
|
|
- this.videoTrackConfig = void 0;
|
|
|
- }
|
|
|
- getVideoStartPts(videoSamples) {
|
|
|
- let rolloverDetected = false;
|
|
|
- const firstPts = videoSamples[0].pts;
|
|
|
- const startPTS = videoSamples.reduce((minPTS, sample) => {
|
|
|
- let pts = sample.pts;
|
|
|
- let delta = pts - minPTS;
|
|
|
- if (delta < -4294967296) {
|
|
|
- rolloverDetected = true;
|
|
|
- pts = normalizePts(pts, firstPts);
|
|
|
- delta = pts - minPTS;
|
|
|
- }
|
|
|
- if (delta > 0) {
|
|
|
- return minPTS;
|
|
|
- }
|
|
|
- return pts;
|
|
|
- }, firstPts);
|
|
|
- if (rolloverDetected) {
|
|
|
- this.debug("PTS rollover detected");
|
|
|
- }
|
|
|
- return startPTS;
|
|
|
- }
|
|
|
- remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, flush, playlistType) {
|
|
|
- let video;
|
|
|
- let audio;
|
|
|
- let initSegment;
|
|
|
- let text;
|
|
|
- let id3;
|
|
|
- let independent;
|
|
|
- let audioTimeOffset = timeOffset;
|
|
|
- let videoTimeOffset = timeOffset;
|
|
|
- const hasAudio = audioTrack.pid > -1;
|
|
|
- const hasVideo = videoTrack.pid > -1;
|
|
|
- const length = videoTrack.samples.length;
|
|
|
- const enoughAudioSamples = audioTrack.samples.length > 0;
|
|
|
- const enoughVideoSamples = flush && length > 0 || length > 1;
|
|
|
- const canRemuxAvc = (!hasAudio || enoughAudioSamples) && (!hasVideo || enoughVideoSamples) || this.ISGenerated || flush;
|
|
|
- if (canRemuxAvc) {
|
|
|
- if (this.ISGenerated) {
|
|
|
- var _videoTrack$pixelRati, _config$pixelRatio, _videoTrack$pixelRati2, _config$pixelRatio2;
|
|
|
- const config = this.videoTrackConfig;
|
|
|
- if (config && (videoTrack.width !== config.width || videoTrack.height !== config.height || ((_videoTrack$pixelRati = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati[0]) !== ((_config$pixelRatio = config.pixelRatio) == null ? void 0 : _config$pixelRatio[0]) || ((_videoTrack$pixelRati2 = videoTrack.pixelRatio) == null ? void 0 : _videoTrack$pixelRati2[1]) !== ((_config$pixelRatio2 = config.pixelRatio) == null ? void 0 : _config$pixelRatio2[1])) || !config && enoughVideoSamples || this.nextAudioTs === null && enoughAudioSamples) {
|
|
|
- this.resetInitSegment();
|
|
|
- }
|
|
|
- }
|
|
|
- if (!this.ISGenerated) {
|
|
|
- initSegment = this.generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset);
|
|
|
- }
|
|
|
- const isVideoContiguous = this.isVideoContiguous;
|
|
|
- let firstKeyFrameIndex = -1;
|
|
|
- let firstKeyFramePTS;
|
|
|
- if (enoughVideoSamples) {
|
|
|
- firstKeyFrameIndex = findKeyframeIndex(videoTrack.samples);
|
|
|
- if (!isVideoContiguous && this.config.forceKeyFrameOnDiscontinuity) {
|
|
|
- independent = true;
|
|
|
- if (firstKeyFrameIndex > 0) {
|
|
|
- this.warn(`Dropped ${firstKeyFrameIndex} out of ${length} video samples due to a missing keyframe`);
|
|
|
- const startPTS = this.getVideoStartPts(videoTrack.samples);
|
|
|
- videoTrack.samples = videoTrack.samples.slice(firstKeyFrameIndex);
|
|
|
- videoTrack.dropped += firstKeyFrameIndex;
|
|
|
- videoTimeOffset += (videoTrack.samples[0].pts - startPTS) / videoTrack.inputTimeScale;
|
|
|
- firstKeyFramePTS = videoTimeOffset;
|
|
|
- } else if (firstKeyFrameIndex === -1) {
|
|
|
- this.warn(`No keyframe found out of ${length} video samples`);
|
|
|
- independent = false;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (this.ISGenerated) {
|
|
|
- if (enoughAudioSamples && enoughVideoSamples) {
|
|
|
- const startPTS = this.getVideoStartPts(videoTrack.samples);
|
|
|
- const tsDelta = normalizePts(audioTrack.samples[0].pts, startPTS) - startPTS;
|
|
|
- const audiovideoTimestampDelta = tsDelta / videoTrack.inputTimeScale;
|
|
|
- audioTimeOffset += Math.max(0, audiovideoTimestampDelta);
|
|
|
- videoTimeOffset += Math.max(0, -audiovideoTimestampDelta);
|
|
|
- }
|
|
|
- if (enoughAudioSamples) {
|
|
|
- if (!audioTrack.samplerate) {
|
|
|
- this.warn("regenerate InitSegment as audio detected");
|
|
|
- initSegment = this.generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset);
|
|
|
- }
|
|
|
- audio = this.remuxAudio(audioTrack, audioTimeOffset, this.isAudioContiguous, accurateTimeOffset, hasVideo || enoughVideoSamples || playlistType === PlaylistLevelType.AUDIO ? videoTimeOffset : void 0);
|
|
|
- if (enoughVideoSamples) {
|
|
|
- const audioTrackLength = audio ? audio.endPTS - audio.startPTS : 0;
|
|
|
- if (!videoTrack.inputTimeScale) {
|
|
|
- this.warn("regenerate InitSegment as video detected");
|
|
|
- initSegment = this.generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset);
|
|
|
- }
|
|
|
- video = this.remuxVideo(videoTrack, videoTimeOffset, isVideoContiguous, audioTrackLength);
|
|
|
- }
|
|
|
- } else if (enoughVideoSamples) {
|
|
|
- video = this.remuxVideo(videoTrack, videoTimeOffset, isVideoContiguous, 0);
|
|
|
- }
|
|
|
- if (video) {
|
|
|
- video.firstKeyFrame = firstKeyFrameIndex;
|
|
|
- video.independent = firstKeyFrameIndex !== -1;
|
|
|
- video.firstKeyFramePTS = firstKeyFramePTS;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (this.ISGenerated && this._initPTS && this._initDTS) {
|
|
|
- if (id3Track.samples.length) {
|
|
|
- id3 = flushTextTrackMetadataCueSamples(id3Track, timeOffset, this._initPTS, this._initDTS);
|
|
|
- }
|
|
|
- if (textTrack.samples.length) {
|
|
|
- text = flushTextTrackUserdataCueSamples(textTrack, timeOffset, this._initPTS);
|
|
|
- }
|
|
|
- }
|
|
|
- return {
|
|
|
- audio,
|
|
|
- video,
|
|
|
- initSegment,
|
|
|
- independent,
|
|
|
- text,
|
|
|
- id3
|
|
|
- };
|
|
|
- }
|
|
|
- computeInitPts(basetime, timescale, presentationTime, type) {
|
|
|
- const offset = Math.round(presentationTime * timescale);
|
|
|
- let timestamp = normalizePts(basetime, offset);
|
|
|
- if (timestamp < offset + timescale) {
|
|
|
- this.log(`Adjusting PTS for rollover in timeline near ${(offset - timestamp) / timescale} ${type}`);
|
|
|
- while (timestamp < offset + timescale) {
|
|
|
- timestamp += 8589934592;
|
|
|
- }
|
|
|
- }
|
|
|
- return timestamp - offset;
|
|
|
- }
|
|
|
- generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset) {
|
|
|
- const audioSamples = audioTrack.samples;
|
|
|
- const videoSamples = videoTrack.samples;
|
|
|
- const typeSupported = this.typeSupported;
|
|
|
- const tracks = {};
|
|
|
- const _initPTS = this._initPTS;
|
|
|
- let computePTSDTS = !_initPTS || accurateTimeOffset;
|
|
|
- let container = "audio/mp4";
|
|
|
- let initPTS;
|
|
|
- let initDTS;
|
|
|
- let timescale;
|
|
|
- let trackId = -1;
|
|
|
- if (computePTSDTS) {
|
|
|
- initPTS = initDTS = Infinity;
|
|
|
- }
|
|
|
- if (audioTrack.config && audioSamples.length) {
|
|
|
- audioTrack.timescale = audioTrack.samplerate;
|
|
|
- switch (audioTrack.segmentCodec) {
|
|
|
- case "mp3":
|
|
|
- if (typeSupported.mpeg) {
|
|
|
- container = "audio/mpeg";
|
|
|
- audioTrack.codec = "";
|
|
|
- } else if (typeSupported.mp3) {
|
|
|
- audioTrack.codec = "mp3";
|
|
|
- }
|
|
|
- break;
|
|
|
- case "ac3":
|
|
|
- audioTrack.codec = "ac-3";
|
|
|
- break;
|
|
|
- }
|
|
|
- tracks.audio = {
|
|
|
- id: "audio",
|
|
|
- container,
|
|
|
- codec: audioTrack.codec,
|
|
|
- initSegment: audioTrack.segmentCodec === "mp3" && typeSupported.mpeg ? new Uint8Array(0) : MP4.initSegment([audioTrack]),
|
|
|
- metadata: {
|
|
|
- channelCount: audioTrack.channelCount
|
|
|
- }
|
|
|
- };
|
|
|
- if (computePTSDTS) {
|
|
|
- trackId = audioTrack.id;
|
|
|
- timescale = audioTrack.inputTimeScale;
|
|
|
- if (!_initPTS || timescale !== _initPTS.timescale) {
|
|
|
- initPTS = initDTS = this.computeInitPts(audioSamples[0].pts, timescale, timeOffset, "audio");
|
|
|
- } else {
|
|
|
- computePTSDTS = false;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (videoTrack.sps && videoTrack.pps && videoSamples.length) {
|
|
|
- videoTrack.timescale = videoTrack.inputTimeScale;
|
|
|
- tracks.video = {
|
|
|
- id: "main",
|
|
|
- container: "video/mp4",
|
|
|
- codec: videoTrack.codec,
|
|
|
- initSegment: MP4.initSegment([videoTrack]),
|
|
|
- metadata: {
|
|
|
- width: videoTrack.width,
|
|
|
- height: videoTrack.height
|
|
|
- }
|
|
|
- };
|
|
|
- if (computePTSDTS) {
|
|
|
- trackId = videoTrack.id;
|
|
|
- timescale = videoTrack.inputTimeScale;
|
|
|
- if (!_initPTS || timescale !== _initPTS.timescale) {
|
|
|
- const basePTS = this.getVideoStartPts(videoSamples);
|
|
|
- const baseDTS = normalizePts(videoSamples[0].dts, basePTS);
|
|
|
- const videoInitDTS = this.computeInitPts(baseDTS, timescale, timeOffset, "video");
|
|
|
- const videoInitPTS = this.computeInitPts(basePTS, timescale, timeOffset, "video");
|
|
|
- initDTS = Math.min(initDTS, videoInitDTS);
|
|
|
- initPTS = Math.min(initPTS, videoInitPTS);
|
|
|
- } else {
|
|
|
- computePTSDTS = false;
|
|
|
- }
|
|
|
- }
|
|
|
- this.videoTrackConfig = {
|
|
|
- width: videoTrack.width,
|
|
|
- height: videoTrack.height,
|
|
|
- pixelRatio: videoTrack.pixelRatio
|
|
|
- };
|
|
|
- }
|
|
|
- if (Object.keys(tracks).length) {
|
|
|
- this.ISGenerated = true;
|
|
|
- if (computePTSDTS) {
|
|
|
- if (_initPTS) {
|
|
|
- this.warn(`Timestamps at playlist time: ${accurateTimeOffset ? "" : "~"}${timeOffset} ${initPTS / timescale} != initPTS: ${_initPTS.baseTime / _initPTS.timescale} (${_initPTS.baseTime}/${_initPTS.timescale}) trackId: ${_initPTS.trackId}`);
|
|
|
- }
|
|
|
- this.log(`Found initPTS at playlist time: ${timeOffset} offset: ${initPTS / timescale} (${initPTS}/${timescale}) trackId: ${trackId}`);
|
|
|
- this._initPTS = {
|
|
|
- baseTime: initPTS,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- };
|
|
|
- this._initDTS = {
|
|
|
- baseTime: initDTS,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- };
|
|
|
- } else {
|
|
|
- initPTS = timescale = void 0;
|
|
|
- }
|
|
|
- return {
|
|
|
- tracks,
|
|
|
- initPTS,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- remuxVideo(track, timeOffset, contiguous, audioTrackLength) {
|
|
|
- const timeScale = track.inputTimeScale;
|
|
|
- const inputSamples = track.samples;
|
|
|
- const outputSamples = [];
|
|
|
- const nbSamples = inputSamples.length;
|
|
|
- const initPTS = this._initPTS;
|
|
|
- const initTime = initPTS.baseTime * timeScale / initPTS.timescale;
|
|
|
- let nextVideoTs = this.nextVideoTs;
|
|
|
- let offset = 8;
|
|
|
- let mp4SampleDuration = this.videoSampleDuration;
|
|
|
- let firstDTS;
|
|
|
- let lastDTS;
|
|
|
- let minPTS = Number.POSITIVE_INFINITY;
|
|
|
- let maxPTS = Number.NEGATIVE_INFINITY;
|
|
|
- let sortSamples = false;
|
|
|
- if (!contiguous || nextVideoTs === null) {
|
|
|
- const pts = initTime + timeOffset * timeScale;
|
|
|
- const cts = inputSamples[0].pts - normalizePts(inputSamples[0].dts, inputSamples[0].pts);
|
|
|
- if (chromeVersion && nextVideoTs !== null && Math.abs(pts - cts - (nextVideoTs + initTime)) < 15e3) {
|
|
|
- contiguous = true;
|
|
|
- } else {
|
|
|
- nextVideoTs = pts - cts - initTime;
|
|
|
- }
|
|
|
- }
|
|
|
- const nextVideoPts = nextVideoTs + initTime;
|
|
|
- for (let i = 0; i < nbSamples; i++) {
|
|
|
- const sample = inputSamples[i];
|
|
|
- sample.pts = normalizePts(sample.pts, nextVideoPts);
|
|
|
- sample.dts = normalizePts(sample.dts, nextVideoPts);
|
|
|
- if (sample.dts < inputSamples[i > 0 ? i - 1 : i].dts) {
|
|
|
- sortSamples = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (sortSamples) {
|
|
|
- inputSamples.sort(function(a, b) {
|
|
|
- const deltadts = a.dts - b.dts;
|
|
|
- const deltapts = a.pts - b.pts;
|
|
|
- return deltadts || deltapts;
|
|
|
- });
|
|
|
- }
|
|
|
- firstDTS = inputSamples[0].dts;
|
|
|
- lastDTS = inputSamples[inputSamples.length - 1].dts;
|
|
|
- const inputDuration = lastDTS - firstDTS;
|
|
|
- const averageSampleDuration = inputDuration ? Math.round(inputDuration / (nbSamples - 1)) : mp4SampleDuration || track.inputTimeScale / 30;
|
|
|
- if (contiguous) {
|
|
|
- const delta = firstDTS - nextVideoPts;
|
|
|
- const foundHole = delta > averageSampleDuration;
|
|
|
- const foundOverlap = delta < -1;
|
|
|
- if (foundHole || foundOverlap) {
|
|
|
- if (foundHole) {
|
|
|
- this.warn(`${(track.segmentCodec || "").toUpperCase()}: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
|
|
|
- } else {
|
|
|
- this.warn(`${(track.segmentCodec || "").toUpperCase()}: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
|
|
|
- }
|
|
|
- if (!foundOverlap || nextVideoPts >= inputSamples[0].pts || chromeVersion) {
|
|
|
- firstDTS = nextVideoPts;
|
|
|
- const firstPTS = inputSamples[0].pts - delta;
|
|
|
- if (foundHole) {
|
|
|
- inputSamples[0].dts = firstDTS;
|
|
|
- inputSamples[0].pts = firstPTS;
|
|
|
- } else {
|
|
|
- let isPTSOrderRetained = true;
|
|
|
- for (let i = 0; i < inputSamples.length; i++) {
|
|
|
- if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
|
|
|
- break;
|
|
|
- }
|
|
|
- const prevPTS = inputSamples[i].pts;
|
|
|
- inputSamples[i].dts -= delta;
|
|
|
- inputSamples[i].pts -= delta;
|
|
|
- if (i < inputSamples.length - 1) {
|
|
|
- const nextSamplePTS = inputSamples[i + 1].pts;
|
|
|
- const currentSamplePTS = inputSamples[i].pts;
|
|
|
- const currentOrder = nextSamplePTS <= currentSamplePTS;
|
|
|
- const prevOrder = nextSamplePTS <= prevPTS;
|
|
|
- isPTSOrderRetained = currentOrder == prevOrder;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.log(`Video: Initial PTS/DTS adjusted: ${toMsFromMpegTsClock(firstPTS, true)}/${toMsFromMpegTsClock(firstDTS, true)}, delta: ${toMsFromMpegTsClock(delta, true)} ms`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- firstDTS = Math.max(0, firstDTS);
|
|
|
- let nbNalu = 0;
|
|
|
- let naluLen = 0;
|
|
|
- let dtsStep = firstDTS;
|
|
|
- for (let i = 0; i < nbSamples; i++) {
|
|
|
- const sample = inputSamples[i];
|
|
|
- const units = sample.units;
|
|
|
- const nbUnits = units.length;
|
|
|
- let sampleLen = 0;
|
|
|
- for (let j = 0; j < nbUnits; j++) {
|
|
|
- sampleLen += units[j].data.length;
|
|
|
- }
|
|
|
- naluLen += sampleLen;
|
|
|
- nbNalu += nbUnits;
|
|
|
- sample.length = sampleLen;
|
|
|
- if (sample.dts < dtsStep) {
|
|
|
- sample.dts = dtsStep;
|
|
|
- dtsStep += averageSampleDuration / 4 | 0 || 1;
|
|
|
- } else {
|
|
|
- dtsStep = sample.dts;
|
|
|
- }
|
|
|
- minPTS = Math.min(sample.pts, minPTS);
|
|
|
- maxPTS = Math.max(sample.pts, maxPTS);
|
|
|
- }
|
|
|
- lastDTS = inputSamples[nbSamples - 1].dts;
|
|
|
- const mdatSize = naluLen + 4 * nbNalu + 8;
|
|
|
- let mdat;
|
|
|
- try {
|
|
|
- mdat = new Uint8Array(mdatSize);
|
|
|
- } catch (err) {
|
|
|
- this.observer.emit(Events.ERROR, Events.ERROR, {
|
|
|
- type: ErrorTypes.MUX_ERROR,
|
|
|
- details: ErrorDetails.REMUX_ALLOC_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: err,
|
|
|
- bytes: mdatSize,
|
|
|
- reason: `fail allocating video mdat ${mdatSize}`
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- const view2 = new DataView(mdat.buffer);
|
|
|
- view2.setUint32(0, mdatSize);
|
|
|
- mdat.set(MP4.types.mdat, 4);
|
|
|
- let stretchedLastFrame = false;
|
|
|
- let minDtsDelta = Number.POSITIVE_INFINITY;
|
|
|
- let minPtsDelta = Number.POSITIVE_INFINITY;
|
|
|
- let maxDtsDelta = Number.NEGATIVE_INFINITY;
|
|
|
- let maxPtsDelta = Number.NEGATIVE_INFINITY;
|
|
|
- for (let i = 0; i < nbSamples; i++) {
|
|
|
- const VideoSample = inputSamples[i];
|
|
|
- const VideoSampleUnits = VideoSample.units;
|
|
|
- let mp4SampleLength = 0;
|
|
|
- for (let j = 0, nbUnits = VideoSampleUnits.length; j < nbUnits; j++) {
|
|
|
- const unit = VideoSampleUnits[j];
|
|
|
- const unitData = unit.data;
|
|
|
- const unitDataLen = unit.data.byteLength;
|
|
|
- view2.setUint32(offset, unitDataLen);
|
|
|
- offset += 4;
|
|
|
- mdat.set(unitData, offset);
|
|
|
- offset += unitDataLen;
|
|
|
- mp4SampleLength += 4 + unitDataLen;
|
|
|
- }
|
|
|
- let ptsDelta;
|
|
|
- if (i < nbSamples - 1) {
|
|
|
- mp4SampleDuration = inputSamples[i + 1].dts - VideoSample.dts;
|
|
|
- ptsDelta = inputSamples[i + 1].pts - VideoSample.pts;
|
|
|
- } else {
|
|
|
- const config = this.config;
|
|
|
- const lastFrameDuration = i > 0 ? VideoSample.dts - inputSamples[i - 1].dts : averageSampleDuration;
|
|
|
- ptsDelta = i > 0 ? VideoSample.pts - inputSamples[i - 1].pts : averageSampleDuration;
|
|
|
- if (config.stretchShortVideoTrack && this.nextAudioTs !== null) {
|
|
|
- const gapTolerance = Math.floor(config.maxBufferHole * timeScale);
|
|
|
- const deltaToFrameEnd = (audioTrackLength ? minPTS + audioTrackLength * timeScale : this.nextAudioTs + initTime) - VideoSample.pts;
|
|
|
- if (deltaToFrameEnd > gapTolerance) {
|
|
|
- mp4SampleDuration = deltaToFrameEnd - lastFrameDuration;
|
|
|
- if (mp4SampleDuration < 0) {
|
|
|
- mp4SampleDuration = lastFrameDuration;
|
|
|
- } else {
|
|
|
- stretchedLastFrame = true;
|
|
|
- }
|
|
|
- this.log(`It is approximately ${deltaToFrameEnd / 90} ms to the next segment; using duration ${mp4SampleDuration / 90} ms for the last video frame.`);
|
|
|
- } else {
|
|
|
- mp4SampleDuration = lastFrameDuration;
|
|
|
- }
|
|
|
- } else {
|
|
|
- mp4SampleDuration = lastFrameDuration;
|
|
|
- }
|
|
|
- }
|
|
|
- const compositionTimeOffset = Math.round(VideoSample.pts - VideoSample.dts);
|
|
|
- minDtsDelta = Math.min(minDtsDelta, mp4SampleDuration);
|
|
|
- maxDtsDelta = Math.max(maxDtsDelta, mp4SampleDuration);
|
|
|
- minPtsDelta = Math.min(minPtsDelta, ptsDelta);
|
|
|
- maxPtsDelta = Math.max(maxPtsDelta, ptsDelta);
|
|
|
- outputSamples.push(createMp4Sample(VideoSample.key, mp4SampleDuration, mp4SampleLength, compositionTimeOffset));
|
|
|
- }
|
|
|
- if (outputSamples.length) {
|
|
|
- if (chromeVersion) {
|
|
|
- if (chromeVersion < 70) {
|
|
|
- const flags = outputSamples[0].flags;
|
|
|
- flags.dependsOn = 2;
|
|
|
- flags.isNonSync = 0;
|
|
|
- }
|
|
|
- } else if (safariWebkitVersion) {
|
|
|
- if (maxPtsDelta - minPtsDelta < maxDtsDelta - minDtsDelta && averageSampleDuration / maxDtsDelta < 0.025 && outputSamples[0].cts === 0) {
|
|
|
- this.warn("Found irregular gaps in sample duration. Using PTS instead of DTS to determine MP4 sample duration.");
|
|
|
- let dts = firstDTS;
|
|
|
- for (let i = 0, len = outputSamples.length; i < len; i++) {
|
|
|
- const nextDts = dts + outputSamples[i].duration;
|
|
|
- const pts = dts + outputSamples[i].cts;
|
|
|
- if (i < len - 1) {
|
|
|
- const nextPts = nextDts + outputSamples[i + 1].cts;
|
|
|
- outputSamples[i].duration = nextPts - pts;
|
|
|
- } else {
|
|
|
- outputSamples[i].duration = i ? outputSamples[i - 1].duration : averageSampleDuration;
|
|
|
- }
|
|
|
- outputSamples[i].cts = 0;
|
|
|
- dts = nextDts;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- mp4SampleDuration = stretchedLastFrame || !mp4SampleDuration ? averageSampleDuration : mp4SampleDuration;
|
|
|
- const endDTS = lastDTS + mp4SampleDuration;
|
|
|
- this.nextVideoTs = nextVideoTs = endDTS - initTime;
|
|
|
- this.videoSampleDuration = mp4SampleDuration;
|
|
|
- this.isVideoContiguous = true;
|
|
|
- const moof = MP4.moof(track.sequenceNumber++, firstDTS, _extends(track, {
|
|
|
- samples: outputSamples
|
|
|
- }));
|
|
|
- const type = "video";
|
|
|
- const data = {
|
|
|
- data1: moof,
|
|
|
- data2: mdat,
|
|
|
- startPTS: (minPTS - initTime) / timeScale,
|
|
|
- endPTS: (maxPTS + mp4SampleDuration - initTime) / timeScale,
|
|
|
- startDTS: (firstDTS - initTime) / timeScale,
|
|
|
- endDTS: nextVideoTs / timeScale,
|
|
|
- type,
|
|
|
- hasAudio: false,
|
|
|
- hasVideo: true,
|
|
|
- nb: outputSamples.length,
|
|
|
- dropped: track.dropped
|
|
|
- };
|
|
|
- track.samples = [];
|
|
|
- track.dropped = 0;
|
|
|
- return data;
|
|
|
- }
|
|
|
- getSamplesPerFrame(track) {
|
|
|
- switch (track.segmentCodec) {
|
|
|
- case "mp3":
|
|
|
- return MPEG_AUDIO_SAMPLE_PER_FRAME;
|
|
|
- case "ac3":
|
|
|
- return AC3_SAMPLES_PER_FRAME;
|
|
|
- default:
|
|
|
- return AAC_SAMPLES_PER_FRAME;
|
|
|
- }
|
|
|
- }
|
|
|
- remuxAudio(track, timeOffset, contiguous, accurateTimeOffset, videoTimeOffset) {
|
|
|
- const inputTimeScale = track.inputTimeScale;
|
|
|
- const mp4timeScale = track.samplerate ? track.samplerate : inputTimeScale;
|
|
|
- const scaleFactor = inputTimeScale / mp4timeScale;
|
|
|
- const mp4SampleDuration = this.getSamplesPerFrame(track);
|
|
|
- const inputSampleDuration = mp4SampleDuration * scaleFactor;
|
|
|
- const initPTS = this._initPTS;
|
|
|
- const rawMPEG = track.segmentCodec === "mp3" && this.typeSupported.mpeg;
|
|
|
- const outputSamples = [];
|
|
|
- const alignedWithVideo = videoTimeOffset !== void 0;
|
|
|
- let inputSamples = track.samples;
|
|
|
- let offset = rawMPEG ? 0 : 8;
|
|
|
- let nextAudioTs = this.nextAudioTs || -1;
|
|
|
- const initTime = initPTS.baseTime * inputTimeScale / initPTS.timescale;
|
|
|
- const timeOffsetMpegTS = initTime + timeOffset * inputTimeScale;
|
|
|
- this.isAudioContiguous = contiguous = contiguous || inputSamples.length && nextAudioTs > 0 && (accurateTimeOffset && Math.abs(timeOffsetMpegTS - (nextAudioTs + initTime)) < 9e3 || Math.abs(normalizePts(inputSamples[0].pts, timeOffsetMpegTS) - (nextAudioTs + initTime)) < 20 * inputSampleDuration);
|
|
|
- inputSamples.forEach(function(sample) {
|
|
|
- sample.pts = normalizePts(sample.pts, timeOffsetMpegTS);
|
|
|
- });
|
|
|
- if (!contiguous || nextAudioTs < 0) {
|
|
|
- const sampleCount = inputSamples.length;
|
|
|
- inputSamples = inputSamples.filter((sample) => sample.pts >= 0);
|
|
|
- if (sampleCount !== inputSamples.length) {
|
|
|
- this.warn(`Removed ${inputSamples.length - sampleCount} of ${sampleCount} samples (initPTS ${initTime} / ${inputTimeScale})`);
|
|
|
- }
|
|
|
- if (!inputSamples.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (videoTimeOffset === 0) {
|
|
|
- nextAudioTs = 0;
|
|
|
- } else if (accurateTimeOffset && !alignedWithVideo) {
|
|
|
- nextAudioTs = Math.max(0, timeOffsetMpegTS - initTime);
|
|
|
- } else {
|
|
|
- nextAudioTs = inputSamples[0].pts - initTime;
|
|
|
- }
|
|
|
- }
|
|
|
- if (track.segmentCodec === "aac") {
|
|
|
- const maxAudioFramesDrift = this.config.maxAudioFramesDrift;
|
|
|
- for (let i = 0, nextPts = nextAudioTs + initTime; i < inputSamples.length; i++) {
|
|
|
- const sample = inputSamples[i];
|
|
|
- const pts = sample.pts;
|
|
|
- const delta = pts - nextPts;
|
|
|
- const duration = Math.abs(1e3 * delta / inputTimeScale);
|
|
|
- if (delta <= -maxAudioFramesDrift * inputSampleDuration && alignedWithVideo) {
|
|
|
- if (i === 0) {
|
|
|
- this.warn(`Audio frame @ ${(pts / inputTimeScale).toFixed(3)}s overlaps marker by ${Math.round(1e3 * delta / inputTimeScale)} ms.`);
|
|
|
- this.nextAudioTs = nextAudioTs = pts - initTime;
|
|
|
- nextPts = pts;
|
|
|
- }
|
|
|
- } else if (delta >= maxAudioFramesDrift * inputSampleDuration && duration < MAX_SILENT_FRAME_DURATION && alignedWithVideo) {
|
|
|
- let missing = Math.round(delta / inputSampleDuration);
|
|
|
- nextPts = pts - missing * inputSampleDuration;
|
|
|
- while (nextPts < 0 && missing && inputSampleDuration) {
|
|
|
- missing--;
|
|
|
- nextPts += inputSampleDuration;
|
|
|
- }
|
|
|
- if (i === 0) {
|
|
|
- this.nextAudioTs = nextAudioTs = nextPts - initTime;
|
|
|
- }
|
|
|
- this.warn(`Injecting ${missing} audio frames @ ${((nextPts - initTime) / inputTimeScale).toFixed(3)}s due to ${Math.round(1e3 * delta / inputTimeScale)} ms gap.`);
|
|
|
- for (let j = 0; j < missing; j++) {
|
|
|
- let fillFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
|
|
|
- if (!fillFrame) {
|
|
|
- this.log("Unable to get silent frame for given audio codec; duplicating last frame instead.");
|
|
|
- fillFrame = sample.unit.subarray();
|
|
|
- }
|
|
|
- inputSamples.splice(i, 0, {
|
|
|
- unit: fillFrame,
|
|
|
- pts: nextPts
|
|
|
- });
|
|
|
- nextPts += inputSampleDuration;
|
|
|
- i++;
|
|
|
- }
|
|
|
- }
|
|
|
- sample.pts = nextPts;
|
|
|
- nextPts += inputSampleDuration;
|
|
|
- }
|
|
|
- }
|
|
|
- let firstPTS = null;
|
|
|
- let lastPTS = null;
|
|
|
- let mdat;
|
|
|
- let mdatSize = 0;
|
|
|
- let sampleLength = inputSamples.length;
|
|
|
- while (sampleLength--) {
|
|
|
- mdatSize += inputSamples[sampleLength].unit.byteLength;
|
|
|
- }
|
|
|
- for (let j = 0, _nbSamples = inputSamples.length; j < _nbSamples; j++) {
|
|
|
- const audioSample = inputSamples[j];
|
|
|
- const unit = audioSample.unit;
|
|
|
- let pts = audioSample.pts;
|
|
|
- if (lastPTS !== null) {
|
|
|
- const prevSample = outputSamples[j - 1];
|
|
|
- prevSample.duration = Math.round((pts - lastPTS) / scaleFactor);
|
|
|
- } else {
|
|
|
- if (contiguous && track.segmentCodec === "aac") {
|
|
|
- pts = nextAudioTs + initTime;
|
|
|
- }
|
|
|
- firstPTS = pts;
|
|
|
- if (mdatSize > 0) {
|
|
|
- mdatSize += offset;
|
|
|
- try {
|
|
|
- mdat = new Uint8Array(mdatSize);
|
|
|
- } catch (err) {
|
|
|
- this.observer.emit(Events.ERROR, Events.ERROR, {
|
|
|
- type: ErrorTypes.MUX_ERROR,
|
|
|
- details: ErrorDetails.REMUX_ALLOC_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: err,
|
|
|
- bytes: mdatSize,
|
|
|
- reason: `fail allocating audio mdat ${mdatSize}`
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!rawMPEG) {
|
|
|
- const view2 = new DataView(mdat.buffer);
|
|
|
- view2.setUint32(0, mdatSize);
|
|
|
- mdat.set(MP4.types.mdat, 4);
|
|
|
- }
|
|
|
- } else {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- mdat.set(unit, offset);
|
|
|
- const unitLen = unit.byteLength;
|
|
|
- offset += unitLen;
|
|
|
- outputSamples.push(createMp4Sample(true, mp4SampleDuration, unitLen, 0));
|
|
|
- lastPTS = pts;
|
|
|
- }
|
|
|
- const nbSamples = outputSamples.length;
|
|
|
- if (!nbSamples) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const lastSample = outputSamples[outputSamples.length - 1];
|
|
|
- nextAudioTs = lastPTS - initTime;
|
|
|
- this.nextAudioTs = nextAudioTs + scaleFactor * lastSample.duration;
|
|
|
- const moof = rawMPEG ? new Uint8Array(0) : MP4.moof(track.sequenceNumber++, firstPTS / scaleFactor, _extends({}, track, {
|
|
|
- samples: outputSamples
|
|
|
- }));
|
|
|
- track.samples = [];
|
|
|
- const start = (firstPTS - initTime) / inputTimeScale;
|
|
|
- const end = nextAudioTs / inputTimeScale;
|
|
|
- const type = "audio";
|
|
|
- const audioData = {
|
|
|
- data1: moof,
|
|
|
- data2: mdat,
|
|
|
- startPTS: start,
|
|
|
- endPTS: end,
|
|
|
- startDTS: start,
|
|
|
- endDTS: end,
|
|
|
- type,
|
|
|
- hasAudio: true,
|
|
|
- hasVideo: false,
|
|
|
- nb: nbSamples
|
|
|
- };
|
|
|
- this.isAudioContiguous = true;
|
|
|
- return audioData;
|
|
|
- }
|
|
|
-};
|
|
|
-function normalizePts(value, reference) {
|
|
|
- let offset;
|
|
|
- if (reference === null) {
|
|
|
- return value;
|
|
|
- }
|
|
|
- if (reference < value) {
|
|
|
- offset = -8589934592;
|
|
|
- } else {
|
|
|
- offset = 8589934592;
|
|
|
- }
|
|
|
- while (Math.abs(value - reference) > 4294967296) {
|
|
|
- value += offset;
|
|
|
- }
|
|
|
- return value;
|
|
|
-}
|
|
|
-function findKeyframeIndex(samples) {
|
|
|
- for (let i = 0; i < samples.length; i++) {
|
|
|
- if (samples[i].key) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
-}
|
|
|
-function flushTextTrackMetadataCueSamples(track, timeOffset, initPTS, initDTS) {
|
|
|
- const length = track.samples.length;
|
|
|
- if (!length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const inputTimeScale = track.inputTimeScale;
|
|
|
- for (let index = 0; index < length; index++) {
|
|
|
- const sample = track.samples[index];
|
|
|
- sample.pts = normalizePts(sample.pts - initPTS.baseTime * inputTimeScale / initPTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
|
|
|
- sample.dts = normalizePts(sample.dts - initDTS.baseTime * inputTimeScale / initDTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
|
|
|
- }
|
|
|
- const samples = track.samples;
|
|
|
- track.samples = [];
|
|
|
- return {
|
|
|
- samples
|
|
|
- };
|
|
|
-}
|
|
|
-function flushTextTrackUserdataCueSamples(track, timeOffset, initPTS) {
|
|
|
- const length = track.samples.length;
|
|
|
- if (!length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const inputTimeScale = track.inputTimeScale;
|
|
|
- for (let index = 0; index < length; index++) {
|
|
|
- const sample = track.samples[index];
|
|
|
- sample.pts = normalizePts(sample.pts - initPTS.baseTime * inputTimeScale / initPTS.timescale, timeOffset * inputTimeScale) / inputTimeScale;
|
|
|
- }
|
|
|
- track.samples.sort((a, b) => a.pts - b.pts);
|
|
|
- const samples = track.samples;
|
|
|
- track.samples = [];
|
|
|
- return {
|
|
|
- samples
|
|
|
- };
|
|
|
-}
|
|
|
-var PassThroughRemuxer = class extends Logger {
|
|
|
- constructor(observer, config, typeSupported, logger2) {
|
|
|
- super("passthrough-remuxer", logger2);
|
|
|
- this.emitInitSegment = false;
|
|
|
- this.audioCodec = void 0;
|
|
|
- this.videoCodec = void 0;
|
|
|
- this.initData = void 0;
|
|
|
- this.initPTS = null;
|
|
|
- this.initTracks = void 0;
|
|
|
- this.lastEndTime = null;
|
|
|
- this.isVideoContiguous = false;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- }
|
|
|
- resetTimeStamp(defaultInitPTS) {
|
|
|
- this.lastEndTime = null;
|
|
|
- const initPTS = this.initPTS;
|
|
|
- if (initPTS && defaultInitPTS) {
|
|
|
- if (initPTS.baseTime === defaultInitPTS.baseTime && initPTS.timescale === defaultInitPTS.timescale) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.initPTS = defaultInitPTS;
|
|
|
- }
|
|
|
- resetNextTimestamp() {
|
|
|
- this.isVideoContiguous = false;
|
|
|
- this.lastEndTime = null;
|
|
|
- }
|
|
|
- resetInitSegment(initSegment, audioCodec, videoCodec, decryptdata) {
|
|
|
- this.audioCodec = audioCodec;
|
|
|
- this.videoCodec = videoCodec;
|
|
|
- this.generateInitSegment(initSegment, decryptdata);
|
|
|
- this.emitInitSegment = true;
|
|
|
- }
|
|
|
- generateInitSegment(initSegment, decryptdata) {
|
|
|
- let {
|
|
|
- audioCodec,
|
|
|
- videoCodec
|
|
|
- } = this;
|
|
|
- if (!(initSegment != null && initSegment.byteLength)) {
|
|
|
- this.initTracks = void 0;
|
|
|
- this.initData = void 0;
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- audio,
|
|
|
- video
|
|
|
- } = this.initData = parseInitSegment(initSegment);
|
|
|
- if (decryptdata) {
|
|
|
- patchEncyptionData(initSegment, decryptdata);
|
|
|
- } else {
|
|
|
- const eitherTrack = audio || video;
|
|
|
- if (eitherTrack != null && eitherTrack.encrypted) {
|
|
|
- this.warn(`Init segment with encrypted track with has no key ("${eitherTrack.codec}")!`);
|
|
|
- }
|
|
|
- }
|
|
|
- if (audio) {
|
|
|
- audioCodec = getParsedTrackCodec(audio, ElementaryStreamTypes.AUDIO, this);
|
|
|
- }
|
|
|
- if (video) {
|
|
|
- videoCodec = getParsedTrackCodec(video, ElementaryStreamTypes.VIDEO, this);
|
|
|
- }
|
|
|
- const tracks = {};
|
|
|
- if (audio && video) {
|
|
|
- tracks.audiovideo = {
|
|
|
- container: "video/mp4",
|
|
|
- codec: audioCodec + "," + videoCodec,
|
|
|
- supplemental: video.supplemental,
|
|
|
- encrypted: video.encrypted,
|
|
|
- initSegment,
|
|
|
- id: "main"
|
|
|
- };
|
|
|
- } else if (audio) {
|
|
|
- tracks.audio = {
|
|
|
- container: "audio/mp4",
|
|
|
- codec: audioCodec,
|
|
|
- encrypted: audio.encrypted,
|
|
|
- initSegment,
|
|
|
- id: "audio"
|
|
|
- };
|
|
|
- } else if (video) {
|
|
|
- tracks.video = {
|
|
|
- container: "video/mp4",
|
|
|
- codec: videoCodec,
|
|
|
- supplemental: video.supplemental,
|
|
|
- encrypted: video.encrypted,
|
|
|
- initSegment,
|
|
|
- id: "main"
|
|
|
- };
|
|
|
- } else {
|
|
|
- this.warn("initSegment does not contain moov or trak boxes.");
|
|
|
- }
|
|
|
- this.initTracks = tracks;
|
|
|
- }
|
|
|
- remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset, accurateTimeOffset) {
|
|
|
- var _initData, _initData2;
|
|
|
- let {
|
|
|
- initPTS,
|
|
|
- lastEndTime
|
|
|
- } = this;
|
|
|
- const result = {
|
|
|
- audio: void 0,
|
|
|
- video: void 0,
|
|
|
- text: textTrack,
|
|
|
- id3: id3Track,
|
|
|
- initSegment: void 0
|
|
|
- };
|
|
|
- if (!isFiniteNumber(lastEndTime)) {
|
|
|
- lastEndTime = this.lastEndTime = timeOffset || 0;
|
|
|
- }
|
|
|
- const data = videoTrack.samples;
|
|
|
- if (!data.length) {
|
|
|
- return result;
|
|
|
- }
|
|
|
- const initSegment = {
|
|
|
- initPTS: void 0,
|
|
|
- timescale: void 0,
|
|
|
- trackId: void 0
|
|
|
- };
|
|
|
- let initData = this.initData;
|
|
|
- if (!((_initData = initData) != null && _initData.length)) {
|
|
|
- this.generateInitSegment(data);
|
|
|
- initData = this.initData;
|
|
|
- }
|
|
|
- if (!((_initData2 = initData) != null && _initData2.length)) {
|
|
|
- this.warn("Failed to generate initSegment.");
|
|
|
- return result;
|
|
|
- }
|
|
|
- if (this.emitInitSegment) {
|
|
|
- initSegment.tracks = this.initTracks;
|
|
|
- this.emitInitSegment = false;
|
|
|
- }
|
|
|
- const trackSampleData = getSampleData(data, initData, this);
|
|
|
- const audioSampleTimestamps = initData.audio ? trackSampleData[initData.audio.id] : null;
|
|
|
- const videoSampleTimestamps = initData.video ? trackSampleData[initData.video.id] : null;
|
|
|
- const videoStartTime = toStartEndOrDefault(videoSampleTimestamps, Infinity);
|
|
|
- const audioStartTime = toStartEndOrDefault(audioSampleTimestamps, Infinity);
|
|
|
- const videoEndTime = toStartEndOrDefault(videoSampleTimestamps, 0, true);
|
|
|
- const audioEndTime = toStartEndOrDefault(audioSampleTimestamps, 0, true);
|
|
|
- let decodeTime = timeOffset;
|
|
|
- let duration = 0;
|
|
|
- const syncOnAudio = audioSampleTimestamps && (!videoSampleTimestamps || !initPTS && audioStartTime < videoStartTime || initPTS && initPTS.trackId === initData.audio.id);
|
|
|
- const baseOffsetSamples = syncOnAudio ? audioSampleTimestamps : videoSampleTimestamps;
|
|
|
- if (baseOffsetSamples) {
|
|
|
- const timescale = baseOffsetSamples.timescale;
|
|
|
- const baseTime = baseOffsetSamples.start - timeOffset * timescale;
|
|
|
- const trackId = syncOnAudio ? initData.audio.id : initData.video.id;
|
|
|
- decodeTime = baseOffsetSamples.start / timescale;
|
|
|
- duration = syncOnAudio ? audioEndTime - audioStartTime : videoEndTime - videoStartTime;
|
|
|
- if ((accurateTimeOffset || !initPTS) && (isInvalidInitPts(initPTS, decodeTime, timeOffset, duration) || timescale !== initPTS.timescale)) {
|
|
|
- if (initPTS) {
|
|
|
- this.warn(`Timestamps at playlist time: ${accurateTimeOffset ? "" : "~"}${timeOffset} ${baseTime / timescale} != initPTS: ${initPTS.baseTime / initPTS.timescale} (${initPTS.baseTime}/${initPTS.timescale}) trackId: ${initPTS.trackId}`);
|
|
|
- }
|
|
|
- this.log(`Found initPTS at playlist time: ${timeOffset} offset: ${decodeTime - timeOffset} (${baseTime}/${timescale}) trackId: ${trackId}`);
|
|
|
- initPTS = null;
|
|
|
- initSegment.initPTS = baseTime;
|
|
|
- initSegment.timescale = timescale;
|
|
|
- initSegment.trackId = trackId;
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.warn(`No audio or video samples found for initPTS at playlist time: ${timeOffset}`);
|
|
|
- }
|
|
|
- if (!initPTS) {
|
|
|
- if (!initSegment.timescale || initSegment.trackId === void 0 || initSegment.initPTS === void 0) {
|
|
|
- this.warn("Could not set initPTS");
|
|
|
- initSegment.initPTS = decodeTime;
|
|
|
- initSegment.timescale = 1;
|
|
|
- initSegment.trackId = -1;
|
|
|
- }
|
|
|
- this.initPTS = initPTS = {
|
|
|
- baseTime: initSegment.initPTS,
|
|
|
- timescale: initSegment.timescale,
|
|
|
- trackId: initSegment.trackId
|
|
|
- };
|
|
|
- } else {
|
|
|
- initSegment.initPTS = initPTS.baseTime;
|
|
|
- initSegment.timescale = initPTS.timescale;
|
|
|
- initSegment.trackId = initPTS.trackId;
|
|
|
- }
|
|
|
- const startTime = decodeTime - initPTS.baseTime / initPTS.timescale;
|
|
|
- const endTime = startTime + duration;
|
|
|
- if (duration > 0) {
|
|
|
- this.lastEndTime = endTime;
|
|
|
- } else {
|
|
|
- this.warn("Duration parsed from mp4 should be greater than zero");
|
|
|
- this.resetNextTimestamp();
|
|
|
- }
|
|
|
- const hasAudio = !!initData.audio;
|
|
|
- const hasVideo = !!initData.video;
|
|
|
- let type = "";
|
|
|
- if (hasAudio) {
|
|
|
- type += "audio";
|
|
|
- }
|
|
|
- if (hasVideo) {
|
|
|
- type += "video";
|
|
|
- }
|
|
|
- const encrypted = (initData.audio ? initData.audio.encrypted : false) || (initData.video ? initData.video.encrypted : false);
|
|
|
- const track = {
|
|
|
- data1: data,
|
|
|
- startPTS: startTime,
|
|
|
- startDTS: startTime,
|
|
|
- endPTS: endTime,
|
|
|
- endDTS: endTime,
|
|
|
- type,
|
|
|
- hasAudio,
|
|
|
- hasVideo,
|
|
|
- nb: 1,
|
|
|
- dropped: 0,
|
|
|
- encrypted
|
|
|
- };
|
|
|
- result.audio = hasAudio && !hasVideo ? track : void 0;
|
|
|
- result.video = hasVideo ? track : void 0;
|
|
|
- const videoSampleCount = videoSampleTimestamps == null ? void 0 : videoSampleTimestamps.sampleCount;
|
|
|
- if (videoSampleCount) {
|
|
|
- const firstKeyFrame = videoSampleTimestamps.keyFrameIndex;
|
|
|
- const independent = firstKeyFrame !== -1;
|
|
|
- track.nb = videoSampleCount;
|
|
|
- track.dropped = firstKeyFrame === 0 || this.isVideoContiguous ? 0 : independent ? firstKeyFrame : videoSampleCount;
|
|
|
- track.independent = independent;
|
|
|
- track.firstKeyFrame = firstKeyFrame;
|
|
|
- if (independent && videoSampleTimestamps.keyFrameStart) {
|
|
|
- track.firstKeyFramePTS = (videoSampleTimestamps.keyFrameStart - initPTS.baseTime) / initPTS.timescale;
|
|
|
- }
|
|
|
- if (!this.isVideoContiguous) {
|
|
|
- result.independent = independent;
|
|
|
- }
|
|
|
- this.isVideoContiguous || (this.isVideoContiguous = independent);
|
|
|
- if (track.dropped) {
|
|
|
- this.warn(`fmp4 does not start with IDR: firstIDR ${firstKeyFrame}/${videoSampleCount} dropped: ${track.dropped} start: ${track.firstKeyFramePTS || "NA"}`);
|
|
|
- }
|
|
|
- }
|
|
|
- result.initSegment = initSegment;
|
|
|
- result.id3 = flushTextTrackMetadataCueSamples(id3Track, timeOffset, initPTS, initPTS);
|
|
|
- if (textTrack.samples.length) {
|
|
|
- result.text = flushTextTrackUserdataCueSamples(textTrack, timeOffset, initPTS);
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
-};
|
|
|
-function toStartEndOrDefault(trackTimes, defaultValue, end = false) {
|
|
|
- return (trackTimes == null ? void 0 : trackTimes.start) !== void 0 ? (trackTimes.start + (end ? trackTimes.duration : 0)) / trackTimes.timescale : defaultValue;
|
|
|
-}
|
|
|
-function isInvalidInitPts(initPTS, startDTS, timeOffset, duration) {
|
|
|
- if (initPTS === null) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- const minDuration = Math.max(duration, 1);
|
|
|
- const startTime = startDTS - initPTS.baseTime / initPTS.timescale;
|
|
|
- return Math.abs(startTime - timeOffset) > minDuration;
|
|
|
-}
|
|
|
-function getParsedTrackCodec(track, type, logger2) {
|
|
|
- const parsedCodec = track.codec;
|
|
|
- if (parsedCodec && parsedCodec.length > 4) {
|
|
|
- return parsedCodec;
|
|
|
- }
|
|
|
- if (type === ElementaryStreamTypes.AUDIO) {
|
|
|
- if (parsedCodec === "ec-3" || parsedCodec === "ac-3" || parsedCodec === "alac") {
|
|
|
- return parsedCodec;
|
|
|
- }
|
|
|
- if (parsedCodec === "fLaC" || parsedCodec === "Opus") {
|
|
|
- const preferManagedMediaSource = false;
|
|
|
- return getCodecCompatibleName(parsedCodec, preferManagedMediaSource);
|
|
|
- }
|
|
|
- logger2.warn(`Unhandled audio codec "${parsedCodec}" in mp4 MAP`);
|
|
|
- return parsedCodec || "mp4a";
|
|
|
- }
|
|
|
- logger2.warn(`Unhandled video codec "${parsedCodec}" in mp4 MAP`);
|
|
|
- return parsedCodec || "avc1";
|
|
|
-}
|
|
|
-var now;
|
|
|
-try {
|
|
|
- now = self.performance.now.bind(self.performance);
|
|
|
-} catch (err) {
|
|
|
- now = Date.now;
|
|
|
-}
|
|
|
-var muxConfig = [{
|
|
|
- demux: MP4Demuxer,
|
|
|
- remux: PassThroughRemuxer
|
|
|
-}, {
|
|
|
- demux: TSDemuxer,
|
|
|
- remux: MP4Remuxer
|
|
|
-}, {
|
|
|
- demux: AACDemuxer,
|
|
|
- remux: MP4Remuxer
|
|
|
-}, {
|
|
|
- demux: MP3Demuxer,
|
|
|
- remux: MP4Remuxer
|
|
|
-}];
|
|
|
-{
|
|
|
- muxConfig.splice(2, 0, {
|
|
|
- demux: AC3Demuxer,
|
|
|
- remux: MP4Remuxer
|
|
|
- });
|
|
|
-}
|
|
|
-var Transmuxer = class {
|
|
|
- constructor(observer, typeSupported, config, vendor, id, logger2) {
|
|
|
- this.asyncResult = false;
|
|
|
- this.logger = void 0;
|
|
|
- this.observer = void 0;
|
|
|
- this.typeSupported = void 0;
|
|
|
- this.config = void 0;
|
|
|
- this.id = void 0;
|
|
|
- this.demuxer = void 0;
|
|
|
- this.remuxer = void 0;
|
|
|
- this.decrypter = void 0;
|
|
|
- this.probe = void 0;
|
|
|
- this.decryptionPromise = null;
|
|
|
- this.transmuxConfig = void 0;
|
|
|
- this.currentTransmuxState = void 0;
|
|
|
- this.observer = observer;
|
|
|
- this.typeSupported = typeSupported;
|
|
|
- this.config = config;
|
|
|
- this.id = id;
|
|
|
- this.logger = logger2;
|
|
|
- }
|
|
|
- configure(transmuxConfig) {
|
|
|
- this.transmuxConfig = transmuxConfig;
|
|
|
- if (this.decrypter) {
|
|
|
- this.decrypter.reset();
|
|
|
- }
|
|
|
- }
|
|
|
- push(data, decryptdata, chunkMeta, state) {
|
|
|
- const stats = chunkMeta.transmuxing;
|
|
|
- stats.executeStart = now();
|
|
|
- let uintData = new Uint8Array(data);
|
|
|
- const {
|
|
|
- currentTransmuxState,
|
|
|
- transmuxConfig
|
|
|
- } = this;
|
|
|
- if (state) {
|
|
|
- this.currentTransmuxState = state;
|
|
|
- }
|
|
|
- const {
|
|
|
- contiguous,
|
|
|
- discontinuity,
|
|
|
- trackSwitch,
|
|
|
- accurateTimeOffset,
|
|
|
- timeOffset,
|
|
|
- initSegmentChange
|
|
|
- } = state || currentTransmuxState;
|
|
|
- const {
|
|
|
- audioCodec,
|
|
|
- videoCodec,
|
|
|
- defaultInitPts,
|
|
|
- duration,
|
|
|
- initSegmentData
|
|
|
- } = transmuxConfig;
|
|
|
- const keyData = getEncryptionType(uintData, decryptdata);
|
|
|
- if (keyData && isFullSegmentEncryption(keyData.method)) {
|
|
|
- const decrypter = this.getDecrypter();
|
|
|
- const aesMode = getAesModeFromFullSegmentMethod(keyData.method);
|
|
|
- if (decrypter.isSync()) {
|
|
|
- let decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode);
|
|
|
- const loadingParts = chunkMeta.part > -1;
|
|
|
- if (loadingParts) {
|
|
|
- const _data = decrypter.flush();
|
|
|
- decryptedData = _data ? _data.buffer : _data;
|
|
|
- }
|
|
|
- if (!decryptedData) {
|
|
|
- stats.executeEnd = now();
|
|
|
- return emptyResult(chunkMeta);
|
|
|
- }
|
|
|
- uintData = new Uint8Array(decryptedData);
|
|
|
- } else {
|
|
|
- this.asyncResult = true;
|
|
|
- this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).then((decryptedData) => {
|
|
|
- const result2 = this.push(decryptedData, null, chunkMeta);
|
|
|
- this.decryptionPromise = null;
|
|
|
- return result2;
|
|
|
- });
|
|
|
- return this.decryptionPromise;
|
|
|
- }
|
|
|
- }
|
|
|
- const resetMuxers = this.needsProbing(discontinuity, trackSwitch);
|
|
|
- if (resetMuxers) {
|
|
|
- const error = this.configureTransmuxer(uintData);
|
|
|
- if (error) {
|
|
|
- this.logger.warn(`[transmuxer] ${error.message}`);
|
|
|
- this.observer.emit(Events.ERROR, Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_PARSING_ERROR,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- reason: error.message
|
|
|
- });
|
|
|
- stats.executeEnd = now();
|
|
|
- return emptyResult(chunkMeta);
|
|
|
- }
|
|
|
- }
|
|
|
- if (discontinuity || trackSwitch || initSegmentChange || resetMuxers) {
|
|
|
- this.resetInitSegment(initSegmentData, audioCodec, videoCodec, duration, decryptdata);
|
|
|
- }
|
|
|
- if (discontinuity || initSegmentChange || resetMuxers) {
|
|
|
- this.resetInitialTimestamp(defaultInitPts);
|
|
|
- }
|
|
|
- if (!contiguous) {
|
|
|
- this.resetContiguity();
|
|
|
- }
|
|
|
- const result = this.transmux(uintData, keyData, timeOffset, accurateTimeOffset, chunkMeta);
|
|
|
- this.asyncResult = isPromise(result);
|
|
|
- const currentState = this.currentTransmuxState;
|
|
|
- currentState.contiguous = true;
|
|
|
- currentState.discontinuity = false;
|
|
|
- currentState.trackSwitch = false;
|
|
|
- stats.executeEnd = now();
|
|
|
- return result;
|
|
|
- }
|
|
|
- // Due to data caching, flush calls can produce more than one TransmuxerResult (hence the Array type)
|
|
|
- flush(chunkMeta) {
|
|
|
- const stats = chunkMeta.transmuxing;
|
|
|
- stats.executeStart = now();
|
|
|
- const {
|
|
|
- decrypter,
|
|
|
- currentTransmuxState,
|
|
|
- decryptionPromise
|
|
|
- } = this;
|
|
|
- if (decryptionPromise) {
|
|
|
- this.asyncResult = true;
|
|
|
- return decryptionPromise.then(() => {
|
|
|
- return this.flush(chunkMeta);
|
|
|
- });
|
|
|
- }
|
|
|
- const transmuxResults = [];
|
|
|
- const {
|
|
|
- timeOffset
|
|
|
- } = currentTransmuxState;
|
|
|
- if (decrypter) {
|
|
|
- const decryptedData = decrypter.flush();
|
|
|
- if (decryptedData) {
|
|
|
- transmuxResults.push(this.push(decryptedData.buffer, null, chunkMeta));
|
|
|
- }
|
|
|
- }
|
|
|
- const {
|
|
|
- demuxer,
|
|
|
- remuxer
|
|
|
- } = this;
|
|
|
- if (!demuxer || !remuxer) {
|
|
|
- stats.executeEnd = now();
|
|
|
- const emptyResults = [emptyResult(chunkMeta)];
|
|
|
- if (this.asyncResult) {
|
|
|
- return Promise.resolve(emptyResults);
|
|
|
- }
|
|
|
- return emptyResults;
|
|
|
- }
|
|
|
- const demuxResultOrPromise = demuxer.flush(timeOffset);
|
|
|
- if (isPromise(demuxResultOrPromise)) {
|
|
|
- this.asyncResult = true;
|
|
|
- return demuxResultOrPromise.then((demuxResult) => {
|
|
|
- this.flushRemux(transmuxResults, demuxResult, chunkMeta);
|
|
|
- return transmuxResults;
|
|
|
- });
|
|
|
- }
|
|
|
- this.flushRemux(transmuxResults, demuxResultOrPromise, chunkMeta);
|
|
|
- if (this.asyncResult) {
|
|
|
- return Promise.resolve(transmuxResults);
|
|
|
- }
|
|
|
- return transmuxResults;
|
|
|
- }
|
|
|
- flushRemux(transmuxResults, demuxResult, chunkMeta) {
|
|
|
- const {
|
|
|
- audioTrack,
|
|
|
- videoTrack,
|
|
|
- id3Track,
|
|
|
- textTrack
|
|
|
- } = demuxResult;
|
|
|
- const {
|
|
|
- accurateTimeOffset,
|
|
|
- timeOffset
|
|
|
- } = this.currentTransmuxState;
|
|
|
- this.logger.log(`[transmuxer.ts]: Flushed ${this.id} sn: ${chunkMeta.sn}${chunkMeta.part > -1 ? " part: " + chunkMeta.part : ""} of ${this.id === PlaylistLevelType.MAIN ? "level" : "track"} ${chunkMeta.level}`);
|
|
|
- const remuxResult = this.remuxer.remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, true, this.id);
|
|
|
- transmuxResults.push({
|
|
|
- remuxResult,
|
|
|
- chunkMeta
|
|
|
- });
|
|
|
- chunkMeta.transmuxing.executeEnd = now();
|
|
|
- }
|
|
|
- resetInitialTimestamp(defaultInitPts) {
|
|
|
- const {
|
|
|
- demuxer,
|
|
|
- remuxer
|
|
|
- } = this;
|
|
|
- if (!demuxer || !remuxer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- demuxer.resetTimeStamp(defaultInitPts);
|
|
|
- remuxer.resetTimeStamp(defaultInitPts);
|
|
|
- }
|
|
|
- resetContiguity() {
|
|
|
- const {
|
|
|
- demuxer,
|
|
|
- remuxer
|
|
|
- } = this;
|
|
|
- if (!demuxer || !remuxer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- demuxer.resetContiguity();
|
|
|
- remuxer.resetNextTimestamp();
|
|
|
- }
|
|
|
- resetInitSegment(initSegmentData, audioCodec, videoCodec, trackDuration, decryptdata) {
|
|
|
- const {
|
|
|
- demuxer,
|
|
|
- remuxer
|
|
|
- } = this;
|
|
|
- if (!demuxer || !remuxer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- demuxer.resetInitSegment(initSegmentData, audioCodec, videoCodec, trackDuration);
|
|
|
- remuxer.resetInitSegment(initSegmentData, audioCodec, videoCodec, decryptdata);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- if (this.demuxer) {
|
|
|
- this.demuxer.destroy();
|
|
|
- this.demuxer = void 0;
|
|
|
- }
|
|
|
- if (this.remuxer) {
|
|
|
- this.remuxer.destroy();
|
|
|
- this.remuxer = void 0;
|
|
|
- }
|
|
|
- }
|
|
|
- transmux(data, keyData, timeOffset, accurateTimeOffset, chunkMeta) {
|
|
|
- let result;
|
|
|
- if (keyData && keyData.method === "SAMPLE-AES") {
|
|
|
- result = this.transmuxSampleAes(data, keyData, timeOffset, accurateTimeOffset, chunkMeta);
|
|
|
- } else {
|
|
|
- result = this.transmuxUnencrypted(data, timeOffset, accurateTimeOffset, chunkMeta);
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- transmuxUnencrypted(data, timeOffset, accurateTimeOffset, chunkMeta) {
|
|
|
- const {
|
|
|
- audioTrack,
|
|
|
- videoTrack,
|
|
|
- id3Track,
|
|
|
- textTrack
|
|
|
- } = this.demuxer.demux(data, timeOffset, false, !this.config.progressive);
|
|
|
- const remuxResult = this.remuxer.remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, false, this.id);
|
|
|
- return {
|
|
|
- remuxResult,
|
|
|
- chunkMeta
|
|
|
- };
|
|
|
- }
|
|
|
- transmuxSampleAes(data, decryptData, timeOffset, accurateTimeOffset, chunkMeta) {
|
|
|
- return this.demuxer.demuxSampleAes(data, decryptData, timeOffset).then((demuxResult) => {
|
|
|
- const remuxResult = this.remuxer.remux(demuxResult.audioTrack, demuxResult.videoTrack, demuxResult.id3Track, demuxResult.textTrack, timeOffset, accurateTimeOffset, false, this.id);
|
|
|
- return {
|
|
|
- remuxResult,
|
|
|
- chunkMeta
|
|
|
- };
|
|
|
- });
|
|
|
- }
|
|
|
- configureTransmuxer(data) {
|
|
|
- const {
|
|
|
- config,
|
|
|
- observer,
|
|
|
- typeSupported
|
|
|
- } = this;
|
|
|
- let mux;
|
|
|
- for (let i = 0, len = muxConfig.length; i < len; i++) {
|
|
|
- var _muxConfig$i$demux;
|
|
|
- if ((_muxConfig$i$demux = muxConfig[i].demux) != null && _muxConfig$i$demux.probe(data, this.logger)) {
|
|
|
- mux = muxConfig[i];
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!mux) {
|
|
|
- return new Error("Failed to find demuxer by probing fragment data");
|
|
|
- }
|
|
|
- const demuxer = this.demuxer;
|
|
|
- const remuxer = this.remuxer;
|
|
|
- const Remuxer = mux.remux;
|
|
|
- const Demuxer = mux.demux;
|
|
|
- if (!remuxer || !(remuxer instanceof Remuxer)) {
|
|
|
- this.remuxer = new Remuxer(observer, config, typeSupported, this.logger);
|
|
|
- }
|
|
|
- if (!demuxer || !(demuxer instanceof Demuxer)) {
|
|
|
- this.demuxer = new Demuxer(observer, config, typeSupported, this.logger);
|
|
|
- this.probe = Demuxer.probe;
|
|
|
- }
|
|
|
- }
|
|
|
- needsProbing(discontinuity, trackSwitch) {
|
|
|
- return !this.demuxer || !this.remuxer || discontinuity || trackSwitch;
|
|
|
- }
|
|
|
- getDecrypter() {
|
|
|
- let decrypter = this.decrypter;
|
|
|
- if (!decrypter) {
|
|
|
- decrypter = this.decrypter = new Decrypter(this.config);
|
|
|
- }
|
|
|
- return decrypter;
|
|
|
- }
|
|
|
-};
|
|
|
-function getEncryptionType(data, decryptData) {
|
|
|
- let encryptionType = null;
|
|
|
- if (data.byteLength > 0 && (decryptData == null ? void 0 : decryptData.key) != null && decryptData.iv !== null && decryptData.method != null) {
|
|
|
- encryptionType = decryptData;
|
|
|
- }
|
|
|
- return encryptionType;
|
|
|
-}
|
|
|
-var emptyResult = (chunkMeta) => ({
|
|
|
- remuxResult: {},
|
|
|
- chunkMeta
|
|
|
-});
|
|
|
-function isPromise(p) {
|
|
|
- return "then" in p && p.then instanceof Function;
|
|
|
-}
|
|
|
-var TransmuxConfig = class {
|
|
|
- constructor(audioCodec, videoCodec, initSegmentData, duration, defaultInitPts) {
|
|
|
- this.audioCodec = void 0;
|
|
|
- this.videoCodec = void 0;
|
|
|
- this.initSegmentData = void 0;
|
|
|
- this.duration = void 0;
|
|
|
- this.defaultInitPts = void 0;
|
|
|
- this.audioCodec = audioCodec;
|
|
|
- this.videoCodec = videoCodec;
|
|
|
- this.initSegmentData = initSegmentData;
|
|
|
- this.duration = duration;
|
|
|
- this.defaultInitPts = defaultInitPts || null;
|
|
|
- }
|
|
|
-};
|
|
|
-var TransmuxState = class {
|
|
|
- constructor(discontinuity, contiguous, accurateTimeOffset, trackSwitch, timeOffset, initSegmentChange) {
|
|
|
- this.discontinuity = void 0;
|
|
|
- this.contiguous = void 0;
|
|
|
- this.accurateTimeOffset = void 0;
|
|
|
- this.trackSwitch = void 0;
|
|
|
- this.timeOffset = void 0;
|
|
|
- this.initSegmentChange = void 0;
|
|
|
- this.discontinuity = discontinuity;
|
|
|
- this.contiguous = contiguous;
|
|
|
- this.accurateTimeOffset = accurateTimeOffset;
|
|
|
- this.trackSwitch = trackSwitch;
|
|
|
- this.timeOffset = timeOffset;
|
|
|
- this.initSegmentChange = initSegmentChange;
|
|
|
- }
|
|
|
-};
|
|
|
-var transmuxerInstanceCount = 0;
|
|
|
-var TransmuxerInterface = class {
|
|
|
- constructor(_hls, id, onTransmuxComplete, onFlush) {
|
|
|
- this.error = null;
|
|
|
- this.hls = void 0;
|
|
|
- this.id = void 0;
|
|
|
- this.instanceNo = transmuxerInstanceCount++;
|
|
|
- this.observer = void 0;
|
|
|
- this.frag = null;
|
|
|
- this.part = null;
|
|
|
- this.useWorker = void 0;
|
|
|
- this.workerContext = null;
|
|
|
- this.transmuxer = null;
|
|
|
- this.onTransmuxComplete = void 0;
|
|
|
- this.onFlush = void 0;
|
|
|
- this.onWorkerMessage = (event) => {
|
|
|
- const data = event.data;
|
|
|
- const hls = this.hls;
|
|
|
- if (!hls || !(data != null && data.event) || data.instanceNo !== this.instanceNo) {
|
|
|
- return;
|
|
|
- }
|
|
|
- switch (data.event) {
|
|
|
- case "init": {
|
|
|
- var _this$workerContext;
|
|
|
- const objectURL = (_this$workerContext = this.workerContext) == null ? void 0 : _this$workerContext.objectURL;
|
|
|
- if (objectURL) {
|
|
|
- self.URL.revokeObjectURL(objectURL);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case "transmuxComplete": {
|
|
|
- this.handleTransmuxComplete(data.data);
|
|
|
- break;
|
|
|
- }
|
|
|
- case "flush": {
|
|
|
- this.onFlush(data.data);
|
|
|
- break;
|
|
|
- }
|
|
|
- case "workerLog": {
|
|
|
- if (hls.logger[data.data.logType]) {
|
|
|
- hls.logger[data.data.logType](data.data.message);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- default: {
|
|
|
- data.data = data.data || {};
|
|
|
- data.data.frag = this.frag;
|
|
|
- data.data.part = this.part;
|
|
|
- data.data.id = this.id;
|
|
|
- hls.trigger(data.event, data.data);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- this.onWorkerError = (event) => {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const error = new Error(`${event.message} (${event.filename}:${event.lineno})`);
|
|
|
- this.hls.config.enableWorker = false;
|
|
|
- this.hls.logger.warn(`Error in "${this.id}" Web Worker, fallback to inline`);
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.INTERNAL_EXCEPTION,
|
|
|
- fatal: false,
|
|
|
- event: "demuxerWorker",
|
|
|
- error
|
|
|
- });
|
|
|
- };
|
|
|
- const config = _hls.config;
|
|
|
- this.hls = _hls;
|
|
|
- this.id = id;
|
|
|
- this.useWorker = !!config.enableWorker;
|
|
|
- this.onTransmuxComplete = onTransmuxComplete;
|
|
|
- this.onFlush = onFlush;
|
|
|
- const forwardMessage = (ev, data) => {
|
|
|
- data = data || {};
|
|
|
- data.frag = this.frag || void 0;
|
|
|
- if (ev === Events.ERROR) {
|
|
|
- data = data;
|
|
|
- data.parent = this.id;
|
|
|
- data.part = this.part;
|
|
|
- this.error = data.error;
|
|
|
- }
|
|
|
- this.hls.trigger(ev, data);
|
|
|
- };
|
|
|
- this.observer = new EventEmitter();
|
|
|
- this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
|
|
|
- this.observer.on(Events.ERROR, forwardMessage);
|
|
|
- const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
|
|
|
- if (this.useWorker && typeof Worker !== "undefined") {
|
|
|
- const logger2 = this.hls.logger;
|
|
|
- const canCreateWorker = config.workerPath || hasUMDWorker();
|
|
|
- if (canCreateWorker) {
|
|
|
- try {
|
|
|
- if (config.workerPath) {
|
|
|
- logger2.log(`loading Web Worker ${config.workerPath} for "${id}"`);
|
|
|
- this.workerContext = loadWorker(config.workerPath);
|
|
|
- } else {
|
|
|
- logger2.log(`injecting Web Worker for "${id}"`);
|
|
|
- this.workerContext = injectWorker();
|
|
|
- }
|
|
|
- const {
|
|
|
- worker
|
|
|
- } = this.workerContext;
|
|
|
- worker.addEventListener("message", this.onWorkerMessage);
|
|
|
- worker.addEventListener("error", this.onWorkerError);
|
|
|
- worker.postMessage({
|
|
|
- instanceNo: this.instanceNo,
|
|
|
- cmd: "init",
|
|
|
- typeSupported: m2tsTypeSupported,
|
|
|
- id,
|
|
|
- config: stringify(config)
|
|
|
- });
|
|
|
- } catch (err) {
|
|
|
- logger2.warn(`Error setting up "${id}" Web Worker, fallback to inline`, err);
|
|
|
- this.terminateWorker();
|
|
|
- this.error = null;
|
|
|
- this.transmuxer = new Transmuxer(this.observer, m2tsTypeSupported, config, "", id, _hls.logger);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.transmuxer = new Transmuxer(this.observer, m2tsTypeSupported, config, "", id, _hls.logger);
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.frag = null;
|
|
|
- this.part = null;
|
|
|
- if (this.workerContext) {
|
|
|
- const instanceNo = this.instanceNo;
|
|
|
- this.instanceNo = transmuxerInstanceCount++;
|
|
|
- const config = this.hls.config;
|
|
|
- const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
|
|
|
- this.workerContext.worker.postMessage({
|
|
|
- instanceNo: this.instanceNo,
|
|
|
- cmd: "reset",
|
|
|
- resetNo: instanceNo,
|
|
|
- typeSupported: m2tsTypeSupported,
|
|
|
- id: this.id,
|
|
|
- config: stringify(config)
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- terminateWorker() {
|
|
|
- if (this.workerContext) {
|
|
|
- const {
|
|
|
- worker
|
|
|
- } = this.workerContext;
|
|
|
- this.workerContext = null;
|
|
|
- worker.removeEventListener("message", this.onWorkerMessage);
|
|
|
- worker.removeEventListener("error", this.onWorkerError);
|
|
|
- removeWorkerFromStore(this.hls.config.workerPath);
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- if (this.workerContext) {
|
|
|
- this.terminateWorker();
|
|
|
- this.onWorkerMessage = this.onWorkerError = null;
|
|
|
- } else {
|
|
|
- const transmuxer = this.transmuxer;
|
|
|
- if (transmuxer) {
|
|
|
- transmuxer.destroy();
|
|
|
- this.transmuxer = null;
|
|
|
- }
|
|
|
- }
|
|
|
- const observer = this.observer;
|
|
|
- if (observer) {
|
|
|
- observer.removeAllListeners();
|
|
|
- }
|
|
|
- this.frag = null;
|
|
|
- this.part = null;
|
|
|
- this.observer = null;
|
|
|
- this.hls = null;
|
|
|
- }
|
|
|
- push(data, initSegmentData, audioCodec, videoCodec, frag, part, duration, accurateTimeOffset, chunkMeta, defaultInitPTS) {
|
|
|
- var _frag$initSegment, _lastFrag$initSegment;
|
|
|
- chunkMeta.transmuxing.start = self.performance.now();
|
|
|
- const {
|
|
|
- instanceNo,
|
|
|
- transmuxer
|
|
|
- } = this;
|
|
|
- const timeOffset = part ? part.start : frag.start;
|
|
|
- const decryptdata = frag.decryptdata;
|
|
|
- const lastFrag = this.frag;
|
|
|
- const discontinuity = !(lastFrag && frag.cc === lastFrag.cc);
|
|
|
- const trackSwitch = !(lastFrag && chunkMeta.level === lastFrag.level);
|
|
|
- const snDiff = lastFrag ? chunkMeta.sn - lastFrag.sn : -1;
|
|
|
- const partDiff = this.part ? chunkMeta.part - this.part.index : -1;
|
|
|
- const progressive = snDiff === 0 && chunkMeta.id > 1 && chunkMeta.id === (lastFrag == null ? void 0 : lastFrag.stats.chunkCount);
|
|
|
- const contiguous = !trackSwitch && (snDiff === 1 || snDiff === 0 && (partDiff === 1 || progressive && partDiff <= 0));
|
|
|
- const now2 = self.performance.now();
|
|
|
- if (trackSwitch || snDiff || frag.stats.parsing.start === 0) {
|
|
|
- frag.stats.parsing.start = now2;
|
|
|
- }
|
|
|
- if (part && (partDiff || !contiguous)) {
|
|
|
- part.stats.parsing.start = now2;
|
|
|
- }
|
|
|
- const initSegmentChange = !(lastFrag && ((_frag$initSegment = frag.initSegment) == null ? void 0 : _frag$initSegment.url) === ((_lastFrag$initSegment = lastFrag.initSegment) == null ? void 0 : _lastFrag$initSegment.url));
|
|
|
- const state = new TransmuxState(discontinuity, contiguous, accurateTimeOffset, trackSwitch, timeOffset, initSegmentChange);
|
|
|
- if (!contiguous || discontinuity || initSegmentChange) {
|
|
|
- this.hls.logger.log(`[transmuxer-interface]: Starting new transmux session for ${frag.type} sn: ${chunkMeta.sn}${chunkMeta.part > -1 ? " part: " + chunkMeta.part : ""} ${this.id === PlaylistLevelType.MAIN ? "level" : "track"}: ${chunkMeta.level} id: ${chunkMeta.id}
|
|
|
- discontinuity: ${discontinuity}
|
|
|
- trackSwitch: ${trackSwitch}
|
|
|
- contiguous: ${contiguous}
|
|
|
- accurateTimeOffset: ${accurateTimeOffset}
|
|
|
- timeOffset: ${timeOffset}
|
|
|
- initSegmentChange: ${initSegmentChange}`);
|
|
|
- const config = new TransmuxConfig(audioCodec, videoCodec, initSegmentData, duration, defaultInitPTS);
|
|
|
- this.configureTransmuxer(config);
|
|
|
- }
|
|
|
- this.frag = frag;
|
|
|
- this.part = part;
|
|
|
- if (this.workerContext) {
|
|
|
- this.workerContext.worker.postMessage({
|
|
|
- instanceNo,
|
|
|
- cmd: "demux",
|
|
|
- data,
|
|
|
- decryptdata,
|
|
|
- chunkMeta,
|
|
|
- state
|
|
|
- }, data instanceof ArrayBuffer ? [data] : []);
|
|
|
- } else if (transmuxer) {
|
|
|
- const transmuxResult = transmuxer.push(data, decryptdata, chunkMeta, state);
|
|
|
- if (isPromise(transmuxResult)) {
|
|
|
- transmuxResult.then((data2) => {
|
|
|
- this.handleTransmuxComplete(data2);
|
|
|
- }).catch((error) => {
|
|
|
- this.transmuxerError(error, chunkMeta, "transmuxer-interface push error");
|
|
|
- });
|
|
|
- } else {
|
|
|
- this.handleTransmuxComplete(transmuxResult);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- flush(chunkMeta) {
|
|
|
- chunkMeta.transmuxing.start = self.performance.now();
|
|
|
- const {
|
|
|
- instanceNo,
|
|
|
- transmuxer
|
|
|
- } = this;
|
|
|
- if (this.workerContext) {
|
|
|
- this.workerContext.worker.postMessage({
|
|
|
- instanceNo,
|
|
|
- cmd: "flush",
|
|
|
- chunkMeta
|
|
|
- });
|
|
|
- } else if (transmuxer) {
|
|
|
- const transmuxResult = transmuxer.flush(chunkMeta);
|
|
|
- if (isPromise(transmuxResult)) {
|
|
|
- transmuxResult.then((data) => {
|
|
|
- this.handleFlushResult(data, chunkMeta);
|
|
|
- }).catch((error) => {
|
|
|
- this.transmuxerError(error, chunkMeta, "transmuxer-interface flush error");
|
|
|
- });
|
|
|
- } else {
|
|
|
- this.handleFlushResult(transmuxResult, chunkMeta);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- transmuxerError(error, chunkMeta, reason) {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.error = error;
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_PARSING_ERROR,
|
|
|
- chunkMeta,
|
|
|
- frag: this.frag || void 0,
|
|
|
- part: this.part || void 0,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- err: error,
|
|
|
- reason
|
|
|
- });
|
|
|
- }
|
|
|
- handleFlushResult(results, chunkMeta) {
|
|
|
- results.forEach((result) => {
|
|
|
- this.handleTransmuxComplete(result);
|
|
|
- });
|
|
|
- this.onFlush(chunkMeta);
|
|
|
- }
|
|
|
- configureTransmuxer(config) {
|
|
|
- const {
|
|
|
- instanceNo,
|
|
|
- transmuxer
|
|
|
- } = this;
|
|
|
- if (this.workerContext) {
|
|
|
- this.workerContext.worker.postMessage({
|
|
|
- instanceNo,
|
|
|
- cmd: "configure",
|
|
|
- config
|
|
|
- });
|
|
|
- } else if (transmuxer) {
|
|
|
- transmuxer.configure(config);
|
|
|
- }
|
|
|
- }
|
|
|
- handleTransmuxComplete(result) {
|
|
|
- result.chunkMeta.transmuxing.end = self.performance.now();
|
|
|
- this.onTransmuxComplete(result);
|
|
|
- }
|
|
|
-};
|
|
|
-var TICK_INTERVAL$3 = 100;
|
|
|
-var AudioStreamController = class extends BaseStreamController {
|
|
|
- constructor(hls, fragmentTracker, keyLoader) {
|
|
|
- super(hls, fragmentTracker, keyLoader, "audio-stream-controller", PlaylistLevelType.AUDIO);
|
|
|
- this.mainAnchor = null;
|
|
|
- this.mainFragLoading = null;
|
|
|
- this.audioOnly = false;
|
|
|
- this.bufferedTrack = null;
|
|
|
- this.switchingTrack = null;
|
|
|
- this.trackId = -1;
|
|
|
- this.waitingData = null;
|
|
|
- this.mainDetails = null;
|
|
|
- this.flushing = false;
|
|
|
- this.bufferFlushed = false;
|
|
|
- this.cachedTrackLoadedData = null;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- onHandlerDestroying() {
|
|
|
- this.unregisterListeners();
|
|
|
- super.onHandlerDestroying();
|
|
|
- this.resetItem();
|
|
|
- }
|
|
|
- resetItem() {
|
|
|
- this.mainDetails = this.mainAnchor = this.mainFragLoading = this.bufferedTrack = this.switchingTrack = this.waitingData = this.cachedTrackLoadedData = null;
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- super.registerListeners();
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.on(Events.AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
|
|
|
- hls.on(Events.BUFFER_RESET, this.onBufferReset, this);
|
|
|
- hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
|
|
|
- hls.on(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
|
|
|
- hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
|
|
|
- hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- super.unregisterListeners();
|
|
|
- hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.off(Events.AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
|
|
|
- hls.off(Events.BUFFER_RESET, this.onBufferReset, this);
|
|
|
- hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
|
|
|
- hls.off(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
|
|
|
- hls.off(Events.FRAG_LOADING, this.onFragLoading, this);
|
|
|
- hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- }
|
|
|
- // INIT_PTS_FOUND is triggered when the video track parsed in the stream-controller has a new PTS value
|
|
|
- onInitPtsFound(event, {
|
|
|
- frag,
|
|
|
- id,
|
|
|
- initPTS,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- }) {
|
|
|
- if (id === PlaylistLevelType.MAIN) {
|
|
|
- const cc = frag.cc;
|
|
|
- const inFlightFrag = this.fragCurrent;
|
|
|
- this.initPTS[cc] = {
|
|
|
- baseTime: initPTS,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- };
|
|
|
- this.log(`InitPTS for cc: ${cc} found from main: ${initPTS / timescale} (${initPTS}/${timescale}) trackId: ${trackId}`);
|
|
|
- this.mainAnchor = frag;
|
|
|
- if (this.state === State.WAITING_INIT_PTS) {
|
|
|
- const waitingData = this.waitingData;
|
|
|
- if (!waitingData && !this.loadingParts || waitingData && waitingData.frag.cc !== cc) {
|
|
|
- this.syncWithAnchor(frag, waitingData == null ? void 0 : waitingData.frag);
|
|
|
- }
|
|
|
- } else if (!this.hls.hasEnoughToStart && inFlightFrag && inFlightFrag.cc !== cc) {
|
|
|
- inFlightFrag.abortRequests();
|
|
|
- this.syncWithAnchor(frag, inFlightFrag);
|
|
|
- } else if (this.state === State.IDLE) {
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- getLoadPosition() {
|
|
|
- if (!this.startFragRequested && this.nextLoadPosition >= 0) {
|
|
|
- return this.nextLoadPosition;
|
|
|
- }
|
|
|
- return super.getLoadPosition();
|
|
|
- }
|
|
|
- syncWithAnchor(mainAnchor, waitingToAppend) {
|
|
|
- var _this$mainFragLoading;
|
|
|
- const mainFragLoading = ((_this$mainFragLoading = this.mainFragLoading) == null ? void 0 : _this$mainFragLoading.frag) || null;
|
|
|
- if (waitingToAppend) {
|
|
|
- if ((mainFragLoading == null ? void 0 : mainFragLoading.cc) === waitingToAppend.cc) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const targetDiscontinuity = (mainFragLoading || mainAnchor).cc;
|
|
|
- const trackDetails = this.getLevelDetails();
|
|
|
- const pos = this.getLoadPosition();
|
|
|
- const syncFrag = findNearestWithCC(trackDetails, targetDiscontinuity, pos);
|
|
|
- if (syncFrag) {
|
|
|
- this.log(`Syncing with main frag at ${syncFrag.start} cc ${syncFrag.cc}`);
|
|
|
- this.startFragRequested = false;
|
|
|
- this.nextLoadPosition = syncFrag.start;
|
|
|
- this.resetLoadingState();
|
|
|
- if (this.state === State.IDLE) {
|
|
|
- this.doTickIdle();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- startLoad(startPosition, skipSeekToStartPosition) {
|
|
|
- if (!this.levels) {
|
|
|
- this.startPosition = startPosition;
|
|
|
- this.state = State.STOPPED;
|
|
|
- return;
|
|
|
- }
|
|
|
- const lastCurrentTime = this.lastCurrentTime;
|
|
|
- this.stopLoad();
|
|
|
- this.setInterval(TICK_INTERVAL$3);
|
|
|
- if (lastCurrentTime > 0 && startPosition === -1) {
|
|
|
- this.log(`Override startPosition with lastCurrentTime @${lastCurrentTime.toFixed(3)}`);
|
|
|
- startPosition = lastCurrentTime;
|
|
|
- this.state = State.IDLE;
|
|
|
- } else {
|
|
|
- this.state = State.WAITING_TRACK;
|
|
|
- }
|
|
|
- this.nextLoadPosition = this.lastCurrentTime = startPosition + this.timelineOffset;
|
|
|
- this.startPosition = skipSeekToStartPosition ? -1 : startPosition;
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- doTick() {
|
|
|
- switch (this.state) {
|
|
|
- case State.IDLE:
|
|
|
- this.doTickIdle();
|
|
|
- break;
|
|
|
- case State.WAITING_TRACK: {
|
|
|
- const {
|
|
|
- levels,
|
|
|
- trackId
|
|
|
- } = this;
|
|
|
- const currenTrack = levels == null ? void 0 : levels[trackId];
|
|
|
- const details = currenTrack == null ? void 0 : currenTrack.details;
|
|
|
- if (details && !this.waitForLive(currenTrack)) {
|
|
|
- if (this.waitForCdnTuneIn(details)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- this.state = State.WAITING_INIT_PTS;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case State.FRAG_LOADING_WAITING_RETRY: {
|
|
|
- this.checkRetryDate();
|
|
|
- break;
|
|
|
- }
|
|
|
- case State.WAITING_INIT_PTS: {
|
|
|
- const waitingData = this.waitingData;
|
|
|
- if (waitingData) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- cache,
|
|
|
- complete
|
|
|
- } = waitingData;
|
|
|
- const mainAnchor = this.mainAnchor;
|
|
|
- if (this.initPTS[frag.cc] !== void 0) {
|
|
|
- this.waitingData = null;
|
|
|
- this.state = State.FRAG_LOADING;
|
|
|
- const payload = cache.flush().buffer;
|
|
|
- const data = {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- payload,
|
|
|
- networkDetails: null
|
|
|
- };
|
|
|
- this._handleFragmentLoadProgress(data);
|
|
|
- if (complete) {
|
|
|
- super._handleFragmentLoadComplete(data);
|
|
|
- }
|
|
|
- } else if (mainAnchor && mainAnchor.cc !== waitingData.frag.cc) {
|
|
|
- this.syncWithAnchor(mainAnchor, waitingData.frag);
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.onTickEnd();
|
|
|
- }
|
|
|
- resetLoadingState() {
|
|
|
- const waitingData = this.waitingData;
|
|
|
- if (waitingData) {
|
|
|
- this.fragmentTracker.removeFragment(waitingData.frag);
|
|
|
- this.waitingData = null;
|
|
|
- }
|
|
|
- super.resetLoadingState();
|
|
|
- }
|
|
|
- onTickEnd() {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (!(media != null && media.readyState)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.lastCurrentTime = media.currentTime;
|
|
|
- }
|
|
|
- doTickIdle() {
|
|
|
- var _this$mainFragLoading2;
|
|
|
- const {
|
|
|
- hls,
|
|
|
- levels,
|
|
|
- media,
|
|
|
- trackId
|
|
|
- } = this;
|
|
|
- const config = hls.config;
|
|
|
- if (!this.buffering || !media && !this.primaryPrefetch && (this.startFragRequested || !config.startFragPrefetch) || !(levels != null && levels[trackId])) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const levelInfo = levels[trackId];
|
|
|
- const trackDetails = levelInfo.details;
|
|
|
- if (!trackDetails || this.waitForLive(levelInfo) || this.waitForCdnTuneIn(trackDetails)) {
|
|
|
- this.state = State.WAITING_TRACK;
|
|
|
- this.startFragRequested = false;
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferable = this.mediaBuffer ? this.mediaBuffer : this.media;
|
|
|
- if (this.bufferFlushed && bufferable) {
|
|
|
- this.bufferFlushed = false;
|
|
|
- this.afterBufferFlushed(bufferable, ElementaryStreamTypes.AUDIO, PlaylistLevelType.AUDIO);
|
|
|
- }
|
|
|
- const bufferInfo = this.getFwdBufferInfo(bufferable, PlaylistLevelType.AUDIO);
|
|
|
- if (bufferInfo === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!this.switchingTrack && this._streamEnded(bufferInfo, trackDetails)) {
|
|
|
- hls.trigger(Events.BUFFER_EOS, {
|
|
|
- type: "audio"
|
|
|
- });
|
|
|
- this.state = State.ENDED;
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferLen = bufferInfo.len;
|
|
|
- const maxBufLen = hls.maxBufferLength;
|
|
|
- const fragments = trackDetails.fragments;
|
|
|
- const start = fragments[0].start;
|
|
|
- const loadPosition = this.getLoadPosition();
|
|
|
- const targetBufferTime = this.flushing ? loadPosition : bufferInfo.end;
|
|
|
- if (this.switchingTrack && media) {
|
|
|
- const pos = loadPosition;
|
|
|
- if (trackDetails.PTSKnown && pos < start) {
|
|
|
- if (bufferInfo.end > start || bufferInfo.nextStart) {
|
|
|
- this.log("Alt audio track ahead of main track, seek to start of alt audio track");
|
|
|
- media.currentTime = start + 0.05;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (bufferLen >= maxBufLen && !this.switchingTrack && targetBufferTime < fragments[fragments.length - 1].start) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let frag = this.getNextFragment(targetBufferTime, trackDetails);
|
|
|
- if (frag && this.isLoopLoading(frag, targetBufferTime)) {
|
|
|
- frag = this.getNextFragmentLoopLoading(frag, trackDetails, bufferInfo, PlaylistLevelType.MAIN, maxBufLen);
|
|
|
- }
|
|
|
- if (!frag) {
|
|
|
- this.bufferFlushed = true;
|
|
|
- return;
|
|
|
- }
|
|
|
- let mainFragLoading = ((_this$mainFragLoading2 = this.mainFragLoading) == null ? void 0 : _this$mainFragLoading2.frag) || null;
|
|
|
- if (!this.audioOnly && this.startFragRequested && mainFragLoading && isMediaFragment(frag) && !frag.endList && (!trackDetails.live || !this.loadingParts && targetBufferTime < this.hls.liveSyncPosition)) {
|
|
|
- if (this.fragmentTracker.getState(mainFragLoading) === FragmentState.OK) {
|
|
|
- this.mainFragLoading = mainFragLoading = null;
|
|
|
- }
|
|
|
- if (mainFragLoading && isMediaFragment(mainFragLoading)) {
|
|
|
- if (frag.start > mainFragLoading.end) {
|
|
|
- const mainFragAtPos = this.fragmentTracker.getFragAtPos(targetBufferTime, PlaylistLevelType.MAIN);
|
|
|
- if (mainFragAtPos && mainFragAtPos.end > mainFragLoading.end) {
|
|
|
- mainFragLoading = mainFragAtPos;
|
|
|
- this.mainFragLoading = {
|
|
|
- frag: mainFragAtPos,
|
|
|
- targetBufferTime: null
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- const atBufferSyncLimit = frag.start > mainFragLoading.end;
|
|
|
- if (atBufferSyncLimit) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.loadFragment(frag, levelInfo, targetBufferTime);
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- this.bufferFlushed = this.flushing = false;
|
|
|
- super.onMediaDetaching(event, data);
|
|
|
- }
|
|
|
- onAudioTracksUpdated(event, {
|
|
|
- audioTracks
|
|
|
- }) {
|
|
|
- this.resetTransmuxer();
|
|
|
- this.levels = audioTracks.map((mediaPlaylist) => new Level(mediaPlaylist));
|
|
|
- }
|
|
|
- onAudioTrackSwitching(event, data) {
|
|
|
- const altAudio = !!data.url;
|
|
|
- this.trackId = data.id;
|
|
|
- const {
|
|
|
- fragCurrent
|
|
|
- } = this;
|
|
|
- if (fragCurrent) {
|
|
|
- fragCurrent.abortRequests();
|
|
|
- this.removeUnbufferedFrags(fragCurrent.start);
|
|
|
- }
|
|
|
- this.resetLoadingState();
|
|
|
- if (altAudio) {
|
|
|
- this.switchingTrack = data;
|
|
|
- this.flushAudioIfNeeded(data);
|
|
|
- if (this.state !== State.STOPPED) {
|
|
|
- this.setInterval(TICK_INTERVAL$3);
|
|
|
- this.state = State.IDLE;
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.resetTransmuxer();
|
|
|
- this.switchingTrack = null;
|
|
|
- this.bufferedTrack = data;
|
|
|
- this.clearInterval();
|
|
|
- }
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- super.onManifestLoading();
|
|
|
- this.bufferFlushed = this.flushing = this.audioOnly = false;
|
|
|
- this.resetItem();
|
|
|
- this.trackId = -1;
|
|
|
- }
|
|
|
- onLevelLoaded(event, data) {
|
|
|
- this.mainDetails = data.details;
|
|
|
- const cachedTrackLoadedData = this.cachedTrackLoadedData;
|
|
|
- if (cachedTrackLoadedData) {
|
|
|
- this.cachedTrackLoadedData = null;
|
|
|
- this.onAudioTrackLoaded(Events.AUDIO_TRACK_LOADED, cachedTrackLoadedData);
|
|
|
- }
|
|
|
- }
|
|
|
- onAudioTrackLoaded(event, data) {
|
|
|
- var _trackLevel$details;
|
|
|
- const {
|
|
|
- levels
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- details: newDetails,
|
|
|
- id: trackId,
|
|
|
- groupId,
|
|
|
- track
|
|
|
- } = data;
|
|
|
- if (!levels) {
|
|
|
- this.warn(`Audio tracks reset while loading track ${trackId} "${track.name}" of "${groupId}"`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const mainDetails = this.mainDetails;
|
|
|
- if (!mainDetails || newDetails.endCC > mainDetails.endCC || mainDetails.expired) {
|
|
|
- this.cachedTrackLoadedData = data;
|
|
|
- if (this.state !== State.STOPPED) {
|
|
|
- this.state = State.WAITING_TRACK;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- this.cachedTrackLoadedData = null;
|
|
|
- this.log(`Audio track ${trackId} "${track.name}" of "${groupId}" loaded [${newDetails.startSN},${newDetails.endSN}]${newDetails.lastPartSn ? `[part-${newDetails.lastPartSn}-${newDetails.lastPartIndex}]` : ""},duration:${newDetails.totalduration}`);
|
|
|
- const trackLevel = levels[trackId];
|
|
|
- let sliding = 0;
|
|
|
- if (newDetails.live || (_trackLevel$details = trackLevel.details) != null && _trackLevel$details.live) {
|
|
|
- this.checkLiveUpdate(newDetails);
|
|
|
- if (newDetails.deltaUpdateFailed) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (trackLevel.details) {
|
|
|
- var _this$levelLastLoaded;
|
|
|
- sliding = this.alignPlaylists(newDetails, trackLevel.details, (_this$levelLastLoaded = this.levelLastLoaded) == null ? void 0 : _this$levelLastLoaded.details);
|
|
|
- }
|
|
|
- if (!newDetails.alignedSliding) {
|
|
|
- alignDiscontinuities(newDetails, mainDetails);
|
|
|
- if (!newDetails.alignedSliding) {
|
|
|
- alignMediaPlaylistByPDT(newDetails, mainDetails);
|
|
|
- }
|
|
|
- sliding = newDetails.fragmentStart;
|
|
|
- }
|
|
|
- }
|
|
|
- trackLevel.details = newDetails;
|
|
|
- this.levelLastLoaded = trackLevel;
|
|
|
- if (!this.startFragRequested) {
|
|
|
- this.setStartPosition(mainDetails, sliding);
|
|
|
- }
|
|
|
- this.hls.trigger(Events.AUDIO_TRACK_UPDATED, {
|
|
|
- details: newDetails,
|
|
|
- id: trackId,
|
|
|
- groupId: data.groupId
|
|
|
- });
|
|
|
- if (this.state === State.WAITING_TRACK && !this.waitForCdnTuneIn(newDetails)) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- _handleFragmentLoadProgress(data) {
|
|
|
- var _frag$initSegment;
|
|
|
- const frag = data.frag;
|
|
|
- const {
|
|
|
- part,
|
|
|
- payload
|
|
|
- } = data;
|
|
|
- const {
|
|
|
- config,
|
|
|
- trackId,
|
|
|
- levels
|
|
|
- } = this;
|
|
|
- if (!levels) {
|
|
|
- this.warn(`Audio tracks were reset while fragment load was in progress. Fragment ${frag.sn} of level ${frag.level} will not be buffered`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const track = levels[trackId];
|
|
|
- if (!track) {
|
|
|
- this.warn("Audio track is undefined on fragment load progress");
|
|
|
- return;
|
|
|
- }
|
|
|
- const details = track.details;
|
|
|
- if (!details) {
|
|
|
- this.warn("Audio track details undefined on fragment load progress");
|
|
|
- this.removeUnbufferedFrags(frag.start);
|
|
|
- return;
|
|
|
- }
|
|
|
- const audioCodec = config.defaultAudioCodec || track.audioCodec || "mp4a.40.2";
|
|
|
- let transmuxer = this.transmuxer;
|
|
|
- if (!transmuxer) {
|
|
|
- transmuxer = this.transmuxer = new TransmuxerInterface(this.hls, PlaylistLevelType.AUDIO, this._handleTransmuxComplete.bind(this), this._handleTransmuxerFlush.bind(this));
|
|
|
- }
|
|
|
- const initPTS = this.initPTS[frag.cc];
|
|
|
- const initSegmentData = (_frag$initSegment = frag.initSegment) == null ? void 0 : _frag$initSegment.data;
|
|
|
- if (initPTS !== void 0) {
|
|
|
- const accurateTimeOffset = false;
|
|
|
- const partIndex = part ? part.index : -1;
|
|
|
- const partial = partIndex !== -1;
|
|
|
- const chunkMeta = new ChunkMetadata(frag.level, frag.sn, frag.stats.chunkCount, payload.byteLength, partIndex, partial);
|
|
|
- transmuxer.push(payload, initSegmentData, audioCodec, "", frag, part, details.totalduration, accurateTimeOffset, chunkMeta, initPTS);
|
|
|
- } else {
|
|
|
- this.log(`Unknown video PTS for cc ${frag.cc}, waiting for video PTS before demuxing audio frag ${frag.sn} of [${details.startSN} ,${details.endSN}],track ${trackId}`);
|
|
|
- const {
|
|
|
- cache
|
|
|
- } = this.waitingData = this.waitingData || {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- cache: new ChunkCache(),
|
|
|
- complete: false
|
|
|
- };
|
|
|
- cache.push(new Uint8Array(payload));
|
|
|
- if (this.state !== State.STOPPED) {
|
|
|
- this.state = State.WAITING_INIT_PTS;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- _handleFragmentLoadComplete(fragLoadedData) {
|
|
|
- if (this.waitingData) {
|
|
|
- this.waitingData.complete = true;
|
|
|
- return;
|
|
|
- }
|
|
|
- super._handleFragmentLoadComplete(fragLoadedData);
|
|
|
- }
|
|
|
- onBufferReset() {
|
|
|
- this.mediaBuffer = null;
|
|
|
- }
|
|
|
- onBufferCreated(event, data) {
|
|
|
- this.bufferFlushed = this.flushing = false;
|
|
|
- const audioTrack = data.tracks.audio;
|
|
|
- if (audioTrack) {
|
|
|
- this.mediaBuffer = audioTrack.buffer || null;
|
|
|
- }
|
|
|
- }
|
|
|
- onFragLoading(event, data) {
|
|
|
- if (!this.audioOnly && data.frag.type === PlaylistLevelType.MAIN && isMediaFragment(data.frag)) {
|
|
|
- this.mainFragLoading = data;
|
|
|
- if (this.state === State.IDLE) {
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onFragBuffered(event, data) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part
|
|
|
- } = data;
|
|
|
- if (frag.type !== PlaylistLevelType.AUDIO) {
|
|
|
- if (!this.audioOnly && frag.type === PlaylistLevelType.MAIN && !frag.elementaryStreams.video && !frag.elementaryStreams.audiovideo) {
|
|
|
- this.audioOnly = true;
|
|
|
- this.mainFragLoading = null;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.fragContextChanged(frag)) {
|
|
|
- this.warn(`Fragment ${frag.sn}${part ? " p: " + part.index : ""} of level ${frag.level} finished buffering, but was aborted. state: ${this.state}, audioSwitch: ${this.switchingTrack ? this.switchingTrack.name : "false"}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (isMediaFragment(frag)) {
|
|
|
- this.fragPrevious = frag;
|
|
|
- const track = this.switchingTrack;
|
|
|
- if (track) {
|
|
|
- this.bufferedTrack = track;
|
|
|
- this.switchingTrack = null;
|
|
|
- this.hls.trigger(Events.AUDIO_TRACK_SWITCHED, _objectSpread2({}, track));
|
|
|
- }
|
|
|
- }
|
|
|
- this.fragBufferedComplete(frag, part);
|
|
|
- if (this.media) {
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- var _data$context;
|
|
|
- if (data.fatal) {
|
|
|
- this.state = State.ERROR;
|
|
|
- return;
|
|
|
- }
|
|
|
- switch (data.details) {
|
|
|
- case ErrorDetails.FRAG_GAP:
|
|
|
- case ErrorDetails.FRAG_PARSING_ERROR:
|
|
|
- case ErrorDetails.FRAG_DECRYPT_ERROR:
|
|
|
- case ErrorDetails.FRAG_LOAD_ERROR:
|
|
|
- case ErrorDetails.FRAG_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.KEY_LOAD_ERROR:
|
|
|
- case ErrorDetails.KEY_LOAD_TIMEOUT:
|
|
|
- this.onFragmentOrKeyLoadError(PlaylistLevelType.AUDIO, data);
|
|
|
- break;
|
|
|
- case ErrorDetails.AUDIO_TRACK_LOAD_ERROR:
|
|
|
- case ErrorDetails.AUDIO_TRACK_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.LEVEL_PARSING_ERROR:
|
|
|
- if (!data.levelRetry && this.state === State.WAITING_TRACK && ((_data$context = data.context) == null ? void 0 : _data$context.type) === PlaylistContextType.AUDIO_TRACK) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- break;
|
|
|
- case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
|
|
|
- case ErrorDetails.BUFFER_APPEND_ERROR:
|
|
|
- if (data.parent !== "audio") {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!this.reduceLengthAndFlushBuffer(data)) {
|
|
|
- this.resetLoadingState();
|
|
|
- }
|
|
|
- break;
|
|
|
- case ErrorDetails.BUFFER_FULL_ERROR:
|
|
|
- if (data.parent !== "audio") {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.reduceLengthAndFlushBuffer(data)) {
|
|
|
- this.bufferedTrack = null;
|
|
|
- super.flushMainBuffer(0, Number.POSITIVE_INFINITY, "audio");
|
|
|
- }
|
|
|
- break;
|
|
|
- case ErrorDetails.INTERNAL_EXCEPTION:
|
|
|
- this.recoverWorkerError(data);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferFlushing(event, {
|
|
|
- type
|
|
|
- }) {
|
|
|
- if (type !== ElementaryStreamTypes.VIDEO) {
|
|
|
- this.flushing = true;
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferFlushed(event, {
|
|
|
- type
|
|
|
- }) {
|
|
|
- if (type !== ElementaryStreamTypes.VIDEO) {
|
|
|
- this.flushing = false;
|
|
|
- this.bufferFlushed = true;
|
|
|
- if (this.state === State.ENDED) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- const mediaBuffer = this.mediaBuffer || this.media;
|
|
|
- if (mediaBuffer) {
|
|
|
- this.afterBufferFlushed(mediaBuffer, type, PlaylistLevelType.AUDIO);
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- _handleTransmuxComplete(transmuxResult) {
|
|
|
- var _id3$samples;
|
|
|
- const id = "audio";
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- remuxResult,
|
|
|
- chunkMeta
|
|
|
- } = transmuxResult;
|
|
|
- const context = this.getCurrentContext(chunkMeta);
|
|
|
- if (!context) {
|
|
|
- this.resetWhenMissingContext(chunkMeta);
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- level
|
|
|
- } = context;
|
|
|
- const {
|
|
|
- details
|
|
|
- } = level;
|
|
|
- const {
|
|
|
- audio,
|
|
|
- text,
|
|
|
- id3,
|
|
|
- initSegment
|
|
|
- } = remuxResult;
|
|
|
- if (this.fragContextChanged(frag) || !details) {
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.state = State.PARSING;
|
|
|
- if (this.switchingTrack && audio) {
|
|
|
- this.completeAudioSwitch(this.switchingTrack);
|
|
|
- }
|
|
|
- if (initSegment != null && initSegment.tracks) {
|
|
|
- const mapFragment = frag.initSegment || frag;
|
|
|
- if (this.unhandledEncryptionError(initSegment, frag)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this._bufferInitSegment(level, initSegment.tracks, mapFragment, chunkMeta);
|
|
|
- hls.trigger(Events.FRAG_PARSING_INIT_SEGMENT, {
|
|
|
- frag: mapFragment,
|
|
|
- id,
|
|
|
- tracks: initSegment.tracks
|
|
|
- });
|
|
|
- }
|
|
|
- if (audio) {
|
|
|
- const {
|
|
|
- startPTS,
|
|
|
- endPTS,
|
|
|
- startDTS,
|
|
|
- endDTS
|
|
|
- } = audio;
|
|
|
- if (part) {
|
|
|
- part.elementaryStreams[ElementaryStreamTypes.AUDIO] = {
|
|
|
- startPTS,
|
|
|
- endPTS,
|
|
|
- startDTS,
|
|
|
- endDTS
|
|
|
- };
|
|
|
- }
|
|
|
- frag.setElementaryStreamInfo(ElementaryStreamTypes.AUDIO, startPTS, endPTS, startDTS, endDTS);
|
|
|
- this.bufferFragmentData(audio, frag, part, chunkMeta);
|
|
|
- }
|
|
|
- if (id3 != null && (_id3$samples = id3.samples) != null && _id3$samples.length) {
|
|
|
- const emittedID3 = _extends({
|
|
|
- id,
|
|
|
- frag,
|
|
|
- details
|
|
|
- }, id3);
|
|
|
- hls.trigger(Events.FRAG_PARSING_METADATA, emittedID3);
|
|
|
- }
|
|
|
- if (text) {
|
|
|
- const emittedText = _extends({
|
|
|
- id,
|
|
|
- frag,
|
|
|
- details
|
|
|
- }, text);
|
|
|
- hls.trigger(Events.FRAG_PARSING_USERDATA, emittedText);
|
|
|
- }
|
|
|
- }
|
|
|
- _bufferInitSegment(currentLevel, tracks, frag, chunkMeta) {
|
|
|
- if (this.state !== State.PARSING) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (tracks.video) {
|
|
|
- delete tracks.video;
|
|
|
- }
|
|
|
- if (tracks.audiovideo) {
|
|
|
- delete tracks.audiovideo;
|
|
|
- }
|
|
|
- if (!tracks.audio) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const track = tracks.audio;
|
|
|
- track.id = PlaylistLevelType.AUDIO;
|
|
|
- const variantAudioCodecs = currentLevel.audioCodec;
|
|
|
- this.log(`Init audio buffer, container:${track.container}, codecs[level/parsed]=[${variantAudioCodecs}/${track.codec}]`);
|
|
|
- if (variantAudioCodecs && variantAudioCodecs.split(",").length === 1) {
|
|
|
- track.levelCodec = variantAudioCodecs;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.BUFFER_CODECS, tracks);
|
|
|
- const initSegment = track.initSegment;
|
|
|
- if (initSegment != null && initSegment.byteLength) {
|
|
|
- const segment = {
|
|
|
- type: "audio",
|
|
|
- frag,
|
|
|
- part: null,
|
|
|
- chunkMeta,
|
|
|
- parent: frag.type,
|
|
|
- data: initSegment
|
|
|
- };
|
|
|
- this.hls.trigger(Events.BUFFER_APPENDING, segment);
|
|
|
- }
|
|
|
- this.tickImmediate();
|
|
|
- }
|
|
|
- loadFragment(frag, track, targetBufferTime) {
|
|
|
- const fragState = this.fragmentTracker.getState(frag);
|
|
|
- if (this.switchingTrack || fragState === FragmentState.NOT_LOADED || fragState === FragmentState.PARTIAL) {
|
|
|
- var _track$details;
|
|
|
- if (!isMediaFragment(frag)) {
|
|
|
- this._loadInitSegment(frag, track);
|
|
|
- } else if ((_track$details = track.details) != null && _track$details.live && !this.initPTS[frag.cc]) {
|
|
|
- this.log(`Waiting for video PTS in continuity counter ${frag.cc} of live stream before loading audio fragment ${frag.sn} of level ${this.trackId}`);
|
|
|
- this.state = State.WAITING_INIT_PTS;
|
|
|
- const mainDetails = this.mainDetails;
|
|
|
- if (mainDetails && mainDetails.fragmentStart !== track.details.fragmentStart) {
|
|
|
- alignMediaPlaylistByPDT(track.details, mainDetails);
|
|
|
- }
|
|
|
- } else {
|
|
|
- super.loadFragment(frag, track, targetBufferTime);
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.clearTrackerIfNeeded(frag);
|
|
|
- }
|
|
|
- }
|
|
|
- flushAudioIfNeeded(switchingTrack) {
|
|
|
- if (this.media && this.bufferedTrack) {
|
|
|
- const {
|
|
|
- name,
|
|
|
- lang,
|
|
|
- assocLang,
|
|
|
- characteristics,
|
|
|
- audioCodec,
|
|
|
- channels
|
|
|
- } = this.bufferedTrack;
|
|
|
- if (!matchesOption({
|
|
|
- name,
|
|
|
- lang,
|
|
|
- assocLang,
|
|
|
- characteristics,
|
|
|
- audioCodec,
|
|
|
- channels
|
|
|
- }, switchingTrack, audioMatchPredicate)) {
|
|
|
- if (useAlternateAudio(switchingTrack.url, this.hls)) {
|
|
|
- this.log("Switching audio track : flushing all audio");
|
|
|
- super.flushMainBuffer(0, Number.POSITIVE_INFINITY, "audio");
|
|
|
- this.bufferedTrack = null;
|
|
|
- } else {
|
|
|
- this.bufferedTrack = switchingTrack;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- completeAudioSwitch(switchingTrack) {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- this.flushAudioIfNeeded(switchingTrack);
|
|
|
- this.bufferedTrack = switchingTrack;
|
|
|
- this.switchingTrack = null;
|
|
|
- hls.trigger(Events.AUDIO_TRACK_SWITCHED, _objectSpread2({}, switchingTrack));
|
|
|
- }
|
|
|
-};
|
|
|
-var BasePlaylistController = class extends Logger {
|
|
|
- constructor(hls, logPrefix) {
|
|
|
- super(logPrefix, hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.canLoad = false;
|
|
|
- this.timer = -1;
|
|
|
- this.hls = hls;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.clearTimer();
|
|
|
- this.hls = this.log = this.warn = null;
|
|
|
- }
|
|
|
- clearTimer() {
|
|
|
- if (this.timer !== -1) {
|
|
|
- self.clearTimeout(this.timer);
|
|
|
- this.timer = -1;
|
|
|
- }
|
|
|
- }
|
|
|
- startLoad() {
|
|
|
- this.canLoad = true;
|
|
|
- this.loadPlaylist();
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- this.canLoad = false;
|
|
|
- this.clearTimer();
|
|
|
- }
|
|
|
- switchParams(playlistUri, previous, current) {
|
|
|
- const renditionReports = previous == null ? void 0 : previous.renditionReports;
|
|
|
- if (renditionReports) {
|
|
|
- let foundIndex = -1;
|
|
|
- for (let i = 0; i < renditionReports.length; i++) {
|
|
|
- const attr = renditionReports[i];
|
|
|
- let uri;
|
|
|
- try {
|
|
|
- uri = new self.URL(attr.URI, previous.url).href;
|
|
|
- } catch (error) {
|
|
|
- this.warn(`Could not construct new URL for Rendition Report: ${error}`);
|
|
|
- uri = attr.URI || "";
|
|
|
- }
|
|
|
- if (uri === playlistUri) {
|
|
|
- foundIndex = i;
|
|
|
- break;
|
|
|
- } else if (uri === playlistUri.substring(0, uri.length)) {
|
|
|
- foundIndex = i;
|
|
|
- }
|
|
|
- }
|
|
|
- if (foundIndex !== -1) {
|
|
|
- const attr = renditionReports[foundIndex];
|
|
|
- const msn = parseInt(attr["LAST-MSN"]) || previous.lastPartSn;
|
|
|
- let part = parseInt(attr["LAST-PART"]) || previous.lastPartIndex;
|
|
|
- if (this.hls.config.lowLatencyMode) {
|
|
|
- const currentGoal = Math.min(previous.age - previous.partTarget, previous.targetduration);
|
|
|
- if (part >= 0 && currentGoal > previous.partTarget) {
|
|
|
- part += 1;
|
|
|
- }
|
|
|
- }
|
|
|
- const skip = current && getSkipValue(current);
|
|
|
- return new HlsUrlParameters(msn, part >= 0 ? part : void 0, skip);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- loadPlaylist(hlsUrlParameters) {
|
|
|
- this.clearTimer();
|
|
|
- }
|
|
|
- loadingPlaylist(playlist, hlsUrlParameters) {
|
|
|
- this.clearTimer();
|
|
|
- }
|
|
|
- shouldLoadPlaylist(playlist) {
|
|
|
- return this.canLoad && !!playlist && !!playlist.url && (!playlist.details || playlist.details.live);
|
|
|
- }
|
|
|
- getUrlWithDirectives(uri, hlsUrlParameters) {
|
|
|
- if (hlsUrlParameters) {
|
|
|
- try {
|
|
|
- return hlsUrlParameters.addDirectives(uri);
|
|
|
- } catch (error) {
|
|
|
- this.warn(`Could not construct new URL with HLS Delivery Directives: ${error}`);
|
|
|
- }
|
|
|
- }
|
|
|
- return uri;
|
|
|
- }
|
|
|
- playlistLoaded(index, data, previousDetails) {
|
|
|
- const {
|
|
|
- details,
|
|
|
- stats
|
|
|
- } = data;
|
|
|
- const now2 = self.performance.now();
|
|
|
- const elapsed = stats.loading.first ? Math.max(0, now2 - stats.loading.first) : 0;
|
|
|
- details.advancedDateTime = Date.now() - elapsed;
|
|
|
- const timelineOffset = this.hls.config.timelineOffset;
|
|
|
- if (timelineOffset !== details.appliedTimelineOffset) {
|
|
|
- const offset = Math.max(timelineOffset || 0, 0);
|
|
|
- details.appliedTimelineOffset = offset;
|
|
|
- details.fragments.forEach((frag) => {
|
|
|
- frag.setStart(frag.playlistOffset + offset);
|
|
|
- });
|
|
|
- }
|
|
|
- if (details.live || previousDetails != null && previousDetails.live) {
|
|
|
- const levelOrTrack = "levelInfo" in data ? data.levelInfo : data.track;
|
|
|
- details.reloaded(previousDetails);
|
|
|
- if (previousDetails && details.fragments.length > 0) {
|
|
|
- mergeDetails(previousDetails, details, this);
|
|
|
- const error = details.playlistParsingError;
|
|
|
- if (error) {
|
|
|
- this.warn(error);
|
|
|
- const hls = this.hls;
|
|
|
- if (!hls.config.ignorePlaylistParsingErrors) {
|
|
|
- var _details$fragments$;
|
|
|
- const {
|
|
|
- networkDetails
|
|
|
- } = data;
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.LEVEL_PARSING_ERROR,
|
|
|
- fatal: false,
|
|
|
- url: details.url,
|
|
|
- error,
|
|
|
- reason: error.message,
|
|
|
- level: data.level || void 0,
|
|
|
- parent: (_details$fragments$ = details.fragments[0]) == null ? void 0 : _details$fragments$.type,
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- details.playlistParsingError = null;
|
|
|
- }
|
|
|
- }
|
|
|
- if (details.requestScheduled === -1) {
|
|
|
- details.requestScheduled = stats.loading.start;
|
|
|
- }
|
|
|
- const bufferInfo = this.hls.mainForwardBufferInfo;
|
|
|
- const position = bufferInfo ? bufferInfo.end - bufferInfo.len : 0;
|
|
|
- const distanceToLiveEdgeMs = (details.edge - position) * 1e3;
|
|
|
- const reloadInterval = computeReloadInterval(details, distanceToLiveEdgeMs);
|
|
|
- if (details.requestScheduled + reloadInterval < now2) {
|
|
|
- details.requestScheduled = now2;
|
|
|
- } else {
|
|
|
- details.requestScheduled += reloadInterval;
|
|
|
- }
|
|
|
- this.log(`live playlist ${index} ${details.advanced ? "REFRESHED " + details.lastPartSn + "-" + details.lastPartIndex : details.updated ? "UPDATED" : "MISSED"}`);
|
|
|
- if (!this.canLoad || !details.live) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let deliveryDirectives;
|
|
|
- let msn = void 0;
|
|
|
- let part = void 0;
|
|
|
- if (details.canBlockReload && details.endSN && details.advanced) {
|
|
|
- const lowLatencyMode = this.hls.config.lowLatencyMode;
|
|
|
- const lastPartSn = details.lastPartSn;
|
|
|
- const endSn = details.endSN;
|
|
|
- const lastPartIndex = details.lastPartIndex;
|
|
|
- const hasParts = lastPartIndex !== -1;
|
|
|
- const atLastPartOfSegment = lastPartSn === endSn;
|
|
|
- if (hasParts) {
|
|
|
- if (atLastPartOfSegment) {
|
|
|
- msn = endSn + 1;
|
|
|
- part = lowLatencyMode ? 0 : lastPartIndex;
|
|
|
- } else {
|
|
|
- msn = lastPartSn;
|
|
|
- part = lowLatencyMode ? lastPartIndex + 1 : details.maxPartIndex;
|
|
|
- }
|
|
|
- } else {
|
|
|
- msn = endSn + 1;
|
|
|
- }
|
|
|
- const lastAdvanced = details.age;
|
|
|
- const cdnAge = lastAdvanced + details.ageHeader;
|
|
|
- let currentGoal = Math.min(cdnAge - details.partTarget, details.targetduration * 1.5);
|
|
|
- if (currentGoal > 0) {
|
|
|
- if (cdnAge > details.targetduration * 3) {
|
|
|
- this.log(`Playlist last advanced ${lastAdvanced.toFixed(2)}s ago. Omitting segment and part directives.`);
|
|
|
- msn = void 0;
|
|
|
- part = void 0;
|
|
|
- } else if (previousDetails != null && previousDetails.tuneInGoal && cdnAge - details.partTarget > previousDetails.tuneInGoal) {
|
|
|
- this.warn(`CDN Tune-in goal increased from: ${previousDetails.tuneInGoal} to: ${currentGoal} with playlist age: ${details.age}`);
|
|
|
- currentGoal = 0;
|
|
|
- } else {
|
|
|
- const segments = Math.floor(currentGoal / details.targetduration);
|
|
|
- msn += segments;
|
|
|
- if (part !== void 0) {
|
|
|
- const parts = Math.round(currentGoal % details.targetduration / details.partTarget);
|
|
|
- part += parts;
|
|
|
- }
|
|
|
- this.log(`CDN Tune-in age: ${details.ageHeader}s last advanced ${lastAdvanced.toFixed(2)}s goal: ${currentGoal} skip sn ${segments} to part ${part}`);
|
|
|
- }
|
|
|
- details.tuneInGoal = currentGoal;
|
|
|
- }
|
|
|
- deliveryDirectives = this.getDeliveryDirectives(details, data.deliveryDirectives, msn, part);
|
|
|
- if (lowLatencyMode || !atLastPartOfSegment) {
|
|
|
- details.requestScheduled = now2;
|
|
|
- this.loadingPlaylist(levelOrTrack, deliveryDirectives);
|
|
|
- return;
|
|
|
- }
|
|
|
- } else if (details.canBlockReload || details.canSkipUntil) {
|
|
|
- deliveryDirectives = this.getDeliveryDirectives(details, data.deliveryDirectives, msn, part);
|
|
|
- }
|
|
|
- if (deliveryDirectives && msn !== void 0 && details.canBlockReload) {
|
|
|
- details.requestScheduled = stats.loading.first + Math.max(reloadInterval - elapsed * 2, reloadInterval / 2);
|
|
|
- }
|
|
|
- this.scheduleLoading(levelOrTrack, deliveryDirectives, details);
|
|
|
- } else {
|
|
|
- this.clearTimer();
|
|
|
- }
|
|
|
- }
|
|
|
- scheduleLoading(levelOrTrack, deliveryDirectives, updatedDetails) {
|
|
|
- const details = updatedDetails || levelOrTrack.details;
|
|
|
- if (!details) {
|
|
|
- this.loadingPlaylist(levelOrTrack, deliveryDirectives);
|
|
|
- return;
|
|
|
- }
|
|
|
- const now2 = self.performance.now();
|
|
|
- const requestScheduled = details.requestScheduled;
|
|
|
- if (now2 >= requestScheduled) {
|
|
|
- this.loadingPlaylist(levelOrTrack, deliveryDirectives);
|
|
|
- return;
|
|
|
- }
|
|
|
- const estimatedTimeUntilUpdate = requestScheduled - now2;
|
|
|
- this.log(`reload live playlist ${levelOrTrack.name || levelOrTrack.bitrate + "bps"} in ${Math.round(estimatedTimeUntilUpdate)} ms`);
|
|
|
- this.clearTimer();
|
|
|
- this.timer = self.setTimeout(() => this.loadingPlaylist(levelOrTrack, deliveryDirectives), estimatedTimeUntilUpdate);
|
|
|
- }
|
|
|
- getDeliveryDirectives(details, previousDeliveryDirectives, msn, part) {
|
|
|
- let skip = getSkipValue(details);
|
|
|
- if (previousDeliveryDirectives != null && previousDeliveryDirectives.skip && details.deltaUpdateFailed) {
|
|
|
- msn = previousDeliveryDirectives.msn;
|
|
|
- part = previousDeliveryDirectives.part;
|
|
|
- skip = HlsSkip.No;
|
|
|
- }
|
|
|
- return new HlsUrlParameters(msn, part, skip);
|
|
|
- }
|
|
|
- checkRetry(errorEvent) {
|
|
|
- const errorDetails = errorEvent.details;
|
|
|
- const isTimeout = isTimeoutError(errorEvent);
|
|
|
- const errorAction = errorEvent.errorAction;
|
|
|
- const {
|
|
|
- action,
|
|
|
- retryCount = 0,
|
|
|
- retryConfig
|
|
|
- } = errorAction || {};
|
|
|
- const retry = !!errorAction && !!retryConfig && (action === NetworkErrorAction.RetryRequest || !errorAction.resolved && action === NetworkErrorAction.SendAlternateToPenaltyBox);
|
|
|
- if (retry) {
|
|
|
- var _errorEvent$context;
|
|
|
- if (retryCount >= retryConfig.maxNumRetry) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (isTimeout && (_errorEvent$context = errorEvent.context) != null && _errorEvent$context.deliveryDirectives) {
|
|
|
- this.warn(`Retrying playlist loading ${retryCount + 1}/${retryConfig.maxNumRetry} after "${errorDetails}" without delivery-directives`);
|
|
|
- this.loadPlaylist();
|
|
|
- } else {
|
|
|
- const delay = getRetryDelay(retryConfig, retryCount);
|
|
|
- this.clearTimer();
|
|
|
- this.timer = self.setTimeout(() => this.loadPlaylist(), delay);
|
|
|
- this.warn(`Retrying playlist loading ${retryCount + 1}/${retryConfig.maxNumRetry} after "${errorDetails}" in ${delay}ms`);
|
|
|
- }
|
|
|
- errorEvent.levelRetry = true;
|
|
|
- errorAction.resolved = true;
|
|
|
- }
|
|
|
- return retry;
|
|
|
- }
|
|
|
-};
|
|
|
-function subtitleOptionsIdentical(trackList1, trackList2) {
|
|
|
- if (trackList1.length !== trackList2.length) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (let i = 0; i < trackList1.length; i++) {
|
|
|
- if (!mediaAttributesIdentical(trackList1[i].attrs, trackList2[i].attrs)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
-}
|
|
|
-function mediaAttributesIdentical(attrs1, attrs2, customAttributes) {
|
|
|
- const stableRenditionId = attrs1["STABLE-RENDITION-ID"];
|
|
|
- if (stableRenditionId && !customAttributes) {
|
|
|
- return stableRenditionId === attrs2["STABLE-RENDITION-ID"];
|
|
|
- }
|
|
|
- return !(customAttributes || ["LANGUAGE", "NAME", "CHARACTERISTICS", "AUTOSELECT", "DEFAULT", "FORCED", "ASSOC-LANGUAGE"]).some((subtitleAttribute) => attrs1[subtitleAttribute] !== attrs2[subtitleAttribute]);
|
|
|
-}
|
|
|
-function subtitleTrackMatchesTextTrack(subtitleTrack, textTrack) {
|
|
|
- return textTrack.label.toLowerCase() === subtitleTrack.name.toLowerCase() && (!textTrack.language || textTrack.language.toLowerCase() === (subtitleTrack.lang || "").toLowerCase());
|
|
|
-}
|
|
|
-var AudioTrackController = class extends BasePlaylistController {
|
|
|
- constructor(hls) {
|
|
|
- super(hls, "audio-track-controller");
|
|
|
- this.tracks = [];
|
|
|
- this.groupIds = null;
|
|
|
- this.tracksInGroup = [];
|
|
|
- this.trackId = -1;
|
|
|
- this.currentTrack = null;
|
|
|
- this.selectDefaultTrack = true;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
|
|
|
- hls.on(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.off(Events.LEVEL_LOADING, this.onLevelLoading, this);
|
|
|
- hls.off(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.tracks.length = 0;
|
|
|
- this.tracksInGroup.length = 0;
|
|
|
- this.currentTrack = null;
|
|
|
- super.destroy();
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.tracks = [];
|
|
|
- this.tracksInGroup = [];
|
|
|
- this.groupIds = null;
|
|
|
- this.currentTrack = null;
|
|
|
- this.trackId = -1;
|
|
|
- this.selectDefaultTrack = true;
|
|
|
- }
|
|
|
- onManifestParsed(event, data) {
|
|
|
- this.tracks = data.audioTracks || [];
|
|
|
- }
|
|
|
- onAudioTrackLoaded(event, data) {
|
|
|
- const {
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- details
|
|
|
- } = data;
|
|
|
- const trackInActiveGroup = this.tracksInGroup[id];
|
|
|
- if (!trackInActiveGroup || trackInActiveGroup.groupId !== groupId) {
|
|
|
- this.warn(`Audio track with id:${id} and group:${groupId} not found in active group ${trackInActiveGroup == null ? void 0 : trackInActiveGroup.groupId}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const curDetails = trackInActiveGroup.details;
|
|
|
- trackInActiveGroup.details = data.details;
|
|
|
- this.log(`Audio track ${id} "${trackInActiveGroup.name}" lang:${trackInActiveGroup.lang} group:${groupId} loaded [${details.startSN}-${details.endSN}]`);
|
|
|
- if (id === this.trackId) {
|
|
|
- this.playlistLoaded(id, data, curDetails);
|
|
|
- }
|
|
|
- }
|
|
|
- onLevelLoading(event, data) {
|
|
|
- this.switchLevel(data.level);
|
|
|
- }
|
|
|
- onLevelSwitching(event, data) {
|
|
|
- this.switchLevel(data.level);
|
|
|
- }
|
|
|
- switchLevel(levelIndex) {
|
|
|
- const levelInfo = this.hls.levels[levelIndex];
|
|
|
- if (!levelInfo) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const audioGroups = levelInfo.audioGroups || null;
|
|
|
- const currentGroups = this.groupIds;
|
|
|
- let currentTrack = this.currentTrack;
|
|
|
- if (!audioGroups || (currentGroups == null ? void 0 : currentGroups.length) !== (audioGroups == null ? void 0 : audioGroups.length) || audioGroups != null && audioGroups.some((groupId) => (currentGroups == null ? void 0 : currentGroups.indexOf(groupId)) === -1)) {
|
|
|
- this.groupIds = audioGroups;
|
|
|
- this.trackId = -1;
|
|
|
- this.currentTrack = null;
|
|
|
- const audioTracks = this.tracks.filter((track) => !audioGroups || audioGroups.indexOf(track.groupId) !== -1);
|
|
|
- if (audioTracks.length) {
|
|
|
- if (this.selectDefaultTrack && !audioTracks.some((track) => track.default)) {
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- }
|
|
|
- audioTracks.forEach((track, i) => {
|
|
|
- track.id = i;
|
|
|
- });
|
|
|
- } else if (!currentTrack && !this.tracksInGroup.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.tracksInGroup = audioTracks;
|
|
|
- const audioPreference = this.hls.config.audioPreference;
|
|
|
- if (!currentTrack && audioPreference) {
|
|
|
- const groupIndex = findMatchingOption(audioPreference, audioTracks, audioMatchPredicate);
|
|
|
- if (groupIndex > -1) {
|
|
|
- currentTrack = audioTracks[groupIndex];
|
|
|
- } else {
|
|
|
- const allIndex = findMatchingOption(audioPreference, this.tracks);
|
|
|
- currentTrack = this.tracks[allIndex];
|
|
|
- }
|
|
|
- }
|
|
|
- let trackId = this.findTrackId(currentTrack);
|
|
|
- if (trackId === -1 && currentTrack) {
|
|
|
- trackId = this.findTrackId(null);
|
|
|
- }
|
|
|
- const audioTracksUpdated = {
|
|
|
- audioTracks
|
|
|
- };
|
|
|
- this.log(`Updating audio tracks, ${audioTracks.length} track(s) found in group(s): ${audioGroups == null ? void 0 : audioGroups.join(",")}`);
|
|
|
- this.hls.trigger(Events.AUDIO_TRACKS_UPDATED, audioTracksUpdated);
|
|
|
- const selectedTrackId = this.trackId;
|
|
|
- if (trackId !== -1 && selectedTrackId === -1) {
|
|
|
- this.setAudioTrack(trackId);
|
|
|
- } else if (audioTracks.length && selectedTrackId === -1) {
|
|
|
- var _this$groupIds;
|
|
|
- const error = new Error(`No audio track selected for current audio group-ID(s): ${(_this$groupIds = this.groupIds) == null ? void 0 : _this$groupIds.join(",")} track count: ${audioTracks.length}`);
|
|
|
- this.warn(error.message);
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.AUDIO_TRACK_LOAD_ERROR,
|
|
|
- fatal: true,
|
|
|
- error
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- if (data.fatal || !data.context) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (data.context.type === PlaylistContextType.AUDIO_TRACK && data.context.id === this.trackId && (!this.groupIds || this.groupIds.indexOf(data.context.groupId) !== -1)) {
|
|
|
- this.checkRetry(data);
|
|
|
- }
|
|
|
- }
|
|
|
- get allAudioTracks() {
|
|
|
- return this.tracks;
|
|
|
- }
|
|
|
- get audioTracks() {
|
|
|
- return this.tracksInGroup;
|
|
|
- }
|
|
|
- get audioTrack() {
|
|
|
- return this.trackId;
|
|
|
- }
|
|
|
- set audioTrack(newId) {
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- this.setAudioTrack(newId);
|
|
|
- }
|
|
|
- setAudioOption(audioOption) {
|
|
|
- const hls = this.hls;
|
|
|
- hls.config.audioPreference = audioOption;
|
|
|
- if (audioOption) {
|
|
|
- const allAudioTracks = this.allAudioTracks;
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- if (allAudioTracks.length) {
|
|
|
- const currentTrack = this.currentTrack;
|
|
|
- if (currentTrack && matchesOption(audioOption, currentTrack, audioMatchPredicate)) {
|
|
|
- return currentTrack;
|
|
|
- }
|
|
|
- const groupIndex = findMatchingOption(audioOption, this.tracksInGroup, audioMatchPredicate);
|
|
|
- if (groupIndex > -1) {
|
|
|
- const track = this.tracksInGroup[groupIndex];
|
|
|
- this.setAudioTrack(groupIndex);
|
|
|
- return track;
|
|
|
- } else if (currentTrack) {
|
|
|
- let searchIndex = hls.loadLevel;
|
|
|
- if (searchIndex === -1) {
|
|
|
- searchIndex = hls.firstAutoLevel;
|
|
|
- }
|
|
|
- const switchIndex = findClosestLevelWithAudioGroup(audioOption, hls.levels, allAudioTracks, searchIndex, audioMatchPredicate);
|
|
|
- if (switchIndex === -1) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- hls.nextLoadLevel = switchIndex;
|
|
|
- }
|
|
|
- if (audioOption.channels || audioOption.audioCodec) {
|
|
|
- const withoutCodecAndChannelsMatch = findMatchingOption(audioOption, allAudioTracks);
|
|
|
- if (withoutCodecAndChannelsMatch > -1) {
|
|
|
- return allAudioTracks[withoutCodecAndChannelsMatch];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- setAudioTrack(newId) {
|
|
|
- const tracks = this.tracksInGroup;
|
|
|
- if (newId < 0 || newId >= tracks.length) {
|
|
|
- this.warn(`Invalid audio track id: ${newId}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- const lastTrack = this.currentTrack;
|
|
|
- const track = tracks[newId];
|
|
|
- const trackLoaded = track.details && !track.details.live;
|
|
|
- if (newId === this.trackId && track === lastTrack && trackLoaded) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Switching to audio-track ${newId} "${track.name}" lang:${track.lang} group:${track.groupId} channels:${track.channels}`);
|
|
|
- this.trackId = newId;
|
|
|
- this.currentTrack = track;
|
|
|
- this.hls.trigger(Events.AUDIO_TRACK_SWITCHING, _objectSpread2({}, track));
|
|
|
- if (trackLoaded) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const hlsUrlParameters = this.switchParams(track.url, lastTrack == null ? void 0 : lastTrack.details, track.details);
|
|
|
- this.loadPlaylist(hlsUrlParameters);
|
|
|
- }
|
|
|
- findTrackId(currentTrack) {
|
|
|
- const audioTracks = this.tracksInGroup;
|
|
|
- for (let i = 0; i < audioTracks.length; i++) {
|
|
|
- const track = audioTracks[i];
|
|
|
- if (this.selectDefaultTrack && !track.default) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (!currentTrack || matchesOption(currentTrack, track, audioMatchPredicate)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- if (currentTrack) {
|
|
|
- const {
|
|
|
- name,
|
|
|
- lang,
|
|
|
- assocLang,
|
|
|
- characteristics,
|
|
|
- audioCodec,
|
|
|
- channels
|
|
|
- } = currentTrack;
|
|
|
- for (let i = 0; i < audioTracks.length; i++) {
|
|
|
- const track = audioTracks[i];
|
|
|
- if (matchesOption({
|
|
|
- name,
|
|
|
- lang,
|
|
|
- assocLang,
|
|
|
- characteristics,
|
|
|
- audioCodec,
|
|
|
- channels
|
|
|
- }, track, audioMatchPredicate)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- for (let i = 0; i < audioTracks.length; i++) {
|
|
|
- const track = audioTracks[i];
|
|
|
- if (mediaAttributesIdentical(currentTrack.attrs, track.attrs, ["LANGUAGE", "ASSOC-LANGUAGE", "CHARACTERISTICS"])) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- for (let i = 0; i < audioTracks.length; i++) {
|
|
|
- const track = audioTracks[i];
|
|
|
- if (mediaAttributesIdentical(currentTrack.attrs, track.attrs, ["LANGUAGE"])) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- loadPlaylist(hlsUrlParameters) {
|
|
|
- super.loadPlaylist();
|
|
|
- const audioTrack = this.currentTrack;
|
|
|
- if (!this.shouldLoadPlaylist(audioTrack)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (useAlternateAudio(audioTrack.url, this.hls)) {
|
|
|
- this.scheduleLoading(audioTrack, hlsUrlParameters);
|
|
|
- }
|
|
|
- }
|
|
|
- loadingPlaylist(audioTrack, hlsUrlParameters) {
|
|
|
- super.loadingPlaylist(audioTrack, hlsUrlParameters);
|
|
|
- const id = audioTrack.id;
|
|
|
- const groupId = audioTrack.groupId;
|
|
|
- const url = this.getUrlWithDirectives(audioTrack.url, hlsUrlParameters);
|
|
|
- const details = audioTrack.details;
|
|
|
- const age = details == null ? void 0 : details.age;
|
|
|
- this.log(`Loading audio-track ${id} "${audioTrack.name}" lang:${audioTrack.lang} group:${groupId}${(hlsUrlParameters == null ? void 0 : hlsUrlParameters.msn) !== void 0 ? " at sn " + hlsUrlParameters.msn + " part " + hlsUrlParameters.part : ""}${age && details.live ? " age " + age.toFixed(1) + (details.type ? " " + details.type || "" : "") : ""} ${url}`);
|
|
|
- this.hls.trigger(Events.AUDIO_TRACK_LOADING, {
|
|
|
- url,
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- deliveryDirectives: hlsUrlParameters || null,
|
|
|
- track: audioTrack
|
|
|
- });
|
|
|
- }
|
|
|
-};
|
|
|
-var BufferOperationQueue = class {
|
|
|
- constructor(sourceBufferReference) {
|
|
|
- this.tracks = void 0;
|
|
|
- this.queues = {
|
|
|
- video: [],
|
|
|
- audio: [],
|
|
|
- audiovideo: []
|
|
|
- };
|
|
|
- this.tracks = sourceBufferReference;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.tracks = this.queues = null;
|
|
|
- }
|
|
|
- append(operation, type, pending) {
|
|
|
- if (this.queues === null || this.tracks === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const queue = this.queues[type];
|
|
|
- queue.push(operation);
|
|
|
- if (queue.length === 1 && !pending) {
|
|
|
- this.executeNext(type);
|
|
|
- }
|
|
|
- }
|
|
|
- appendBlocker(type) {
|
|
|
- return new Promise((resolve) => {
|
|
|
- const operation = {
|
|
|
- label: "async-blocker",
|
|
|
- execute: resolve,
|
|
|
- onStart: () => {
|
|
|
- },
|
|
|
- onComplete: () => {
|
|
|
- },
|
|
|
- onError: () => {
|
|
|
- }
|
|
|
- };
|
|
|
- this.append(operation, type);
|
|
|
- });
|
|
|
- }
|
|
|
- prependBlocker(type) {
|
|
|
- return new Promise((resolve) => {
|
|
|
- if (this.queues) {
|
|
|
- const operation = {
|
|
|
- label: "async-blocker-prepend",
|
|
|
- execute: resolve,
|
|
|
- onStart: () => {
|
|
|
- },
|
|
|
- onComplete: () => {
|
|
|
- },
|
|
|
- onError: () => {
|
|
|
- }
|
|
|
- };
|
|
|
- this.queues[type].unshift(operation);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- removeBlockers() {
|
|
|
- if (this.queues === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- [this.queues.video, this.queues.audio, this.queues.audiovideo].forEach((queue) => {
|
|
|
- var _queue$;
|
|
|
- const label = (_queue$ = queue[0]) == null ? void 0 : _queue$.label;
|
|
|
- if (label === "async-blocker" || label === "async-blocker-prepend") {
|
|
|
- queue[0].execute();
|
|
|
- queue.splice(0, 1);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- unblockAudio(op) {
|
|
|
- if (this.queues === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const queue = this.queues.audio;
|
|
|
- if (queue[0] === op) {
|
|
|
- this.shiftAndExecuteNext("audio");
|
|
|
- }
|
|
|
- }
|
|
|
- executeNext(type) {
|
|
|
- if (this.queues === null || this.tracks === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const queue = this.queues[type];
|
|
|
- if (queue.length) {
|
|
|
- const operation = queue[0];
|
|
|
- try {
|
|
|
- operation.execute();
|
|
|
- } catch (error) {
|
|
|
- var _this$tracks$type;
|
|
|
- operation.onError(error);
|
|
|
- if (this.queues === null || this.tracks === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const sb = (_this$tracks$type = this.tracks[type]) == null ? void 0 : _this$tracks$type.buffer;
|
|
|
- if (!(sb != null && sb.updating)) {
|
|
|
- this.shiftAndExecuteNext(type);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- shiftAndExecuteNext(type) {
|
|
|
- if (this.queues === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.queues[type].shift();
|
|
|
- this.executeNext(type);
|
|
|
- }
|
|
|
- current(type) {
|
|
|
- var _this$queues;
|
|
|
- return ((_this$queues = this.queues) == null ? void 0 : _this$queues[type][0]) || null;
|
|
|
- }
|
|
|
- toString() {
|
|
|
- const {
|
|
|
- queues,
|
|
|
- tracks
|
|
|
- } = this;
|
|
|
- if (queues === null || tracks === null) {
|
|
|
- return `<destroyed>`;
|
|
|
- }
|
|
|
- return `
|
|
|
-${this.list("video")}
|
|
|
-${this.list("audio")}
|
|
|
-${this.list("audiovideo")}}`;
|
|
|
- }
|
|
|
- list(type) {
|
|
|
- var _this$queues2, _this$tracks;
|
|
|
- return (_this$queues2 = this.queues) != null && _this$queues2[type] || (_this$tracks = this.tracks) != null && _this$tracks[type] ? `${type}: (${this.listSbInfo(type)}) ${this.listOps(type)}` : "";
|
|
|
- }
|
|
|
- listSbInfo(type) {
|
|
|
- var _this$tracks2;
|
|
|
- const track = (_this$tracks2 = this.tracks) == null ? void 0 : _this$tracks2[type];
|
|
|
- const sb = track == null ? void 0 : track.buffer;
|
|
|
- if (!sb) {
|
|
|
- return "none";
|
|
|
- }
|
|
|
- return `SourceBuffer${sb.updating ? " updating" : ""}${track.ended ? " ended" : ""}${track.ending ? " ending" : ""}`;
|
|
|
- }
|
|
|
- listOps(type) {
|
|
|
- var _this$queues3;
|
|
|
- return ((_this$queues3 = this.queues) == null ? void 0 : _this$queues3[type].map((op) => op.label).join(", ")) || "";
|
|
|
- }
|
|
|
-};
|
|
|
-var VIDEO_CODEC_PROFILE_REPLACE = /(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/;
|
|
|
-var TRACK_REMOVED_ERROR_NAME = "HlsJsTrackRemovedError";
|
|
|
-var HlsJsTrackRemovedError = class extends Error {
|
|
|
- constructor(message) {
|
|
|
- super(message);
|
|
|
- this.name = TRACK_REMOVED_ERROR_NAME;
|
|
|
- }
|
|
|
-};
|
|
|
-var BufferController = class extends Logger {
|
|
|
- constructor(hls, fragmentTracker) {
|
|
|
- super("buffer-controller", hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.fragmentTracker = void 0;
|
|
|
- this.details = null;
|
|
|
- this._objectUrl = null;
|
|
|
- this.operationQueue = null;
|
|
|
- this.bufferCodecEventsTotal = 0;
|
|
|
- this.media = null;
|
|
|
- this.mediaSource = null;
|
|
|
- this.lastMpegAudioChunk = null;
|
|
|
- this.blockedAudioAppend = null;
|
|
|
- this.lastVideoAppendEnd = 0;
|
|
|
- this.appendSource = void 0;
|
|
|
- this.transferData = void 0;
|
|
|
- this.overrides = void 0;
|
|
|
- this.appendErrors = {
|
|
|
- audio: 0,
|
|
|
- video: 0,
|
|
|
- audiovideo: 0
|
|
|
- };
|
|
|
- this.tracks = {};
|
|
|
- this.sourceBuffers = [[null, null], [null, null]];
|
|
|
- this._onEndStreaming = (event) => {
|
|
|
- var _this$mediaSource;
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (((_this$mediaSource = this.mediaSource) == null ? void 0 : _this$mediaSource.readyState) !== "open") {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.hls.pauseBuffering();
|
|
|
- };
|
|
|
- this._onStartStreaming = (event) => {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.hls.resumeBuffering();
|
|
|
- };
|
|
|
- this._onMediaSourceOpen = (e) => {
|
|
|
- const {
|
|
|
- media,
|
|
|
- mediaSource
|
|
|
- } = this;
|
|
|
- if (e) {
|
|
|
- this.log("Media source opened");
|
|
|
- }
|
|
|
- if (!media || !mediaSource) {
|
|
|
- return;
|
|
|
- }
|
|
|
- mediaSource.removeEventListener("sourceopen", this._onMediaSourceOpen);
|
|
|
- media.removeEventListener("emptied", this._onMediaEmptied);
|
|
|
- this.updateDuration();
|
|
|
- this.hls.trigger(Events.MEDIA_ATTACHED, {
|
|
|
- media,
|
|
|
- mediaSource
|
|
|
- });
|
|
|
- if (this.mediaSource !== null) {
|
|
|
- this.checkPendingTracks();
|
|
|
- }
|
|
|
- };
|
|
|
- this._onMediaSourceClose = () => {
|
|
|
- this.log("Media source closed");
|
|
|
- };
|
|
|
- this._onMediaSourceEnded = () => {
|
|
|
- this.log("Media source ended");
|
|
|
- };
|
|
|
- this._onMediaEmptied = () => {
|
|
|
- const {
|
|
|
- mediaSrc,
|
|
|
- _objectUrl
|
|
|
- } = this;
|
|
|
- if (mediaSrc !== _objectUrl) {
|
|
|
- this.error(`Media element src was set while attaching MediaSource (${_objectUrl} > ${mediaSrc})`);
|
|
|
- }
|
|
|
- };
|
|
|
- this.hls = hls;
|
|
|
- this.fragmentTracker = fragmentTracker;
|
|
|
- this.appendSource = isManagedMediaSource(getMediaSource(hls.config.preferManagedMediaSource));
|
|
|
- this.initTracks();
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- hasSourceTypes() {
|
|
|
- return Object.keys(this.tracks).length > 0;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.details = null;
|
|
|
- this.lastMpegAudioChunk = this.blockedAudioAppend = null;
|
|
|
- this.transferData = this.overrides = void 0;
|
|
|
- if (this.operationQueue) {
|
|
|
- this.operationQueue.destroy();
|
|
|
- this.operationQueue = null;
|
|
|
- }
|
|
|
- this.hls = this.fragmentTracker = null;
|
|
|
- this._onMediaSourceOpen = this._onMediaSourceClose = null;
|
|
|
- this._onMediaSourceEnded = null;
|
|
|
- this._onStartStreaming = this._onEndStreaming = null;
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.on(Events.BUFFER_RESET, this.onBufferReset, this);
|
|
|
- hls.on(Events.BUFFER_APPENDING, this.onBufferAppending, this);
|
|
|
- hls.on(Events.BUFFER_CODECS, this.onBufferCodecs, this);
|
|
|
- hls.on(Events.BUFFER_EOS, this.onBufferEos, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.on(Events.FRAG_PARSED, this.onFragParsed, this);
|
|
|
- hls.on(Events.FRAG_CHANGED, this.onFragChanged, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.off(Events.BUFFER_RESET, this.onBufferReset, this);
|
|
|
- hls.off(Events.BUFFER_APPENDING, this.onBufferAppending, this);
|
|
|
- hls.off(Events.BUFFER_CODECS, this.onBufferCodecs, this);
|
|
|
- hls.off(Events.BUFFER_EOS, this.onBufferEos, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.off(Events.FRAG_PARSED, this.onFragParsed, this);
|
|
|
- hls.off(Events.FRAG_CHANGED, this.onFragChanged, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- transferMedia() {
|
|
|
- const {
|
|
|
- media,
|
|
|
- mediaSource
|
|
|
- } = this;
|
|
|
- if (!media) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const tracks = {};
|
|
|
- if (this.operationQueue) {
|
|
|
- const updating = this.isUpdating();
|
|
|
- if (!updating) {
|
|
|
- this.operationQueue.removeBlockers();
|
|
|
- }
|
|
|
- const queued = this.isQueued();
|
|
|
- if (updating || queued) {
|
|
|
- this.warn(`Transfering MediaSource with${queued ? " operations in queue" : ""}${updating ? " updating SourceBuffer(s)" : ""} ${this.operationQueue}`);
|
|
|
- }
|
|
|
- this.operationQueue.destroy();
|
|
|
- }
|
|
|
- const transferData = this.transferData;
|
|
|
- if (!this.sourceBufferCount && transferData && transferData.mediaSource === mediaSource) {
|
|
|
- _extends(tracks, transferData.tracks);
|
|
|
- } else {
|
|
|
- this.sourceBuffers.forEach((tuple) => {
|
|
|
- const [type] = tuple;
|
|
|
- if (type) {
|
|
|
- tracks[type] = _extends({}, this.tracks[type]);
|
|
|
- this.removeBuffer(type);
|
|
|
- }
|
|
|
- tuple[0] = tuple[1] = null;
|
|
|
- });
|
|
|
- }
|
|
|
- return {
|
|
|
- media,
|
|
|
- mediaSource,
|
|
|
- tracks
|
|
|
- };
|
|
|
- }
|
|
|
- initTracks() {
|
|
|
- const tracks = {};
|
|
|
- this.sourceBuffers = [[null, null], [null, null]];
|
|
|
- this.tracks = tracks;
|
|
|
- this.resetQueue();
|
|
|
- this.resetAppendErrors();
|
|
|
- this.lastMpegAudioChunk = this.blockedAudioAppend = null;
|
|
|
- this.lastVideoAppendEnd = 0;
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.bufferCodecEventsTotal = 0;
|
|
|
- this.details = null;
|
|
|
- }
|
|
|
- onManifestParsed(event, data) {
|
|
|
- var _this$transferData;
|
|
|
- let codecEvents = 2;
|
|
|
- if (data.audio && !data.video || !data.altAudio) {
|
|
|
- codecEvents = 1;
|
|
|
- }
|
|
|
- this.bufferCodecEventsTotal = codecEvents;
|
|
|
- this.log(`${codecEvents} bufferCodec event(s) expected.`);
|
|
|
- if ((_this$transferData = this.transferData) != null && _this$transferData.mediaSource && this.sourceBufferCount && codecEvents) {
|
|
|
- this.bufferCreated();
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaAttaching(event, data) {
|
|
|
- const media = this.media = data.media;
|
|
|
- this.transferData = this.overrides = void 0;
|
|
|
- const MediaSource = getMediaSource(this.appendSource);
|
|
|
- if (MediaSource) {
|
|
|
- const transferringMedia = !!data.mediaSource;
|
|
|
- if (transferringMedia || data.overrides) {
|
|
|
- this.transferData = data;
|
|
|
- this.overrides = data.overrides;
|
|
|
- }
|
|
|
- const ms = this.mediaSource = data.mediaSource || new MediaSource();
|
|
|
- this.assignMediaSource(ms);
|
|
|
- if (transferringMedia) {
|
|
|
- this._objectUrl = media.src;
|
|
|
- this.attachTransferred();
|
|
|
- } else {
|
|
|
- const objectUrl = this._objectUrl = self.URL.createObjectURL(ms);
|
|
|
- if (this.appendSource) {
|
|
|
- try {
|
|
|
- media.removeAttribute("src");
|
|
|
- const MMS = self.ManagedMediaSource;
|
|
|
- media.disableRemotePlayback = media.disableRemotePlayback || MMS && ms instanceof MMS;
|
|
|
- removeSourceChildren(media);
|
|
|
- addSource(media, objectUrl);
|
|
|
- media.load();
|
|
|
- } catch (error) {
|
|
|
- media.src = objectUrl;
|
|
|
- }
|
|
|
- } else {
|
|
|
- media.src = objectUrl;
|
|
|
- }
|
|
|
- }
|
|
|
- media.addEventListener("emptied", this._onMediaEmptied);
|
|
|
- }
|
|
|
- }
|
|
|
- assignMediaSource(ms) {
|
|
|
- var _this$transferData2, _ms$constructor;
|
|
|
- this.log(`${((_this$transferData2 = this.transferData) == null ? void 0 : _this$transferData2.mediaSource) === ms ? "transferred" : "created"} media source: ${(_ms$constructor = ms.constructor) == null ? void 0 : _ms$constructor.name}`);
|
|
|
- ms.addEventListener("sourceopen", this._onMediaSourceOpen);
|
|
|
- ms.addEventListener("sourceended", this._onMediaSourceEnded);
|
|
|
- ms.addEventListener("sourceclose", this._onMediaSourceClose);
|
|
|
- if (this.appendSource) {
|
|
|
- ms.addEventListener("startstreaming", this._onStartStreaming);
|
|
|
- ms.addEventListener("endstreaming", this._onEndStreaming);
|
|
|
- }
|
|
|
- }
|
|
|
- attachTransferred() {
|
|
|
- const media = this.media;
|
|
|
- const data = this.transferData;
|
|
|
- if (!data || !media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const requiredTracks = this.tracks;
|
|
|
- const transferredTracks = data.tracks;
|
|
|
- const trackNames = transferredTracks ? Object.keys(transferredTracks) : null;
|
|
|
- const trackCount = trackNames ? trackNames.length : 0;
|
|
|
- const mediaSourceOpenCallback = () => {
|
|
|
- Promise.resolve().then(() => {
|
|
|
- if (this.media && this.mediaSourceOpenOrEnded) {
|
|
|
- this._onMediaSourceOpen();
|
|
|
- }
|
|
|
- });
|
|
|
- };
|
|
|
- if (transferredTracks && trackNames && trackCount) {
|
|
|
- if (!this.tracksReady) {
|
|
|
- this.hls.config.startFragPrefetch = true;
|
|
|
- this.log(`attachTransferred: waiting for SourceBuffer track info`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`attachTransferred: (bufferCodecEventsTotal ${this.bufferCodecEventsTotal})
|
|
|
-required tracks: ${stringify(requiredTracks, (key, value) => key === "initSegment" ? void 0 : value)};
|
|
|
-transfer tracks: ${stringify(transferredTracks, (key, value) => key === "initSegment" ? void 0 : value)}}`);
|
|
|
- if (!isCompatibleTrackChange(transferredTracks, requiredTracks)) {
|
|
|
- data.mediaSource = null;
|
|
|
- data.tracks = void 0;
|
|
|
- const currentTime = media.currentTime;
|
|
|
- const details = this.details;
|
|
|
- const startTime = Math.max(currentTime, (details == null ? void 0 : details.fragments[0].start) || 0);
|
|
|
- if (startTime - currentTime > 1) {
|
|
|
- this.log(`attachTransferred: waiting for playback to reach new tracks start time ${currentTime} -> ${startTime}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.warn(`attachTransferred: resetting MediaSource for incompatible tracks ("${Object.keys(transferredTracks)}"->"${Object.keys(requiredTracks)}") start time: ${startTime} currentTime: ${currentTime}`);
|
|
|
- this.onMediaDetaching(Events.MEDIA_DETACHING, {});
|
|
|
- this.onMediaAttaching(Events.MEDIA_ATTACHING, data);
|
|
|
- media.currentTime = startTime;
|
|
|
- return;
|
|
|
- }
|
|
|
- this.transferData = void 0;
|
|
|
- trackNames.forEach((trackName) => {
|
|
|
- const type = trackName;
|
|
|
- const track = transferredTracks[type];
|
|
|
- if (track) {
|
|
|
- const sb = track.buffer;
|
|
|
- if (sb) {
|
|
|
- const fragmentTracker = this.fragmentTracker;
|
|
|
- const playlistType = track.id;
|
|
|
- if (fragmentTracker.hasFragments(playlistType) || fragmentTracker.hasParts(playlistType)) {
|
|
|
- const bufferedTimeRanges = BufferHelper.getBuffered(sb);
|
|
|
- fragmentTracker.detectEvictedFragments(type, bufferedTimeRanges, playlistType, null, true);
|
|
|
- }
|
|
|
- const sbIndex = sourceBufferNameToIndex(type);
|
|
|
- const sbTuple = [type, sb];
|
|
|
- this.sourceBuffers[sbIndex] = sbTuple;
|
|
|
- if (sb.updating && this.operationQueue) {
|
|
|
- this.operationQueue.prependBlocker(type);
|
|
|
- }
|
|
|
- this.trackSourceBuffer(type, track);
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- mediaSourceOpenCallback();
|
|
|
- this.bufferCreated();
|
|
|
- } else {
|
|
|
- this.log(`attachTransferred: MediaSource w/o SourceBuffers`);
|
|
|
- mediaSourceOpenCallback();
|
|
|
- }
|
|
|
- }
|
|
|
- get mediaSourceOpenOrEnded() {
|
|
|
- var _this$mediaSource2;
|
|
|
- const readyState = (_this$mediaSource2 = this.mediaSource) == null ? void 0 : _this$mediaSource2.readyState;
|
|
|
- return readyState === "open" || readyState === "ended";
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- const transferringMedia = !!data.transferMedia;
|
|
|
- this.transferData = this.overrides = void 0;
|
|
|
- const {
|
|
|
- media,
|
|
|
- mediaSource,
|
|
|
- _objectUrl
|
|
|
- } = this;
|
|
|
- if (mediaSource) {
|
|
|
- this.log(`media source ${transferringMedia ? "transferring" : "detaching"}`);
|
|
|
- if (transferringMedia) {
|
|
|
- this.sourceBuffers.forEach(([type]) => {
|
|
|
- if (type) {
|
|
|
- this.removeBuffer(type);
|
|
|
- }
|
|
|
- });
|
|
|
- this.resetQueue();
|
|
|
- } else {
|
|
|
- if (this.mediaSourceOpenOrEnded) {
|
|
|
- const open = mediaSource.readyState === "open";
|
|
|
- try {
|
|
|
- const sourceBuffers = mediaSource.sourceBuffers;
|
|
|
- for (let i = sourceBuffers.length; i--; ) {
|
|
|
- if (open) {
|
|
|
- sourceBuffers[i].abort();
|
|
|
- }
|
|
|
- mediaSource.removeSourceBuffer(sourceBuffers[i]);
|
|
|
- }
|
|
|
- if (open) {
|
|
|
- mediaSource.endOfStream();
|
|
|
- }
|
|
|
- } catch (err) {
|
|
|
- this.warn(`onMediaDetaching: ${err.message} while calling endOfStream`);
|
|
|
- }
|
|
|
- }
|
|
|
- if (this.sourceBufferCount) {
|
|
|
- this.onBufferReset();
|
|
|
- }
|
|
|
- }
|
|
|
- mediaSource.removeEventListener("sourceopen", this._onMediaSourceOpen);
|
|
|
- mediaSource.removeEventListener("sourceended", this._onMediaSourceEnded);
|
|
|
- mediaSource.removeEventListener("sourceclose", this._onMediaSourceClose);
|
|
|
- if (this.appendSource) {
|
|
|
- mediaSource.removeEventListener("startstreaming", this._onStartStreaming);
|
|
|
- mediaSource.removeEventListener("endstreaming", this._onEndStreaming);
|
|
|
- }
|
|
|
- this.mediaSource = null;
|
|
|
- this._objectUrl = null;
|
|
|
- }
|
|
|
- if (media) {
|
|
|
- media.removeEventListener("emptied", this._onMediaEmptied);
|
|
|
- if (!transferringMedia) {
|
|
|
- if (_objectUrl) {
|
|
|
- self.URL.revokeObjectURL(_objectUrl);
|
|
|
- }
|
|
|
- if (this.mediaSrc === _objectUrl) {
|
|
|
- media.removeAttribute("src");
|
|
|
- if (this.appendSource) {
|
|
|
- removeSourceChildren(media);
|
|
|
- }
|
|
|
- media.load();
|
|
|
- } else {
|
|
|
- this.warn("media|source.src was changed by a third party - skip cleanup");
|
|
|
- }
|
|
|
- }
|
|
|
- this.media = null;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.MEDIA_DETACHED, data);
|
|
|
- }
|
|
|
- onBufferReset() {
|
|
|
- this.sourceBuffers.forEach(([type]) => {
|
|
|
- if (type) {
|
|
|
- this.resetBuffer(type);
|
|
|
- }
|
|
|
- });
|
|
|
- this.initTracks();
|
|
|
- }
|
|
|
- resetBuffer(type) {
|
|
|
- var _this$tracks$type;
|
|
|
- const sb = (_this$tracks$type = this.tracks[type]) == null ? void 0 : _this$tracks$type.buffer;
|
|
|
- this.removeBuffer(type);
|
|
|
- if (sb) {
|
|
|
- try {
|
|
|
- var _this$mediaSource3;
|
|
|
- if ((_this$mediaSource3 = this.mediaSource) != null && _this$mediaSource3.sourceBuffers.length) {
|
|
|
- this.mediaSource.removeSourceBuffer(sb);
|
|
|
- }
|
|
|
- } catch (err) {
|
|
|
- this.warn(`onBufferReset ${type}`, err);
|
|
|
- }
|
|
|
- }
|
|
|
- delete this.tracks[type];
|
|
|
- }
|
|
|
- removeBuffer(type) {
|
|
|
- this.removeBufferListeners(type);
|
|
|
- this.sourceBuffers[sourceBufferNameToIndex(type)] = [null, null];
|
|
|
- const track = this.tracks[type];
|
|
|
- if (track) {
|
|
|
- track.buffer = void 0;
|
|
|
- }
|
|
|
- }
|
|
|
- resetQueue() {
|
|
|
- if (this.operationQueue) {
|
|
|
- this.operationQueue.destroy();
|
|
|
- }
|
|
|
- this.operationQueue = new BufferOperationQueue(this.tracks);
|
|
|
- }
|
|
|
- onBufferCodecs(event, data) {
|
|
|
- var _data$audio;
|
|
|
- const tracks = this.tracks;
|
|
|
- const trackNames = Object.keys(data);
|
|
|
- this.log(`BUFFER_CODECS: "${trackNames}" (current SB count ${this.sourceBufferCount})`);
|
|
|
- const unmuxedToMuxed = "audiovideo" in data && (tracks.audio || tracks.video) || tracks.audiovideo && ("audio" in data || "video" in data);
|
|
|
- const muxedToUnmuxed = !unmuxedToMuxed && this.sourceBufferCount && this.media && trackNames.some((sbName) => !tracks[sbName]);
|
|
|
- if (unmuxedToMuxed || muxedToUnmuxed) {
|
|
|
- this.warn(`Unsupported transition between "${Object.keys(tracks)}" and "${trackNames}" SourceBuffers`);
|
|
|
- return;
|
|
|
- }
|
|
|
- trackNames.forEach((trackName) => {
|
|
|
- var _this$transferData3, _trackCodec;
|
|
|
- const parsedTrack = data[trackName];
|
|
|
- const {
|
|
|
- id,
|
|
|
- codec,
|
|
|
- levelCodec,
|
|
|
- container,
|
|
|
- metadata,
|
|
|
- supplemental
|
|
|
- } = parsedTrack;
|
|
|
- let track = tracks[trackName];
|
|
|
- const transferredTrack = (_this$transferData3 = this.transferData) == null || (_this$transferData3 = _this$transferData3.tracks) == null ? void 0 : _this$transferData3[trackName];
|
|
|
- const sbTrack = transferredTrack != null && transferredTrack.buffer ? transferredTrack : track;
|
|
|
- const sbCodec = (sbTrack == null ? void 0 : sbTrack.pendingCodec) || (sbTrack == null ? void 0 : sbTrack.codec);
|
|
|
- const trackLevelCodec = sbTrack == null ? void 0 : sbTrack.levelCodec;
|
|
|
- if (!track) {
|
|
|
- track = tracks[trackName] = {
|
|
|
- buffer: void 0,
|
|
|
- listeners: [],
|
|
|
- codec,
|
|
|
- supplemental,
|
|
|
- container,
|
|
|
- levelCodec,
|
|
|
- metadata,
|
|
|
- id
|
|
|
- };
|
|
|
- }
|
|
|
- const currentCodecFull = pickMostCompleteCodecName(sbCodec, trackLevelCodec);
|
|
|
- const currentCodec = currentCodecFull == null ? void 0 : currentCodecFull.replace(VIDEO_CODEC_PROFILE_REPLACE, "$1");
|
|
|
- let trackCodec = pickMostCompleteCodecName(codec, levelCodec);
|
|
|
- const nextCodec = (_trackCodec = trackCodec) == null ? void 0 : _trackCodec.replace(VIDEO_CODEC_PROFILE_REPLACE, "$1");
|
|
|
- if (trackCodec && currentCodecFull && currentCodec !== nextCodec) {
|
|
|
- if (trackName.slice(0, 5) === "audio") {
|
|
|
- trackCodec = getCodecCompatibleName(trackCodec, this.appendSource);
|
|
|
- }
|
|
|
- this.log(`switching codec ${sbCodec} to ${trackCodec}`);
|
|
|
- if (trackCodec !== (track.pendingCodec || track.codec)) {
|
|
|
- track.pendingCodec = trackCodec;
|
|
|
- }
|
|
|
- track.container = container;
|
|
|
- this.appendChangeType(trackName, container, trackCodec);
|
|
|
- }
|
|
|
- });
|
|
|
- if (this.tracksReady || this.sourceBufferCount) {
|
|
|
- data.tracks = this.sourceBufferTracks;
|
|
|
- }
|
|
|
- if (this.sourceBufferCount) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.bufferCodecEventsTotal > 1 && !this.tracks.video && !data.video && ((_data$audio = data.audio) == null ? void 0 : _data$audio.id) === "main") {
|
|
|
- this.log(`Main audio-only`);
|
|
|
- this.bufferCodecEventsTotal = 1;
|
|
|
- }
|
|
|
- if (this.mediaSourceOpenOrEnded) {
|
|
|
- this.checkPendingTracks();
|
|
|
- }
|
|
|
- }
|
|
|
- get sourceBufferTracks() {
|
|
|
- return Object.keys(this.tracks).reduce((baseTracks, type) => {
|
|
|
- const track = this.tracks[type];
|
|
|
- baseTracks[type] = {
|
|
|
- id: track.id,
|
|
|
- container: track.container,
|
|
|
- codec: track.codec,
|
|
|
- levelCodec: track.levelCodec
|
|
|
- };
|
|
|
- return baseTracks;
|
|
|
- }, {});
|
|
|
- }
|
|
|
- appendChangeType(type, container, codec) {
|
|
|
- const mimeType = `${container};codecs=${codec}`;
|
|
|
- const operation = {
|
|
|
- label: `change-type=${mimeType}`,
|
|
|
- execute: () => {
|
|
|
- const track = this.tracks[type];
|
|
|
- if (track) {
|
|
|
- const sb = track.buffer;
|
|
|
- if (sb != null && sb.changeType) {
|
|
|
- this.log(`changing ${type} sourceBuffer type to ${mimeType}`);
|
|
|
- sb.changeType(mimeType);
|
|
|
- track.codec = codec;
|
|
|
- track.container = container;
|
|
|
- }
|
|
|
- }
|
|
|
- this.shiftAndExecuteNext(type);
|
|
|
- },
|
|
|
- onStart: () => {
|
|
|
- },
|
|
|
- onComplete: () => {
|
|
|
- },
|
|
|
- onError: (error) => {
|
|
|
- this.warn(`Failed to change ${type} SourceBuffer type`, error);
|
|
|
- }
|
|
|
- };
|
|
|
- this.append(operation, type, this.isPending(this.tracks[type]));
|
|
|
- }
|
|
|
- blockAudio(partOrFrag) {
|
|
|
- var _this$fragmentTracker;
|
|
|
- const pStart = partOrFrag.start;
|
|
|
- const pTime = pStart + partOrFrag.duration * 0.05;
|
|
|
- const atGap = ((_this$fragmentTracker = this.fragmentTracker.getAppendedFrag(pStart, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker.gap) === true;
|
|
|
- if (atGap) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const op = {
|
|
|
- label: "block-audio",
|
|
|
- execute: () => {
|
|
|
- var _this$fragmentTracker2;
|
|
|
- const videoTrack = this.tracks.video;
|
|
|
- if (this.lastVideoAppendEnd > pTime || videoTrack != null && videoTrack.buffer && BufferHelper.isBuffered(videoTrack.buffer, pTime) || ((_this$fragmentTracker2 = this.fragmentTracker.getAppendedFrag(pTime, PlaylistLevelType.MAIN)) == null ? void 0 : _this$fragmentTracker2.gap) === true) {
|
|
|
- this.blockedAudioAppend = null;
|
|
|
- this.shiftAndExecuteNext("audio");
|
|
|
- }
|
|
|
- },
|
|
|
- onStart: () => {
|
|
|
- },
|
|
|
- onComplete: () => {
|
|
|
- },
|
|
|
- onError: (error) => {
|
|
|
- this.warn("Error executing block-audio operation", error);
|
|
|
- }
|
|
|
- };
|
|
|
- this.blockedAudioAppend = {
|
|
|
- op,
|
|
|
- frag: partOrFrag
|
|
|
- };
|
|
|
- this.append(op, "audio", true);
|
|
|
- }
|
|
|
- unblockAudio() {
|
|
|
- const {
|
|
|
- blockedAudioAppend,
|
|
|
- operationQueue
|
|
|
- } = this;
|
|
|
- if (blockedAudioAppend && operationQueue) {
|
|
|
- this.blockedAudioAppend = null;
|
|
|
- operationQueue.unblockAudio(blockedAudioAppend.op);
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferAppending(event, eventData) {
|
|
|
- const {
|
|
|
- tracks
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- data,
|
|
|
- type,
|
|
|
- parent,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- chunkMeta,
|
|
|
- offset
|
|
|
- } = eventData;
|
|
|
- const chunkStats = chunkMeta.buffering[type];
|
|
|
- const {
|
|
|
- sn,
|
|
|
- cc
|
|
|
- } = frag;
|
|
|
- const bufferAppendingStart = self.performance.now();
|
|
|
- chunkStats.start = bufferAppendingStart;
|
|
|
- const fragBuffering = frag.stats.buffering;
|
|
|
- const partBuffering = part ? part.stats.buffering : null;
|
|
|
- if (fragBuffering.start === 0) {
|
|
|
- fragBuffering.start = bufferAppendingStart;
|
|
|
- }
|
|
|
- if (partBuffering && partBuffering.start === 0) {
|
|
|
- partBuffering.start = bufferAppendingStart;
|
|
|
- }
|
|
|
- const audioTrack = tracks.audio;
|
|
|
- let checkTimestampOffset = false;
|
|
|
- if (type === "audio" && (audioTrack == null ? void 0 : audioTrack.container) === "audio/mpeg") {
|
|
|
- checkTimestampOffset = !this.lastMpegAudioChunk || chunkMeta.id === 1 || this.lastMpegAudioChunk.sn !== chunkMeta.sn;
|
|
|
- this.lastMpegAudioChunk = chunkMeta;
|
|
|
- }
|
|
|
- const videoTrack = tracks.video;
|
|
|
- const videoSb = videoTrack == null ? void 0 : videoTrack.buffer;
|
|
|
- if (videoSb && sn !== "initSegment") {
|
|
|
- const partOrFrag = part || frag;
|
|
|
- const blockedAudioAppend = this.blockedAudioAppend;
|
|
|
- if (type === "audio" && parent !== "main" && !this.blockedAudioAppend && !(videoTrack.ending || videoTrack.ended)) {
|
|
|
- const pStart = partOrFrag.start;
|
|
|
- const pTime = pStart + partOrFrag.duration * 0.05;
|
|
|
- const vbuffered = videoSb.buffered;
|
|
|
- const vappending = this.currentOp("video");
|
|
|
- if (!vbuffered.length && !vappending) {
|
|
|
- this.blockAudio(partOrFrag);
|
|
|
- } else if (!vappending && !BufferHelper.isBuffered(videoSb, pTime) && this.lastVideoAppendEnd < pTime) {
|
|
|
- this.blockAudio(partOrFrag);
|
|
|
- }
|
|
|
- } else if (type === "video") {
|
|
|
- const videoAppendEnd = partOrFrag.end;
|
|
|
- if (blockedAudioAppend) {
|
|
|
- const audioStart = blockedAudioAppend.frag.start;
|
|
|
- if (videoAppendEnd > audioStart || videoAppendEnd < this.lastVideoAppendEnd || BufferHelper.isBuffered(videoSb, audioStart)) {
|
|
|
- this.unblockAudio();
|
|
|
- }
|
|
|
- }
|
|
|
- this.lastVideoAppendEnd = videoAppendEnd;
|
|
|
- }
|
|
|
- }
|
|
|
- const fragStart = (part || frag).start;
|
|
|
- const operation = {
|
|
|
- label: `append-${type}`,
|
|
|
- execute: () => {
|
|
|
- var _this$tracks$type2;
|
|
|
- chunkStats.executeStart = self.performance.now();
|
|
|
- const sb = (_this$tracks$type2 = this.tracks[type]) == null ? void 0 : _this$tracks$type2.buffer;
|
|
|
- if (sb) {
|
|
|
- if (checkTimestampOffset) {
|
|
|
- this.updateTimestampOffset(sb, fragStart, 0.1, type, sn, cc);
|
|
|
- } else if (offset !== void 0 && isFiniteNumber(offset)) {
|
|
|
- this.updateTimestampOffset(sb, offset, 1e-6, type, sn, cc);
|
|
|
- }
|
|
|
- }
|
|
|
- this.appendExecutor(data, type);
|
|
|
- },
|
|
|
- onStart: () => {
|
|
|
- },
|
|
|
- onComplete: () => {
|
|
|
- const end = self.performance.now();
|
|
|
- chunkStats.executeEnd = chunkStats.end = end;
|
|
|
- if (fragBuffering.first === 0) {
|
|
|
- fragBuffering.first = end;
|
|
|
- }
|
|
|
- if (partBuffering && partBuffering.first === 0) {
|
|
|
- partBuffering.first = end;
|
|
|
- }
|
|
|
- const timeRanges = {};
|
|
|
- this.sourceBuffers.forEach(([type2, sb]) => {
|
|
|
- if (type2) {
|
|
|
- timeRanges[type2] = BufferHelper.getBuffered(sb);
|
|
|
- }
|
|
|
- });
|
|
|
- this.appendErrors[type] = 0;
|
|
|
- if (type === "audio" || type === "video") {
|
|
|
- this.appendErrors.audiovideo = 0;
|
|
|
- } else {
|
|
|
- this.appendErrors.audio = 0;
|
|
|
- this.appendErrors.video = 0;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.BUFFER_APPENDED, {
|
|
|
- type,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- chunkMeta,
|
|
|
- parent: frag.type,
|
|
|
- timeRanges
|
|
|
- });
|
|
|
- },
|
|
|
- onError: (error) => {
|
|
|
- var _this$media;
|
|
|
- const event2 = {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- parent: frag.type,
|
|
|
- details: ErrorDetails.BUFFER_APPEND_ERROR,
|
|
|
- sourceBufferName: type,
|
|
|
- frag,
|
|
|
- part,
|
|
|
- chunkMeta,
|
|
|
- error,
|
|
|
- err: error,
|
|
|
- fatal: false
|
|
|
- };
|
|
|
- const mediaError = (_this$media = this.media) == null ? void 0 : _this$media.error;
|
|
|
- if (error.code === DOMException.QUOTA_EXCEEDED_ERR || error.name == "QuotaExceededError" || `quota` in error) {
|
|
|
- event2.details = ErrorDetails.BUFFER_FULL_ERROR;
|
|
|
- } else if (error.code === DOMException.INVALID_STATE_ERR && this.mediaSourceOpenOrEnded && !mediaError) {
|
|
|
- event2.errorAction = createDoNothingErrorAction(true);
|
|
|
- } else if (error.name === TRACK_REMOVED_ERROR_NAME && this.sourceBufferCount === 0) {
|
|
|
- event2.errorAction = createDoNothingErrorAction(true);
|
|
|
- } else {
|
|
|
- const appendErrorCount = ++this.appendErrors[type];
|
|
|
- this.warn(`Failed ${appendErrorCount}/${this.hls.config.appendErrorMaxRetry} times to append segment in "${type}" sourceBuffer (${mediaError ? mediaError : "no media error"})`);
|
|
|
- if (appendErrorCount >= this.hls.config.appendErrorMaxRetry || !!mediaError) {
|
|
|
- event2.fatal = true;
|
|
|
- }
|
|
|
- }
|
|
|
- this.hls.trigger(Events.ERROR, event2);
|
|
|
- }
|
|
|
- };
|
|
|
- this.log(`queuing "${type}" append sn: ${sn}${part ? " p: " + part.index : ""} of ${frag.type === PlaylistLevelType.MAIN ? "level" : "track"} ${frag.level} cc: ${cc}`);
|
|
|
- this.append(operation, type, this.isPending(this.tracks[type]));
|
|
|
- }
|
|
|
- getFlushOp(type, start, end) {
|
|
|
- this.log(`queuing "${type}" remove ${start}-${end}`);
|
|
|
- return {
|
|
|
- label: "remove",
|
|
|
- execute: () => {
|
|
|
- this.removeExecutor(type, start, end);
|
|
|
- },
|
|
|
- onStart: () => {
|
|
|
- },
|
|
|
- onComplete: () => {
|
|
|
- this.hls.trigger(Events.BUFFER_FLUSHED, {
|
|
|
- type
|
|
|
- });
|
|
|
- },
|
|
|
- onError: (error) => {
|
|
|
- this.warn(`Failed to remove ${start}-${end} from "${type}" SourceBuffer`, error);
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
- onBufferFlushing(event, data) {
|
|
|
- const {
|
|
|
- type,
|
|
|
- startOffset,
|
|
|
- endOffset
|
|
|
- } = data;
|
|
|
- if (type) {
|
|
|
- this.append(this.getFlushOp(type, startOffset, endOffset), type);
|
|
|
- } else {
|
|
|
- this.sourceBuffers.forEach(([type2]) => {
|
|
|
- if (type2) {
|
|
|
- this.append(this.getFlushOp(type2, startOffset, endOffset), type2);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- onFragParsed(event, data) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part
|
|
|
- } = data;
|
|
|
- const buffersAppendedTo = [];
|
|
|
- const elementaryStreams = part ? part.elementaryStreams : frag.elementaryStreams;
|
|
|
- if (elementaryStreams[ElementaryStreamTypes.AUDIOVIDEO]) {
|
|
|
- buffersAppendedTo.push("audiovideo");
|
|
|
- } else {
|
|
|
- if (elementaryStreams[ElementaryStreamTypes.AUDIO]) {
|
|
|
- buffersAppendedTo.push("audio");
|
|
|
- }
|
|
|
- if (elementaryStreams[ElementaryStreamTypes.VIDEO]) {
|
|
|
- buffersAppendedTo.push("video");
|
|
|
- }
|
|
|
- }
|
|
|
- const onUnblocked = () => {
|
|
|
- const now2 = self.performance.now();
|
|
|
- frag.stats.buffering.end = now2;
|
|
|
- if (part) {
|
|
|
- part.stats.buffering.end = now2;
|
|
|
- }
|
|
|
- const stats = part ? part.stats : frag.stats;
|
|
|
- this.hls.trigger(Events.FRAG_BUFFERED, {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- stats,
|
|
|
- id: frag.type
|
|
|
- });
|
|
|
- };
|
|
|
- if (buffersAppendedTo.length === 0) {
|
|
|
- this.warn(`Fragments must have at least one ElementaryStreamType set. type: ${frag.type} level: ${frag.level} sn: ${frag.sn}`);
|
|
|
- }
|
|
|
- this.blockBuffers(onUnblocked, buffersAppendedTo).catch((error) => {
|
|
|
- this.warn(`Fragment buffered callback ${error}`);
|
|
|
- this.stepOperationQueue(this.sourceBufferTypes);
|
|
|
- });
|
|
|
- }
|
|
|
- onFragChanged(event, data) {
|
|
|
- this.trimBuffers();
|
|
|
- }
|
|
|
- get bufferedToEnd() {
|
|
|
- return this.sourceBufferCount > 0 && !this.sourceBuffers.some(([type]) => {
|
|
|
- if (type) {
|
|
|
- const track = this.tracks[type];
|
|
|
- if (track) {
|
|
|
- return !track.ended || track.ending;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- });
|
|
|
- }
|
|
|
- // on BUFFER_EOS mark matching sourcebuffer(s) as "ending" and "ended" and queue endOfStream after remaining operations(s)
|
|
|
- // an undefined data.type will mark all buffers as EOS.
|
|
|
- onBufferEos(event, data) {
|
|
|
- var _this$overrides;
|
|
|
- this.sourceBuffers.forEach(([type]) => {
|
|
|
- if (type) {
|
|
|
- const track = this.tracks[type];
|
|
|
- if (!data.type || data.type === type) {
|
|
|
- track.ending = true;
|
|
|
- if (!track.ended) {
|
|
|
- track.ended = true;
|
|
|
- this.log(`${type} buffer reached EOS`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- const allowEndOfStream = ((_this$overrides = this.overrides) == null ? void 0 : _this$overrides.endOfStream) !== false;
|
|
|
- const allTracksEnding = this.sourceBufferCount > 0 && !this.sourceBuffers.some(([type]) => {
|
|
|
- var _this$tracks$type3;
|
|
|
- return type && !((_this$tracks$type3 = this.tracks[type]) != null && _this$tracks$type3.ended);
|
|
|
- });
|
|
|
- if (allTracksEnding) {
|
|
|
- if (allowEndOfStream) {
|
|
|
- this.log(`Queueing EOS`);
|
|
|
- this.blockUntilOpen(() => {
|
|
|
- this.tracksEnded();
|
|
|
- const {
|
|
|
- mediaSource
|
|
|
- } = this;
|
|
|
- if (!mediaSource || mediaSource.readyState !== "open") {
|
|
|
- if (mediaSource) {
|
|
|
- this.log(`Could not call mediaSource.endOfStream(). mediaSource.readyState: ${mediaSource.readyState}`);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Calling mediaSource.endOfStream()`);
|
|
|
- mediaSource.endOfStream();
|
|
|
- this.hls.trigger(Events.BUFFERED_TO_END, void 0);
|
|
|
- });
|
|
|
- } else {
|
|
|
- this.tracksEnded();
|
|
|
- this.hls.trigger(Events.BUFFERED_TO_END, void 0);
|
|
|
- }
|
|
|
- } else if (data.type === "video") {
|
|
|
- this.unblockAudio();
|
|
|
- }
|
|
|
- }
|
|
|
- tracksEnded() {
|
|
|
- this.sourceBuffers.forEach(([type]) => {
|
|
|
- if (type !== null) {
|
|
|
- const track = this.tracks[type];
|
|
|
- if (track) {
|
|
|
- track.ending = false;
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- onLevelUpdated(event, {
|
|
|
- details
|
|
|
- }) {
|
|
|
- if (!details.fragments.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.details = details;
|
|
|
- this.updateDuration();
|
|
|
- }
|
|
|
- updateDuration() {
|
|
|
- this.blockUntilOpen(() => {
|
|
|
- const durationAndRange = this.getDurationAndRange();
|
|
|
- if (!durationAndRange) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.updateMediaSource(durationAndRange);
|
|
|
- });
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- if (data.details === ErrorDetails.BUFFER_APPEND_ERROR && data.frag) {
|
|
|
- var _data$errorAction;
|
|
|
- const nextAutoLevel = (_data$errorAction = data.errorAction) == null ? void 0 : _data$errorAction.nextAutoLevel;
|
|
|
- if (isFiniteNumber(nextAutoLevel) && nextAutoLevel !== data.frag.level) {
|
|
|
- this.resetAppendErrors();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- resetAppendErrors() {
|
|
|
- this.appendErrors = {
|
|
|
- audio: 0,
|
|
|
- video: 0,
|
|
|
- audiovideo: 0
|
|
|
- };
|
|
|
- }
|
|
|
- trimBuffers() {
|
|
|
- const {
|
|
|
- hls,
|
|
|
- details,
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (!media || details === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!this.sourceBufferCount) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const config = hls.config;
|
|
|
- const currentTime = media.currentTime;
|
|
|
- const targetDuration = details.levelTargetDuration;
|
|
|
- const backBufferLength = details.live && config.liveBackBufferLength !== null ? config.liveBackBufferLength : config.backBufferLength;
|
|
|
- if (isFiniteNumber(backBufferLength) && backBufferLength >= 0) {
|
|
|
- const maxBackBufferLength = Math.max(backBufferLength, targetDuration);
|
|
|
- const targetBackBufferPosition = Math.floor(currentTime / targetDuration) * targetDuration - maxBackBufferLength;
|
|
|
- this.flushBackBuffer(currentTime, targetDuration, targetBackBufferPosition);
|
|
|
- }
|
|
|
- const frontBufferFlushThreshold = config.frontBufferFlushThreshold;
|
|
|
- if (isFiniteNumber(frontBufferFlushThreshold) && frontBufferFlushThreshold > 0) {
|
|
|
- const frontBufferLength = Math.max(config.maxBufferLength, frontBufferFlushThreshold);
|
|
|
- const maxFrontBufferLength = Math.max(frontBufferLength, targetDuration);
|
|
|
- const targetFrontBufferPosition = Math.floor(currentTime / targetDuration) * targetDuration + maxFrontBufferLength;
|
|
|
- this.flushFrontBuffer(currentTime, targetDuration, targetFrontBufferPosition);
|
|
|
- }
|
|
|
- }
|
|
|
- flushBackBuffer(currentTime, targetDuration, targetBackBufferPosition) {
|
|
|
- this.sourceBuffers.forEach(([type, sb]) => {
|
|
|
- if (sb) {
|
|
|
- const buffered = BufferHelper.getBuffered(sb);
|
|
|
- if (buffered.length > 0 && targetBackBufferPosition > buffered.start(0)) {
|
|
|
- var _this$details;
|
|
|
- this.hls.trigger(Events.BACK_BUFFER_REACHED, {
|
|
|
- bufferEnd: targetBackBufferPosition
|
|
|
- });
|
|
|
- const track = this.tracks[type];
|
|
|
- if ((_this$details = this.details) != null && _this$details.live) {
|
|
|
- this.hls.trigger(Events.LIVE_BACK_BUFFER_REACHED, {
|
|
|
- bufferEnd: targetBackBufferPosition
|
|
|
- });
|
|
|
- } else if (track != null && track.ended) {
|
|
|
- this.log(`Cannot flush ${type} back buffer while SourceBuffer is in ended state`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.BUFFER_FLUSHING, {
|
|
|
- startOffset: 0,
|
|
|
- endOffset: targetBackBufferPosition,
|
|
|
- type
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- flushFrontBuffer(currentTime, targetDuration, targetFrontBufferPosition) {
|
|
|
- this.sourceBuffers.forEach(([type, sb]) => {
|
|
|
- if (sb) {
|
|
|
- const buffered = BufferHelper.getBuffered(sb);
|
|
|
- const numBufferedRanges = buffered.length;
|
|
|
- if (numBufferedRanges < 2) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferStart = buffered.start(numBufferedRanges - 1);
|
|
|
- const bufferEnd = buffered.end(numBufferedRanges - 1);
|
|
|
- if (targetFrontBufferPosition > bufferStart || currentTime >= bufferStart && currentTime <= bufferEnd) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.BUFFER_FLUSHING, {
|
|
|
- startOffset: bufferStart,
|
|
|
- endOffset: Infinity,
|
|
|
- type
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- /**
|
|
|
- * Update Media Source duration to current level duration or override to Infinity if configuration parameter
|
|
|
- * 'liveDurationInfinity` is set to `true`
|
|
|
- * More details: https://github.com/video-dev/hls.js/issues/355
|
|
|
- */
|
|
|
- getDurationAndRange() {
|
|
|
- var _this$overrides2;
|
|
|
- const {
|
|
|
- details,
|
|
|
- mediaSource
|
|
|
- } = this;
|
|
|
- if (!details || !this.media || (mediaSource == null ? void 0 : mediaSource.readyState) !== "open") {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const playlistEnd = details.edge;
|
|
|
- if (details.live && this.hls.config.liveDurationInfinity) {
|
|
|
- const len = details.fragments.length;
|
|
|
- if (len && !!mediaSource.setLiveSeekableRange) {
|
|
|
- const start = Math.max(0, details.fragmentStart);
|
|
|
- const end = Math.max(start, playlistEnd);
|
|
|
- return {
|
|
|
- duration: Infinity,
|
|
|
- start,
|
|
|
- end
|
|
|
- };
|
|
|
- }
|
|
|
- return {
|
|
|
- duration: Infinity
|
|
|
- };
|
|
|
- }
|
|
|
- const overrideDuration = (_this$overrides2 = this.overrides) == null ? void 0 : _this$overrides2.duration;
|
|
|
- if (overrideDuration) {
|
|
|
- if (!isFiniteNumber(overrideDuration)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return {
|
|
|
- duration: overrideDuration
|
|
|
- };
|
|
|
- }
|
|
|
- const mediaDuration = this.media.duration;
|
|
|
- const msDuration = isFiniteNumber(mediaSource.duration) ? mediaSource.duration : 0;
|
|
|
- if (playlistEnd > msDuration && playlistEnd > mediaDuration || !isFiniteNumber(mediaDuration)) {
|
|
|
- return {
|
|
|
- duration: playlistEnd
|
|
|
- };
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- updateMediaSource({
|
|
|
- duration,
|
|
|
- start,
|
|
|
- end
|
|
|
- }) {
|
|
|
- const mediaSource = this.mediaSource;
|
|
|
- if (!this.media || !mediaSource || mediaSource.readyState !== "open") {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (mediaSource.duration !== duration) {
|
|
|
- if (isFiniteNumber(duration)) {
|
|
|
- this.log(`Updating MediaSource duration to ${duration.toFixed(3)}`);
|
|
|
- }
|
|
|
- mediaSource.duration = duration;
|
|
|
- }
|
|
|
- if (start !== void 0 && end !== void 0) {
|
|
|
- this.log(`MediaSource duration is set to ${mediaSource.duration}. Setting seekable range to ${start}-${end}.`);
|
|
|
- mediaSource.setLiveSeekableRange(start, end);
|
|
|
- }
|
|
|
- }
|
|
|
- get tracksReady() {
|
|
|
- const pendingTrackCount = this.pendingTrackCount;
|
|
|
- return pendingTrackCount > 0 && (pendingTrackCount >= this.bufferCodecEventsTotal || this.isPending(this.tracks.audiovideo));
|
|
|
- }
|
|
|
- checkPendingTracks() {
|
|
|
- const {
|
|
|
- bufferCodecEventsTotal,
|
|
|
- pendingTrackCount,
|
|
|
- tracks
|
|
|
- } = this;
|
|
|
- this.log(`checkPendingTracks (pending: ${pendingTrackCount} codec events expected: ${bufferCodecEventsTotal}) ${stringify(tracks)}`);
|
|
|
- if (this.tracksReady) {
|
|
|
- var _this$transferData4;
|
|
|
- const transferredTracks = (_this$transferData4 = this.transferData) == null ? void 0 : _this$transferData4.tracks;
|
|
|
- if (transferredTracks && Object.keys(transferredTracks).length) {
|
|
|
- this.attachTransferred();
|
|
|
- } else {
|
|
|
- this.createSourceBuffers();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- bufferCreated() {
|
|
|
- if (this.sourceBufferCount) {
|
|
|
- const tracks = {};
|
|
|
- this.sourceBuffers.forEach(([type, buffer]) => {
|
|
|
- if (type) {
|
|
|
- const track = this.tracks[type];
|
|
|
- tracks[type] = {
|
|
|
- buffer,
|
|
|
- container: track.container,
|
|
|
- codec: track.codec,
|
|
|
- supplemental: track.supplemental,
|
|
|
- levelCodec: track.levelCodec,
|
|
|
- id: track.id,
|
|
|
- metadata: track.metadata
|
|
|
- };
|
|
|
- }
|
|
|
- });
|
|
|
- this.hls.trigger(Events.BUFFER_CREATED, {
|
|
|
- tracks
|
|
|
- });
|
|
|
- this.log(`SourceBuffers created. Running queue: ${this.operationQueue}`);
|
|
|
- this.sourceBuffers.forEach(([type]) => {
|
|
|
- this.executeNext(type);
|
|
|
- });
|
|
|
- } else {
|
|
|
- const error = new Error("could not create source buffer for media codec(s)");
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_INCOMPATIBLE_CODECS_ERROR,
|
|
|
- fatal: true,
|
|
|
- error,
|
|
|
- reason: error.message
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- createSourceBuffers() {
|
|
|
- const {
|
|
|
- tracks,
|
|
|
- sourceBuffers,
|
|
|
- mediaSource
|
|
|
- } = this;
|
|
|
- if (!mediaSource) {
|
|
|
- throw new Error("createSourceBuffers called when mediaSource was null");
|
|
|
- }
|
|
|
- for (const trackName in tracks) {
|
|
|
- const type = trackName;
|
|
|
- const track = tracks[type];
|
|
|
- if (this.isPending(track)) {
|
|
|
- const codec = this.getTrackCodec(track, type);
|
|
|
- const mimeType = `${track.container};codecs=${codec}`;
|
|
|
- track.codec = codec;
|
|
|
- this.log(`creating sourceBuffer(${mimeType})${this.currentOp(type) ? " Queued" : ""} ${stringify(track)}`);
|
|
|
- try {
|
|
|
- const sb = mediaSource.addSourceBuffer(mimeType);
|
|
|
- const sbIndex = sourceBufferNameToIndex(type);
|
|
|
- const sbTuple = [type, sb];
|
|
|
- sourceBuffers[sbIndex] = sbTuple;
|
|
|
- track.buffer = sb;
|
|
|
- } catch (error) {
|
|
|
- var _this$operationQueue;
|
|
|
- this.error(`error while trying to add sourceBuffer: ${error.message}`);
|
|
|
- this.shiftAndExecuteNext(type);
|
|
|
- (_this$operationQueue = this.operationQueue) == null || _this$operationQueue.removeBlockers();
|
|
|
- delete this.tracks[type];
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_ADD_CODEC_ERROR,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- sourceBufferName: type,
|
|
|
- mimeType,
|
|
|
- parent: track.id
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- this.trackSourceBuffer(type, track);
|
|
|
- }
|
|
|
- }
|
|
|
- this.bufferCreated();
|
|
|
- }
|
|
|
- getTrackCodec(track, trackName) {
|
|
|
- const supplementalCodec = track.supplemental;
|
|
|
- let trackCodec = track.codec;
|
|
|
- if (supplementalCodec && (trackName === "video" || trackName === "audiovideo") && areCodecsMediaSourceSupported(supplementalCodec, "video")) {
|
|
|
- trackCodec = replaceVideoCodec(trackCodec, supplementalCodec);
|
|
|
- }
|
|
|
- const codec = pickMostCompleteCodecName(trackCodec, track.levelCodec);
|
|
|
- if (codec) {
|
|
|
- if (trackName.slice(0, 5) === "audio") {
|
|
|
- return getCodecCompatibleName(codec, this.appendSource);
|
|
|
- }
|
|
|
- return codec;
|
|
|
- }
|
|
|
- return "";
|
|
|
- }
|
|
|
- trackSourceBuffer(type, track) {
|
|
|
- const buffer = track.buffer;
|
|
|
- if (!buffer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const codec = this.getTrackCodec(track, type);
|
|
|
- this.tracks[type] = {
|
|
|
- buffer,
|
|
|
- codec,
|
|
|
- container: track.container,
|
|
|
- levelCodec: track.levelCodec,
|
|
|
- supplemental: track.supplemental,
|
|
|
- metadata: track.metadata,
|
|
|
- id: track.id,
|
|
|
- listeners: []
|
|
|
- };
|
|
|
- this.removeBufferListeners(type);
|
|
|
- this.addBufferListener(type, "updatestart", this.onSBUpdateStart);
|
|
|
- this.addBufferListener(type, "updateend", this.onSBUpdateEnd);
|
|
|
- this.addBufferListener(type, "error", this.onSBUpdateError);
|
|
|
- if (this.appendSource) {
|
|
|
- this.addBufferListener(type, "bufferedchange", (type2, event) => {
|
|
|
- const removedRanges = event.removedRanges;
|
|
|
- if (removedRanges != null && removedRanges.length) {
|
|
|
- this.hls.trigger(Events.BUFFER_FLUSHED, {
|
|
|
- type: type2
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- get mediaSrc() {
|
|
|
- var _this$media2, _this$media2$querySel;
|
|
|
- const media = ((_this$media2 = this.media) == null || (_this$media2$querySel = _this$media2.querySelector) == null ? void 0 : _this$media2$querySel.call(_this$media2, "source")) || this.media;
|
|
|
- return media == null ? void 0 : media.src;
|
|
|
- }
|
|
|
- onSBUpdateStart(type) {
|
|
|
- const operation = this.currentOp(type);
|
|
|
- if (!operation) {
|
|
|
- return;
|
|
|
- }
|
|
|
- operation.onStart();
|
|
|
- }
|
|
|
- onSBUpdateEnd(type) {
|
|
|
- var _this$mediaSource4;
|
|
|
- if (((_this$mediaSource4 = this.mediaSource) == null ? void 0 : _this$mediaSource4.readyState) === "closed") {
|
|
|
- this.resetBuffer(type);
|
|
|
- return;
|
|
|
- }
|
|
|
- const operation = this.currentOp(type);
|
|
|
- if (!operation) {
|
|
|
- return;
|
|
|
- }
|
|
|
- operation.onComplete();
|
|
|
- this.shiftAndExecuteNext(type);
|
|
|
- }
|
|
|
- onSBUpdateError(type, event) {
|
|
|
- var _this$mediaSource5;
|
|
|
- const error = new Error(`${type} SourceBuffer error. MediaSource readyState: ${(_this$mediaSource5 = this.mediaSource) == null ? void 0 : _this$mediaSource5.readyState}`);
|
|
|
- this.error(`${error}`, event);
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_APPENDING_ERROR,
|
|
|
- sourceBufferName: type,
|
|
|
- error,
|
|
|
- fatal: false
|
|
|
- });
|
|
|
- const operation = this.currentOp(type);
|
|
|
- if (operation) {
|
|
|
- operation.onError(error);
|
|
|
- }
|
|
|
- }
|
|
|
- updateTimestampOffset(sb, timestampOffset, tolerance, type, sn, cc) {
|
|
|
- const delta = timestampOffset - sb.timestampOffset;
|
|
|
- if (Math.abs(delta) >= tolerance) {
|
|
|
- this.log(`Updating ${type} SourceBuffer timestampOffset to ${timestampOffset} (sn: ${sn} cc: ${cc})`);
|
|
|
- sb.timestampOffset = timestampOffset;
|
|
|
- }
|
|
|
- }
|
|
|
- // This method must result in an updateend event; if remove is not called, onSBUpdateEnd must be called manually
|
|
|
- removeExecutor(type, startOffset, endOffset) {
|
|
|
- const {
|
|
|
- media,
|
|
|
- mediaSource
|
|
|
- } = this;
|
|
|
- const track = this.tracks[type];
|
|
|
- const sb = track == null ? void 0 : track.buffer;
|
|
|
- if (!media || !mediaSource || !sb) {
|
|
|
- this.warn(`Attempting to remove from the ${type} SourceBuffer, but it does not exist`);
|
|
|
- this.shiftAndExecuteNext(type);
|
|
|
- return;
|
|
|
- }
|
|
|
- const mediaDuration = isFiniteNumber(media.duration) ? media.duration : Infinity;
|
|
|
- const msDuration = isFiniteNumber(mediaSource.duration) ? mediaSource.duration : Infinity;
|
|
|
- const removeStart = Math.max(0, startOffset);
|
|
|
- const removeEnd = Math.min(endOffset, mediaDuration, msDuration);
|
|
|
- if (removeEnd > removeStart && (!track.ending || track.ended)) {
|
|
|
- track.ended = false;
|
|
|
- this.log(`Removing [${removeStart},${removeEnd}] from the ${type} SourceBuffer`);
|
|
|
- sb.remove(removeStart, removeEnd);
|
|
|
- } else {
|
|
|
- this.shiftAndExecuteNext(type);
|
|
|
- }
|
|
|
- }
|
|
|
- // This method must result in an updateend event; if append is not called, onSBUpdateEnd must be called manually
|
|
|
- appendExecutor(data, type) {
|
|
|
- const track = this.tracks[type];
|
|
|
- const sb = track == null ? void 0 : track.buffer;
|
|
|
- if (!sb) {
|
|
|
- throw new HlsJsTrackRemovedError(`Attempting to append to the ${type} SourceBuffer, but it does not exist`);
|
|
|
- }
|
|
|
- track.ending = false;
|
|
|
- track.ended = false;
|
|
|
- sb.appendBuffer(data);
|
|
|
- }
|
|
|
- blockUntilOpen(callback) {
|
|
|
- if (this.isUpdating() || this.isQueued()) {
|
|
|
- this.blockBuffers(callback).catch((error) => {
|
|
|
- this.warn(`SourceBuffer blocked callback ${error}`);
|
|
|
- this.stepOperationQueue(this.sourceBufferTypes);
|
|
|
- });
|
|
|
- } else {
|
|
|
- try {
|
|
|
- callback();
|
|
|
- } catch (error) {
|
|
|
- this.warn(`Callback run without blocking ${this.operationQueue} ${error}`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- isUpdating() {
|
|
|
- return this.sourceBuffers.some(([type, sb]) => type && sb.updating);
|
|
|
- }
|
|
|
- isQueued() {
|
|
|
- return this.sourceBuffers.some(([type]) => type && !!this.currentOp(type));
|
|
|
- }
|
|
|
- isPending(track) {
|
|
|
- return !!track && !track.buffer;
|
|
|
- }
|
|
|
- // Enqueues an operation to each SourceBuffer queue which, upon execution, resolves a promise. When all promises
|
|
|
- // resolve, the onUnblocked function is executed. Functions calling this method do not need to unblock the queue
|
|
|
- // upon completion, since we already do it here
|
|
|
- blockBuffers(onUnblocked, bufferNames = this.sourceBufferTypes) {
|
|
|
- if (!bufferNames.length) {
|
|
|
- this.log("Blocking operation requested, but no SourceBuffers exist");
|
|
|
- return Promise.resolve().then(onUnblocked);
|
|
|
- }
|
|
|
- const {
|
|
|
- operationQueue
|
|
|
- } = this;
|
|
|
- const blockingOperations = bufferNames.map((type) => this.appendBlocker(type));
|
|
|
- const audioBlocked = bufferNames.length > 1 && !!this.blockedAudioAppend;
|
|
|
- if (audioBlocked) {
|
|
|
- this.unblockAudio();
|
|
|
- }
|
|
|
- return Promise.all(blockingOperations).then((result) => {
|
|
|
- if (operationQueue !== this.operationQueue) {
|
|
|
- return;
|
|
|
- }
|
|
|
- onUnblocked();
|
|
|
- this.stepOperationQueue(this.sourceBufferTypes);
|
|
|
- });
|
|
|
- }
|
|
|
- stepOperationQueue(bufferNames) {
|
|
|
- bufferNames.forEach((type) => {
|
|
|
- var _this$tracks$type4;
|
|
|
- const sb = (_this$tracks$type4 = this.tracks[type]) == null ? void 0 : _this$tracks$type4.buffer;
|
|
|
- if (!sb || sb.updating) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.shiftAndExecuteNext(type);
|
|
|
- });
|
|
|
- }
|
|
|
- append(operation, type, pending) {
|
|
|
- if (this.operationQueue) {
|
|
|
- this.operationQueue.append(operation, type, pending);
|
|
|
- }
|
|
|
- }
|
|
|
- appendBlocker(type) {
|
|
|
- if (this.operationQueue) {
|
|
|
- return this.operationQueue.appendBlocker(type);
|
|
|
- }
|
|
|
- }
|
|
|
- currentOp(type) {
|
|
|
- if (this.operationQueue) {
|
|
|
- return this.operationQueue.current(type);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- executeNext(type) {
|
|
|
- if (type && this.operationQueue) {
|
|
|
- this.operationQueue.executeNext(type);
|
|
|
- }
|
|
|
- }
|
|
|
- shiftAndExecuteNext(type) {
|
|
|
- if (this.operationQueue) {
|
|
|
- this.operationQueue.shiftAndExecuteNext(type);
|
|
|
- }
|
|
|
- }
|
|
|
- get pendingTrackCount() {
|
|
|
- return Object.keys(this.tracks).reduce((acc, type) => acc + (this.isPending(this.tracks[type]) ? 1 : 0), 0);
|
|
|
- }
|
|
|
- get sourceBufferCount() {
|
|
|
- return this.sourceBuffers.reduce((acc, [type]) => acc + (type ? 1 : 0), 0);
|
|
|
- }
|
|
|
- get sourceBufferTypes() {
|
|
|
- return this.sourceBuffers.map(([type]) => type).filter((type) => !!type);
|
|
|
- }
|
|
|
- addBufferListener(type, event, fn) {
|
|
|
- const track = this.tracks[type];
|
|
|
- if (!track) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const buffer = track.buffer;
|
|
|
- if (!buffer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const listener = fn.bind(this, type);
|
|
|
- track.listeners.push({
|
|
|
- event,
|
|
|
- listener
|
|
|
- });
|
|
|
- buffer.addEventListener(event, listener);
|
|
|
- }
|
|
|
- removeBufferListeners(type) {
|
|
|
- const track = this.tracks[type];
|
|
|
- if (!track) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const buffer = track.buffer;
|
|
|
- if (!buffer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- track.listeners.forEach((l) => {
|
|
|
- buffer.removeEventListener(l.event, l.listener);
|
|
|
- });
|
|
|
- track.listeners.length = 0;
|
|
|
- }
|
|
|
-};
|
|
|
-function removeSourceChildren(node) {
|
|
|
- const sourceChildren = node.querySelectorAll("source");
|
|
|
- [].slice.call(sourceChildren).forEach((source) => {
|
|
|
- node.removeChild(source);
|
|
|
- });
|
|
|
-}
|
|
|
-function addSource(media, url) {
|
|
|
- const source = self.document.createElement("source");
|
|
|
- source.type = "video/mp4";
|
|
|
- source.src = url;
|
|
|
- media.appendChild(source);
|
|
|
-}
|
|
|
-function sourceBufferNameToIndex(type) {
|
|
|
- return type === "audio" ? 1 : 0;
|
|
|
-}
|
|
|
-var CapLevelController = class _CapLevelController {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.autoLevelCapping = void 0;
|
|
|
- this.firstLevel = void 0;
|
|
|
- this.media = void 0;
|
|
|
- this.restrictedLevels = void 0;
|
|
|
- this.timer = void 0;
|
|
|
- this.clientRect = void 0;
|
|
|
- this.streamController = void 0;
|
|
|
- this.hls = hls;
|
|
|
- this.autoLevelCapping = Number.POSITIVE_INFINITY;
|
|
|
- this.firstLevel = -1;
|
|
|
- this.media = null;
|
|
|
- this.restrictedLevels = [];
|
|
|
- this.timer = void 0;
|
|
|
- this.clientRect = null;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- setStreamController(streamController) {
|
|
|
- this.streamController = streamController;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- if (this.hls) {
|
|
|
- this.unregisterListener();
|
|
|
- }
|
|
|
- if (this.timer) {
|
|
|
- this.stopCapping();
|
|
|
- }
|
|
|
- this.media = null;
|
|
|
- this.clientRect = null;
|
|
|
- this.hls = this.streamController = null;
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.FPS_DROP_LEVEL_CAPPING, this.onFpsDropLevelCapping, this);
|
|
|
- hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.on(Events.BUFFER_CODECS, this.onBufferCodecs, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- }
|
|
|
- unregisterListener() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.FPS_DROP_LEVEL_CAPPING, this.onFpsDropLevelCapping, this);
|
|
|
- hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.off(Events.BUFFER_CODECS, this.onBufferCodecs, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- }
|
|
|
- onFpsDropLevelCapping(event, data) {
|
|
|
- const level = this.hls.levels[data.droppedLevel];
|
|
|
- if (this.isLevelAllowed(level)) {
|
|
|
- this.restrictedLevels.push({
|
|
|
- bitrate: level.bitrate,
|
|
|
- height: level.height,
|
|
|
- width: level.width
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaAttaching(event, data) {
|
|
|
- this.media = data.media instanceof HTMLVideoElement ? data.media : null;
|
|
|
- this.clientRect = null;
|
|
|
- if (this.timer && this.hls.levels.length) {
|
|
|
- this.detectPlayerSize();
|
|
|
- }
|
|
|
- }
|
|
|
- onManifestParsed(event, data) {
|
|
|
- const hls = this.hls;
|
|
|
- this.restrictedLevels = [];
|
|
|
- this.firstLevel = data.firstLevel;
|
|
|
- if (hls.config.capLevelToPlayerSize && data.video) {
|
|
|
- this.startCapping();
|
|
|
- }
|
|
|
- }
|
|
|
- onLevelsUpdated(event, data) {
|
|
|
- if (this.timer && isFiniteNumber(this.autoLevelCapping)) {
|
|
|
- this.detectPlayerSize();
|
|
|
- }
|
|
|
- }
|
|
|
- // Only activate capping when playing a video stream; otherwise, multi-bitrate audio-only streams will be restricted
|
|
|
- // to the first level
|
|
|
- onBufferCodecs(event, data) {
|
|
|
- const hls = this.hls;
|
|
|
- if (hls.config.capLevelToPlayerSize && data.video) {
|
|
|
- this.startCapping();
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaDetaching() {
|
|
|
- this.stopCapping();
|
|
|
- this.media = null;
|
|
|
- }
|
|
|
- detectPlayerSize() {
|
|
|
- if (this.media) {
|
|
|
- if (this.mediaHeight <= 0 || this.mediaWidth <= 0) {
|
|
|
- this.clientRect = null;
|
|
|
- return;
|
|
|
- }
|
|
|
- const levels = this.hls.levels;
|
|
|
- if (levels.length) {
|
|
|
- const hls = this.hls;
|
|
|
- const maxLevel = this.getMaxLevel(levels.length - 1);
|
|
|
- if (maxLevel !== this.autoLevelCapping) {
|
|
|
- hls.logger.log(`Setting autoLevelCapping to ${maxLevel}: ${levels[maxLevel].height}p@${levels[maxLevel].bitrate} for media ${this.mediaWidth}x${this.mediaHeight}`);
|
|
|
- }
|
|
|
- hls.autoLevelCapping = maxLevel;
|
|
|
- if (hls.autoLevelEnabled && hls.autoLevelCapping > this.autoLevelCapping && this.streamController) {
|
|
|
- this.streamController.nextLevelSwitch();
|
|
|
- }
|
|
|
- this.autoLevelCapping = hls.autoLevelCapping;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /*
|
|
|
- * returns level should be the one with the dimensions equal or greater than the media (player) dimensions (so the video will be downscaled)
|
|
|
- */
|
|
|
- getMaxLevel(capLevelIndex) {
|
|
|
- const levels = this.hls.levels;
|
|
|
- if (!levels.length) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- const validLevels = levels.filter((level, index) => this.isLevelAllowed(level) && index <= capLevelIndex);
|
|
|
- this.clientRect = null;
|
|
|
- return _CapLevelController.getMaxLevelByMediaSize(validLevels, this.mediaWidth, this.mediaHeight);
|
|
|
- }
|
|
|
- startCapping() {
|
|
|
- if (this.timer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.autoLevelCapping = Number.POSITIVE_INFINITY;
|
|
|
- self.clearInterval(this.timer);
|
|
|
- this.timer = self.setInterval(this.detectPlayerSize.bind(this), 1e3);
|
|
|
- this.detectPlayerSize();
|
|
|
- }
|
|
|
- stopCapping() {
|
|
|
- this.restrictedLevels = [];
|
|
|
- this.firstLevel = -1;
|
|
|
- this.autoLevelCapping = Number.POSITIVE_INFINITY;
|
|
|
- if (this.timer) {
|
|
|
- self.clearInterval(this.timer);
|
|
|
- this.timer = void 0;
|
|
|
- }
|
|
|
- }
|
|
|
- getDimensions() {
|
|
|
- if (this.clientRect) {
|
|
|
- return this.clientRect;
|
|
|
- }
|
|
|
- const media = this.media;
|
|
|
- const boundsRect = {
|
|
|
- width: 0,
|
|
|
- height: 0
|
|
|
- };
|
|
|
- if (media) {
|
|
|
- const clientRect = media.getBoundingClientRect();
|
|
|
- boundsRect.width = clientRect.width;
|
|
|
- boundsRect.height = clientRect.height;
|
|
|
- if (!boundsRect.width && !boundsRect.height) {
|
|
|
- boundsRect.width = clientRect.right - clientRect.left || media.width || 0;
|
|
|
- boundsRect.height = clientRect.bottom - clientRect.top || media.height || 0;
|
|
|
- }
|
|
|
- }
|
|
|
- this.clientRect = boundsRect;
|
|
|
- return boundsRect;
|
|
|
- }
|
|
|
- get mediaWidth() {
|
|
|
- return this.getDimensions().width * this.contentScaleFactor;
|
|
|
- }
|
|
|
- get mediaHeight() {
|
|
|
- return this.getDimensions().height * this.contentScaleFactor;
|
|
|
- }
|
|
|
- get contentScaleFactor() {
|
|
|
- let pixelRatio = 1;
|
|
|
- if (!this.hls.config.ignoreDevicePixelRatio) {
|
|
|
- try {
|
|
|
- pixelRatio = self.devicePixelRatio;
|
|
|
- } catch (e) {
|
|
|
- }
|
|
|
- }
|
|
|
- return Math.min(pixelRatio, this.hls.config.maxDevicePixelRatio);
|
|
|
- }
|
|
|
- isLevelAllowed(level) {
|
|
|
- const restrictedLevels = this.restrictedLevels;
|
|
|
- return !restrictedLevels.some((restrictedLevel) => {
|
|
|
- return level.bitrate === restrictedLevel.bitrate && level.width === restrictedLevel.width && level.height === restrictedLevel.height;
|
|
|
- });
|
|
|
- }
|
|
|
- static getMaxLevelByMediaSize(levels, width, height) {
|
|
|
- if (!(levels != null && levels.length)) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- const atGreatestBandwidth = (curLevel, nextLevel) => {
|
|
|
- if (!nextLevel) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return curLevel.width !== nextLevel.width || curLevel.height !== nextLevel.height;
|
|
|
- };
|
|
|
- let maxLevelIndex = levels.length - 1;
|
|
|
- const squareSize = Math.max(width, height);
|
|
|
- for (let i = 0; i < levels.length; i += 1) {
|
|
|
- const level = levels[i];
|
|
|
- if ((level.width >= squareSize || level.height >= squareSize) && atGreatestBandwidth(level, levels[i + 1])) {
|
|
|
- maxLevelIndex = i;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return maxLevelIndex;
|
|
|
- }
|
|
|
-};
|
|
|
-var CmObjectType = {
|
|
|
- /**
|
|
|
- * text file, such as a manifest or playlist
|
|
|
- */
|
|
|
- MANIFEST: "m",
|
|
|
- /**
|
|
|
- * audio only
|
|
|
- */
|
|
|
- AUDIO: "a",
|
|
|
- /**
|
|
|
- * video only
|
|
|
- */
|
|
|
- VIDEO: "v",
|
|
|
- /**
|
|
|
- * muxed audio and video
|
|
|
- */
|
|
|
- MUXED: "av",
|
|
|
- /**
|
|
|
- * init segment
|
|
|
- */
|
|
|
- INIT: "i",
|
|
|
- /**
|
|
|
- * caption or subtitle
|
|
|
- */
|
|
|
- CAPTION: "c",
|
|
|
- /**
|
|
|
- * ISOBMFF timed text track
|
|
|
- */
|
|
|
- TIMED_TEXT: "tt",
|
|
|
- /**
|
|
|
- * cryptographic key, license or certificate.
|
|
|
- */
|
|
|
- KEY: "k",
|
|
|
- /**
|
|
|
- * other
|
|
|
- */
|
|
|
- OTHER: "o"
|
|
|
-};
|
|
|
-var CmcdObjectType = CmObjectType;
|
|
|
-var CmStreamingFormat = {
|
|
|
- /**
|
|
|
- * HTTP Live Streaming (HLS)
|
|
|
- */
|
|
|
- HLS: "h"
|
|
|
-};
|
|
|
-var CmcdStreamingFormat = CmStreamingFormat;
|
|
|
-var SfItem = class _SfItem {
|
|
|
- constructor(value, params) {
|
|
|
- if (Array.isArray(value)) {
|
|
|
- value = value.map((v) => v instanceof _SfItem ? v : new _SfItem(v));
|
|
|
- }
|
|
|
- this.value = value;
|
|
|
- this.params = params;
|
|
|
- }
|
|
|
-};
|
|
|
-var DICT = "Dict";
|
|
|
-function format(value) {
|
|
|
- if (Array.isArray(value)) {
|
|
|
- return JSON.stringify(value);
|
|
|
- }
|
|
|
- if (value instanceof Map) {
|
|
|
- return "Map{}";
|
|
|
- }
|
|
|
- if (value instanceof Set) {
|
|
|
- return "Set{}";
|
|
|
- }
|
|
|
- if (typeof value === "object") {
|
|
|
- return JSON.stringify(value);
|
|
|
- }
|
|
|
- return String(value);
|
|
|
-}
|
|
|
-function throwError(action, src, type, cause) {
|
|
|
- return new Error(`failed to ${action} "${format(src)}" as ${type}`, {
|
|
|
- cause
|
|
|
- });
|
|
|
-}
|
|
|
-function serializeError(src, type, cause) {
|
|
|
- return throwError("serialize", src, type, cause);
|
|
|
-}
|
|
|
-var SfToken = class {
|
|
|
- constructor(description) {
|
|
|
- this.description = description;
|
|
|
- }
|
|
|
-};
|
|
|
-var BARE_ITEM = "Bare Item";
|
|
|
-var BOOLEAN = "Boolean";
|
|
|
-function serializeBoolean(value) {
|
|
|
- if (typeof value !== "boolean") {
|
|
|
- throw serializeError(value, BOOLEAN);
|
|
|
- }
|
|
|
- return value ? "?1" : "?0";
|
|
|
-}
|
|
|
-function encodeBase64(binary) {
|
|
|
- return btoa(String.fromCharCode(...binary));
|
|
|
-}
|
|
|
-var BYTES = "Byte Sequence";
|
|
|
-function serializeByteSequence(value) {
|
|
|
- if (ArrayBuffer.isView(value) === false) {
|
|
|
- throw serializeError(value, BYTES);
|
|
|
- }
|
|
|
- return `:${encodeBase64(value)}:`;
|
|
|
-}
|
|
|
-var INTEGER = "Integer";
|
|
|
-function isInvalidInt(value) {
|
|
|
- return value < -999999999999999 || 999999999999999 < value;
|
|
|
-}
|
|
|
-function serializeInteger(value) {
|
|
|
- if (isInvalidInt(value)) {
|
|
|
- throw serializeError(value, INTEGER);
|
|
|
- }
|
|
|
- return value.toString();
|
|
|
-}
|
|
|
-function serializeDate(value) {
|
|
|
- return `@${serializeInteger(value.getTime() / 1e3)}`;
|
|
|
-}
|
|
|
-function roundToEven(value, precision) {
|
|
|
- if (value < 0) {
|
|
|
- return -roundToEven(-value, precision);
|
|
|
- }
|
|
|
- const decimalShift = Math.pow(10, precision);
|
|
|
- const isEquidistant = Math.abs(value * decimalShift % 1 - 0.5) < Number.EPSILON;
|
|
|
- if (isEquidistant) {
|
|
|
- const flooredValue = Math.floor(value * decimalShift);
|
|
|
- return (flooredValue % 2 === 0 ? flooredValue : flooredValue + 1) / decimalShift;
|
|
|
- } else {
|
|
|
- return Math.round(value * decimalShift) / decimalShift;
|
|
|
- }
|
|
|
-}
|
|
|
-var DECIMAL = "Decimal";
|
|
|
-function serializeDecimal(value) {
|
|
|
- const roundedValue = roundToEven(value, 3);
|
|
|
- if (Math.floor(Math.abs(roundedValue)).toString().length > 12) {
|
|
|
- throw serializeError(value, DECIMAL);
|
|
|
- }
|
|
|
- const stringValue = roundedValue.toString();
|
|
|
- return stringValue.includes(".") ? stringValue : `${stringValue}.0`;
|
|
|
-}
|
|
|
-var STRING = "String";
|
|
|
-var STRING_REGEX = /[\x00-\x1f\x7f]+/;
|
|
|
-function serializeString(value) {
|
|
|
- if (STRING_REGEX.test(value)) {
|
|
|
- throw serializeError(value, STRING);
|
|
|
- }
|
|
|
- return `"${value.replace(/\\/g, `\\\\`).replace(/"/g, `\\"`)}"`;
|
|
|
-}
|
|
|
-function symbolToStr(symbol) {
|
|
|
- return symbol.description || symbol.toString().slice(7, -1);
|
|
|
-}
|
|
|
-var TOKEN = "Token";
|
|
|
-function serializeToken(token) {
|
|
|
- const value = symbolToStr(token);
|
|
|
- if (/^([a-zA-Z*])([!#$%&'*+\-.^_`|~\w:/]*)$/.test(value) === false) {
|
|
|
- throw serializeError(value, TOKEN);
|
|
|
- }
|
|
|
- return value;
|
|
|
-}
|
|
|
-function serializeBareItem(value) {
|
|
|
- switch (typeof value) {
|
|
|
- case "number":
|
|
|
- if (!isFiniteNumber(value)) {
|
|
|
- throw serializeError(value, BARE_ITEM);
|
|
|
- }
|
|
|
- if (Number.isInteger(value)) {
|
|
|
- return serializeInteger(value);
|
|
|
- }
|
|
|
- return serializeDecimal(value);
|
|
|
- case "string":
|
|
|
- return serializeString(value);
|
|
|
- case "symbol":
|
|
|
- return serializeToken(value);
|
|
|
- case "boolean":
|
|
|
- return serializeBoolean(value);
|
|
|
- case "object":
|
|
|
- if (value instanceof Date) {
|
|
|
- return serializeDate(value);
|
|
|
- }
|
|
|
- if (value instanceof Uint8Array) {
|
|
|
- return serializeByteSequence(value);
|
|
|
- }
|
|
|
- if (value instanceof SfToken) {
|
|
|
- return serializeToken(value);
|
|
|
- }
|
|
|
- default:
|
|
|
- throw serializeError(value, BARE_ITEM);
|
|
|
- }
|
|
|
-}
|
|
|
-var KEY = "Key";
|
|
|
-function serializeKey(value) {
|
|
|
- if (/^[a-z*][a-z0-9\-_.*]*$/.test(value) === false) {
|
|
|
- throw serializeError(value, KEY);
|
|
|
- }
|
|
|
- return value;
|
|
|
-}
|
|
|
-function serializeParams(params) {
|
|
|
- if (params == null) {
|
|
|
- return "";
|
|
|
- }
|
|
|
- return Object.entries(params).map(([key, value]) => {
|
|
|
- if (value === true) {
|
|
|
- return `;${serializeKey(key)}`;
|
|
|
- }
|
|
|
- return `;${serializeKey(key)}=${serializeBareItem(value)}`;
|
|
|
- }).join("");
|
|
|
-}
|
|
|
-function serializeItem(value) {
|
|
|
- if (value instanceof SfItem) {
|
|
|
- return `${serializeBareItem(value.value)}${serializeParams(value.params)}`;
|
|
|
- } else {
|
|
|
- return serializeBareItem(value);
|
|
|
- }
|
|
|
-}
|
|
|
-function serializeInnerList(value) {
|
|
|
- return `(${value.value.map(serializeItem).join(" ")})${serializeParams(value.params)}`;
|
|
|
-}
|
|
|
-function serializeDict(dict, options = {
|
|
|
- whitespace: true
|
|
|
-}) {
|
|
|
- if (typeof dict !== "object" || dict == null) {
|
|
|
- throw serializeError(dict, DICT);
|
|
|
- }
|
|
|
- const entries = dict instanceof Map ? dict.entries() : Object.entries(dict);
|
|
|
- const optionalWhiteSpace = (options === null || options === void 0 ? void 0 : options.whitespace) ? " " : "";
|
|
|
- return Array.from(entries).map(([key, item]) => {
|
|
|
- if (item instanceof SfItem === false) {
|
|
|
- item = new SfItem(item);
|
|
|
- }
|
|
|
- let output = serializeKey(key);
|
|
|
- if (item.value === true) {
|
|
|
- output += serializeParams(item.params);
|
|
|
- } else {
|
|
|
- output += "=";
|
|
|
- if (Array.isArray(item.value)) {
|
|
|
- output += serializeInnerList(item);
|
|
|
- } else {
|
|
|
- output += serializeItem(item);
|
|
|
- }
|
|
|
- }
|
|
|
- return output;
|
|
|
- }).join(`,${optionalWhiteSpace}`);
|
|
|
-}
|
|
|
-function encodeSfDict(value, options) {
|
|
|
- return serializeDict(value, options);
|
|
|
-}
|
|
|
-var CMCD_OBJECT = "CMCD-Object";
|
|
|
-var CMCD_REQUEST = "CMCD-Request";
|
|
|
-var CMCD_SESSION = "CMCD-Session";
|
|
|
-var CMCD_STATUS = "CMCD-Status";
|
|
|
-var CMCD_HEADER_MAP = {
|
|
|
- // Object
|
|
|
- br: CMCD_OBJECT,
|
|
|
- ab: CMCD_OBJECT,
|
|
|
- d: CMCD_OBJECT,
|
|
|
- ot: CMCD_OBJECT,
|
|
|
- tb: CMCD_OBJECT,
|
|
|
- tpb: CMCD_OBJECT,
|
|
|
- lb: CMCD_OBJECT,
|
|
|
- tab: CMCD_OBJECT,
|
|
|
- lab: CMCD_OBJECT,
|
|
|
- url: CMCD_OBJECT,
|
|
|
- // Request
|
|
|
- pb: CMCD_REQUEST,
|
|
|
- bl: CMCD_REQUEST,
|
|
|
- tbl: CMCD_REQUEST,
|
|
|
- dl: CMCD_REQUEST,
|
|
|
- ltc: CMCD_REQUEST,
|
|
|
- mtp: CMCD_REQUEST,
|
|
|
- nor: CMCD_REQUEST,
|
|
|
- nrr: CMCD_REQUEST,
|
|
|
- rc: CMCD_REQUEST,
|
|
|
- sn: CMCD_REQUEST,
|
|
|
- sta: CMCD_REQUEST,
|
|
|
- su: CMCD_REQUEST,
|
|
|
- ttfb: CMCD_REQUEST,
|
|
|
- ttfbb: CMCD_REQUEST,
|
|
|
- ttlb: CMCD_REQUEST,
|
|
|
- cmsdd: CMCD_REQUEST,
|
|
|
- cmsds: CMCD_REQUEST,
|
|
|
- smrt: CMCD_REQUEST,
|
|
|
- df: CMCD_REQUEST,
|
|
|
- cs: CMCD_REQUEST,
|
|
|
- // TODO: Which header to put the `ts` field is not defined yet.
|
|
|
- ts: CMCD_REQUEST,
|
|
|
- // Session
|
|
|
- cid: CMCD_SESSION,
|
|
|
- pr: CMCD_SESSION,
|
|
|
- sf: CMCD_SESSION,
|
|
|
- sid: CMCD_SESSION,
|
|
|
- st: CMCD_SESSION,
|
|
|
- v: CMCD_SESSION,
|
|
|
- msd: CMCD_SESSION,
|
|
|
- // Status
|
|
|
- bs: CMCD_STATUS,
|
|
|
- bsd: CMCD_STATUS,
|
|
|
- cdn: CMCD_STATUS,
|
|
|
- rtp: CMCD_STATUS,
|
|
|
- bg: CMCD_STATUS,
|
|
|
- pt: CMCD_STATUS,
|
|
|
- ec: CMCD_STATUS,
|
|
|
- e: CMCD_STATUS
|
|
|
-};
|
|
|
-var CmcdHeaderField = {
|
|
|
- /**
|
|
|
- * keys whose values vary with each request.
|
|
|
- */
|
|
|
- REQUEST: CMCD_REQUEST
|
|
|
-};
|
|
|
-function createHeaderMap(headerMap) {
|
|
|
- return Object.keys(headerMap).reduce((acc, field) => {
|
|
|
- var _a;
|
|
|
- (_a = headerMap[field]) === null || _a === void 0 ? void 0 : _a.forEach((key) => acc[key] = field);
|
|
|
- return acc;
|
|
|
- }, {});
|
|
|
-}
|
|
|
-function groupCmcdHeaders(cmcd, customHeaderMap) {
|
|
|
- const result = {};
|
|
|
- if (!cmcd) {
|
|
|
- return result;
|
|
|
- }
|
|
|
- const keys = Object.keys(cmcd);
|
|
|
- const custom = customHeaderMap ? createHeaderMap(customHeaderMap) : {};
|
|
|
- return keys.reduce((acc, key) => {
|
|
|
- var _a;
|
|
|
- const field = CMCD_HEADER_MAP[key] || custom[key] || CmcdHeaderField.REQUEST;
|
|
|
- const data = (_a = acc[field]) !== null && _a !== void 0 ? _a : acc[field] = {};
|
|
|
- data[key] = cmcd[key];
|
|
|
- return acc;
|
|
|
- }, result);
|
|
|
-}
|
|
|
-function isTokenField(key) {
|
|
|
- return ["ot", "sf", "st", "e", "sta"].includes(key);
|
|
|
-}
|
|
|
-function isValid(value) {
|
|
|
- if (typeof value === "number") {
|
|
|
- return isFiniteNumber(value);
|
|
|
- }
|
|
|
- return value != null && value !== "" && value !== false;
|
|
|
-}
|
|
|
-var CMCD_EVENT_MODE = "event";
|
|
|
-function urlToRelativePath(url, base) {
|
|
|
- const to = new URL(url);
|
|
|
- const from = new URL(base);
|
|
|
- if (to.origin !== from.origin) {
|
|
|
- return url;
|
|
|
- }
|
|
|
- const toPath = to.pathname.split("/").slice(1);
|
|
|
- const fromPath = from.pathname.split("/").slice(1, -1);
|
|
|
- while (toPath[0] === fromPath[0]) {
|
|
|
- toPath.shift();
|
|
|
- fromPath.shift();
|
|
|
- }
|
|
|
- while (fromPath.length) {
|
|
|
- fromPath.shift();
|
|
|
- toPath.unshift("..");
|
|
|
- }
|
|
|
- const relativePath = toPath.join("/");
|
|
|
- return relativePath + to.search + to.hash;
|
|
|
-}
|
|
|
-var toRounded = (value) => Math.round(value);
|
|
|
-var toUrlSafe = (value, options) => {
|
|
|
- if (Array.isArray(value)) {
|
|
|
- return value.map((item) => toUrlSafe(item, options));
|
|
|
- }
|
|
|
- if (value instanceof SfItem && typeof value.value === "string") {
|
|
|
- return new SfItem(toUrlSafe(value.value, options), value.params);
|
|
|
- } else {
|
|
|
- if (options.baseUrl) {
|
|
|
- value = urlToRelativePath(value, options.baseUrl);
|
|
|
- }
|
|
|
- return options.version === 1 ? encodeURIComponent(value) : value;
|
|
|
- }
|
|
|
-};
|
|
|
-var toHundred = (value) => toRounded(value / 100) * 100;
|
|
|
-var nor = (value, options) => {
|
|
|
- let norValue = value;
|
|
|
- if (options.version >= 2) {
|
|
|
- if (value instanceof SfItem && typeof value.value === "string") {
|
|
|
- norValue = new SfItem([value]);
|
|
|
- } else if (typeof value === "string") {
|
|
|
- norValue = [value];
|
|
|
- }
|
|
|
- }
|
|
|
- return toUrlSafe(norValue, options);
|
|
|
-};
|
|
|
-var CMCD_FORMATTER_MAP = {
|
|
|
- /**
|
|
|
- * Bitrate (kbps) rounded integer
|
|
|
- */
|
|
|
- br: toRounded,
|
|
|
- /**
|
|
|
- * Duration (milliseconds) rounded integer
|
|
|
- */
|
|
|
- d: toRounded,
|
|
|
- /**
|
|
|
- * Buffer Length (milliseconds) rounded nearest 100ms
|
|
|
- */
|
|
|
- bl: toHundred,
|
|
|
- /**
|
|
|
- * Deadline (milliseconds) rounded nearest 100ms
|
|
|
- */
|
|
|
- dl: toHundred,
|
|
|
- /**
|
|
|
- * Measured Throughput (kbps) rounded nearest 100kbps
|
|
|
- */
|
|
|
- mtp: toHundred,
|
|
|
- /**
|
|
|
- * Next Object Request URL encoded
|
|
|
- */
|
|
|
- nor,
|
|
|
- /**
|
|
|
- * Requested maximum throughput (kbps) rounded nearest 100kbps
|
|
|
- */
|
|
|
- rtp: toHundred,
|
|
|
- /**
|
|
|
- * Top Bitrate (kbps) rounded integer
|
|
|
- */
|
|
|
- tb: toRounded
|
|
|
-};
|
|
|
-var CMCD_REQUEST_MODE = "request";
|
|
|
-var CMCD_RESPONSE_MODE = "response";
|
|
|
-var CMCD_COMMON_KEYS = ["ab", "bg", "bl", "br", "bs", "bsd", "cdn", "cid", "cs", "df", "ec", "lab", "lb", "ltc", "msd", "mtp", "pb", "pr", "pt", "sf", "sid", "sn", "st", "sta", "tab", "tb", "tbl", "tpb", "ts", "v"];
|
|
|
-var CMCD_EVENT_KEYS = ["e"];
|
|
|
-var CUSTOM_KEY_REGEX = /^[a-zA-Z0-9-.]+-[a-zA-Z0-9-.]+$/;
|
|
|
-function isCmcdCustomKey(key) {
|
|
|
- return CUSTOM_KEY_REGEX.test(key);
|
|
|
-}
|
|
|
-function isCmcdEventKey(key) {
|
|
|
- return CMCD_COMMON_KEYS.includes(key) || CMCD_EVENT_KEYS.includes(key) || isCmcdCustomKey(key);
|
|
|
-}
|
|
|
-var CMCD_REQUEST_KEYS = ["d", "dl", "nor", "ot", "rtp", "su"];
|
|
|
-function isCmcdRequestKey(key) {
|
|
|
- return CMCD_COMMON_KEYS.includes(key) || CMCD_REQUEST_KEYS.includes(key) || isCmcdCustomKey(key);
|
|
|
-}
|
|
|
-var CMCD_RESPONSE_KEYS = ["cmsdd", "cmsds", "rc", "smrt", "ttfb", "ttfbb", "ttlb", "url"];
|
|
|
-function isCmcdResponseKey(key) {
|
|
|
- return CMCD_COMMON_KEYS.includes(key) || CMCD_REQUEST_KEYS.includes(key) || CMCD_RESPONSE_KEYS.includes(key) || isCmcdCustomKey(key);
|
|
|
-}
|
|
|
-var CMCD_V1_KEYS = ["bl", "br", "bs", "cid", "d", "dl", "mtp", "nor", "nrr", "ot", "pr", "rtp", "sf", "sid", "st", "su", "tb", "v"];
|
|
|
-function isCmcdV1Key(key) {
|
|
|
- return CMCD_V1_KEYS.includes(key) || isCmcdCustomKey(key);
|
|
|
-}
|
|
|
-var filterMap = {
|
|
|
- [CMCD_RESPONSE_MODE]: isCmcdResponseKey,
|
|
|
- [CMCD_EVENT_MODE]: isCmcdEventKey,
|
|
|
- [CMCD_REQUEST_MODE]: isCmcdRequestKey
|
|
|
-};
|
|
|
-function prepareCmcdData(obj, options = {}) {
|
|
|
- const results = {};
|
|
|
- if (obj == null || typeof obj !== "object") {
|
|
|
- return results;
|
|
|
- }
|
|
|
- const version2 = options.version || obj["v"] || 1;
|
|
|
- const reportingMode = options.reportingMode || CMCD_REQUEST_MODE;
|
|
|
- const keyFilter = version2 === 1 ? isCmcdV1Key : filterMap[reportingMode];
|
|
|
- let keys = Object.keys(obj).filter(keyFilter);
|
|
|
- const filter = options.filter;
|
|
|
- if (typeof filter === "function") {
|
|
|
- keys = keys.filter(filter);
|
|
|
- }
|
|
|
- const needsTimestamp = reportingMode === CMCD_RESPONSE_MODE || reportingMode === CMCD_EVENT_MODE;
|
|
|
- if (needsTimestamp && !keys.includes("ts")) {
|
|
|
- keys.push("ts");
|
|
|
- }
|
|
|
- if (version2 > 1 && !keys.includes("v")) {
|
|
|
- keys.push("v");
|
|
|
- }
|
|
|
- const formatters = _extends({}, CMCD_FORMATTER_MAP, options.formatters);
|
|
|
- const formatterOptions = {
|
|
|
- version: version2,
|
|
|
- reportingMode,
|
|
|
- baseUrl: options.baseUrl
|
|
|
- };
|
|
|
- keys.sort().forEach((key) => {
|
|
|
- let value = obj[key];
|
|
|
- const formatter = formatters[key];
|
|
|
- if (typeof formatter === "function") {
|
|
|
- value = formatter(value, formatterOptions);
|
|
|
- }
|
|
|
- if (key === "v") {
|
|
|
- if (version2 === 1) {
|
|
|
- return;
|
|
|
- } else {
|
|
|
- value = version2;
|
|
|
- }
|
|
|
- }
|
|
|
- if (key == "pr" && value === 1) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (needsTimestamp && key === "ts" && !isFiniteNumber(value)) {
|
|
|
- value = Date.now();
|
|
|
- }
|
|
|
- if (!isValid(value)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (isTokenField(key) && typeof value === "string") {
|
|
|
- value = new SfToken(value);
|
|
|
- }
|
|
|
- results[key] = value;
|
|
|
- });
|
|
|
- return results;
|
|
|
-}
|
|
|
-function toCmcdHeaders(cmcd, options = {}) {
|
|
|
- const result = {};
|
|
|
- if (!cmcd) {
|
|
|
- return result;
|
|
|
- }
|
|
|
- const data = prepareCmcdData(cmcd, options);
|
|
|
- const shards = groupCmcdHeaders(data, options === null || options === void 0 ? void 0 : options.customHeaderMap);
|
|
|
- return Object.entries(shards).reduce((acc, [field, value]) => {
|
|
|
- const shard = encodeSfDict(value, {
|
|
|
- whitespace: false
|
|
|
- });
|
|
|
- if (shard) {
|
|
|
- acc[field] = shard;
|
|
|
- }
|
|
|
- return acc;
|
|
|
- }, result);
|
|
|
-}
|
|
|
-function appendCmcdHeaders(headers, cmcd, options) {
|
|
|
- return _extends(headers, toCmcdHeaders(cmcd, options));
|
|
|
-}
|
|
|
-var CMCD_PARAM = "CMCD";
|
|
|
-function encodeCmcd(cmcd, options = {}) {
|
|
|
- if (!cmcd) {
|
|
|
- return "";
|
|
|
- }
|
|
|
- return encodeSfDict(prepareCmcdData(cmcd, options), {
|
|
|
- whitespace: false
|
|
|
- });
|
|
|
-}
|
|
|
-function toCmcdUrl(cmcd, options = {}) {
|
|
|
- if (!cmcd) {
|
|
|
- return "";
|
|
|
- }
|
|
|
- const params = encodeCmcd(cmcd, options);
|
|
|
- return encodeURIComponent(params);
|
|
|
-}
|
|
|
-function toCmcdQuery(cmcd, options = {}) {
|
|
|
- if (!cmcd) {
|
|
|
- return "";
|
|
|
- }
|
|
|
- const value = toCmcdUrl(cmcd, options);
|
|
|
- return `${CMCD_PARAM}=${value}`;
|
|
|
-}
|
|
|
-var REGEX = /CMCD=[^&#]+/;
|
|
|
-function appendCmcdQuery(url, cmcd, options) {
|
|
|
- const query = toCmcdQuery(cmcd, options);
|
|
|
- if (!query) {
|
|
|
- return url;
|
|
|
- }
|
|
|
- if (REGEX.test(url)) {
|
|
|
- return url.replace(REGEX, query);
|
|
|
- }
|
|
|
- const separator = url.includes("?") ? "&" : "?";
|
|
|
- return `${url}${separator}${query}`;
|
|
|
-}
|
|
|
-var CMCDController = class {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.config = void 0;
|
|
|
- this.media = void 0;
|
|
|
- this.sid = void 0;
|
|
|
- this.cid = void 0;
|
|
|
- this.useHeaders = false;
|
|
|
- this.includeKeys = void 0;
|
|
|
- this.initialized = false;
|
|
|
- this.starved = false;
|
|
|
- this.buffering = true;
|
|
|
- this.audioBuffer = void 0;
|
|
|
- this.videoBuffer = void 0;
|
|
|
- this.onWaiting = () => {
|
|
|
- if (this.initialized) {
|
|
|
- this.starved = true;
|
|
|
- }
|
|
|
- this.buffering = true;
|
|
|
- };
|
|
|
- this.onPlaying = () => {
|
|
|
- if (!this.initialized) {
|
|
|
- this.initialized = true;
|
|
|
- }
|
|
|
- this.buffering = false;
|
|
|
- };
|
|
|
- this.applyPlaylistData = (context) => {
|
|
|
- try {
|
|
|
- this.apply(context, {
|
|
|
- ot: CmcdObjectType.MANIFEST,
|
|
|
- su: !this.initialized
|
|
|
- });
|
|
|
- } catch (error) {
|
|
|
- this.hls.logger.warn("Could not generate manifest CMCD data.", error);
|
|
|
- }
|
|
|
- };
|
|
|
- this.applyFragmentData = (context) => {
|
|
|
- try {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part
|
|
|
- } = context;
|
|
|
- const level = this.hls.levels[frag.level];
|
|
|
- const ot = this.getObjectType(frag);
|
|
|
- const data = {
|
|
|
- d: (part || frag).duration * 1e3,
|
|
|
- ot
|
|
|
- };
|
|
|
- if (ot === CmcdObjectType.VIDEO || ot === CmcdObjectType.AUDIO || ot == CmcdObjectType.MUXED) {
|
|
|
- data.br = level.bitrate / 1e3;
|
|
|
- data.tb = this.getTopBandwidth(ot) / 1e3;
|
|
|
- data.bl = this.getBufferLength(ot);
|
|
|
- }
|
|
|
- const next = part ? this.getNextPart(part) : this.getNextFrag(frag);
|
|
|
- if (next != null && next.url && next.url !== frag.url) {
|
|
|
- data.nor = next.url;
|
|
|
- }
|
|
|
- this.apply(context, data);
|
|
|
- } catch (error) {
|
|
|
- this.hls.logger.warn("Could not generate segment CMCD data.", error);
|
|
|
- }
|
|
|
- };
|
|
|
- this.hls = hls;
|
|
|
- const config = this.config = hls.config;
|
|
|
- const {
|
|
|
- cmcd
|
|
|
- } = config;
|
|
|
- if (cmcd != null) {
|
|
|
- config.pLoader = this.createPlaylistLoader();
|
|
|
- config.fLoader = this.createFragmentLoader();
|
|
|
- this.sid = cmcd.sessionId || hls.sessionId;
|
|
|
- this.cid = cmcd.contentId;
|
|
|
- this.useHeaders = cmcd.useHeaders === true;
|
|
|
- this.includeKeys = cmcd.includeKeys;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.on(Events.MEDIA_DETACHED, this.onMediaDetached, this);
|
|
|
- hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.off(Events.MEDIA_DETACHED, this.onMediaDetached, this);
|
|
|
- hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.onMediaDetached();
|
|
|
- this.hls = this.config = this.audioBuffer = this.videoBuffer = null;
|
|
|
- this.onWaiting = this.onPlaying = this.media = null;
|
|
|
- }
|
|
|
- onMediaAttached(event, data) {
|
|
|
- this.media = data.media;
|
|
|
- this.media.addEventListener("waiting", this.onWaiting);
|
|
|
- this.media.addEventListener("playing", this.onPlaying);
|
|
|
- }
|
|
|
- onMediaDetached() {
|
|
|
- if (!this.media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.media.removeEventListener("waiting", this.onWaiting);
|
|
|
- this.media.removeEventListener("playing", this.onPlaying);
|
|
|
- this.media = null;
|
|
|
- }
|
|
|
- onBufferCreated(event, data) {
|
|
|
- var _data$tracks$audio, _data$tracks$video;
|
|
|
- this.audioBuffer = (_data$tracks$audio = data.tracks.audio) == null ? void 0 : _data$tracks$audio.buffer;
|
|
|
- this.videoBuffer = (_data$tracks$video = data.tracks.video) == null ? void 0 : _data$tracks$video.buffer;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Create baseline CMCD data
|
|
|
- */
|
|
|
- createData() {
|
|
|
- var _this$media;
|
|
|
- return {
|
|
|
- v: 1,
|
|
|
- sf: CmcdStreamingFormat.HLS,
|
|
|
- sid: this.sid,
|
|
|
- cid: this.cid,
|
|
|
- pr: (_this$media = this.media) == null ? void 0 : _this$media.playbackRate,
|
|
|
- mtp: this.hls.bandwidthEstimate / 1e3
|
|
|
- };
|
|
|
- }
|
|
|
- /**
|
|
|
- * Apply CMCD data to a request.
|
|
|
- */
|
|
|
- apply(context, data = {}) {
|
|
|
- _extends(data, this.createData());
|
|
|
- const isVideo = data.ot === CmcdObjectType.INIT || data.ot === CmcdObjectType.VIDEO || data.ot === CmcdObjectType.MUXED;
|
|
|
- if (this.starved && isVideo) {
|
|
|
- data.bs = true;
|
|
|
- data.su = true;
|
|
|
- this.starved = false;
|
|
|
- }
|
|
|
- if (data.su == null) {
|
|
|
- data.su = this.buffering;
|
|
|
- }
|
|
|
- const {
|
|
|
- includeKeys
|
|
|
- } = this;
|
|
|
- if (includeKeys) {
|
|
|
- data = Object.keys(data).reduce((acc, key) => {
|
|
|
- includeKeys.includes(key) && (acc[key] = data[key]);
|
|
|
- return acc;
|
|
|
- }, {});
|
|
|
- }
|
|
|
- const options = {
|
|
|
- baseUrl: context.url
|
|
|
- };
|
|
|
- if (this.useHeaders) {
|
|
|
- if (!context.headers) {
|
|
|
- context.headers = {};
|
|
|
- }
|
|
|
- appendCmcdHeaders(context.headers, data, options);
|
|
|
- } else {
|
|
|
- context.url = appendCmcdQuery(context.url, data, options);
|
|
|
- }
|
|
|
- }
|
|
|
- getNextFrag(fragment) {
|
|
|
- var _this$hls$levels$frag;
|
|
|
- const levelDetails = (_this$hls$levels$frag = this.hls.levels[fragment.level]) == null ? void 0 : _this$hls$levels$frag.details;
|
|
|
- if (levelDetails) {
|
|
|
- const index = fragment.sn - levelDetails.startSN;
|
|
|
- return levelDetails.fragments[index + 1];
|
|
|
- }
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- getNextPart(part) {
|
|
|
- var _this$hls$levels$frag2;
|
|
|
- const {
|
|
|
- index,
|
|
|
- fragment
|
|
|
- } = part;
|
|
|
- const partList = (_this$hls$levels$frag2 = this.hls.levels[fragment.level]) == null || (_this$hls$levels$frag2 = _this$hls$levels$frag2.details) == null ? void 0 : _this$hls$levels$frag2.partList;
|
|
|
- if (partList) {
|
|
|
- const {
|
|
|
- sn
|
|
|
- } = fragment;
|
|
|
- for (let i = partList.length - 1; i >= 0; i--) {
|
|
|
- const p = partList[i];
|
|
|
- if (p.index === index && p.fragment.sn === sn) {
|
|
|
- return partList[i + 1];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- /**
|
|
|
- * The CMCD object type.
|
|
|
- */
|
|
|
- getObjectType(fragment) {
|
|
|
- const {
|
|
|
- type
|
|
|
- } = fragment;
|
|
|
- if (type === "subtitle") {
|
|
|
- return CmcdObjectType.TIMED_TEXT;
|
|
|
- }
|
|
|
- if (fragment.sn === "initSegment") {
|
|
|
- return CmcdObjectType.INIT;
|
|
|
- }
|
|
|
- if (type === "audio") {
|
|
|
- return CmcdObjectType.AUDIO;
|
|
|
- }
|
|
|
- if (type === "main") {
|
|
|
- if (!this.hls.audioTracks.length) {
|
|
|
- return CmcdObjectType.MUXED;
|
|
|
- }
|
|
|
- return CmcdObjectType.VIDEO;
|
|
|
- }
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get the highest bitrate.
|
|
|
- */
|
|
|
- getTopBandwidth(type) {
|
|
|
- let bitrate = 0;
|
|
|
- let levels;
|
|
|
- const hls = this.hls;
|
|
|
- if (type === CmcdObjectType.AUDIO) {
|
|
|
- levels = hls.audioTracks;
|
|
|
- } else {
|
|
|
- const max = hls.maxAutoLevel;
|
|
|
- const len = max > -1 ? max + 1 : hls.levels.length;
|
|
|
- levels = hls.levels.slice(0, len);
|
|
|
- }
|
|
|
- levels.forEach((level) => {
|
|
|
- if (level.bitrate > bitrate) {
|
|
|
- bitrate = level.bitrate;
|
|
|
- }
|
|
|
- });
|
|
|
- return bitrate > 0 ? bitrate : NaN;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get the buffer length for a media type in milliseconds
|
|
|
- */
|
|
|
- getBufferLength(type) {
|
|
|
- const media = this.media;
|
|
|
- const buffer = type === CmcdObjectType.AUDIO ? this.audioBuffer : this.videoBuffer;
|
|
|
- if (!buffer || !media) {
|
|
|
- return NaN;
|
|
|
- }
|
|
|
- const info = BufferHelper.bufferInfo(buffer, media.currentTime, this.config.maxBufferHole);
|
|
|
- return info.len * 1e3;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Create a playlist loader
|
|
|
- */
|
|
|
- createPlaylistLoader() {
|
|
|
- const {
|
|
|
- pLoader
|
|
|
- } = this.config;
|
|
|
- const apply = this.applyPlaylistData;
|
|
|
- const Ctor = pLoader || this.config.loader;
|
|
|
- return class CmcdPlaylistLoader {
|
|
|
- constructor(config) {
|
|
|
- this.loader = void 0;
|
|
|
- this.loader = new Ctor(config);
|
|
|
- }
|
|
|
- get stats() {
|
|
|
- return this.loader.stats;
|
|
|
- }
|
|
|
- get context() {
|
|
|
- return this.loader.context;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.loader.destroy();
|
|
|
- }
|
|
|
- abort() {
|
|
|
- this.loader.abort();
|
|
|
- }
|
|
|
- load(context, config, callbacks) {
|
|
|
- apply(context);
|
|
|
- this.loader.load(context, config, callbacks);
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
- /**
|
|
|
- * Create a playlist loader
|
|
|
- */
|
|
|
- createFragmentLoader() {
|
|
|
- const {
|
|
|
- fLoader
|
|
|
- } = this.config;
|
|
|
- const apply = this.applyFragmentData;
|
|
|
- const Ctor = fLoader || this.config.loader;
|
|
|
- return class CmcdFragmentLoader {
|
|
|
- constructor(config) {
|
|
|
- this.loader = void 0;
|
|
|
- this.loader = new Ctor(config);
|
|
|
- }
|
|
|
- get stats() {
|
|
|
- return this.loader.stats;
|
|
|
- }
|
|
|
- get context() {
|
|
|
- return this.loader.context;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.loader.destroy();
|
|
|
- }
|
|
|
- abort() {
|
|
|
- this.loader.abort();
|
|
|
- }
|
|
|
- load(context, config, callbacks) {
|
|
|
- apply(context);
|
|
|
- this.loader.load(context, config, callbacks);
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
-};
|
|
|
-var PATHWAY_PENALTY_DURATION_MS = 3e5;
|
|
|
-var ContentSteeringController = class extends Logger {
|
|
|
- constructor(hls) {
|
|
|
- super("content-steering", hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.loader = null;
|
|
|
- this.uri = null;
|
|
|
- this.pathwayId = ".";
|
|
|
- this._pathwayPriority = null;
|
|
|
- this.timeToLoad = 300;
|
|
|
- this.reloadTimer = -1;
|
|
|
- this.updated = 0;
|
|
|
- this.started = false;
|
|
|
- this.enabled = true;
|
|
|
- this.levels = null;
|
|
|
- this.audioTracks = null;
|
|
|
- this.subtitleTracks = null;
|
|
|
- this.penalizedPathways = {};
|
|
|
- this.hls = hls;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- pathways() {
|
|
|
- return (this.levels || []).reduce((pathways, level) => {
|
|
|
- if (pathways.indexOf(level.pathwayId) === -1) {
|
|
|
- pathways.push(level.pathwayId);
|
|
|
- }
|
|
|
- return pathways;
|
|
|
- }, []);
|
|
|
- }
|
|
|
- get pathwayPriority() {
|
|
|
- return this._pathwayPriority;
|
|
|
- }
|
|
|
- set pathwayPriority(pathwayPriority) {
|
|
|
- this.updatePathwayPriority(pathwayPriority);
|
|
|
- }
|
|
|
- startLoad() {
|
|
|
- this.started = true;
|
|
|
- this.clearTimeout();
|
|
|
- if (this.enabled && this.uri) {
|
|
|
- if (this.updated) {
|
|
|
- const ttl = this.timeToLoad * 1e3 - (performance.now() - this.updated);
|
|
|
- if (ttl > 0) {
|
|
|
- this.scheduleRefresh(this.uri, ttl);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.loadSteeringManifest(this.uri);
|
|
|
- }
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- this.started = false;
|
|
|
- if (this.loader) {
|
|
|
- this.loader.destroy();
|
|
|
- this.loader = null;
|
|
|
- }
|
|
|
- this.clearTimeout();
|
|
|
- }
|
|
|
- clearTimeout() {
|
|
|
- if (this.reloadTimer !== -1) {
|
|
|
- self.clearTimeout(this.reloadTimer);
|
|
|
- this.reloadTimer = -1;
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.stopLoad();
|
|
|
- this.hls = null;
|
|
|
- this.levels = this.audioTracks = this.subtitleTracks = null;
|
|
|
- }
|
|
|
- removeLevel(levelToRemove) {
|
|
|
- const levels = this.levels;
|
|
|
- if (levels) {
|
|
|
- this.levels = levels.filter((level) => level !== levelToRemove);
|
|
|
- }
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.stopLoad();
|
|
|
- this.enabled = true;
|
|
|
- this.timeToLoad = 300;
|
|
|
- this.updated = 0;
|
|
|
- this.uri = null;
|
|
|
- this.pathwayId = ".";
|
|
|
- this.levels = this.audioTracks = this.subtitleTracks = null;
|
|
|
- }
|
|
|
- onManifestLoaded(event, data) {
|
|
|
- const {
|
|
|
- contentSteering
|
|
|
- } = data;
|
|
|
- if (contentSteering === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.pathwayId = contentSteering.pathwayId;
|
|
|
- this.uri = contentSteering.uri;
|
|
|
- if (this.started) {
|
|
|
- this.startLoad();
|
|
|
- }
|
|
|
- }
|
|
|
- onManifestParsed(event, data) {
|
|
|
- this.audioTracks = data.audioTracks;
|
|
|
- this.subtitleTracks = data.subtitleTracks;
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- const {
|
|
|
- errorAction
|
|
|
- } = data;
|
|
|
- if ((errorAction == null ? void 0 : errorAction.action) === NetworkErrorAction.SendAlternateToPenaltyBox && errorAction.flags === ErrorActionFlags.MoveAllAlternatesMatchingHost) {
|
|
|
- const levels = this.levels;
|
|
|
- let pathwayPriority = this._pathwayPriority;
|
|
|
- let errorPathway = this.pathwayId;
|
|
|
- if (data.context) {
|
|
|
- const {
|
|
|
- groupId,
|
|
|
- pathwayId,
|
|
|
- type
|
|
|
- } = data.context;
|
|
|
- if (groupId && levels) {
|
|
|
- errorPathway = this.getPathwayForGroupId(groupId, type, errorPathway);
|
|
|
- } else if (pathwayId) {
|
|
|
- errorPathway = pathwayId;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!(errorPathway in this.penalizedPathways)) {
|
|
|
- this.penalizedPathways[errorPathway] = performance.now();
|
|
|
- }
|
|
|
- if (!pathwayPriority && levels) {
|
|
|
- pathwayPriority = this.pathways();
|
|
|
- }
|
|
|
- if (pathwayPriority && pathwayPriority.length > 1) {
|
|
|
- this.updatePathwayPriority(pathwayPriority);
|
|
|
- errorAction.resolved = this.pathwayId !== errorPathway;
|
|
|
- }
|
|
|
- if (data.details === ErrorDetails.BUFFER_APPEND_ERROR && !data.fatal) {
|
|
|
- errorAction.resolved = true;
|
|
|
- } else if (!errorAction.resolved) {
|
|
|
- this.warn(`Could not resolve ${data.details} ("${data.error.message}") with content-steering for Pathway: ${errorPathway} levels: ${levels ? levels.length : levels} priorities: ${stringify(pathwayPriority)} penalized: ${stringify(this.penalizedPathways)}`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- filterParsedLevels(levels) {
|
|
|
- this.levels = levels;
|
|
|
- let pathwayLevels = this.getLevelsForPathway(this.pathwayId);
|
|
|
- if (pathwayLevels.length === 0) {
|
|
|
- const pathwayId = levels[0].pathwayId;
|
|
|
- this.log(`No levels found in Pathway ${this.pathwayId}. Setting initial Pathway to "${pathwayId}"`);
|
|
|
- pathwayLevels = this.getLevelsForPathway(pathwayId);
|
|
|
- this.pathwayId = pathwayId;
|
|
|
- }
|
|
|
- if (pathwayLevels.length !== levels.length) {
|
|
|
- this.log(`Found ${pathwayLevels.length}/${levels.length} levels in Pathway "${this.pathwayId}"`);
|
|
|
- }
|
|
|
- return pathwayLevels;
|
|
|
- }
|
|
|
- getLevelsForPathway(pathwayId) {
|
|
|
- if (this.levels === null) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- return this.levels.filter((level) => pathwayId === level.pathwayId);
|
|
|
- }
|
|
|
- updatePathwayPriority(pathwayPriority) {
|
|
|
- this._pathwayPriority = pathwayPriority;
|
|
|
- let levels;
|
|
|
- const penalizedPathways = this.penalizedPathways;
|
|
|
- const now2 = performance.now();
|
|
|
- Object.keys(penalizedPathways).forEach((pathwayId) => {
|
|
|
- if (now2 - penalizedPathways[pathwayId] > PATHWAY_PENALTY_DURATION_MS) {
|
|
|
- delete penalizedPathways[pathwayId];
|
|
|
- }
|
|
|
- });
|
|
|
- for (let i = 0; i < pathwayPriority.length; i++) {
|
|
|
- const pathwayId = pathwayPriority[i];
|
|
|
- if (pathwayId in penalizedPathways) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (pathwayId === this.pathwayId) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const selectedIndex = this.hls.nextLoadLevel;
|
|
|
- const selectedLevel = this.hls.levels[selectedIndex];
|
|
|
- levels = this.getLevelsForPathway(pathwayId);
|
|
|
- if (levels.length > 0) {
|
|
|
- this.log(`Setting Pathway to "${pathwayId}"`);
|
|
|
- this.pathwayId = pathwayId;
|
|
|
- reassignFragmentLevelIndexes(levels);
|
|
|
- this.hls.trigger(Events.LEVELS_UPDATED, {
|
|
|
- levels
|
|
|
- });
|
|
|
- const levelAfterChange = this.hls.levels[selectedIndex];
|
|
|
- if (selectedLevel && levelAfterChange && this.levels) {
|
|
|
- if (levelAfterChange.attrs["STABLE-VARIANT-ID"] !== selectedLevel.attrs["STABLE-VARIANT-ID"] && levelAfterChange.bitrate !== selectedLevel.bitrate) {
|
|
|
- this.log(`Unstable Pathways change from bitrate ${selectedLevel.bitrate} to ${levelAfterChange.bitrate}`);
|
|
|
- }
|
|
|
- this.hls.nextLoadLevel = selectedIndex;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- getPathwayForGroupId(groupId, type, defaultPathway) {
|
|
|
- const levels = this.getLevelsForPathway(defaultPathway).concat(this.levels || []);
|
|
|
- for (let i = 0; i < levels.length; i++) {
|
|
|
- if (type === PlaylistContextType.AUDIO_TRACK && levels[i].hasAudioGroup(groupId) || type === PlaylistContextType.SUBTITLE_TRACK && levels[i].hasSubtitleGroup(groupId)) {
|
|
|
- return levels[i].pathwayId;
|
|
|
- }
|
|
|
- }
|
|
|
- return defaultPathway;
|
|
|
- }
|
|
|
- clonePathways(pathwayClones) {
|
|
|
- const levels = this.levels;
|
|
|
- if (!levels) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const audioGroupCloneMap = {};
|
|
|
- const subtitleGroupCloneMap = {};
|
|
|
- pathwayClones.forEach((pathwayClone) => {
|
|
|
- const {
|
|
|
- ID: cloneId,
|
|
|
- "BASE-ID": baseId,
|
|
|
- "URI-REPLACEMENT": uriReplacement
|
|
|
- } = pathwayClone;
|
|
|
- if (levels.some((level) => level.pathwayId === cloneId)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const clonedVariants = this.getLevelsForPathway(baseId).map((baseLevel) => {
|
|
|
- const attributes = new AttrList(baseLevel.attrs);
|
|
|
- attributes["PATHWAY-ID"] = cloneId;
|
|
|
- const clonedAudioGroupId = attributes.AUDIO && `${attributes.AUDIO}_clone_${cloneId}`;
|
|
|
- const clonedSubtitleGroupId = attributes.SUBTITLES && `${attributes.SUBTITLES}_clone_${cloneId}`;
|
|
|
- if (clonedAudioGroupId) {
|
|
|
- audioGroupCloneMap[attributes.AUDIO] = clonedAudioGroupId;
|
|
|
- attributes.AUDIO = clonedAudioGroupId;
|
|
|
- }
|
|
|
- if (clonedSubtitleGroupId) {
|
|
|
- subtitleGroupCloneMap[attributes.SUBTITLES] = clonedSubtitleGroupId;
|
|
|
- attributes.SUBTITLES = clonedSubtitleGroupId;
|
|
|
- }
|
|
|
- const url = performUriReplacement(baseLevel.uri, attributes["STABLE-VARIANT-ID"], "PER-VARIANT-URIS", uriReplacement);
|
|
|
- const clonedLevel = new Level({
|
|
|
- attrs: attributes,
|
|
|
- audioCodec: baseLevel.audioCodec,
|
|
|
- bitrate: baseLevel.bitrate,
|
|
|
- height: baseLevel.height,
|
|
|
- name: baseLevel.name,
|
|
|
- url,
|
|
|
- videoCodec: baseLevel.videoCodec,
|
|
|
- width: baseLevel.width
|
|
|
- });
|
|
|
- if (baseLevel.audioGroups) {
|
|
|
- for (let i = 1; i < baseLevel.audioGroups.length; i++) {
|
|
|
- clonedLevel.addGroupId("audio", `${baseLevel.audioGroups[i]}_clone_${cloneId}`);
|
|
|
- }
|
|
|
- }
|
|
|
- if (baseLevel.subtitleGroups) {
|
|
|
- for (let i = 1; i < baseLevel.subtitleGroups.length; i++) {
|
|
|
- clonedLevel.addGroupId("text", `${baseLevel.subtitleGroups[i]}_clone_${cloneId}`);
|
|
|
- }
|
|
|
- }
|
|
|
- return clonedLevel;
|
|
|
- });
|
|
|
- levels.push(...clonedVariants);
|
|
|
- cloneRenditionGroups(this.audioTracks, audioGroupCloneMap, uriReplacement, cloneId);
|
|
|
- cloneRenditionGroups(this.subtitleTracks, subtitleGroupCloneMap, uriReplacement, cloneId);
|
|
|
- });
|
|
|
- }
|
|
|
- loadSteeringManifest(uri) {
|
|
|
- const config = this.hls.config;
|
|
|
- const Loader = config.loader;
|
|
|
- if (this.loader) {
|
|
|
- this.loader.destroy();
|
|
|
- }
|
|
|
- this.loader = new Loader(config);
|
|
|
- let url;
|
|
|
- try {
|
|
|
- url = new self.URL(uri);
|
|
|
- } catch (error) {
|
|
|
- this.enabled = false;
|
|
|
- this.log(`Failed to parse Steering Manifest URI: ${uri}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (url.protocol !== "data:") {
|
|
|
- const throughput = (this.hls.bandwidthEstimate || config.abrEwmaDefaultEstimate) | 0;
|
|
|
- url.searchParams.set("_HLS_pathway", this.pathwayId);
|
|
|
- url.searchParams.set("_HLS_throughput", "" + throughput);
|
|
|
- }
|
|
|
- const context = {
|
|
|
- responseType: "json",
|
|
|
- url: url.href
|
|
|
- };
|
|
|
- const loadPolicy = config.steeringManifestLoadPolicy.default;
|
|
|
- const legacyRetryCompatibility = loadPolicy.errorRetry || loadPolicy.timeoutRetry || {};
|
|
|
- const loaderConfig = {
|
|
|
- loadPolicy,
|
|
|
- timeout: loadPolicy.maxLoadTimeMs,
|
|
|
- maxRetry: legacyRetryCompatibility.maxNumRetry || 0,
|
|
|
- retryDelay: legacyRetryCompatibility.retryDelayMs || 0,
|
|
|
- maxRetryDelay: legacyRetryCompatibility.maxRetryDelayMs || 0
|
|
|
- };
|
|
|
- const callbacks = {
|
|
|
- onSuccess: (response, stats, context2, networkDetails) => {
|
|
|
- this.log(`Loaded steering manifest: "${url}"`);
|
|
|
- const steeringData = response.data;
|
|
|
- if ((steeringData == null ? void 0 : steeringData.VERSION) !== 1) {
|
|
|
- this.log(`Steering VERSION ${steeringData.VERSION} not supported!`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.updated = performance.now();
|
|
|
- this.timeToLoad = steeringData.TTL;
|
|
|
- const {
|
|
|
- "RELOAD-URI": reloadUri,
|
|
|
- "PATHWAY-CLONES": pathwayClones,
|
|
|
- "PATHWAY-PRIORITY": pathwayPriority
|
|
|
- } = steeringData;
|
|
|
- if (reloadUri) {
|
|
|
- try {
|
|
|
- this.uri = new self.URL(reloadUri, url).href;
|
|
|
- } catch (error) {
|
|
|
- this.enabled = false;
|
|
|
- this.log(`Failed to parse Steering Manifest RELOAD-URI: ${reloadUri}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.scheduleRefresh(this.uri || context2.url);
|
|
|
- if (pathwayClones) {
|
|
|
- this.clonePathways(pathwayClones);
|
|
|
- }
|
|
|
- const loadedSteeringData = {
|
|
|
- steeringManifest: steeringData,
|
|
|
- url: url.toString()
|
|
|
- };
|
|
|
- this.hls.trigger(Events.STEERING_MANIFEST_LOADED, loadedSteeringData);
|
|
|
- if (pathwayPriority) {
|
|
|
- this.updatePathwayPriority(pathwayPriority);
|
|
|
- }
|
|
|
- },
|
|
|
- onError: (error, context2, networkDetails, stats) => {
|
|
|
- this.log(`Error loading steering manifest: ${error.code} ${error.text} (${context2.url})`);
|
|
|
- this.stopLoad();
|
|
|
- if (error.code === 410) {
|
|
|
- this.enabled = false;
|
|
|
- this.log(`Steering manifest ${context2.url} no longer available`);
|
|
|
- return;
|
|
|
- }
|
|
|
- let ttl = this.timeToLoad * 1e3;
|
|
|
- if (error.code === 429) {
|
|
|
- const loader = this.loader;
|
|
|
- if (typeof (loader == null ? void 0 : loader.getResponseHeader) === "function") {
|
|
|
- const retryAfter = loader.getResponseHeader("Retry-After");
|
|
|
- if (retryAfter) {
|
|
|
- ttl = parseFloat(retryAfter) * 1e3;
|
|
|
- }
|
|
|
- }
|
|
|
- this.log(`Steering manifest ${context2.url} rate limited`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.scheduleRefresh(this.uri || context2.url, ttl);
|
|
|
- },
|
|
|
- onTimeout: (stats, context2, networkDetails) => {
|
|
|
- this.log(`Timeout loading steering manifest (${context2.url})`);
|
|
|
- this.scheduleRefresh(this.uri || context2.url);
|
|
|
- }
|
|
|
- };
|
|
|
- this.log(`Requesting steering manifest: ${url}`);
|
|
|
- this.loader.load(context, loaderConfig, callbacks);
|
|
|
- }
|
|
|
- scheduleRefresh(uri, ttlMs = this.timeToLoad * 1e3) {
|
|
|
- this.clearTimeout();
|
|
|
- this.reloadTimer = self.setTimeout(() => {
|
|
|
- var _this$hls;
|
|
|
- const media = (_this$hls = this.hls) == null ? void 0 : _this$hls.media;
|
|
|
- if (media && !media.ended) {
|
|
|
- this.loadSteeringManifest(uri);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.scheduleRefresh(uri, this.timeToLoad * 1e3);
|
|
|
- }, ttlMs);
|
|
|
- }
|
|
|
-};
|
|
|
-function cloneRenditionGroups(tracks, groupCloneMap, uriReplacement, cloneId) {
|
|
|
- if (!tracks) {
|
|
|
- return;
|
|
|
- }
|
|
|
- Object.keys(groupCloneMap).forEach((audioGroupId) => {
|
|
|
- const clonedTracks = tracks.filter((track) => track.groupId === audioGroupId).map((track) => {
|
|
|
- const clonedTrack = _extends({}, track);
|
|
|
- clonedTrack.details = void 0;
|
|
|
- clonedTrack.attrs = new AttrList(clonedTrack.attrs);
|
|
|
- clonedTrack.url = clonedTrack.attrs.URI = performUriReplacement(track.url, track.attrs["STABLE-RENDITION-ID"], "PER-RENDITION-URIS", uriReplacement);
|
|
|
- clonedTrack.groupId = clonedTrack.attrs["GROUP-ID"] = groupCloneMap[audioGroupId];
|
|
|
- clonedTrack.attrs["PATHWAY-ID"] = cloneId;
|
|
|
- return clonedTrack;
|
|
|
- });
|
|
|
- tracks.push(...clonedTracks);
|
|
|
- });
|
|
|
-}
|
|
|
-function performUriReplacement(uri, stableId, perOptionKey, uriReplacement) {
|
|
|
- const {
|
|
|
- HOST: host,
|
|
|
- PARAMS: params,
|
|
|
- [perOptionKey]: perOptionUris
|
|
|
- } = uriReplacement;
|
|
|
- let perVariantUri;
|
|
|
- if (stableId) {
|
|
|
- perVariantUri = perOptionUris == null ? void 0 : perOptionUris[stableId];
|
|
|
- if (perVariantUri) {
|
|
|
- uri = perVariantUri;
|
|
|
- }
|
|
|
- }
|
|
|
- const url = new self.URL(uri);
|
|
|
- if (host && !perVariantUri) {
|
|
|
- url.host = host;
|
|
|
- }
|
|
|
- if (params) {
|
|
|
- Object.keys(params).sort().forEach((key) => {
|
|
|
- if (key) {
|
|
|
- url.searchParams.set(key, params[key]);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- return url.href;
|
|
|
-}
|
|
|
-var EMEController = class _EMEController extends Logger {
|
|
|
- constructor(hls) {
|
|
|
- super("eme", hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.config = void 0;
|
|
|
- this.media = null;
|
|
|
- this.keyFormatPromise = null;
|
|
|
- this.keySystemAccessPromises = {};
|
|
|
- this._requestLicenseFailureCount = 0;
|
|
|
- this.mediaKeySessions = [];
|
|
|
- this.keyIdToKeySessionPromise = {};
|
|
|
- this.mediaKeys = null;
|
|
|
- this.setMediaKeysQueue = _EMEController.CDMCleanupPromise ? [_EMEController.CDMCleanupPromise] : [];
|
|
|
- this.bannedKeyIds = {};
|
|
|
- this.onMediaEncrypted = (event) => {
|
|
|
- const {
|
|
|
- initDataType,
|
|
|
- initData
|
|
|
- } = event;
|
|
|
- const logMessage = `"${event.type}" event: init data type: "${initDataType}"`;
|
|
|
- this.debug(logMessage);
|
|
|
- if (initData === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!this.keyFormatPromise) {
|
|
|
- let keySystems = Object.keys(this.keySystemAccessPromises);
|
|
|
- if (!keySystems.length) {
|
|
|
- keySystems = getKeySystemsForConfig(this.config);
|
|
|
- }
|
|
|
- const keyFormats = keySystems.map(keySystemDomainToKeySystemFormat).filter((k) => !!k);
|
|
|
- this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
|
|
|
- }
|
|
|
- this.keyFormatPromise.then((keySystemFormat) => {
|
|
|
- const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
|
|
|
- if (initDataType !== "sinf" || keySystem !== KeySystems.FAIRPLAY) {
|
|
|
- this.log(`Ignoring "${event.type}" event with init data type: "${initDataType}" for selected key-system ${keySystem}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- let keyId;
|
|
|
- try {
|
|
|
- const json = bin2str(new Uint8Array(initData));
|
|
|
- const sinf = base64Decode(JSON.parse(json).sinf);
|
|
|
- const tenc = parseSinf(sinf);
|
|
|
- if (!tenc) {
|
|
|
- throw new Error(`'schm' box missing or not cbcs/cenc with schi > tenc`);
|
|
|
- }
|
|
|
- keyId = new Uint8Array(tenc.subarray(8, 24));
|
|
|
- } catch (error) {
|
|
|
- this.warn(`${logMessage} Failed to parse sinf: ${error}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const keyIdHex = arrayToHex(keyId);
|
|
|
- const {
|
|
|
- keyIdToKeySessionPromise,
|
|
|
- mediaKeySessions
|
|
|
- } = this;
|
|
|
- let keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex];
|
|
|
- for (let i = 0; i < mediaKeySessions.length; i++) {
|
|
|
- const keyContext = mediaKeySessions[i];
|
|
|
- const decryptdata = keyContext.decryptdata;
|
|
|
- if (!decryptdata.keyId) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- const oldKeyIdHex = arrayToHex(decryptdata.keyId);
|
|
|
- if (arrayValuesMatch(keyId, decryptdata.keyId) || decryptdata.uri.replace(/-/g, "").indexOf(keyIdHex) !== -1) {
|
|
|
- keySessionContextPromise = keyIdToKeySessionPromise[oldKeyIdHex];
|
|
|
- if (!keySessionContextPromise) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (decryptdata.pssh) {
|
|
|
- break;
|
|
|
- }
|
|
|
- delete keyIdToKeySessionPromise[oldKeyIdHex];
|
|
|
- decryptdata.pssh = new Uint8Array(initData);
|
|
|
- decryptdata.keyId = keyId;
|
|
|
- keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = keySessionContextPromise.then(() => {
|
|
|
- return this.generateRequestWithPreferredKeySession(keyContext, initDataType, initData, "encrypted-event-key-match");
|
|
|
- });
|
|
|
- keySessionContextPromise.catch((error) => this.handleError(error));
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!keySessionContextPromise) {
|
|
|
- this.handleError(new Error(`Key ID ${keyIdHex} not encountered in playlist. Key-system sessions ${mediaKeySessions.length}.`));
|
|
|
- }
|
|
|
- }).catch((error) => this.handleError(error));
|
|
|
- };
|
|
|
- this.onWaitingForKey = (event) => {
|
|
|
- this.log(`"${event.type}" event`);
|
|
|
- };
|
|
|
- this.hls = hls;
|
|
|
- this.config = hls.config;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.onDestroying();
|
|
|
- this.onMediaDetached();
|
|
|
- const config = this.config;
|
|
|
- config.requestMediaKeySystemAccessFunc = null;
|
|
|
- config.licenseXhrSetup = config.licenseResponseCallback = void 0;
|
|
|
- config.drmSystems = config.drmSystemOptions = {};
|
|
|
- this.hls = this.config = this.keyIdToKeySessionPromise = null;
|
|
|
- this.onMediaEncrypted = this.onWaitingForKey = null;
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- this.hls.on(Events.MEDIA_DETACHED, this.onMediaDetached, this);
|
|
|
- this.hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- this.hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- this.hls.on(Events.DESTROYING, this.onDestroying, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- this.hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- this.hls.off(Events.MEDIA_DETACHED, this.onMediaDetached, this);
|
|
|
- this.hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- this.hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- this.hls.off(Events.DESTROYING, this.onDestroying, this);
|
|
|
- }
|
|
|
- getLicenseServerUrl(keySystem) {
|
|
|
- const {
|
|
|
- drmSystems,
|
|
|
- widevineLicenseUrl
|
|
|
- } = this.config;
|
|
|
- const keySystemConfiguration = drmSystems == null ? void 0 : drmSystems[keySystem];
|
|
|
- if (keySystemConfiguration) {
|
|
|
- return keySystemConfiguration.licenseUrl;
|
|
|
- }
|
|
|
- if (keySystem === KeySystems.WIDEVINE && widevineLicenseUrl) {
|
|
|
- return widevineLicenseUrl;
|
|
|
- }
|
|
|
- }
|
|
|
- getLicenseServerUrlOrThrow(keySystem) {
|
|
|
- const url = this.getLicenseServerUrl(keySystem);
|
|
|
- if (url === void 0) {
|
|
|
- throw new Error(`no license server URL configured for key-system "${keySystem}"`);
|
|
|
- }
|
|
|
- return url;
|
|
|
- }
|
|
|
- getServerCertificateUrl(keySystem) {
|
|
|
- const {
|
|
|
- drmSystems
|
|
|
- } = this.config;
|
|
|
- const keySystemConfiguration = drmSystems == null ? void 0 : drmSystems[keySystem];
|
|
|
- if (keySystemConfiguration) {
|
|
|
- return keySystemConfiguration.serverCertificateUrl;
|
|
|
- } else {
|
|
|
- this.log(`No Server Certificate in config.drmSystems["${keySystem}"]`);
|
|
|
- }
|
|
|
- }
|
|
|
- attemptKeySystemAccess(keySystemsToAttempt) {
|
|
|
- const levels = this.hls.levels;
|
|
|
- const uniqueCodec = (value, i, a) => !!value && a.indexOf(value) === i;
|
|
|
- const audioCodecs = levels.map((level) => level.audioCodec).filter(uniqueCodec);
|
|
|
- const videoCodecs = levels.map((level) => level.videoCodec).filter(uniqueCodec);
|
|
|
- if (audioCodecs.length + videoCodecs.length === 0) {
|
|
|
- videoCodecs.push("avc1.42e01e");
|
|
|
- }
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- const attempt = (keySystems) => {
|
|
|
- const keySystem = keySystems.shift();
|
|
|
- this.getMediaKeysPromise(keySystem, audioCodecs, videoCodecs).then((mediaKeys) => resolve({
|
|
|
- keySystem,
|
|
|
- mediaKeys
|
|
|
- })).catch((error) => {
|
|
|
- if (keySystems.length) {
|
|
|
- attempt(keySystems);
|
|
|
- } else if (error instanceof EMEKeyError) {
|
|
|
- reject(error);
|
|
|
- } else {
|
|
|
- reject(new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_NO_ACCESS,
|
|
|
- error,
|
|
|
- fatal: true
|
|
|
- }, error.message));
|
|
|
- }
|
|
|
- });
|
|
|
- };
|
|
|
- attempt(keySystemsToAttempt);
|
|
|
- });
|
|
|
- }
|
|
|
- requestMediaKeySystemAccess(keySystem, supportedConfigurations) {
|
|
|
- const {
|
|
|
- requestMediaKeySystemAccessFunc
|
|
|
- } = this.config;
|
|
|
- if (!(typeof requestMediaKeySystemAccessFunc === "function")) {
|
|
|
- let errMessage = `Configured requestMediaKeySystemAccess is not a function ${requestMediaKeySystemAccessFunc}`;
|
|
|
- if (requestMediaKeySystemAccess === null && self.location.protocol === "http:") {
|
|
|
- errMessage = `navigator.requestMediaKeySystemAccess is not available over insecure protocol ${location.protocol}`;
|
|
|
- }
|
|
|
- return Promise.reject(new Error(errMessage));
|
|
|
- }
|
|
|
- return requestMediaKeySystemAccessFunc(keySystem, supportedConfigurations);
|
|
|
- }
|
|
|
- getMediaKeysPromise(keySystem, audioCodecs, videoCodecs) {
|
|
|
- var _keySystemAccessPromi;
|
|
|
- const mediaKeySystemConfigs = getSupportedMediaKeySystemConfigurations(keySystem, audioCodecs, videoCodecs, this.config.drmSystemOptions || {});
|
|
|
- let keySystemAccessPromises = this.keySystemAccessPromises[keySystem];
|
|
|
- let keySystemAccess = (_keySystemAccessPromi = keySystemAccessPromises) == null ? void 0 : _keySystemAccessPromi.keySystemAccess;
|
|
|
- if (!keySystemAccess) {
|
|
|
- this.log(`Requesting encrypted media "${keySystem}" key-system access with config: ${stringify(mediaKeySystemConfigs)}`);
|
|
|
- keySystemAccess = this.requestMediaKeySystemAccess(keySystem, mediaKeySystemConfigs);
|
|
|
- const keySystemAccessPromisesNew = keySystemAccessPromises = this.keySystemAccessPromises[keySystem] = {
|
|
|
- keySystemAccess
|
|
|
- };
|
|
|
- keySystemAccess.catch((error) => {
|
|
|
- this.log(`Failed to obtain access to key-system "${keySystem}": ${error}`);
|
|
|
- });
|
|
|
- return keySystemAccess.then((mediaKeySystemAccess) => {
|
|
|
- this.log(`Access for key-system "${mediaKeySystemAccess.keySystem}" obtained`);
|
|
|
- const certificateRequest = this.fetchServerCertificate(keySystem);
|
|
|
- this.log(`Create media-keys for "${keySystem}"`);
|
|
|
- const mediaKeys = keySystemAccessPromisesNew.mediaKeys = mediaKeySystemAccess.createMediaKeys().then((mediaKeys2) => {
|
|
|
- this.log(`Media-keys created for "${keySystem}"`);
|
|
|
- keySystemAccessPromisesNew.hasMediaKeys = true;
|
|
|
- return certificateRequest.then((certificate) => {
|
|
|
- if (certificate) {
|
|
|
- return this.setMediaKeysServerCertificate(mediaKeys2, keySystem, certificate);
|
|
|
- }
|
|
|
- return mediaKeys2;
|
|
|
- });
|
|
|
- });
|
|
|
- mediaKeys.catch((error) => {
|
|
|
- this.error(`Failed to create media-keys for "${keySystem}"}: ${error}`);
|
|
|
- });
|
|
|
- return mediaKeys;
|
|
|
- });
|
|
|
- }
|
|
|
- return keySystemAccess.then(() => keySystemAccessPromises.mediaKeys);
|
|
|
- }
|
|
|
- createMediaKeySessionContext({
|
|
|
- decryptdata,
|
|
|
- keySystem,
|
|
|
- mediaKeys
|
|
|
- }) {
|
|
|
- this.log(`Creating key-system session "${keySystem}" keyId: ${arrayToHex(decryptdata.keyId || [])} keyUri: ${decryptdata.uri}`);
|
|
|
- const mediaKeysSession = mediaKeys.createSession();
|
|
|
- const mediaKeySessionContext = {
|
|
|
- decryptdata,
|
|
|
- keySystem,
|
|
|
- mediaKeys,
|
|
|
- mediaKeysSession,
|
|
|
- keyStatus: "status-pending"
|
|
|
- };
|
|
|
- this.mediaKeySessions.push(mediaKeySessionContext);
|
|
|
- return mediaKeySessionContext;
|
|
|
- }
|
|
|
- renewKeySession(mediaKeySessionContext) {
|
|
|
- const decryptdata = mediaKeySessionContext.decryptdata;
|
|
|
- if (decryptdata.pssh) {
|
|
|
- const keySessionContext = this.createMediaKeySessionContext(mediaKeySessionContext);
|
|
|
- const keyId = getKeyIdString(decryptdata);
|
|
|
- const scheme = "cenc";
|
|
|
- this.keyIdToKeySessionPromise[keyId] = this.generateRequestWithPreferredKeySession(keySessionContext, scheme, decryptdata.pssh.buffer, "expired");
|
|
|
- } else {
|
|
|
- this.warn(`Could not renew expired session. Missing pssh initData.`);
|
|
|
- }
|
|
|
- this.removeSession(mediaKeySessionContext);
|
|
|
- }
|
|
|
- updateKeySession(mediaKeySessionContext, data) {
|
|
|
- const keySession = mediaKeySessionContext.mediaKeysSession;
|
|
|
- this.log(`Updating key-session "${keySession.sessionId}" for keyId ${arrayToHex(mediaKeySessionContext.decryptdata.keyId || [])}
|
|
|
- } (data length: ${data.byteLength})`);
|
|
|
- return keySession.update(data);
|
|
|
- }
|
|
|
- getSelectedKeySystemFormats() {
|
|
|
- return Object.keys(this.keySystemAccessPromises).map((keySystem) => ({
|
|
|
- keySystem,
|
|
|
- hasMediaKeys: this.keySystemAccessPromises[keySystem].hasMediaKeys
|
|
|
- })).filter(({
|
|
|
- hasMediaKeys
|
|
|
- }) => !!hasMediaKeys).map(({
|
|
|
- keySystem
|
|
|
- }) => keySystemDomainToKeySystemFormat(keySystem)).filter((keySystem) => !!keySystem);
|
|
|
- }
|
|
|
- getKeySystemAccess(keySystemsToAttempt) {
|
|
|
- return this.getKeySystemSelectionPromise(keySystemsToAttempt).then(({
|
|
|
- keySystem,
|
|
|
- mediaKeys
|
|
|
- }) => {
|
|
|
- return this.attemptSetMediaKeys(keySystem, mediaKeys);
|
|
|
- });
|
|
|
- }
|
|
|
- selectKeySystem(keySystemsToAttempt) {
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- this.getKeySystemSelectionPromise(keySystemsToAttempt).then(({
|
|
|
- keySystem
|
|
|
- }) => {
|
|
|
- const keySystemFormat = keySystemDomainToKeySystemFormat(keySystem);
|
|
|
- if (keySystemFormat) {
|
|
|
- resolve(keySystemFormat);
|
|
|
- } else {
|
|
|
- reject(new Error(`Unable to find format for key-system "${keySystem}"`));
|
|
|
- }
|
|
|
- }).catch(reject);
|
|
|
- });
|
|
|
- }
|
|
|
- selectKeySystemFormat(frag) {
|
|
|
- const keyFormats = Object.keys(frag.levelkeys || {});
|
|
|
- if (!this.keyFormatPromise) {
|
|
|
- this.log(`Selecting key-system from fragment (sn: ${frag.sn} ${frag.type}: ${frag.level}) key formats ${keyFormats.join(", ")}`);
|
|
|
- this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
|
|
|
- }
|
|
|
- return this.keyFormatPromise;
|
|
|
- }
|
|
|
- getKeyFormatPromise(keyFormats) {
|
|
|
- const keySystemsInConfig = getKeySystemsForConfig(this.config);
|
|
|
- const keySystemsToAttempt = keyFormats.map(keySystemFormatToKeySystemDomain).filter((value) => !!value && keySystemsInConfig.indexOf(value) !== -1);
|
|
|
- return this.selectKeySystem(keySystemsToAttempt);
|
|
|
- }
|
|
|
- getKeyStatus(decryptdata) {
|
|
|
- const {
|
|
|
- mediaKeySessions
|
|
|
- } = this;
|
|
|
- for (let i = 0; i < mediaKeySessions.length; i++) {
|
|
|
- const status2 = getKeyStatus(decryptdata, mediaKeySessions[i]);
|
|
|
- if (status2) {
|
|
|
- return status2;
|
|
|
- }
|
|
|
- }
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- loadKey(data) {
|
|
|
- const decryptdata = data.keyInfo.decryptdata;
|
|
|
- const keyId = getKeyIdString(decryptdata);
|
|
|
- const badStatus = this.bannedKeyIds[keyId];
|
|
|
- if (badStatus || this.getKeyStatus(decryptdata) === "internal-error") {
|
|
|
- const error = getKeyStatusError(badStatus || "internal-error", decryptdata);
|
|
|
- this.handleError(error, data.frag);
|
|
|
- return Promise.reject(error);
|
|
|
- }
|
|
|
- const keyDetails = `(keyId: ${keyId} format: "${decryptdata.keyFormat}" method: ${decryptdata.method} uri: ${decryptdata.uri})`;
|
|
|
- this.log(`Starting session for key ${keyDetails}`);
|
|
|
- const keyContextPromise = this.keyIdToKeySessionPromise[keyId];
|
|
|
- if (!keyContextPromise) {
|
|
|
- const keySessionContextPromise = this.getKeySystemForKeyPromise(decryptdata).then(({
|
|
|
- keySystem,
|
|
|
- mediaKeys
|
|
|
- }) => {
|
|
|
- this.throwIfDestroyed();
|
|
|
- this.log(`Handle encrypted media sn: ${data.frag.sn} ${data.frag.type}: ${data.frag.level} using key ${keyDetails}`);
|
|
|
- return this.attemptSetMediaKeys(keySystem, mediaKeys).then(() => {
|
|
|
- this.throwIfDestroyed();
|
|
|
- return this.createMediaKeySessionContext({
|
|
|
- keySystem,
|
|
|
- mediaKeys,
|
|
|
- decryptdata
|
|
|
- });
|
|
|
- });
|
|
|
- }).then((keySessionContext) => {
|
|
|
- const scheme = "cenc";
|
|
|
- const initData = decryptdata.pssh ? decryptdata.pssh.buffer : null;
|
|
|
- return this.generateRequestWithPreferredKeySession(keySessionContext, scheme, initData, "playlist-key");
|
|
|
- });
|
|
|
- keySessionContextPromise.catch((error) => this.handleError(error, data.frag));
|
|
|
- this.keyIdToKeySessionPromise[keyId] = keySessionContextPromise;
|
|
|
- return keySessionContextPromise;
|
|
|
- }
|
|
|
- keyContextPromise.catch((error) => {
|
|
|
- if (error instanceof EMEKeyError) {
|
|
|
- const errorData = _objectSpread2({}, error.data);
|
|
|
- if (this.getKeyStatus(decryptdata) === "internal-error") {
|
|
|
- errorData.decryptdata = decryptdata;
|
|
|
- }
|
|
|
- const clonedError = new EMEKeyError(errorData, error.message);
|
|
|
- this.handleError(clonedError, data.frag);
|
|
|
- }
|
|
|
- });
|
|
|
- return keyContextPromise;
|
|
|
- }
|
|
|
- throwIfDestroyed(message = "Invalid state") {
|
|
|
- if (!this.hls) {
|
|
|
- throw new Error("invalid state");
|
|
|
- }
|
|
|
- }
|
|
|
- handleError(error, frag) {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (error instanceof EMEKeyError) {
|
|
|
- if (frag) {
|
|
|
- error.data.frag = frag;
|
|
|
- }
|
|
|
- const levelKey = error.data.decryptdata;
|
|
|
- this.error(`${error.message}${levelKey ? ` (${arrayToHex(levelKey.keyId || [])})` : ""}`);
|
|
|
- this.hls.trigger(Events.ERROR, error.data);
|
|
|
- } else {
|
|
|
- this.error(error.message);
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_NO_KEYS,
|
|
|
- error,
|
|
|
- fatal: true
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- getKeySystemForKeyPromise(decryptdata) {
|
|
|
- const keyId = getKeyIdString(decryptdata);
|
|
|
- const mediaKeySessionContext = this.keyIdToKeySessionPromise[keyId];
|
|
|
- if (!mediaKeySessionContext) {
|
|
|
- const keySystem = keySystemFormatToKeySystemDomain(decryptdata.keyFormat);
|
|
|
- const keySystemsToAttempt = keySystem ? [keySystem] : getKeySystemsForConfig(this.config);
|
|
|
- return this.attemptKeySystemAccess(keySystemsToAttempt);
|
|
|
- }
|
|
|
- return mediaKeySessionContext;
|
|
|
- }
|
|
|
- getKeySystemSelectionPromise(keySystemsToAttempt) {
|
|
|
- if (!keySystemsToAttempt.length) {
|
|
|
- keySystemsToAttempt = getKeySystemsForConfig(this.config);
|
|
|
- }
|
|
|
- if (keySystemsToAttempt.length === 0) {
|
|
|
- throw new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_NO_CONFIGURED_LICENSE,
|
|
|
- fatal: true
|
|
|
- }, `Missing key-system license configuration options ${stringify({
|
|
|
- drmSystems: this.config.drmSystems
|
|
|
- })}`);
|
|
|
- }
|
|
|
- return this.attemptKeySystemAccess(keySystemsToAttempt);
|
|
|
- }
|
|
|
- attemptSetMediaKeys(keySystem, mediaKeys) {
|
|
|
- if (this.mediaKeys === mediaKeys) {
|
|
|
- return Promise.resolve();
|
|
|
- }
|
|
|
- const queue = this.setMediaKeysQueue.slice();
|
|
|
- this.log(`Setting media-keys for "${keySystem}"`);
|
|
|
- const setMediaKeysPromise = Promise.all(queue).then(() => {
|
|
|
- if (!this.media) {
|
|
|
- this.mediaKeys = null;
|
|
|
- throw new Error("Attempted to set mediaKeys without media element attached");
|
|
|
- }
|
|
|
- return this.media.setMediaKeys(mediaKeys);
|
|
|
- });
|
|
|
- this.mediaKeys = mediaKeys;
|
|
|
- this.setMediaKeysQueue.push(setMediaKeysPromise);
|
|
|
- return setMediaKeysPromise.then(() => {
|
|
|
- this.log(`Media-keys set for "${keySystem}"`);
|
|
|
- queue.push(setMediaKeysPromise);
|
|
|
- this.setMediaKeysQueue = this.setMediaKeysQueue.filter((p) => queue.indexOf(p) === -1);
|
|
|
- });
|
|
|
- }
|
|
|
- generateRequestWithPreferredKeySession(context, initDataType, initData, reason) {
|
|
|
- var _this$config$drmSyste;
|
|
|
- const generateRequestFilter = (_this$config$drmSyste = this.config.drmSystems) == null || (_this$config$drmSyste = _this$config$drmSyste[context.keySystem]) == null ? void 0 : _this$config$drmSyste.generateRequest;
|
|
|
- if (generateRequestFilter) {
|
|
|
- try {
|
|
|
- const mappedInitData = generateRequestFilter.call(this.hls, initDataType, initData, context);
|
|
|
- if (!mappedInitData) {
|
|
|
- throw new Error("Invalid response from configured generateRequest filter");
|
|
|
- }
|
|
|
- initDataType = mappedInitData.initDataType;
|
|
|
- initData = mappedInitData.initData ? mappedInitData.initData : null;
|
|
|
- context.decryptdata.pssh = initData ? new Uint8Array(initData) : null;
|
|
|
- } catch (error) {
|
|
|
- this.warn(error.message);
|
|
|
- if (this.hls && this.hls.config.debug) {
|
|
|
- throw error;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (initData === null) {
|
|
|
- this.log(`Skipping key-session request for "${reason}" (no initData)`);
|
|
|
- return Promise.resolve(context);
|
|
|
- }
|
|
|
- const keyId = getKeyIdString(context.decryptdata);
|
|
|
- const keyUri = context.decryptdata.uri;
|
|
|
- this.log(`Generating key-session request for "${reason}" keyId: ${keyId} URI: ${keyUri} (init data type: ${initDataType} length: ${initData.byteLength})`);
|
|
|
- const licenseStatus = new EventEmitter();
|
|
|
- const onmessage = context._onmessage = (event) => {
|
|
|
- const keySession = context.mediaKeysSession;
|
|
|
- if (!keySession) {
|
|
|
- licenseStatus.emit("error", new Error("invalid state"));
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- messageType,
|
|
|
- message
|
|
|
- } = event;
|
|
|
- this.log(`"${messageType}" message event for session "${keySession.sessionId}" message size: ${message.byteLength}`);
|
|
|
- if (messageType === "license-request" || messageType === "license-renewal") {
|
|
|
- this.renewLicense(context, message).catch((error) => {
|
|
|
- if (licenseStatus.eventNames().length) {
|
|
|
- licenseStatus.emit("error", error);
|
|
|
- } else {
|
|
|
- this.handleError(error);
|
|
|
- }
|
|
|
- });
|
|
|
- } else if (messageType === "license-release") {
|
|
|
- if (context.keySystem === KeySystems.FAIRPLAY) {
|
|
|
- this.updateKeySession(context, strToUtf8array("acknowledged")).then(() => this.removeSession(context)).catch((error) => this.handleError(error));
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.warn(`unhandled media key message type "${messageType}"`);
|
|
|
- }
|
|
|
- };
|
|
|
- const handleKeyStatus = (keyStatus, context2) => {
|
|
|
- context2.keyStatus = keyStatus;
|
|
|
- let keyError;
|
|
|
- if (keyStatus.startsWith("usable")) {
|
|
|
- licenseStatus.emit("resolved");
|
|
|
- } else if (keyStatus === "internal-error" || keyStatus === "output-restricted" || keyStatus === "output-downscaled") {
|
|
|
- keyError = getKeyStatusError(keyStatus, context2.decryptdata);
|
|
|
- } else if (keyStatus === "expired") {
|
|
|
- keyError = new Error(`key expired (keyId: ${keyId})`);
|
|
|
- } else if (keyStatus === "released") {
|
|
|
- keyError = new Error(`key released`);
|
|
|
- } else if (keyStatus === "status-pending")
|
|
|
- ;
|
|
|
- else {
|
|
|
- this.warn(`unhandled key status change "${keyStatus}" (keyId: ${keyId})`);
|
|
|
- }
|
|
|
- if (keyError) {
|
|
|
- if (licenseStatus.eventNames().length) {
|
|
|
- licenseStatus.emit("error", keyError);
|
|
|
- } else {
|
|
|
- this.handleError(keyError);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- const onkeystatuseschange = context._onkeystatuseschange = (event) => {
|
|
|
- const keySession = context.mediaKeysSession;
|
|
|
- if (!keySession) {
|
|
|
- licenseStatus.emit("error", new Error("invalid state"));
|
|
|
- return;
|
|
|
- }
|
|
|
- const keyStatuses = this.getKeyStatuses(context);
|
|
|
- const keyIds = Object.keys(keyStatuses);
|
|
|
- if (!keyIds.some((id) => keyStatuses[id] !== "status-pending")) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (keyStatuses[keyId] === "expired") {
|
|
|
- this.log(`Expired key ${stringify(keyStatuses)} in key-session "${context.mediaKeysSession.sessionId}"`);
|
|
|
- this.renewKeySession(context);
|
|
|
- return;
|
|
|
- }
|
|
|
- let keyStatus = keyStatuses[keyId];
|
|
|
- if (keyStatus) {
|
|
|
- handleKeyStatus(keyStatus, context);
|
|
|
- } else {
|
|
|
- var _context$keyStatusTim;
|
|
|
- const timeout = 1e3;
|
|
|
- context.keyStatusTimeouts || (context.keyStatusTimeouts = {});
|
|
|
- (_context$keyStatusTim = context.keyStatusTimeouts)[keyId] || (_context$keyStatusTim[keyId] = self.setTimeout(() => {
|
|
|
- if (!context.mediaKeysSession || !this.mediaKeys) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const sessionKeyStatus = this.getKeyStatus(context.decryptdata);
|
|
|
- if (sessionKeyStatus && sessionKeyStatus !== "status-pending") {
|
|
|
- this.log(`No status for keyId ${keyId} in key-session "${context.mediaKeysSession.sessionId}". Using session key-status ${sessionKeyStatus} from other session.`);
|
|
|
- return handleKeyStatus(sessionKeyStatus, context);
|
|
|
- }
|
|
|
- this.log(`key status for ${keyId} in key-session "${context.mediaKeysSession.sessionId}" timed out after ${timeout}ms`);
|
|
|
- keyStatus = "internal-error";
|
|
|
- handleKeyStatus(keyStatus, context);
|
|
|
- }, timeout));
|
|
|
- this.log(`No status for keyId ${keyId} (${stringify(keyStatuses)}).`);
|
|
|
- }
|
|
|
- };
|
|
|
- addEventListener(context.mediaKeysSession, "message", onmessage);
|
|
|
- addEventListener(context.mediaKeysSession, "keystatuseschange", onkeystatuseschange);
|
|
|
- const keyUsablePromise = new Promise((resolve, reject) => {
|
|
|
- licenseStatus.on("error", reject);
|
|
|
- licenseStatus.on("resolved", resolve);
|
|
|
- });
|
|
|
- return context.mediaKeysSession.generateRequest(initDataType, initData).then(() => {
|
|
|
- this.log(`Request generated for key-session "${context.mediaKeysSession.sessionId}" keyId: ${keyId} URI: ${keyUri}`);
|
|
|
- }).catch((error) => {
|
|
|
- throw new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_NO_SESSION,
|
|
|
- error,
|
|
|
- decryptdata: context.decryptdata,
|
|
|
- fatal: false
|
|
|
- }, `Error generating key-session request: ${error}`);
|
|
|
- }).then(() => keyUsablePromise).catch((error) => {
|
|
|
- licenseStatus.removeAllListeners();
|
|
|
- return this.removeSession(context).then(() => {
|
|
|
- throw error;
|
|
|
- });
|
|
|
- }).then(() => {
|
|
|
- licenseStatus.removeAllListeners();
|
|
|
- return context;
|
|
|
- });
|
|
|
- }
|
|
|
- getKeyStatuses(mediaKeySessionContext) {
|
|
|
- const keyStatuses = {};
|
|
|
- mediaKeySessionContext.mediaKeysSession.keyStatuses.forEach((status2, keyId) => {
|
|
|
- if (typeof keyId === "string" && typeof status2 === "object") {
|
|
|
- const temp = keyId;
|
|
|
- keyId = status2;
|
|
|
- status2 = temp;
|
|
|
- }
|
|
|
- const keyIdArray = "buffer" in keyId ? new Uint8Array(keyId.buffer, keyId.byteOffset, keyId.byteLength) : new Uint8Array(keyId);
|
|
|
- if (mediaKeySessionContext.keySystem === KeySystems.PLAYREADY && keyIdArray.length === 16) {
|
|
|
- changeEndianness(keyIdArray);
|
|
|
- }
|
|
|
- const keyIdWithStatusChange = arrayToHex(keyIdArray);
|
|
|
- if (status2 === "internal-error") {
|
|
|
- this.bannedKeyIds[keyIdWithStatusChange] = status2;
|
|
|
- }
|
|
|
- this.log(`key status change "${status2}" for keyStatuses keyId: ${keyIdWithStatusChange} key-session "${mediaKeySessionContext.mediaKeysSession.sessionId}"`);
|
|
|
- keyStatuses[keyIdWithStatusChange] = status2;
|
|
|
- });
|
|
|
- return keyStatuses;
|
|
|
- }
|
|
|
- fetchServerCertificate(keySystem) {
|
|
|
- const config = this.config;
|
|
|
- const Loader = config.loader;
|
|
|
- const certLoader = new Loader(config);
|
|
|
- const url = this.getServerCertificateUrl(keySystem);
|
|
|
- if (!url) {
|
|
|
- return Promise.resolve();
|
|
|
- }
|
|
|
- this.log(`Fetching server certificate for "${keySystem}"`);
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- const loaderContext = {
|
|
|
- responseType: "arraybuffer",
|
|
|
- url
|
|
|
- };
|
|
|
- const loadPolicy = config.certLoadPolicy.default;
|
|
|
- const loaderConfig = {
|
|
|
- loadPolicy,
|
|
|
- timeout: loadPolicy.maxLoadTimeMs,
|
|
|
- maxRetry: 0,
|
|
|
- retryDelay: 0,
|
|
|
- maxRetryDelay: 0
|
|
|
- };
|
|
|
- const loaderCallbacks = {
|
|
|
- onSuccess: (response, stats, context, networkDetails) => {
|
|
|
- resolve(response.data);
|
|
|
- },
|
|
|
- onError: (response, contex, networkDetails, stats) => {
|
|
|
- reject(new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED,
|
|
|
- fatal: true,
|
|
|
- networkDetails,
|
|
|
- response: _objectSpread2({
|
|
|
- url: loaderContext.url,
|
|
|
- data: void 0
|
|
|
- }, response)
|
|
|
- }, `"${keySystem}" certificate request failed (${url}). Status: ${response.code} (${response.text})`));
|
|
|
- },
|
|
|
- onTimeout: (stats, context, networkDetails) => {
|
|
|
- reject(new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED,
|
|
|
- fatal: true,
|
|
|
- networkDetails,
|
|
|
- response: {
|
|
|
- url: loaderContext.url,
|
|
|
- data: void 0
|
|
|
- }
|
|
|
- }, `"${keySystem}" certificate request timed out (${url})`));
|
|
|
- },
|
|
|
- onAbort: (stats, context, networkDetails) => {
|
|
|
- reject(new Error("aborted"));
|
|
|
- }
|
|
|
- };
|
|
|
- certLoader.load(loaderContext, loaderConfig, loaderCallbacks);
|
|
|
- });
|
|
|
- }
|
|
|
- setMediaKeysServerCertificate(mediaKeys, keySystem, cert) {
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- mediaKeys.setServerCertificate(cert).then((success) => {
|
|
|
- this.log(`setServerCertificate ${success ? "success" : "not supported by CDM"} (${cert.byteLength}) on "${keySystem}"`);
|
|
|
- resolve(mediaKeys);
|
|
|
- }).catch((error) => {
|
|
|
- reject(new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED,
|
|
|
- error,
|
|
|
- fatal: true
|
|
|
- }, error.message));
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- renewLicense(context, keyMessage) {
|
|
|
- return this.requestLicense(context, new Uint8Array(keyMessage)).then((data) => {
|
|
|
- return this.updateKeySession(context, new Uint8Array(data)).catch((error) => {
|
|
|
- throw new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_SESSION_UPDATE_FAILED,
|
|
|
- decryptdata: context.decryptdata,
|
|
|
- error,
|
|
|
- fatal: false
|
|
|
- }, error.message);
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- unpackPlayReadyKeyMessage(xhr, licenseChallenge) {
|
|
|
- const xmlString = String.fromCharCode.apply(null, new Uint16Array(licenseChallenge.buffer));
|
|
|
- if (!xmlString.includes("PlayReadyKeyMessage")) {
|
|
|
- xhr.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
|
|
|
- return licenseChallenge;
|
|
|
- }
|
|
|
- const keyMessageXml = new DOMParser().parseFromString(xmlString, "application/xml");
|
|
|
- const headers = keyMessageXml.querySelectorAll("HttpHeader");
|
|
|
- if (headers.length > 0) {
|
|
|
- let header;
|
|
|
- for (let i = 0, len = headers.length; i < len; i++) {
|
|
|
- var _header$querySelector, _header$querySelector2;
|
|
|
- header = headers[i];
|
|
|
- const name = (_header$querySelector = header.querySelector("name")) == null ? void 0 : _header$querySelector.textContent;
|
|
|
- const value = (_header$querySelector2 = header.querySelector("value")) == null ? void 0 : _header$querySelector2.textContent;
|
|
|
- if (name && value) {
|
|
|
- xhr.setRequestHeader(name, value);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const challengeElement = keyMessageXml.querySelector("Challenge");
|
|
|
- const challengeText = challengeElement == null ? void 0 : challengeElement.textContent;
|
|
|
- if (!challengeText) {
|
|
|
- throw new Error(`Cannot find <Challenge> in key message`);
|
|
|
- }
|
|
|
- return strToUtf8array(atob(challengeText));
|
|
|
- }
|
|
|
- setupLicenseXHR(xhr, url, keysListItem, licenseChallenge) {
|
|
|
- const licenseXhrSetup = this.config.licenseXhrSetup;
|
|
|
- if (!licenseXhrSetup) {
|
|
|
- xhr.open("POST", url, true);
|
|
|
- return Promise.resolve({
|
|
|
- xhr,
|
|
|
- licenseChallenge
|
|
|
- });
|
|
|
- }
|
|
|
- return Promise.resolve().then(() => {
|
|
|
- if (!keysListItem.decryptdata) {
|
|
|
- throw new Error("Key removed");
|
|
|
- }
|
|
|
- return licenseXhrSetup.call(this.hls, xhr, url, keysListItem, licenseChallenge);
|
|
|
- }).catch((error) => {
|
|
|
- if (!keysListItem.decryptdata) {
|
|
|
- throw error;
|
|
|
- }
|
|
|
- xhr.open("POST", url, true);
|
|
|
- return licenseXhrSetup.call(this.hls, xhr, url, keysListItem, licenseChallenge);
|
|
|
- }).then((licenseXhrSetupResult) => {
|
|
|
- if (!xhr.readyState) {
|
|
|
- xhr.open("POST", url, true);
|
|
|
- }
|
|
|
- const finalLicenseChallenge = licenseXhrSetupResult ? licenseXhrSetupResult : licenseChallenge;
|
|
|
- return {
|
|
|
- xhr,
|
|
|
- licenseChallenge: finalLicenseChallenge
|
|
|
- };
|
|
|
- });
|
|
|
- }
|
|
|
- requestLicense(keySessionContext, licenseChallenge) {
|
|
|
- const keyLoadPolicy = this.config.keyLoadPolicy.default;
|
|
|
- return new Promise((resolve, reject) => {
|
|
|
- const url = this.getLicenseServerUrlOrThrow(keySessionContext.keySystem);
|
|
|
- this.log(`Sending license request to URL: ${url}`);
|
|
|
- const xhr = new XMLHttpRequest();
|
|
|
- xhr.responseType = "arraybuffer";
|
|
|
- xhr.onreadystatechange = () => {
|
|
|
- if (!this.hls || !keySessionContext.mediaKeysSession) {
|
|
|
- return reject(new Error("invalid state"));
|
|
|
- }
|
|
|
- if (xhr.readyState === 4) {
|
|
|
- if (xhr.status === 200) {
|
|
|
- this._requestLicenseFailureCount = 0;
|
|
|
- let data = xhr.response;
|
|
|
- this.log(`License received ${data instanceof ArrayBuffer ? data.byteLength : data}`);
|
|
|
- const licenseResponseCallback = this.config.licenseResponseCallback;
|
|
|
- if (licenseResponseCallback) {
|
|
|
- try {
|
|
|
- data = licenseResponseCallback.call(this.hls, xhr, url, keySessionContext);
|
|
|
- } catch (error) {
|
|
|
- this.error(error);
|
|
|
- }
|
|
|
- }
|
|
|
- resolve(data);
|
|
|
- } else {
|
|
|
- const retryConfig = keyLoadPolicy.errorRetry;
|
|
|
- const maxNumRetry = retryConfig ? retryConfig.maxNumRetry : 0;
|
|
|
- this._requestLicenseFailureCount++;
|
|
|
- if (this._requestLicenseFailureCount > maxNumRetry || xhr.status >= 400 && xhr.status < 500) {
|
|
|
- reject(new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_LICENSE_REQUEST_FAILED,
|
|
|
- decryptdata: keySessionContext.decryptdata,
|
|
|
- fatal: true,
|
|
|
- networkDetails: xhr,
|
|
|
- response: {
|
|
|
- url,
|
|
|
- data: void 0,
|
|
|
- code: xhr.status,
|
|
|
- text: xhr.statusText
|
|
|
- }
|
|
|
- }, `License Request XHR failed (${url}). Status: ${xhr.status} (${xhr.statusText})`));
|
|
|
- } else {
|
|
|
- const attemptsLeft = maxNumRetry - this._requestLicenseFailureCount + 1;
|
|
|
- this.warn(`Retrying license request, ${attemptsLeft} attempts left`);
|
|
|
- this.requestLicense(keySessionContext, licenseChallenge).then(resolve, reject);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- if (keySessionContext.licenseXhr && keySessionContext.licenseXhr.readyState !== XMLHttpRequest.DONE) {
|
|
|
- keySessionContext.licenseXhr.abort();
|
|
|
- }
|
|
|
- keySessionContext.licenseXhr = xhr;
|
|
|
- this.setupLicenseXHR(xhr, url, keySessionContext, licenseChallenge).then(({
|
|
|
- xhr: xhr2,
|
|
|
- licenseChallenge: licenseChallenge2
|
|
|
- }) => {
|
|
|
- if (keySessionContext.keySystem == KeySystems.PLAYREADY) {
|
|
|
- licenseChallenge2 = this.unpackPlayReadyKeyMessage(xhr2, licenseChallenge2);
|
|
|
- }
|
|
|
- xhr2.send(licenseChallenge2);
|
|
|
- }).catch(reject);
|
|
|
- });
|
|
|
- }
|
|
|
- onDestroying() {
|
|
|
- this.unregisterListeners();
|
|
|
- this._clear();
|
|
|
- }
|
|
|
- onMediaAttached(event, data) {
|
|
|
- if (!this.config.emeEnabled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const media = data.media;
|
|
|
- this.media = media;
|
|
|
- addEventListener(media, "encrypted", this.onMediaEncrypted);
|
|
|
- addEventListener(media, "waitingforkey", this.onWaitingForKey);
|
|
|
- }
|
|
|
- onMediaDetached() {
|
|
|
- const media = this.media;
|
|
|
- if (media) {
|
|
|
- removeEventListener(media, "encrypted", this.onMediaEncrypted);
|
|
|
- removeEventListener(media, "waitingforkey", this.onWaitingForKey);
|
|
|
- this.media = null;
|
|
|
- this.mediaKeys = null;
|
|
|
- }
|
|
|
- }
|
|
|
- _clear() {
|
|
|
- var _media$setMediaKeys;
|
|
|
- this._requestLicenseFailureCount = 0;
|
|
|
- this.keyIdToKeySessionPromise = {};
|
|
|
- this.bannedKeyIds = {};
|
|
|
- if (!this.mediaKeys && !this.mediaKeySessions.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const media = this.media;
|
|
|
- const mediaKeysList = this.mediaKeySessions.slice();
|
|
|
- this.mediaKeySessions = [];
|
|
|
- this.mediaKeys = null;
|
|
|
- LevelKey.clearKeyUriToKeyIdMap();
|
|
|
- const keySessionCount = mediaKeysList.length;
|
|
|
- _EMEController.CDMCleanupPromise = Promise.all(mediaKeysList.map((mediaKeySessionContext) => this.removeSession(mediaKeySessionContext)).concat((media == null || (_media$setMediaKeys = media.setMediaKeys(null)) == null ? void 0 : _media$setMediaKeys.catch((error) => {
|
|
|
- this.log(`Could not clear media keys: ${error}`);
|
|
|
- if (!this.hls)
|
|
|
- return;
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: new Error(`Could not clear media keys: ${error}`)
|
|
|
- });
|
|
|
- })) || Promise.resolve())).catch((error) => {
|
|
|
- this.log(`Could not close sessions and clear media keys: ${error}`);
|
|
|
- if (!this.hls)
|
|
|
- return;
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: new Error(`Could not close sessions and clear media keys: ${error}`)
|
|
|
- });
|
|
|
- }).then(() => {
|
|
|
- if (keySessionCount) {
|
|
|
- this.log("finished closing key sessions and clearing media keys");
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.keyFormatPromise = null;
|
|
|
- this.bannedKeyIds = {};
|
|
|
- }
|
|
|
- onManifestLoaded(event, {
|
|
|
- sessionKeys
|
|
|
- }) {
|
|
|
- if (!sessionKeys || !this.config.emeEnabled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!this.keyFormatPromise) {
|
|
|
- const keyFormats = sessionKeys.reduce((formats, sessionKey) => {
|
|
|
- if (formats.indexOf(sessionKey.keyFormat) === -1) {
|
|
|
- formats.push(sessionKey.keyFormat);
|
|
|
- }
|
|
|
- return formats;
|
|
|
- }, []);
|
|
|
- this.log(`Selecting key-system from session-keys ${keyFormats.join(", ")}`);
|
|
|
- this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
|
|
|
- }
|
|
|
- }
|
|
|
- removeSession(mediaKeySessionContext) {
|
|
|
- const {
|
|
|
- mediaKeysSession,
|
|
|
- licenseXhr,
|
|
|
- decryptdata
|
|
|
- } = mediaKeySessionContext;
|
|
|
- if (mediaKeysSession) {
|
|
|
- this.log(`Remove licenses and keys and close session "${mediaKeysSession.sessionId}" keyId: ${arrayToHex((decryptdata == null ? void 0 : decryptdata.keyId) || [])}`);
|
|
|
- if (mediaKeySessionContext._onmessage) {
|
|
|
- mediaKeysSession.removeEventListener("message", mediaKeySessionContext._onmessage);
|
|
|
- mediaKeySessionContext._onmessage = void 0;
|
|
|
- }
|
|
|
- if (mediaKeySessionContext._onkeystatuseschange) {
|
|
|
- mediaKeysSession.removeEventListener("keystatuseschange", mediaKeySessionContext._onkeystatuseschange);
|
|
|
- mediaKeySessionContext._onkeystatuseschange = void 0;
|
|
|
- }
|
|
|
- if (licenseXhr && licenseXhr.readyState !== XMLHttpRequest.DONE) {
|
|
|
- licenseXhr.abort();
|
|
|
- }
|
|
|
- mediaKeySessionContext.mediaKeysSession = mediaKeySessionContext.decryptdata = mediaKeySessionContext.licenseXhr = void 0;
|
|
|
- const index = this.mediaKeySessions.indexOf(mediaKeySessionContext);
|
|
|
- if (index > -1) {
|
|
|
- this.mediaKeySessions.splice(index, 1);
|
|
|
- }
|
|
|
- const {
|
|
|
- keyStatusTimeouts
|
|
|
- } = mediaKeySessionContext;
|
|
|
- if (keyStatusTimeouts) {
|
|
|
- Object.keys(keyStatusTimeouts).forEach((keyId) => self.clearTimeout(keyStatusTimeouts[keyId]));
|
|
|
- }
|
|
|
- const {
|
|
|
- drmSystemOptions
|
|
|
- } = this.config;
|
|
|
- const removePromise = isPersistentSessionType(drmSystemOptions) ? new Promise((resolve, reject) => {
|
|
|
- self.setTimeout(() => reject(new Error(`MediaKeySession.remove() timeout`)), 8e3);
|
|
|
- mediaKeysSession.remove().then(resolve).catch(reject);
|
|
|
- }) : Promise.resolve();
|
|
|
- return removePromise.catch((error) => {
|
|
|
- this.log(`Could not remove session: ${error}`);
|
|
|
- if (!this.hls)
|
|
|
- return;
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: new Error(`Could not remove session: ${error}`)
|
|
|
- });
|
|
|
- }).then(() => {
|
|
|
- return mediaKeysSession.close();
|
|
|
- }).catch((error) => {
|
|
|
- this.log(`Could not close session: ${error}`);
|
|
|
- if (!this.hls)
|
|
|
- return;
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: new Error(`Could not close session: ${error}`)
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- return Promise.resolve();
|
|
|
- }
|
|
|
-};
|
|
|
-EMEController.CDMCleanupPromise = void 0;
|
|
|
-function getKeyIdString(decryptdata) {
|
|
|
- if (!decryptdata) {
|
|
|
- throw new Error("Could not read keyId of undefined decryptdata");
|
|
|
- }
|
|
|
- if (decryptdata.keyId === null) {
|
|
|
- throw new Error("keyId is null");
|
|
|
- }
|
|
|
- return arrayToHex(decryptdata.keyId);
|
|
|
-}
|
|
|
-function getKeyStatus(decryptdata, keyContext) {
|
|
|
- if (decryptdata.keyId && keyContext.mediaKeysSession.keyStatuses.has(decryptdata.keyId)) {
|
|
|
- return keyContext.mediaKeysSession.keyStatuses.get(decryptdata.keyId);
|
|
|
- }
|
|
|
- if (decryptdata.matches(keyContext.decryptdata)) {
|
|
|
- return keyContext.keyStatus;
|
|
|
- }
|
|
|
- return void 0;
|
|
|
-}
|
|
|
-var EMEKeyError = class extends Error {
|
|
|
- constructor(data, message) {
|
|
|
- super(message);
|
|
|
- this.data = void 0;
|
|
|
- data.error || (data.error = new Error(message));
|
|
|
- this.data = data;
|
|
|
- data.err = data.error;
|
|
|
- }
|
|
|
-};
|
|
|
-function getKeyStatusError(keyStatus, decryptdata) {
|
|
|
- const outputRestricted = keyStatus === "output-restricted";
|
|
|
- const details = outputRestricted ? ErrorDetails.KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED : ErrorDetails.KEY_SYSTEM_STATUS_INTERNAL_ERROR;
|
|
|
- return new EMEKeyError({
|
|
|
- type: ErrorTypes.KEY_SYSTEM_ERROR,
|
|
|
- details,
|
|
|
- fatal: false,
|
|
|
- decryptdata
|
|
|
- }, outputRestricted ? "HDCP level output restricted" : `key status changed to "${keyStatus}"`);
|
|
|
-}
|
|
|
-var FPSController = class {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.isVideoPlaybackQualityAvailable = false;
|
|
|
- this.timer = void 0;
|
|
|
- this.media = null;
|
|
|
- this.lastTime = void 0;
|
|
|
- this.lastDroppedFrames = 0;
|
|
|
- this.lastDecodedFrames = 0;
|
|
|
- this.streamController = void 0;
|
|
|
- this.hls = hls;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- setStreamController(streamController) {
|
|
|
- this.streamController = streamController;
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- this.hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- this.hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- this.hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- this.hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- if (this.timer) {
|
|
|
- clearInterval(this.timer);
|
|
|
- }
|
|
|
- this.unregisterListeners();
|
|
|
- this.isVideoPlaybackQualityAvailable = false;
|
|
|
- this.media = null;
|
|
|
- }
|
|
|
- onMediaAttaching(event, data) {
|
|
|
- const config = this.hls.config;
|
|
|
- if (config.capLevelOnFPSDrop) {
|
|
|
- const media = data.media instanceof self.HTMLVideoElement ? data.media : null;
|
|
|
- this.media = media;
|
|
|
- if (media && typeof media.getVideoPlaybackQuality === "function") {
|
|
|
- this.isVideoPlaybackQualityAvailable = true;
|
|
|
- }
|
|
|
- self.clearInterval(this.timer);
|
|
|
- this.timer = self.setInterval(this.checkFPSInterval.bind(this), config.fpsDroppedMonitoringPeriod);
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaDetaching() {
|
|
|
- this.media = null;
|
|
|
- }
|
|
|
- checkFPS(video, decodedFrames, droppedFrames) {
|
|
|
- const currentTime = performance.now();
|
|
|
- if (decodedFrames) {
|
|
|
- if (this.lastTime) {
|
|
|
- const currentPeriod = currentTime - this.lastTime;
|
|
|
- const currentDropped = droppedFrames - this.lastDroppedFrames;
|
|
|
- const currentDecoded = decodedFrames - this.lastDecodedFrames;
|
|
|
- const droppedFPS = 1e3 * currentDropped / currentPeriod;
|
|
|
- const hls = this.hls;
|
|
|
- hls.trigger(Events.FPS_DROP, {
|
|
|
- currentDropped,
|
|
|
- currentDecoded,
|
|
|
- totalDroppedFrames: droppedFrames
|
|
|
- });
|
|
|
- if (droppedFPS > 0) {
|
|
|
- if (currentDropped > hls.config.fpsDroppedMonitoringThreshold * currentDecoded) {
|
|
|
- let currentLevel = hls.currentLevel;
|
|
|
- hls.logger.warn("drop FPS ratio greater than max allowed value for currentLevel: " + currentLevel);
|
|
|
- if (currentLevel > 0 && (hls.autoLevelCapping === -1 || hls.autoLevelCapping >= currentLevel)) {
|
|
|
- currentLevel = currentLevel - 1;
|
|
|
- hls.trigger(Events.FPS_DROP_LEVEL_CAPPING, {
|
|
|
- level: currentLevel,
|
|
|
- droppedLevel: hls.currentLevel
|
|
|
- });
|
|
|
- hls.autoLevelCapping = currentLevel;
|
|
|
- this.streamController.nextLevelSwitch();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.lastTime = currentTime;
|
|
|
- this.lastDroppedFrames = droppedFrames;
|
|
|
- this.lastDecodedFrames = decodedFrames;
|
|
|
- }
|
|
|
- }
|
|
|
- checkFPSInterval() {
|
|
|
- const video = this.media;
|
|
|
- if (video) {
|
|
|
- if (this.isVideoPlaybackQualityAvailable) {
|
|
|
- const videoPlaybackQuality = video.getVideoPlaybackQuality();
|
|
|
- this.checkFPS(video, videoPlaybackQuality.totalVideoFrames, videoPlaybackQuality.droppedVideoFrames);
|
|
|
- } else {
|
|
|
- this.checkFPS(video, video.webkitDecodedFrameCount, video.webkitDroppedFrameCount);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function sendAddTrackEvent(track, videoEl) {
|
|
|
- let event;
|
|
|
- try {
|
|
|
- event = new Event("addtrack");
|
|
|
- } catch (err) {
|
|
|
- event = document.createEvent("Event");
|
|
|
- event.initEvent("addtrack", false, false);
|
|
|
- }
|
|
|
- event.track = track;
|
|
|
- videoEl.dispatchEvent(event);
|
|
|
-}
|
|
|
-function addCueToTrack(track, cue) {
|
|
|
- const mode = track.mode;
|
|
|
- if (mode === "disabled") {
|
|
|
- track.mode = "hidden";
|
|
|
- }
|
|
|
- if (track.cues && !track.cues.getCueById(cue.id)) {
|
|
|
- try {
|
|
|
- track.addCue(cue);
|
|
|
- if (!track.cues.getCueById(cue.id)) {
|
|
|
- throw new Error(`addCue is failed for: ${cue}`);
|
|
|
- }
|
|
|
- } catch (err) {
|
|
|
- logger.debug(`[texttrack-utils]: ${err}`);
|
|
|
- try {
|
|
|
- const textTrackCue = new self.TextTrackCue(cue.startTime, cue.endTime, cue.text);
|
|
|
- textTrackCue.id = cue.id;
|
|
|
- track.addCue(textTrackCue);
|
|
|
- } catch (err2) {
|
|
|
- logger.debug(`[texttrack-utils]: Legacy TextTrackCue fallback failed: ${err2}`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (mode === "disabled") {
|
|
|
- track.mode = mode;
|
|
|
- }
|
|
|
-}
|
|
|
-function clearCurrentCues(track, enterHandler) {
|
|
|
- const mode = track.mode;
|
|
|
- if (mode === "disabled") {
|
|
|
- track.mode = "hidden";
|
|
|
- }
|
|
|
- if (track.cues) {
|
|
|
- for (let i = track.cues.length; i--; ) {
|
|
|
- if (enterHandler) {
|
|
|
- track.cues[i].removeEventListener("enter", enterHandler);
|
|
|
- }
|
|
|
- track.removeCue(track.cues[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- if (mode === "disabled") {
|
|
|
- track.mode = mode;
|
|
|
- }
|
|
|
-}
|
|
|
-function removeCuesInRange(track, start, end, predicate) {
|
|
|
- const mode = track.mode;
|
|
|
- if (mode === "disabled") {
|
|
|
- track.mode = "hidden";
|
|
|
- }
|
|
|
- if (track.cues && track.cues.length > 0) {
|
|
|
- const cues = getCuesInRange(track.cues, start, end);
|
|
|
- for (let i = 0; i < cues.length; i++) {
|
|
|
- if (!predicate || predicate(cues[i])) {
|
|
|
- track.removeCue(cues[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (mode === "disabled") {
|
|
|
- track.mode = mode;
|
|
|
- }
|
|
|
-}
|
|
|
-function getFirstCueIndexFromTime(cues, time) {
|
|
|
- if (time <= cues[0].startTime) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const len = cues.length - 1;
|
|
|
- if (time > cues[len].endTime) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- let left = 0;
|
|
|
- let right = len;
|
|
|
- let mid;
|
|
|
- while (left <= right) {
|
|
|
- mid = Math.floor((right + left) / 2);
|
|
|
- if (time < cues[mid].startTime) {
|
|
|
- right = mid - 1;
|
|
|
- } else if (time > cues[mid].startTime && left < len) {
|
|
|
- left = mid + 1;
|
|
|
- } else {
|
|
|
- return mid;
|
|
|
- }
|
|
|
- }
|
|
|
- return cues[left].startTime - time < time - cues[right].startTime ? left : right;
|
|
|
-}
|
|
|
-function getCuesInRange(cues, start, end) {
|
|
|
- const cuesFound = [];
|
|
|
- const firstCueInRange = getFirstCueIndexFromTime(cues, start);
|
|
|
- if (firstCueInRange > -1) {
|
|
|
- for (let i = firstCueInRange, len = cues.length; i < len; i++) {
|
|
|
- const cue = cues[i];
|
|
|
- if (cue.startTime >= start && cue.endTime <= end) {
|
|
|
- cuesFound.push(cue);
|
|
|
- } else if (cue.startTime > end) {
|
|
|
- return cuesFound;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return cuesFound;
|
|
|
-}
|
|
|
-function filterSubtitleTracks(textTrackList) {
|
|
|
- const tracks = [];
|
|
|
- for (let i = 0; i < textTrackList.length; i++) {
|
|
|
- const track = textTrackList[i];
|
|
|
- if ((track.kind === "subtitles" || track.kind === "captions") && track.label) {
|
|
|
- tracks.push(textTrackList[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- return tracks;
|
|
|
-}
|
|
|
-var SubtitleTrackController = class extends BasePlaylistController {
|
|
|
- constructor(hls) {
|
|
|
- super(hls, "subtitle-track-controller");
|
|
|
- this.media = null;
|
|
|
- this.tracks = [];
|
|
|
- this.groupIds = null;
|
|
|
- this.tracksInGroup = [];
|
|
|
- this.trackId = -1;
|
|
|
- this.currentTrack = null;
|
|
|
- this.selectDefaultTrack = true;
|
|
|
- this.queuedDefaultTrack = -1;
|
|
|
- this.useTextTrackPolling = false;
|
|
|
- this.subtitlePollingInterval = -1;
|
|
|
- this._subtitleDisplay = true;
|
|
|
- this.asyncPollTrackChange = () => this.pollTrackChange(0);
|
|
|
- this.onTextTracksChanged = () => {
|
|
|
- if (!this.useTextTrackPolling) {
|
|
|
- self.clearInterval(this.subtitlePollingInterval);
|
|
|
- }
|
|
|
- if (!this.media || !this.hls.config.renderTextTracksNatively) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let textTrack = null;
|
|
|
- const tracks = filterSubtitleTracks(this.media.textTracks);
|
|
|
- for (let i = 0; i < tracks.length; i++) {
|
|
|
- if (tracks[i].mode === "hidden") {
|
|
|
- textTrack = tracks[i];
|
|
|
- } else if (tracks[i].mode === "showing") {
|
|
|
- textTrack = tracks[i];
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- const trackId = this.findTrackForTextTrack(textTrack);
|
|
|
- if (this.subtitleTrack !== trackId) {
|
|
|
- this.setSubtitleTrack(trackId);
|
|
|
- }
|
|
|
- };
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.tracks.length = 0;
|
|
|
- this.tracksInGroup.length = 0;
|
|
|
- this.currentTrack = null;
|
|
|
- this.onTextTracksChanged = this.asyncPollTrackChange = null;
|
|
|
- super.destroy();
|
|
|
- }
|
|
|
- get subtitleDisplay() {
|
|
|
- return this._subtitleDisplay;
|
|
|
- }
|
|
|
- set subtitleDisplay(value) {
|
|
|
- this._subtitleDisplay = value;
|
|
|
- if (this.trackId > -1) {
|
|
|
- this.toggleTrackModes();
|
|
|
- }
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
|
|
|
- hls.on(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.off(Events.LEVEL_LOADING, this.onLevelLoading, this);
|
|
|
- hls.off(Events.LEVEL_SWITCHING, this.onLevelSwitching, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- // Listen for subtitle track change, then extract the current track ID.
|
|
|
- onMediaAttached(event, data) {
|
|
|
- this.media = data.media;
|
|
|
- if (!this.media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.queuedDefaultTrack > -1) {
|
|
|
- this.subtitleTrack = this.queuedDefaultTrack;
|
|
|
- this.queuedDefaultTrack = -1;
|
|
|
- }
|
|
|
- this.useTextTrackPolling = !(this.media.textTracks && "onchange" in this.media.textTracks);
|
|
|
- if (this.useTextTrackPolling) {
|
|
|
- this.pollTrackChange(500);
|
|
|
- } else {
|
|
|
- this.media.textTracks.addEventListener("change", this.asyncPollTrackChange);
|
|
|
- }
|
|
|
- }
|
|
|
- pollTrackChange(timeout) {
|
|
|
- self.clearInterval(this.subtitlePollingInterval);
|
|
|
- this.subtitlePollingInterval = self.setInterval(this.onTextTracksChanged, timeout);
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- const media = this.media;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const transferringMedia = !!data.transferMedia;
|
|
|
- self.clearInterval(this.subtitlePollingInterval);
|
|
|
- if (!this.useTextTrackPolling) {
|
|
|
- media.textTracks.removeEventListener("change", this.asyncPollTrackChange);
|
|
|
- }
|
|
|
- if (this.trackId > -1) {
|
|
|
- this.queuedDefaultTrack = this.trackId;
|
|
|
- }
|
|
|
- this.subtitleTrack = -1;
|
|
|
- this.media = null;
|
|
|
- if (transferringMedia) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const textTracks = filterSubtitleTracks(media.textTracks);
|
|
|
- textTracks.forEach((track) => {
|
|
|
- clearCurrentCues(track);
|
|
|
- });
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.tracks = [];
|
|
|
- this.groupIds = null;
|
|
|
- this.tracksInGroup = [];
|
|
|
- this.trackId = -1;
|
|
|
- this.currentTrack = null;
|
|
|
- this.selectDefaultTrack = true;
|
|
|
- }
|
|
|
- // Fired whenever a new manifest is loaded.
|
|
|
- onManifestParsed(event, data) {
|
|
|
- this.tracks = data.subtitleTracks;
|
|
|
- }
|
|
|
- onSubtitleTrackLoaded(event, data) {
|
|
|
- const {
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- details
|
|
|
- } = data;
|
|
|
- const trackInActiveGroup = this.tracksInGroup[id];
|
|
|
- if (!trackInActiveGroup || trackInActiveGroup.groupId !== groupId) {
|
|
|
- this.warn(`Subtitle track with id:${id} and group:${groupId} not found in active group ${trackInActiveGroup == null ? void 0 : trackInActiveGroup.groupId}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const curDetails = trackInActiveGroup.details;
|
|
|
- trackInActiveGroup.details = data.details;
|
|
|
- this.log(`Subtitle track ${id} "${trackInActiveGroup.name}" lang:${trackInActiveGroup.lang} group:${groupId} loaded [${details.startSN}-${details.endSN}]`);
|
|
|
- if (id === this.trackId) {
|
|
|
- this.playlistLoaded(id, data, curDetails);
|
|
|
- }
|
|
|
- }
|
|
|
- onLevelLoading(event, data) {
|
|
|
- this.switchLevel(data.level);
|
|
|
- }
|
|
|
- onLevelSwitching(event, data) {
|
|
|
- this.switchLevel(data.level);
|
|
|
- }
|
|
|
- switchLevel(levelIndex) {
|
|
|
- const levelInfo = this.hls.levels[levelIndex];
|
|
|
- if (!levelInfo) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const subtitleGroups = levelInfo.subtitleGroups || null;
|
|
|
- const currentGroups = this.groupIds;
|
|
|
- let currentTrack = this.currentTrack;
|
|
|
- if (!subtitleGroups || (currentGroups == null ? void 0 : currentGroups.length) !== (subtitleGroups == null ? void 0 : subtitleGroups.length) || subtitleGroups != null && subtitleGroups.some((groupId) => (currentGroups == null ? void 0 : currentGroups.indexOf(groupId)) === -1)) {
|
|
|
- this.groupIds = subtitleGroups;
|
|
|
- this.trackId = -1;
|
|
|
- this.currentTrack = null;
|
|
|
- const subtitleTracks = this.tracks.filter((track) => !subtitleGroups || subtitleGroups.indexOf(track.groupId) !== -1);
|
|
|
- if (subtitleTracks.length) {
|
|
|
- if (this.selectDefaultTrack && !subtitleTracks.some((track) => track.default)) {
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- }
|
|
|
- subtitleTracks.forEach((track, i) => {
|
|
|
- track.id = i;
|
|
|
- });
|
|
|
- } else if (!currentTrack && !this.tracksInGroup.length) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.tracksInGroup = subtitleTracks;
|
|
|
- const subtitlePreference = this.hls.config.subtitlePreference;
|
|
|
- if (!currentTrack && subtitlePreference) {
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- const groupIndex = findMatchingOption(subtitlePreference, subtitleTracks);
|
|
|
- if (groupIndex > -1) {
|
|
|
- currentTrack = subtitleTracks[groupIndex];
|
|
|
- } else {
|
|
|
- const allIndex = findMatchingOption(subtitlePreference, this.tracks);
|
|
|
- currentTrack = this.tracks[allIndex];
|
|
|
- }
|
|
|
- }
|
|
|
- let trackId = this.findTrackId(currentTrack);
|
|
|
- if (trackId === -1 && currentTrack) {
|
|
|
- trackId = this.findTrackId(null);
|
|
|
- }
|
|
|
- const subtitleTracksUpdated = {
|
|
|
- subtitleTracks
|
|
|
- };
|
|
|
- this.log(`Updating subtitle tracks, ${subtitleTracks.length} track(s) found in "${subtitleGroups == null ? void 0 : subtitleGroups.join(",")}" group-id`);
|
|
|
- this.hls.trigger(Events.SUBTITLE_TRACKS_UPDATED, subtitleTracksUpdated);
|
|
|
- if (trackId !== -1 && this.trackId === -1) {
|
|
|
- this.setSubtitleTrack(trackId);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- findTrackId(currentTrack) {
|
|
|
- const tracks = this.tracksInGroup;
|
|
|
- const selectDefault = this.selectDefaultTrack;
|
|
|
- for (let i = 0; i < tracks.length; i++) {
|
|
|
- const track = tracks[i];
|
|
|
- if (selectDefault && !track.default || !selectDefault && !currentTrack) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (!currentTrack || matchesOption(track, currentTrack)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- if (currentTrack) {
|
|
|
- for (let i = 0; i < tracks.length; i++) {
|
|
|
- const track = tracks[i];
|
|
|
- if (mediaAttributesIdentical(currentTrack.attrs, track.attrs, ["LANGUAGE", "ASSOC-LANGUAGE", "CHARACTERISTICS"])) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- for (let i = 0; i < tracks.length; i++) {
|
|
|
- const track = tracks[i];
|
|
|
- if (mediaAttributesIdentical(currentTrack.attrs, track.attrs, ["LANGUAGE"])) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- findTrackForTextTrack(textTrack) {
|
|
|
- if (textTrack) {
|
|
|
- const tracks = this.tracksInGroup;
|
|
|
- for (let i = 0; i < tracks.length; i++) {
|
|
|
- const track = tracks[i];
|
|
|
- if (subtitleTrackMatchesTextTrack(track, textTrack)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- if (data.fatal || !data.context) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (data.context.type === PlaylistContextType.SUBTITLE_TRACK && data.context.id === this.trackId && (!this.groupIds || this.groupIds.indexOf(data.context.groupId) !== -1)) {
|
|
|
- this.checkRetry(data);
|
|
|
- }
|
|
|
- }
|
|
|
- get allSubtitleTracks() {
|
|
|
- return this.tracks;
|
|
|
- }
|
|
|
- /** get alternate subtitle tracks list from playlist **/
|
|
|
- get subtitleTracks() {
|
|
|
- return this.tracksInGroup;
|
|
|
- }
|
|
|
- /** get/set index of the selected subtitle track (based on index in subtitle track lists) **/
|
|
|
- get subtitleTrack() {
|
|
|
- return this.trackId;
|
|
|
- }
|
|
|
- set subtitleTrack(newId) {
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- this.setSubtitleTrack(newId);
|
|
|
- }
|
|
|
- setSubtitleOption(subtitleOption) {
|
|
|
- this.hls.config.subtitlePreference = subtitleOption;
|
|
|
- if (subtitleOption) {
|
|
|
- if (subtitleOption.id === -1) {
|
|
|
- this.setSubtitleTrack(-1);
|
|
|
- return null;
|
|
|
- }
|
|
|
- const allSubtitleTracks = this.allSubtitleTracks;
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- if (allSubtitleTracks.length) {
|
|
|
- const currentTrack = this.currentTrack;
|
|
|
- if (currentTrack && matchesOption(subtitleOption, currentTrack)) {
|
|
|
- return currentTrack;
|
|
|
- }
|
|
|
- const groupIndex = findMatchingOption(subtitleOption, this.tracksInGroup);
|
|
|
- if (groupIndex > -1) {
|
|
|
- const track = this.tracksInGroup[groupIndex];
|
|
|
- this.setSubtitleTrack(groupIndex);
|
|
|
- return track;
|
|
|
- } else if (currentTrack) {
|
|
|
- return null;
|
|
|
- } else {
|
|
|
- const allIndex = findMatchingOption(subtitleOption, allSubtitleTracks);
|
|
|
- if (allIndex > -1) {
|
|
|
- return allSubtitleTracks[allIndex];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- loadPlaylist(hlsUrlParameters) {
|
|
|
- super.loadPlaylist();
|
|
|
- if (this.shouldLoadPlaylist(this.currentTrack)) {
|
|
|
- this.scheduleLoading(this.currentTrack, hlsUrlParameters);
|
|
|
- }
|
|
|
- }
|
|
|
- loadingPlaylist(currentTrack, hlsUrlParameters) {
|
|
|
- super.loadingPlaylist(currentTrack, hlsUrlParameters);
|
|
|
- const id = currentTrack.id;
|
|
|
- const groupId = currentTrack.groupId;
|
|
|
- const url = this.getUrlWithDirectives(currentTrack.url, hlsUrlParameters);
|
|
|
- const details = currentTrack.details;
|
|
|
- const age = details == null ? void 0 : details.age;
|
|
|
- this.log(`Loading subtitle ${id} "${currentTrack.name}" lang:${currentTrack.lang} group:${groupId}${(hlsUrlParameters == null ? void 0 : hlsUrlParameters.msn) !== void 0 ? " at sn " + hlsUrlParameters.msn + " part " + hlsUrlParameters.part : ""}${age && details.live ? " age " + age.toFixed(1) + (details.type ? " " + details.type || "" : "") : ""} ${url}`);
|
|
|
- this.hls.trigger(Events.SUBTITLE_TRACK_LOADING, {
|
|
|
- url,
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- deliveryDirectives: hlsUrlParameters || null,
|
|
|
- track: currentTrack
|
|
|
- });
|
|
|
- }
|
|
|
- /**
|
|
|
- * Disables the old subtitleTrack and sets current mode on the next subtitleTrack.
|
|
|
- * This operates on the DOM textTracks.
|
|
|
- * A value of -1 will disable all subtitle tracks.
|
|
|
- */
|
|
|
- toggleTrackModes() {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const textTracks = filterSubtitleTracks(media.textTracks);
|
|
|
- const currentTrack = this.currentTrack;
|
|
|
- let nextTrack;
|
|
|
- if (currentTrack) {
|
|
|
- nextTrack = textTracks.filter((textTrack) => subtitleTrackMatchesTextTrack(currentTrack, textTrack))[0];
|
|
|
- if (!nextTrack) {
|
|
|
- this.warn(`Unable to find subtitle TextTrack with name "${currentTrack.name}" and language "${currentTrack.lang}"`);
|
|
|
- }
|
|
|
- }
|
|
|
- [].slice.call(textTracks).forEach((track) => {
|
|
|
- if (track.mode !== "disabled" && track !== nextTrack) {
|
|
|
- track.mode = "disabled";
|
|
|
- }
|
|
|
- });
|
|
|
- if (nextTrack) {
|
|
|
- const mode = this.subtitleDisplay ? "showing" : "hidden";
|
|
|
- if (nextTrack.mode !== mode) {
|
|
|
- nextTrack.mode = mode;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * This method is responsible for validating the subtitle index and periodically reloading if live.
|
|
|
- * Dispatches the SUBTITLE_TRACK_SWITCH event, which instructs the subtitle-stream-controller to load the selected track.
|
|
|
- */
|
|
|
- setSubtitleTrack(newId) {
|
|
|
- const tracks = this.tracksInGroup;
|
|
|
- if (!this.media) {
|
|
|
- this.queuedDefaultTrack = newId;
|
|
|
- return;
|
|
|
- }
|
|
|
- if (newId < -1 || newId >= tracks.length || !isFiniteNumber(newId)) {
|
|
|
- this.warn(`Invalid subtitle track id: ${newId}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.selectDefaultTrack = false;
|
|
|
- const lastTrack = this.currentTrack;
|
|
|
- const track = tracks[newId] || null;
|
|
|
- this.trackId = newId;
|
|
|
- this.currentTrack = track;
|
|
|
- this.toggleTrackModes();
|
|
|
- if (!track) {
|
|
|
- this.hls.trigger(Events.SUBTITLE_TRACK_SWITCH, {
|
|
|
- id: newId
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- const trackLoaded = !!track.details && !track.details.live;
|
|
|
- if (newId === this.trackId && track === lastTrack && trackLoaded) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Switching to subtitle-track ${newId}` + (track ? ` "${track.name}" lang:${track.lang} group:${track.groupId}` : ""));
|
|
|
- const {
|
|
|
- id,
|
|
|
- groupId = "",
|
|
|
- name,
|
|
|
- type,
|
|
|
- url
|
|
|
- } = track;
|
|
|
- this.hls.trigger(Events.SUBTITLE_TRACK_SWITCH, {
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- name,
|
|
|
- type,
|
|
|
- url
|
|
|
- });
|
|
|
- const hlsUrlParameters = this.switchParams(track.url, lastTrack == null ? void 0 : lastTrack.details, track.details);
|
|
|
- this.loadPlaylist(hlsUrlParameters);
|
|
|
- }
|
|
|
-};
|
|
|
-function uuid() {
|
|
|
- try {
|
|
|
- return crypto.randomUUID();
|
|
|
- } catch (error) {
|
|
|
- try {
|
|
|
- const url = URL.createObjectURL(new Blob());
|
|
|
- const uuid2 = url.toString();
|
|
|
- URL.revokeObjectURL(url);
|
|
|
- return uuid2.slice(uuid2.lastIndexOf("/") + 1);
|
|
|
- } catch (error2) {
|
|
|
- let dt = (/* @__PURE__ */ new Date()).getTime();
|
|
|
- const uuid2 = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
|
|
|
- const r = (dt + Math.random() * 16) % 16 | 0;
|
|
|
- dt = Math.floor(dt / 16);
|
|
|
- return (c == "x" ? r : r & 3 | 8).toString(16);
|
|
|
- });
|
|
|
- return uuid2;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-function hash(text) {
|
|
|
- let hash2 = 5381;
|
|
|
- let i = text.length;
|
|
|
- while (i) {
|
|
|
- hash2 = hash2 * 33 ^ text.charCodeAt(--i);
|
|
|
- }
|
|
|
- return (hash2 >>> 0).toString();
|
|
|
-}
|
|
|
-var ALIGNED_END_THRESHOLD_SECONDS = 0.025;
|
|
|
-var TimelineOccupancy = function(TimelineOccupancy2) {
|
|
|
- TimelineOccupancy2[TimelineOccupancy2["Point"] = 0] = "Point";
|
|
|
- TimelineOccupancy2[TimelineOccupancy2["Range"] = 1] = "Range";
|
|
|
- return TimelineOccupancy2;
|
|
|
-}({});
|
|
|
-function generateAssetIdentifier(interstitial, uri, assetListIndex) {
|
|
|
- return `${interstitial.identifier}-${assetListIndex + 1}-${hash(uri)}`;
|
|
|
-}
|
|
|
-var InterstitialEvent = class {
|
|
|
- constructor(dateRange, base) {
|
|
|
- this.base = void 0;
|
|
|
- this._duration = null;
|
|
|
- this._timelineStart = null;
|
|
|
- this.appendInPlaceDisabled = void 0;
|
|
|
- this.appendInPlaceStarted = void 0;
|
|
|
- this.dateRange = void 0;
|
|
|
- this.hasPlayed = false;
|
|
|
- this.cumulativeDuration = 0;
|
|
|
- this.resumeOffset = NaN;
|
|
|
- this.playoutLimit = NaN;
|
|
|
- this.restrictions = {
|
|
|
- skip: false,
|
|
|
- jump: false
|
|
|
- };
|
|
|
- this.snapOptions = {
|
|
|
- out: false,
|
|
|
- in: false
|
|
|
- };
|
|
|
- this.assetList = [];
|
|
|
- this.assetListLoader = void 0;
|
|
|
- this.assetListResponse = null;
|
|
|
- this.resumeAnchor = void 0;
|
|
|
- this.error = void 0;
|
|
|
- this.resetOnResume = void 0;
|
|
|
- this.base = base;
|
|
|
- this.dateRange = dateRange;
|
|
|
- this.setDateRange(dateRange);
|
|
|
- }
|
|
|
- setDateRange(dateRange) {
|
|
|
- this.dateRange = dateRange;
|
|
|
- this.resumeOffset = dateRange.attr.optionalFloat("X-RESUME-OFFSET", this.resumeOffset);
|
|
|
- this.playoutLimit = dateRange.attr.optionalFloat("X-PLAYOUT-LIMIT", this.playoutLimit);
|
|
|
- this.restrictions = dateRange.attr.enumeratedStringList("X-RESTRICT", this.restrictions);
|
|
|
- this.snapOptions = dateRange.attr.enumeratedStringList("X-SNAP", this.snapOptions);
|
|
|
- }
|
|
|
- reset() {
|
|
|
- var _this$assetListLoader;
|
|
|
- this.appendInPlaceStarted = false;
|
|
|
- (_this$assetListLoader = this.assetListLoader) == null || _this$assetListLoader.destroy();
|
|
|
- this.assetListLoader = void 0;
|
|
|
- if (!this.supplementsPrimary) {
|
|
|
- this.assetListResponse = null;
|
|
|
- this.assetList = [];
|
|
|
- this._duration = null;
|
|
|
- }
|
|
|
- }
|
|
|
- isAssetPastPlayoutLimit(assetIndex) {
|
|
|
- var _this$assetList$asset;
|
|
|
- if (assetIndex > 0 && assetIndex >= this.assetList.length) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- const playoutLimit = this.playoutLimit;
|
|
|
- if (assetIndex <= 0 || isNaN(playoutLimit)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (playoutLimit === 0) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- const assetOffset = ((_this$assetList$asset = this.assetList[assetIndex]) == null ? void 0 : _this$assetList$asset.startOffset) || 0;
|
|
|
- return assetOffset > playoutLimit;
|
|
|
- }
|
|
|
- findAssetIndex(asset) {
|
|
|
- const index = this.assetList.indexOf(asset);
|
|
|
- return index;
|
|
|
- }
|
|
|
- get identifier() {
|
|
|
- return this.dateRange.id;
|
|
|
- }
|
|
|
- get startDate() {
|
|
|
- return this.dateRange.startDate;
|
|
|
- }
|
|
|
- get startTime() {
|
|
|
- const startTime = this.dateRange.startTime;
|
|
|
- if (this.snapOptions.out) {
|
|
|
- const frag = this.dateRange.tagAnchor;
|
|
|
- if (frag) {
|
|
|
- return getSnapToFragmentTime(startTime, frag);
|
|
|
- }
|
|
|
- }
|
|
|
- return startTime;
|
|
|
- }
|
|
|
- get startOffset() {
|
|
|
- return this.cue.pre ? 0 : this.startTime;
|
|
|
- }
|
|
|
- get startIsAligned() {
|
|
|
- if (this.startTime === 0 || this.snapOptions.out) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- const frag = this.dateRange.tagAnchor;
|
|
|
- if (frag) {
|
|
|
- const startTime = this.dateRange.startTime;
|
|
|
- const snappedStart = getSnapToFragmentTime(startTime, frag);
|
|
|
- return startTime - snappedStart < 0.1;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- get resumptionOffset() {
|
|
|
- const resumeOffset = this.resumeOffset;
|
|
|
- const offset = isFiniteNumber(resumeOffset) ? resumeOffset : this.duration;
|
|
|
- return this.cumulativeDuration + offset;
|
|
|
- }
|
|
|
- get resumeTime() {
|
|
|
- const resumeTime = this.startOffset + this.resumptionOffset;
|
|
|
- if (this.snapOptions.in) {
|
|
|
- const frag = this.resumeAnchor;
|
|
|
- if (frag) {
|
|
|
- return getSnapToFragmentTime(resumeTime, frag);
|
|
|
- }
|
|
|
- }
|
|
|
- return resumeTime;
|
|
|
- }
|
|
|
- get appendInPlace() {
|
|
|
- if (this.appendInPlaceStarted) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (this.appendInPlaceDisabled) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (!this.cue.once && !this.cue.pre && // preroll starts at startPosition before startPosition is known (live)
|
|
|
- this.startIsAligned && (isNaN(this.playoutLimit) && isNaN(this.resumeOffset) || this.resumeOffset && this.duration && Math.abs(this.resumeOffset - this.duration) < ALIGNED_END_THRESHOLD_SECONDS)) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- set appendInPlace(value) {
|
|
|
- if (this.appendInPlaceStarted) {
|
|
|
- this.resetOnResume = !value;
|
|
|
- return;
|
|
|
- }
|
|
|
- this.appendInPlaceDisabled = !value;
|
|
|
- }
|
|
|
- // Extended timeline start time
|
|
|
- get timelineStart() {
|
|
|
- if (this._timelineStart !== null) {
|
|
|
- return this._timelineStart;
|
|
|
- }
|
|
|
- return this.startTime;
|
|
|
- }
|
|
|
- set timelineStart(value) {
|
|
|
- this._timelineStart = value;
|
|
|
- }
|
|
|
- get duration() {
|
|
|
- const playoutLimit = this.playoutLimit;
|
|
|
- let duration;
|
|
|
- if (this._duration !== null) {
|
|
|
- duration = this._duration;
|
|
|
- } else if (this.dateRange.duration) {
|
|
|
- duration = this.dateRange.duration;
|
|
|
- } else {
|
|
|
- duration = this.dateRange.plannedDuration || 0;
|
|
|
- }
|
|
|
- if (!isNaN(playoutLimit) && playoutLimit < duration) {
|
|
|
- duration = playoutLimit;
|
|
|
- }
|
|
|
- return duration;
|
|
|
- }
|
|
|
- set duration(value) {
|
|
|
- this._duration = value;
|
|
|
- }
|
|
|
- get cue() {
|
|
|
- return this.dateRange.cue;
|
|
|
- }
|
|
|
- get timelineOccupancy() {
|
|
|
- if (this.dateRange.attr["X-TIMELINE-OCCUPIES"] === "RANGE") {
|
|
|
- return TimelineOccupancy.Range;
|
|
|
- }
|
|
|
- return TimelineOccupancy.Point;
|
|
|
- }
|
|
|
- get supplementsPrimary() {
|
|
|
- return this.dateRange.attr["X-TIMELINE-STYLE"] === "PRIMARY";
|
|
|
- }
|
|
|
- get contentMayVary() {
|
|
|
- return this.dateRange.attr["X-CONTENT-MAY-VARY"] !== "NO";
|
|
|
- }
|
|
|
- get assetUrl() {
|
|
|
- return this.dateRange.attr["X-ASSET-URI"];
|
|
|
- }
|
|
|
- get assetListUrl() {
|
|
|
- return this.dateRange.attr["X-ASSET-LIST"];
|
|
|
- }
|
|
|
- get baseUrl() {
|
|
|
- return this.base.url;
|
|
|
- }
|
|
|
- get assetListLoaded() {
|
|
|
- return this.assetList.length > 0 || this.assetListResponse !== null;
|
|
|
- }
|
|
|
- toString() {
|
|
|
- return eventToString(this);
|
|
|
- }
|
|
|
-};
|
|
|
-function getSnapToFragmentTime(time, frag) {
|
|
|
- return time - frag.start < frag.duration / 2 && !(Math.abs(time - (frag.start + frag.duration)) < ALIGNED_END_THRESHOLD_SECONDS) ? frag.start : frag.start + frag.duration;
|
|
|
-}
|
|
|
-function getInterstitialUrl(uri, sessionId, baseUrl) {
|
|
|
- const url = new self.URL(uri, baseUrl);
|
|
|
- if (url.protocol !== "data:") {
|
|
|
- url.searchParams.set("_HLS_primary_id", sessionId);
|
|
|
- }
|
|
|
- return url;
|
|
|
-}
|
|
|
-function getNextAssetIndex(interstitial, assetListIndex) {
|
|
|
- while ((_interstitial$assetLi = interstitial.assetList[++assetListIndex]) != null && _interstitial$assetLi.error) {
|
|
|
- var _interstitial$assetLi;
|
|
|
- }
|
|
|
- return assetListIndex;
|
|
|
-}
|
|
|
-function eventToString(interstitial) {
|
|
|
- return `["${interstitial.identifier}" ${interstitial.cue.pre ? "<pre>" : interstitial.cue.post ? "<post>" : ""}${interstitial.timelineStart.toFixed(2)}-${interstitial.resumeTime.toFixed(2)}]`;
|
|
|
-}
|
|
|
-function eventAssetToString(asset) {
|
|
|
- const start = asset.timelineStart;
|
|
|
- const duration = asset.duration || 0;
|
|
|
- return `["${asset.identifier}" ${start.toFixed(2)}-${(start + duration).toFixed(2)}]`;
|
|
|
-}
|
|
|
-var HlsAssetPlayer = class {
|
|
|
- constructor(HlsPlayerClass, userConfig, interstitial, assetItem) {
|
|
|
- this.hls = void 0;
|
|
|
- this.interstitial = void 0;
|
|
|
- this.assetItem = void 0;
|
|
|
- this.tracks = null;
|
|
|
- this.hasDetails = false;
|
|
|
- this.mediaAttached = null;
|
|
|
- this._currentTime = void 0;
|
|
|
- this._bufferedEosTime = void 0;
|
|
|
- this.checkPlayout = () => {
|
|
|
- if (this.reachedPlayout(this.currentTime) && this.hls) {
|
|
|
- this.hls.trigger(Events.PLAYOUT_LIMIT_REACHED, {});
|
|
|
- }
|
|
|
- };
|
|
|
- const hls = this.hls = new HlsPlayerClass(userConfig);
|
|
|
- this.interstitial = interstitial;
|
|
|
- this.assetItem = assetItem;
|
|
|
- const detailsLoaded = () => {
|
|
|
- this.hasDetails = true;
|
|
|
- };
|
|
|
- hls.once(Events.LEVEL_LOADED, detailsLoaded);
|
|
|
- hls.once(Events.AUDIO_TRACK_LOADED, detailsLoaded);
|
|
|
- hls.once(Events.SUBTITLE_TRACK_LOADED, detailsLoaded);
|
|
|
- hls.on(Events.MEDIA_ATTACHING, (name, {
|
|
|
- media
|
|
|
- }) => {
|
|
|
- this.removeMediaListeners();
|
|
|
- this.mediaAttached = media;
|
|
|
- const event = this.interstitial;
|
|
|
- if (event.playoutLimit) {
|
|
|
- media.addEventListener("timeupdate", this.checkPlayout);
|
|
|
- if (this.appendInPlace) {
|
|
|
- hls.on(Events.BUFFER_APPENDED, () => {
|
|
|
- const bufferedEnd = this.bufferedEnd;
|
|
|
- if (this.reachedPlayout(bufferedEnd)) {
|
|
|
- this._bufferedEosTime = bufferedEnd;
|
|
|
- hls.trigger(Events.BUFFERED_TO_END, void 0);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- get appendInPlace() {
|
|
|
- return this.interstitial.appendInPlace;
|
|
|
- }
|
|
|
- loadSource() {
|
|
|
- const hls = this.hls;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!hls.url) {
|
|
|
- let uri = this.assetItem.uri;
|
|
|
- try {
|
|
|
- uri = getInterstitialUrl(uri, hls.config.primarySessionId || "").href;
|
|
|
- } catch (error) {
|
|
|
- }
|
|
|
- hls.loadSource(uri);
|
|
|
- } else if (hls.levels.length && !hls.started) {
|
|
|
- hls.startLoad(-1, true);
|
|
|
- }
|
|
|
- }
|
|
|
- bufferedInPlaceToEnd(media) {
|
|
|
- var _this$hls;
|
|
|
- if (!this.appendInPlace) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if ((_this$hls = this.hls) != null && _this$hls.bufferedToEnd) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (!media) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const duration = Math.min(this._bufferedEosTime || Infinity, this.duration);
|
|
|
- const start = this.timelineOffset;
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(media, start, 0);
|
|
|
- const bufferedEnd = this.getAssetTime(bufferInfo.end);
|
|
|
- return bufferedEnd >= duration - 0.02;
|
|
|
- }
|
|
|
- reachedPlayout(time) {
|
|
|
- const interstitial = this.interstitial;
|
|
|
- const playoutLimit = interstitial.playoutLimit;
|
|
|
- return this.startOffset + time >= playoutLimit;
|
|
|
- }
|
|
|
- get destroyed() {
|
|
|
- var _this$hls2;
|
|
|
- return !((_this$hls2 = this.hls) != null && _this$hls2.userConfig);
|
|
|
- }
|
|
|
- get assetId() {
|
|
|
- return this.assetItem.identifier;
|
|
|
- }
|
|
|
- get interstitialId() {
|
|
|
- return this.assetItem.parentIdentifier;
|
|
|
- }
|
|
|
- get media() {
|
|
|
- var _this$hls3;
|
|
|
- return ((_this$hls3 = this.hls) == null ? void 0 : _this$hls3.media) || null;
|
|
|
- }
|
|
|
- get bufferedEnd() {
|
|
|
- const media = this.media || this.mediaAttached;
|
|
|
- if (!media) {
|
|
|
- if (this._bufferedEosTime) {
|
|
|
- return this._bufferedEosTime;
|
|
|
- }
|
|
|
- return this.currentTime;
|
|
|
- }
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(media, media.currentTime, 1e-3);
|
|
|
- return this.getAssetTime(bufferInfo.end);
|
|
|
- }
|
|
|
- get currentTime() {
|
|
|
- const media = this.media || this.mediaAttached;
|
|
|
- if (!media) {
|
|
|
- return this._currentTime || 0;
|
|
|
- }
|
|
|
- return this.getAssetTime(media.currentTime);
|
|
|
- }
|
|
|
- get duration() {
|
|
|
- const duration = this.assetItem.duration;
|
|
|
- if (!duration) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const playoutLimit = this.interstitial.playoutLimit;
|
|
|
- if (playoutLimit) {
|
|
|
- const assetPlayout = playoutLimit - this.startOffset;
|
|
|
- if (assetPlayout > 0 && assetPlayout < duration) {
|
|
|
- return assetPlayout;
|
|
|
- }
|
|
|
- }
|
|
|
- return duration;
|
|
|
- }
|
|
|
- get remaining() {
|
|
|
- const duration = this.duration;
|
|
|
- if (!duration) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- return Math.max(0, duration - this.currentTime);
|
|
|
- }
|
|
|
- get startOffset() {
|
|
|
- return this.assetItem.startOffset;
|
|
|
- }
|
|
|
- get timelineOffset() {
|
|
|
- var _this$hls4;
|
|
|
- return ((_this$hls4 = this.hls) == null ? void 0 : _this$hls4.config.timelineOffset) || 0;
|
|
|
- }
|
|
|
- set timelineOffset(value) {
|
|
|
- const timelineOffset = this.timelineOffset;
|
|
|
- if (value !== timelineOffset) {
|
|
|
- const diff = value - timelineOffset;
|
|
|
- if (Math.abs(diff) > 1 / 9e4 && this.hls) {
|
|
|
- if (this.hasDetails) {
|
|
|
- throw new Error(`Cannot set timelineOffset after playlists are loaded`);
|
|
|
- }
|
|
|
- this.hls.config.timelineOffset = value;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- getAssetTime(time) {
|
|
|
- const timelineOffset = this.timelineOffset;
|
|
|
- const duration = this.duration;
|
|
|
- return Math.min(Math.max(0, time - timelineOffset), duration);
|
|
|
- }
|
|
|
- removeMediaListeners() {
|
|
|
- const media = this.mediaAttached;
|
|
|
- if (media) {
|
|
|
- this._currentTime = media.currentTime;
|
|
|
- this.bufferSnapShot();
|
|
|
- media.removeEventListener("timeupdate", this.checkPlayout);
|
|
|
- }
|
|
|
- }
|
|
|
- bufferSnapShot() {
|
|
|
- if (this.mediaAttached) {
|
|
|
- var _this$hls5;
|
|
|
- if ((_this$hls5 = this.hls) != null && _this$hls5.bufferedToEnd) {
|
|
|
- this._bufferedEosTime = this.bufferedEnd;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.removeMediaListeners();
|
|
|
- if (this.hls) {
|
|
|
- this.hls.destroy();
|
|
|
- }
|
|
|
- this.hls = null;
|
|
|
- this.tracks = this.mediaAttached = this.checkPlayout = null;
|
|
|
- }
|
|
|
- attachMedia(data) {
|
|
|
- var _this$hls6;
|
|
|
- this.loadSource();
|
|
|
- (_this$hls6 = this.hls) == null || _this$hls6.attachMedia(data);
|
|
|
- }
|
|
|
- detachMedia() {
|
|
|
- var _this$hls7;
|
|
|
- this.removeMediaListeners();
|
|
|
- this.mediaAttached = null;
|
|
|
- (_this$hls7 = this.hls) == null || _this$hls7.detachMedia();
|
|
|
- }
|
|
|
- resumeBuffering() {
|
|
|
- var _this$hls8;
|
|
|
- (_this$hls8 = this.hls) == null || _this$hls8.resumeBuffering();
|
|
|
- }
|
|
|
- pauseBuffering() {
|
|
|
- var _this$hls9;
|
|
|
- (_this$hls9 = this.hls) == null || _this$hls9.pauseBuffering();
|
|
|
- }
|
|
|
- transferMedia() {
|
|
|
- var _this$hls0;
|
|
|
- this.bufferSnapShot();
|
|
|
- return ((_this$hls0 = this.hls) == null ? void 0 : _this$hls0.transferMedia()) || null;
|
|
|
- }
|
|
|
- resetDetails() {
|
|
|
- const hls = this.hls;
|
|
|
- if (hls && this.hasDetails) {
|
|
|
- hls.stopLoad();
|
|
|
- const deleteDetails = (obj) => delete obj.details;
|
|
|
- hls.levels.forEach(deleteDetails);
|
|
|
- hls.allAudioTracks.forEach(deleteDetails);
|
|
|
- hls.allSubtitleTracks.forEach(deleteDetails);
|
|
|
- this.hasDetails = false;
|
|
|
- }
|
|
|
- }
|
|
|
- on(event, listener, context) {
|
|
|
- var _this$hls1;
|
|
|
- (_this$hls1 = this.hls) == null || _this$hls1.on(event, listener);
|
|
|
- }
|
|
|
- once(event, listener, context) {
|
|
|
- var _this$hls10;
|
|
|
- (_this$hls10 = this.hls) == null || _this$hls10.once(event, listener);
|
|
|
- }
|
|
|
- off(event, listener, context) {
|
|
|
- var _this$hls11;
|
|
|
- (_this$hls11 = this.hls) == null || _this$hls11.off(event, listener);
|
|
|
- }
|
|
|
- toString() {
|
|
|
- var _this$hls12;
|
|
|
- return `HlsAssetPlayer: ${eventAssetToString(this.assetItem)} ${(_this$hls12 = this.hls) == null ? void 0 : _this$hls12.sessionId} ${this.appendInPlace ? "append-in-place" : ""}`;
|
|
|
- }
|
|
|
-};
|
|
|
-var ABUTTING_THRESHOLD_SECONDS = 0.033;
|
|
|
-var InterstitialsSchedule = class extends Logger {
|
|
|
- constructor(onScheduleUpdate, logger2) {
|
|
|
- super("interstitials-sched", logger2);
|
|
|
- this.onScheduleUpdate = void 0;
|
|
|
- this.eventMap = {};
|
|
|
- this.events = null;
|
|
|
- this.items = null;
|
|
|
- this.durations = {
|
|
|
- primary: 0,
|
|
|
- playout: 0,
|
|
|
- integrated: 0
|
|
|
- };
|
|
|
- this.onScheduleUpdate = onScheduleUpdate;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.reset();
|
|
|
- this.onScheduleUpdate = null;
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.eventMap = {};
|
|
|
- this.setDurations(0, 0, 0);
|
|
|
- if (this.events) {
|
|
|
- this.events.forEach((interstitial) => interstitial.reset());
|
|
|
- }
|
|
|
- this.events = this.items = null;
|
|
|
- }
|
|
|
- resetErrorsInRange(start, end) {
|
|
|
- if (this.events) {
|
|
|
- return this.events.reduce((count, interstitial) => {
|
|
|
- if (start <= interstitial.startOffset && end > interstitial.startOffset) {
|
|
|
- delete interstitial.error;
|
|
|
- return count + 1;
|
|
|
- }
|
|
|
- return count;
|
|
|
- }, 0);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- get duration() {
|
|
|
- const items = this.items;
|
|
|
- return items ? items[items.length - 1].end : 0;
|
|
|
- }
|
|
|
- get length() {
|
|
|
- return this.items ? this.items.length : 0;
|
|
|
- }
|
|
|
- getEvent(identifier) {
|
|
|
- return identifier ? this.eventMap[identifier] || null : null;
|
|
|
- }
|
|
|
- hasEvent(identifier) {
|
|
|
- return identifier in this.eventMap;
|
|
|
- }
|
|
|
- findItemIndex(item, time) {
|
|
|
- if (item.event) {
|
|
|
- return this.findEventIndex(item.event.identifier);
|
|
|
- }
|
|
|
- let index = -1;
|
|
|
- if (item.nextEvent) {
|
|
|
- index = this.findEventIndex(item.nextEvent.identifier) - 1;
|
|
|
- } else if (item.previousEvent) {
|
|
|
- index = this.findEventIndex(item.previousEvent.identifier) + 1;
|
|
|
- }
|
|
|
- const items = this.items;
|
|
|
- if (items) {
|
|
|
- if (!items[index]) {
|
|
|
- if (time === void 0) {
|
|
|
- time = item.start;
|
|
|
- }
|
|
|
- index = this.findItemIndexAtTime(time);
|
|
|
- }
|
|
|
- while (index >= 0 && (_items$index = items[index]) != null && _items$index.event) {
|
|
|
- var _items$index;
|
|
|
- index--;
|
|
|
- }
|
|
|
- }
|
|
|
- return index;
|
|
|
- }
|
|
|
- findItemIndexAtTime(timelinePos, timelineType) {
|
|
|
- const items = this.items;
|
|
|
- if (items) {
|
|
|
- for (let i = 0; i < items.length; i++) {
|
|
|
- let timeRange = items[i];
|
|
|
- if (timelineType && timelineType !== "primary") {
|
|
|
- timeRange = timeRange[timelineType];
|
|
|
- }
|
|
|
- if (timelinePos === timeRange.start || timelinePos > timeRange.start && timelinePos < timeRange.end) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- findJumpRestrictedIndex(startIndex, endIndex) {
|
|
|
- const items = this.items;
|
|
|
- if (items) {
|
|
|
- for (let i = startIndex; i <= endIndex; i++) {
|
|
|
- if (!items[i]) {
|
|
|
- break;
|
|
|
- }
|
|
|
- const event = items[i].event;
|
|
|
- if (event != null && event.restrictions.jump && !event.appendInPlace) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- findEventIndex(identifier) {
|
|
|
- const items = this.items;
|
|
|
- if (items) {
|
|
|
- for (let i = items.length; i--; ) {
|
|
|
- var _items$i$event;
|
|
|
- if (((_items$i$event = items[i].event) == null ? void 0 : _items$i$event.identifier) === identifier) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- findAssetIndex(event, timelinePos) {
|
|
|
- const assetList = event.assetList;
|
|
|
- const length = assetList.length;
|
|
|
- if (length > 1) {
|
|
|
- for (let i = 0; i < length; i++) {
|
|
|
- const asset = assetList[i];
|
|
|
- if (!asset.error) {
|
|
|
- const timelineStart = asset.timelineStart;
|
|
|
- if (timelinePos === timelineStart || timelinePos > timelineStart && (timelinePos < timelineStart + (asset.duration || 0) || i === length - 1)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- get assetIdAtEnd() {
|
|
|
- var _this$items;
|
|
|
- const interstitialAtEnd = (_this$items = this.items) == null || (_this$items = _this$items[this.length - 1]) == null ? void 0 : _this$items.event;
|
|
|
- if (interstitialAtEnd) {
|
|
|
- const assetList = interstitialAtEnd.assetList;
|
|
|
- const assetAtEnd = assetList[assetList.length - 1];
|
|
|
- if (assetAtEnd) {
|
|
|
- return assetAtEnd.identifier;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- parseInterstitialDateRanges(mediaSelection, enableAppendInPlace) {
|
|
|
- const details = mediaSelection.main.details;
|
|
|
- const {
|
|
|
- dateRanges
|
|
|
- } = details;
|
|
|
- const previousInterstitialEvents = this.events;
|
|
|
- const interstitialEvents = this.parseDateRanges(dateRanges, {
|
|
|
- url: details.url
|
|
|
- }, enableAppendInPlace);
|
|
|
- const ids = Object.keys(dateRanges);
|
|
|
- const removedInterstitials = previousInterstitialEvents ? previousInterstitialEvents.filter((event) => !ids.includes(event.identifier)) : [];
|
|
|
- if (interstitialEvents.length) {
|
|
|
- interstitialEvents.sort((a, b) => {
|
|
|
- const aPre = a.cue.pre;
|
|
|
- const aPost = a.cue.post;
|
|
|
- const bPre = b.cue.pre;
|
|
|
- const bPost = b.cue.post;
|
|
|
- if (aPre && !bPre) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- if (bPre && !aPre) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- if (aPost && !bPost) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- if (bPost && !aPost) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- if (!aPre && !bPre && !aPost && !bPost) {
|
|
|
- const startA = a.startTime;
|
|
|
- const startB = b.startTime;
|
|
|
- if (startA !== startB) {
|
|
|
- return startA - startB;
|
|
|
- }
|
|
|
- }
|
|
|
- return a.dateRange.tagOrder - b.dateRange.tagOrder;
|
|
|
- });
|
|
|
- }
|
|
|
- this.events = interstitialEvents;
|
|
|
- removedInterstitials.forEach((interstitial) => {
|
|
|
- this.removeEvent(interstitial);
|
|
|
- });
|
|
|
- this.updateSchedule(mediaSelection, removedInterstitials);
|
|
|
- }
|
|
|
- updateSchedule(mediaSelection, removedInterstitials = [], forceUpdate = false) {
|
|
|
- const events = this.events || [];
|
|
|
- if (events.length || removedInterstitials.length || this.length < 2) {
|
|
|
- const currentItems = this.items;
|
|
|
- const updatedItems = this.parseSchedule(events, mediaSelection);
|
|
|
- const updated = forceUpdate || removedInterstitials.length || (currentItems == null ? void 0 : currentItems.length) !== updatedItems.length || updatedItems.some((item, i) => {
|
|
|
- return Math.abs(item.playout.start - currentItems[i].playout.start) > 5e-3 || Math.abs(item.playout.end - currentItems[i].playout.end) > 5e-3;
|
|
|
- });
|
|
|
- if (updated) {
|
|
|
- this.items = updatedItems;
|
|
|
- this.onScheduleUpdate(removedInterstitials, currentItems);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- parseDateRanges(dateRanges, baseData, enableAppendInPlace) {
|
|
|
- const interstitialEvents = [];
|
|
|
- const ids = Object.keys(dateRanges);
|
|
|
- for (let i = 0; i < ids.length; i++) {
|
|
|
- const id = ids[i];
|
|
|
- const dateRange = dateRanges[id];
|
|
|
- if (dateRange.isInterstitial) {
|
|
|
- let interstitial = this.eventMap[id];
|
|
|
- if (interstitial) {
|
|
|
- interstitial.setDateRange(dateRange);
|
|
|
- } else {
|
|
|
- interstitial = new InterstitialEvent(dateRange, baseData);
|
|
|
- this.eventMap[id] = interstitial;
|
|
|
- if (enableAppendInPlace === false) {
|
|
|
- interstitial.appendInPlace = enableAppendInPlace;
|
|
|
- }
|
|
|
- }
|
|
|
- interstitialEvents.push(interstitial);
|
|
|
- }
|
|
|
- }
|
|
|
- return interstitialEvents;
|
|
|
- }
|
|
|
- parseSchedule(interstitialEvents, mediaSelection) {
|
|
|
- const schedule = [];
|
|
|
- const details = mediaSelection.main.details;
|
|
|
- const primaryDuration = details.live ? Infinity : details.edge;
|
|
|
- let playoutDuration = 0;
|
|
|
- interstitialEvents = interstitialEvents.filter((event) => !event.error && !(event.cue.once && event.hasPlayed));
|
|
|
- if (interstitialEvents.length) {
|
|
|
- this.resolveOffsets(interstitialEvents, mediaSelection);
|
|
|
- let primaryPosition = 0;
|
|
|
- let integratedTime = 0;
|
|
|
- interstitialEvents.forEach((interstitial, i) => {
|
|
|
- const preroll = interstitial.cue.pre;
|
|
|
- const postroll = interstitial.cue.post;
|
|
|
- const previousEvent = interstitialEvents[i - 1] || null;
|
|
|
- const appendInPlace = interstitial.appendInPlace;
|
|
|
- const eventStart = postroll ? primaryDuration : interstitial.startOffset;
|
|
|
- const interstitialDuration = interstitial.duration;
|
|
|
- const timelineDuration = interstitial.timelineOccupancy === TimelineOccupancy.Range ? interstitialDuration : 0;
|
|
|
- const resumptionOffset = interstitial.resumptionOffset;
|
|
|
- const inSameStartTimeSequence = (previousEvent == null ? void 0 : previousEvent.startTime) === eventStart;
|
|
|
- const start = eventStart + interstitial.cumulativeDuration;
|
|
|
- let end = appendInPlace ? start + interstitialDuration : eventStart + resumptionOffset;
|
|
|
- if (preroll || !postroll && eventStart <= 0) {
|
|
|
- const integratedStart = integratedTime;
|
|
|
- integratedTime += timelineDuration;
|
|
|
- interstitial.timelineStart = start;
|
|
|
- const playoutStart = playoutDuration;
|
|
|
- playoutDuration += interstitialDuration;
|
|
|
- schedule.push({
|
|
|
- event: interstitial,
|
|
|
- start,
|
|
|
- end,
|
|
|
- playout: {
|
|
|
- start: playoutStart,
|
|
|
- end: playoutDuration
|
|
|
- },
|
|
|
- integrated: {
|
|
|
- start: integratedStart,
|
|
|
- end: integratedTime
|
|
|
- }
|
|
|
- });
|
|
|
- } else if (eventStart <= primaryDuration) {
|
|
|
- if (!inSameStartTimeSequence) {
|
|
|
- const segmentDuration = eventStart - primaryPosition;
|
|
|
- if (segmentDuration > ABUTTING_THRESHOLD_SECONDS) {
|
|
|
- const timelineStart = primaryPosition;
|
|
|
- const _integratedStart = integratedTime;
|
|
|
- integratedTime += segmentDuration;
|
|
|
- const _playoutStart = playoutDuration;
|
|
|
- playoutDuration += segmentDuration;
|
|
|
- const primarySegment = {
|
|
|
- previousEvent: interstitialEvents[i - 1] || null,
|
|
|
- nextEvent: interstitial,
|
|
|
- start: timelineStart,
|
|
|
- end: timelineStart + segmentDuration,
|
|
|
- playout: {
|
|
|
- start: _playoutStart,
|
|
|
- end: playoutDuration
|
|
|
- },
|
|
|
- integrated: {
|
|
|
- start: _integratedStart,
|
|
|
- end: integratedTime
|
|
|
- }
|
|
|
- };
|
|
|
- schedule.push(primarySegment);
|
|
|
- } else if (segmentDuration > 0 && previousEvent) {
|
|
|
- previousEvent.cumulativeDuration += segmentDuration;
|
|
|
- schedule[schedule.length - 1].end = eventStart;
|
|
|
- }
|
|
|
- }
|
|
|
- if (postroll) {
|
|
|
- end = start;
|
|
|
- }
|
|
|
- interstitial.timelineStart = start;
|
|
|
- const integratedStart = integratedTime;
|
|
|
- integratedTime += timelineDuration;
|
|
|
- const playoutStart = playoutDuration;
|
|
|
- playoutDuration += interstitialDuration;
|
|
|
- schedule.push({
|
|
|
- event: interstitial,
|
|
|
- start,
|
|
|
- end,
|
|
|
- playout: {
|
|
|
- start: playoutStart,
|
|
|
- end: playoutDuration
|
|
|
- },
|
|
|
- integrated: {
|
|
|
- start: integratedStart,
|
|
|
- end: integratedTime
|
|
|
- }
|
|
|
- });
|
|
|
- } else {
|
|
|
- return;
|
|
|
- }
|
|
|
- const resumeTime = interstitial.resumeTime;
|
|
|
- if (postroll || resumeTime > primaryDuration) {
|
|
|
- primaryPosition = primaryDuration;
|
|
|
- } else {
|
|
|
- primaryPosition = resumeTime;
|
|
|
- }
|
|
|
- });
|
|
|
- if (primaryPosition < primaryDuration) {
|
|
|
- var _schedule;
|
|
|
- const timelineStart = primaryPosition;
|
|
|
- const integratedStart = integratedTime;
|
|
|
- const segmentDuration = primaryDuration - primaryPosition;
|
|
|
- integratedTime += segmentDuration;
|
|
|
- const playoutStart = playoutDuration;
|
|
|
- playoutDuration += segmentDuration;
|
|
|
- schedule.push({
|
|
|
- previousEvent: ((_schedule = schedule[schedule.length - 1]) == null ? void 0 : _schedule.event) || null,
|
|
|
- nextEvent: null,
|
|
|
- start: primaryPosition,
|
|
|
- end: timelineStart + segmentDuration,
|
|
|
- playout: {
|
|
|
- start: playoutStart,
|
|
|
- end: playoutDuration
|
|
|
- },
|
|
|
- integrated: {
|
|
|
- start: integratedStart,
|
|
|
- end: integratedTime
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- this.setDurations(primaryDuration, playoutDuration, integratedTime);
|
|
|
- } else {
|
|
|
- const start = 0;
|
|
|
- schedule.push({
|
|
|
- previousEvent: null,
|
|
|
- nextEvent: null,
|
|
|
- start,
|
|
|
- end: primaryDuration,
|
|
|
- playout: {
|
|
|
- start,
|
|
|
- end: primaryDuration
|
|
|
- },
|
|
|
- integrated: {
|
|
|
- start,
|
|
|
- end: primaryDuration
|
|
|
- }
|
|
|
- });
|
|
|
- this.setDurations(primaryDuration, primaryDuration, primaryDuration);
|
|
|
- }
|
|
|
- return schedule;
|
|
|
- }
|
|
|
- setDurations(primary, playout, integrated) {
|
|
|
- this.durations = {
|
|
|
- primary,
|
|
|
- playout,
|
|
|
- integrated
|
|
|
- };
|
|
|
- }
|
|
|
- resolveOffsets(interstitialEvents, mediaSelection) {
|
|
|
- const details = mediaSelection.main.details;
|
|
|
- const primaryDuration = details.live ? Infinity : details.edge;
|
|
|
- let cumulativeDuration = 0;
|
|
|
- let lastScheduledStart = -1;
|
|
|
- interstitialEvents.forEach((interstitial, i) => {
|
|
|
- const preroll = interstitial.cue.pre;
|
|
|
- const postroll = interstitial.cue.post;
|
|
|
- const eventStart = preroll ? 0 : postroll ? primaryDuration : interstitial.startTime;
|
|
|
- this.updateAssetDurations(interstitial);
|
|
|
- const inSameStartTimeSequence = lastScheduledStart === eventStart;
|
|
|
- if (inSameStartTimeSequence) {
|
|
|
- interstitial.cumulativeDuration = cumulativeDuration;
|
|
|
- } else {
|
|
|
- cumulativeDuration = 0;
|
|
|
- lastScheduledStart = eventStart;
|
|
|
- }
|
|
|
- if (!postroll && interstitial.snapOptions.in) {
|
|
|
- interstitial.resumeAnchor = findFragmentByPTS(null, details.fragments, interstitial.startOffset + interstitial.resumptionOffset, 0, 0) || void 0;
|
|
|
- }
|
|
|
- if (interstitial.appendInPlace && !interstitial.appendInPlaceStarted) {
|
|
|
- const alignedSegmentStart = this.primaryCanResumeInPlaceAt(interstitial, mediaSelection);
|
|
|
- if (!alignedSegmentStart) {
|
|
|
- interstitial.appendInPlace = false;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!interstitial.appendInPlace && i + 1 < interstitialEvents.length) {
|
|
|
- const timeBetween = interstitialEvents[i + 1].startTime - interstitialEvents[i].resumeTime;
|
|
|
- if (timeBetween < ABUTTING_THRESHOLD_SECONDS) {
|
|
|
- interstitialEvents[i + 1].appendInPlace = false;
|
|
|
- if (interstitialEvents[i + 1].appendInPlace) {
|
|
|
- this.warn(`Could not change append strategy for abutting event ${interstitial}`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const resumeOffset = isFiniteNumber(interstitial.resumeOffset) ? interstitial.resumeOffset : interstitial.duration;
|
|
|
- cumulativeDuration += resumeOffset;
|
|
|
- });
|
|
|
- }
|
|
|
- primaryCanResumeInPlaceAt(interstitial, mediaSelection) {
|
|
|
- const resumeTime = interstitial.resumeTime;
|
|
|
- const resumesInPlaceAt = interstitial.startTime + interstitial.resumptionOffset;
|
|
|
- if (Math.abs(resumeTime - resumesInPlaceAt) > ALIGNED_END_THRESHOLD_SECONDS) {
|
|
|
- this.log(`"${interstitial.identifier}" resumption ${resumeTime} not aligned with estimated timeline end ${resumesInPlaceAt}`);
|
|
|
- return false;
|
|
|
- }
|
|
|
- const playlists = Object.keys(mediaSelection);
|
|
|
- return !playlists.some((playlistType) => {
|
|
|
- const details = mediaSelection[playlistType].details;
|
|
|
- const playlistEnd = details.edge;
|
|
|
- if (resumeTime >= playlistEnd) {
|
|
|
- this.log(`"${interstitial.identifier}" resumption ${resumeTime} past ${playlistType} playlist end ${playlistEnd}`);
|
|
|
- return false;
|
|
|
- }
|
|
|
- const startFragment = findFragmentByPTS(null, details.fragments, resumeTime);
|
|
|
- if (!startFragment) {
|
|
|
- this.log(`"${interstitial.identifier}" resumption ${resumeTime} does not align with any fragments in ${playlistType} playlist (${details.fragStart}-${details.fragmentEnd})`);
|
|
|
- return true;
|
|
|
- }
|
|
|
- const allowance = playlistType === "audio" ? 0.175 : 0;
|
|
|
- const alignedWithSegment = Math.abs(startFragment.start - resumeTime) < ALIGNED_END_THRESHOLD_SECONDS + allowance || Math.abs(startFragment.end - resumeTime) < ALIGNED_END_THRESHOLD_SECONDS + allowance;
|
|
|
- if (!alignedWithSegment) {
|
|
|
- this.log(`"${interstitial.identifier}" resumption ${resumeTime} not aligned with ${playlistType} fragment bounds (${startFragment.start}-${startFragment.end} sn: ${startFragment.sn} cc: ${startFragment.cc})`);
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- });
|
|
|
- }
|
|
|
- updateAssetDurations(interstitial) {
|
|
|
- if (!interstitial.assetListLoaded) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const eventStart = interstitial.timelineStart;
|
|
|
- let sumDuration = 0;
|
|
|
- let hasUnknownDuration = false;
|
|
|
- let hasErrors = false;
|
|
|
- for (let i = 0; i < interstitial.assetList.length; i++) {
|
|
|
- const asset = interstitial.assetList[i];
|
|
|
- const timelineStart = eventStart + sumDuration;
|
|
|
- asset.startOffset = sumDuration;
|
|
|
- asset.timelineStart = timelineStart;
|
|
|
- hasUnknownDuration || (hasUnknownDuration = asset.duration === null);
|
|
|
- hasErrors || (hasErrors = !!asset.error);
|
|
|
- const duration = asset.error ? 0 : asset.duration || 0;
|
|
|
- sumDuration += duration;
|
|
|
- }
|
|
|
- if (hasUnknownDuration && !hasErrors) {
|
|
|
- interstitial.duration = Math.max(sumDuration, interstitial.duration);
|
|
|
- } else {
|
|
|
- interstitial.duration = sumDuration;
|
|
|
- }
|
|
|
- }
|
|
|
- removeEvent(interstitial) {
|
|
|
- interstitial.reset();
|
|
|
- delete this.eventMap[interstitial.identifier];
|
|
|
- }
|
|
|
-};
|
|
|
-function segmentToString(segment) {
|
|
|
- return `[${segment.event ? '"' + segment.event.identifier + '"' : "primary"}: ${segment.start.toFixed(2)}-${segment.end.toFixed(2)}]`;
|
|
|
-}
|
|
|
-var AssetListLoader = class {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.hls = hls;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.hls = null;
|
|
|
- }
|
|
|
- loadAssetList(interstitial, hlsStartOffset) {
|
|
|
- const assetListUrl = interstitial.assetListUrl;
|
|
|
- let url;
|
|
|
- try {
|
|
|
- url = getInterstitialUrl(assetListUrl, this.hls.sessionId, interstitial.baseUrl);
|
|
|
- } catch (error) {
|
|
|
- const errorData = this.assignAssetListError(interstitial, ErrorDetails.ASSET_LIST_LOAD_ERROR, error, assetListUrl);
|
|
|
- this.hls.trigger(Events.ERROR, errorData);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (hlsStartOffset && url.protocol !== "data:") {
|
|
|
- url.searchParams.set("_HLS_start_offset", "" + hlsStartOffset);
|
|
|
- }
|
|
|
- const config = this.hls.config;
|
|
|
- const Loader = config.loader;
|
|
|
- const loader = new Loader(config);
|
|
|
- const context = {
|
|
|
- responseType: "json",
|
|
|
- url: url.href
|
|
|
- };
|
|
|
- const loadPolicy = config.interstitialAssetListLoadPolicy.default;
|
|
|
- const loaderConfig = {
|
|
|
- loadPolicy,
|
|
|
- timeout: loadPolicy.maxLoadTimeMs,
|
|
|
- maxRetry: 0,
|
|
|
- retryDelay: 0,
|
|
|
- maxRetryDelay: 0
|
|
|
- };
|
|
|
- const callbacks = {
|
|
|
- onSuccess: (response, stats, context2, networkDetails) => {
|
|
|
- const assetListResponse = response.data;
|
|
|
- const assets = assetListResponse == null ? void 0 : assetListResponse.ASSETS;
|
|
|
- if (!Array.isArray(assets)) {
|
|
|
- const errorData = this.assignAssetListError(interstitial, ErrorDetails.ASSET_LIST_PARSING_ERROR, new Error(`Invalid interstitial asset list`), context2.url, stats, networkDetails);
|
|
|
- this.hls.trigger(Events.ERROR, errorData);
|
|
|
- return;
|
|
|
- }
|
|
|
- interstitial.assetListResponse = assetListResponse;
|
|
|
- this.hls.trigger(Events.ASSET_LIST_LOADED, {
|
|
|
- event: interstitial,
|
|
|
- assetListResponse,
|
|
|
- networkDetails
|
|
|
- });
|
|
|
- },
|
|
|
- onError: (error, context2, networkDetails, stats) => {
|
|
|
- const errorData = this.assignAssetListError(interstitial, ErrorDetails.ASSET_LIST_LOAD_ERROR, new Error(`Error loading X-ASSET-LIST: HTTP status ${error.code} ${error.text} (${context2.url})`), context2.url, stats, networkDetails);
|
|
|
- this.hls.trigger(Events.ERROR, errorData);
|
|
|
- },
|
|
|
- onTimeout: (stats, context2, networkDetails) => {
|
|
|
- const errorData = this.assignAssetListError(interstitial, ErrorDetails.ASSET_LIST_LOAD_TIMEOUT, new Error(`Timeout loading X-ASSET-LIST (${context2.url})`), context2.url, stats, networkDetails);
|
|
|
- this.hls.trigger(Events.ERROR, errorData);
|
|
|
- }
|
|
|
- };
|
|
|
- loader.load(context, loaderConfig, callbacks);
|
|
|
- this.hls.trigger(Events.ASSET_LIST_LOADING, {
|
|
|
- event: interstitial
|
|
|
- });
|
|
|
- return loader;
|
|
|
- }
|
|
|
- assignAssetListError(interstitial, details, error, url, stats, networkDetails) {
|
|
|
- interstitial.error = error;
|
|
|
- return {
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details,
|
|
|
- fatal: false,
|
|
|
- interstitial,
|
|
|
- url,
|
|
|
- error,
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- };
|
|
|
- }
|
|
|
-};
|
|
|
-function playWithCatch(media) {
|
|
|
- media == null || media.play().catch(() => {
|
|
|
- });
|
|
|
-}
|
|
|
-function timelineMessage(label, time) {
|
|
|
- return `[${label}] Advancing timeline position to ${time}`;
|
|
|
-}
|
|
|
-var InterstitialsController = class extends Logger {
|
|
|
- constructor(hls, HlsPlayerClass) {
|
|
|
- super("interstitials", hls.logger);
|
|
|
- this.HlsPlayerClass = void 0;
|
|
|
- this.hls = void 0;
|
|
|
- this.assetListLoader = void 0;
|
|
|
- this.mediaSelection = null;
|
|
|
- this.altSelection = null;
|
|
|
- this.media = null;
|
|
|
- this.detachedData = null;
|
|
|
- this.requiredTracks = null;
|
|
|
- this.manager = null;
|
|
|
- this.playerQueue = [];
|
|
|
- this.bufferedPos = -1;
|
|
|
- this.timelinePos = -1;
|
|
|
- this.schedule = void 0;
|
|
|
- this.playingItem = null;
|
|
|
- this.bufferingItem = null;
|
|
|
- this.waitingItem = null;
|
|
|
- this.endedItem = null;
|
|
|
- this.playingAsset = null;
|
|
|
- this.endedAsset = null;
|
|
|
- this.bufferingAsset = null;
|
|
|
- this.shouldPlay = false;
|
|
|
- this.onPlay = () => {
|
|
|
- this.shouldPlay = true;
|
|
|
- };
|
|
|
- this.onPause = () => {
|
|
|
- this.shouldPlay = false;
|
|
|
- };
|
|
|
- this.onSeeking = () => {
|
|
|
- const currentTime = this.currentTime;
|
|
|
- if (currentTime === void 0 || this.playbackDisabled || !this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const diff = currentTime - this.timelinePos;
|
|
|
- const roundingError = Math.abs(diff) < 1 / 7056e5;
|
|
|
- if (roundingError) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const backwardSeek = diff <= -0.01;
|
|
|
- this.timelinePos = currentTime;
|
|
|
- this.bufferedPos = currentTime;
|
|
|
- const playingItem = this.playingItem;
|
|
|
- if (!playingItem) {
|
|
|
- this.checkBuffer();
|
|
|
- return;
|
|
|
- }
|
|
|
- if (backwardSeek) {
|
|
|
- const resetCount = this.schedule.resetErrorsInRange(currentTime, currentTime - diff);
|
|
|
- if (resetCount) {
|
|
|
- this.updateSchedule(true);
|
|
|
- }
|
|
|
- }
|
|
|
- this.checkBuffer();
|
|
|
- if (backwardSeek && currentTime < playingItem.start || currentTime >= playingItem.end) {
|
|
|
- var _this$media;
|
|
|
- const playingIndex = this.findItemIndex(playingItem);
|
|
|
- let scheduleIndex = this.schedule.findItemIndexAtTime(currentTime);
|
|
|
- if (scheduleIndex === -1) {
|
|
|
- scheduleIndex = playingIndex + (backwardSeek ? -1 : 1);
|
|
|
- this.log(`seeked ${backwardSeek ? "back " : ""}to position not covered by schedule ${currentTime} (resolving from ${playingIndex} to ${scheduleIndex})`);
|
|
|
- }
|
|
|
- if (!this.isInterstitial(playingItem) && (_this$media = this.media) != null && _this$media.paused) {
|
|
|
- this.shouldPlay = false;
|
|
|
- }
|
|
|
- if (!backwardSeek) {
|
|
|
- if (scheduleIndex > playingIndex) {
|
|
|
- const jumpIndex = this.schedule.findJumpRestrictedIndex(playingIndex + 1, scheduleIndex);
|
|
|
- if (jumpIndex > playingIndex) {
|
|
|
- this.setSchedulePosition(jumpIndex);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.setSchedulePosition(scheduleIndex);
|
|
|
- return;
|
|
|
- }
|
|
|
- const playingAsset = this.playingAsset;
|
|
|
- if (!playingAsset) {
|
|
|
- if (this.playingLastItem && this.isInterstitial(playingItem)) {
|
|
|
- const restartAsset = playingItem.event.assetList[0];
|
|
|
- if (restartAsset) {
|
|
|
- this.endedItem = this.playingItem;
|
|
|
- this.playingItem = null;
|
|
|
- this.setScheduleToAssetAtTime(currentTime, restartAsset);
|
|
|
- }
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- const start = playingAsset.timelineStart;
|
|
|
- const duration = playingAsset.duration || 0;
|
|
|
- if (backwardSeek && currentTime < start || currentTime >= start + duration) {
|
|
|
- var _playingItem$event;
|
|
|
- if ((_playingItem$event = playingItem.event) != null && _playingItem$event.appendInPlace) {
|
|
|
- this.clearInterstitial(playingItem.event, playingItem);
|
|
|
- this.flushFrontBuffer(currentTime);
|
|
|
- }
|
|
|
- this.setScheduleToAssetAtTime(currentTime, playingAsset);
|
|
|
- }
|
|
|
- };
|
|
|
- this.onTimeupdate = () => {
|
|
|
- const currentTime = this.currentTime;
|
|
|
- if (currentTime === void 0 || this.playbackDisabled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (currentTime > this.timelinePos) {
|
|
|
- this.timelinePos = currentTime;
|
|
|
- if (currentTime > this.bufferedPos) {
|
|
|
- this.checkBuffer();
|
|
|
- }
|
|
|
- } else {
|
|
|
- return;
|
|
|
- }
|
|
|
- const playingItem = this.playingItem;
|
|
|
- if (!playingItem || this.playingLastItem) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (currentTime >= playingItem.end) {
|
|
|
- this.timelinePos = playingItem.end;
|
|
|
- const playingIndex = this.findItemIndex(playingItem);
|
|
|
- this.setSchedulePosition(playingIndex + 1);
|
|
|
- }
|
|
|
- const playingAsset = this.playingAsset;
|
|
|
- if (!playingAsset) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const end = playingAsset.timelineStart + (playingAsset.duration || 0);
|
|
|
- if (currentTime >= end) {
|
|
|
- this.setScheduleToAssetAtTime(currentTime, playingAsset);
|
|
|
- }
|
|
|
- };
|
|
|
- this.onScheduleUpdate = (removedInterstitials, previousItems) => {
|
|
|
- const schedule = this.schedule;
|
|
|
- if (!schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const playingItem = this.playingItem;
|
|
|
- const interstitialEvents = schedule.events || [];
|
|
|
- const scheduleItems = schedule.items || [];
|
|
|
- const durations = schedule.durations;
|
|
|
- const removedIds = removedInterstitials.map((interstitial) => interstitial.identifier);
|
|
|
- const interstitialsUpdated = !!(interstitialEvents.length || removedIds.length);
|
|
|
- if (interstitialsUpdated || previousItems) {
|
|
|
- this.log(`INTERSTITIALS_UPDATED (${interstitialEvents.length}): ${interstitialEvents}
|
|
|
-Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timelinePos}`);
|
|
|
- }
|
|
|
- if (removedIds.length) {
|
|
|
- this.log(`Removed events ${removedIds}`);
|
|
|
- }
|
|
|
- let updatedPlayingItem = null;
|
|
|
- let updatedBufferingItem = null;
|
|
|
- if (playingItem) {
|
|
|
- updatedPlayingItem = this.updateItem(playingItem, this.timelinePos);
|
|
|
- if (this.itemsMatch(playingItem, updatedPlayingItem)) {
|
|
|
- this.playingItem = updatedPlayingItem;
|
|
|
- } else {
|
|
|
- this.waitingItem = this.endedItem = null;
|
|
|
- }
|
|
|
- }
|
|
|
- this.waitingItem = this.updateItem(this.waitingItem);
|
|
|
- this.endedItem = this.updateItem(this.endedItem);
|
|
|
- const bufferingItem = this.bufferingItem;
|
|
|
- if (bufferingItem) {
|
|
|
- updatedBufferingItem = this.updateItem(bufferingItem, this.bufferedPos);
|
|
|
- if (this.itemsMatch(bufferingItem, updatedBufferingItem)) {
|
|
|
- this.bufferingItem = updatedBufferingItem;
|
|
|
- } else if (bufferingItem.event) {
|
|
|
- this.bufferingItem = this.playingItem;
|
|
|
- this.clearInterstitial(bufferingItem.event, null);
|
|
|
- }
|
|
|
- }
|
|
|
- removedInterstitials.forEach((interstitial) => {
|
|
|
- interstitial.assetList.forEach((asset) => {
|
|
|
- this.clearAssetPlayer(asset.identifier, null);
|
|
|
- });
|
|
|
- });
|
|
|
- this.playerQueue.forEach((player) => {
|
|
|
- if (player.interstitial.appendInPlace) {
|
|
|
- const timelineStart = player.assetItem.timelineStart;
|
|
|
- const diff = player.timelineOffset - timelineStart;
|
|
|
- if (diff) {
|
|
|
- try {
|
|
|
- player.timelineOffset = timelineStart;
|
|
|
- } catch (e) {
|
|
|
- if (Math.abs(diff) > ALIGNED_END_THRESHOLD_SECONDS) {
|
|
|
- this.warn(`${e} ("${player.assetId}" ${player.timelineOffset}->${timelineStart})`);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- if (interstitialsUpdated || previousItems) {
|
|
|
- this.hls.trigger(Events.INTERSTITIALS_UPDATED, {
|
|
|
- events: interstitialEvents.slice(0),
|
|
|
- schedule: scheduleItems.slice(0),
|
|
|
- durations,
|
|
|
- removedIds
|
|
|
- });
|
|
|
- if (this.isInterstitial(playingItem) && removedIds.includes(playingItem.event.identifier)) {
|
|
|
- this.warn(`Interstitial "${playingItem.event.identifier}" removed while playing`);
|
|
|
- this.primaryFallback(playingItem.event);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (playingItem) {
|
|
|
- this.trimInPlace(updatedPlayingItem, playingItem);
|
|
|
- }
|
|
|
- if (bufferingItem && updatedBufferingItem !== updatedPlayingItem) {
|
|
|
- this.trimInPlace(updatedBufferingItem, bufferingItem);
|
|
|
- }
|
|
|
- this.checkBuffer();
|
|
|
- }
|
|
|
- };
|
|
|
- this.hls = hls;
|
|
|
- this.HlsPlayerClass = HlsPlayerClass;
|
|
|
- this.assetListLoader = new AssetListLoader(hls);
|
|
|
- this.schedule = new InterstitialsSchedule(this.onScheduleUpdate, hls.logger);
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- if (hls) {
|
|
|
- hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_UPDATED, this.onAudioTrackUpdated, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACK_UPDATED, this.onSubtitleTrackUpdated, this);
|
|
|
- hls.on(Events.EVENT_CUE_ENTER, this.onInterstitialCueEnter, this);
|
|
|
- hls.on(Events.ASSET_LIST_LOADED, this.onAssetListLoaded, this);
|
|
|
- hls.on(Events.BUFFER_APPENDED, this.onBufferAppended, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
|
|
|
- hls.on(Events.BUFFERED_TO_END, this.onBufferedToEnd, this);
|
|
|
- hls.on(Events.MEDIA_ENDED, this.onMediaEnded, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- hls.on(Events.DESTROYING, this.onDestroying, this);
|
|
|
- }
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const hls = this.hls;
|
|
|
- if (hls) {
|
|
|
- hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_UPDATED, this.onAudioTrackUpdated, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACK_UPDATED, this.onSubtitleTrackUpdated, this);
|
|
|
- hls.off(Events.EVENT_CUE_ENTER, this.onInterstitialCueEnter, this);
|
|
|
- hls.off(Events.ASSET_LIST_LOADED, this.onAssetListLoaded, this);
|
|
|
- hls.off(Events.BUFFER_CODECS, this.onBufferCodecs, this);
|
|
|
- hls.off(Events.BUFFER_APPENDED, this.onBufferAppended, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
|
|
|
- hls.off(Events.BUFFERED_TO_END, this.onBufferedToEnd, this);
|
|
|
- hls.off(Events.MEDIA_ENDED, this.onMediaEnded, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- hls.off(Events.DESTROYING, this.onDestroying, this);
|
|
|
- }
|
|
|
- }
|
|
|
- startLoad() {
|
|
|
- this.resumeBuffering();
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- this.pauseBuffering();
|
|
|
- }
|
|
|
- resumeBuffering() {
|
|
|
- var _this$getBufferingPla;
|
|
|
- (_this$getBufferingPla = this.getBufferingPlayer()) == null || _this$getBufferingPla.resumeBuffering();
|
|
|
- }
|
|
|
- pauseBuffering() {
|
|
|
- var _this$getBufferingPla2;
|
|
|
- (_this$getBufferingPla2 = this.getBufferingPlayer()) == null || _this$getBufferingPla2.pauseBuffering();
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.stopLoad();
|
|
|
- if (this.assetListLoader) {
|
|
|
- this.assetListLoader.destroy();
|
|
|
- }
|
|
|
- this.emptyPlayerQueue();
|
|
|
- this.clearScheduleState();
|
|
|
- if (this.schedule) {
|
|
|
- this.schedule.destroy();
|
|
|
- }
|
|
|
- this.media = this.detachedData = this.mediaSelection = this.requiredTracks = this.altSelection = this.schedule = this.manager = null;
|
|
|
- this.hls = this.HlsPlayerClass = this.log = null;
|
|
|
- this.assetListLoader = null;
|
|
|
- this.onPlay = this.onPause = this.onSeeking = this.onTimeupdate = null;
|
|
|
- this.onScheduleUpdate = null;
|
|
|
- }
|
|
|
- onDestroying() {
|
|
|
- const media = this.primaryMedia || this.media;
|
|
|
- if (media) {
|
|
|
- this.removeMediaListeners(media);
|
|
|
- }
|
|
|
- }
|
|
|
- removeMediaListeners(media) {
|
|
|
- removeEventListener(media, "play", this.onPlay);
|
|
|
- removeEventListener(media, "pause", this.onPause);
|
|
|
- removeEventListener(media, "seeking", this.onSeeking);
|
|
|
- removeEventListener(media, "timeupdate", this.onTimeupdate);
|
|
|
- }
|
|
|
- onMediaAttaching(event, data) {
|
|
|
- const media = this.media = data.media;
|
|
|
- addEventListener(media, "seeking", this.onSeeking);
|
|
|
- addEventListener(media, "timeupdate", this.onTimeupdate);
|
|
|
- addEventListener(media, "play", this.onPlay);
|
|
|
- addEventListener(media, "pause", this.onPause);
|
|
|
- }
|
|
|
- onMediaAttached(event, data) {
|
|
|
- const playingItem = this.effectivePlayingItem;
|
|
|
- const detachedMedia = this.detachedData;
|
|
|
- this.detachedData = null;
|
|
|
- if (playingItem === null) {
|
|
|
- this.checkStart();
|
|
|
- } else if (!detachedMedia) {
|
|
|
- this.clearScheduleState();
|
|
|
- const playingIndex = this.findItemIndex(playingItem);
|
|
|
- this.setSchedulePosition(playingIndex);
|
|
|
- }
|
|
|
- }
|
|
|
- clearScheduleState() {
|
|
|
- this.log(`clear schedule state`);
|
|
|
- this.playingItem = this.bufferingItem = this.waitingItem = this.endedItem = this.playingAsset = this.endedAsset = this.bufferingAsset = null;
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- const transferringMedia = !!data.transferMedia;
|
|
|
- const media = this.media;
|
|
|
- this.media = null;
|
|
|
- if (transferringMedia) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (media) {
|
|
|
- this.removeMediaListeners(media);
|
|
|
- }
|
|
|
- if (this.detachedData) {
|
|
|
- const player = this.getBufferingPlayer();
|
|
|
- if (player) {
|
|
|
- this.log(`Removing schedule state for detachedData and ${player}`);
|
|
|
- this.playingAsset = this.endedAsset = this.bufferingAsset = this.bufferingItem = this.waitingItem = this.detachedData = null;
|
|
|
- player.detachMedia();
|
|
|
- }
|
|
|
- this.shouldPlay = false;
|
|
|
- }
|
|
|
- }
|
|
|
- get interstitialsManager() {
|
|
|
- if (!this.hls) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (this.manager) {
|
|
|
- return this.manager;
|
|
|
- }
|
|
|
- const c = this;
|
|
|
- const effectiveBufferingItem = () => c.bufferingItem || c.waitingItem;
|
|
|
- const getAssetPlayer = (asset) => asset ? c.getAssetPlayer(asset.identifier) : asset;
|
|
|
- const getMappedTime = (item, timelineType, asset, controllerField, assetPlayerField) => {
|
|
|
- if (item) {
|
|
|
- let time = item[timelineType].start;
|
|
|
- const interstitial = item.event;
|
|
|
- if (interstitial) {
|
|
|
- if (timelineType === "playout" || interstitial.timelineOccupancy !== TimelineOccupancy.Point) {
|
|
|
- const assetPlayer = getAssetPlayer(asset);
|
|
|
- if ((assetPlayer == null ? void 0 : assetPlayer.interstitial) === interstitial) {
|
|
|
- time += assetPlayer.assetItem.startOffset + assetPlayer[assetPlayerField];
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- const value = controllerField === "bufferedPos" ? getBufferedEnd() : c[controllerField];
|
|
|
- time += value - item.start;
|
|
|
- }
|
|
|
- return time;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- };
|
|
|
- const findMappedTime = (primaryTime, timelineType) => {
|
|
|
- var _c$schedule;
|
|
|
- if (primaryTime !== 0 && timelineType !== "primary" && (_c$schedule = c.schedule) != null && _c$schedule.length) {
|
|
|
- var _c$schedule$items;
|
|
|
- const index = c.schedule.findItemIndexAtTime(primaryTime);
|
|
|
- const item = (_c$schedule$items = c.schedule.items) == null ? void 0 : _c$schedule$items[index];
|
|
|
- if (item) {
|
|
|
- const diff = item[timelineType].start - item.start;
|
|
|
- return primaryTime + diff;
|
|
|
- }
|
|
|
- }
|
|
|
- return primaryTime;
|
|
|
- };
|
|
|
- const getBufferedEnd = () => {
|
|
|
- const value = c.bufferedPos;
|
|
|
- if (value === Number.MAX_VALUE) {
|
|
|
- return getMappedDuration("primary");
|
|
|
- }
|
|
|
- return Math.max(value, 0);
|
|
|
- };
|
|
|
- const getMappedDuration = (timelineType) => {
|
|
|
- var _c$primaryDetails, _c$schedule2;
|
|
|
- if ((_c$primaryDetails = c.primaryDetails) != null && _c$primaryDetails.live) {
|
|
|
- return c.primaryDetails.edge;
|
|
|
- }
|
|
|
- return ((_c$schedule2 = c.schedule) == null ? void 0 : _c$schedule2.durations[timelineType]) || 0;
|
|
|
- };
|
|
|
- const seekTo = (time, timelineType) => {
|
|
|
- var _item$event, _c$schedule$items2;
|
|
|
- const item = c.effectivePlayingItem;
|
|
|
- if (item != null && (_item$event = item.event) != null && _item$event.restrictions.skip || !c.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- c.log(`seek to ${time} "${timelineType}"`);
|
|
|
- const playingItem = c.effectivePlayingItem;
|
|
|
- const targetIndex = c.schedule.findItemIndexAtTime(time, timelineType);
|
|
|
- const targetItem = (_c$schedule$items2 = c.schedule.items) == null ? void 0 : _c$schedule$items2[targetIndex];
|
|
|
- const bufferingPlayer = c.getBufferingPlayer();
|
|
|
- const bufferingInterstitial = bufferingPlayer == null ? void 0 : bufferingPlayer.interstitial;
|
|
|
- const appendInPlace = bufferingInterstitial == null ? void 0 : bufferingInterstitial.appendInPlace;
|
|
|
- const seekInItem = playingItem && c.itemsMatch(playingItem, targetItem);
|
|
|
- if (playingItem && (appendInPlace || seekInItem)) {
|
|
|
- const assetPlayer = getAssetPlayer(c.playingAsset);
|
|
|
- const media = (assetPlayer == null ? void 0 : assetPlayer.media) || c.primaryMedia;
|
|
|
- if (media) {
|
|
|
- const currentTime = timelineType === "primary" ? media.currentTime : getMappedTime(playingItem, timelineType, c.playingAsset, "timelinePos", "currentTime");
|
|
|
- const diff = time - currentTime;
|
|
|
- const seekToTime = (appendInPlace ? currentTime : media.currentTime) + diff;
|
|
|
- if (seekToTime >= 0 && (!assetPlayer || appendInPlace || seekToTime <= assetPlayer.duration)) {
|
|
|
- media.currentTime = seekToTime;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (targetItem) {
|
|
|
- let seekToTime = time;
|
|
|
- if (timelineType !== "primary") {
|
|
|
- const primarySegmentStart = targetItem[timelineType].start;
|
|
|
- const diff = time - primarySegmentStart;
|
|
|
- seekToTime = targetItem.start + diff;
|
|
|
- }
|
|
|
- const targetIsPrimary = !c.isInterstitial(targetItem);
|
|
|
- if ((!c.isInterstitial(playingItem) || playingItem.event.appendInPlace) && (targetIsPrimary || targetItem.event.appendInPlace)) {
|
|
|
- const media = c.media || (appendInPlace ? bufferingPlayer == null ? void 0 : bufferingPlayer.media : null);
|
|
|
- if (media) {
|
|
|
- media.currentTime = seekToTime;
|
|
|
- }
|
|
|
- } else if (playingItem) {
|
|
|
- const playingIndex = c.findItemIndex(playingItem);
|
|
|
- if (targetIndex > playingIndex) {
|
|
|
- const jumpIndex = c.schedule.findJumpRestrictedIndex(playingIndex + 1, targetIndex);
|
|
|
- if (jumpIndex > playingIndex) {
|
|
|
- c.setSchedulePosition(jumpIndex);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- let assetIndex = 0;
|
|
|
- if (targetIsPrimary) {
|
|
|
- c.timelinePos = seekToTime;
|
|
|
- c.checkBuffer();
|
|
|
- } else {
|
|
|
- const assetList = targetItem.event.assetList;
|
|
|
- const eventTime = time - (targetItem[timelineType] || targetItem).start;
|
|
|
- for (let i = assetList.length; i--; ) {
|
|
|
- const asset = assetList[i];
|
|
|
- if (asset.duration && eventTime >= asset.startOffset && eventTime < asset.startOffset + asset.duration) {
|
|
|
- assetIndex = i;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- c.setSchedulePosition(targetIndex, assetIndex);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- const getActiveInterstitial = () => {
|
|
|
- const playingItem = c.effectivePlayingItem;
|
|
|
- if (c.isInterstitial(playingItem)) {
|
|
|
- return playingItem;
|
|
|
- }
|
|
|
- const bufferingItem = effectiveBufferingItem();
|
|
|
- if (c.isInterstitial(bufferingItem)) {
|
|
|
- return bufferingItem;
|
|
|
- }
|
|
|
- return null;
|
|
|
- };
|
|
|
- const interstitialPlayer = {
|
|
|
- get bufferedEnd() {
|
|
|
- const interstitialItem = effectiveBufferingItem();
|
|
|
- const bufferingItem = c.bufferingItem;
|
|
|
- if (bufferingItem && bufferingItem === interstitialItem) {
|
|
|
- var _c$bufferingAsset;
|
|
|
- return getMappedTime(bufferingItem, "playout", c.bufferingAsset, "bufferedPos", "bufferedEnd") - bufferingItem.playout.start || ((_c$bufferingAsset = c.bufferingAsset) == null ? void 0 : _c$bufferingAsset.startOffset) || 0;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- },
|
|
|
- get currentTime() {
|
|
|
- const interstitialItem = getActiveInterstitial();
|
|
|
- const playingItem = c.effectivePlayingItem;
|
|
|
- if (playingItem && playingItem === interstitialItem) {
|
|
|
- return getMappedTime(playingItem, "playout", c.effectivePlayingAsset, "timelinePos", "currentTime") - playingItem.playout.start;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- },
|
|
|
- set currentTime(time) {
|
|
|
- const interstitialItem = getActiveInterstitial();
|
|
|
- const playingItem = c.effectivePlayingItem;
|
|
|
- if (playingItem && playingItem === interstitialItem) {
|
|
|
- seekTo(time + playingItem.playout.start, "playout");
|
|
|
- }
|
|
|
- },
|
|
|
- get duration() {
|
|
|
- const interstitialItem = getActiveInterstitial();
|
|
|
- if (interstitialItem) {
|
|
|
- return interstitialItem.playout.end - interstitialItem.playout.start;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- },
|
|
|
- get assetPlayers() {
|
|
|
- var _getActiveInterstitia;
|
|
|
- const assetList = (_getActiveInterstitia = getActiveInterstitial()) == null ? void 0 : _getActiveInterstitia.event.assetList;
|
|
|
- if (assetList) {
|
|
|
- return assetList.map((asset) => c.getAssetPlayer(asset.identifier));
|
|
|
- }
|
|
|
- return [];
|
|
|
- },
|
|
|
- get playingIndex() {
|
|
|
- var _getActiveInterstitia2;
|
|
|
- const interstitial = (_getActiveInterstitia2 = getActiveInterstitial()) == null ? void 0 : _getActiveInterstitia2.event;
|
|
|
- if (interstitial && c.effectivePlayingAsset) {
|
|
|
- return interstitial.findAssetIndex(c.effectivePlayingAsset);
|
|
|
- }
|
|
|
- return -1;
|
|
|
- },
|
|
|
- get scheduleItem() {
|
|
|
- return getActiveInterstitial();
|
|
|
- }
|
|
|
- };
|
|
|
- return this.manager = {
|
|
|
- get events() {
|
|
|
- var _c$schedule3;
|
|
|
- return ((_c$schedule3 = c.schedule) == null || (_c$schedule3 = _c$schedule3.events) == null ? void 0 : _c$schedule3.slice(0)) || [];
|
|
|
- },
|
|
|
- get schedule() {
|
|
|
- var _c$schedule4;
|
|
|
- return ((_c$schedule4 = c.schedule) == null || (_c$schedule4 = _c$schedule4.items) == null ? void 0 : _c$schedule4.slice(0)) || [];
|
|
|
- },
|
|
|
- get interstitialPlayer() {
|
|
|
- if (getActiveInterstitial()) {
|
|
|
- return interstitialPlayer;
|
|
|
- }
|
|
|
- return null;
|
|
|
- },
|
|
|
- get playerQueue() {
|
|
|
- return c.playerQueue.slice(0);
|
|
|
- },
|
|
|
- get bufferingAsset() {
|
|
|
- return c.bufferingAsset;
|
|
|
- },
|
|
|
- get bufferingItem() {
|
|
|
- return effectiveBufferingItem();
|
|
|
- },
|
|
|
- get bufferingIndex() {
|
|
|
- const item = effectiveBufferingItem();
|
|
|
- return c.findItemIndex(item);
|
|
|
- },
|
|
|
- get playingAsset() {
|
|
|
- return c.effectivePlayingAsset;
|
|
|
- },
|
|
|
- get playingItem() {
|
|
|
- return c.effectivePlayingItem;
|
|
|
- },
|
|
|
- get playingIndex() {
|
|
|
- const item = c.effectivePlayingItem;
|
|
|
- return c.findItemIndex(item);
|
|
|
- },
|
|
|
- primary: {
|
|
|
- get bufferedEnd() {
|
|
|
- return getBufferedEnd();
|
|
|
- },
|
|
|
- get currentTime() {
|
|
|
- const timelinePos = c.timelinePos;
|
|
|
- return timelinePos > 0 ? timelinePos : 0;
|
|
|
- },
|
|
|
- set currentTime(time) {
|
|
|
- seekTo(time, "primary");
|
|
|
- },
|
|
|
- get duration() {
|
|
|
- return getMappedDuration("primary");
|
|
|
- },
|
|
|
- get seekableStart() {
|
|
|
- var _c$primaryDetails2;
|
|
|
- return ((_c$primaryDetails2 = c.primaryDetails) == null ? void 0 : _c$primaryDetails2.fragmentStart) || 0;
|
|
|
- }
|
|
|
- },
|
|
|
- integrated: {
|
|
|
- get bufferedEnd() {
|
|
|
- return getMappedTime(effectiveBufferingItem(), "integrated", c.bufferingAsset, "bufferedPos", "bufferedEnd");
|
|
|
- },
|
|
|
- get currentTime() {
|
|
|
- return getMappedTime(c.effectivePlayingItem, "integrated", c.effectivePlayingAsset, "timelinePos", "currentTime");
|
|
|
- },
|
|
|
- set currentTime(time) {
|
|
|
- seekTo(time, "integrated");
|
|
|
- },
|
|
|
- get duration() {
|
|
|
- return getMappedDuration("integrated");
|
|
|
- },
|
|
|
- get seekableStart() {
|
|
|
- var _c$primaryDetails3;
|
|
|
- return findMappedTime(((_c$primaryDetails3 = c.primaryDetails) == null ? void 0 : _c$primaryDetails3.fragmentStart) || 0, "integrated");
|
|
|
- }
|
|
|
- },
|
|
|
- skip: () => {
|
|
|
- const item = c.effectivePlayingItem;
|
|
|
- const event = item == null ? void 0 : item.event;
|
|
|
- if (event && !event.restrictions.skip) {
|
|
|
- const index = c.findItemIndex(item);
|
|
|
- if (event.appendInPlace) {
|
|
|
- const time = item.playout.start + item.event.duration;
|
|
|
- seekTo(time + 1e-3, "playout");
|
|
|
- } else {
|
|
|
- c.advanceAfterAssetEnded(event, index, Infinity);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
- // Schedule getters
|
|
|
- get effectivePlayingItem() {
|
|
|
- return this.waitingItem || this.playingItem || this.endedItem;
|
|
|
- }
|
|
|
- get effectivePlayingAsset() {
|
|
|
- return this.playingAsset || this.endedAsset;
|
|
|
- }
|
|
|
- get playingLastItem() {
|
|
|
- var _this$schedule;
|
|
|
- const playingItem = this.playingItem;
|
|
|
- const items = (_this$schedule = this.schedule) == null ? void 0 : _this$schedule.items;
|
|
|
- if (!this.playbackStarted || !playingItem || !items) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return this.findItemIndex(playingItem) === items.length - 1;
|
|
|
- }
|
|
|
- get playbackStarted() {
|
|
|
- return this.effectivePlayingItem !== null;
|
|
|
- }
|
|
|
- // Media getters and event callbacks
|
|
|
- get currentTime() {
|
|
|
- var _this$bufferingItem, _media;
|
|
|
- if (this.mediaSelection === null) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- const queuedForPlayback = this.waitingItem || this.playingItem;
|
|
|
- if (this.isInterstitial(queuedForPlayback) && !queuedForPlayback.event.appendInPlace) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- let media = this.media;
|
|
|
- if (!media && (_this$bufferingItem = this.bufferingItem) != null && (_this$bufferingItem = _this$bufferingItem.event) != null && _this$bufferingItem.appendInPlace) {
|
|
|
- media = this.primaryMedia;
|
|
|
- }
|
|
|
- const currentTime = (_media = media) == null ? void 0 : _media.currentTime;
|
|
|
- if (currentTime === void 0 || !isFiniteNumber(currentTime)) {
|
|
|
- return void 0;
|
|
|
- }
|
|
|
- return currentTime;
|
|
|
- }
|
|
|
- get primaryMedia() {
|
|
|
- var _this$detachedData;
|
|
|
- return this.media || ((_this$detachedData = this.detachedData) == null ? void 0 : _this$detachedData.media) || null;
|
|
|
- }
|
|
|
- isInterstitial(item) {
|
|
|
- return !!(item != null && item.event);
|
|
|
- }
|
|
|
- retreiveMediaSource(assetId, toSegment) {
|
|
|
- const player = this.getAssetPlayer(assetId);
|
|
|
- if (player) {
|
|
|
- this.transferMediaFromPlayer(player, toSegment);
|
|
|
- }
|
|
|
- }
|
|
|
- transferMediaFromPlayer(player, toSegment) {
|
|
|
- const appendInPlace = player.interstitial.appendInPlace;
|
|
|
- const playerMedia = player.media;
|
|
|
- if (appendInPlace && playerMedia === this.primaryMedia) {
|
|
|
- this.bufferingAsset = null;
|
|
|
- if (!toSegment || this.isInterstitial(toSegment) && !toSegment.event.appendInPlace) {
|
|
|
- if (toSegment && playerMedia) {
|
|
|
- this.detachedData = {
|
|
|
- media: playerMedia
|
|
|
- };
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const attachMediaSourceData = player.transferMedia();
|
|
|
- this.log(`transfer MediaSource from ${player} ${stringify(attachMediaSourceData)}`);
|
|
|
- this.detachedData = attachMediaSourceData;
|
|
|
- } else if (toSegment && playerMedia) {
|
|
|
- this.shouldPlay || (this.shouldPlay = !playerMedia.paused);
|
|
|
- }
|
|
|
- }
|
|
|
- transferMediaTo(player, media) {
|
|
|
- var _this$detachedData2, _attachMediaSourceDat;
|
|
|
- if (player.media === media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let attachMediaSourceData = null;
|
|
|
- const primaryPlayer = this.hls;
|
|
|
- const isAssetPlayer = player !== primaryPlayer;
|
|
|
- const appendInPlace = isAssetPlayer && player.interstitial.appendInPlace;
|
|
|
- const detachedMediaSource = (_this$detachedData2 = this.detachedData) == null ? void 0 : _this$detachedData2.mediaSource;
|
|
|
- let logFromSource;
|
|
|
- if (primaryPlayer.media) {
|
|
|
- if (appendInPlace) {
|
|
|
- attachMediaSourceData = primaryPlayer.transferMedia();
|
|
|
- this.detachedData = attachMediaSourceData;
|
|
|
- }
|
|
|
- logFromSource = `Primary`;
|
|
|
- } else if (detachedMediaSource) {
|
|
|
- const bufferingPlayer = this.getBufferingPlayer();
|
|
|
- if (bufferingPlayer) {
|
|
|
- attachMediaSourceData = bufferingPlayer.transferMedia();
|
|
|
- logFromSource = `${bufferingPlayer}`;
|
|
|
- } else {
|
|
|
- logFromSource = `detached MediaSource`;
|
|
|
- }
|
|
|
- } else {
|
|
|
- logFromSource = `detached media`;
|
|
|
- }
|
|
|
- if (!attachMediaSourceData) {
|
|
|
- if (detachedMediaSource) {
|
|
|
- attachMediaSourceData = this.detachedData;
|
|
|
- this.log(`using detachedData: MediaSource ${stringify(attachMediaSourceData)}`);
|
|
|
- } else if (!this.detachedData || primaryPlayer.media === media) {
|
|
|
- const playerQueue = this.playerQueue;
|
|
|
- if (playerQueue.length > 1) {
|
|
|
- playerQueue.forEach((queuedPlayer) => {
|
|
|
- if (isAssetPlayer && queuedPlayer.interstitial.appendInPlace !== appendInPlace) {
|
|
|
- const interstitial = queuedPlayer.interstitial;
|
|
|
- this.clearInterstitial(queuedPlayer.interstitial, null);
|
|
|
- interstitial.appendInPlace = false;
|
|
|
- if (interstitial.appendInPlace) {
|
|
|
- this.warn(`Could not change append strategy for queued assets ${interstitial}`);
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- this.hls.detachMedia();
|
|
|
- this.detachedData = {
|
|
|
- media
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- const transferring = attachMediaSourceData && "mediaSource" in attachMediaSourceData && ((_attachMediaSourceDat = attachMediaSourceData.mediaSource) == null ? void 0 : _attachMediaSourceDat.readyState) !== "closed";
|
|
|
- const dataToAttach = transferring && attachMediaSourceData ? attachMediaSourceData : media;
|
|
|
- this.log(`${transferring ? "transfering MediaSource" : "attaching media"} to ${isAssetPlayer ? player : "Primary"} from ${logFromSource} (media.currentTime: ${media.currentTime})`);
|
|
|
- const schedule = this.schedule;
|
|
|
- if (dataToAttach === attachMediaSourceData && schedule) {
|
|
|
- const isAssetAtEndOfSchedule = isAssetPlayer && player.assetId === schedule.assetIdAtEnd;
|
|
|
- dataToAttach.overrides = {
|
|
|
- duration: schedule.duration,
|
|
|
- endOfStream: !isAssetPlayer || isAssetAtEndOfSchedule,
|
|
|
- cueRemoval: !isAssetPlayer
|
|
|
- };
|
|
|
- }
|
|
|
- player.attachMedia(dataToAttach);
|
|
|
- }
|
|
|
- onInterstitialCueEnter() {
|
|
|
- this.onTimeupdate();
|
|
|
- }
|
|
|
- // Scheduling methods
|
|
|
- checkStart() {
|
|
|
- const schedule = this.schedule;
|
|
|
- const interstitialEvents = schedule == null ? void 0 : schedule.events;
|
|
|
- if (!interstitialEvents || this.playbackDisabled || !this.media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.bufferedPos === -1) {
|
|
|
- this.bufferedPos = 0;
|
|
|
- }
|
|
|
- const timelinePos = this.timelinePos;
|
|
|
- const effectivePlayingItem = this.effectivePlayingItem;
|
|
|
- if (timelinePos === -1) {
|
|
|
- const startPosition = this.hls.startPosition;
|
|
|
- this.log(timelineMessage("checkStart", startPosition));
|
|
|
- this.timelinePos = startPosition;
|
|
|
- if (interstitialEvents.length && interstitialEvents[0].cue.pre) {
|
|
|
- const index = schedule.findEventIndex(interstitialEvents[0].identifier);
|
|
|
- this.setSchedulePosition(index);
|
|
|
- } else if (startPosition >= 0 || !this.primaryLive) {
|
|
|
- const start = this.timelinePos = startPosition > 0 ? startPosition : 0;
|
|
|
- const index = schedule.findItemIndexAtTime(start);
|
|
|
- this.setSchedulePosition(index);
|
|
|
- }
|
|
|
- } else if (effectivePlayingItem && !this.playingItem) {
|
|
|
- const index = schedule.findItemIndex(effectivePlayingItem);
|
|
|
- this.setSchedulePosition(index);
|
|
|
- }
|
|
|
- }
|
|
|
- advanceAssetBuffering(item, assetItem) {
|
|
|
- const interstitial = item.event;
|
|
|
- const assetListIndex = interstitial.findAssetIndex(assetItem);
|
|
|
- const nextAssetIndex = getNextAssetIndex(interstitial, assetListIndex);
|
|
|
- if (!interstitial.isAssetPastPlayoutLimit(nextAssetIndex)) {
|
|
|
- this.bufferedToEvent(item, nextAssetIndex);
|
|
|
- } else if (this.schedule) {
|
|
|
- var _this$schedule$items;
|
|
|
- const nextItem = (_this$schedule$items = this.schedule.items) == null ? void 0 : _this$schedule$items[this.findItemIndex(item) + 1];
|
|
|
- if (nextItem) {
|
|
|
- this.bufferedToItem(nextItem);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- advanceAfterAssetEnded(interstitial, index, assetListIndex) {
|
|
|
- const nextAssetIndex = getNextAssetIndex(interstitial, assetListIndex);
|
|
|
- if (!interstitial.isAssetPastPlayoutLimit(nextAssetIndex)) {
|
|
|
- if (interstitial.appendInPlace) {
|
|
|
- const assetItem = interstitial.assetList[nextAssetIndex];
|
|
|
- if (assetItem) {
|
|
|
- this.advanceInPlace(assetItem.timelineStart);
|
|
|
- }
|
|
|
- }
|
|
|
- this.setSchedulePosition(index, nextAssetIndex);
|
|
|
- } else if (this.schedule) {
|
|
|
- const scheduleItems = this.schedule.items;
|
|
|
- if (scheduleItems) {
|
|
|
- const nextIndex = index + 1;
|
|
|
- const scheduleLength = scheduleItems.length;
|
|
|
- if (nextIndex >= scheduleLength) {
|
|
|
- this.setSchedulePosition(-1);
|
|
|
- return;
|
|
|
- }
|
|
|
- const resumptionTime = interstitial.resumeTime;
|
|
|
- if (this.timelinePos < resumptionTime) {
|
|
|
- this.log(timelineMessage("advanceAfterAssetEnded", resumptionTime));
|
|
|
- this.timelinePos = resumptionTime;
|
|
|
- if (interstitial.appendInPlace) {
|
|
|
- this.advanceInPlace(resumptionTime);
|
|
|
- }
|
|
|
- this.checkBuffer(this.bufferedPos < resumptionTime);
|
|
|
- }
|
|
|
- this.setSchedulePosition(nextIndex);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- setScheduleToAssetAtTime(time, playingAsset) {
|
|
|
- const schedule = this.schedule;
|
|
|
- if (!schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const parentIdentifier = playingAsset.parentIdentifier;
|
|
|
- const interstitial = schedule.getEvent(parentIdentifier);
|
|
|
- if (interstitial) {
|
|
|
- const itemIndex = schedule.findEventIndex(parentIdentifier);
|
|
|
- const assetListIndex = schedule.findAssetIndex(interstitial, time);
|
|
|
- this.advanceAfterAssetEnded(interstitial, itemIndex, assetListIndex - 1);
|
|
|
- }
|
|
|
- }
|
|
|
- setSchedulePosition(index, assetListIndex) {
|
|
|
- var _this$schedule2;
|
|
|
- const scheduleItems = (_this$schedule2 = this.schedule) == null ? void 0 : _this$schedule2.items;
|
|
|
- if (!scheduleItems || this.playbackDisabled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const scheduledItem = index >= 0 ? scheduleItems[index] : null;
|
|
|
- this.log(`setSchedulePosition ${index}, ${assetListIndex} (${scheduledItem ? segmentToString(scheduledItem) : scheduledItem}) pos: ${this.timelinePos}`);
|
|
|
- const currentItem = this.waitingItem || this.playingItem;
|
|
|
- const playingLastItem = this.playingLastItem;
|
|
|
- if (this.isInterstitial(currentItem)) {
|
|
|
- const interstitial = currentItem.event;
|
|
|
- const playingAsset = this.playingAsset;
|
|
|
- const assetId = playingAsset == null ? void 0 : playingAsset.identifier;
|
|
|
- const player = assetId ? this.getAssetPlayer(assetId) : null;
|
|
|
- if (player && assetId && (!this.eventItemsMatch(currentItem, scheduledItem) || assetListIndex !== void 0 && assetId !== interstitial.assetList[assetListIndex].identifier)) {
|
|
|
- var _this$detachedData3;
|
|
|
- const playingAssetListIndex = interstitial.findAssetIndex(playingAsset);
|
|
|
- this.log(`INTERSTITIAL_ASSET_ENDED ${playingAssetListIndex + 1}/${interstitial.assetList.length} ${eventAssetToString(playingAsset)}`);
|
|
|
- this.endedAsset = playingAsset;
|
|
|
- this.playingAsset = null;
|
|
|
- this.hls.trigger(Events.INTERSTITIAL_ASSET_ENDED, {
|
|
|
- asset: playingAsset,
|
|
|
- assetListIndex: playingAssetListIndex,
|
|
|
- event: interstitial,
|
|
|
- schedule: scheduleItems.slice(0),
|
|
|
- scheduleIndex: index,
|
|
|
- player
|
|
|
- });
|
|
|
- if (currentItem !== this.playingItem) {
|
|
|
- if (this.itemsMatch(currentItem, this.playingItem) && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
|
|
|
- !this.playingAsset) {
|
|
|
- this.advanceAfterAssetEnded(interstitial, this.findItemIndex(this.playingItem), playingAssetListIndex);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- this.retreiveMediaSource(assetId, scheduledItem);
|
|
|
- if (player.media && !((_this$detachedData3 = this.detachedData) != null && _this$detachedData3.mediaSource)) {
|
|
|
- player.detachMedia();
|
|
|
- }
|
|
|
- }
|
|
|
- if (!this.eventItemsMatch(currentItem, scheduledItem)) {
|
|
|
- this.endedItem = currentItem;
|
|
|
- this.playingItem = null;
|
|
|
- this.log(`INTERSTITIAL_ENDED ${interstitial} ${segmentToString(currentItem)}`);
|
|
|
- interstitial.hasPlayed = true;
|
|
|
- this.hls.trigger(Events.INTERSTITIAL_ENDED, {
|
|
|
- event: interstitial,
|
|
|
- schedule: scheduleItems.slice(0),
|
|
|
- scheduleIndex: index
|
|
|
- });
|
|
|
- if (interstitial.cue.once) {
|
|
|
- var _this$schedule3;
|
|
|
- this.updateSchedule();
|
|
|
- const updatedScheduleItems = (_this$schedule3 = this.schedule) == null ? void 0 : _this$schedule3.items;
|
|
|
- if (scheduledItem && updatedScheduleItems) {
|
|
|
- const updatedIndex = this.findItemIndex(scheduledItem);
|
|
|
- this.advanceSchedule(updatedIndex, updatedScheduleItems, assetListIndex, currentItem, playingLastItem);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.advanceSchedule(index, scheduleItems, assetListIndex, currentItem, playingLastItem);
|
|
|
- }
|
|
|
- advanceSchedule(index, scheduleItems, assetListIndex, currentItem, playedLastItem) {
|
|
|
- const schedule = this.schedule;
|
|
|
- if (!schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const scheduledItem = scheduleItems[index] || null;
|
|
|
- const media = this.primaryMedia;
|
|
|
- const playerQueue = this.playerQueue;
|
|
|
- if (playerQueue.length) {
|
|
|
- playerQueue.forEach((player) => {
|
|
|
- const interstitial = player.interstitial;
|
|
|
- const queuedIndex = schedule.findEventIndex(interstitial.identifier);
|
|
|
- if (queuedIndex < index || queuedIndex > index + 1) {
|
|
|
- this.clearInterstitial(interstitial, scheduledItem);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- if (this.isInterstitial(scheduledItem)) {
|
|
|
- this.timelinePos = Math.min(Math.max(this.timelinePos, scheduledItem.start), scheduledItem.end);
|
|
|
- const interstitial = scheduledItem.event;
|
|
|
- if (assetListIndex === void 0) {
|
|
|
- assetListIndex = schedule.findAssetIndex(interstitial, this.timelinePos);
|
|
|
- const assetIndexCandidate = getNextAssetIndex(interstitial, assetListIndex - 1);
|
|
|
- if (interstitial.isAssetPastPlayoutLimit(assetIndexCandidate) || interstitial.appendInPlace && this.timelinePos === scheduledItem.end) {
|
|
|
- this.advanceAfterAssetEnded(interstitial, index, assetListIndex);
|
|
|
- return;
|
|
|
- }
|
|
|
- assetListIndex = assetIndexCandidate;
|
|
|
- }
|
|
|
- const waitingItem = this.waitingItem;
|
|
|
- if (!this.assetsBuffered(scheduledItem, media)) {
|
|
|
- this.setBufferingItem(scheduledItem);
|
|
|
- }
|
|
|
- let player = this.preloadAssets(interstitial, assetListIndex);
|
|
|
- if (!this.eventItemsMatch(scheduledItem, waitingItem || currentItem)) {
|
|
|
- this.waitingItem = scheduledItem;
|
|
|
- this.log(`INTERSTITIAL_STARTED ${segmentToString(scheduledItem)} ${interstitial.appendInPlace ? "append in place" : ""}`);
|
|
|
- this.hls.trigger(Events.INTERSTITIAL_STARTED, {
|
|
|
- event: interstitial,
|
|
|
- schedule: scheduleItems.slice(0),
|
|
|
- scheduleIndex: index
|
|
|
- });
|
|
|
- }
|
|
|
- if (!interstitial.assetListLoaded) {
|
|
|
- this.log(`Waiting for ASSET-LIST to complete loading ${interstitial}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (interstitial.assetListLoader) {
|
|
|
- interstitial.assetListLoader.destroy();
|
|
|
- interstitial.assetListLoader = void 0;
|
|
|
- }
|
|
|
- if (!media) {
|
|
|
- this.log(`Waiting for attachMedia to start Interstitial ${interstitial}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.waitingItem = this.endedItem = null;
|
|
|
- this.playingItem = scheduledItem;
|
|
|
- const assetItem = interstitial.assetList[assetListIndex];
|
|
|
- if (!assetItem) {
|
|
|
- this.advanceAfterAssetEnded(interstitial, index, assetListIndex || 0);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!player) {
|
|
|
- player = this.getAssetPlayer(assetItem.identifier);
|
|
|
- }
|
|
|
- if (player === null || player.destroyed) {
|
|
|
- const assetListLength = interstitial.assetList.length;
|
|
|
- this.warn(`asset ${assetListIndex + 1}/${assetListLength} player destroyed ${interstitial}`);
|
|
|
- player = this.createAssetPlayer(interstitial, assetItem, assetListIndex);
|
|
|
- player.loadSource();
|
|
|
- }
|
|
|
- if (!this.eventItemsMatch(scheduledItem, this.bufferingItem)) {
|
|
|
- if (interstitial.appendInPlace && this.isAssetBuffered(assetItem)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.startAssetPlayer(player, assetListIndex, scheduleItems, index, media);
|
|
|
- if (this.shouldPlay) {
|
|
|
- playWithCatch(player.media);
|
|
|
- }
|
|
|
- } else if (scheduledItem) {
|
|
|
- this.resumePrimary(scheduledItem, index, currentItem);
|
|
|
- if (this.shouldPlay) {
|
|
|
- playWithCatch(this.hls.media);
|
|
|
- }
|
|
|
- } else if (playedLastItem && this.isInterstitial(currentItem)) {
|
|
|
- this.endedItem = null;
|
|
|
- this.playingItem = currentItem;
|
|
|
- if (!currentItem.event.appendInPlace) {
|
|
|
- this.attachPrimary(schedule.durations.primary, null);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- get playbackDisabled() {
|
|
|
- return this.hls.config.enableInterstitialPlayback === false;
|
|
|
- }
|
|
|
- get primaryDetails() {
|
|
|
- var _this$mediaSelection;
|
|
|
- return (_this$mediaSelection = this.mediaSelection) == null ? void 0 : _this$mediaSelection.main.details;
|
|
|
- }
|
|
|
- get primaryLive() {
|
|
|
- var _this$primaryDetails;
|
|
|
- return !!((_this$primaryDetails = this.primaryDetails) != null && _this$primaryDetails.live);
|
|
|
- }
|
|
|
- resumePrimary(scheduledItem, index, fromItem) {
|
|
|
- var _this$detachedData4, _this$schedule4;
|
|
|
- this.playingItem = scheduledItem;
|
|
|
- this.playingAsset = this.endedAsset = null;
|
|
|
- this.waitingItem = this.endedItem = null;
|
|
|
- this.bufferedToItem(scheduledItem);
|
|
|
- this.log(`resuming ${segmentToString(scheduledItem)}`);
|
|
|
- if (!((_this$detachedData4 = this.detachedData) != null && _this$detachedData4.mediaSource)) {
|
|
|
- let timelinePos = this.timelinePos;
|
|
|
- if (timelinePos < scheduledItem.start || timelinePos >= scheduledItem.end) {
|
|
|
- timelinePos = this.getPrimaryResumption(scheduledItem, index);
|
|
|
- this.log(timelineMessage("resumePrimary", timelinePos));
|
|
|
- this.timelinePos = timelinePos;
|
|
|
- }
|
|
|
- this.attachPrimary(timelinePos, scheduledItem);
|
|
|
- }
|
|
|
- if (!fromItem) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const scheduleItems = (_this$schedule4 = this.schedule) == null ? void 0 : _this$schedule4.items;
|
|
|
- if (!scheduleItems) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`INTERSTITIALS_PRIMARY_RESUMED ${segmentToString(scheduledItem)}`);
|
|
|
- this.hls.trigger(Events.INTERSTITIALS_PRIMARY_RESUMED, {
|
|
|
- schedule: scheduleItems.slice(0),
|
|
|
- scheduleIndex: index
|
|
|
- });
|
|
|
- this.checkBuffer();
|
|
|
- }
|
|
|
- getPrimaryResumption(scheduledItem, index) {
|
|
|
- const itemStart = scheduledItem.start;
|
|
|
- if (this.primaryLive) {
|
|
|
- const details = this.primaryDetails;
|
|
|
- if (index === 0) {
|
|
|
- return this.hls.startPosition;
|
|
|
- } else if (details && (itemStart < details.fragmentStart || itemStart > details.edge)) {
|
|
|
- return this.hls.liveSyncPosition || -1;
|
|
|
- }
|
|
|
- }
|
|
|
- return itemStart;
|
|
|
- }
|
|
|
- isAssetBuffered(asset) {
|
|
|
- const player = this.getAssetPlayer(asset.identifier);
|
|
|
- if (player != null && player.hls) {
|
|
|
- return player.hls.bufferedToEnd;
|
|
|
- }
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(this.primaryMedia, this.timelinePos, 0);
|
|
|
- return bufferInfo.end + 1 >= asset.timelineStart + (asset.duration || 0);
|
|
|
- }
|
|
|
- attachPrimary(timelinePos, item, skipSeekToStartPosition) {
|
|
|
- if (item) {
|
|
|
- this.setBufferingItem(item);
|
|
|
- } else {
|
|
|
- this.bufferingItem = this.playingItem;
|
|
|
- }
|
|
|
- this.bufferingAsset = null;
|
|
|
- const media = this.primaryMedia;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const hls = this.hls;
|
|
|
- if (hls.media) {
|
|
|
- this.checkBuffer();
|
|
|
- } else {
|
|
|
- this.transferMediaTo(hls, media);
|
|
|
- if (skipSeekToStartPosition) {
|
|
|
- this.startLoadingPrimaryAt(timelinePos, skipSeekToStartPosition);
|
|
|
- }
|
|
|
- }
|
|
|
- if (!skipSeekToStartPosition) {
|
|
|
- this.log(timelineMessage("attachPrimary", timelinePos));
|
|
|
- this.timelinePos = timelinePos;
|
|
|
- this.startLoadingPrimaryAt(timelinePos, skipSeekToStartPosition);
|
|
|
- }
|
|
|
- }
|
|
|
- startLoadingPrimaryAt(timelinePos, skipSeekToStartPosition) {
|
|
|
- var _hls$mainForwardBuffe;
|
|
|
- const hls = this.hls;
|
|
|
- if (!hls.loadingEnabled || !hls.media || Math.abs((((_hls$mainForwardBuffe = hls.mainForwardBufferInfo) == null ? void 0 : _hls$mainForwardBuffe.start) || hls.media.currentTime) - timelinePos) > 0.5) {
|
|
|
- hls.startLoad(timelinePos, skipSeekToStartPosition);
|
|
|
- } else if (!hls.bufferingEnabled) {
|
|
|
- hls.resumeBuffering();
|
|
|
- }
|
|
|
- }
|
|
|
- // HLS.js event callbacks
|
|
|
- onManifestLoading() {
|
|
|
- var _this$schedule5;
|
|
|
- this.stopLoad();
|
|
|
- (_this$schedule5 = this.schedule) == null || _this$schedule5.reset();
|
|
|
- this.emptyPlayerQueue();
|
|
|
- this.clearScheduleState();
|
|
|
- this.shouldPlay = false;
|
|
|
- this.bufferedPos = this.timelinePos = -1;
|
|
|
- this.mediaSelection = this.altSelection = this.manager = this.requiredTracks = null;
|
|
|
- this.hls.off(Events.BUFFER_CODECS, this.onBufferCodecs, this);
|
|
|
- this.hls.on(Events.BUFFER_CODECS, this.onBufferCodecs, this);
|
|
|
- }
|
|
|
- onLevelUpdated(event, data) {
|
|
|
- if (data.level === -1 || !this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const main = this.hls.levels[data.level];
|
|
|
- if (!main.details) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentSelection = _objectSpread2(_objectSpread2({}, this.mediaSelection || this.altSelection), {}, {
|
|
|
- main
|
|
|
- });
|
|
|
- this.mediaSelection = currentSelection;
|
|
|
- this.schedule.parseInterstitialDateRanges(currentSelection, this.hls.config.interstitialAppendInPlace);
|
|
|
- if (!this.effectivePlayingItem && this.schedule.items) {
|
|
|
- this.checkStart();
|
|
|
- }
|
|
|
- }
|
|
|
- onAudioTrackUpdated(event, data) {
|
|
|
- const audio = this.hls.audioTracks[data.id];
|
|
|
- const previousSelection = this.mediaSelection;
|
|
|
- if (!previousSelection) {
|
|
|
- this.altSelection = _objectSpread2(_objectSpread2({}, this.altSelection), {}, {
|
|
|
- audio
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentSelection = _objectSpread2(_objectSpread2({}, previousSelection), {}, {
|
|
|
- audio
|
|
|
- });
|
|
|
- this.mediaSelection = currentSelection;
|
|
|
- }
|
|
|
- onSubtitleTrackUpdated(event, data) {
|
|
|
- const subtitles = this.hls.subtitleTracks[data.id];
|
|
|
- const previousSelection = this.mediaSelection;
|
|
|
- if (!previousSelection) {
|
|
|
- this.altSelection = _objectSpread2(_objectSpread2({}, this.altSelection), {}, {
|
|
|
- subtitles
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentSelection = _objectSpread2(_objectSpread2({}, previousSelection), {}, {
|
|
|
- subtitles
|
|
|
- });
|
|
|
- this.mediaSelection = currentSelection;
|
|
|
- }
|
|
|
- onAudioTrackSwitching(event, data) {
|
|
|
- const audioOption = getBasicSelectionOption(data);
|
|
|
- this.playerQueue.forEach(({
|
|
|
- hls
|
|
|
- }) => hls && (hls.setAudioOption(data) || hls.setAudioOption(audioOption)));
|
|
|
- }
|
|
|
- onSubtitleTrackSwitch(event, data) {
|
|
|
- const subtitleOption = getBasicSelectionOption(data);
|
|
|
- this.playerQueue.forEach(({
|
|
|
- hls
|
|
|
- }) => hls && (hls.setSubtitleOption(data) || data.id !== -1 && hls.setSubtitleOption(subtitleOption)));
|
|
|
- }
|
|
|
- onBufferCodecs(event, data) {
|
|
|
- const requiredTracks = data.tracks;
|
|
|
- if (requiredTracks) {
|
|
|
- this.requiredTracks = requiredTracks;
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferAppended(event, data) {
|
|
|
- this.checkBuffer();
|
|
|
- }
|
|
|
- onBufferFlushed(event, data) {
|
|
|
- const playingItem = this.playingItem;
|
|
|
- if (playingItem && !this.itemsMatch(playingItem, this.bufferingItem) && !this.isInterstitial(playingItem)) {
|
|
|
- const timelinePos = this.timelinePos;
|
|
|
- this.bufferedPos = timelinePos;
|
|
|
- this.checkBuffer();
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferedToEnd(event) {
|
|
|
- if (!this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const interstitialEvents = this.schedule.events;
|
|
|
- if (this.bufferedPos < Number.MAX_VALUE && interstitialEvents) {
|
|
|
- for (let i = 0; i < interstitialEvents.length; i++) {
|
|
|
- const interstitial = interstitialEvents[i];
|
|
|
- if (interstitial.cue.post) {
|
|
|
- var _this$schedule$items2;
|
|
|
- const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);
|
|
|
- const item = (_this$schedule$items2 = this.schedule.items) == null ? void 0 : _this$schedule$items2[scheduleIndex];
|
|
|
- if (this.isInterstitial(item) && this.eventItemsMatch(item, this.bufferingItem)) {
|
|
|
- this.bufferedToItem(item, 0);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- this.bufferedPos = Number.MAX_VALUE;
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaEnded(event) {
|
|
|
- const playingItem = this.playingItem;
|
|
|
- if (!this.playingLastItem && playingItem) {
|
|
|
- const playingIndex = this.findItemIndex(playingItem);
|
|
|
- this.setSchedulePosition(playingIndex + 1);
|
|
|
- } else {
|
|
|
- this.shouldPlay = false;
|
|
|
- }
|
|
|
- }
|
|
|
- updateItem(previousItem, time) {
|
|
|
- var _this$schedule6;
|
|
|
- const items = (_this$schedule6 = this.schedule) == null ? void 0 : _this$schedule6.items;
|
|
|
- if (previousItem && items) {
|
|
|
- const index = this.findItemIndex(previousItem, time);
|
|
|
- return items[index] || null;
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- trimInPlace(updatedItem, itemBeforeUpdate) {
|
|
|
- if (this.isInterstitial(updatedItem) && updatedItem.event.appendInPlace && itemBeforeUpdate.end - updatedItem.end > 0.25) {
|
|
|
- updatedItem.event.assetList.forEach((asset, index) => {
|
|
|
- if (updatedItem.event.isAssetPastPlayoutLimit(index)) {
|
|
|
- this.clearAssetPlayer(asset.identifier, null);
|
|
|
- }
|
|
|
- });
|
|
|
- const flushStart = updatedItem.end + 0.25;
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(this.primaryMedia, flushStart, 0);
|
|
|
- if (bufferInfo.end > flushStart || (bufferInfo.nextStart || 0) > flushStart) {
|
|
|
- this.log(`trim buffered interstitial ${segmentToString(updatedItem)} (was ${segmentToString(itemBeforeUpdate)})`);
|
|
|
- const skipSeekToStartPosition = true;
|
|
|
- this.attachPrimary(flushStart, null, skipSeekToStartPosition);
|
|
|
- this.flushFrontBuffer(flushStart);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- itemsMatch(a, b) {
|
|
|
- return !!b && (a === b || a.event && b.event && this.eventItemsMatch(a, b) || !a.event && !b.event && this.findItemIndex(a) === this.findItemIndex(b));
|
|
|
- }
|
|
|
- eventItemsMatch(a, b) {
|
|
|
- var _b$event;
|
|
|
- return !!b && (a === b || a.event.identifier === ((_b$event = b.event) == null ? void 0 : _b$event.identifier));
|
|
|
- }
|
|
|
- findItemIndex(item, time) {
|
|
|
- return item && this.schedule ? this.schedule.findItemIndex(item, time) : -1;
|
|
|
- }
|
|
|
- updateSchedule(forceUpdate = false) {
|
|
|
- var _this$schedule7;
|
|
|
- const mediaSelection = this.mediaSelection;
|
|
|
- if (!mediaSelection) {
|
|
|
- return;
|
|
|
- }
|
|
|
- (_this$schedule7 = this.schedule) == null || _this$schedule7.updateSchedule(mediaSelection, [], forceUpdate);
|
|
|
- }
|
|
|
- // Schedule buffer control
|
|
|
- checkBuffer(starved) {
|
|
|
- var _this$schedule8;
|
|
|
- const items = (_this$schedule8 = this.schedule) == null ? void 0 : _this$schedule8.items;
|
|
|
- if (!items) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(this.primaryMedia, this.timelinePos, 0);
|
|
|
- if (starved) {
|
|
|
- this.bufferedPos = this.timelinePos;
|
|
|
- }
|
|
|
- starved || (starved = bufferInfo.len < 1);
|
|
|
- this.updateBufferedPos(bufferInfo.end, items, starved);
|
|
|
- }
|
|
|
- updateBufferedPos(bufferEnd, items, bufferIsEmpty) {
|
|
|
- const schedule = this.schedule;
|
|
|
- const bufferingItem = this.bufferingItem;
|
|
|
- if (this.bufferedPos > bufferEnd || !schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (items.length === 1 && this.itemsMatch(items[0], bufferingItem)) {
|
|
|
- this.bufferedPos = bufferEnd;
|
|
|
- return;
|
|
|
- }
|
|
|
- const playingItem = this.playingItem;
|
|
|
- const playingIndex = this.findItemIndex(playingItem);
|
|
|
- let bufferEndIndex = schedule.findItemIndexAtTime(bufferEnd);
|
|
|
- if (this.bufferedPos < bufferEnd) {
|
|
|
- var _nextItemToBuffer$eve;
|
|
|
- const bufferingIndex = this.findItemIndex(bufferingItem);
|
|
|
- const nextToBufferIndex = Math.min(bufferingIndex + 1, items.length - 1);
|
|
|
- const nextItemToBuffer = items[nextToBufferIndex];
|
|
|
- if (bufferEndIndex === -1 && bufferingItem && bufferEnd >= bufferingItem.end || (_nextItemToBuffer$eve = nextItemToBuffer.event) != null && _nextItemToBuffer$eve.appendInPlace && bufferEnd + 0.01 >= nextItemToBuffer.start) {
|
|
|
- bufferEndIndex = nextToBufferIndex;
|
|
|
- }
|
|
|
- if (this.isInterstitial(bufferingItem)) {
|
|
|
- const interstitial = bufferingItem.event;
|
|
|
- if (nextToBufferIndex - playingIndex > 1 && interstitial.appendInPlace === false) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (interstitial.assetList.length === 0 && interstitial.assetListLoader) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.bufferedPos = bufferEnd;
|
|
|
- if (bufferEndIndex > bufferingIndex && bufferEndIndex > playingIndex) {
|
|
|
- this.bufferedToItem(nextItemToBuffer);
|
|
|
- } else {
|
|
|
- const details = this.primaryDetails;
|
|
|
- if (this.primaryLive && details && bufferEnd > details.edge - details.targetduration && nextItemToBuffer.start < details.edge + this.hls.config.interstitialLiveLookAhead && this.isInterstitial(nextItemToBuffer)) {
|
|
|
- this.preloadAssets(nextItemToBuffer.event, 0);
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (bufferIsEmpty && playingItem && !this.itemsMatch(playingItem, bufferingItem)) {
|
|
|
- if (bufferEndIndex === playingIndex) {
|
|
|
- this.bufferedToItem(playingItem);
|
|
|
- } else if (bufferEndIndex === playingIndex + 1) {
|
|
|
- this.bufferedToItem(items[bufferEndIndex]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- assetsBuffered(item, media) {
|
|
|
- const assetList = item.event.assetList;
|
|
|
- if (assetList.length === 0) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return !item.event.assetList.some((asset) => {
|
|
|
- const player = this.getAssetPlayer(asset.identifier);
|
|
|
- return !(player != null && player.bufferedInPlaceToEnd(media));
|
|
|
- });
|
|
|
- }
|
|
|
- setBufferingItem(item) {
|
|
|
- const bufferingLast = this.bufferingItem;
|
|
|
- const schedule = this.schedule;
|
|
|
- if (!this.itemsMatch(item, bufferingLast) && schedule) {
|
|
|
- const {
|
|
|
- items,
|
|
|
- events
|
|
|
- } = schedule;
|
|
|
- if (!items || !events) {
|
|
|
- return bufferingLast;
|
|
|
- }
|
|
|
- const isInterstitial = this.isInterstitial(item);
|
|
|
- const bufferingPlayer = this.getBufferingPlayer();
|
|
|
- this.bufferingItem = item;
|
|
|
- this.bufferedPos = Math.max(item.start, Math.min(item.end, this.timelinePos));
|
|
|
- const timeRemaining = bufferingPlayer ? bufferingPlayer.remaining : bufferingLast ? bufferingLast.end - this.timelinePos : 0;
|
|
|
- this.log(`INTERSTITIALS_BUFFERED_TO_BOUNDARY ${segmentToString(item)}` + (bufferingLast ? ` (${timeRemaining.toFixed(2)} remaining)` : ""));
|
|
|
- if (!this.playbackDisabled) {
|
|
|
- if (isInterstitial) {
|
|
|
- const bufferIndex = schedule.findAssetIndex(item.event, this.bufferedPos);
|
|
|
- item.event.assetList.forEach((asset, i) => {
|
|
|
- const player = this.getAssetPlayer(asset.identifier);
|
|
|
- if (player) {
|
|
|
- if (i === bufferIndex) {
|
|
|
- player.loadSource();
|
|
|
- }
|
|
|
- player.resumeBuffering();
|
|
|
- }
|
|
|
- });
|
|
|
- } else {
|
|
|
- this.hls.resumeBuffering();
|
|
|
- this.playerQueue.forEach((player) => player.pauseBuffering());
|
|
|
- }
|
|
|
- }
|
|
|
- this.hls.trigger(Events.INTERSTITIALS_BUFFERED_TO_BOUNDARY, {
|
|
|
- events: events.slice(0),
|
|
|
- schedule: items.slice(0),
|
|
|
- bufferingIndex: this.findItemIndex(item),
|
|
|
- playingIndex: this.findItemIndex(this.playingItem)
|
|
|
- });
|
|
|
- } else if (this.bufferingItem !== item) {
|
|
|
- this.bufferingItem = item;
|
|
|
- }
|
|
|
- return bufferingLast;
|
|
|
- }
|
|
|
- bufferedToItem(item, assetListIndex = 0) {
|
|
|
- const bufferingLast = this.setBufferingItem(item);
|
|
|
- if (this.playbackDisabled) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.isInterstitial(item)) {
|
|
|
- this.bufferedToEvent(item, assetListIndex);
|
|
|
- } else if (bufferingLast !== null) {
|
|
|
- this.bufferingAsset = null;
|
|
|
- const detachedData = this.detachedData;
|
|
|
- if (detachedData) {
|
|
|
- if (detachedData.mediaSource) {
|
|
|
- const skipSeekToStartPosition = true;
|
|
|
- this.attachPrimary(item.start, item, skipSeekToStartPosition);
|
|
|
- } else {
|
|
|
- this.preloadPrimary(item);
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.preloadPrimary(item);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- preloadPrimary(item) {
|
|
|
- const index = this.findItemIndex(item);
|
|
|
- const timelinePos = this.getPrimaryResumption(item, index);
|
|
|
- this.startLoadingPrimaryAt(timelinePos);
|
|
|
- }
|
|
|
- bufferedToEvent(item, assetListIndex) {
|
|
|
- const interstitial = item.event;
|
|
|
- const neverLoaded = interstitial.assetList.length === 0 && !interstitial.assetListLoader;
|
|
|
- const playOnce = interstitial.cue.once;
|
|
|
- if (neverLoaded || !playOnce) {
|
|
|
- const player = this.preloadAssets(interstitial, assetListIndex);
|
|
|
- if (player != null && player.interstitial.appendInPlace) {
|
|
|
- const media = this.primaryMedia;
|
|
|
- if (media) {
|
|
|
- this.bufferAssetPlayer(player, media);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- preloadAssets(interstitial, assetListIndex) {
|
|
|
- const uri = interstitial.assetUrl;
|
|
|
- const assetListLength = interstitial.assetList.length;
|
|
|
- const neverLoaded = assetListLength === 0 && !interstitial.assetListLoader;
|
|
|
- const playOnce = interstitial.cue.once;
|
|
|
- if (neverLoaded) {
|
|
|
- const timelineStart = interstitial.timelineStart;
|
|
|
- if (interstitial.appendInPlace) {
|
|
|
- var _playingItem$nextEven;
|
|
|
- const playingItem = this.playingItem;
|
|
|
- if (!this.isInterstitial(playingItem) && (playingItem == null || (_playingItem$nextEven = playingItem.nextEvent) == null ? void 0 : _playingItem$nextEven.identifier) === interstitial.identifier) {
|
|
|
- this.flushFrontBuffer(timelineStart + 0.25);
|
|
|
- }
|
|
|
- }
|
|
|
- let hlsStartOffset;
|
|
|
- let liveStartPosition = 0;
|
|
|
- if (!this.playingItem && this.primaryLive) {
|
|
|
- liveStartPosition = this.hls.startPosition;
|
|
|
- if (liveStartPosition === -1) {
|
|
|
- liveStartPosition = this.hls.liveSyncPosition || 0;
|
|
|
- }
|
|
|
- }
|
|
|
- if (liveStartPosition && !(interstitial.cue.pre || interstitial.cue.post)) {
|
|
|
- const startOffset = liveStartPosition - timelineStart;
|
|
|
- if (startOffset > 0) {
|
|
|
- hlsStartOffset = Math.round(startOffset * 1e3) / 1e3;
|
|
|
- }
|
|
|
- }
|
|
|
- this.log(`Load interstitial asset ${assetListIndex + 1}/${uri ? 1 : assetListLength} ${interstitial}${hlsStartOffset ? ` live-start: ${liveStartPosition} start-offset: ${hlsStartOffset}` : ""}`);
|
|
|
- if (uri) {
|
|
|
- return this.createAsset(interstitial, 0, 0, timelineStart, interstitial.duration, uri);
|
|
|
- }
|
|
|
- const assetListLoader = this.assetListLoader.loadAssetList(interstitial, hlsStartOffset);
|
|
|
- if (assetListLoader) {
|
|
|
- interstitial.assetListLoader = assetListLoader;
|
|
|
- }
|
|
|
- } else if (!playOnce && assetListLength) {
|
|
|
- for (let i = assetListIndex; i < assetListLength; i++) {
|
|
|
- const _asset = interstitial.assetList[i];
|
|
|
- const playerIndex = this.getAssetPlayerQueueIndex(_asset.identifier);
|
|
|
- if ((playerIndex === -1 || this.playerQueue[playerIndex].destroyed) && !_asset.error) {
|
|
|
- this.createAssetPlayer(interstitial, _asset, i);
|
|
|
- }
|
|
|
- }
|
|
|
- const asset = interstitial.assetList[assetListIndex];
|
|
|
- if (asset) {
|
|
|
- const player = this.getAssetPlayer(asset.identifier);
|
|
|
- if (player) {
|
|
|
- player.loadSource();
|
|
|
- }
|
|
|
- return player;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- flushFrontBuffer(startOffset) {
|
|
|
- const requiredTracks = this.requiredTracks;
|
|
|
- if (!requiredTracks) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Removing front buffer starting at ${startOffset}`);
|
|
|
- const sourceBufferNames = Object.keys(requiredTracks);
|
|
|
- sourceBufferNames.forEach((type) => {
|
|
|
- this.hls.trigger(Events.BUFFER_FLUSHING, {
|
|
|
- startOffset,
|
|
|
- endOffset: Infinity,
|
|
|
- type
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- // Interstitial Asset Player control
|
|
|
- getAssetPlayerQueueIndex(assetId) {
|
|
|
- const playerQueue = this.playerQueue;
|
|
|
- for (let i = 0; i < playerQueue.length; i++) {
|
|
|
- if (assetId === playerQueue[i].assetId) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- getAssetPlayer(assetId) {
|
|
|
- const index = this.getAssetPlayerQueueIndex(assetId);
|
|
|
- return this.playerQueue[index] || null;
|
|
|
- }
|
|
|
- getBufferingPlayer() {
|
|
|
- const {
|
|
|
- playerQueue,
|
|
|
- primaryMedia
|
|
|
- } = this;
|
|
|
- if (primaryMedia) {
|
|
|
- for (let i = 0; i < playerQueue.length; i++) {
|
|
|
- if (playerQueue[i].media === primaryMedia) {
|
|
|
- return playerQueue[i];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- createAsset(interstitial, assetListIndex, startOffset, timelineStart, duration, uri) {
|
|
|
- const assetItem = {
|
|
|
- parentIdentifier: interstitial.identifier,
|
|
|
- identifier: generateAssetIdentifier(interstitial, uri, assetListIndex),
|
|
|
- duration,
|
|
|
- startOffset,
|
|
|
- timelineStart,
|
|
|
- uri
|
|
|
- };
|
|
|
- return this.createAssetPlayer(interstitial, assetItem, assetListIndex);
|
|
|
- }
|
|
|
- createAssetPlayer(interstitial, assetItem, assetListIndex) {
|
|
|
- const primary = this.hls;
|
|
|
- const userConfig = primary.userConfig;
|
|
|
- let videoPreference = userConfig.videoPreference;
|
|
|
- const currentLevel = primary.loadLevelObj || primary.levels[primary.currentLevel];
|
|
|
- if (videoPreference || currentLevel) {
|
|
|
- videoPreference = _extends({}, videoPreference);
|
|
|
- if (currentLevel.videoCodec) {
|
|
|
- videoPreference.videoCodec = currentLevel.videoCodec;
|
|
|
- }
|
|
|
- if (currentLevel.videoRange) {
|
|
|
- videoPreference.allowedVideoRanges = [currentLevel.videoRange];
|
|
|
- }
|
|
|
- }
|
|
|
- const selectedAudio = primary.audioTracks[primary.audioTrack];
|
|
|
- const selectedSubtitle = primary.subtitleTracks[primary.subtitleTrack];
|
|
|
- let startPosition = 0;
|
|
|
- if (this.primaryLive || interstitial.appendInPlace) {
|
|
|
- const timePastStart = this.timelinePos - assetItem.timelineStart;
|
|
|
- if (timePastStart > 1) {
|
|
|
- const duration = assetItem.duration;
|
|
|
- if (duration && timePastStart < duration) {
|
|
|
- startPosition = timePastStart;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const assetId = assetItem.identifier;
|
|
|
- const playerConfig = _objectSpread2(_objectSpread2({}, userConfig), {}, {
|
|
|
- maxMaxBufferLength: Math.min(180, primary.config.maxMaxBufferLength),
|
|
|
- autoStartLoad: true,
|
|
|
- startFragPrefetch: true,
|
|
|
- primarySessionId: primary.sessionId,
|
|
|
- assetPlayerId: assetId,
|
|
|
- abrEwmaDefaultEstimate: primary.bandwidthEstimate,
|
|
|
- interstitialsController: void 0,
|
|
|
- startPosition,
|
|
|
- liveDurationInfinity: false,
|
|
|
- testBandwidth: false,
|
|
|
- videoPreference,
|
|
|
- audioPreference: selectedAudio || userConfig.audioPreference,
|
|
|
- subtitlePreference: selectedSubtitle || userConfig.subtitlePreference
|
|
|
- });
|
|
|
- if (interstitial.appendInPlace) {
|
|
|
- interstitial.appendInPlaceStarted = true;
|
|
|
- if (assetItem.timelineStart) {
|
|
|
- playerConfig.timelineOffset = assetItem.timelineStart;
|
|
|
- }
|
|
|
- }
|
|
|
- const cmcd = playerConfig.cmcd;
|
|
|
- if (cmcd != null && cmcd.sessionId && cmcd.contentId) {
|
|
|
- playerConfig.cmcd = _extends({}, cmcd, {
|
|
|
- contentId: hash(assetItem.uri)
|
|
|
- });
|
|
|
- }
|
|
|
- if (this.getAssetPlayer(assetId)) {
|
|
|
- this.warn(`Duplicate date range identifier ${interstitial} and asset ${assetId}`);
|
|
|
- }
|
|
|
- const player = new HlsAssetPlayer(this.HlsPlayerClass, playerConfig, interstitial, assetItem);
|
|
|
- this.playerQueue.push(player);
|
|
|
- interstitial.assetList[assetListIndex] = assetItem;
|
|
|
- let initialDuration = true;
|
|
|
- const updateAssetPlayerDetails = (details) => {
|
|
|
- if (details.live) {
|
|
|
- var _this$schedule9;
|
|
|
- const error = new Error(`Interstitials MUST be VOD assets ${interstitial}`);
|
|
|
- const errorData = {
|
|
|
- fatal: true,
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.INTERSTITIAL_ASSET_ITEM_ERROR,
|
|
|
- error
|
|
|
- };
|
|
|
- const scheduleIndex = ((_this$schedule9 = this.schedule) == null ? void 0 : _this$schedule9.findEventIndex(interstitial.identifier)) || -1;
|
|
|
- this.handleAssetItemError(errorData, interstitial, scheduleIndex, assetListIndex, error.message);
|
|
|
- return;
|
|
|
- }
|
|
|
- const duration = details.edge - details.fragmentStart;
|
|
|
- const currentAssetDuration = assetItem.duration;
|
|
|
- if (initialDuration || currentAssetDuration === null || duration > currentAssetDuration) {
|
|
|
- initialDuration = false;
|
|
|
- this.log(`Interstitial asset "${assetId}" duration change ${currentAssetDuration} > ${duration}`);
|
|
|
- assetItem.duration = duration;
|
|
|
- this.updateSchedule();
|
|
|
- }
|
|
|
- };
|
|
|
- player.on(Events.LEVEL_UPDATED, (event, {
|
|
|
- details
|
|
|
- }) => updateAssetPlayerDetails(details));
|
|
|
- player.on(Events.LEVEL_PTS_UPDATED, (event, {
|
|
|
- details
|
|
|
- }) => updateAssetPlayerDetails(details));
|
|
|
- player.on(Events.EVENT_CUE_ENTER, () => this.onInterstitialCueEnter());
|
|
|
- const onBufferCodecs = (event, data) => {
|
|
|
- const inQueuPlayer = this.getAssetPlayer(assetId);
|
|
|
- if (inQueuPlayer && data.tracks) {
|
|
|
- inQueuPlayer.off(Events.BUFFER_CODECS, onBufferCodecs);
|
|
|
- inQueuPlayer.tracks = data.tracks;
|
|
|
- const media = this.primaryMedia;
|
|
|
- if (this.bufferingAsset === inQueuPlayer.assetItem && media && !inQueuPlayer.media) {
|
|
|
- this.bufferAssetPlayer(inQueuPlayer, media);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- player.on(Events.BUFFER_CODECS, onBufferCodecs);
|
|
|
- const bufferedToEnd = () => {
|
|
|
- var _this$schedule$items3;
|
|
|
- const inQueuPlayer = this.getAssetPlayer(assetId);
|
|
|
- this.log(`buffered to end of asset ${inQueuPlayer}`);
|
|
|
- if (!inQueuPlayer || !this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);
|
|
|
- const item = (_this$schedule$items3 = this.schedule.items) == null ? void 0 : _this$schedule$items3[scheduleIndex];
|
|
|
- if (this.isInterstitial(item)) {
|
|
|
- this.advanceAssetBuffering(item, assetItem);
|
|
|
- }
|
|
|
- };
|
|
|
- player.on(Events.BUFFERED_TO_END, bufferedToEnd);
|
|
|
- const endedWithAssetIndex = (assetIndex) => {
|
|
|
- return () => {
|
|
|
- const inQueuPlayer = this.getAssetPlayer(assetId);
|
|
|
- if (!inQueuPlayer || !this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.shouldPlay = true;
|
|
|
- const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);
|
|
|
- this.advanceAfterAssetEnded(interstitial, scheduleIndex, assetIndex);
|
|
|
- };
|
|
|
- };
|
|
|
- player.once(Events.MEDIA_ENDED, endedWithAssetIndex(assetListIndex));
|
|
|
- player.once(Events.PLAYOUT_LIMIT_REACHED, endedWithAssetIndex(Infinity));
|
|
|
- player.on(Events.ERROR, (event, data) => {
|
|
|
- if (!this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const inQueuPlayer = this.getAssetPlayer(assetId);
|
|
|
- if (data.details === ErrorDetails.BUFFER_STALLED_ERROR) {
|
|
|
- if (inQueuPlayer != null && inQueuPlayer.appendInPlace) {
|
|
|
- this.handleInPlaceStall(interstitial);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.onTimeupdate();
|
|
|
- this.checkBuffer(true);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.handleAssetItemError(data, interstitial, this.schedule.findEventIndex(interstitial.identifier), assetListIndex, `Asset player error ${data.error} ${interstitial}`);
|
|
|
- });
|
|
|
- player.on(Events.DESTROYING, () => {
|
|
|
- const inQueuPlayer = this.getAssetPlayer(assetId);
|
|
|
- if (!inQueuPlayer || !this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const error = new Error(`Asset player destroyed unexpectedly ${assetId}`);
|
|
|
- const errorData = {
|
|
|
- fatal: true,
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.INTERSTITIAL_ASSET_ITEM_ERROR,
|
|
|
- error
|
|
|
- };
|
|
|
- this.handleAssetItemError(errorData, interstitial, this.schedule.findEventIndex(interstitial.identifier), assetListIndex, error.message);
|
|
|
- });
|
|
|
- this.log(`INTERSTITIAL_ASSET_PLAYER_CREATED ${eventAssetToString(assetItem)}`);
|
|
|
- this.hls.trigger(Events.INTERSTITIAL_ASSET_PLAYER_CREATED, {
|
|
|
- asset: assetItem,
|
|
|
- assetListIndex,
|
|
|
- event: interstitial,
|
|
|
- player
|
|
|
- });
|
|
|
- return player;
|
|
|
- }
|
|
|
- clearInterstitial(interstitial, toSegment) {
|
|
|
- interstitial.assetList.forEach((asset) => {
|
|
|
- this.clearAssetPlayer(asset.identifier, toSegment);
|
|
|
- });
|
|
|
- interstitial.reset();
|
|
|
- }
|
|
|
- resetAssetPlayer(assetId) {
|
|
|
- const playerIndex = this.getAssetPlayerQueueIndex(assetId);
|
|
|
- if (playerIndex !== -1) {
|
|
|
- this.log(`reset asset player "${assetId}" after error`);
|
|
|
- const player = this.playerQueue[playerIndex];
|
|
|
- this.transferMediaFromPlayer(player, null);
|
|
|
- player.resetDetails();
|
|
|
- }
|
|
|
- }
|
|
|
- clearAssetPlayer(assetId, toSegment) {
|
|
|
- const playerIndex = this.getAssetPlayerQueueIndex(assetId);
|
|
|
- if (playerIndex !== -1) {
|
|
|
- const player = this.playerQueue[playerIndex];
|
|
|
- this.log(`clear ${player} toSegment: ${toSegment ? segmentToString(toSegment) : toSegment}`);
|
|
|
- this.transferMediaFromPlayer(player, toSegment);
|
|
|
- this.playerQueue.splice(playerIndex, 1);
|
|
|
- player.destroy();
|
|
|
- }
|
|
|
- }
|
|
|
- emptyPlayerQueue() {
|
|
|
- let player;
|
|
|
- while (player = this.playerQueue.pop()) {
|
|
|
- player.destroy();
|
|
|
- }
|
|
|
- this.playerQueue = [];
|
|
|
- }
|
|
|
- startAssetPlayer(player, assetListIndex, scheduleItems, scheduleIndex, media) {
|
|
|
- const {
|
|
|
- interstitial,
|
|
|
- assetItem,
|
|
|
- assetId
|
|
|
- } = player;
|
|
|
- const assetListLength = interstitial.assetList.length;
|
|
|
- const playingAsset = this.playingAsset;
|
|
|
- this.endedAsset = null;
|
|
|
- this.playingAsset = assetItem;
|
|
|
- if (!playingAsset || playingAsset.identifier !== assetId) {
|
|
|
- if (playingAsset) {
|
|
|
- this.clearAssetPlayer(playingAsset.identifier, scheduleItems[scheduleIndex]);
|
|
|
- delete playingAsset.error;
|
|
|
- }
|
|
|
- this.log(`INTERSTITIAL_ASSET_STARTED ${assetListIndex + 1}/${assetListLength} ${eventAssetToString(assetItem)}`);
|
|
|
- this.hls.trigger(Events.INTERSTITIAL_ASSET_STARTED, {
|
|
|
- asset: assetItem,
|
|
|
- assetListIndex,
|
|
|
- event: interstitial,
|
|
|
- schedule: scheduleItems.slice(0),
|
|
|
- scheduleIndex,
|
|
|
- player
|
|
|
- });
|
|
|
- }
|
|
|
- this.bufferAssetPlayer(player, media);
|
|
|
- }
|
|
|
- bufferAssetPlayer(player, media) {
|
|
|
- var _this$schedule$items4, _this$detachedData5;
|
|
|
- if (!this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- interstitial,
|
|
|
- assetItem
|
|
|
- } = player;
|
|
|
- const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);
|
|
|
- const item = (_this$schedule$items4 = this.schedule.items) == null ? void 0 : _this$schedule$items4[scheduleIndex];
|
|
|
- if (!item) {
|
|
|
- return;
|
|
|
- }
|
|
|
- player.loadSource();
|
|
|
- this.setBufferingItem(item);
|
|
|
- this.bufferingAsset = assetItem;
|
|
|
- const bufferingPlayer = this.getBufferingPlayer();
|
|
|
- if (bufferingPlayer === player) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const appendInPlaceNext = interstitial.appendInPlace;
|
|
|
- if (appendInPlaceNext && (bufferingPlayer == null ? void 0 : bufferingPlayer.interstitial.appendInPlace) === false) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const activeTracks = (bufferingPlayer == null ? void 0 : bufferingPlayer.tracks) || ((_this$detachedData5 = this.detachedData) == null ? void 0 : _this$detachedData5.tracks) || this.requiredTracks;
|
|
|
- if (appendInPlaceNext && assetItem !== this.playingAsset) {
|
|
|
- if (!player.tracks) {
|
|
|
- this.log(`Waiting for track info before buffering ${player}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (activeTracks && !isCompatibleTrackChange(activeTracks, player.tracks)) {
|
|
|
- const error = new Error(`Asset ${eventAssetToString(assetItem)} SourceBuffer tracks ('${Object.keys(player.tracks)}') are not compatible with primary content tracks ('${Object.keys(activeTracks)}')`);
|
|
|
- const errorData = {
|
|
|
- fatal: true,
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.INTERSTITIAL_ASSET_ITEM_ERROR,
|
|
|
- error
|
|
|
- };
|
|
|
- const assetListIndex = interstitial.findAssetIndex(assetItem);
|
|
|
- this.handleAssetItemError(errorData, interstitial, scheduleIndex, assetListIndex, error.message);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.transferMediaTo(player, media);
|
|
|
- }
|
|
|
- handleInPlaceStall(interstitial) {
|
|
|
- const schedule = this.schedule;
|
|
|
- const media = this.primaryMedia;
|
|
|
- if (!schedule || !media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentTime = media.currentTime;
|
|
|
- const foundAssetIndex = schedule.findAssetIndex(interstitial, currentTime);
|
|
|
- const stallingAsset = interstitial.assetList[foundAssetIndex];
|
|
|
- if (stallingAsset) {
|
|
|
- const player = this.getAssetPlayer(stallingAsset.identifier);
|
|
|
- if (player) {
|
|
|
- const assetCurrentTime = player.currentTime || currentTime - stallingAsset.timelineStart;
|
|
|
- const distanceFromEnd = player.duration - assetCurrentTime;
|
|
|
- this.warn(`Stalled at ${assetCurrentTime} of ${assetCurrentTime + distanceFromEnd} in ${player} ${interstitial} (media.currentTime: ${currentTime})`);
|
|
|
- if (assetCurrentTime && (distanceFromEnd / media.playbackRate < 0.5 || player.bufferedInPlaceToEnd(media)) && player.hls) {
|
|
|
- const scheduleIndex = schedule.findEventIndex(interstitial.identifier);
|
|
|
- this.advanceAfterAssetEnded(interstitial, scheduleIndex, foundAssetIndex);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- advanceInPlace(time) {
|
|
|
- const media = this.primaryMedia;
|
|
|
- if (media && media.currentTime < time) {
|
|
|
- media.currentTime = time;
|
|
|
- }
|
|
|
- }
|
|
|
- handleAssetItemError(data, interstitial, scheduleIndex, assetListIndex, errorMessage) {
|
|
|
- if (data.details === ErrorDetails.BUFFER_STALLED_ERROR) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const assetItem = interstitial.assetList[assetListIndex] || null;
|
|
|
- this.warn(`INTERSTITIAL_ASSET_ERROR ${assetItem ? eventAssetToString(assetItem) : assetItem} ${data.error}`);
|
|
|
- if (!this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const assetId = (assetItem == null ? void 0 : assetItem.identifier) || "";
|
|
|
- const playerIndex = this.getAssetPlayerQueueIndex(assetId);
|
|
|
- const player = this.playerQueue[playerIndex] || null;
|
|
|
- const items = this.schedule.items;
|
|
|
- const interstitialAssetError = _extends({}, data, {
|
|
|
- fatal: false,
|
|
|
- errorAction: createDoNothingErrorAction(true),
|
|
|
- asset: assetItem,
|
|
|
- assetListIndex,
|
|
|
- event: interstitial,
|
|
|
- schedule: items,
|
|
|
- scheduleIndex,
|
|
|
- player
|
|
|
- });
|
|
|
- this.hls.trigger(Events.INTERSTITIAL_ASSET_ERROR, interstitialAssetError);
|
|
|
- if (!data.fatal) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const playingAsset = this.playingAsset;
|
|
|
- const bufferingAsset = this.bufferingAsset;
|
|
|
- const error = new Error(errorMessage);
|
|
|
- if (assetItem) {
|
|
|
- this.clearAssetPlayer(assetId, null);
|
|
|
- assetItem.error = error;
|
|
|
- }
|
|
|
- if (!interstitial.assetList.some((asset) => !asset.error)) {
|
|
|
- interstitial.error = error;
|
|
|
- } else {
|
|
|
- for (let i = assetListIndex; i < interstitial.assetList.length; i++) {
|
|
|
- this.resetAssetPlayer(interstitial.assetList[i].identifier);
|
|
|
- }
|
|
|
- }
|
|
|
- this.updateSchedule(true);
|
|
|
- if (interstitial.error) {
|
|
|
- this.primaryFallback(interstitial);
|
|
|
- } else if (playingAsset && playingAsset.identifier === assetId) {
|
|
|
- this.advanceAfterAssetEnded(interstitial, scheduleIndex, assetListIndex);
|
|
|
- } else if (bufferingAsset && bufferingAsset.identifier === assetId && this.isInterstitial(this.bufferingItem)) {
|
|
|
- this.advanceAssetBuffering(this.bufferingItem, bufferingAsset);
|
|
|
- }
|
|
|
- }
|
|
|
- primaryFallback(interstitial) {
|
|
|
- const flushStart = interstitial.timelineStart;
|
|
|
- const playingItem = this.effectivePlayingItem;
|
|
|
- if (playingItem) {
|
|
|
- this.log(`Fallback to primary from event "${interstitial.identifier}" start: ${flushStart} pos: ${this.timelinePos} playing: ${segmentToString(playingItem)} error: ${interstitial.error}`);
|
|
|
- let timelinePos = this.timelinePos;
|
|
|
- if (timelinePos === -1) {
|
|
|
- timelinePos = this.hls.startPosition;
|
|
|
- }
|
|
|
- const newPlayingItem = this.updateItem(playingItem, timelinePos);
|
|
|
- if (this.itemsMatch(playingItem, newPlayingItem)) {
|
|
|
- this.clearInterstitial(interstitial, null);
|
|
|
- }
|
|
|
- if (interstitial.appendInPlace) {
|
|
|
- this.attachPrimary(flushStart, null);
|
|
|
- this.flushFrontBuffer(flushStart);
|
|
|
- }
|
|
|
- if (!this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const scheduleIndex = this.schedule.findItemIndexAtTime(timelinePos);
|
|
|
- this.setSchedulePosition(scheduleIndex);
|
|
|
- } else {
|
|
|
- this.checkStart();
|
|
|
- }
|
|
|
- }
|
|
|
- // Asset List loading
|
|
|
- onAssetListLoaded(event, data) {
|
|
|
- var _this$schedule0, _this$bufferingItem2;
|
|
|
- const interstitial = data.event;
|
|
|
- const interstitialId = interstitial.identifier;
|
|
|
- const assets = data.assetListResponse.ASSETS;
|
|
|
- if (!((_this$schedule0 = this.schedule) != null && _this$schedule0.hasEvent(interstitialId))) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const eventStart = interstitial.timelineStart;
|
|
|
- const previousDuration = interstitial.duration;
|
|
|
- let sumDuration = 0;
|
|
|
- assets.forEach((asset, assetListIndex) => {
|
|
|
- const duration = parseFloat(asset.DURATION);
|
|
|
- this.createAsset(interstitial, assetListIndex, sumDuration, eventStart + sumDuration, duration, asset.URI);
|
|
|
- sumDuration += duration;
|
|
|
- });
|
|
|
- interstitial.duration = sumDuration;
|
|
|
- this.log(`Loaded asset-list with duration: ${sumDuration} (was: ${previousDuration}) ${interstitial}`);
|
|
|
- const waitingItem = this.waitingItem;
|
|
|
- const waitingForItem = (waitingItem == null ? void 0 : waitingItem.event.identifier) === interstitialId;
|
|
|
- this.updateSchedule();
|
|
|
- const bufferingEvent = (_this$bufferingItem2 = this.bufferingItem) == null ? void 0 : _this$bufferingItem2.event;
|
|
|
- if (waitingForItem) {
|
|
|
- var _this$schedule$items5;
|
|
|
- const scheduleIndex = this.schedule.findEventIndex(interstitialId);
|
|
|
- const item = (_this$schedule$items5 = this.schedule.items) == null ? void 0 : _this$schedule$items5[scheduleIndex];
|
|
|
- if (item) {
|
|
|
- if (!this.playingItem && this.timelinePos > item.end) {
|
|
|
- const index = this.schedule.findItemIndexAtTime(this.timelinePos);
|
|
|
- if (index !== scheduleIndex) {
|
|
|
- interstitial.error = new Error(`Interstitial no longer within playback range ${this.timelinePos} ${interstitial}`);
|
|
|
- this.updateSchedule(true);
|
|
|
- this.primaryFallback(interstitial);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- this.setBufferingItem(item);
|
|
|
- }
|
|
|
- this.setSchedulePosition(scheduleIndex);
|
|
|
- } else if ((bufferingEvent == null ? void 0 : bufferingEvent.identifier) === interstitialId) {
|
|
|
- const assetItem = interstitial.assetList[0];
|
|
|
- if (assetItem) {
|
|
|
- const player = this.getAssetPlayer(assetItem.identifier);
|
|
|
- if (bufferingEvent.appendInPlace) {
|
|
|
- const media = this.primaryMedia;
|
|
|
- if (player && media) {
|
|
|
- this.bufferAssetPlayer(player, media);
|
|
|
- }
|
|
|
- } else if (player) {
|
|
|
- player.loadSource();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- if (!this.schedule) {
|
|
|
- return;
|
|
|
- }
|
|
|
- switch (data.details) {
|
|
|
- case ErrorDetails.ASSET_LIST_PARSING_ERROR:
|
|
|
- case ErrorDetails.ASSET_LIST_LOAD_ERROR:
|
|
|
- case ErrorDetails.ASSET_LIST_LOAD_TIMEOUT: {
|
|
|
- const interstitial = data.interstitial;
|
|
|
- if (interstitial) {
|
|
|
- this.updateSchedule(true);
|
|
|
- this.primaryFallback(interstitial);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case ErrorDetails.BUFFER_STALLED_ERROR: {
|
|
|
- const stallingItem = this.endedItem || this.waitingItem || this.playingItem;
|
|
|
- if (this.isInterstitial(stallingItem) && stallingItem.event.appendInPlace) {
|
|
|
- this.handleInPlaceStall(stallingItem.event);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Primary player stall @${this.timelinePos} bufferedPos: ${this.bufferedPos}`);
|
|
|
- this.onTimeupdate();
|
|
|
- this.checkBuffer(true);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var TICK_INTERVAL$2 = 500;
|
|
|
-var SubtitleStreamController = class extends BaseStreamController {
|
|
|
- constructor(hls, fragmentTracker, keyLoader) {
|
|
|
- super(hls, fragmentTracker, keyLoader, "subtitle-stream-controller", PlaylistLevelType.SUBTITLE);
|
|
|
- this.currentTrackId = -1;
|
|
|
- this.tracksBuffered = [];
|
|
|
- this.mainDetails = null;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- onHandlerDestroying() {
|
|
|
- this.unregisterListeners();
|
|
|
- super.onHandlerDestroying();
|
|
|
- this.mainDetails = null;
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- super.registerListeners();
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
|
|
|
- hls.on(Events.SUBTITLE_FRAG_PROCESSED, this.onSubtitleFragProcessed, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- super.unregisterListeners();
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
|
|
|
- hls.off(Events.SUBTITLE_FRAG_PROCESSED, this.onSubtitleFragProcessed, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- }
|
|
|
- startLoad(startPosition, skipSeekToStartPosition) {
|
|
|
- this.stopLoad();
|
|
|
- this.state = State.IDLE;
|
|
|
- this.setInterval(TICK_INTERVAL$2);
|
|
|
- this.nextLoadPosition = this.lastCurrentTime = startPosition + this.timelineOffset;
|
|
|
- this.startPosition = skipSeekToStartPosition ? -1 : startPosition;
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- super.onManifestLoading();
|
|
|
- this.mainDetails = null;
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- this.tracksBuffered = [];
|
|
|
- super.onMediaDetaching(event, data);
|
|
|
- }
|
|
|
- onLevelLoaded(event, data) {
|
|
|
- this.mainDetails = data.details;
|
|
|
- }
|
|
|
- onSubtitleFragProcessed(event, data) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- success
|
|
|
- } = data;
|
|
|
- if (!this.fragContextChanged(frag)) {
|
|
|
- if (isMediaFragment(frag)) {
|
|
|
- this.fragPrevious = frag;
|
|
|
- }
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- if (!success) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const buffered = this.tracksBuffered[this.currentTrackId];
|
|
|
- if (!buffered) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let timeRange;
|
|
|
- const fragStart = frag.start;
|
|
|
- for (let i = 0; i < buffered.length; i++) {
|
|
|
- if (fragStart >= buffered[i].start && fragStart <= buffered[i].end) {
|
|
|
- timeRange = buffered[i];
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- const fragEnd = frag.start + frag.duration;
|
|
|
- if (timeRange) {
|
|
|
- timeRange.end = fragEnd;
|
|
|
- } else {
|
|
|
- timeRange = {
|
|
|
- start: fragStart,
|
|
|
- end: fragEnd
|
|
|
- };
|
|
|
- buffered.push(timeRange);
|
|
|
- }
|
|
|
- this.fragmentTracker.fragBuffered(frag);
|
|
|
- this.fragBufferedComplete(frag, null);
|
|
|
- if (this.media) {
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferFlushing(event, data) {
|
|
|
- const {
|
|
|
- startOffset,
|
|
|
- endOffset
|
|
|
- } = data;
|
|
|
- if (startOffset === 0 && endOffset !== Number.POSITIVE_INFINITY) {
|
|
|
- const endOffsetSubtitles = endOffset - 1;
|
|
|
- if (endOffsetSubtitles <= 0) {
|
|
|
- return;
|
|
|
- }
|
|
|
- data.endOffsetSubtitles = Math.max(0, endOffsetSubtitles);
|
|
|
- this.tracksBuffered.forEach((buffered) => {
|
|
|
- for (let i = 0; i < buffered.length; ) {
|
|
|
- if (buffered[i].end <= endOffsetSubtitles) {
|
|
|
- buffered.shift();
|
|
|
- continue;
|
|
|
- } else if (buffered[i].start < endOffsetSubtitles) {
|
|
|
- buffered[i].start = endOffsetSubtitles;
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- i++;
|
|
|
- }
|
|
|
- });
|
|
|
- this.fragmentTracker.removeFragmentsInRange(startOffset, endOffsetSubtitles, PlaylistLevelType.SUBTITLE);
|
|
|
- }
|
|
|
- }
|
|
|
- // If something goes wrong, proceed to next frag, if we were processing one.
|
|
|
- onError(event, data) {
|
|
|
- const frag = data.frag;
|
|
|
- if ((frag == null ? void 0 : frag.type) === PlaylistLevelType.SUBTITLE) {
|
|
|
- if (data.details === ErrorDetails.FRAG_GAP) {
|
|
|
- this.fragmentTracker.fragBuffered(frag, true);
|
|
|
- }
|
|
|
- if (this.fragCurrent) {
|
|
|
- this.fragCurrent.abortRequests();
|
|
|
- }
|
|
|
- if (this.state !== State.STOPPED) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- // Got all new subtitle levels.
|
|
|
- onSubtitleTracksUpdated(event, {
|
|
|
- subtitleTracks
|
|
|
- }) {
|
|
|
- if (this.levels && subtitleOptionsIdentical(this.levels, subtitleTracks)) {
|
|
|
- this.levels = subtitleTracks.map((mediaPlaylist) => new Level(mediaPlaylist));
|
|
|
- return;
|
|
|
- }
|
|
|
- this.tracksBuffered = [];
|
|
|
- this.levels = subtitleTracks.map((mediaPlaylist) => {
|
|
|
- const level = new Level(mediaPlaylist);
|
|
|
- this.tracksBuffered[level.id] = [];
|
|
|
- return level;
|
|
|
- });
|
|
|
- this.fragmentTracker.removeFragmentsInRange(0, Number.POSITIVE_INFINITY, PlaylistLevelType.SUBTITLE);
|
|
|
- this.fragPrevious = null;
|
|
|
- this.mediaBuffer = null;
|
|
|
- }
|
|
|
- onSubtitleTrackSwitch(event, data) {
|
|
|
- var _this$levels;
|
|
|
- this.currentTrackId = data.id;
|
|
|
- if (!((_this$levels = this.levels) != null && _this$levels.length) || this.currentTrackId === -1) {
|
|
|
- this.clearInterval();
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentTrack = this.levels[this.currentTrackId];
|
|
|
- if (currentTrack != null && currentTrack.details) {
|
|
|
- this.mediaBuffer = this.mediaBufferTimeRanges;
|
|
|
- } else {
|
|
|
- this.mediaBuffer = null;
|
|
|
- }
|
|
|
- if (currentTrack && this.state !== State.STOPPED) {
|
|
|
- this.setInterval(TICK_INTERVAL$2);
|
|
|
- }
|
|
|
- }
|
|
|
- // Got a new set of subtitle fragments.
|
|
|
- onSubtitleTrackLoaded(event, data) {
|
|
|
- var _track$details;
|
|
|
- const {
|
|
|
- currentTrackId,
|
|
|
- levels
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- details: newDetails,
|
|
|
- id: trackId
|
|
|
- } = data;
|
|
|
- if (!levels) {
|
|
|
- this.warn(`Subtitle tracks were reset while loading level ${trackId}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const track = levels[trackId];
|
|
|
- if (trackId >= levels.length || !track) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Subtitle track ${trackId} loaded [${newDetails.startSN},${newDetails.endSN}]${newDetails.lastPartSn ? `[part-${newDetails.lastPartSn}-${newDetails.lastPartIndex}]` : ""},duration:${newDetails.totalduration}`);
|
|
|
- this.mediaBuffer = this.mediaBufferTimeRanges;
|
|
|
- let sliding = 0;
|
|
|
- if (newDetails.live || (_track$details = track.details) != null && _track$details.live) {
|
|
|
- if (newDetails.deltaUpdateFailed) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const mainDetails = this.mainDetails;
|
|
|
- if (!mainDetails) {
|
|
|
- this.startFragRequested = false;
|
|
|
- return;
|
|
|
- }
|
|
|
- const mainSlidingStartFragment = mainDetails.fragments[0];
|
|
|
- if (!track.details) {
|
|
|
- if (newDetails.hasProgramDateTime && mainDetails.hasProgramDateTime) {
|
|
|
- alignMediaPlaylistByPDT(newDetails, mainDetails);
|
|
|
- sliding = newDetails.fragmentStart;
|
|
|
- } else if (mainSlidingStartFragment) {
|
|
|
- sliding = mainSlidingStartFragment.start;
|
|
|
- addSliding(newDetails, sliding);
|
|
|
- }
|
|
|
- } else {
|
|
|
- var _this$levelLastLoaded;
|
|
|
- sliding = this.alignPlaylists(newDetails, track.details, (_this$levelLastLoaded = this.levelLastLoaded) == null ? void 0 : _this$levelLastLoaded.details);
|
|
|
- if (sliding === 0 && mainSlidingStartFragment) {
|
|
|
- sliding = mainSlidingStartFragment.start;
|
|
|
- addSliding(newDetails, sliding);
|
|
|
- }
|
|
|
- }
|
|
|
- if (mainDetails && !this.startFragRequested) {
|
|
|
- this.setStartPosition(mainDetails, sliding);
|
|
|
- }
|
|
|
- }
|
|
|
- track.details = newDetails;
|
|
|
- this.levelLastLoaded = track;
|
|
|
- if (trackId !== currentTrackId) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.SUBTITLE_TRACK_UPDATED, {
|
|
|
- details: newDetails,
|
|
|
- id: trackId,
|
|
|
- groupId: data.groupId
|
|
|
- });
|
|
|
- this.tick();
|
|
|
- if (newDetails.live && !this.fragCurrent && this.media && this.state === State.IDLE) {
|
|
|
- const foundFrag = findFragmentByPTS(null, newDetails.fragments, this.media.currentTime, 0);
|
|
|
- if (!foundFrag) {
|
|
|
- this.warn("Subtitle playlist not aligned with playback");
|
|
|
- track.details = void 0;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- _handleFragmentLoadComplete(fragLoadedData) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- payload
|
|
|
- } = fragLoadedData;
|
|
|
- const decryptData = frag.decryptdata;
|
|
|
- const hls = this.hls;
|
|
|
- if (this.fragContextChanged(frag)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (payload && payload.byteLength > 0 && decryptData != null && decryptData.key && decryptData.iv && isFullSegmentEncryption(decryptData.method)) {
|
|
|
- const startTime = performance.now();
|
|
|
- this.decrypter.decrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer, getAesModeFromFullSegmentMethod(decryptData.method)).catch((err) => {
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.FRAG_DECRYPT_ERROR,
|
|
|
- fatal: false,
|
|
|
- error: err,
|
|
|
- reason: err.message,
|
|
|
- frag
|
|
|
- });
|
|
|
- throw err;
|
|
|
- }).then((decryptedData) => {
|
|
|
- const endTime = performance.now();
|
|
|
- hls.trigger(Events.FRAG_DECRYPTED, {
|
|
|
- frag,
|
|
|
- payload: decryptedData,
|
|
|
- stats: {
|
|
|
- tstart: startTime,
|
|
|
- tdecrypt: endTime
|
|
|
- }
|
|
|
- });
|
|
|
- }).catch((err) => {
|
|
|
- this.warn(`${err.name}: ${err.message}`);
|
|
|
- this.state = State.IDLE;
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- doTick() {
|
|
|
- if (!this.media) {
|
|
|
- this.state = State.IDLE;
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.state === State.IDLE) {
|
|
|
- const {
|
|
|
- currentTrackId,
|
|
|
- levels
|
|
|
- } = this;
|
|
|
- const track = levels == null ? void 0 : levels[currentTrackId];
|
|
|
- if (!track || !levels.length || !track.details) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.waitForLive(track)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- config
|
|
|
- } = this;
|
|
|
- const currentTime = this.getLoadPosition();
|
|
|
- const bufferedInfo = BufferHelper.bufferedInfo(this.tracksBuffered[this.currentTrackId] || [], currentTime, config.maxBufferHole);
|
|
|
- const {
|
|
|
- end: targetBufferTime,
|
|
|
- len: bufferLen
|
|
|
- } = bufferedInfo;
|
|
|
- const trackDetails = track.details;
|
|
|
- const maxBufLen = this.hls.maxBufferLength + trackDetails.levelTargetDuration;
|
|
|
- if (bufferLen > maxBufLen) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const fragments = trackDetails.fragments;
|
|
|
- const fragLen = fragments.length;
|
|
|
- const end = trackDetails.edge;
|
|
|
- let foundFrag = null;
|
|
|
- const fragPrevious = this.fragPrevious;
|
|
|
- if (targetBufferTime < end) {
|
|
|
- const tolerance = config.maxFragLookUpTolerance;
|
|
|
- const lookupTolerance = targetBufferTime > end - tolerance ? 0 : tolerance;
|
|
|
- foundFrag = findFragmentByPTS(fragPrevious, fragments, Math.max(fragments[0].start, targetBufferTime), lookupTolerance);
|
|
|
- if (!foundFrag && fragPrevious && fragPrevious.start < fragments[0].start) {
|
|
|
- foundFrag = fragments[0];
|
|
|
- }
|
|
|
- } else {
|
|
|
- foundFrag = fragments[fragLen - 1];
|
|
|
- }
|
|
|
- foundFrag = this.filterReplacedPrimary(foundFrag, track.details);
|
|
|
- if (!foundFrag) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const curSNIdx = foundFrag.sn - trackDetails.startSN;
|
|
|
- const prevFrag = fragments[curSNIdx - 1];
|
|
|
- if (prevFrag && prevFrag.cc === foundFrag.cc && this.fragmentTracker.getState(prevFrag) === FragmentState.NOT_LOADED) {
|
|
|
- foundFrag = prevFrag;
|
|
|
- }
|
|
|
- if (this.fragmentTracker.getState(foundFrag) === FragmentState.NOT_LOADED) {
|
|
|
- const fragToLoad = this.mapToInitFragWhenRequired(foundFrag);
|
|
|
- if (fragToLoad) {
|
|
|
- this.loadFragment(fragToLoad, track, targetBufferTime);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- loadFragment(frag, level, targetBufferTime) {
|
|
|
- if (!isMediaFragment(frag)) {
|
|
|
- this._loadInitSegment(frag, level);
|
|
|
- } else {
|
|
|
- super.loadFragment(frag, level, targetBufferTime);
|
|
|
- }
|
|
|
- }
|
|
|
- get mediaBufferTimeRanges() {
|
|
|
- return new BufferableInstance(this.tracksBuffered[this.currentTrackId] || []);
|
|
|
- }
|
|
|
-};
|
|
|
-var BufferableInstance = class {
|
|
|
- constructor(timeranges) {
|
|
|
- this.buffered = void 0;
|
|
|
- const getRange = (name, index, length) => {
|
|
|
- index = index >>> 0;
|
|
|
- if (index > length - 1) {
|
|
|
- throw new DOMException(`Failed to execute '${name}' on 'TimeRanges': The index provided (${index}) is greater than the maximum bound (${length})`);
|
|
|
- }
|
|
|
- return timeranges[index][name];
|
|
|
- };
|
|
|
- this.buffered = {
|
|
|
- get length() {
|
|
|
- return timeranges.length;
|
|
|
- },
|
|
|
- end(index) {
|
|
|
- return getRange("end", index, timeranges.length);
|
|
|
- },
|
|
|
- start(index) {
|
|
|
- return getRange("start", index, timeranges.length);
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
-};
|
|
|
-var specialCea608CharsCodes = {
|
|
|
- 42: 225,
|
|
|
- // lowercase a, acute accent
|
|
|
- 92: 233,
|
|
|
- // lowercase e, acute accent
|
|
|
- 94: 237,
|
|
|
- // lowercase i, acute accent
|
|
|
- 95: 243,
|
|
|
- // lowercase o, acute accent
|
|
|
- 96: 250,
|
|
|
- // lowercase u, acute accent
|
|
|
- 123: 231,
|
|
|
- // lowercase c with cedilla
|
|
|
- 124: 247,
|
|
|
- // division symbol
|
|
|
- 125: 209,
|
|
|
- // uppercase N tilde
|
|
|
- 126: 241,
|
|
|
- // lowercase n tilde
|
|
|
- 127: 9608,
|
|
|
- // Full block
|
|
|
- // THIS BLOCK INCLUDES THE 16 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
|
|
|
- // THAT COME FROM HI BYTE=0x11 AND LOW BETWEEN 0x30 AND 0x3F
|
|
|
- // THIS MEANS THAT \x50 MUST BE ADDED TO THE VALUES
|
|
|
- 128: 174,
|
|
|
- // Registered symbol (R)
|
|
|
- 129: 176,
|
|
|
- // degree sign
|
|
|
- 130: 189,
|
|
|
- // 1/2 symbol
|
|
|
- 131: 191,
|
|
|
- // Inverted (open) question mark
|
|
|
- 132: 8482,
|
|
|
- // Trademark symbol (TM)
|
|
|
- 133: 162,
|
|
|
- // Cents symbol
|
|
|
- 134: 163,
|
|
|
- // Pounds sterling
|
|
|
- 135: 9834,
|
|
|
- // Music 8'th note
|
|
|
- 136: 224,
|
|
|
- // lowercase a, grave accent
|
|
|
- 137: 32,
|
|
|
- // transparent space (regular)
|
|
|
- 138: 232,
|
|
|
- // lowercase e, grave accent
|
|
|
- 139: 226,
|
|
|
- // lowercase a, circumflex accent
|
|
|
- 140: 234,
|
|
|
- // lowercase e, circumflex accent
|
|
|
- 141: 238,
|
|
|
- // lowercase i, circumflex accent
|
|
|
- 142: 244,
|
|
|
- // lowercase o, circumflex accent
|
|
|
- 143: 251,
|
|
|
- // lowercase u, circumflex accent
|
|
|
- // THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
|
|
|
- // THAT COME FROM HI BYTE=0x12 AND LOW BETWEEN 0x20 AND 0x3F
|
|
|
- 144: 193,
|
|
|
- // capital letter A with acute
|
|
|
- 145: 201,
|
|
|
- // capital letter E with acute
|
|
|
- 146: 211,
|
|
|
- // capital letter O with acute
|
|
|
- 147: 218,
|
|
|
- // capital letter U with acute
|
|
|
- 148: 220,
|
|
|
- // capital letter U with diaresis
|
|
|
- 149: 252,
|
|
|
- // lowercase letter U with diaeresis
|
|
|
- 150: 8216,
|
|
|
- // opening single quote
|
|
|
- 151: 161,
|
|
|
- // inverted exclamation mark
|
|
|
- 152: 42,
|
|
|
- // asterisk
|
|
|
- 153: 8217,
|
|
|
- // closing single quote
|
|
|
- 154: 9473,
|
|
|
- // box drawings heavy horizontal
|
|
|
- 155: 169,
|
|
|
- // copyright sign
|
|
|
- 156: 8480,
|
|
|
- // Service mark
|
|
|
- 157: 8226,
|
|
|
- // (round) bullet
|
|
|
- 158: 8220,
|
|
|
- // Left double quotation mark
|
|
|
- 159: 8221,
|
|
|
- // Right double quotation mark
|
|
|
- 160: 192,
|
|
|
- // uppercase A, grave accent
|
|
|
- 161: 194,
|
|
|
- // uppercase A, circumflex
|
|
|
- 162: 199,
|
|
|
- // uppercase C with cedilla
|
|
|
- 163: 200,
|
|
|
- // uppercase E, grave accent
|
|
|
- 164: 202,
|
|
|
- // uppercase E, circumflex
|
|
|
- 165: 203,
|
|
|
- // capital letter E with diaresis
|
|
|
- 166: 235,
|
|
|
- // lowercase letter e with diaresis
|
|
|
- 167: 206,
|
|
|
- // uppercase I, circumflex
|
|
|
- 168: 207,
|
|
|
- // uppercase I, with diaresis
|
|
|
- 169: 239,
|
|
|
- // lowercase i, with diaresis
|
|
|
- 170: 212,
|
|
|
- // uppercase O, circumflex
|
|
|
- 171: 217,
|
|
|
- // uppercase U, grave accent
|
|
|
- 172: 249,
|
|
|
- // lowercase u, grave accent
|
|
|
- 173: 219,
|
|
|
- // uppercase U, circumflex
|
|
|
- 174: 171,
|
|
|
- // left-pointing double angle quotation mark
|
|
|
- 175: 187,
|
|
|
- // right-pointing double angle quotation mark
|
|
|
- // THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
|
|
|
- // THAT COME FROM HI BYTE=0x13 AND LOW BETWEEN 0x20 AND 0x3F
|
|
|
- 176: 195,
|
|
|
- // Uppercase A, tilde
|
|
|
- 177: 227,
|
|
|
- // Lowercase a, tilde
|
|
|
- 178: 205,
|
|
|
- // Uppercase I, acute accent
|
|
|
- 179: 204,
|
|
|
- // Uppercase I, grave accent
|
|
|
- 180: 236,
|
|
|
- // Lowercase i, grave accent
|
|
|
- 181: 210,
|
|
|
- // Uppercase O, grave accent
|
|
|
- 182: 242,
|
|
|
- // Lowercase o, grave accent
|
|
|
- 183: 213,
|
|
|
- // Uppercase O, tilde
|
|
|
- 184: 245,
|
|
|
- // Lowercase o, tilde
|
|
|
- 185: 123,
|
|
|
- // Open curly brace
|
|
|
- 186: 125,
|
|
|
- // Closing curly brace
|
|
|
- 187: 92,
|
|
|
- // Backslash
|
|
|
- 188: 94,
|
|
|
- // Caret
|
|
|
- 189: 95,
|
|
|
- // Underscore
|
|
|
- 190: 124,
|
|
|
- // Pipe (vertical line)
|
|
|
- 191: 8764,
|
|
|
- // Tilde operator
|
|
|
- 192: 196,
|
|
|
- // Uppercase A, umlaut
|
|
|
- 193: 228,
|
|
|
- // Lowercase A, umlaut
|
|
|
- 194: 214,
|
|
|
- // Uppercase O, umlaut
|
|
|
- 195: 246,
|
|
|
- // Lowercase o, umlaut
|
|
|
- 196: 223,
|
|
|
- // Esszett (sharp S)
|
|
|
- 197: 165,
|
|
|
- // Yen symbol
|
|
|
- 198: 164,
|
|
|
- // Generic currency sign
|
|
|
- 199: 9475,
|
|
|
- // Box drawings heavy vertical
|
|
|
- 200: 197,
|
|
|
- // Uppercase A, ring
|
|
|
- 201: 229,
|
|
|
- // Lowercase A, ring
|
|
|
- 202: 216,
|
|
|
- // Uppercase O, stroke
|
|
|
- 203: 248,
|
|
|
- // Lowercase o, strok
|
|
|
- 204: 9487,
|
|
|
- // Box drawings heavy down and right
|
|
|
- 205: 9491,
|
|
|
- // Box drawings heavy down and left
|
|
|
- 206: 9495,
|
|
|
- // Box drawings heavy up and right
|
|
|
- 207: 9499
|
|
|
- // Box drawings heavy up and left
|
|
|
-};
|
|
|
-var getCharForByte = (byte) => String.fromCharCode(specialCea608CharsCodes[byte] || byte);
|
|
|
-var NR_ROWS = 15;
|
|
|
-var NR_COLS = 100;
|
|
|
-var rowsLowCh1 = {
|
|
|
- 17: 1,
|
|
|
- 18: 3,
|
|
|
- 21: 5,
|
|
|
- 22: 7,
|
|
|
- 23: 9,
|
|
|
- 16: 11,
|
|
|
- 19: 12,
|
|
|
- 20: 14
|
|
|
-};
|
|
|
-var rowsHighCh1 = {
|
|
|
- 17: 2,
|
|
|
- 18: 4,
|
|
|
- 21: 6,
|
|
|
- 22: 8,
|
|
|
- 23: 10,
|
|
|
- 19: 13,
|
|
|
- 20: 15
|
|
|
-};
|
|
|
-var rowsLowCh2 = {
|
|
|
- 25: 1,
|
|
|
- 26: 3,
|
|
|
- 29: 5,
|
|
|
- 30: 7,
|
|
|
- 31: 9,
|
|
|
- 24: 11,
|
|
|
- 27: 12,
|
|
|
- 28: 14
|
|
|
-};
|
|
|
-var rowsHighCh2 = {
|
|
|
- 25: 2,
|
|
|
- 26: 4,
|
|
|
- 29: 6,
|
|
|
- 30: 8,
|
|
|
- 31: 10,
|
|
|
- 27: 13,
|
|
|
- 28: 15
|
|
|
-};
|
|
|
-var backgroundColors = ["white", "green", "blue", "cyan", "red", "yellow", "magenta", "black", "transparent"];
|
|
|
-var CaptionsLogger = class {
|
|
|
- constructor() {
|
|
|
- this.time = null;
|
|
|
- this.verboseLevel = 0;
|
|
|
- }
|
|
|
- log(severity, msg) {
|
|
|
- if (this.verboseLevel >= severity) {
|
|
|
- const m = typeof msg === "function" ? msg() : msg;
|
|
|
- logger.log(`${this.time} [${severity}] ${m}`);
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var numArrayToHexArray = function numArrayToHexArray2(numArray) {
|
|
|
- const hexArray = [];
|
|
|
- for (let j = 0; j < numArray.length; j++) {
|
|
|
- hexArray.push(numArray[j].toString(16));
|
|
|
- }
|
|
|
- return hexArray;
|
|
|
-};
|
|
|
-var PenState = class {
|
|
|
- constructor() {
|
|
|
- this.foreground = "white";
|
|
|
- this.underline = false;
|
|
|
- this.italics = false;
|
|
|
- this.background = "black";
|
|
|
- this.flash = false;
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.foreground = "white";
|
|
|
- this.underline = false;
|
|
|
- this.italics = false;
|
|
|
- this.background = "black";
|
|
|
- this.flash = false;
|
|
|
- }
|
|
|
- setStyles(styles) {
|
|
|
- const attribs = ["foreground", "underline", "italics", "background", "flash"];
|
|
|
- for (let i = 0; i < attribs.length; i++) {
|
|
|
- const style = attribs[i];
|
|
|
- if (styles.hasOwnProperty(style)) {
|
|
|
- this[style] = styles[style];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- isDefault() {
|
|
|
- return this.foreground === "white" && !this.underline && !this.italics && this.background === "black" && !this.flash;
|
|
|
- }
|
|
|
- equals(other) {
|
|
|
- return this.foreground === other.foreground && this.underline === other.underline && this.italics === other.italics && this.background === other.background && this.flash === other.flash;
|
|
|
- }
|
|
|
- copy(newPenState) {
|
|
|
- this.foreground = newPenState.foreground;
|
|
|
- this.underline = newPenState.underline;
|
|
|
- this.italics = newPenState.italics;
|
|
|
- this.background = newPenState.background;
|
|
|
- this.flash = newPenState.flash;
|
|
|
- }
|
|
|
- toString() {
|
|
|
- return "color=" + this.foreground + ", underline=" + this.underline + ", italics=" + this.italics + ", background=" + this.background + ", flash=" + this.flash;
|
|
|
- }
|
|
|
-};
|
|
|
-var StyledUnicodeChar = class {
|
|
|
- constructor() {
|
|
|
- this.uchar = " ";
|
|
|
- this.penState = new PenState();
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.uchar = " ";
|
|
|
- this.penState.reset();
|
|
|
- }
|
|
|
- setChar(uchar, newPenState) {
|
|
|
- this.uchar = uchar;
|
|
|
- this.penState.copy(newPenState);
|
|
|
- }
|
|
|
- setPenState(newPenState) {
|
|
|
- this.penState.copy(newPenState);
|
|
|
- }
|
|
|
- equals(other) {
|
|
|
- return this.uchar === other.uchar && this.penState.equals(other.penState);
|
|
|
- }
|
|
|
- copy(newChar) {
|
|
|
- this.uchar = newChar.uchar;
|
|
|
- this.penState.copy(newChar.penState);
|
|
|
- }
|
|
|
- isEmpty() {
|
|
|
- return this.uchar === " " && this.penState.isDefault();
|
|
|
- }
|
|
|
-};
|
|
|
-var Row = class {
|
|
|
- constructor(logger2) {
|
|
|
- this.chars = [];
|
|
|
- this.pos = 0;
|
|
|
- this.currPenState = new PenState();
|
|
|
- this.cueStartTime = null;
|
|
|
- this.logger = void 0;
|
|
|
- for (let i = 0; i < NR_COLS; i++) {
|
|
|
- this.chars.push(new StyledUnicodeChar());
|
|
|
- }
|
|
|
- this.logger = logger2;
|
|
|
- }
|
|
|
- equals(other) {
|
|
|
- for (let i = 0; i < NR_COLS; i++) {
|
|
|
- if (!this.chars[i].equals(other.chars[i])) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- copy(other) {
|
|
|
- for (let i = 0; i < NR_COLS; i++) {
|
|
|
- this.chars[i].copy(other.chars[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- isEmpty() {
|
|
|
- let empty = true;
|
|
|
- for (let i = 0; i < NR_COLS; i++) {
|
|
|
- if (!this.chars[i].isEmpty()) {
|
|
|
- empty = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return empty;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Set the cursor to a valid column.
|
|
|
- */
|
|
|
- setCursor(absPos) {
|
|
|
- if (this.pos !== absPos) {
|
|
|
- this.pos = absPos;
|
|
|
- }
|
|
|
- if (this.pos < 0) {
|
|
|
- this.logger.log(3, "Negative cursor position " + this.pos);
|
|
|
- this.pos = 0;
|
|
|
- } else if (this.pos > NR_COLS) {
|
|
|
- this.logger.log(3, "Too large cursor position " + this.pos);
|
|
|
- this.pos = NR_COLS;
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Move the cursor relative to current position.
|
|
|
- */
|
|
|
- moveCursor(relPos) {
|
|
|
- const newPos = this.pos + relPos;
|
|
|
- if (relPos > 1) {
|
|
|
- for (let i = this.pos + 1; i < newPos + 1; i++) {
|
|
|
- this.chars[i].setPenState(this.currPenState);
|
|
|
- }
|
|
|
- }
|
|
|
- this.setCursor(newPos);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Backspace, move one step back and clear character.
|
|
|
- */
|
|
|
- backSpace() {
|
|
|
- this.moveCursor(-1);
|
|
|
- this.chars[this.pos].setChar(" ", this.currPenState);
|
|
|
- }
|
|
|
- insertChar(byte) {
|
|
|
- if (byte >= 144) {
|
|
|
- this.backSpace();
|
|
|
- }
|
|
|
- const char = getCharForByte(byte);
|
|
|
- if (this.pos >= NR_COLS) {
|
|
|
- this.logger.log(0, () => "Cannot insert " + byte.toString(16) + " (" + char + ") at position " + this.pos + ". Skipping it!");
|
|
|
- return;
|
|
|
- }
|
|
|
- this.chars[this.pos].setChar(char, this.currPenState);
|
|
|
- this.moveCursor(1);
|
|
|
- }
|
|
|
- clearFromPos(startPos) {
|
|
|
- let i;
|
|
|
- for (i = startPos; i < NR_COLS; i++) {
|
|
|
- this.chars[i].reset();
|
|
|
- }
|
|
|
- }
|
|
|
- clear() {
|
|
|
- this.clearFromPos(0);
|
|
|
- this.pos = 0;
|
|
|
- this.currPenState.reset();
|
|
|
- }
|
|
|
- clearToEndOfRow() {
|
|
|
- this.clearFromPos(this.pos);
|
|
|
- }
|
|
|
- getTextString() {
|
|
|
- const chars = [];
|
|
|
- let empty = true;
|
|
|
- for (let i = 0; i < NR_COLS; i++) {
|
|
|
- const char = this.chars[i].uchar;
|
|
|
- if (char !== " ") {
|
|
|
- empty = false;
|
|
|
- }
|
|
|
- chars.push(char);
|
|
|
- }
|
|
|
- if (empty) {
|
|
|
- return "";
|
|
|
- } else {
|
|
|
- return chars.join("");
|
|
|
- }
|
|
|
- }
|
|
|
- setPenStyles(styles) {
|
|
|
- this.currPenState.setStyles(styles);
|
|
|
- const currChar = this.chars[this.pos];
|
|
|
- currChar.setPenState(this.currPenState);
|
|
|
- }
|
|
|
-};
|
|
|
-var CaptionScreen = class {
|
|
|
- constructor(logger2) {
|
|
|
- this.rows = [];
|
|
|
- this.currRow = NR_ROWS - 1;
|
|
|
- this.nrRollUpRows = null;
|
|
|
- this.lastOutputScreen = null;
|
|
|
- this.logger = void 0;
|
|
|
- for (let i = 0; i < NR_ROWS; i++) {
|
|
|
- this.rows.push(new Row(logger2));
|
|
|
- }
|
|
|
- this.logger = logger2;
|
|
|
- }
|
|
|
- reset() {
|
|
|
- for (let i = 0; i < NR_ROWS; i++) {
|
|
|
- this.rows[i].clear();
|
|
|
- }
|
|
|
- this.currRow = NR_ROWS - 1;
|
|
|
- }
|
|
|
- equals(other) {
|
|
|
- let equal = true;
|
|
|
- for (let i = 0; i < NR_ROWS; i++) {
|
|
|
- if (!this.rows[i].equals(other.rows[i])) {
|
|
|
- equal = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return equal;
|
|
|
- }
|
|
|
- copy(other) {
|
|
|
- for (let i = 0; i < NR_ROWS; i++) {
|
|
|
- this.rows[i].copy(other.rows[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- isEmpty() {
|
|
|
- let empty = true;
|
|
|
- for (let i = 0; i < NR_ROWS; i++) {
|
|
|
- if (!this.rows[i].isEmpty()) {
|
|
|
- empty = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return empty;
|
|
|
- }
|
|
|
- backSpace() {
|
|
|
- const row = this.rows[this.currRow];
|
|
|
- row.backSpace();
|
|
|
- }
|
|
|
- clearToEndOfRow() {
|
|
|
- const row = this.rows[this.currRow];
|
|
|
- row.clearToEndOfRow();
|
|
|
- }
|
|
|
- /**
|
|
|
- * Insert a character (without styling) in the current row.
|
|
|
- */
|
|
|
- insertChar(char) {
|
|
|
- const row = this.rows[this.currRow];
|
|
|
- row.insertChar(char);
|
|
|
- }
|
|
|
- setPen(styles) {
|
|
|
- const row = this.rows[this.currRow];
|
|
|
- row.setPenStyles(styles);
|
|
|
- }
|
|
|
- moveCursor(relPos) {
|
|
|
- const row = this.rows[this.currRow];
|
|
|
- row.moveCursor(relPos);
|
|
|
- }
|
|
|
- setCursor(absPos) {
|
|
|
- this.logger.log(2, "setCursor: " + absPos);
|
|
|
- const row = this.rows[this.currRow];
|
|
|
- row.setCursor(absPos);
|
|
|
- }
|
|
|
- setPAC(pacData) {
|
|
|
- this.logger.log(2, () => "pacData = " + stringify(pacData));
|
|
|
- let newRow = pacData.row - 1;
|
|
|
- if (this.nrRollUpRows && newRow < this.nrRollUpRows - 1) {
|
|
|
- newRow = this.nrRollUpRows - 1;
|
|
|
- }
|
|
|
- if (this.nrRollUpRows && this.currRow !== newRow) {
|
|
|
- for (let i = 0; i < NR_ROWS; i++) {
|
|
|
- this.rows[i].clear();
|
|
|
- }
|
|
|
- const topRowIndex = this.currRow + 1 - this.nrRollUpRows;
|
|
|
- const lastOutputScreen = this.lastOutputScreen;
|
|
|
- if (lastOutputScreen) {
|
|
|
- const prevLineTime = lastOutputScreen.rows[topRowIndex].cueStartTime;
|
|
|
- const time = this.logger.time;
|
|
|
- if (prevLineTime !== null && time !== null && prevLineTime < time) {
|
|
|
- for (let i = 0; i < this.nrRollUpRows; i++) {
|
|
|
- this.rows[newRow - this.nrRollUpRows + i + 1].copy(lastOutputScreen.rows[topRowIndex + i]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this.currRow = newRow;
|
|
|
- const row = this.rows[this.currRow];
|
|
|
- if (pacData.indent !== null) {
|
|
|
- const indent = pacData.indent;
|
|
|
- const prevPos = Math.max(indent - 1, 0);
|
|
|
- row.setCursor(pacData.indent);
|
|
|
- pacData.color = row.chars[prevPos].penState.foreground;
|
|
|
- }
|
|
|
- const styles = {
|
|
|
- foreground: pacData.color,
|
|
|
- underline: pacData.underline,
|
|
|
- italics: pacData.italics,
|
|
|
- background: "black",
|
|
|
- flash: false
|
|
|
- };
|
|
|
- this.setPen(styles);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Set background/extra foreground, but first do back_space, and then insert space (backwards compatibility).
|
|
|
- */
|
|
|
- setBkgData(bkgData) {
|
|
|
- this.logger.log(2, () => "bkgData = " + stringify(bkgData));
|
|
|
- this.backSpace();
|
|
|
- this.setPen(bkgData);
|
|
|
- this.insertChar(32);
|
|
|
- }
|
|
|
- setRollUpRows(nrRows) {
|
|
|
- this.nrRollUpRows = nrRows;
|
|
|
- }
|
|
|
- rollUp() {
|
|
|
- if (this.nrRollUpRows === null) {
|
|
|
- this.logger.log(3, "roll_up but nrRollUpRows not set yet");
|
|
|
- return;
|
|
|
- }
|
|
|
- this.logger.log(1, () => this.getDisplayText());
|
|
|
- const topRowIndex = this.currRow + 1 - this.nrRollUpRows;
|
|
|
- const topRow = this.rows.splice(topRowIndex, 1)[0];
|
|
|
- topRow.clear();
|
|
|
- this.rows.splice(this.currRow, 0, topRow);
|
|
|
- this.logger.log(2, "Rolling up");
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get all non-empty rows with as unicode text.
|
|
|
- */
|
|
|
- getDisplayText(asOneRow) {
|
|
|
- asOneRow = asOneRow || false;
|
|
|
- const displayText = [];
|
|
|
- let text = "";
|
|
|
- let rowNr = -1;
|
|
|
- for (let i = 0; i < NR_ROWS; i++) {
|
|
|
- const rowText = this.rows[i].getTextString();
|
|
|
- if (rowText) {
|
|
|
- rowNr = i + 1;
|
|
|
- if (asOneRow) {
|
|
|
- displayText.push("Row " + rowNr + ": '" + rowText + "'");
|
|
|
- } else {
|
|
|
- displayText.push(rowText.trim());
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (displayText.length > 0) {
|
|
|
- if (asOneRow) {
|
|
|
- text = "[" + displayText.join(" | ") + "]";
|
|
|
- } else {
|
|
|
- text = displayText.join("\n");
|
|
|
- }
|
|
|
- }
|
|
|
- return text;
|
|
|
- }
|
|
|
- getTextAndFormat() {
|
|
|
- return this.rows;
|
|
|
- }
|
|
|
-};
|
|
|
-var Cea608Channel = class {
|
|
|
- constructor(channelNumber, outputFilter, logger2) {
|
|
|
- this.chNr = void 0;
|
|
|
- this.outputFilter = void 0;
|
|
|
- this.mode = void 0;
|
|
|
- this.verbose = void 0;
|
|
|
- this.displayedMemory = void 0;
|
|
|
- this.nonDisplayedMemory = void 0;
|
|
|
- this.lastOutputScreen = void 0;
|
|
|
- this.currRollUpRow = void 0;
|
|
|
- this.writeScreen = void 0;
|
|
|
- this.cueStartTime = void 0;
|
|
|
- this.logger = void 0;
|
|
|
- this.chNr = channelNumber;
|
|
|
- this.outputFilter = outputFilter;
|
|
|
- this.mode = null;
|
|
|
- this.verbose = 0;
|
|
|
- this.displayedMemory = new CaptionScreen(logger2);
|
|
|
- this.nonDisplayedMemory = new CaptionScreen(logger2);
|
|
|
- this.lastOutputScreen = new CaptionScreen(logger2);
|
|
|
- this.currRollUpRow = this.displayedMemory.rows[NR_ROWS - 1];
|
|
|
- this.writeScreen = this.displayedMemory;
|
|
|
- this.mode = null;
|
|
|
- this.cueStartTime = null;
|
|
|
- this.logger = logger2;
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.mode = null;
|
|
|
- this.displayedMemory.reset();
|
|
|
- this.nonDisplayedMemory.reset();
|
|
|
- this.lastOutputScreen.reset();
|
|
|
- this.outputFilter.reset();
|
|
|
- this.currRollUpRow = this.displayedMemory.rows[NR_ROWS - 1];
|
|
|
- this.writeScreen = this.displayedMemory;
|
|
|
- this.mode = null;
|
|
|
- this.cueStartTime = null;
|
|
|
- }
|
|
|
- getHandler() {
|
|
|
- return this.outputFilter;
|
|
|
- }
|
|
|
- setHandler(newHandler) {
|
|
|
- this.outputFilter = newHandler;
|
|
|
- }
|
|
|
- setPAC(pacData) {
|
|
|
- this.writeScreen.setPAC(pacData);
|
|
|
- }
|
|
|
- setBkgData(bkgData) {
|
|
|
- this.writeScreen.setBkgData(bkgData);
|
|
|
- }
|
|
|
- setMode(newMode) {
|
|
|
- if (newMode === this.mode) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.mode = newMode;
|
|
|
- this.logger.log(2, () => "MODE=" + newMode);
|
|
|
- if (this.mode === "MODE_POP-ON") {
|
|
|
- this.writeScreen = this.nonDisplayedMemory;
|
|
|
- } else {
|
|
|
- this.writeScreen = this.displayedMemory;
|
|
|
- this.writeScreen.reset();
|
|
|
- }
|
|
|
- if (this.mode !== "MODE_ROLL-UP") {
|
|
|
- this.displayedMemory.nrRollUpRows = null;
|
|
|
- this.nonDisplayedMemory.nrRollUpRows = null;
|
|
|
- }
|
|
|
- this.mode = newMode;
|
|
|
- }
|
|
|
- insertChars(chars) {
|
|
|
- for (let i = 0; i < chars.length; i++) {
|
|
|
- this.writeScreen.insertChar(chars[i]);
|
|
|
- }
|
|
|
- const screen = this.writeScreen === this.displayedMemory ? "DISP" : "NON_DISP";
|
|
|
- this.logger.log(2, () => screen + ": " + this.writeScreen.getDisplayText(true));
|
|
|
- if (this.mode === "MODE_PAINT-ON" || this.mode === "MODE_ROLL-UP") {
|
|
|
- this.logger.log(1, () => "DISPLAYED: " + this.displayedMemory.getDisplayText(true));
|
|
|
- this.outputDataUpdate();
|
|
|
- }
|
|
|
- }
|
|
|
- ccRCL() {
|
|
|
- this.logger.log(2, "RCL - Resume Caption Loading");
|
|
|
- this.setMode("MODE_POP-ON");
|
|
|
- }
|
|
|
- ccBS() {
|
|
|
- this.logger.log(2, "BS - BackSpace");
|
|
|
- if (this.mode === "MODE_TEXT") {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.writeScreen.backSpace();
|
|
|
- if (this.writeScreen === this.displayedMemory) {
|
|
|
- this.outputDataUpdate();
|
|
|
- }
|
|
|
- }
|
|
|
- ccAOF() {
|
|
|
- }
|
|
|
- ccAON() {
|
|
|
- }
|
|
|
- ccDER() {
|
|
|
- this.logger.log(2, "DER- Delete to End of Row");
|
|
|
- this.writeScreen.clearToEndOfRow();
|
|
|
- this.outputDataUpdate();
|
|
|
- }
|
|
|
- ccRU(nrRows) {
|
|
|
- this.logger.log(2, "RU(" + nrRows + ") - Roll Up");
|
|
|
- this.writeScreen = this.displayedMemory;
|
|
|
- this.setMode("MODE_ROLL-UP");
|
|
|
- this.writeScreen.setRollUpRows(nrRows);
|
|
|
- }
|
|
|
- ccFON() {
|
|
|
- this.logger.log(2, "FON - Flash On");
|
|
|
- this.writeScreen.setPen({
|
|
|
- flash: true
|
|
|
- });
|
|
|
- }
|
|
|
- ccRDC() {
|
|
|
- this.logger.log(2, "RDC - Resume Direct Captioning");
|
|
|
- this.setMode("MODE_PAINT-ON");
|
|
|
- }
|
|
|
- ccTR() {
|
|
|
- this.logger.log(2, "TR");
|
|
|
- this.setMode("MODE_TEXT");
|
|
|
- }
|
|
|
- ccRTD() {
|
|
|
- this.logger.log(2, "RTD");
|
|
|
- this.setMode("MODE_TEXT");
|
|
|
- }
|
|
|
- ccEDM() {
|
|
|
- this.logger.log(2, "EDM - Erase Displayed Memory");
|
|
|
- this.displayedMemory.reset();
|
|
|
- this.outputDataUpdate(true);
|
|
|
- }
|
|
|
- ccCR() {
|
|
|
- this.logger.log(2, "CR - Carriage Return");
|
|
|
- this.writeScreen.rollUp();
|
|
|
- this.outputDataUpdate(true);
|
|
|
- }
|
|
|
- ccENM() {
|
|
|
- this.logger.log(2, "ENM - Erase Non-displayed Memory");
|
|
|
- this.nonDisplayedMemory.reset();
|
|
|
- }
|
|
|
- ccEOC() {
|
|
|
- this.logger.log(2, "EOC - End Of Caption");
|
|
|
- if (this.mode === "MODE_POP-ON") {
|
|
|
- const tmp = this.displayedMemory;
|
|
|
- this.displayedMemory = this.nonDisplayedMemory;
|
|
|
- this.nonDisplayedMemory = tmp;
|
|
|
- this.writeScreen = this.nonDisplayedMemory;
|
|
|
- this.logger.log(1, () => "DISP: " + this.displayedMemory.getDisplayText());
|
|
|
- }
|
|
|
- this.outputDataUpdate(true);
|
|
|
- }
|
|
|
- ccTO(nrCols) {
|
|
|
- this.logger.log(2, "TO(" + nrCols + ") - Tab Offset");
|
|
|
- this.writeScreen.moveCursor(nrCols);
|
|
|
- }
|
|
|
- ccMIDROW(secondByte) {
|
|
|
- const styles = {
|
|
|
- flash: false
|
|
|
- };
|
|
|
- styles.underline = secondByte % 2 === 1;
|
|
|
- styles.italics = secondByte >= 46;
|
|
|
- if (!styles.italics) {
|
|
|
- const colorIndex = Math.floor(secondByte / 2) - 16;
|
|
|
- const colors = ["white", "green", "blue", "cyan", "red", "yellow", "magenta"];
|
|
|
- styles.foreground = colors[colorIndex];
|
|
|
- } else {
|
|
|
- styles.foreground = "white";
|
|
|
- }
|
|
|
- this.logger.log(2, "MIDROW: " + stringify(styles));
|
|
|
- this.writeScreen.setPen(styles);
|
|
|
- }
|
|
|
- outputDataUpdate(dispatch = false) {
|
|
|
- const time = this.logger.time;
|
|
|
- if (time === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.outputFilter) {
|
|
|
- if (this.cueStartTime === null && !this.displayedMemory.isEmpty()) {
|
|
|
- this.cueStartTime = time;
|
|
|
- } else {
|
|
|
- if (!this.displayedMemory.equals(this.lastOutputScreen)) {
|
|
|
- this.outputFilter.newCue(this.cueStartTime, time, this.lastOutputScreen);
|
|
|
- if (dispatch && this.outputFilter.dispatchCue) {
|
|
|
- this.outputFilter.dispatchCue();
|
|
|
- }
|
|
|
- this.cueStartTime = this.displayedMemory.isEmpty() ? null : time;
|
|
|
- }
|
|
|
- }
|
|
|
- this.lastOutputScreen.copy(this.displayedMemory);
|
|
|
- }
|
|
|
- }
|
|
|
- cueSplitAtTime(t) {
|
|
|
- if (this.outputFilter) {
|
|
|
- if (!this.displayedMemory.isEmpty()) {
|
|
|
- if (this.outputFilter.newCue) {
|
|
|
- this.outputFilter.newCue(this.cueStartTime, t, this.displayedMemory);
|
|
|
- }
|
|
|
- this.cueStartTime = t;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var Cea608Parser = class {
|
|
|
- constructor(field, out1, out2) {
|
|
|
- this.channels = void 0;
|
|
|
- this.currentChannel = 0;
|
|
|
- this.cmdHistory = createCmdHistory();
|
|
|
- this.logger = void 0;
|
|
|
- const logger2 = this.logger = new CaptionsLogger();
|
|
|
- this.channels = [null, new Cea608Channel(field, out1, logger2), new Cea608Channel(field + 1, out2, logger2)];
|
|
|
- }
|
|
|
- getHandler(channel) {
|
|
|
- return this.channels[channel].getHandler();
|
|
|
- }
|
|
|
- setHandler(channel, newHandler) {
|
|
|
- this.channels[channel].setHandler(newHandler);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Add data for time t in forms of list of bytes (unsigned ints). The bytes are treated as pairs.
|
|
|
- */
|
|
|
- addData(time, byteList) {
|
|
|
- this.logger.time = time;
|
|
|
- for (let i = 0; i < byteList.length; i += 2) {
|
|
|
- const a = byteList[i] & 127;
|
|
|
- const b = byteList[i + 1] & 127;
|
|
|
- let cmdFound = false;
|
|
|
- let charsFound = null;
|
|
|
- if (a === 0 && b === 0) {
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- this.logger.log(3, () => "[" + numArrayToHexArray([byteList[i], byteList[i + 1]]) + "] -> (" + numArrayToHexArray([a, b]) + ")");
|
|
|
- }
|
|
|
- const cmdHistory = this.cmdHistory;
|
|
|
- const isControlCode = a >= 16 && a <= 31;
|
|
|
- if (isControlCode) {
|
|
|
- if (hasCmdRepeated(a, b, cmdHistory)) {
|
|
|
- setLastCmd(null, null, cmdHistory);
|
|
|
- this.logger.log(3, () => "Repeated command (" + numArrayToHexArray([a, b]) + ") is dropped");
|
|
|
- continue;
|
|
|
- }
|
|
|
- setLastCmd(a, b, this.cmdHistory);
|
|
|
- cmdFound = this.parseCmd(a, b);
|
|
|
- if (!cmdFound) {
|
|
|
- cmdFound = this.parseMidrow(a, b);
|
|
|
- }
|
|
|
- if (!cmdFound) {
|
|
|
- cmdFound = this.parsePAC(a, b);
|
|
|
- }
|
|
|
- if (!cmdFound) {
|
|
|
- cmdFound = this.parseBackgroundAttributes(a, b);
|
|
|
- }
|
|
|
- } else {
|
|
|
- setLastCmd(null, null, cmdHistory);
|
|
|
- }
|
|
|
- if (!cmdFound) {
|
|
|
- charsFound = this.parseChars(a, b);
|
|
|
- if (charsFound) {
|
|
|
- const currChNr = this.currentChannel;
|
|
|
- if (currChNr && currChNr > 0) {
|
|
|
- const channel = this.channels[currChNr];
|
|
|
- channel.insertChars(charsFound);
|
|
|
- } else {
|
|
|
- this.logger.log(2, "No channel found yet. TEXT-MODE?");
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (!cmdFound && !charsFound) {
|
|
|
- this.logger.log(2, () => "Couldn't parse cleaned data " + numArrayToHexArray([a, b]) + " orig: " + numArrayToHexArray([byteList[i], byteList[i + 1]]));
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Parse Command.
|
|
|
- * @returns True if a command was found
|
|
|
- */
|
|
|
- parseCmd(a, b) {
|
|
|
- const cond1 = (a === 20 || a === 28 || a === 21 || a === 29) && b >= 32 && b <= 47;
|
|
|
- const cond2 = (a === 23 || a === 31) && b >= 33 && b <= 35;
|
|
|
- if (!(cond1 || cond2)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const chNr = a === 20 || a === 21 || a === 23 ? 1 : 2;
|
|
|
- const channel = this.channels[chNr];
|
|
|
- if (a === 20 || a === 21 || a === 28 || a === 29) {
|
|
|
- if (b === 32) {
|
|
|
- channel.ccRCL();
|
|
|
- } else if (b === 33) {
|
|
|
- channel.ccBS();
|
|
|
- } else if (b === 34) {
|
|
|
- channel.ccAOF();
|
|
|
- } else if (b === 35) {
|
|
|
- channel.ccAON();
|
|
|
- } else if (b === 36) {
|
|
|
- channel.ccDER();
|
|
|
- } else if (b === 37) {
|
|
|
- channel.ccRU(2);
|
|
|
- } else if (b === 38) {
|
|
|
- channel.ccRU(3);
|
|
|
- } else if (b === 39) {
|
|
|
- channel.ccRU(4);
|
|
|
- } else if (b === 40) {
|
|
|
- channel.ccFON();
|
|
|
- } else if (b === 41) {
|
|
|
- channel.ccRDC();
|
|
|
- } else if (b === 42) {
|
|
|
- channel.ccTR();
|
|
|
- } else if (b === 43) {
|
|
|
- channel.ccRTD();
|
|
|
- } else if (b === 44) {
|
|
|
- channel.ccEDM();
|
|
|
- } else if (b === 45) {
|
|
|
- channel.ccCR();
|
|
|
- } else if (b === 46) {
|
|
|
- channel.ccENM();
|
|
|
- } else if (b === 47) {
|
|
|
- channel.ccEOC();
|
|
|
- }
|
|
|
- } else {
|
|
|
- channel.ccTO(b - 32);
|
|
|
- }
|
|
|
- this.currentChannel = chNr;
|
|
|
- return true;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Parse midrow styling command
|
|
|
- */
|
|
|
- parseMidrow(a, b) {
|
|
|
- let chNr = 0;
|
|
|
- if ((a === 17 || a === 25) && b >= 32 && b <= 47) {
|
|
|
- if (a === 17) {
|
|
|
- chNr = 1;
|
|
|
- } else {
|
|
|
- chNr = 2;
|
|
|
- }
|
|
|
- if (chNr !== this.currentChannel) {
|
|
|
- this.logger.log(0, "Mismatch channel in midrow parsing");
|
|
|
- return false;
|
|
|
- }
|
|
|
- const channel = this.channels[chNr];
|
|
|
- if (!channel) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- channel.ccMIDROW(b);
|
|
|
- this.logger.log(3, () => "MIDROW (" + numArrayToHexArray([a, b]) + ")");
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Parse Preable Access Codes (Table 53).
|
|
|
- * @returns {Boolean} Tells if PAC found
|
|
|
- */
|
|
|
- parsePAC(a, b) {
|
|
|
- let row;
|
|
|
- const case1 = (a >= 17 && a <= 23 || a >= 25 && a <= 31) && b >= 64 && b <= 127;
|
|
|
- const case2 = (a === 16 || a === 24) && b >= 64 && b <= 95;
|
|
|
- if (!(case1 || case2)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const chNr = a <= 23 ? 1 : 2;
|
|
|
- if (b >= 64 && b <= 95) {
|
|
|
- row = chNr === 1 ? rowsLowCh1[a] : rowsLowCh2[a];
|
|
|
- } else {
|
|
|
- row = chNr === 1 ? rowsHighCh1[a] : rowsHighCh2[a];
|
|
|
- }
|
|
|
- const channel = this.channels[chNr];
|
|
|
- if (!channel) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- channel.setPAC(this.interpretPAC(row, b));
|
|
|
- this.currentChannel = chNr;
|
|
|
- return true;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Interpret the second byte of the pac, and return the information.
|
|
|
- * @returns pacData with style parameters
|
|
|
- */
|
|
|
- interpretPAC(row, byte) {
|
|
|
- let pacIndex;
|
|
|
- const pacData = {
|
|
|
- color: null,
|
|
|
- italics: false,
|
|
|
- indent: null,
|
|
|
- underline: false,
|
|
|
- row
|
|
|
- };
|
|
|
- if (byte > 95) {
|
|
|
- pacIndex = byte - 96;
|
|
|
- } else {
|
|
|
- pacIndex = byte - 64;
|
|
|
- }
|
|
|
- pacData.underline = (pacIndex & 1) === 1;
|
|
|
- if (pacIndex <= 13) {
|
|
|
- pacData.color = ["white", "green", "blue", "cyan", "red", "yellow", "magenta", "white"][Math.floor(pacIndex / 2)];
|
|
|
- } else if (pacIndex <= 15) {
|
|
|
- pacData.italics = true;
|
|
|
- pacData.color = "white";
|
|
|
- } else {
|
|
|
- pacData.indent = Math.floor((pacIndex - 16) / 2) * 4;
|
|
|
- }
|
|
|
- return pacData;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Parse characters.
|
|
|
- * @returns An array with 1 to 2 codes corresponding to chars, if found. null otherwise.
|
|
|
- */
|
|
|
- parseChars(a, b) {
|
|
|
- let channelNr;
|
|
|
- let charCodes = null;
|
|
|
- let charCode1 = null;
|
|
|
- if (a >= 25) {
|
|
|
- channelNr = 2;
|
|
|
- charCode1 = a - 8;
|
|
|
- } else {
|
|
|
- channelNr = 1;
|
|
|
- charCode1 = a;
|
|
|
- }
|
|
|
- if (charCode1 >= 17 && charCode1 <= 19) {
|
|
|
- let oneCode;
|
|
|
- if (charCode1 === 17) {
|
|
|
- oneCode = b + 80;
|
|
|
- } else if (charCode1 === 18) {
|
|
|
- oneCode = b + 112;
|
|
|
- } else {
|
|
|
- oneCode = b + 144;
|
|
|
- }
|
|
|
- this.logger.log(2, () => "Special char '" + getCharForByte(oneCode) + "' in channel " + channelNr);
|
|
|
- charCodes = [oneCode];
|
|
|
- } else if (a >= 32 && a <= 127) {
|
|
|
- charCodes = b === 0 ? [a] : [a, b];
|
|
|
- }
|
|
|
- if (charCodes) {
|
|
|
- this.logger.log(3, () => "Char codes = " + numArrayToHexArray(charCodes).join(","));
|
|
|
- }
|
|
|
- return charCodes;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Parse extended background attributes as well as new foreground color black.
|
|
|
- * @returns True if background attributes are found
|
|
|
- */
|
|
|
- parseBackgroundAttributes(a, b) {
|
|
|
- const case1 = (a === 16 || a === 24) && b >= 32 && b <= 47;
|
|
|
- const case2 = (a === 23 || a === 31) && b >= 45 && b <= 47;
|
|
|
- if (!(case1 || case2)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- let index;
|
|
|
- const bkgData = {};
|
|
|
- if (a === 16 || a === 24) {
|
|
|
- index = Math.floor((b - 32) / 2);
|
|
|
- bkgData.background = backgroundColors[index];
|
|
|
- if (b % 2 === 1) {
|
|
|
- bkgData.background = bkgData.background + "_semi";
|
|
|
- }
|
|
|
- } else if (b === 45) {
|
|
|
- bkgData.background = "transparent";
|
|
|
- } else {
|
|
|
- bkgData.foreground = "black";
|
|
|
- if (b === 47) {
|
|
|
- bkgData.underline = true;
|
|
|
- }
|
|
|
- }
|
|
|
- const chNr = a <= 23 ? 1 : 2;
|
|
|
- const channel = this.channels[chNr];
|
|
|
- channel.setBkgData(bkgData);
|
|
|
- return true;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Reset state of parser and its channels.
|
|
|
- */
|
|
|
- reset() {
|
|
|
- for (let i = 0; i < Object.keys(this.channels).length; i++) {
|
|
|
- const channel = this.channels[i];
|
|
|
- if (channel) {
|
|
|
- channel.reset();
|
|
|
- }
|
|
|
- }
|
|
|
- setLastCmd(null, null, this.cmdHistory);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Trigger the generation of a cue, and the start of a new one if displayScreens are not empty.
|
|
|
- */
|
|
|
- cueSplitAtTime(t) {
|
|
|
- for (let i = 0; i < this.channels.length; i++) {
|
|
|
- const channel = this.channels[i];
|
|
|
- if (channel) {
|
|
|
- channel.cueSplitAtTime(t);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function setLastCmd(a, b, cmdHistory) {
|
|
|
- cmdHistory.a = a;
|
|
|
- cmdHistory.b = b;
|
|
|
-}
|
|
|
-function hasCmdRepeated(a, b, cmdHistory) {
|
|
|
- return cmdHistory.a === a && cmdHistory.b === b;
|
|
|
-}
|
|
|
-function createCmdHistory() {
|
|
|
- return {
|
|
|
- a: null,
|
|
|
- b: null
|
|
|
- };
|
|
|
-}
|
|
|
-var VTTCue = function() {
|
|
|
- if (optionalSelf != null && optionalSelf.VTTCue) {
|
|
|
- return self.VTTCue;
|
|
|
- }
|
|
|
- const AllowedDirections = ["", "lr", "rl"];
|
|
|
- const AllowedAlignments = ["start", "middle", "end", "left", "right"];
|
|
|
- function isAllowedValue(allowed, value) {
|
|
|
- if (typeof value !== "string") {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (!Array.isArray(allowed)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const lcValue = value.toLowerCase();
|
|
|
- if (~allowed.indexOf(lcValue)) {
|
|
|
- return lcValue;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- function findDirectionSetting(value) {
|
|
|
- return isAllowedValue(AllowedDirections, value);
|
|
|
- }
|
|
|
- function findAlignSetting(value) {
|
|
|
- return isAllowedValue(AllowedAlignments, value);
|
|
|
- }
|
|
|
- function extend(obj, ...rest) {
|
|
|
- let i = 1;
|
|
|
- for (; i < arguments.length; i++) {
|
|
|
- const cobj = arguments[i];
|
|
|
- for (const p in cobj) {
|
|
|
- obj[p] = cobj[p];
|
|
|
- }
|
|
|
- }
|
|
|
- return obj;
|
|
|
- }
|
|
|
- function VTTCue2(startTime, endTime, text) {
|
|
|
- const cue = this;
|
|
|
- const baseObj = {
|
|
|
- enumerable: true
|
|
|
- };
|
|
|
- cue.hasBeenReset = false;
|
|
|
- let _id = "";
|
|
|
- let _pauseOnExit = false;
|
|
|
- let _startTime = startTime;
|
|
|
- let _endTime = endTime;
|
|
|
- let _text = text;
|
|
|
- let _region = null;
|
|
|
- let _vertical = "";
|
|
|
- let _snapToLines = true;
|
|
|
- let _line = "auto";
|
|
|
- let _lineAlign = "start";
|
|
|
- let _position = 50;
|
|
|
- let _positionAlign = "middle";
|
|
|
- let _size = 50;
|
|
|
- let _align = "middle";
|
|
|
- Object.defineProperty(cue, "id", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _id;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- _id = "" + value;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "pauseOnExit", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _pauseOnExit;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- _pauseOnExit = !!value;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "startTime", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _startTime;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- if (typeof value !== "number") {
|
|
|
- throw new TypeError("Start time must be set to a number.");
|
|
|
- }
|
|
|
- _startTime = value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "endTime", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _endTime;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- if (typeof value !== "number") {
|
|
|
- throw new TypeError("End time must be set to a number.");
|
|
|
- }
|
|
|
- _endTime = value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "text", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _text;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- _text = "" + value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "region", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _region;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- _region = value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "vertical", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _vertical;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- const setting = findDirectionSetting(value);
|
|
|
- if (setting === false) {
|
|
|
- throw new SyntaxError("An invalid or illegal string was specified.");
|
|
|
- }
|
|
|
- _vertical = setting;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "snapToLines", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _snapToLines;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- _snapToLines = !!value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "line", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _line;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- if (typeof value !== "number" && value !== "auto") {
|
|
|
- throw new SyntaxError("An invalid number or illegal string was specified.");
|
|
|
- }
|
|
|
- _line = value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "lineAlign", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _lineAlign;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- const setting = findAlignSetting(value);
|
|
|
- if (!setting) {
|
|
|
- throw new SyntaxError("An invalid or illegal string was specified.");
|
|
|
- }
|
|
|
- _lineAlign = setting;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "position", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _position;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- if (value < 0 || value > 100) {
|
|
|
- throw new Error("Position must be between 0 and 100.");
|
|
|
- }
|
|
|
- _position = value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "positionAlign", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _positionAlign;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- const setting = findAlignSetting(value);
|
|
|
- if (!setting) {
|
|
|
- throw new SyntaxError("An invalid or illegal string was specified.");
|
|
|
- }
|
|
|
- _positionAlign = setting;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "size", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _size;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- if (value < 0 || value > 100) {
|
|
|
- throw new Error("Size must be between 0 and 100.");
|
|
|
- }
|
|
|
- _size = value;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- Object.defineProperty(cue, "align", extend({}, baseObj, {
|
|
|
- get: function() {
|
|
|
- return _align;
|
|
|
- },
|
|
|
- set: function(value) {
|
|
|
- const setting = findAlignSetting(value);
|
|
|
- if (!setting) {
|
|
|
- throw new SyntaxError("An invalid or illegal string was specified.");
|
|
|
- }
|
|
|
- _align = setting;
|
|
|
- this.hasBeenReset = true;
|
|
|
- }
|
|
|
- }));
|
|
|
- cue.displayState = void 0;
|
|
|
- }
|
|
|
- VTTCue2.prototype.getCueAsHTML = function() {
|
|
|
- const WebVTT = self.WebVTT;
|
|
|
- return WebVTT.convertCueToDOMTree(self, this.text);
|
|
|
- };
|
|
|
- return VTTCue2;
|
|
|
-}();
|
|
|
-var StringDecoder = class {
|
|
|
- decode(data, options) {
|
|
|
- if (!data) {
|
|
|
- return "";
|
|
|
- }
|
|
|
- if (typeof data !== "string") {
|
|
|
- throw new Error("Error - expected string data.");
|
|
|
- }
|
|
|
- return decodeURIComponent(encodeURIComponent(data));
|
|
|
- }
|
|
|
-};
|
|
|
-function parseTimeStamp(input) {
|
|
|
- function computeSeconds(h, m2, s, f) {
|
|
|
- return (h | 0) * 3600 + (m2 | 0) * 60 + (s | 0) + parseFloat(f || 0);
|
|
|
- }
|
|
|
- const m = input.match(/^(?:(\d+):)?(\d{2}):(\d{2})(\.\d+)?/);
|
|
|
- if (!m) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (parseFloat(m[2]) > 59) {
|
|
|
- return computeSeconds(m[2], m[3], 0, m[4]);
|
|
|
- }
|
|
|
- return computeSeconds(m[1], m[2], m[3], m[4]);
|
|
|
-}
|
|
|
-var Settings = class {
|
|
|
- constructor() {
|
|
|
- this.values = /* @__PURE__ */ Object.create(null);
|
|
|
- }
|
|
|
- // Only accept the first assignment to any key.
|
|
|
- set(k, v) {
|
|
|
- if (!this.get(k) && v !== "") {
|
|
|
- this.values[k] = v;
|
|
|
- }
|
|
|
- }
|
|
|
- // Return the value for a key, or a default value.
|
|
|
- // If 'defaultKey' is passed then 'dflt' is assumed to be an object with
|
|
|
- // a number of possible default values as properties where 'defaultKey' is
|
|
|
- // the key of the property that will be chosen; otherwise it's assumed to be
|
|
|
- // a single value.
|
|
|
- get(k, dflt, defaultKey) {
|
|
|
- if (defaultKey) {
|
|
|
- return this.has(k) ? this.values[k] : dflt[defaultKey];
|
|
|
- }
|
|
|
- return this.has(k) ? this.values[k] : dflt;
|
|
|
- }
|
|
|
- // Check whether we have a value for a key.
|
|
|
- has(k) {
|
|
|
- return k in this.values;
|
|
|
- }
|
|
|
- // Accept a setting if its one of the given alternatives.
|
|
|
- alt(k, v, a) {
|
|
|
- for (let n = 0; n < a.length; ++n) {
|
|
|
- if (v === a[n]) {
|
|
|
- this.set(k, v);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- // Accept a setting if its a valid (signed) integer.
|
|
|
- integer(k, v) {
|
|
|
- if (/^-?\d+$/.test(v)) {
|
|
|
- this.set(k, parseInt(v, 10));
|
|
|
- }
|
|
|
- }
|
|
|
- // Accept a setting if its a valid percentage.
|
|
|
- percent(k, v) {
|
|
|
- if (/^([\d]{1,3})(\.[\d]*)?%$/.test(v)) {
|
|
|
- const percent = parseFloat(v);
|
|
|
- if (percent >= 0 && percent <= 100) {
|
|
|
- this.set(k, percent);
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
-};
|
|
|
-function parseOptions(input, callback, keyValueDelim, groupDelim) {
|
|
|
- const groups = groupDelim ? input.split(groupDelim) : [input];
|
|
|
- for (const i in groups) {
|
|
|
- if (typeof groups[i] !== "string") {
|
|
|
- continue;
|
|
|
- }
|
|
|
- const kv = groups[i].split(keyValueDelim);
|
|
|
- if (kv.length !== 2) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- const k = kv[0];
|
|
|
- const v = kv[1];
|
|
|
- callback(k, v);
|
|
|
- }
|
|
|
-}
|
|
|
-var defaults = new VTTCue(0, 0, "");
|
|
|
-var center = defaults.align === "middle" ? "middle" : "center";
|
|
|
-function parseCue(input, cue, regionList) {
|
|
|
- const oInput = input;
|
|
|
- function consumeTimeStamp() {
|
|
|
- const ts = parseTimeStamp(input);
|
|
|
- if (ts === null) {
|
|
|
- throw new Error("Malformed timestamp: " + oInput);
|
|
|
- }
|
|
|
- input = input.replace(/^[^\sa-zA-Z-]+/, "");
|
|
|
- return ts;
|
|
|
- }
|
|
|
- function consumeCueSettings(input2, cue2) {
|
|
|
- const settings = new Settings();
|
|
|
- parseOptions(input2, function(k, v) {
|
|
|
- let vals;
|
|
|
- switch (k) {
|
|
|
- case "region":
|
|
|
- for (let i = regionList.length - 1; i >= 0; i--) {
|
|
|
- if (regionList[i].id === v) {
|
|
|
- settings.set(k, regionList[i].region);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- case "vertical":
|
|
|
- settings.alt(k, v, ["rl", "lr"]);
|
|
|
- break;
|
|
|
- case "line":
|
|
|
- vals = v.split(",");
|
|
|
- settings.integer(k, vals[0]);
|
|
|
- if (settings.percent(k, vals[0])) {
|
|
|
- settings.set("snapToLines", false);
|
|
|
- }
|
|
|
- settings.alt(k, vals[0], ["auto"]);
|
|
|
- if (vals.length === 2) {
|
|
|
- settings.alt("lineAlign", vals[1], ["start", center, "end"]);
|
|
|
- }
|
|
|
- break;
|
|
|
- case "position":
|
|
|
- vals = v.split(",");
|
|
|
- settings.percent(k, vals[0]);
|
|
|
- if (vals.length === 2) {
|
|
|
- settings.alt("positionAlign", vals[1], ["start", center, "end", "line-left", "line-right", "auto"]);
|
|
|
- }
|
|
|
- break;
|
|
|
- case "size":
|
|
|
- settings.percent(k, v);
|
|
|
- break;
|
|
|
- case "align":
|
|
|
- settings.alt(k, v, ["start", center, "end", "left", "right"]);
|
|
|
- break;
|
|
|
- }
|
|
|
- }, /:/, /\s/);
|
|
|
- cue2.region = settings.get("region", null);
|
|
|
- cue2.vertical = settings.get("vertical", "");
|
|
|
- let line = settings.get("line", "auto");
|
|
|
- if (line === "auto" && defaults.line === -1) {
|
|
|
- line = -1;
|
|
|
- }
|
|
|
- cue2.line = line;
|
|
|
- cue2.lineAlign = settings.get("lineAlign", "start");
|
|
|
- cue2.snapToLines = settings.get("snapToLines", true);
|
|
|
- cue2.size = settings.get("size", 100);
|
|
|
- cue2.align = settings.get("align", center);
|
|
|
- let position = settings.get("position", "auto");
|
|
|
- if (position === "auto" && defaults.position === 50) {
|
|
|
- position = cue2.align === "start" || cue2.align === "left" ? 0 : cue2.align === "end" || cue2.align === "right" ? 100 : 50;
|
|
|
- }
|
|
|
- cue2.position = position;
|
|
|
- }
|
|
|
- function skipWhitespace() {
|
|
|
- input = input.replace(/^\s+/, "");
|
|
|
- }
|
|
|
- skipWhitespace();
|
|
|
- cue.startTime = consumeTimeStamp();
|
|
|
- skipWhitespace();
|
|
|
- if (input.slice(0, 3) !== "-->") {
|
|
|
- throw new Error("Malformed time stamp (time stamps must be separated by '-->'): " + oInput);
|
|
|
- }
|
|
|
- input = input.slice(3);
|
|
|
- skipWhitespace();
|
|
|
- cue.endTime = consumeTimeStamp();
|
|
|
- skipWhitespace();
|
|
|
- consumeCueSettings(input, cue);
|
|
|
-}
|
|
|
-function fixLineBreaks(input) {
|
|
|
- return input.replace(/<br(?: \/)?>/gi, "\n");
|
|
|
-}
|
|
|
-var VTTParser = class {
|
|
|
- constructor() {
|
|
|
- this.state = "INITIAL";
|
|
|
- this.buffer = "";
|
|
|
- this.decoder = new StringDecoder();
|
|
|
- this.regionList = [];
|
|
|
- this.cue = null;
|
|
|
- this.oncue = void 0;
|
|
|
- this.onparsingerror = void 0;
|
|
|
- this.onflush = void 0;
|
|
|
- }
|
|
|
- parse(data) {
|
|
|
- const _this = this;
|
|
|
- if (data) {
|
|
|
- _this.buffer += _this.decoder.decode(data, {
|
|
|
- stream: true
|
|
|
- });
|
|
|
- }
|
|
|
- function collectNextLine() {
|
|
|
- let buffer = _this.buffer;
|
|
|
- let pos = 0;
|
|
|
- buffer = fixLineBreaks(buffer);
|
|
|
- while (pos < buffer.length && buffer[pos] !== "\r" && buffer[pos] !== "\n") {
|
|
|
- ++pos;
|
|
|
- }
|
|
|
- const line = buffer.slice(0, pos);
|
|
|
- if (buffer[pos] === "\r") {
|
|
|
- ++pos;
|
|
|
- }
|
|
|
- if (buffer[pos] === "\n") {
|
|
|
- ++pos;
|
|
|
- }
|
|
|
- _this.buffer = buffer.slice(pos);
|
|
|
- return line;
|
|
|
- }
|
|
|
- function parseHeader2(input) {
|
|
|
- parseOptions(input, function(k, v) {
|
|
|
- }, /:/);
|
|
|
- }
|
|
|
- try {
|
|
|
- let line = "";
|
|
|
- if (_this.state === "INITIAL") {
|
|
|
- if (!/\r\n|\n/.test(_this.buffer)) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- line = collectNextLine();
|
|
|
- const m = line.match(/^()?WEBVTT([ \t].*)?$/);
|
|
|
- if (!(m != null && m[0])) {
|
|
|
- throw new Error("Malformed WebVTT signature.");
|
|
|
- }
|
|
|
- _this.state = "HEADER";
|
|
|
- }
|
|
|
- let alreadyCollectedLine = false;
|
|
|
- while (_this.buffer) {
|
|
|
- if (!/\r\n|\n/.test(_this.buffer)) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- if (!alreadyCollectedLine) {
|
|
|
- line = collectNextLine();
|
|
|
- } else {
|
|
|
- alreadyCollectedLine = false;
|
|
|
- }
|
|
|
- switch (_this.state) {
|
|
|
- case "HEADER":
|
|
|
- if (/:/.test(line)) {
|
|
|
- parseHeader2(line);
|
|
|
- } else if (!line) {
|
|
|
- _this.state = "ID";
|
|
|
- }
|
|
|
- continue;
|
|
|
- case "NOTE":
|
|
|
- if (!line) {
|
|
|
- _this.state = "ID";
|
|
|
- }
|
|
|
- continue;
|
|
|
- case "ID":
|
|
|
- if (/^NOTE($|[ \t])/.test(line)) {
|
|
|
- _this.state = "NOTE";
|
|
|
- break;
|
|
|
- }
|
|
|
- if (!line) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- _this.cue = new VTTCue(0, 0, "");
|
|
|
- _this.state = "CUE";
|
|
|
- if (line.indexOf("-->") === -1) {
|
|
|
- _this.cue.id = line;
|
|
|
- continue;
|
|
|
- }
|
|
|
- case "CUE":
|
|
|
- if (!_this.cue) {
|
|
|
- _this.state = "BADCUE";
|
|
|
- continue;
|
|
|
- }
|
|
|
- try {
|
|
|
- parseCue(line, _this.cue, _this.regionList);
|
|
|
- } catch (e) {
|
|
|
- _this.cue = null;
|
|
|
- _this.state = "BADCUE";
|
|
|
- continue;
|
|
|
- }
|
|
|
- _this.state = "CUETEXT";
|
|
|
- continue;
|
|
|
- case "CUETEXT":
|
|
|
- {
|
|
|
- const hasSubstring = line.indexOf("-->") !== -1;
|
|
|
- if (!line || hasSubstring && (alreadyCollectedLine = true)) {
|
|
|
- if (_this.oncue && _this.cue) {
|
|
|
- _this.oncue(_this.cue);
|
|
|
- }
|
|
|
- _this.cue = null;
|
|
|
- _this.state = "ID";
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (_this.cue === null) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (_this.cue.text) {
|
|
|
- _this.cue.text += "\n";
|
|
|
- }
|
|
|
- _this.cue.text += line;
|
|
|
- }
|
|
|
- continue;
|
|
|
- case "BADCUE":
|
|
|
- if (!line) {
|
|
|
- _this.state = "ID";
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } catch (e) {
|
|
|
- if (_this.state === "CUETEXT" && _this.cue && _this.oncue) {
|
|
|
- _this.oncue(_this.cue);
|
|
|
- }
|
|
|
- _this.cue = null;
|
|
|
- _this.state = _this.state === "INITIAL" ? "BADWEBVTT" : "BADCUE";
|
|
|
- }
|
|
|
- return this;
|
|
|
- }
|
|
|
- flush() {
|
|
|
- const _this = this;
|
|
|
- try {
|
|
|
- if (_this.cue || _this.state === "HEADER") {
|
|
|
- _this.buffer += "\n\n";
|
|
|
- _this.parse();
|
|
|
- }
|
|
|
- if (_this.state === "INITIAL" || _this.state === "BADWEBVTT") {
|
|
|
- throw new Error("Malformed WebVTT signature.");
|
|
|
- }
|
|
|
- } catch (e) {
|
|
|
- if (_this.onparsingerror) {
|
|
|
- _this.onparsingerror(e);
|
|
|
- }
|
|
|
- }
|
|
|
- if (_this.onflush) {
|
|
|
- _this.onflush();
|
|
|
- }
|
|
|
- return this;
|
|
|
- }
|
|
|
-};
|
|
|
-var LINEBREAKS = /\r\n|\n\r|\n|\r/g;
|
|
|
-var startsWith = function startsWith2(inputString, searchString, position = 0) {
|
|
|
- return inputString.slice(position, position + searchString.length) === searchString;
|
|
|
-};
|
|
|
-var cueString2millis = function cueString2millis2(timeString) {
|
|
|
- let ts = parseInt(timeString.slice(-3));
|
|
|
- const secs = parseInt(timeString.slice(-6, -4));
|
|
|
- const mins = parseInt(timeString.slice(-9, -7));
|
|
|
- const hours = timeString.length > 9 ? parseInt(timeString.substring(0, timeString.indexOf(":"))) : 0;
|
|
|
- if (!isFiniteNumber(ts) || !isFiniteNumber(secs) || !isFiniteNumber(mins) || !isFiniteNumber(hours)) {
|
|
|
- throw Error(`Malformed X-TIMESTAMP-MAP: Local:${timeString}`);
|
|
|
- }
|
|
|
- ts += 1e3 * secs;
|
|
|
- ts += 60 * 1e3 * mins;
|
|
|
- ts += 60 * 60 * 1e3 * hours;
|
|
|
- return ts;
|
|
|
-};
|
|
|
-function generateCueId(startTime, endTime, text) {
|
|
|
- return hash(startTime.toString()) + hash(endTime.toString()) + hash(text);
|
|
|
-}
|
|
|
-var calculateOffset = function calculateOffset2(vttCCs, cc, presentationTime) {
|
|
|
- let currCC = vttCCs[cc];
|
|
|
- let prevCC = vttCCs[currCC.prevCC];
|
|
|
- if (!prevCC || !prevCC.new && currCC.new) {
|
|
|
- vttCCs.ccOffset = vttCCs.presentationOffset = currCC.start;
|
|
|
- currCC.new = false;
|
|
|
- return;
|
|
|
- }
|
|
|
- while ((_prevCC = prevCC) != null && _prevCC.new) {
|
|
|
- var _prevCC;
|
|
|
- vttCCs.ccOffset += currCC.start - prevCC.start;
|
|
|
- currCC.new = false;
|
|
|
- currCC = prevCC;
|
|
|
- prevCC = vttCCs[currCC.prevCC];
|
|
|
- }
|
|
|
- vttCCs.presentationOffset = presentationTime;
|
|
|
-};
|
|
|
-function parseWebVTT(vttByteArray, initPTS, vttCCs, cc, timeOffset, callBack, errorCallBack) {
|
|
|
- const parser = new VTTParser();
|
|
|
- const vttLines = utf8ArrayToStr(new Uint8Array(vttByteArray)).trim().replace(LINEBREAKS, "\n").split("\n");
|
|
|
- const cues = [];
|
|
|
- const init90kHz = initPTS ? toMpegTsClockFromTimescale(initPTS.baseTime, initPTS.timescale) : 0;
|
|
|
- let cueTime = "00:00.000";
|
|
|
- let timestampMapMPEGTS = 0;
|
|
|
- let timestampMapLOCAL = 0;
|
|
|
- let parsingError;
|
|
|
- let inHeader = true;
|
|
|
- parser.oncue = function(cue) {
|
|
|
- const currCC = vttCCs[cc];
|
|
|
- let cueOffset = vttCCs.ccOffset;
|
|
|
- const webVttMpegTsMapOffset = (timestampMapMPEGTS - init90kHz) / 9e4;
|
|
|
- if (currCC != null && currCC.new) {
|
|
|
- if (timestampMapLOCAL !== void 0) {
|
|
|
- cueOffset = vttCCs.ccOffset = currCC.start;
|
|
|
- } else {
|
|
|
- calculateOffset(vttCCs, cc, webVttMpegTsMapOffset);
|
|
|
- }
|
|
|
- }
|
|
|
- if (webVttMpegTsMapOffset) {
|
|
|
- if (!initPTS) {
|
|
|
- parsingError = new Error("Missing initPTS for VTT MPEGTS");
|
|
|
- return;
|
|
|
- }
|
|
|
- cueOffset = webVttMpegTsMapOffset - vttCCs.presentationOffset;
|
|
|
- }
|
|
|
- const duration = cue.endTime - cue.startTime;
|
|
|
- const startTime = normalizePts((cue.startTime + cueOffset - timestampMapLOCAL) * 9e4, timeOffset * 9e4) / 9e4;
|
|
|
- cue.startTime = Math.max(startTime, 0);
|
|
|
- cue.endTime = Math.max(startTime + duration, 0);
|
|
|
- const text = cue.text.trim();
|
|
|
- cue.text = decodeURIComponent(encodeURIComponent(text));
|
|
|
- if (!cue.id) {
|
|
|
- cue.id = generateCueId(cue.startTime, cue.endTime, text);
|
|
|
- }
|
|
|
- if (cue.endTime > 0) {
|
|
|
- cues.push(cue);
|
|
|
- }
|
|
|
- };
|
|
|
- parser.onparsingerror = function(error) {
|
|
|
- parsingError = error;
|
|
|
- };
|
|
|
- parser.onflush = function() {
|
|
|
- if (parsingError) {
|
|
|
- errorCallBack(parsingError);
|
|
|
- return;
|
|
|
- }
|
|
|
- callBack(cues);
|
|
|
- };
|
|
|
- vttLines.forEach((line) => {
|
|
|
- if (inHeader) {
|
|
|
- if (startsWith(line, "X-TIMESTAMP-MAP=")) {
|
|
|
- inHeader = false;
|
|
|
- line.slice(16).split(",").forEach((timestamp) => {
|
|
|
- if (startsWith(timestamp, "LOCAL:")) {
|
|
|
- cueTime = timestamp.slice(6);
|
|
|
- } else if (startsWith(timestamp, "MPEGTS:")) {
|
|
|
- timestampMapMPEGTS = parseInt(timestamp.slice(7));
|
|
|
- }
|
|
|
- });
|
|
|
- try {
|
|
|
- timestampMapLOCAL = cueString2millis(cueTime) / 1e3;
|
|
|
- } catch (error) {
|
|
|
- parsingError = error;
|
|
|
- }
|
|
|
- return;
|
|
|
- } else if (line === "") {
|
|
|
- inHeader = false;
|
|
|
- }
|
|
|
- }
|
|
|
- parser.parse(line + "\n");
|
|
|
- });
|
|
|
- parser.flush();
|
|
|
-}
|
|
|
-var IMSC1_CODEC = "stpp.ttml.im1t";
|
|
|
-var HMSF_REGEX = /^(\d{2,}):(\d{2}):(\d{2}):(\d{2})\.?(\d+)?$/;
|
|
|
-var TIME_UNIT_REGEX = /^(\d*(?:\.\d*)?)(h|m|s|ms|f|t)$/;
|
|
|
-var textAlignToLineAlign = {
|
|
|
- left: "start",
|
|
|
- center: "center",
|
|
|
- right: "end",
|
|
|
- start: "start",
|
|
|
- end: "end"
|
|
|
-};
|
|
|
-function parseIMSC1(payload, initPTS, callBack, errorCallBack) {
|
|
|
- const results = findBox(new Uint8Array(payload), ["mdat"]);
|
|
|
- if (results.length === 0) {
|
|
|
- errorCallBack(new Error("Could not parse IMSC1 mdat"));
|
|
|
- return;
|
|
|
- }
|
|
|
- const ttmlList = results.map((mdat) => utf8ArrayToStr(mdat));
|
|
|
- const syncTime = toTimescaleFromScale(initPTS.baseTime, 1, initPTS.timescale);
|
|
|
- try {
|
|
|
- ttmlList.forEach((ttml) => callBack(parseTTML(ttml, syncTime)));
|
|
|
- } catch (error) {
|
|
|
- errorCallBack(error);
|
|
|
- }
|
|
|
-}
|
|
|
-function parseTTML(ttml, syncTime) {
|
|
|
- const parser = new DOMParser();
|
|
|
- const xmlDoc = parser.parseFromString(ttml, "text/xml");
|
|
|
- const tt = xmlDoc.getElementsByTagName("tt")[0];
|
|
|
- if (!tt) {
|
|
|
- throw new Error("Invalid ttml");
|
|
|
- }
|
|
|
- const defaultRateInfo = {
|
|
|
- frameRate: 30,
|
|
|
- subFrameRate: 1,
|
|
|
- frameRateMultiplier: 0,
|
|
|
- tickRate: 0
|
|
|
- };
|
|
|
- const rateInfo = Object.keys(defaultRateInfo).reduce((result, key) => {
|
|
|
- result[key] = tt.getAttribute(`ttp:${key}`) || defaultRateInfo[key];
|
|
|
- return result;
|
|
|
- }, {});
|
|
|
- const trim = tt.getAttribute("xml:space") !== "preserve";
|
|
|
- const styleElements = collectionToDictionary(getElementCollection(tt, "styling", "style"));
|
|
|
- const regionElements = collectionToDictionary(getElementCollection(tt, "layout", "region"));
|
|
|
- const cueElements = getElementCollection(tt, "body", "[begin]");
|
|
|
- return [].map.call(cueElements, (cueElement) => {
|
|
|
- const cueText = getTextContent(cueElement, trim);
|
|
|
- if (!cueText || !cueElement.hasAttribute("begin")) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const startTime = parseTtmlTime(cueElement.getAttribute("begin"), rateInfo);
|
|
|
- const duration = parseTtmlTime(cueElement.getAttribute("dur"), rateInfo);
|
|
|
- let endTime = parseTtmlTime(cueElement.getAttribute("end"), rateInfo);
|
|
|
- if (startTime === null) {
|
|
|
- throw timestampParsingError(cueElement);
|
|
|
- }
|
|
|
- if (endTime === null) {
|
|
|
- if (duration === null) {
|
|
|
- throw timestampParsingError(cueElement);
|
|
|
- }
|
|
|
- endTime = startTime + duration;
|
|
|
- }
|
|
|
- const cue = new VTTCue(startTime - syncTime, endTime - syncTime, cueText);
|
|
|
- cue.id = generateCueId(cue.startTime, cue.endTime, cue.text);
|
|
|
- const region = regionElements[cueElement.getAttribute("region")];
|
|
|
- const style = styleElements[cueElement.getAttribute("style")];
|
|
|
- const styles = getTtmlStyles(region, style, styleElements);
|
|
|
- const {
|
|
|
- textAlign
|
|
|
- } = styles;
|
|
|
- if (textAlign) {
|
|
|
- const lineAlign = textAlignToLineAlign[textAlign];
|
|
|
- if (lineAlign) {
|
|
|
- cue.lineAlign = lineAlign;
|
|
|
- }
|
|
|
- cue.align = textAlign;
|
|
|
- }
|
|
|
- _extends(cue, styles);
|
|
|
- return cue;
|
|
|
- }).filter((cue) => cue !== null);
|
|
|
-}
|
|
|
-function getElementCollection(fromElement, parentName, childName) {
|
|
|
- const parent = fromElement.getElementsByTagName(parentName)[0];
|
|
|
- if (parent) {
|
|
|
- return [].slice.call(parent.querySelectorAll(childName));
|
|
|
- }
|
|
|
- return [];
|
|
|
-}
|
|
|
-function collectionToDictionary(elementsWithId) {
|
|
|
- return elementsWithId.reduce((dict, element) => {
|
|
|
- const id = element.getAttribute("xml:id");
|
|
|
- if (id) {
|
|
|
- dict[id] = element;
|
|
|
- }
|
|
|
- return dict;
|
|
|
- }, {});
|
|
|
-}
|
|
|
-function getTextContent(element, trim) {
|
|
|
- return [].slice.call(element.childNodes).reduce((str, node, i) => {
|
|
|
- var _node$childNodes;
|
|
|
- if (node.nodeName === "br" && i) {
|
|
|
- return str + "\n";
|
|
|
- }
|
|
|
- if ((_node$childNodes = node.childNodes) != null && _node$childNodes.length) {
|
|
|
- return getTextContent(node, trim);
|
|
|
- } else if (trim) {
|
|
|
- return str + node.textContent.trim().replace(/\s+/g, " ");
|
|
|
- }
|
|
|
- return str + node.textContent;
|
|
|
- }, "");
|
|
|
-}
|
|
|
-function getTtmlStyles(region, style, styleElements) {
|
|
|
- const ttsNs = "http://www.w3.org/ns/ttml#styling";
|
|
|
- let regionStyle = null;
|
|
|
- const styleAttributes = [
|
|
|
- "displayAlign",
|
|
|
- "textAlign",
|
|
|
- "color",
|
|
|
- "backgroundColor",
|
|
|
- "fontSize",
|
|
|
- "fontFamily"
|
|
|
- // 'fontWeight',
|
|
|
- // 'lineHeight',
|
|
|
- // 'wrapOption',
|
|
|
- // 'fontStyle',
|
|
|
- // 'direction',
|
|
|
- // 'writingMode'
|
|
|
- ];
|
|
|
- const regionStyleName = region != null && region.hasAttribute("style") ? region.getAttribute("style") : null;
|
|
|
- if (regionStyleName && styleElements.hasOwnProperty(regionStyleName)) {
|
|
|
- regionStyle = styleElements[regionStyleName];
|
|
|
- }
|
|
|
- return styleAttributes.reduce((styles, name) => {
|
|
|
- const value = getAttributeNS(style, ttsNs, name) || getAttributeNS(region, ttsNs, name) || getAttributeNS(regionStyle, ttsNs, name);
|
|
|
- if (value) {
|
|
|
- styles[name] = value;
|
|
|
- }
|
|
|
- return styles;
|
|
|
- }, {});
|
|
|
-}
|
|
|
-function getAttributeNS(element, ns, name) {
|
|
|
- if (!element) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return element.hasAttributeNS(ns, name) ? element.getAttributeNS(ns, name) : null;
|
|
|
-}
|
|
|
-function timestampParsingError(node) {
|
|
|
- return new Error(`Could not parse ttml timestamp ${node}`);
|
|
|
-}
|
|
|
-function parseTtmlTime(timeAttributeValue, rateInfo) {
|
|
|
- if (!timeAttributeValue) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- let seconds = parseTimeStamp(timeAttributeValue);
|
|
|
- if (seconds === null) {
|
|
|
- if (HMSF_REGEX.test(timeAttributeValue)) {
|
|
|
- seconds = parseHoursMinutesSecondsFrames(timeAttributeValue, rateInfo);
|
|
|
- } else if (TIME_UNIT_REGEX.test(timeAttributeValue)) {
|
|
|
- seconds = parseTimeUnits(timeAttributeValue, rateInfo);
|
|
|
- }
|
|
|
- }
|
|
|
- return seconds;
|
|
|
-}
|
|
|
-function parseHoursMinutesSecondsFrames(timeAttributeValue, rateInfo) {
|
|
|
- const m = HMSF_REGEX.exec(timeAttributeValue);
|
|
|
- const frames = (m[4] | 0) + (m[5] | 0) / rateInfo.subFrameRate;
|
|
|
- return (m[1] | 0) * 3600 + (m[2] | 0) * 60 + (m[3] | 0) + frames / rateInfo.frameRate;
|
|
|
-}
|
|
|
-function parseTimeUnits(timeAttributeValue, rateInfo) {
|
|
|
- const m = TIME_UNIT_REGEX.exec(timeAttributeValue);
|
|
|
- const value = Number(m[1]);
|
|
|
- const unit = m[2];
|
|
|
- switch (unit) {
|
|
|
- case "h":
|
|
|
- return value * 3600;
|
|
|
- case "m":
|
|
|
- return value * 60;
|
|
|
- case "ms":
|
|
|
- return value * 1e3;
|
|
|
- case "f":
|
|
|
- return value / rateInfo.frameRate;
|
|
|
- case "t":
|
|
|
- return value / rateInfo.tickRate;
|
|
|
- }
|
|
|
- return value;
|
|
|
-}
|
|
|
-var OutputFilter = class {
|
|
|
- constructor(timelineController, trackName) {
|
|
|
- this.timelineController = void 0;
|
|
|
- this.cueRanges = [];
|
|
|
- this.trackName = void 0;
|
|
|
- this.startTime = null;
|
|
|
- this.endTime = null;
|
|
|
- this.screen = null;
|
|
|
- this.timelineController = timelineController;
|
|
|
- this.trackName = trackName;
|
|
|
- }
|
|
|
- dispatchCue() {
|
|
|
- if (this.startTime === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.timelineController.addCues(this.trackName, this.startTime, this.endTime, this.screen, this.cueRanges);
|
|
|
- this.startTime = null;
|
|
|
- }
|
|
|
- newCue(startTime, endTime, screen) {
|
|
|
- if (this.startTime === null || this.startTime > startTime) {
|
|
|
- this.startTime = startTime;
|
|
|
- }
|
|
|
- this.endTime = endTime;
|
|
|
- this.screen = screen;
|
|
|
- this.timelineController.createCaptionsTrack(this.trackName);
|
|
|
- }
|
|
|
- reset() {
|
|
|
- this.cueRanges = [];
|
|
|
- this.startTime = null;
|
|
|
- }
|
|
|
-};
|
|
|
-var TimelineController = class {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.media = null;
|
|
|
- this.config = void 0;
|
|
|
- this.enabled = true;
|
|
|
- this.Cues = void 0;
|
|
|
- this.textTracks = [];
|
|
|
- this.tracks = [];
|
|
|
- this.initPTS = [];
|
|
|
- this.unparsedVttFrags = [];
|
|
|
- this.captionsTracks = {};
|
|
|
- this.nonNativeCaptionsTracks = {};
|
|
|
- this.cea608Parser1 = void 0;
|
|
|
- this.cea608Parser2 = void 0;
|
|
|
- this.lastCc = -1;
|
|
|
- this.lastSn = -1;
|
|
|
- this.lastPartIndex = -1;
|
|
|
- this.prevCC = -1;
|
|
|
- this.vttCCs = newVTTCCs();
|
|
|
- this.captionsProperties = void 0;
|
|
|
- this.hls = hls;
|
|
|
- this.config = hls.config;
|
|
|
- this.Cues = hls.config.cueHandler;
|
|
|
- this.captionsProperties = {
|
|
|
- textTrack1: {
|
|
|
- label: this.config.captionsTextTrack1Label,
|
|
|
- languageCode: this.config.captionsTextTrack1LanguageCode
|
|
|
- },
|
|
|
- textTrack2: {
|
|
|
- label: this.config.captionsTextTrack2Label,
|
|
|
- languageCode: this.config.captionsTextTrack2LanguageCode
|
|
|
- },
|
|
|
- textTrack3: {
|
|
|
- label: this.config.captionsTextTrack3Label,
|
|
|
- languageCode: this.config.captionsTextTrack3LanguageCode
|
|
|
- },
|
|
|
- textTrack4: {
|
|
|
- label: this.config.captionsTextTrack4Label,
|
|
|
- languageCode: this.config.captionsTextTrack4LanguageCode
|
|
|
- }
|
|
|
- };
|
|
|
- hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
|
|
|
- hls.on(Events.FRAG_LOADING, this.onFragLoading, this);
|
|
|
- hls.on(Events.FRAG_LOADED, this.onFragLoaded, this);
|
|
|
- hls.on(Events.FRAG_PARSING_USERDATA, this.onFragParsingUserdata, this);
|
|
|
- hls.on(Events.FRAG_DECRYPTED, this.onFragDecrypted, this);
|
|
|
- hls.on(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACKS_CLEARED, this.onSubtitleTracksCleared, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
|
|
|
- hls.off(Events.FRAG_LOADING, this.onFragLoading, this);
|
|
|
- hls.off(Events.FRAG_LOADED, this.onFragLoaded, this);
|
|
|
- hls.off(Events.FRAG_PARSING_USERDATA, this.onFragParsingUserdata, this);
|
|
|
- hls.off(Events.FRAG_DECRYPTED, this.onFragDecrypted, this);
|
|
|
- hls.off(Events.INIT_PTS_FOUND, this.onInitPtsFound, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACKS_CLEARED, this.onSubtitleTracksCleared, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- this.hls = this.config = this.media = null;
|
|
|
- this.cea608Parser1 = this.cea608Parser2 = void 0;
|
|
|
- }
|
|
|
- initCea608Parsers() {
|
|
|
- const channel1 = new OutputFilter(this, "textTrack1");
|
|
|
- const channel2 = new OutputFilter(this, "textTrack2");
|
|
|
- const channel3 = new OutputFilter(this, "textTrack3");
|
|
|
- const channel4 = new OutputFilter(this, "textTrack4");
|
|
|
- this.cea608Parser1 = new Cea608Parser(1, channel1, channel2);
|
|
|
- this.cea608Parser2 = new Cea608Parser(3, channel3, channel4);
|
|
|
- }
|
|
|
- addCues(trackName, startTime, endTime, screen, cueRanges) {
|
|
|
- let merged = false;
|
|
|
- for (let i = cueRanges.length; i--; ) {
|
|
|
- const cueRange = cueRanges[i];
|
|
|
- const overlap = intersection(cueRange[0], cueRange[1], startTime, endTime);
|
|
|
- if (overlap >= 0) {
|
|
|
- cueRange[0] = Math.min(cueRange[0], startTime);
|
|
|
- cueRange[1] = Math.max(cueRange[1], endTime);
|
|
|
- merged = true;
|
|
|
- if (overlap / (endTime - startTime) > 0.5) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (!merged) {
|
|
|
- cueRanges.push([startTime, endTime]);
|
|
|
- }
|
|
|
- if (this.config.renderTextTracksNatively) {
|
|
|
- const track = this.captionsTracks[trackName];
|
|
|
- this.Cues.newCue(track, startTime, endTime, screen);
|
|
|
- } else {
|
|
|
- const cues = this.Cues.newCue(null, startTime, endTime, screen);
|
|
|
- this.hls.trigger(Events.CUES_PARSED, {
|
|
|
- type: "captions",
|
|
|
- cues,
|
|
|
- track: trackName
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- // Triggered when an initial PTS is found; used for synchronisation of WebVTT.
|
|
|
- onInitPtsFound(event, {
|
|
|
- frag,
|
|
|
- id,
|
|
|
- initPTS,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- }) {
|
|
|
- const {
|
|
|
- unparsedVttFrags
|
|
|
- } = this;
|
|
|
- if (id === PlaylistLevelType.MAIN) {
|
|
|
- this.initPTS[frag.cc] = {
|
|
|
- baseTime: initPTS,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- };
|
|
|
- }
|
|
|
- if (unparsedVttFrags.length) {
|
|
|
- this.unparsedVttFrags = [];
|
|
|
- unparsedVttFrags.forEach((data) => {
|
|
|
- if (this.initPTS[data.frag.cc]) {
|
|
|
- this.onFragLoaded(Events.FRAG_LOADED, data);
|
|
|
- } else {
|
|
|
- this.hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
|
|
|
- success: false,
|
|
|
- frag: data.frag,
|
|
|
- error: new Error("Subtitle discontinuity domain does not match main")
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- getExistingTrack(label, language) {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (media) {
|
|
|
- for (let i = 0; i < media.textTracks.length; i++) {
|
|
|
- const textTrack = media.textTracks[i];
|
|
|
- if (canReuseVttTextTrack(textTrack, {
|
|
|
- name: label,
|
|
|
- lang: language,
|
|
|
- characteristics: "transcribes-spoken-dialog,describes-music-and-sound"
|
|
|
- })) {
|
|
|
- return textTrack;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- createCaptionsTrack(trackName) {
|
|
|
- if (this.config.renderTextTracksNatively) {
|
|
|
- this.createNativeTrack(trackName);
|
|
|
- } else {
|
|
|
- this.createNonNativeTrack(trackName);
|
|
|
- }
|
|
|
- }
|
|
|
- createNativeTrack(trackName) {
|
|
|
- if (this.captionsTracks[trackName]) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- captionsProperties,
|
|
|
- captionsTracks,
|
|
|
- media
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- label,
|
|
|
- languageCode
|
|
|
- } = captionsProperties[trackName];
|
|
|
- const existingTrack = this.getExistingTrack(label, languageCode);
|
|
|
- if (!existingTrack) {
|
|
|
- const textTrack = this.createTextTrack("captions", label, languageCode);
|
|
|
- if (textTrack) {
|
|
|
- textTrack[trackName] = true;
|
|
|
- captionsTracks[trackName] = textTrack;
|
|
|
- }
|
|
|
- } else {
|
|
|
- captionsTracks[trackName] = existingTrack;
|
|
|
- clearCurrentCues(captionsTracks[trackName]);
|
|
|
- sendAddTrackEvent(captionsTracks[trackName], media);
|
|
|
- }
|
|
|
- }
|
|
|
- createNonNativeTrack(trackName) {
|
|
|
- if (this.nonNativeCaptionsTracks[trackName]) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const trackProperties = this.captionsProperties[trackName];
|
|
|
- if (!trackProperties) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const label = trackProperties.label;
|
|
|
- const track = {
|
|
|
- _id: trackName,
|
|
|
- label,
|
|
|
- kind: "captions",
|
|
|
- default: trackProperties.media ? !!trackProperties.media.default : false,
|
|
|
- closedCaptions: trackProperties.media
|
|
|
- };
|
|
|
- this.nonNativeCaptionsTracks[trackName] = track;
|
|
|
- this.hls.trigger(Events.NON_NATIVE_TEXT_TRACKS_FOUND, {
|
|
|
- tracks: [track]
|
|
|
- });
|
|
|
- }
|
|
|
- createTextTrack(kind, label, lang) {
|
|
|
- const media = this.media;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- return media.addTextTrack(kind, label, lang);
|
|
|
- }
|
|
|
- onMediaAttaching(event, data) {
|
|
|
- this.media = data.media;
|
|
|
- if (!data.mediaSource) {
|
|
|
- this._cleanTracks();
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- const transferringMedia = !!data.transferMedia;
|
|
|
- this.media = null;
|
|
|
- if (transferringMedia) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- captionsTracks
|
|
|
- } = this;
|
|
|
- Object.keys(captionsTracks).forEach((trackName) => {
|
|
|
- clearCurrentCues(captionsTracks[trackName]);
|
|
|
- delete captionsTracks[trackName];
|
|
|
- });
|
|
|
- this.nonNativeCaptionsTracks = {};
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.lastCc = -1;
|
|
|
- this.lastSn = -1;
|
|
|
- this.lastPartIndex = -1;
|
|
|
- this.prevCC = -1;
|
|
|
- this.vttCCs = newVTTCCs();
|
|
|
- this._cleanTracks();
|
|
|
- this.tracks = [];
|
|
|
- this.captionsTracks = {};
|
|
|
- this.nonNativeCaptionsTracks = {};
|
|
|
- this.textTracks = [];
|
|
|
- this.unparsedVttFrags = [];
|
|
|
- this.initPTS = [];
|
|
|
- if (this.cea608Parser1 && this.cea608Parser2) {
|
|
|
- this.cea608Parser1.reset();
|
|
|
- this.cea608Parser2.reset();
|
|
|
- }
|
|
|
- }
|
|
|
- _cleanTracks() {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const textTracks = media.textTracks;
|
|
|
- if (textTracks) {
|
|
|
- for (let i = 0; i < textTracks.length; i++) {
|
|
|
- clearCurrentCues(textTracks[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onSubtitleTracksUpdated(event, data) {
|
|
|
- const tracks = data.subtitleTracks || [];
|
|
|
- const hasIMSC1 = tracks.some((track) => track.textCodec === IMSC1_CODEC);
|
|
|
- if (this.config.enableWebVTT || hasIMSC1 && this.config.enableIMSC1) {
|
|
|
- const listIsIdentical = subtitleOptionsIdentical(this.tracks, tracks);
|
|
|
- if (listIsIdentical) {
|
|
|
- this.tracks = tracks;
|
|
|
- return;
|
|
|
- }
|
|
|
- this.textTracks = [];
|
|
|
- this.tracks = tracks;
|
|
|
- if (this.config.renderTextTracksNatively) {
|
|
|
- const media = this.media;
|
|
|
- const inUseTracks = media ? filterSubtitleTracks(media.textTracks) : null;
|
|
|
- this.tracks.forEach((track, index) => {
|
|
|
- let textTrack;
|
|
|
- if (inUseTracks) {
|
|
|
- let inUseTrack = null;
|
|
|
- for (let i = 0; i < inUseTracks.length; i++) {
|
|
|
- if (inUseTracks[i] && canReuseVttTextTrack(inUseTracks[i], track)) {
|
|
|
- inUseTrack = inUseTracks[i];
|
|
|
- inUseTracks[i] = null;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (inUseTrack) {
|
|
|
- textTrack = inUseTrack;
|
|
|
- }
|
|
|
- }
|
|
|
- if (textTrack) {
|
|
|
- clearCurrentCues(textTrack);
|
|
|
- } else {
|
|
|
- const textTrackKind = captionsOrSubtitlesFromCharacteristics(track);
|
|
|
- textTrack = this.createTextTrack(textTrackKind, track.name, track.lang);
|
|
|
- if (textTrack) {
|
|
|
- textTrack.mode = "disabled";
|
|
|
- }
|
|
|
- }
|
|
|
- if (textTrack) {
|
|
|
- this.textTracks.push(textTrack);
|
|
|
- }
|
|
|
- });
|
|
|
- if (inUseTracks != null && inUseTracks.length) {
|
|
|
- const unusedTextTracks = inUseTracks.filter((t) => t !== null).map((t) => t.label);
|
|
|
- if (unusedTextTracks.length) {
|
|
|
- this.hls.logger.warn(`Media element contains unused subtitle tracks: ${unusedTextTracks.join(", ")}. Replace media element for each source to clear TextTracks and captions menu.`);
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (this.tracks.length) {
|
|
|
- const tracksList = this.tracks.map((track) => {
|
|
|
- return {
|
|
|
- label: track.name,
|
|
|
- kind: track.type.toLowerCase(),
|
|
|
- default: track.default,
|
|
|
- subtitleTrack: track
|
|
|
- };
|
|
|
- });
|
|
|
- this.hls.trigger(Events.NON_NATIVE_TEXT_TRACKS_FOUND, {
|
|
|
- tracks: tracksList
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onManifestLoaded(event, data) {
|
|
|
- if (this.config.enableCEA708Captions && data.captions) {
|
|
|
- data.captions.forEach((captionsTrack) => {
|
|
|
- const instreamIdMatch = /(?:CC|SERVICE)([1-4])/.exec(captionsTrack.instreamId);
|
|
|
- if (!instreamIdMatch) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const trackName = `textTrack${instreamIdMatch[1]}`;
|
|
|
- const trackProperties = this.captionsProperties[trackName];
|
|
|
- if (!trackProperties) {
|
|
|
- return;
|
|
|
- }
|
|
|
- trackProperties.label = captionsTrack.name;
|
|
|
- if (captionsTrack.lang) {
|
|
|
- trackProperties.languageCode = captionsTrack.lang;
|
|
|
- }
|
|
|
- trackProperties.media = captionsTrack;
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- closedCaptionsForLevel(frag) {
|
|
|
- const level = this.hls.levels[frag.level];
|
|
|
- return level == null ? void 0 : level.attrs["CLOSED-CAPTIONS"];
|
|
|
- }
|
|
|
- onFragLoading(event, data) {
|
|
|
- if (this.enabled && data.frag.type === PlaylistLevelType.MAIN) {
|
|
|
- var _data$part$index, _data$part;
|
|
|
- const {
|
|
|
- cea608Parser1,
|
|
|
- cea608Parser2,
|
|
|
- lastSn
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- cc,
|
|
|
- sn
|
|
|
- } = data.frag;
|
|
|
- const partIndex = (_data$part$index = (_data$part = data.part) == null ? void 0 : _data$part.index) != null ? _data$part$index : -1;
|
|
|
- if (cea608Parser1 && cea608Parser2) {
|
|
|
- if (sn !== lastSn + 1 || sn === lastSn && partIndex !== this.lastPartIndex + 1 || cc !== this.lastCc) {
|
|
|
- cea608Parser1.reset();
|
|
|
- cea608Parser2.reset();
|
|
|
- }
|
|
|
- }
|
|
|
- this.lastCc = cc;
|
|
|
- this.lastSn = sn;
|
|
|
- this.lastPartIndex = partIndex;
|
|
|
- }
|
|
|
- }
|
|
|
- onFragLoaded(event, data) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- payload
|
|
|
- } = data;
|
|
|
- if (frag.type === PlaylistLevelType.SUBTITLE) {
|
|
|
- if (payload.byteLength) {
|
|
|
- const decryptData = frag.decryptdata;
|
|
|
- const decrypted = "stats" in data;
|
|
|
- if (decryptData == null || !decryptData.encrypted || decrypted) {
|
|
|
- const trackPlaylistMedia = this.tracks[frag.level];
|
|
|
- const vttCCs = this.vttCCs;
|
|
|
- if (!vttCCs[frag.cc]) {
|
|
|
- vttCCs[frag.cc] = {
|
|
|
- start: frag.start,
|
|
|
- prevCC: this.prevCC,
|
|
|
- new: true
|
|
|
- };
|
|
|
- this.prevCC = frag.cc;
|
|
|
- }
|
|
|
- if (trackPlaylistMedia && trackPlaylistMedia.textCodec === IMSC1_CODEC) {
|
|
|
- this._parseIMSC1(frag, payload);
|
|
|
- } else {
|
|
|
- this._parseVTTs(data);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
|
|
|
- success: false,
|
|
|
- frag,
|
|
|
- error: new Error("Empty subtitle payload")
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- _parseIMSC1(frag, payload) {
|
|
|
- const hls = this.hls;
|
|
|
- parseIMSC1(payload, this.initPTS[frag.cc], (cues) => {
|
|
|
- this._appendCues(cues, frag.level);
|
|
|
- hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
|
|
|
- success: true,
|
|
|
- frag
|
|
|
- });
|
|
|
- }, (error) => {
|
|
|
- hls.logger.log(`Failed to parse IMSC1: ${error}`);
|
|
|
- hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
|
|
|
- success: false,
|
|
|
- frag,
|
|
|
- error
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- _parseVTTs(data) {
|
|
|
- var _frag$initSegment;
|
|
|
- const {
|
|
|
- frag,
|
|
|
- payload
|
|
|
- } = data;
|
|
|
- const {
|
|
|
- initPTS,
|
|
|
- unparsedVttFrags
|
|
|
- } = this;
|
|
|
- const maxAvCC = initPTS.length - 1;
|
|
|
- if (!initPTS[frag.cc] && maxAvCC === -1) {
|
|
|
- unparsedVttFrags.push(data);
|
|
|
- return;
|
|
|
- }
|
|
|
- const hls = this.hls;
|
|
|
- const payloadWebVTT = (_frag$initSegment = frag.initSegment) != null && _frag$initSegment.data ? appendUint8Array(frag.initSegment.data, new Uint8Array(payload)).buffer : payload;
|
|
|
- parseWebVTT(payloadWebVTT, this.initPTS[frag.cc], this.vttCCs, frag.cc, frag.start, (cues) => {
|
|
|
- this._appendCues(cues, frag.level);
|
|
|
- hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
|
|
|
- success: true,
|
|
|
- frag
|
|
|
- });
|
|
|
- }, (error) => {
|
|
|
- const missingInitPTS = error.message === "Missing initPTS for VTT MPEGTS";
|
|
|
- if (missingInitPTS) {
|
|
|
- unparsedVttFrags.push(data);
|
|
|
- } else {
|
|
|
- this._fallbackToIMSC1(frag, payload);
|
|
|
- }
|
|
|
- hls.logger.log(`Failed to parse VTT cue: ${error}`);
|
|
|
- if (missingInitPTS && maxAvCC > frag.cc) {
|
|
|
- return;
|
|
|
- }
|
|
|
- hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
|
|
|
- success: false,
|
|
|
- frag,
|
|
|
- error
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- _fallbackToIMSC1(frag, payload) {
|
|
|
- const trackPlaylistMedia = this.tracks[frag.level];
|
|
|
- if (!trackPlaylistMedia.textCodec) {
|
|
|
- parseIMSC1(payload, this.initPTS[frag.cc], () => {
|
|
|
- trackPlaylistMedia.textCodec = IMSC1_CODEC;
|
|
|
- this._parseIMSC1(frag, payload);
|
|
|
- }, () => {
|
|
|
- trackPlaylistMedia.textCodec = "wvtt";
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- _appendCues(cues, fragLevel) {
|
|
|
- const hls = this.hls;
|
|
|
- if (this.config.renderTextTracksNatively) {
|
|
|
- const textTrack = this.textTracks[fragLevel];
|
|
|
- if (!textTrack || textTrack.mode === "disabled") {
|
|
|
- return;
|
|
|
- }
|
|
|
- cues.forEach((cue) => addCueToTrack(textTrack, cue));
|
|
|
- } else {
|
|
|
- const currentTrack = this.tracks[fragLevel];
|
|
|
- if (!currentTrack) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const track = currentTrack.default ? "default" : "subtitles" + fragLevel;
|
|
|
- hls.trigger(Events.CUES_PARSED, {
|
|
|
- type: "subtitles",
|
|
|
- cues,
|
|
|
- track
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- onFragDecrypted(event, data) {
|
|
|
- const {
|
|
|
- frag
|
|
|
- } = data;
|
|
|
- if (frag.type === PlaylistLevelType.SUBTITLE) {
|
|
|
- this.onFragLoaded(Events.FRAG_LOADED, data);
|
|
|
- }
|
|
|
- }
|
|
|
- onSubtitleTracksCleared() {
|
|
|
- this.tracks = [];
|
|
|
- this.captionsTracks = {};
|
|
|
- }
|
|
|
- onFragParsingUserdata(event, data) {
|
|
|
- if (!this.enabled || !this.config.enableCEA708Captions) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- frag,
|
|
|
- samples
|
|
|
- } = data;
|
|
|
- if (frag.type === PlaylistLevelType.MAIN && this.closedCaptionsForLevel(frag) === "NONE") {
|
|
|
- return;
|
|
|
- }
|
|
|
- for (let i = 0; i < samples.length; i++) {
|
|
|
- const ccBytes = samples[i].bytes;
|
|
|
- if (ccBytes) {
|
|
|
- if (!this.cea608Parser1) {
|
|
|
- this.initCea608Parsers();
|
|
|
- }
|
|
|
- const ccdatas = this.extractCea608Data(ccBytes);
|
|
|
- this.cea608Parser1.addData(samples[i].pts, ccdatas[0]);
|
|
|
- this.cea608Parser2.addData(samples[i].pts, ccdatas[1]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferFlushing(event, {
|
|
|
- startOffset,
|
|
|
- endOffset,
|
|
|
- endOffsetSubtitles,
|
|
|
- type
|
|
|
- }) {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (!media || media.currentTime < endOffset) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!type || type === "video") {
|
|
|
- const {
|
|
|
- captionsTracks
|
|
|
- } = this;
|
|
|
- Object.keys(captionsTracks).forEach((trackName) => removeCuesInRange(captionsTracks[trackName], startOffset, endOffset));
|
|
|
- }
|
|
|
- if (this.config.renderTextTracksNatively) {
|
|
|
- if (startOffset === 0 && endOffsetSubtitles !== void 0) {
|
|
|
- const {
|
|
|
- textTracks
|
|
|
- } = this;
|
|
|
- Object.keys(textTracks).forEach((trackName) => removeCuesInRange(textTracks[trackName], startOffset, endOffsetSubtitles));
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- extractCea608Data(byteArray) {
|
|
|
- const actualCCBytes = [[], []];
|
|
|
- const count = byteArray[0] & 31;
|
|
|
- let position = 2;
|
|
|
- for (let j = 0; j < count; j++) {
|
|
|
- const tmpByte = byteArray[position++];
|
|
|
- const ccbyte1 = 127 & byteArray[position++];
|
|
|
- const ccbyte2 = 127 & byteArray[position++];
|
|
|
- if (ccbyte1 === 0 && ccbyte2 === 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- const ccValid = (4 & tmpByte) !== 0;
|
|
|
- if (ccValid) {
|
|
|
- const ccType = 3 & tmpByte;
|
|
|
- if (0 === ccType || 1 === ccType) {
|
|
|
- actualCCBytes[ccType].push(ccbyte1);
|
|
|
- actualCCBytes[ccType].push(ccbyte2);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return actualCCBytes;
|
|
|
- }
|
|
|
-};
|
|
|
-function captionsOrSubtitlesFromCharacteristics(track) {
|
|
|
- if (track.characteristics) {
|
|
|
- if (/transcribes-spoken-dialog/gi.test(track.characteristics) && /describes-music-and-sound/gi.test(track.characteristics)) {
|
|
|
- return "captions";
|
|
|
- }
|
|
|
- }
|
|
|
- return "subtitles";
|
|
|
-}
|
|
|
-function canReuseVttTextTrack(inUseTrack, manifestTrack) {
|
|
|
- return !!inUseTrack && inUseTrack.kind === captionsOrSubtitlesFromCharacteristics(manifestTrack) && subtitleTrackMatchesTextTrack(manifestTrack, inUseTrack);
|
|
|
-}
|
|
|
-function intersection(x1, x2, y1, y2) {
|
|
|
- return Math.min(x2, y2) - Math.max(x1, y1);
|
|
|
-}
|
|
|
-function newVTTCCs() {
|
|
|
- return {
|
|
|
- ccOffset: 0,
|
|
|
- presentationOffset: 0,
|
|
|
- 0: {
|
|
|
- start: 0,
|
|
|
- prevCC: -1,
|
|
|
- new: true
|
|
|
- }
|
|
|
- };
|
|
|
-}
|
|
|
-var WHITESPACE_CHAR = /\s/;
|
|
|
-var Cues = {
|
|
|
- newCue(track, startTime, endTime, captionScreen) {
|
|
|
- const result = [];
|
|
|
- let row;
|
|
|
- let cue;
|
|
|
- let indenting;
|
|
|
- let indent;
|
|
|
- let text;
|
|
|
- const Cue = self.VTTCue || self.TextTrackCue;
|
|
|
- for (let r = 0; r < captionScreen.rows.length; r++) {
|
|
|
- row = captionScreen.rows[r];
|
|
|
- indenting = true;
|
|
|
- indent = 0;
|
|
|
- text = "";
|
|
|
- if (!row.isEmpty()) {
|
|
|
- var _track$cues;
|
|
|
- for (let c = 0; c < row.chars.length; c++) {
|
|
|
- if (WHITESPACE_CHAR.test(row.chars[c].uchar) && indenting) {
|
|
|
- indent++;
|
|
|
- } else {
|
|
|
- text += row.chars[c].uchar;
|
|
|
- indenting = false;
|
|
|
- }
|
|
|
- }
|
|
|
- row.cueStartTime = startTime;
|
|
|
- if (startTime === endTime) {
|
|
|
- endTime += 1e-4;
|
|
|
- }
|
|
|
- if (indent >= 16) {
|
|
|
- indent--;
|
|
|
- } else {
|
|
|
- indent++;
|
|
|
- }
|
|
|
- const cueText = fixLineBreaks(text.trim());
|
|
|
- const id = generateCueId(startTime, endTime, cueText);
|
|
|
- if (!(track != null && (_track$cues = track.cues) != null && _track$cues.getCueById(id))) {
|
|
|
- cue = new Cue(startTime, endTime, cueText);
|
|
|
- cue.id = id;
|
|
|
- cue.line = r + 1;
|
|
|
- cue.align = "left";
|
|
|
- cue.position = 10 + Math.min(80, Math.floor(indent * 8 / 32) * 10);
|
|
|
- result.push(cue);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (track && result.length) {
|
|
|
- result.sort((cueA, cueB) => {
|
|
|
- if (cueA.line === "auto" || cueB.line === "auto") {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if (cueA.line > 8 && cueB.line > 8) {
|
|
|
- return cueB.line - cueA.line;
|
|
|
- }
|
|
|
- return cueA.line - cueB.line;
|
|
|
- });
|
|
|
- result.forEach((cue2) => addCueToTrack(track, cue2));
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
-};
|
|
|
-function fetchSupported() {
|
|
|
- if (
|
|
|
- // @ts-ignore
|
|
|
- self.fetch && self.AbortController && self.ReadableStream && self.Request
|
|
|
- ) {
|
|
|
- try {
|
|
|
- new self.ReadableStream({});
|
|
|
- return true;
|
|
|
- } catch (e) {
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-var BYTERANGE = /(\d+)-(\d+)\/(\d+)/;
|
|
|
-var FetchLoader = class {
|
|
|
- constructor(config) {
|
|
|
- this.fetchSetup = void 0;
|
|
|
- this.requestTimeout = void 0;
|
|
|
- this.request = null;
|
|
|
- this.response = null;
|
|
|
- this.controller = void 0;
|
|
|
- this.context = null;
|
|
|
- this.config = null;
|
|
|
- this.callbacks = null;
|
|
|
- this.stats = void 0;
|
|
|
- this.loader = null;
|
|
|
- this.fetchSetup = config.fetchSetup || getRequest;
|
|
|
- this.controller = new self.AbortController();
|
|
|
- this.stats = new LoadStats();
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.loader = this.callbacks = this.context = this.config = this.request = null;
|
|
|
- this.abortInternal();
|
|
|
- this.response = null;
|
|
|
- this.fetchSetup = this.controller = this.stats = null;
|
|
|
- }
|
|
|
- abortInternal() {
|
|
|
- if (this.controller && !this.stats.loading.end) {
|
|
|
- this.stats.aborted = true;
|
|
|
- this.controller.abort();
|
|
|
- }
|
|
|
- }
|
|
|
- abort() {
|
|
|
- var _this$callbacks;
|
|
|
- this.abortInternal();
|
|
|
- if ((_this$callbacks = this.callbacks) != null && _this$callbacks.onAbort) {
|
|
|
- this.callbacks.onAbort(this.stats, this.context, this.response);
|
|
|
- }
|
|
|
- }
|
|
|
- load(context, config, callbacks) {
|
|
|
- const stats = this.stats;
|
|
|
- if (stats.loading.start) {
|
|
|
- throw new Error("Loader can only be used once.");
|
|
|
- }
|
|
|
- stats.loading.start = self.performance.now();
|
|
|
- const initParams = getRequestParameters(context, this.controller.signal);
|
|
|
- const isArrayBuffer = context.responseType === "arraybuffer";
|
|
|
- const LENGTH = isArrayBuffer ? "byteLength" : "length";
|
|
|
- const {
|
|
|
- maxTimeToFirstByteMs,
|
|
|
- maxLoadTimeMs
|
|
|
- } = config.loadPolicy;
|
|
|
- this.context = context;
|
|
|
- this.config = config;
|
|
|
- this.callbacks = callbacks;
|
|
|
- this.request = this.fetchSetup(context, initParams);
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- config.timeout = maxTimeToFirstByteMs && isFiniteNumber(maxTimeToFirstByteMs) ? maxTimeToFirstByteMs : maxLoadTimeMs;
|
|
|
- this.requestTimeout = self.setTimeout(() => {
|
|
|
- if (this.callbacks) {
|
|
|
- this.abortInternal();
|
|
|
- this.callbacks.onTimeout(stats, context, this.response);
|
|
|
- }
|
|
|
- }, config.timeout);
|
|
|
- const fetchPromise = isPromise(this.request) ? this.request.then(self.fetch) : self.fetch(this.request);
|
|
|
- fetchPromise.then((response) => {
|
|
|
- var _this$callbacks2;
|
|
|
- this.response = this.loader = response;
|
|
|
- const first = Math.max(self.performance.now(), stats.loading.start);
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- config.timeout = maxLoadTimeMs;
|
|
|
- this.requestTimeout = self.setTimeout(() => {
|
|
|
- if (this.callbacks) {
|
|
|
- this.abortInternal();
|
|
|
- this.callbacks.onTimeout(stats, context, this.response);
|
|
|
- }
|
|
|
- }, maxLoadTimeMs - (first - stats.loading.start));
|
|
|
- if (!response.ok) {
|
|
|
- const {
|
|
|
- status: status2,
|
|
|
- statusText
|
|
|
- } = response;
|
|
|
- throw new FetchError(statusText || "fetch, bad network response", status2, response);
|
|
|
- }
|
|
|
- stats.loading.first = first;
|
|
|
- stats.total = getContentLength(response.headers) || stats.total;
|
|
|
- const onProgress = (_this$callbacks2 = this.callbacks) == null ? void 0 : _this$callbacks2.onProgress;
|
|
|
- if (onProgress && isFiniteNumber(config.highWaterMark)) {
|
|
|
- return this.loadProgressively(response, stats, context, config.highWaterMark, onProgress);
|
|
|
- }
|
|
|
- if (isArrayBuffer) {
|
|
|
- return response.arrayBuffer();
|
|
|
- }
|
|
|
- if (context.responseType === "json") {
|
|
|
- return response.json();
|
|
|
- }
|
|
|
- return response.text();
|
|
|
- }).then((responseData) => {
|
|
|
- var _this$callbacks3, _this$callbacks4;
|
|
|
- const response = this.response;
|
|
|
- if (!response) {
|
|
|
- throw new Error("loader destroyed");
|
|
|
- }
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
|
|
|
- const total = responseData[LENGTH];
|
|
|
- if (total) {
|
|
|
- stats.loaded = stats.total = total;
|
|
|
- }
|
|
|
- const loaderResponse = {
|
|
|
- url: response.url,
|
|
|
- data: responseData,
|
|
|
- code: response.status
|
|
|
- };
|
|
|
- const onProgress = (_this$callbacks3 = this.callbacks) == null ? void 0 : _this$callbacks3.onProgress;
|
|
|
- if (onProgress && !isFiniteNumber(config.highWaterMark)) {
|
|
|
- onProgress(stats, context, responseData, response);
|
|
|
- }
|
|
|
- (_this$callbacks4 = this.callbacks) == null || _this$callbacks4.onSuccess(loaderResponse, stats, context, response);
|
|
|
- }).catch((error) => {
|
|
|
- var _this$callbacks5;
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- if (stats.aborted) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const code = !error ? 0 : error.code || 0;
|
|
|
- const text = !error ? null : error.message;
|
|
|
- (_this$callbacks5 = this.callbacks) == null || _this$callbacks5.onError({
|
|
|
- code,
|
|
|
- text
|
|
|
- }, context, error ? error.details : null, stats);
|
|
|
- });
|
|
|
- }
|
|
|
- getCacheAge() {
|
|
|
- let result = null;
|
|
|
- if (this.response) {
|
|
|
- const ageHeader = this.response.headers.get("age");
|
|
|
- result = ageHeader ? parseFloat(ageHeader) : null;
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- getResponseHeader(name) {
|
|
|
- return this.response ? this.response.headers.get(name) : null;
|
|
|
- }
|
|
|
- loadProgressively(response, stats, context, highWaterMark = 0, onProgress) {
|
|
|
- const chunkCache = new ChunkCache();
|
|
|
- const reader = response.body.getReader();
|
|
|
- const pump = () => {
|
|
|
- return reader.read().then((data) => {
|
|
|
- if (data.done) {
|
|
|
- if (chunkCache.dataLength) {
|
|
|
- onProgress(stats, context, chunkCache.flush().buffer, response);
|
|
|
- }
|
|
|
- return Promise.resolve(new ArrayBuffer(0));
|
|
|
- }
|
|
|
- const chunk = data.value;
|
|
|
- const len = chunk.length;
|
|
|
- stats.loaded += len;
|
|
|
- if (len < highWaterMark || chunkCache.dataLength) {
|
|
|
- chunkCache.push(chunk);
|
|
|
- if (chunkCache.dataLength >= highWaterMark) {
|
|
|
- onProgress(stats, context, chunkCache.flush().buffer, response);
|
|
|
- }
|
|
|
- } else {
|
|
|
- onProgress(stats, context, chunk.buffer, response);
|
|
|
- }
|
|
|
- return pump();
|
|
|
- }).catch(() => {
|
|
|
- return Promise.reject();
|
|
|
- });
|
|
|
- };
|
|
|
- return pump();
|
|
|
- }
|
|
|
-};
|
|
|
-function getRequestParameters(context, signal) {
|
|
|
- const initParams = {
|
|
|
- method: "GET",
|
|
|
- mode: "cors",
|
|
|
- credentials: "same-origin",
|
|
|
- signal,
|
|
|
- headers: new self.Headers(_extends({}, context.headers))
|
|
|
- };
|
|
|
- if (context.rangeEnd) {
|
|
|
- initParams.headers.set("Range", "bytes=" + context.rangeStart + "-" + String(context.rangeEnd - 1));
|
|
|
- }
|
|
|
- return initParams;
|
|
|
-}
|
|
|
-function getByteRangeLength(byteRangeHeader) {
|
|
|
- const result = BYTERANGE.exec(byteRangeHeader);
|
|
|
- if (result) {
|
|
|
- return parseInt(result[2]) - parseInt(result[1]) + 1;
|
|
|
- }
|
|
|
-}
|
|
|
-function getContentLength(headers) {
|
|
|
- const contentRange = headers.get("Content-Range");
|
|
|
- if (contentRange) {
|
|
|
- const byteRangeLength = getByteRangeLength(contentRange);
|
|
|
- if (isFiniteNumber(byteRangeLength)) {
|
|
|
- return byteRangeLength;
|
|
|
- }
|
|
|
- }
|
|
|
- const contentLength = headers.get("Content-Length");
|
|
|
- if (contentLength) {
|
|
|
- return parseInt(contentLength);
|
|
|
- }
|
|
|
-}
|
|
|
-function getRequest(context, initParams) {
|
|
|
- return new self.Request(context.url, initParams);
|
|
|
-}
|
|
|
-var FetchError = class extends Error {
|
|
|
- constructor(message, code, details) {
|
|
|
- super(message);
|
|
|
- this.code = void 0;
|
|
|
- this.details = void 0;
|
|
|
- this.code = code;
|
|
|
- this.details = details;
|
|
|
- }
|
|
|
-};
|
|
|
-var AGE_HEADER_LINE_REGEX = /^age:\s*[\d.]+\s*$/im;
|
|
|
-var XhrLoader = class {
|
|
|
- constructor(config) {
|
|
|
- this.xhrSetup = void 0;
|
|
|
- this.requestTimeout = void 0;
|
|
|
- this.retryTimeout = void 0;
|
|
|
- this.retryDelay = void 0;
|
|
|
- this.config = null;
|
|
|
- this.callbacks = null;
|
|
|
- this.context = null;
|
|
|
- this.loader = null;
|
|
|
- this.stats = void 0;
|
|
|
- this.xhrSetup = config ? config.xhrSetup || null : null;
|
|
|
- this.stats = new LoadStats();
|
|
|
- this.retryDelay = 0;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.callbacks = null;
|
|
|
- this.abortInternal();
|
|
|
- this.loader = null;
|
|
|
- this.config = null;
|
|
|
- this.context = null;
|
|
|
- this.xhrSetup = null;
|
|
|
- }
|
|
|
- abortInternal() {
|
|
|
- const loader = this.loader;
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- self.clearTimeout(this.retryTimeout);
|
|
|
- if (loader) {
|
|
|
- loader.onreadystatechange = null;
|
|
|
- loader.onprogress = null;
|
|
|
- if (loader.readyState !== 4) {
|
|
|
- this.stats.aborted = true;
|
|
|
- loader.abort();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- abort() {
|
|
|
- var _this$callbacks;
|
|
|
- this.abortInternal();
|
|
|
- if ((_this$callbacks = this.callbacks) != null && _this$callbacks.onAbort) {
|
|
|
- this.callbacks.onAbort(this.stats, this.context, this.loader);
|
|
|
- }
|
|
|
- }
|
|
|
- load(context, config, callbacks) {
|
|
|
- if (this.stats.loading.start) {
|
|
|
- throw new Error("Loader can only be used once.");
|
|
|
- }
|
|
|
- this.stats.loading.start = self.performance.now();
|
|
|
- this.context = context;
|
|
|
- this.config = config;
|
|
|
- this.callbacks = callbacks;
|
|
|
- this.loadInternal();
|
|
|
- }
|
|
|
- loadInternal() {
|
|
|
- const {
|
|
|
- config,
|
|
|
- context
|
|
|
- } = this;
|
|
|
- if (!config || !context) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const xhr = this.loader = new self.XMLHttpRequest();
|
|
|
- const stats = this.stats;
|
|
|
- stats.loading.first = 0;
|
|
|
- stats.loaded = 0;
|
|
|
- stats.aborted = false;
|
|
|
- const xhrSetup = this.xhrSetup;
|
|
|
- if (xhrSetup) {
|
|
|
- Promise.resolve().then(() => {
|
|
|
- if (this.loader !== xhr || this.stats.aborted)
|
|
|
- return;
|
|
|
- return xhrSetup(xhr, context.url);
|
|
|
- }).catch((error) => {
|
|
|
- if (this.loader !== xhr || this.stats.aborted)
|
|
|
- return;
|
|
|
- xhr.open("GET", context.url, true);
|
|
|
- return xhrSetup(xhr, context.url);
|
|
|
- }).then(() => {
|
|
|
- if (this.loader !== xhr || this.stats.aborted)
|
|
|
- return;
|
|
|
- this.openAndSendXhr(xhr, context, config);
|
|
|
- }).catch((error) => {
|
|
|
- var _this$callbacks2;
|
|
|
- (_this$callbacks2 = this.callbacks) == null || _this$callbacks2.onError({
|
|
|
- code: xhr.status,
|
|
|
- text: error.message
|
|
|
- }, context, xhr, stats);
|
|
|
- return;
|
|
|
- });
|
|
|
- } else {
|
|
|
- this.openAndSendXhr(xhr, context, config);
|
|
|
- }
|
|
|
- }
|
|
|
- openAndSendXhr(xhr, context, config) {
|
|
|
- if (!xhr.readyState) {
|
|
|
- xhr.open("GET", context.url, true);
|
|
|
- }
|
|
|
- const headers = context.headers;
|
|
|
- const {
|
|
|
- maxTimeToFirstByteMs,
|
|
|
- maxLoadTimeMs
|
|
|
- } = config.loadPolicy;
|
|
|
- if (headers) {
|
|
|
- for (const header in headers) {
|
|
|
- xhr.setRequestHeader(header, headers[header]);
|
|
|
- }
|
|
|
- }
|
|
|
- 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;
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- config.timeout = maxTimeToFirstByteMs && isFiniteNumber(maxTimeToFirstByteMs) ? maxTimeToFirstByteMs : maxLoadTimeMs;
|
|
|
- this.requestTimeout = self.setTimeout(this.loadtimeout.bind(this), config.timeout);
|
|
|
- xhr.send();
|
|
|
- }
|
|
|
- readystatechange() {
|
|
|
- const {
|
|
|
- context,
|
|
|
- loader: xhr,
|
|
|
- stats
|
|
|
- } = this;
|
|
|
- if (!context || !xhr) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const readyState = xhr.readyState;
|
|
|
- const config = this.config;
|
|
|
- if (stats.aborted) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (readyState >= 2) {
|
|
|
- if (stats.loading.first === 0) {
|
|
|
- stats.loading.first = Math.max(self.performance.now(), stats.loading.start);
|
|
|
- if (config.timeout !== config.loadPolicy.maxLoadTimeMs) {
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- config.timeout = config.loadPolicy.maxLoadTimeMs;
|
|
|
- this.requestTimeout = self.setTimeout(this.loadtimeout.bind(this), config.loadPolicy.maxLoadTimeMs - (stats.loading.first - stats.loading.start));
|
|
|
- }
|
|
|
- }
|
|
|
- if (readyState === 4) {
|
|
|
- self.clearTimeout(this.requestTimeout);
|
|
|
- xhr.onreadystatechange = null;
|
|
|
- xhr.onprogress = null;
|
|
|
- const status2 = xhr.status;
|
|
|
- const useResponseText = xhr.responseType === "text" ? xhr.responseText : null;
|
|
|
- if (status2 >= 200 && status2 < 300) {
|
|
|
- const data = useResponseText != null ? useResponseText : xhr.response;
|
|
|
- if (data != null) {
|
|
|
- var _this$callbacks3, _this$callbacks4;
|
|
|
- stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
|
|
|
- const len = xhr.responseType === "arraybuffer" ? data.byteLength : data.length;
|
|
|
- stats.loaded = stats.total = len;
|
|
|
- stats.bwEstimate = stats.total * 8e3 / (stats.loading.end - stats.loading.first);
|
|
|
- const onProgress = (_this$callbacks3 = this.callbacks) == null ? void 0 : _this$callbacks3.onProgress;
|
|
|
- if (onProgress) {
|
|
|
- onProgress(stats, context, data, xhr);
|
|
|
- }
|
|
|
- const _response = {
|
|
|
- url: xhr.responseURL,
|
|
|
- data,
|
|
|
- code: status2
|
|
|
- };
|
|
|
- (_this$callbacks4 = this.callbacks) == null || _this$callbacks4.onSuccess(_response, stats, context, xhr);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const retryConfig = config.loadPolicy.errorRetry;
|
|
|
- const retryCount = stats.retry;
|
|
|
- const response = {
|
|
|
- url: context.url,
|
|
|
- data: void 0,
|
|
|
- code: status2
|
|
|
- };
|
|
|
- if (shouldRetry(retryConfig, retryCount, false, response)) {
|
|
|
- this.retry(retryConfig);
|
|
|
- } else {
|
|
|
- var _this$callbacks5;
|
|
|
- logger.error(`${status2} while loading ${context.url}`);
|
|
|
- (_this$callbacks5 = this.callbacks) == null || _this$callbacks5.onError({
|
|
|
- code: status2,
|
|
|
- text: xhr.statusText
|
|
|
- }, context, xhr, stats);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- loadtimeout() {
|
|
|
- if (!this.config)
|
|
|
- return;
|
|
|
- const retryConfig = this.config.loadPolicy.timeoutRetry;
|
|
|
- const retryCount = this.stats.retry;
|
|
|
- if (shouldRetry(retryConfig, retryCount, true)) {
|
|
|
- this.retry(retryConfig);
|
|
|
- } else {
|
|
|
- var _this$context;
|
|
|
- logger.warn(`timeout while loading ${(_this$context = this.context) == null ? void 0 : _this$context.url}`);
|
|
|
- const callbacks = this.callbacks;
|
|
|
- if (callbacks) {
|
|
|
- this.abortInternal();
|
|
|
- callbacks.onTimeout(this.stats, this.context, this.loader);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- retry(retryConfig) {
|
|
|
- const {
|
|
|
- context,
|
|
|
- stats
|
|
|
- } = this;
|
|
|
- this.retryDelay = getRetryDelay(retryConfig, stats.retry);
|
|
|
- stats.retry++;
|
|
|
- logger.warn(`${status ? "HTTP Status " + status : "Timeout"} while loading ${context == null ? void 0 : context.url}, retrying ${stats.retry}/${retryConfig.maxNumRetry} in ${this.retryDelay}ms`);
|
|
|
- this.abortInternal();
|
|
|
- this.loader = null;
|
|
|
- self.clearTimeout(this.retryTimeout);
|
|
|
- this.retryTimeout = self.setTimeout(this.loadInternal.bind(this), this.retryDelay);
|
|
|
- }
|
|
|
- loadprogress(event) {
|
|
|
- const stats = this.stats;
|
|
|
- stats.loaded = event.loaded;
|
|
|
- if (event.lengthComputable) {
|
|
|
- stats.total = event.total;
|
|
|
- }
|
|
|
- }
|
|
|
- getCacheAge() {
|
|
|
- let result = null;
|
|
|
- if (this.loader && AGE_HEADER_LINE_REGEX.test(this.loader.getAllResponseHeaders())) {
|
|
|
- const ageHeader = this.loader.getResponseHeader("age");
|
|
|
- result = ageHeader ? parseFloat(ageHeader) : null;
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- getResponseHeader(name) {
|
|
|
- if (this.loader && new RegExp(`^${name}:\\s*[\\d.]+\\s*$`, "im").test(this.loader.getAllResponseHeaders())) {
|
|
|
- return this.loader.getResponseHeader(name);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
-};
|
|
|
-var defaultLoadPolicy = {
|
|
|
- maxTimeToFirstByteMs: 8e3,
|
|
|
- maxLoadTimeMs: 2e4,
|
|
|
- timeoutRetry: null,
|
|
|
- errorRetry: null
|
|
|
-};
|
|
|
-var hlsDefaultConfig = _objectSpread2(_objectSpread2({
|
|
|
- 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
|
|
|
- ignoreDevicePixelRatio: false,
|
|
|
- // used by cap-level-controller
|
|
|
- maxDevicePixelRatio: Number.POSITIVE_INFINITY,
|
|
|
- // used by cap-level-controller
|
|
|
- preferManagedMediaSource: true,
|
|
|
- initialLiveManifestSize: 1,
|
|
|
- // used by stream-controller
|
|
|
- maxBufferLength: 30,
|
|
|
- // used by stream-controller
|
|
|
- backBufferLength: Infinity,
|
|
|
- // used by buffer-controller
|
|
|
- frontBufferFlushThreshold: Infinity,
|
|
|
- startOnSegmentBoundary: false,
|
|
|
- // used by stream-controller
|
|
|
- maxBufferSize: 60 * 1e3 * 1e3,
|
|
|
- // used by stream-controller
|
|
|
- maxFragLookUpTolerance: 0.25,
|
|
|
- // used by stream-controller
|
|
|
- maxBufferHole: 0.1,
|
|
|
- // used by stream-controller and gap-controller
|
|
|
- detectStallWithCurrentTimeMs: 1250,
|
|
|
- // used by gap-controller
|
|
|
- highBufferWatchdogPeriod: 2,
|
|
|
- // used by gap-controller
|
|
|
- nudgeOffset: 0.1,
|
|
|
- // used by gap-controller
|
|
|
- nudgeMaxRetry: 3,
|
|
|
- // used by gap-controller
|
|
|
- nudgeOnVideoHole: true,
|
|
|
- // used by gap-controller
|
|
|
- liveSyncMode: "edge",
|
|
|
- // used by stream-controller
|
|
|
- liveSyncDurationCount: 3,
|
|
|
- // used by latency-controller
|
|
|
- liveSyncOnStallIncrease: 1,
|
|
|
- // used by latency-controller
|
|
|
- liveMaxLatencyDurationCount: Infinity,
|
|
|
- // used by latency-controller
|
|
|
- liveSyncDuration: void 0,
|
|
|
- // used by latency-controller
|
|
|
- liveMaxLatencyDuration: void 0,
|
|
|
- // used by latency-controller
|
|
|
- maxLiveSyncPlaybackRate: 1,
|
|
|
- // used by latency-controller
|
|
|
- liveDurationInfinity: false,
|
|
|
- // used by buffer-controller
|
|
|
- /**
|
|
|
- * @deprecated use backBufferLength
|
|
|
- */
|
|
|
- liveBackBufferLength: null,
|
|
|
- // used by buffer-controller
|
|
|
- maxMaxBufferLength: 600,
|
|
|
- // used by stream-controller
|
|
|
- enableWorker: true,
|
|
|
- // used by transmuxer
|
|
|
- workerPath: null,
|
|
|
- // used by transmuxer
|
|
|
- enableSoftwareAES: true,
|
|
|
- // used by decrypter
|
|
|
- startLevel: void 0,
|
|
|
- // used by level-controller
|
|
|
- startFragPrefetch: false,
|
|
|
- // used by stream-controller
|
|
|
- fpsDroppedMonitoringPeriod: 5e3,
|
|
|
- // used by fps-controller
|
|
|
- fpsDroppedMonitoringThreshold: 0.2,
|
|
|
- // used by fps-controller
|
|
|
- appendErrorMaxRetry: 3,
|
|
|
- // used by buffer-controller
|
|
|
- ignorePlaylistParsingErrors: false,
|
|
|
- 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
|
|
|
- licenseResponseCallback: void 0,
|
|
|
- // used by eme-controller
|
|
|
- abrController: AbrController,
|
|
|
- bufferController: BufferController,
|
|
|
- capLevelController: CapLevelController,
|
|
|
- errorController: ErrorController,
|
|
|
- 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
|
|
|
- abrEwmaDefaultEstimateMax: 5e6,
|
|
|
- // 5 mbps
|
|
|
- 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
|
|
|
- drmSystems: {},
|
|
|
- // used by eme-controller
|
|
|
- drmSystemOptions: {},
|
|
|
- // used by eme-controller
|
|
|
- requestMediaKeySystemAccessFunc: requestMediaKeySystemAccess,
|
|
|
- // used by eme-controller
|
|
|
- requireKeySystemAccessOnStart: false,
|
|
|
- // used by eme-controller
|
|
|
- testBandwidth: true,
|
|
|
- progressive: false,
|
|
|
- lowLatencyMode: true,
|
|
|
- cmcd: void 0,
|
|
|
- enableDateRangeMetadataCues: true,
|
|
|
- enableEmsgMetadataCues: true,
|
|
|
- enableEmsgKLVMetadata: false,
|
|
|
- enableID3MetadataCues: true,
|
|
|
- enableInterstitialPlayback: true,
|
|
|
- interstitialAppendInPlace: true,
|
|
|
- interstitialLiveLookAhead: 10,
|
|
|
- useMediaCapabilities: true,
|
|
|
- preserveManualLevelOnError: false,
|
|
|
- certLoadPolicy: {
|
|
|
- default: defaultLoadPolicy
|
|
|
- },
|
|
|
- keyLoadPolicy: {
|
|
|
- default: {
|
|
|
- maxTimeToFirstByteMs: 8e3,
|
|
|
- maxLoadTimeMs: 2e4,
|
|
|
- timeoutRetry: {
|
|
|
- maxNumRetry: 1,
|
|
|
- retryDelayMs: 1e3,
|
|
|
- maxRetryDelayMs: 2e4,
|
|
|
- backoff: "linear"
|
|
|
- },
|
|
|
- errorRetry: {
|
|
|
- maxNumRetry: 8,
|
|
|
- retryDelayMs: 1e3,
|
|
|
- maxRetryDelayMs: 2e4,
|
|
|
- backoff: "linear"
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- manifestLoadPolicy: {
|
|
|
- default: {
|
|
|
- maxTimeToFirstByteMs: Infinity,
|
|
|
- maxLoadTimeMs: 2e4,
|
|
|
- timeoutRetry: {
|
|
|
- maxNumRetry: 2,
|
|
|
- retryDelayMs: 0,
|
|
|
- maxRetryDelayMs: 0
|
|
|
- },
|
|
|
- errorRetry: {
|
|
|
- maxNumRetry: 1,
|
|
|
- retryDelayMs: 1e3,
|
|
|
- maxRetryDelayMs: 8e3
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- playlistLoadPolicy: {
|
|
|
- default: {
|
|
|
- maxTimeToFirstByteMs: 1e4,
|
|
|
- maxLoadTimeMs: 2e4,
|
|
|
- timeoutRetry: {
|
|
|
- maxNumRetry: 2,
|
|
|
- retryDelayMs: 0,
|
|
|
- maxRetryDelayMs: 0
|
|
|
- },
|
|
|
- errorRetry: {
|
|
|
- maxNumRetry: 2,
|
|
|
- retryDelayMs: 1e3,
|
|
|
- maxRetryDelayMs: 8e3
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- fragLoadPolicy: {
|
|
|
- default: {
|
|
|
- maxTimeToFirstByteMs: 1e4,
|
|
|
- maxLoadTimeMs: 12e4,
|
|
|
- timeoutRetry: {
|
|
|
- maxNumRetry: 4,
|
|
|
- retryDelayMs: 0,
|
|
|
- maxRetryDelayMs: 0
|
|
|
- },
|
|
|
- errorRetry: {
|
|
|
- maxNumRetry: 6,
|
|
|
- retryDelayMs: 1e3,
|
|
|
- maxRetryDelayMs: 8e3
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- steeringManifestLoadPolicy: {
|
|
|
- default: {
|
|
|
- maxTimeToFirstByteMs: 1e4,
|
|
|
- maxLoadTimeMs: 2e4,
|
|
|
- timeoutRetry: {
|
|
|
- maxNumRetry: 2,
|
|
|
- retryDelayMs: 0,
|
|
|
- maxRetryDelayMs: 0
|
|
|
- },
|
|
|
- errorRetry: {
|
|
|
- maxNumRetry: 1,
|
|
|
- retryDelayMs: 1e3,
|
|
|
- maxRetryDelayMs: 8e3
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- interstitialAssetListLoadPolicy: {
|
|
|
- default: {
|
|
|
- maxTimeToFirstByteMs: 1e4,
|
|
|
- maxLoadTimeMs: 3e4,
|
|
|
- timeoutRetry: {
|
|
|
- maxNumRetry: 0,
|
|
|
- retryDelayMs: 0,
|
|
|
- maxRetryDelayMs: 0
|
|
|
- },
|
|
|
- errorRetry: {
|
|
|
- maxNumRetry: 0,
|
|
|
- retryDelayMs: 1e3,
|
|
|
- maxRetryDelayMs: 8e3
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- // These default settings are deprecated in favor of the above policies
|
|
|
- // and are maintained for backwards compatibility
|
|
|
- manifestLoadingTimeOut: 1e4,
|
|
|
- manifestLoadingMaxRetry: 1,
|
|
|
- manifestLoadingRetryDelay: 1e3,
|
|
|
- manifestLoadingMaxRetryTimeout: 64e3,
|
|
|
- levelLoadingTimeOut: 1e4,
|
|
|
- levelLoadingMaxRetry: 4,
|
|
|
- levelLoadingRetryDelay: 1e3,
|
|
|
- levelLoadingMaxRetryTimeout: 64e3,
|
|
|
- fragLoadingTimeOut: 2e4,
|
|
|
- fragLoadingMaxRetry: 6,
|
|
|
- fragLoadingRetryDelay: 1e3,
|
|
|
- fragLoadingMaxRetryTimeout: 64e3
|
|
|
-}, timelineConfig()), {}, {
|
|
|
- subtitleStreamController: SubtitleStreamController,
|
|
|
- subtitleTrackController: SubtitleTrackController,
|
|
|
- timelineController: TimelineController,
|
|
|
- audioStreamController: AudioStreamController,
|
|
|
- audioTrackController: AudioTrackController,
|
|
|
- emeController: EMEController,
|
|
|
- cmcdController: CMCDController,
|
|
|
- contentSteeringController: ContentSteeringController,
|
|
|
- interstitialsController: InterstitialsController
|
|
|
-});
|
|
|
-function timelineConfig() {
|
|
|
- return {
|
|
|
- cueHandler: Cues,
|
|
|
- // used by timeline-controller
|
|
|
- enableWebVTT: true,
|
|
|
- // used by timeline-controller
|
|
|
- enableIMSC1: true,
|
|
|
- // used by timeline-controller
|
|
|
- enableCEA708Captions: 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
|
|
|
- captionsTextTrack3Label: "Unknown CC",
|
|
|
- // used by timeline-controller
|
|
|
- captionsTextTrack3LanguageCode: "",
|
|
|
- // used by timeline-controller
|
|
|
- captionsTextTrack4Label: "Unknown CC",
|
|
|
- // used by timeline-controller
|
|
|
- captionsTextTrack4LanguageCode: "",
|
|
|
- // used by timeline-controller
|
|
|
- renderTextTracksNatively: true
|
|
|
- };
|
|
|
-}
|
|
|
-function mergeConfig(defaultConfig, userConfig, logger2) {
|
|
|
- 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");
|
|
|
- }
|
|
|
- if (userConfig.liveMaxLatencyDurationCount !== void 0 && (userConfig.liveSyncDurationCount === void 0 || userConfig.liveMaxLatencyDurationCount <= userConfig.liveSyncDurationCount)) {
|
|
|
- throw new Error('Illegal hls.js config: "liveMaxLatencyDurationCount" must be greater than "liveSyncDurationCount"');
|
|
|
- }
|
|
|
- if (userConfig.liveMaxLatencyDuration !== void 0 && (userConfig.liveSyncDuration === void 0 || userConfig.liveMaxLatencyDuration <= userConfig.liveSyncDuration)) {
|
|
|
- throw new Error('Illegal hls.js config: "liveMaxLatencyDuration" must be greater than "liveSyncDuration"');
|
|
|
- }
|
|
|
- const defaultsCopy = deepCpy(defaultConfig);
|
|
|
- const deprecatedSettingTypes = ["manifest", "level", "frag"];
|
|
|
- const deprecatedSettings = ["TimeOut", "MaxRetry", "RetryDelay", "MaxRetryTimeout"];
|
|
|
- deprecatedSettingTypes.forEach((type) => {
|
|
|
- const policyName = `${type === "level" ? "playlist" : type}LoadPolicy`;
|
|
|
- const policyNotSet = userConfig[policyName] === void 0;
|
|
|
- const report = [];
|
|
|
- deprecatedSettings.forEach((setting) => {
|
|
|
- const deprecatedSetting = `${type}Loading${setting}`;
|
|
|
- const value = userConfig[deprecatedSetting];
|
|
|
- if (value !== void 0 && policyNotSet) {
|
|
|
- report.push(deprecatedSetting);
|
|
|
- const settings = defaultsCopy[policyName].default;
|
|
|
- userConfig[policyName] = {
|
|
|
- default: settings
|
|
|
- };
|
|
|
- switch (setting) {
|
|
|
- case "TimeOut":
|
|
|
- settings.maxLoadTimeMs = value;
|
|
|
- settings.maxTimeToFirstByteMs = value;
|
|
|
- break;
|
|
|
- case "MaxRetry":
|
|
|
- settings.errorRetry.maxNumRetry = value;
|
|
|
- settings.timeoutRetry.maxNumRetry = value;
|
|
|
- break;
|
|
|
- case "RetryDelay":
|
|
|
- settings.errorRetry.retryDelayMs = value;
|
|
|
- settings.timeoutRetry.retryDelayMs = value;
|
|
|
- break;
|
|
|
- case "MaxRetryTimeout":
|
|
|
- settings.errorRetry.maxRetryDelayMs = value;
|
|
|
- settings.timeoutRetry.maxRetryDelayMs = value;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- if (report.length) {
|
|
|
- logger2.warn(`hls.js config: "${report.join('", "')}" setting(s) are deprecated, use "${policyName}": ${stringify(userConfig[policyName])}`);
|
|
|
- }
|
|
|
- });
|
|
|
- return _objectSpread2(_objectSpread2({}, defaultsCopy), userConfig);
|
|
|
-}
|
|
|
-function deepCpy(obj) {
|
|
|
- if (obj && typeof obj === "object") {
|
|
|
- if (Array.isArray(obj)) {
|
|
|
- return obj.map(deepCpy);
|
|
|
- }
|
|
|
- return Object.keys(obj).reduce((result, key) => {
|
|
|
- result[key] = deepCpy(obj[key]);
|
|
|
- return result;
|
|
|
- }, {});
|
|
|
- }
|
|
|
- return obj;
|
|
|
-}
|
|
|
-function enableStreamingMode(config, logger2) {
|
|
|
- const currentLoader = config.loader;
|
|
|
- if (currentLoader !== FetchLoader && currentLoader !== XhrLoader) {
|
|
|
- logger2.log("[config]: Custom loader detected, cannot enable progressive streaming");
|
|
|
- config.progressive = false;
|
|
|
- } else {
|
|
|
- const canStreamProgressively = fetchSupported();
|
|
|
- if (canStreamProgressively) {
|
|
|
- config.loader = FetchLoader;
|
|
|
- config.progressive = true;
|
|
|
- config.enableSoftwareAES = true;
|
|
|
- logger2.log("[config]: Progressive streaming enabled, using FetchLoader");
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-var MAX_START_GAP_JUMP = 2;
|
|
|
-var SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
|
|
|
-var SKIP_BUFFER_RANGE_START = 0.05;
|
|
|
-var TICK_INTERVAL$1 = 100;
|
|
|
-var GapController = class extends TaskLoop {
|
|
|
- constructor(hls, fragmentTracker) {
|
|
|
- super("gap-controller", hls.logger);
|
|
|
- this.hls = void 0;
|
|
|
- this.fragmentTracker = void 0;
|
|
|
- this.media = null;
|
|
|
- this.mediaSource = void 0;
|
|
|
- this.nudgeRetry = 0;
|
|
|
- this.stallReported = false;
|
|
|
- this.stalled = null;
|
|
|
- this.moved = false;
|
|
|
- this.seeking = false;
|
|
|
- this.buffered = {};
|
|
|
- this.lastCurrentTime = 0;
|
|
|
- this.ended = 0;
|
|
|
- this.waiting = 0;
|
|
|
- this.onMediaPlaying = () => {
|
|
|
- this.ended = 0;
|
|
|
- this.waiting = 0;
|
|
|
- };
|
|
|
- this.onMediaWaiting = () => {
|
|
|
- var _this$media;
|
|
|
- if ((_this$media = this.media) != null && _this$media.seeking) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.waiting = self.performance.now();
|
|
|
- this.tick();
|
|
|
- };
|
|
|
- this.onMediaEnded = () => {
|
|
|
- if (this.hls) {
|
|
|
- var _this$media2;
|
|
|
- this.ended = ((_this$media2 = this.media) == null ? void 0 : _this$media2.currentTime) || 1;
|
|
|
- this.hls.trigger(Events.MEDIA_ENDED, {
|
|
|
- stalled: false
|
|
|
- });
|
|
|
- }
|
|
|
- };
|
|
|
- this.hls = hls;
|
|
|
- this.fragmentTracker = fragmentTracker;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (hls) {
|
|
|
- hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.BUFFER_APPENDED, this.onBufferAppended, this);
|
|
|
- }
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (hls) {
|
|
|
- hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.BUFFER_APPENDED, this.onBufferAppended, this);
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- super.destroy();
|
|
|
- this.unregisterListeners();
|
|
|
- this.media = this.hls = this.fragmentTracker = null;
|
|
|
- this.mediaSource = void 0;
|
|
|
- }
|
|
|
- onMediaAttached(event, data) {
|
|
|
- this.setInterval(TICK_INTERVAL$1);
|
|
|
- this.mediaSource = data.mediaSource;
|
|
|
- const media = this.media = data.media;
|
|
|
- addEventListener(media, "playing", this.onMediaPlaying);
|
|
|
- addEventListener(media, "waiting", this.onMediaWaiting);
|
|
|
- addEventListener(media, "ended", this.onMediaEnded);
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- this.clearInterval();
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (media) {
|
|
|
- removeEventListener(media, "playing", this.onMediaPlaying);
|
|
|
- removeEventListener(media, "waiting", this.onMediaWaiting);
|
|
|
- removeEventListener(media, "ended", this.onMediaEnded);
|
|
|
- this.media = null;
|
|
|
- }
|
|
|
- this.mediaSource = void 0;
|
|
|
- }
|
|
|
- onBufferAppended(event, data) {
|
|
|
- this.buffered = data.timeRanges;
|
|
|
- }
|
|
|
- get hasBuffered() {
|
|
|
- return Object.keys(this.buffered).length > 0;
|
|
|
- }
|
|
|
- tick() {
|
|
|
- var _this$media3;
|
|
|
- if (!((_this$media3 = this.media) != null && _this$media3.readyState) || !this.hasBuffered) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentTime = this.media.currentTime;
|
|
|
- this.poll(currentTime, this.lastCurrentTime);
|
|
|
- this.lastCurrentTime = currentTime;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Checks if the playhead is stuck within a gap, and if so, attempts to free it.
|
|
|
- * A gap is an unbuffered range between two buffered ranges (or the start and the first buffered range).
|
|
|
- *
|
|
|
- * @param lastCurrentTime - Previously read playhead position
|
|
|
- */
|
|
|
- poll(currentTime, lastCurrentTime) {
|
|
|
- var _this$hls, _this$hls2;
|
|
|
- const config = (_this$hls = this.hls) == null ? void 0 : _this$hls.config;
|
|
|
- if (!config) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const media = this.media;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- seeking
|
|
|
- } = media;
|
|
|
- const seeked = this.seeking && !seeking;
|
|
|
- const beginSeek = !this.seeking && seeking;
|
|
|
- const pausedEndedOrHalted = media.paused && !seeking || media.ended || media.playbackRate === 0;
|
|
|
- this.seeking = seeking;
|
|
|
- if (currentTime !== lastCurrentTime) {
|
|
|
- if (lastCurrentTime) {
|
|
|
- this.ended = 0;
|
|
|
- }
|
|
|
- this.moved = true;
|
|
|
- if (!seeking) {
|
|
|
- this.nudgeRetry = 0;
|
|
|
- if (config.nudgeOnVideoHole && !pausedEndedOrHalted && currentTime > lastCurrentTime) {
|
|
|
- this.nudgeOnVideoHole(currentTime, lastCurrentTime);
|
|
|
- }
|
|
|
- }
|
|
|
- if (this.waiting === 0) {
|
|
|
- this.stallResolved(currentTime);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if (beginSeek || seeked) {
|
|
|
- if (seeked) {
|
|
|
- this.stallResolved(currentTime);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if (pausedEndedOrHalted) {
|
|
|
- this.nudgeRetry = 0;
|
|
|
- this.stallResolved(currentTime);
|
|
|
- if (!this.ended && media.ended && this.hls) {
|
|
|
- this.ended = currentTime || 1;
|
|
|
- this.hls.trigger(Events.MEDIA_ENDED, {
|
|
|
- stalled: false
|
|
|
- });
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!BufferHelper.getBuffered(media).length) {
|
|
|
- this.nudgeRetry = 0;
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
|
|
|
- const nextStart = bufferInfo.nextStart || 0;
|
|
|
- const fragmentTracker = this.fragmentTracker;
|
|
|
- if (seeking && fragmentTracker && this.hls) {
|
|
|
- const inFlightDependency = getInFlightDependency(this.hls.inFlightFragments, currentTime);
|
|
|
- const hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP;
|
|
|
- const noBufferHole = !nextStart || inFlightDependency || nextStart - currentTime > MAX_START_GAP_JUMP && !fragmentTracker.getPartialFragment(currentTime);
|
|
|
- if (hasEnoughBuffer || noBufferHole) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.moved = false;
|
|
|
- }
|
|
|
- const levelDetails = (_this$hls2 = this.hls) == null ? void 0 : _this$hls2.latestLevelDetails;
|
|
|
- if (!this.moved && this.stalled !== null && fragmentTracker) {
|
|
|
- const isBuffered = bufferInfo.len > 0;
|
|
|
- if (!isBuffered && !nextStart) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const startJump = Math.max(nextStart, bufferInfo.start || 0) - currentTime;
|
|
|
- const isLive = !!(levelDetails != null && levelDetails.live);
|
|
|
- const maxStartGapJump = isLive ? levelDetails.targetduration * 2 : MAX_START_GAP_JUMP;
|
|
|
- const appended = appendedFragAtPosition(currentTime, fragmentTracker);
|
|
|
- if (startJump > 0 && (startJump <= maxStartGapJump || appended)) {
|
|
|
- if (!media.paused) {
|
|
|
- this._trySkipBufferHole(appended);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const detectStallWithCurrentTimeMs = config.detectStallWithCurrentTimeMs;
|
|
|
- const tnow = self.performance.now();
|
|
|
- const tWaiting = this.waiting;
|
|
|
- let stalled = this.stalled;
|
|
|
- if (stalled === null) {
|
|
|
- if (tWaiting > 0 && tnow - tWaiting < detectStallWithCurrentTimeMs) {
|
|
|
- stalled = this.stalled = tWaiting;
|
|
|
- } else {
|
|
|
- this.stalled = tnow;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const stalledDuration = tnow - stalled;
|
|
|
- if (!seeking && (stalledDuration >= detectStallWithCurrentTimeMs || tWaiting) && this.hls) {
|
|
|
- var _this$mediaSource;
|
|
|
- if (((_this$mediaSource = this.mediaSource) == null ? void 0 : _this$mediaSource.readyState) === "ended" && !(levelDetails != null && levelDetails.live) && Math.abs(currentTime - ((levelDetails == null ? void 0 : levelDetails.edge) || 0)) < 1) {
|
|
|
- if (this.ended) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.ended = currentTime || 1;
|
|
|
- this.hls.trigger(Events.MEDIA_ENDED, {
|
|
|
- stalled: true
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- this._reportStall(bufferInfo);
|
|
|
- if (!this.media || !this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const bufferedWithHoles = BufferHelper.bufferInfo(media, currentTime, config.maxBufferHole);
|
|
|
- this._tryFixBufferStall(bufferedWithHoles, stalledDuration, currentTime);
|
|
|
- }
|
|
|
- stallResolved(currentTime) {
|
|
|
- const stalled = this.stalled;
|
|
|
- if (stalled && this.hls) {
|
|
|
- this.stalled = null;
|
|
|
- if (this.stallReported) {
|
|
|
- const stalledDuration = self.performance.now() - stalled;
|
|
|
- this.log(`playback not stuck anymore @${currentTime}, after ${Math.round(stalledDuration)}ms`);
|
|
|
- this.stallReported = false;
|
|
|
- this.waiting = 0;
|
|
|
- this.hls.trigger(Events.STALL_RESOLVED, {});
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- nudgeOnVideoHole(currentTime, lastCurrentTime) {
|
|
|
- var _this$buffered$audio;
|
|
|
- const videoSourceBuffered = this.buffered.video;
|
|
|
- if (this.hls && this.media && this.fragmentTracker && (_this$buffered$audio = this.buffered.audio) != null && _this$buffered$audio.length && videoSourceBuffered && videoSourceBuffered.length > 1 && currentTime > videoSourceBuffered.end(0)) {
|
|
|
- const audioBufferInfo = BufferHelper.bufferedInfo(BufferHelper.timeRangesToArray(this.buffered.audio), currentTime, 0);
|
|
|
- if (audioBufferInfo.len > 1 && lastCurrentTime >= audioBufferInfo.start) {
|
|
|
- const videoTimes = BufferHelper.timeRangesToArray(videoSourceBuffered);
|
|
|
- const lastBufferedIndex = BufferHelper.bufferedInfo(videoTimes, lastCurrentTime, 0).bufferedIndex;
|
|
|
- if (lastBufferedIndex > -1 && lastBufferedIndex < videoTimes.length - 1) {
|
|
|
- const bufferedIndex = BufferHelper.bufferedInfo(videoTimes, currentTime, 0).bufferedIndex;
|
|
|
- const holeStart = videoTimes[lastBufferedIndex].end;
|
|
|
- const holeEnd = videoTimes[lastBufferedIndex + 1].start;
|
|
|
- if ((bufferedIndex === -1 || bufferedIndex > lastBufferedIndex) && holeEnd - holeStart < 1 && // `maxBufferHole` may be too small and setting it to 0 should not disable this feature
|
|
|
- currentTime - holeStart < 2) {
|
|
|
- const error = new Error(`nudging playhead to flush pipeline after video hole. currentTime: ${currentTime} hole: ${holeStart} -> ${holeEnd} buffered index: ${bufferedIndex}`);
|
|
|
- this.warn(error.message);
|
|
|
- this.media.currentTime += 1e-6;
|
|
|
- let frag = appendedFragAtPosition(currentTime, this.fragmentTracker);
|
|
|
- if (frag && "fragment" in frag) {
|
|
|
- frag = frag.fragment;
|
|
|
- } else if (!frag) {
|
|
|
- frag = void 0;
|
|
|
- }
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(this.media, currentTime, 0);
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_SEEK_OVER_HOLE,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- reason: error.message,
|
|
|
- frag,
|
|
|
- buffer: bufferInfo.len,
|
|
|
- bufferInfo
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Detects and attempts to fix known buffer stalling issues.
|
|
|
- * @param bufferInfo - The properties of the current buffer.
|
|
|
- * @param stalledDurationMs - The amount of time Hls.js has been stalling for.
|
|
|
- * @private
|
|
|
- */
|
|
|
- _tryFixBufferStall(bufferInfo, stalledDurationMs, currentTime) {
|
|
|
- var _this$hls3, _this$hls4;
|
|
|
- const {
|
|
|
- fragmentTracker,
|
|
|
- media
|
|
|
- } = this;
|
|
|
- const config = (_this$hls3 = this.hls) == null ? void 0 : _this$hls3.config;
|
|
|
- if (!media || !fragmentTracker || !config) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const levelDetails = (_this$hls4 = this.hls) == null ? void 0 : _this$hls4.latestLevelDetails;
|
|
|
- const appended = appendedFragAtPosition(currentTime, fragmentTracker);
|
|
|
- if (appended || levelDetails != null && levelDetails.live && currentTime < levelDetails.fragmentStart) {
|
|
|
- const targetTime = this._trySkipBufferHole(appended);
|
|
|
- if (targetTime || !this.media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- const bufferedRanges = bufferInfo.buffered;
|
|
|
- const adjacentTraversal = this.adjacentTraversal(bufferInfo, currentTime);
|
|
|
- if ((bufferedRanges && bufferedRanges.length > 1 && bufferInfo.len > config.maxBufferHole || bufferInfo.nextStart && (bufferInfo.nextStart - currentTime < config.maxBufferHole || adjacentTraversal)) && (stalledDurationMs > config.highBufferWatchdogPeriod * 1e3 || this.waiting)) {
|
|
|
- this.warn("Trying to nudge playhead over buffer-hole");
|
|
|
- this._tryNudgeBuffer(bufferInfo);
|
|
|
- }
|
|
|
- }
|
|
|
- adjacentTraversal(bufferInfo, currentTime) {
|
|
|
- const fragmentTracker = this.fragmentTracker;
|
|
|
- const nextStart = bufferInfo.nextStart;
|
|
|
- if (fragmentTracker && nextStart) {
|
|
|
- const current = fragmentTracker.getFragAtPos(currentTime, PlaylistLevelType.MAIN);
|
|
|
- const next = fragmentTracker.getFragAtPos(nextStart, PlaylistLevelType.MAIN);
|
|
|
- if (current && next) {
|
|
|
- return next.sn - current.sn < 2;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Triggers a BUFFER_STALLED_ERROR event, but only once per stall period.
|
|
|
- * @param bufferLen - The playhead distance from the end of the current buffer segment.
|
|
|
- * @private
|
|
|
- */
|
|
|
- _reportStall(bufferInfo) {
|
|
|
- const {
|
|
|
- hls,
|
|
|
- media,
|
|
|
- stallReported,
|
|
|
- stalled
|
|
|
- } = this;
|
|
|
- if (!stallReported && stalled !== null && media && hls) {
|
|
|
- this.stallReported = true;
|
|
|
- const error = new Error(`Playback stalling at @${media.currentTime} due to low buffer (${stringify(bufferInfo)})`);
|
|
|
- this.warn(error.message);
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_STALLED_ERROR,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- buffer: bufferInfo.len,
|
|
|
- bufferInfo,
|
|
|
- stalled: {
|
|
|
- start: stalled
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Attempts to fix buffer stalls by jumping over known gaps caused by partial fragments
|
|
|
- * @param appended - The fragment or part found at the current time (where playback is stalling).
|
|
|
- * @private
|
|
|
- */
|
|
|
- _trySkipBufferHole(appended) {
|
|
|
- var _this$hls5;
|
|
|
- const {
|
|
|
- fragmentTracker,
|
|
|
- media
|
|
|
- } = this;
|
|
|
- const config = (_this$hls5 = this.hls) == null ? void 0 : _this$hls5.config;
|
|
|
- if (!media || !fragmentTracker || !config) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const currentTime = media.currentTime;
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(media, currentTime, 0);
|
|
|
- const startTime = currentTime < bufferInfo.start ? bufferInfo.start : bufferInfo.nextStart;
|
|
|
- if (startTime && this.hls) {
|
|
|
- const bufferStarved = bufferInfo.len <= config.maxBufferHole;
|
|
|
- const waiting = bufferInfo.len > 0 && bufferInfo.len < 1 && media.readyState < 3;
|
|
|
- const gapLength = startTime - currentTime;
|
|
|
- if (gapLength > 0 && (bufferStarved || waiting)) {
|
|
|
- if (gapLength > config.maxBufferHole) {
|
|
|
- let startGap = false;
|
|
|
- if (currentTime === 0) {
|
|
|
- const startFrag = fragmentTracker.getAppendedFrag(0, PlaylistLevelType.MAIN);
|
|
|
- if (startFrag && startTime < startFrag.end) {
|
|
|
- startGap = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!startGap && appended) {
|
|
|
- var _this$hls$loadLevelOb;
|
|
|
- if (!((_this$hls$loadLevelOb = this.hls.loadLevelObj) != null && _this$hls$loadLevelOb.details)) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const inFlightDependency = getInFlightDependency(this.hls.inFlightFragments, startTime);
|
|
|
- if (inFlightDependency) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- let moreToLoad = false;
|
|
|
- let pos = appended.end;
|
|
|
- while (pos < startTime) {
|
|
|
- const provisioned = appendedFragAtPosition(pos, fragmentTracker);
|
|
|
- if (provisioned) {
|
|
|
- pos += provisioned.duration;
|
|
|
- } else {
|
|
|
- moreToLoad = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (moreToLoad) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
|
|
|
- this.warn(`skipping hole, adjusting currentTime from ${currentTime} to ${targetTime}`);
|
|
|
- this.moved = true;
|
|
|
- media.currentTime = targetTime;
|
|
|
- if (!(appended != null && appended.gap)) {
|
|
|
- const error = new Error(`fragment loaded with buffer holes, seeking from ${currentTime} to ${targetTime}`);
|
|
|
- const errorData = {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_SEEK_OVER_HOLE,
|
|
|
- fatal: false,
|
|
|
- error,
|
|
|
- reason: error.message,
|
|
|
- buffer: bufferInfo.len,
|
|
|
- bufferInfo
|
|
|
- };
|
|
|
- if (appended) {
|
|
|
- if ("fragment" in appended) {
|
|
|
- errorData.part = appended;
|
|
|
- } else {
|
|
|
- errorData.frag = appended;
|
|
|
- }
|
|
|
- }
|
|
|
- this.hls.trigger(Events.ERROR, errorData);
|
|
|
- }
|
|
|
- return targetTime;
|
|
|
- }
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
|
|
|
- * @private
|
|
|
- */
|
|
|
- _tryNudgeBuffer(bufferInfo) {
|
|
|
- const {
|
|
|
- hls,
|
|
|
- media,
|
|
|
- nudgeRetry
|
|
|
- } = this;
|
|
|
- const config = hls == null ? void 0 : hls.config;
|
|
|
- if (!media || !config) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const currentTime = media.currentTime;
|
|
|
- this.nudgeRetry++;
|
|
|
- if (nudgeRetry < config.nudgeMaxRetry) {
|
|
|
- const targetTime = currentTime + (nudgeRetry + 1) * config.nudgeOffset;
|
|
|
- const error = new Error(`Nudging 'currentTime' from ${currentTime} to ${targetTime}`);
|
|
|
- this.warn(error.message);
|
|
|
- media.currentTime = targetTime;
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_NUDGE_ON_STALL,
|
|
|
- error,
|
|
|
- fatal: false,
|
|
|
- buffer: bufferInfo.len,
|
|
|
- bufferInfo
|
|
|
- });
|
|
|
- } else {
|
|
|
- const error = new Error(`Playhead still not moving while enough data buffered @${currentTime} after ${config.nudgeMaxRetry} nudges`);
|
|
|
- this.error(error.message);
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.BUFFER_STALLED_ERROR,
|
|
|
- error,
|
|
|
- fatal: true,
|
|
|
- buffer: bufferInfo.len,
|
|
|
- bufferInfo
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function getInFlightDependency(inFlightFragments, currentTime) {
|
|
|
- const main = inFlight(inFlightFragments.main);
|
|
|
- if (main && main.start <= currentTime) {
|
|
|
- return main;
|
|
|
- }
|
|
|
- const audio = inFlight(inFlightFragments.audio);
|
|
|
- if (audio && audio.start <= currentTime) {
|
|
|
- return audio;
|
|
|
- }
|
|
|
- return null;
|
|
|
-}
|
|
|
-function inFlight(inFlightData) {
|
|
|
- if (!inFlightData) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- switch (inFlightData.state) {
|
|
|
- case State.IDLE:
|
|
|
- case State.STOPPED:
|
|
|
- case State.ENDED:
|
|
|
- case State.ERROR:
|
|
|
- return null;
|
|
|
- }
|
|
|
- return inFlightData.frag;
|
|
|
-}
|
|
|
-function appendedFragAtPosition(pos, fragmentTracker) {
|
|
|
- return fragmentTracker.getAppendedFrag(pos, PlaylistLevelType.MAIN) || fragmentTracker.getPartialFragment(pos);
|
|
|
-}
|
|
|
-var MIN_CUE_DURATION = 0.25;
|
|
|
-function getCueClass() {
|
|
|
- if (typeof self === "undefined")
|
|
|
- return void 0;
|
|
|
- return self.VTTCue || self.TextTrackCue;
|
|
|
-}
|
|
|
-function createCueWithDataFields(Cue, startTime, endTime, data, type) {
|
|
|
- let cue = new Cue(startTime, endTime, "");
|
|
|
- try {
|
|
|
- cue.value = data;
|
|
|
- if (type) {
|
|
|
- cue.type = type;
|
|
|
- }
|
|
|
- } catch (e) {
|
|
|
- cue = new Cue(startTime, endTime, stringify(type ? _objectSpread2({
|
|
|
- type
|
|
|
- }, data) : data));
|
|
|
- }
|
|
|
- return cue;
|
|
|
-}
|
|
|
-var MAX_CUE_ENDTIME = (() => {
|
|
|
- const Cue = getCueClass();
|
|
|
- try {
|
|
|
- Cue && new Cue(0, Number.POSITIVE_INFINITY, "");
|
|
|
- } catch (e) {
|
|
|
- return Number.MAX_VALUE;
|
|
|
- }
|
|
|
- return Number.POSITIVE_INFINITY;
|
|
|
-})();
|
|
|
-var ID3TrackController = class {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.id3Track = null;
|
|
|
- this.media = null;
|
|
|
- this.dateRangeCuesAppended = {};
|
|
|
- this.removeCues = true;
|
|
|
- this.assetCue = void 0;
|
|
|
- this.onEventCueEnter = () => {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.EVENT_CUE_ENTER, {});
|
|
|
- };
|
|
|
- this.hls = hls;
|
|
|
- this._registerListeners();
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this._unregisterListeners();
|
|
|
- this.id3Track = null;
|
|
|
- this.media = null;
|
|
|
- this.dateRangeCuesAppended = {};
|
|
|
- this.hls = this.onEventCueEnter = null;
|
|
|
- }
|
|
|
- _registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (hls) {
|
|
|
- hls.on(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.on(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
|
|
|
- }
|
|
|
- }
|
|
|
- _unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (hls) {
|
|
|
- hls.off(Events.MEDIA_ATTACHING, this.onMediaAttaching, this);
|
|
|
- hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
|
|
|
- hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.off(Events.LEVEL_PTS_UPDATED, this.onLevelPtsUpdated, this);
|
|
|
- }
|
|
|
- }
|
|
|
- // Add ID3 metatadata text track.
|
|
|
- onMediaAttaching(event, data) {
|
|
|
- var _data$overrides;
|
|
|
- this.media = data.media;
|
|
|
- if (((_data$overrides = data.overrides) == null ? void 0 : _data$overrides.cueRemoval) === false) {
|
|
|
- this.removeCues = false;
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaAttached() {
|
|
|
- var _this$hls;
|
|
|
- const details = (_this$hls = this.hls) == null ? void 0 : _this$hls.latestLevelDetails;
|
|
|
- if (details) {
|
|
|
- this.updateDateRangeCues(details);
|
|
|
- }
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- this.media = null;
|
|
|
- const transferringMedia = !!data.transferMedia;
|
|
|
- if (transferringMedia) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.id3Track) {
|
|
|
- if (this.removeCues) {
|
|
|
- clearCurrentCues(this.id3Track, this.onEventCueEnter);
|
|
|
- }
|
|
|
- this.id3Track = null;
|
|
|
- }
|
|
|
- this.dateRangeCuesAppended = {};
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this.dateRangeCuesAppended = {};
|
|
|
- }
|
|
|
- createTrack(media) {
|
|
|
- const track = this.getID3Track(media.textTracks);
|
|
|
- track.mode = "hidden";
|
|
|
- return track;
|
|
|
- }
|
|
|
- getID3Track(textTracks) {
|
|
|
- if (!this.media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- for (let i = 0; i < textTracks.length; i++) {
|
|
|
- const textTrack = textTracks[i];
|
|
|
- if (textTrack.kind === "metadata" && textTrack.label === "id3") {
|
|
|
- sendAddTrackEvent(textTrack, this.media);
|
|
|
- return textTrack;
|
|
|
- }
|
|
|
- }
|
|
|
- return this.media.addTextTrack("metadata", "id3");
|
|
|
- }
|
|
|
- onFragParsingMetadata(event, data) {
|
|
|
- if (!this.media || !this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- enableEmsgMetadataCues,
|
|
|
- enableID3MetadataCues
|
|
|
- } = this.hls.config;
|
|
|
- if (!enableEmsgMetadataCues && !enableID3MetadataCues) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- samples
|
|
|
- } = data;
|
|
|
- if (!this.id3Track) {
|
|
|
- this.id3Track = this.createTrack(this.media);
|
|
|
- }
|
|
|
- const Cue = getCueClass();
|
|
|
- if (!Cue) {
|
|
|
- return;
|
|
|
- }
|
|
|
- for (let i = 0; i < samples.length; i++) {
|
|
|
- const type = samples[i].type;
|
|
|
- if (type === MetadataSchema.emsg && !enableEmsgMetadataCues || !enableID3MetadataCues) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- const frames = getId3Frames(samples[i].data);
|
|
|
- const startTime = samples[i].pts;
|
|
|
- let endTime = startTime + samples[i].duration;
|
|
|
- if (endTime > MAX_CUE_ENDTIME) {
|
|
|
- endTime = MAX_CUE_ENDTIME;
|
|
|
- }
|
|
|
- const timeDiff = endTime - startTime;
|
|
|
- if (timeDiff <= 0) {
|
|
|
- endTime = startTime + MIN_CUE_DURATION;
|
|
|
- }
|
|
|
- for (let j = 0; j < frames.length; j++) {
|
|
|
- const frame = frames[j];
|
|
|
- if (!isId3TimestampFrame(frame)) {
|
|
|
- this.updateId3CueEnds(startTime, type);
|
|
|
- const cue = createCueWithDataFields(Cue, startTime, endTime, frame, type);
|
|
|
- if (cue) {
|
|
|
- this.id3Track.addCue(cue);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- updateId3CueEnds(startTime, type) {
|
|
|
- var _this$id3Track;
|
|
|
- const cues = (_this$id3Track = this.id3Track) == null ? void 0 : _this$id3Track.cues;
|
|
|
- if (cues) {
|
|
|
- for (let i = cues.length; i--; ) {
|
|
|
- const cue = cues[i];
|
|
|
- if (cue.type === type && cue.startTime < startTime && cue.endTime === MAX_CUE_ENDTIME) {
|
|
|
- cue.endTime = startTime;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onBufferFlushing(event, {
|
|
|
- startOffset,
|
|
|
- endOffset,
|
|
|
- type
|
|
|
- }) {
|
|
|
- const {
|
|
|
- id3Track,
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- config: {
|
|
|
- enableEmsgMetadataCues,
|
|
|
- enableID3MetadataCues
|
|
|
- }
|
|
|
- } = hls;
|
|
|
- if (id3Track && (enableEmsgMetadataCues || enableID3MetadataCues)) {
|
|
|
- let predicate;
|
|
|
- if (type === "audio") {
|
|
|
- predicate = (cue) => cue.type === MetadataSchema.audioId3 && enableID3MetadataCues;
|
|
|
- } else if (type === "video") {
|
|
|
- predicate = (cue) => cue.type === MetadataSchema.emsg && enableEmsgMetadataCues;
|
|
|
- } else {
|
|
|
- predicate = (cue) => cue.type === MetadataSchema.audioId3 && enableID3MetadataCues || cue.type === MetadataSchema.emsg && enableEmsgMetadataCues;
|
|
|
- }
|
|
|
- removeCuesInRange(id3Track, startOffset, endOffset, predicate);
|
|
|
- }
|
|
|
- }
|
|
|
- onLevelUpdated(event, {
|
|
|
- details
|
|
|
- }) {
|
|
|
- this.updateDateRangeCues(details, true);
|
|
|
- }
|
|
|
- onLevelPtsUpdated(event, data) {
|
|
|
- if (Math.abs(data.drift) > 0.01) {
|
|
|
- this.updateDateRangeCues(data.details);
|
|
|
- }
|
|
|
- }
|
|
|
- updateDateRangeCues(details, removeOldCues) {
|
|
|
- if (!this.hls || !this.media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- assetPlayerId,
|
|
|
- timelineOffset,
|
|
|
- enableDateRangeMetadataCues,
|
|
|
- interstitialsController
|
|
|
- } = this.hls.config;
|
|
|
- if (!enableDateRangeMetadataCues) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const Cue = getCueClass();
|
|
|
- if (assetPlayerId && timelineOffset && !interstitialsController) {
|
|
|
- const {
|
|
|
- fragmentStart,
|
|
|
- fragmentEnd
|
|
|
- } = details;
|
|
|
- let cue = this.assetCue;
|
|
|
- if (cue) {
|
|
|
- cue.startTime = fragmentStart;
|
|
|
- cue.endTime = fragmentEnd;
|
|
|
- } else if (Cue) {
|
|
|
- cue = this.assetCue = createCueWithDataFields(Cue, fragmentStart, fragmentEnd, {
|
|
|
- assetPlayerId: this.hls.config.assetPlayerId
|
|
|
- }, "hlsjs.interstitial.asset");
|
|
|
- if (cue) {
|
|
|
- cue.id = assetPlayerId;
|
|
|
- this.id3Track || (this.id3Track = this.createTrack(this.media));
|
|
|
- this.id3Track.addCue(cue);
|
|
|
- cue.addEventListener("enter", this.onEventCueEnter);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (!details.hasProgramDateTime) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- id3Track
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- dateRanges
|
|
|
- } = details;
|
|
|
- const ids = Object.keys(dateRanges);
|
|
|
- let dateRangeCuesAppended = this.dateRangeCuesAppended;
|
|
|
- if (id3Track && removeOldCues) {
|
|
|
- var _id3Track$cues;
|
|
|
- if ((_id3Track$cues = id3Track.cues) != null && _id3Track$cues.length) {
|
|
|
- const idsToRemove = Object.keys(dateRangeCuesAppended).filter((id) => !ids.includes(id));
|
|
|
- for (let i = idsToRemove.length; i--; ) {
|
|
|
- var _dateRangeCuesAppende;
|
|
|
- const id = idsToRemove[i];
|
|
|
- const cues = (_dateRangeCuesAppende = dateRangeCuesAppended[id]) == null ? void 0 : _dateRangeCuesAppende.cues;
|
|
|
- delete dateRangeCuesAppended[id];
|
|
|
- if (cues) {
|
|
|
- Object.keys(cues).forEach((key) => {
|
|
|
- const cue = cues[key];
|
|
|
- if (cue) {
|
|
|
- cue.removeEventListener("enter", this.onEventCueEnter);
|
|
|
- try {
|
|
|
- id3Track.removeCue(cue);
|
|
|
- } catch (e) {
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- dateRangeCuesAppended = this.dateRangeCuesAppended = {};
|
|
|
- }
|
|
|
- }
|
|
|
- const lastFragment = details.fragments[details.fragments.length - 1];
|
|
|
- if (ids.length === 0 || !isFiniteNumber(lastFragment == null ? void 0 : lastFragment.programDateTime)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.id3Track || (this.id3Track = this.createTrack(this.media));
|
|
|
- for (let i = 0; i < ids.length; i++) {
|
|
|
- const id = ids[i];
|
|
|
- const dateRange = dateRanges[id];
|
|
|
- const startTime = dateRange.startTime;
|
|
|
- const appendedDateRangeCues = dateRangeCuesAppended[id];
|
|
|
- const cues = (appendedDateRangeCues == null ? void 0 : appendedDateRangeCues.cues) || {};
|
|
|
- let durationKnown = (appendedDateRangeCues == null ? void 0 : appendedDateRangeCues.durationKnown) || false;
|
|
|
- let endTime = MAX_CUE_ENDTIME;
|
|
|
- const {
|
|
|
- duration,
|
|
|
- endDate
|
|
|
- } = dateRange;
|
|
|
- if (endDate && duration !== null) {
|
|
|
- endTime = startTime + duration;
|
|
|
- durationKnown = true;
|
|
|
- } else if (dateRange.endOnNext && !durationKnown) {
|
|
|
- const nextDateRangeWithSameClass = ids.reduce((candidateDateRange, id2) => {
|
|
|
- if (id2 !== dateRange.id) {
|
|
|
- const otherDateRange = dateRanges[id2];
|
|
|
- if (otherDateRange.class === dateRange.class && otherDateRange.startDate > dateRange.startDate && (!candidateDateRange || dateRange.startDate < candidateDateRange.startDate)) {
|
|
|
- return otherDateRange;
|
|
|
- }
|
|
|
- }
|
|
|
- return candidateDateRange;
|
|
|
- }, null);
|
|
|
- if (nextDateRangeWithSameClass) {
|
|
|
- endTime = nextDateRangeWithSameClass.startTime;
|
|
|
- durationKnown = true;
|
|
|
- }
|
|
|
- }
|
|
|
- const attributes = Object.keys(dateRange.attr);
|
|
|
- for (let j = 0; j < attributes.length; j++) {
|
|
|
- const key = attributes[j];
|
|
|
- if (!isDateRangeCueAttribute(key)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- const cue = cues[key];
|
|
|
- if (cue) {
|
|
|
- if (durationKnown && !(appendedDateRangeCues != null && appendedDateRangeCues.durationKnown)) {
|
|
|
- cue.endTime = endTime;
|
|
|
- } else if (Math.abs(cue.startTime - startTime) > 0.01) {
|
|
|
- cue.startTime = startTime;
|
|
|
- cue.endTime = endTime;
|
|
|
- }
|
|
|
- } else if (Cue) {
|
|
|
- let data = dateRange.attr[key];
|
|
|
- if (isSCTE35Attribute(key)) {
|
|
|
- data = hexToArrayBuffer(data);
|
|
|
- }
|
|
|
- const payload = {
|
|
|
- key,
|
|
|
- data
|
|
|
- };
|
|
|
- const _cue = createCueWithDataFields(Cue, startTime, endTime, payload, MetadataSchema.dateRange);
|
|
|
- if (_cue) {
|
|
|
- _cue.id = id;
|
|
|
- this.id3Track.addCue(_cue);
|
|
|
- cues[key] = _cue;
|
|
|
- if (interstitialsController) {
|
|
|
- if (key === "X-ASSET-LIST" || key === "X-ASSET-URL") {
|
|
|
- _cue.addEventListener("enter", this.onEventCueEnter);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- dateRangeCuesAppended[id] = {
|
|
|
- cues,
|
|
|
- dateRange,
|
|
|
- durationKnown
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var LatencyController = class {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.config = void 0;
|
|
|
- this.media = null;
|
|
|
- this.currentTime = 0;
|
|
|
- this.stallCount = 0;
|
|
|
- this._latency = null;
|
|
|
- this._targetLatencyUpdated = false;
|
|
|
- this.onTimeupdate = () => {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- if (!media || !levelDetails) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.currentTime = media.currentTime;
|
|
|
- const latency = this.computeLatency();
|
|
|
- if (latency === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this._latency = latency;
|
|
|
- const {
|
|
|
- lowLatencyMode,
|
|
|
- maxLiveSyncPlaybackRate
|
|
|
- } = this.config;
|
|
|
- if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1 || !levelDetails.live) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const targetLatency = this.targetLatency;
|
|
|
- if (targetLatency === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const distanceFromTarget = latency - targetLatency;
|
|
|
- const liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
|
|
|
- const inLiveRange = distanceFromTarget < liveMinLatencyDuration;
|
|
|
- if (inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
|
|
|
- const max = Math.min(2, Math.max(1, maxLiveSyncPlaybackRate));
|
|
|
- const rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
|
|
|
- const playbackRate = Math.min(max, Math.max(1, rate));
|
|
|
- this.changeMediaPlaybackRate(media, playbackRate);
|
|
|
- } else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
|
|
|
- this.changeMediaPlaybackRate(media, 1);
|
|
|
- }
|
|
|
- };
|
|
|
- this.hls = hls;
|
|
|
- this.config = hls.config;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- get levelDetails() {
|
|
|
- var _this$hls;
|
|
|
- return ((_this$hls = this.hls) == null ? void 0 : _this$hls.latestLevelDetails) || null;
|
|
|
- }
|
|
|
- get latency() {
|
|
|
- return this._latency || 0;
|
|
|
- }
|
|
|
- get maxLatency() {
|
|
|
- const {
|
|
|
- config
|
|
|
- } = this;
|
|
|
- if (config.liveMaxLatencyDuration !== void 0) {
|
|
|
- return config.liveMaxLatencyDuration;
|
|
|
- }
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- return levelDetails ? config.liveMaxLatencyDurationCount * levelDetails.targetduration : 0;
|
|
|
- }
|
|
|
- get targetLatency() {
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- if (levelDetails === null || this.hls === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const {
|
|
|
- holdBack,
|
|
|
- partHoldBack,
|
|
|
- targetduration
|
|
|
- } = levelDetails;
|
|
|
- const {
|
|
|
- liveSyncDuration,
|
|
|
- liveSyncDurationCount,
|
|
|
- lowLatencyMode
|
|
|
- } = this.config;
|
|
|
- const userConfig = this.hls.userConfig;
|
|
|
- let targetLatency = lowLatencyMode ? partHoldBack || holdBack : holdBack;
|
|
|
- if (this._targetLatencyUpdated || userConfig.liveSyncDuration || userConfig.liveSyncDurationCount || targetLatency === 0) {
|
|
|
- targetLatency = liveSyncDuration !== void 0 ? liveSyncDuration : liveSyncDurationCount * targetduration;
|
|
|
- }
|
|
|
- const maxLiveSyncOnStallIncrease = targetduration;
|
|
|
- return targetLatency + Math.min(this.stallCount * this.config.liveSyncOnStallIncrease, maxLiveSyncOnStallIncrease);
|
|
|
- }
|
|
|
- set targetLatency(latency) {
|
|
|
- this.stallCount = 0;
|
|
|
- this.config.liveSyncDuration = latency;
|
|
|
- this._targetLatencyUpdated = true;
|
|
|
- }
|
|
|
- get liveSyncPosition() {
|
|
|
- const liveEdge = this.estimateLiveEdge();
|
|
|
- const targetLatency = this.targetLatency;
|
|
|
- if (liveEdge === null || targetLatency === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- if (levelDetails === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- const edge = levelDetails.edge;
|
|
|
- const syncPosition = liveEdge - targetLatency - this.edgeStalled;
|
|
|
- const min = edge - levelDetails.totalduration;
|
|
|
- const max = edge - (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration);
|
|
|
- return Math.min(Math.max(min, syncPosition), max);
|
|
|
- }
|
|
|
- get drift() {
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- if (levelDetails === null) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- return levelDetails.drift;
|
|
|
- }
|
|
|
- get edgeStalled() {
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- if (levelDetails === null) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const maxLevelUpdateAge = (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration) * 3;
|
|
|
- return Math.max(levelDetails.age - maxLevelUpdateAge, 0);
|
|
|
- }
|
|
|
- get forwardBufferLength() {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- if (!media || !levelDetails) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- const bufferedRanges = media.buffered.length;
|
|
|
- return (bufferedRanges ? media.buffered.end(bufferedRanges - 1) : levelDetails.edge) - this.currentTime;
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.unregisterListeners();
|
|
|
- this.onMediaDetaching();
|
|
|
- this.hls = null;
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- if (!hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
|
|
|
- hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.LEVEL_UPDATED, this.onLevelUpdated, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- onMediaAttached(event, data) {
|
|
|
- this.media = data.media;
|
|
|
- this.media.addEventListener("timeupdate", this.onTimeupdate);
|
|
|
- }
|
|
|
- onMediaDetaching() {
|
|
|
- if (this.media) {
|
|
|
- this.media.removeEventListener("timeupdate", this.onTimeupdate);
|
|
|
- this.media = null;
|
|
|
- }
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- this._latency = null;
|
|
|
- this.stallCount = 0;
|
|
|
- }
|
|
|
- onLevelUpdated(event, {
|
|
|
- details
|
|
|
- }) {
|
|
|
- if (details.advanced) {
|
|
|
- this.onTimeupdate();
|
|
|
- }
|
|
|
- if (!details.live && this.media) {
|
|
|
- this.media.removeEventListener("timeupdate", this.onTimeupdate);
|
|
|
- }
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- var _this$levelDetails;
|
|
|
- if (data.details !== ErrorDetails.BUFFER_STALLED_ERROR) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.stallCount++;
|
|
|
- if (this.hls && (_this$levelDetails = this.levelDetails) != null && _this$levelDetails.live) {
|
|
|
- this.hls.logger.warn("[latency-controller]: Stall detected, adjusting target latency");
|
|
|
- }
|
|
|
- }
|
|
|
- changeMediaPlaybackRate(media, playbackRate) {
|
|
|
- var _this$hls2, _this$targetLatency;
|
|
|
- if (media.playbackRate === playbackRate) {
|
|
|
- return;
|
|
|
- }
|
|
|
- (_this$hls2 = this.hls) == null || _this$hls2.logger.debug(`[latency-controller]: latency=${this.latency.toFixed(3)}, targetLatency=${(_this$targetLatency = this.targetLatency) == null ? void 0 : _this$targetLatency.toFixed(3)}, forwardBufferLength=${this.forwardBufferLength.toFixed(3)}: adjusting playback rate from ${media.playbackRate} to ${playbackRate}`);
|
|
|
- media.playbackRate = playbackRate;
|
|
|
- }
|
|
|
- estimateLiveEdge() {
|
|
|
- const levelDetails = this.levelDetails;
|
|
|
- if (levelDetails === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return levelDetails.edge + levelDetails.age;
|
|
|
- }
|
|
|
- computeLatency() {
|
|
|
- const liveEdge = this.estimateLiveEdge();
|
|
|
- if (liveEdge === null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return liveEdge - this.currentTime;
|
|
|
- }
|
|
|
-};
|
|
|
-var LevelController = class extends BasePlaylistController {
|
|
|
- constructor(hls, contentSteeringController) {
|
|
|
- super(hls, "level-controller");
|
|
|
- this._levels = [];
|
|
|
- this._firstLevel = -1;
|
|
|
- this._maxAutoLevel = -1;
|
|
|
- this._startLevel = void 0;
|
|
|
- this.currentLevel = null;
|
|
|
- this.currentLevelIndex = -1;
|
|
|
- this.manualLevelIndex = -1;
|
|
|
- this.steering = void 0;
|
|
|
- this.onParsedComplete = void 0;
|
|
|
- this.steering = contentSteeringController;
|
|
|
- this._registerListeners();
|
|
|
- }
|
|
|
- _registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- hls.on(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- _unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.MANIFEST_LOADED, this.onManifestLoaded, this);
|
|
|
- hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- hls.off(Events.ERROR, this.onError, this);
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this._unregisterListeners();
|
|
|
- this.steering = null;
|
|
|
- this.resetLevels();
|
|
|
- super.destroy();
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- const levels = this._levels;
|
|
|
- levels.forEach((level) => {
|
|
|
- level.loadError = 0;
|
|
|
- level.fragmentError = 0;
|
|
|
- });
|
|
|
- super.stopLoad();
|
|
|
- }
|
|
|
- resetLevels() {
|
|
|
- this._startLevel = void 0;
|
|
|
- this.manualLevelIndex = -1;
|
|
|
- this.currentLevelIndex = -1;
|
|
|
- this.currentLevel = null;
|
|
|
- this._levels = [];
|
|
|
- this._maxAutoLevel = -1;
|
|
|
- }
|
|
|
- onManifestLoading(event, data) {
|
|
|
- this.resetLevels();
|
|
|
- }
|
|
|
- onManifestLoaded(event, data) {
|
|
|
- const preferManagedMediaSource = this.hls.config.preferManagedMediaSource;
|
|
|
- const levels = [];
|
|
|
- const redundantSet = {};
|
|
|
- const generatePathwaySet = {};
|
|
|
- let resolutionFound = false;
|
|
|
- let videoCodecFound = false;
|
|
|
- let audioCodecFound = false;
|
|
|
- data.levels.forEach((levelParsed) => {
|
|
|
- const attributes = levelParsed.attrs;
|
|
|
- let {
|
|
|
- audioCodec,
|
|
|
- videoCodec
|
|
|
- } = levelParsed;
|
|
|
- if (audioCodec) {
|
|
|
- levelParsed.audioCodec = audioCodec = getCodecCompatibleName(audioCodec, preferManagedMediaSource) || void 0;
|
|
|
- }
|
|
|
- if (videoCodec) {
|
|
|
- videoCodec = levelParsed.videoCodec = convertAVC1ToAVCOTI(videoCodec);
|
|
|
- }
|
|
|
- const {
|
|
|
- width,
|
|
|
- height,
|
|
|
- unknownCodecs
|
|
|
- } = levelParsed;
|
|
|
- const unknownUnsupportedCodecCount = (unknownCodecs == null ? void 0 : unknownCodecs.length) || 0;
|
|
|
- resolutionFound || (resolutionFound = !!(width && height));
|
|
|
- videoCodecFound || (videoCodecFound = !!videoCodec);
|
|
|
- audioCodecFound || (audioCodecFound = !!audioCodec);
|
|
|
- if (unknownUnsupportedCodecCount || audioCodec && !this.isAudioSupported(audioCodec) || videoCodec && !this.isVideoSupported(videoCodec)) {
|
|
|
- this.log(`Some or all CODECS not supported "${attributes.CODECS}"`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- CODECS,
|
|
|
- "FRAME-RATE": FRAMERATE,
|
|
|
- "HDCP-LEVEL": HDCP,
|
|
|
- "PATHWAY-ID": PATHWAY,
|
|
|
- RESOLUTION,
|
|
|
- "VIDEO-RANGE": VIDEO_RANGE
|
|
|
- } = attributes;
|
|
|
- const contentSteeringPrefix = `${PATHWAY || "."}-`;
|
|
|
- const levelKey = `${contentSteeringPrefix}${levelParsed.bitrate}-${RESOLUTION}-${FRAMERATE}-${CODECS}-${VIDEO_RANGE}-${HDCP}`;
|
|
|
- if (!redundantSet[levelKey]) {
|
|
|
- const level = this.createLevel(levelParsed);
|
|
|
- redundantSet[levelKey] = level;
|
|
|
- generatePathwaySet[levelKey] = 1;
|
|
|
- levels.push(level);
|
|
|
- } else if (redundantSet[levelKey].uri !== levelParsed.url && !levelParsed.attrs["PATHWAY-ID"]) {
|
|
|
- const pathwayCount = generatePathwaySet[levelKey] += 1;
|
|
|
- levelParsed.attrs["PATHWAY-ID"] = new Array(pathwayCount + 1).join(".");
|
|
|
- const level = this.createLevel(levelParsed);
|
|
|
- redundantSet[levelKey] = level;
|
|
|
- levels.push(level);
|
|
|
- } else {
|
|
|
- redundantSet[levelKey].addGroupId("audio", attributes.AUDIO);
|
|
|
- redundantSet[levelKey].addGroupId("text", attributes.SUBTITLES);
|
|
|
- }
|
|
|
- });
|
|
|
- this.filterAndSortMediaOptions(levels, data, resolutionFound, videoCodecFound, audioCodecFound);
|
|
|
- }
|
|
|
- createLevel(levelParsed) {
|
|
|
- const level = new Level(levelParsed);
|
|
|
- const supplemental = levelParsed.supplemental;
|
|
|
- if (supplemental != null && supplemental.videoCodec && !this.isVideoSupported(supplemental.videoCodec)) {
|
|
|
- const error = new Error(`SUPPLEMENTAL-CODECS not supported "${supplemental.videoCodec}"`);
|
|
|
- this.log(error.message);
|
|
|
- level.supportedResult = getUnsupportedResult(error, []);
|
|
|
- }
|
|
|
- return level;
|
|
|
- }
|
|
|
- isAudioSupported(codec) {
|
|
|
- return areCodecsMediaSourceSupported(codec, "audio", this.hls.config.preferManagedMediaSource);
|
|
|
- }
|
|
|
- isVideoSupported(codec) {
|
|
|
- return areCodecsMediaSourceSupported(codec, "video", this.hls.config.preferManagedMediaSource);
|
|
|
- }
|
|
|
- filterAndSortMediaOptions(filteredLevels, data, resolutionFound, videoCodecFound, audioCodecFound) {
|
|
|
- var _data$stats;
|
|
|
- let audioTracks = [];
|
|
|
- let subtitleTracks = [];
|
|
|
- let levels = filteredLevels;
|
|
|
- const statsParsing = ((_data$stats = data.stats) == null ? void 0 : _data$stats.parsing) || {};
|
|
|
- if ((resolutionFound || videoCodecFound) && audioCodecFound) {
|
|
|
- levels = levels.filter(({
|
|
|
- videoCodec,
|
|
|
- videoRange,
|
|
|
- width,
|
|
|
- height
|
|
|
- }) => (!!videoCodec || !!(width && height)) && isVideoRange(videoRange));
|
|
|
- }
|
|
|
- if (levels.length === 0) {
|
|
|
- Promise.resolve().then(() => {
|
|
|
- if (this.hls) {
|
|
|
- let message = "no level with compatible codecs found in manifest";
|
|
|
- let reason = message;
|
|
|
- if (data.levels.length) {
|
|
|
- reason = `one or more CODECS in variant not supported: ${stringify(data.levels.map((level) => level.attrs.CODECS).filter((value, index, array) => array.indexOf(value) === index))}`;
|
|
|
- this.warn(reason);
|
|
|
- message += ` (${reason})`;
|
|
|
- }
|
|
|
- const error = new Error(message);
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.MEDIA_ERROR,
|
|
|
- details: ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR,
|
|
|
- fatal: true,
|
|
|
- url: data.url,
|
|
|
- error,
|
|
|
- reason
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- statsParsing.end = performance.now();
|
|
|
- return;
|
|
|
- }
|
|
|
- if (data.audioTracks) {
|
|
|
- audioTracks = data.audioTracks.filter((track) => !track.audioCodec || this.isAudioSupported(track.audioCodec));
|
|
|
- assignTrackIdsByGroup(audioTracks);
|
|
|
- }
|
|
|
- if (data.subtitles) {
|
|
|
- subtitleTracks = data.subtitles;
|
|
|
- assignTrackIdsByGroup(subtitleTracks);
|
|
|
- }
|
|
|
- const unsortedLevels = levels.slice(0);
|
|
|
- levels.sort((a, b) => {
|
|
|
- if (a.attrs["HDCP-LEVEL"] !== b.attrs["HDCP-LEVEL"]) {
|
|
|
- return (a.attrs["HDCP-LEVEL"] || "") > (b.attrs["HDCP-LEVEL"] || "") ? 1 : -1;
|
|
|
- }
|
|
|
- if (resolutionFound && a.height !== b.height) {
|
|
|
- return a.height - b.height;
|
|
|
- }
|
|
|
- if (a.frameRate !== b.frameRate) {
|
|
|
- return a.frameRate - b.frameRate;
|
|
|
- }
|
|
|
- if (a.videoRange !== b.videoRange) {
|
|
|
- return VideoRangeValues.indexOf(a.videoRange) - VideoRangeValues.indexOf(b.videoRange);
|
|
|
- }
|
|
|
- if (a.videoCodec !== b.videoCodec) {
|
|
|
- const valueA = videoCodecPreferenceValue(a.videoCodec);
|
|
|
- const valueB = videoCodecPreferenceValue(b.videoCodec);
|
|
|
- if (valueA !== valueB) {
|
|
|
- return valueB - valueA;
|
|
|
- }
|
|
|
- }
|
|
|
- if (a.uri === b.uri && a.codecSet !== b.codecSet) {
|
|
|
- const valueA = codecsSetSelectionPreferenceValue(a.codecSet);
|
|
|
- const valueB = codecsSetSelectionPreferenceValue(b.codecSet);
|
|
|
- if (valueA !== valueB) {
|
|
|
- return valueB - valueA;
|
|
|
- }
|
|
|
- }
|
|
|
- if (a.averageBitrate !== b.averageBitrate) {
|
|
|
- return a.averageBitrate - b.averageBitrate;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- });
|
|
|
- let firstLevelInPlaylist = unsortedLevels[0];
|
|
|
- if (this.steering) {
|
|
|
- levels = this.steering.filterParsedLevels(levels);
|
|
|
- if (levels.length !== unsortedLevels.length) {
|
|
|
- for (let i = 0; i < unsortedLevels.length; i++) {
|
|
|
- if (unsortedLevels[i].pathwayId === levels[0].pathwayId) {
|
|
|
- firstLevelInPlaylist = unsortedLevels[i];
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- this._levels = levels;
|
|
|
- for (let i = 0; i < levels.length; i++) {
|
|
|
- if (levels[i] === firstLevelInPlaylist) {
|
|
|
- var _this$hls$userConfig;
|
|
|
- this._firstLevel = i;
|
|
|
- const firstLevelBitrate = firstLevelInPlaylist.bitrate;
|
|
|
- const bandwidthEstimate = this.hls.bandwidthEstimate;
|
|
|
- this.log(`manifest loaded, ${levels.length} level(s) found, first bitrate: ${firstLevelBitrate}`);
|
|
|
- if (((_this$hls$userConfig = this.hls.userConfig) == null ? void 0 : _this$hls$userConfig.abrEwmaDefaultEstimate) === void 0) {
|
|
|
- const startingBwEstimate = Math.min(firstLevelBitrate, this.hls.config.abrEwmaDefaultEstimateMax);
|
|
|
- if (startingBwEstimate > bandwidthEstimate && bandwidthEstimate === this.hls.abrEwmaDefaultEstimate) {
|
|
|
- this.hls.bandwidthEstimate = startingBwEstimate;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- const audioOnly = audioCodecFound && !videoCodecFound;
|
|
|
- const config = this.hls.config;
|
|
|
- const altAudioEnabled = !!(config.audioStreamController && config.audioTrackController);
|
|
|
- const edata = {
|
|
|
- levels,
|
|
|
- audioTracks,
|
|
|
- subtitleTracks,
|
|
|
- sessionData: data.sessionData,
|
|
|
- sessionKeys: data.sessionKeys,
|
|
|
- firstLevel: this._firstLevel,
|
|
|
- stats: data.stats,
|
|
|
- audio: audioCodecFound,
|
|
|
- video: videoCodecFound,
|
|
|
- altAudio: altAudioEnabled && !audioOnly && audioTracks.some((t) => !!t.url)
|
|
|
- };
|
|
|
- statsParsing.end = performance.now();
|
|
|
- this.hls.trigger(Events.MANIFEST_PARSED, edata);
|
|
|
- }
|
|
|
- get levels() {
|
|
|
- if (this._levels.length === 0) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return this._levels;
|
|
|
- }
|
|
|
- get loadLevelObj() {
|
|
|
- return this.currentLevel;
|
|
|
- }
|
|
|
- get level() {
|
|
|
- return this.currentLevelIndex;
|
|
|
- }
|
|
|
- set level(newLevel) {
|
|
|
- const levels = this._levels;
|
|
|
- if (levels.length === 0) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (newLevel < 0 || newLevel >= levels.length) {
|
|
|
- const error = new Error("invalid level idx");
|
|
|
- const fatal = newLevel < 0;
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.LEVEL_SWITCH_ERROR,
|
|
|
- level: newLevel,
|
|
|
- fatal,
|
|
|
- error,
|
|
|
- reason: error.message
|
|
|
- });
|
|
|
- if (fatal) {
|
|
|
- return;
|
|
|
- }
|
|
|
- newLevel = Math.min(newLevel, levels.length - 1);
|
|
|
- }
|
|
|
- const lastLevelIndex = this.currentLevelIndex;
|
|
|
- const lastLevel = this.currentLevel;
|
|
|
- const lastPathwayId = lastLevel ? lastLevel.attrs["PATHWAY-ID"] : void 0;
|
|
|
- const level = levels[newLevel];
|
|
|
- const pathwayId = level.attrs["PATHWAY-ID"];
|
|
|
- this.currentLevelIndex = newLevel;
|
|
|
- this.currentLevel = level;
|
|
|
- if (lastLevelIndex === newLevel && lastLevel && lastPathwayId === pathwayId) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Switching to level ${newLevel} (${level.height ? level.height + "p " : ""}${level.videoRange ? level.videoRange + " " : ""}${level.codecSet ? level.codecSet + " " : ""}@${level.bitrate})${pathwayId ? " with Pathway " + pathwayId : ""} from level ${lastLevelIndex}${lastPathwayId ? " with Pathway " + lastPathwayId : ""}`);
|
|
|
- const levelSwitchingData = {
|
|
|
- level: newLevel,
|
|
|
- attrs: level.attrs,
|
|
|
- details: level.details,
|
|
|
- bitrate: level.bitrate,
|
|
|
- averageBitrate: level.averageBitrate,
|
|
|
- maxBitrate: level.maxBitrate,
|
|
|
- realBitrate: level.realBitrate,
|
|
|
- width: level.width,
|
|
|
- height: level.height,
|
|
|
- codecSet: level.codecSet,
|
|
|
- audioCodec: level.audioCodec,
|
|
|
- videoCodec: level.videoCodec,
|
|
|
- audioGroups: level.audioGroups,
|
|
|
- subtitleGroups: level.subtitleGroups,
|
|
|
- loaded: level.loaded,
|
|
|
- loadError: level.loadError,
|
|
|
- fragmentError: level.fragmentError,
|
|
|
- name: level.name,
|
|
|
- id: level.id,
|
|
|
- uri: level.uri,
|
|
|
- url: level.url,
|
|
|
- urlId: 0,
|
|
|
- audioGroupIds: level.audioGroupIds,
|
|
|
- textGroupIds: level.textGroupIds
|
|
|
- };
|
|
|
- this.hls.trigger(Events.LEVEL_SWITCHING, levelSwitchingData);
|
|
|
- const levelDetails = level.details;
|
|
|
- if (!levelDetails || levelDetails.live) {
|
|
|
- const hlsUrlParameters = this.switchParams(level.uri, lastLevel == null ? void 0 : lastLevel.details, levelDetails);
|
|
|
- this.loadPlaylist(hlsUrlParameters);
|
|
|
- }
|
|
|
- }
|
|
|
- get manualLevel() {
|
|
|
- return this.manualLevelIndex;
|
|
|
- }
|
|
|
- set manualLevel(newLevel) {
|
|
|
- this.manualLevelIndex = newLevel;
|
|
|
- if (this._startLevel === void 0) {
|
|
|
- this._startLevel = newLevel;
|
|
|
- }
|
|
|
- if (newLevel !== -1) {
|
|
|
- this.level = newLevel;
|
|
|
- }
|
|
|
- }
|
|
|
- get firstLevel() {
|
|
|
- return this._firstLevel;
|
|
|
- }
|
|
|
- set firstLevel(newLevel) {
|
|
|
- this._firstLevel = newLevel;
|
|
|
- }
|
|
|
- get startLevel() {
|
|
|
- if (this._startLevel === void 0) {
|
|
|
- const configStartLevel = this.hls.config.startLevel;
|
|
|
- if (configStartLevel !== void 0) {
|
|
|
- return configStartLevel;
|
|
|
- }
|
|
|
- return this.hls.firstAutoLevel;
|
|
|
- }
|
|
|
- return this._startLevel;
|
|
|
- }
|
|
|
- set startLevel(newLevel) {
|
|
|
- this._startLevel = newLevel;
|
|
|
- }
|
|
|
- get pathways() {
|
|
|
- if (this.steering) {
|
|
|
- return this.steering.pathways();
|
|
|
- }
|
|
|
- return [];
|
|
|
- }
|
|
|
- get pathwayPriority() {
|
|
|
- if (this.steering) {
|
|
|
- return this.steering.pathwayPriority;
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- set pathwayPriority(pathwayPriority) {
|
|
|
- if (this.steering) {
|
|
|
- const pathwaysList = this.steering.pathways();
|
|
|
- const filteredPathwayPriority = pathwayPriority.filter((pathwayId) => {
|
|
|
- return pathwaysList.indexOf(pathwayId) !== -1;
|
|
|
- });
|
|
|
- if (pathwayPriority.length < 1) {
|
|
|
- this.warn(`pathwayPriority ${pathwayPriority} should contain at least one pathway from list: ${pathwaysList}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.steering.pathwayPriority = filteredPathwayPriority;
|
|
|
- }
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- if (data.fatal || !data.context) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (data.context.type === PlaylistContextType.LEVEL && data.context.level === this.level) {
|
|
|
- this.checkRetry(data);
|
|
|
- }
|
|
|
- }
|
|
|
- // reset errors on the successful load of a fragment
|
|
|
- onFragBuffered(event, {
|
|
|
- frag
|
|
|
- }) {
|
|
|
- if (frag !== void 0 && frag.type === PlaylistLevelType.MAIN) {
|
|
|
- const el = frag.elementaryStreams;
|
|
|
- if (!Object.keys(el).some((type) => !!el[type])) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const level = this._levels[frag.level];
|
|
|
- if (level != null && level.loadError) {
|
|
|
- this.log(`Resetting level error count of ${level.loadError} on frag buffered`);
|
|
|
- level.loadError = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onLevelLoaded(event, data) {
|
|
|
- var _data$deliveryDirecti2;
|
|
|
- const {
|
|
|
- level,
|
|
|
- details
|
|
|
- } = data;
|
|
|
- const curLevel = data.levelInfo;
|
|
|
- if (!curLevel) {
|
|
|
- var _data$deliveryDirecti;
|
|
|
- this.warn(`Invalid level index ${level}`);
|
|
|
- if ((_data$deliveryDirecti = data.deliveryDirectives) != null && _data$deliveryDirecti.skip) {
|
|
|
- details.deltaUpdateFailed = true;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- if (curLevel === this.currentLevel || data.withoutMultiVariant) {
|
|
|
- if (curLevel.fragmentError === 0) {
|
|
|
- curLevel.loadError = 0;
|
|
|
- }
|
|
|
- let previousDetails = curLevel.details;
|
|
|
- if (previousDetails === data.details && previousDetails.advanced) {
|
|
|
- previousDetails = void 0;
|
|
|
- }
|
|
|
- this.playlistLoaded(level, data, previousDetails);
|
|
|
- } else if ((_data$deliveryDirecti2 = data.deliveryDirectives) != null && _data$deliveryDirecti2.skip) {
|
|
|
- details.deltaUpdateFailed = true;
|
|
|
- }
|
|
|
- }
|
|
|
- loadPlaylist(hlsUrlParameters) {
|
|
|
- super.loadPlaylist();
|
|
|
- if (this.shouldLoadPlaylist(this.currentLevel)) {
|
|
|
- this.scheduleLoading(this.currentLevel, hlsUrlParameters);
|
|
|
- }
|
|
|
- }
|
|
|
- loadingPlaylist(currentLevel, hlsUrlParameters) {
|
|
|
- super.loadingPlaylist(currentLevel, hlsUrlParameters);
|
|
|
- const url = this.getUrlWithDirectives(currentLevel.uri, hlsUrlParameters);
|
|
|
- const currentLevelIndex = this.currentLevelIndex;
|
|
|
- const pathwayId = currentLevel.attrs["PATHWAY-ID"];
|
|
|
- const details = currentLevel.details;
|
|
|
- const age = details == null ? void 0 : details.age;
|
|
|
- this.log(`Loading level index ${currentLevelIndex}${(hlsUrlParameters == null ? void 0 : hlsUrlParameters.msn) !== void 0 ? " at sn " + hlsUrlParameters.msn + " part " + hlsUrlParameters.part : ""}${pathwayId ? " Pathway " + pathwayId : ""}${age && details.live ? " age " + age.toFixed(1) + (details.type ? " " + details.type || "" : "") : ""} ${url}`);
|
|
|
- this.hls.trigger(Events.LEVEL_LOADING, {
|
|
|
- url,
|
|
|
- level: currentLevelIndex,
|
|
|
- levelInfo: currentLevel,
|
|
|
- pathwayId: currentLevel.attrs["PATHWAY-ID"],
|
|
|
- id: 0,
|
|
|
- // Deprecated Level urlId
|
|
|
- deliveryDirectives: hlsUrlParameters || null
|
|
|
- });
|
|
|
- }
|
|
|
- get nextLoadLevel() {
|
|
|
- if (this.manualLevelIndex !== -1) {
|
|
|
- return this.manualLevelIndex;
|
|
|
- } else {
|
|
|
- return this.hls.nextAutoLevel;
|
|
|
- }
|
|
|
- }
|
|
|
- set nextLoadLevel(nextLevel) {
|
|
|
- this.level = nextLevel;
|
|
|
- if (this.manualLevelIndex === -1) {
|
|
|
- this.hls.nextAutoLevel = nextLevel;
|
|
|
- }
|
|
|
- }
|
|
|
- removeLevel(levelIndex) {
|
|
|
- var _this$currentLevel;
|
|
|
- if (this._levels.length === 1) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const levels = this._levels.filter((level, index) => {
|
|
|
- if (index !== levelIndex) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (this.steering) {
|
|
|
- this.steering.removeLevel(level);
|
|
|
- }
|
|
|
- if (level === this.currentLevel) {
|
|
|
- this.currentLevel = null;
|
|
|
- this.currentLevelIndex = -1;
|
|
|
- if (level.details) {
|
|
|
- level.details.fragments.forEach((f) => f.level = -1);
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- });
|
|
|
- reassignFragmentLevelIndexes(levels);
|
|
|
- this._levels = levels;
|
|
|
- if (this.currentLevelIndex > -1 && (_this$currentLevel = this.currentLevel) != null && _this$currentLevel.details) {
|
|
|
- this.currentLevelIndex = this.currentLevel.details.fragments[0].level;
|
|
|
- }
|
|
|
- if (this.manualLevelIndex > -1) {
|
|
|
- this.manualLevelIndex = this.currentLevelIndex;
|
|
|
- }
|
|
|
- const maxLevel = levels.length - 1;
|
|
|
- this._firstLevel = Math.min(this._firstLevel, maxLevel);
|
|
|
- if (this._startLevel) {
|
|
|
- this._startLevel = Math.min(this._startLevel, maxLevel);
|
|
|
- }
|
|
|
- this.hls.trigger(Events.LEVELS_UPDATED, {
|
|
|
- levels
|
|
|
- });
|
|
|
- }
|
|
|
- onLevelsUpdated(event, {
|
|
|
- levels
|
|
|
- }) {
|
|
|
- this._levels = levels;
|
|
|
- }
|
|
|
- checkMaxAutoUpdated() {
|
|
|
- const {
|
|
|
- autoLevelCapping,
|
|
|
- maxAutoLevel,
|
|
|
- maxHdcpLevel
|
|
|
- } = this.hls;
|
|
|
- if (this._maxAutoLevel !== maxAutoLevel) {
|
|
|
- this._maxAutoLevel = maxAutoLevel;
|
|
|
- this.hls.trigger(Events.MAX_AUTO_LEVEL_UPDATED, {
|
|
|
- autoLevelCapping,
|
|
|
- levels: this.levels,
|
|
|
- maxAutoLevel,
|
|
|
- minAutoLevel: this.hls.minAutoLevel,
|
|
|
- maxHdcpLevel
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function assignTrackIdsByGroup(tracks) {
|
|
|
- const groups = {};
|
|
|
- tracks.forEach((track) => {
|
|
|
- const groupId = track.groupId || "";
|
|
|
- track.id = groups[groupId] = groups[groupId] || 0;
|
|
|
- groups[groupId]++;
|
|
|
- });
|
|
|
-}
|
|
|
-function getSourceBuffer() {
|
|
|
- return self.SourceBuffer || self.WebKitSourceBuffer;
|
|
|
-}
|
|
|
-function isMSESupported() {
|
|
|
- const mediaSource = getMediaSource();
|
|
|
- if (!mediaSource) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const sourceBuffer = getSourceBuffer();
|
|
|
- return !sourceBuffer || sourceBuffer.prototype && typeof sourceBuffer.prototype.appendBuffer === "function" && typeof sourceBuffer.prototype.remove === "function";
|
|
|
-}
|
|
|
-function isSupported() {
|
|
|
- if (!isMSESupported()) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- const mediaSource = getMediaSource();
|
|
|
- return typeof (mediaSource == null ? void 0 : mediaSource.isTypeSupported) === "function" && (["avc1.42E01E,mp4a.40.2", "av01.0.01M.08", "vp09.00.50.08"].some((codecsForVideoContainer) => mediaSource.isTypeSupported(mimeTypeForCodec(codecsForVideoContainer, "video"))) || ["mp4a.40.2", "fLaC"].some((codecForAudioContainer) => mediaSource.isTypeSupported(mimeTypeForCodec(codecForAudioContainer, "audio"))));
|
|
|
-}
|
|
|
-function changeTypeSupported() {
|
|
|
- var _sourceBuffer$prototy;
|
|
|
- const sourceBuffer = getSourceBuffer();
|
|
|
- return typeof (sourceBuffer == null || (_sourceBuffer$prototy = sourceBuffer.prototype) == null ? void 0 : _sourceBuffer$prototy.changeType) === "function";
|
|
|
-}
|
|
|
-var TICK_INTERVAL = 100;
|
|
|
-var StreamController = class extends BaseStreamController {
|
|
|
- constructor(hls, fragmentTracker, keyLoader) {
|
|
|
- super(hls, fragmentTracker, keyLoader, "stream-controller", PlaylistLevelType.MAIN);
|
|
|
- this.audioCodecSwap = false;
|
|
|
- this.level = -1;
|
|
|
- this._forceStartLoad = false;
|
|
|
- this._hasEnoughToStart = false;
|
|
|
- this.altAudio = 0;
|
|
|
- this.audioOnly = false;
|
|
|
- this.fragPlaying = null;
|
|
|
- this.fragLastKbps = 0;
|
|
|
- this.couldBacktrack = false;
|
|
|
- this.backtrackFragment = null;
|
|
|
- this.audioCodecSwitch = false;
|
|
|
- this.videoBuffer = null;
|
|
|
- this.onMediaPlaying = () => {
|
|
|
- this.tick();
|
|
|
- };
|
|
|
- this.onMediaSeeked = () => {
|
|
|
- const media = this.media;
|
|
|
- const currentTime = media ? media.currentTime : null;
|
|
|
- if (currentTime === null || !isFiniteNumber(currentTime)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Media seeked to ${currentTime.toFixed(3)}`);
|
|
|
- if (!this.getBufferedFrag(currentTime)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferInfo = this.getFwdBufferInfoAtPos(media, currentTime, PlaylistLevelType.MAIN, 0);
|
|
|
- if (bufferInfo === null || bufferInfo.len === 0) {
|
|
|
- this.warn(`Main forward buffer length at ${currentTime} on "seeked" event ${bufferInfo ? bufferInfo.len : "empty"})`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.tick();
|
|
|
- };
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- super.registerListeners();
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
|
|
|
- hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.on(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
|
|
|
- hls.on(Events.BUFFER_CREATED, this.onBufferCreated, this);
|
|
|
- hls.on(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
|
|
|
- hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- super.unregisterListeners();
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MANIFEST_PARSED, this.onManifestParsed, this);
|
|
|
- hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
|
|
|
- hls.off(Events.FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
|
|
|
- hls.off(Events.BUFFER_CREATED, this.onBufferCreated, this);
|
|
|
- hls.off(Events.BUFFER_FLUSHED, this.onBufferFlushed, this);
|
|
|
- hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- hls.off(Events.FRAG_BUFFERED, this.onFragBuffered, this);
|
|
|
- }
|
|
|
- onHandlerDestroying() {
|
|
|
- this.onMediaPlaying = this.onMediaSeeked = null;
|
|
|
- this.unregisterListeners();
|
|
|
- super.onHandlerDestroying();
|
|
|
- }
|
|
|
- startLoad(startPosition, skipSeekToStartPosition) {
|
|
|
- if (this.levels) {
|
|
|
- const {
|
|
|
- lastCurrentTime,
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- this.stopLoad();
|
|
|
- this.setInterval(TICK_INTERVAL);
|
|
|
- this.level = -1;
|
|
|
- if (!this.startFragRequested) {
|
|
|
- let startLevel = hls.startLevel;
|
|
|
- if (startLevel === -1) {
|
|
|
- if (hls.config.testBandwidth && this.levels.length > 1) {
|
|
|
- startLevel = 0;
|
|
|
- this.bitrateTest = true;
|
|
|
- } else {
|
|
|
- startLevel = hls.firstAutoLevel;
|
|
|
- }
|
|
|
- }
|
|
|
- hls.nextLoadLevel = startLevel;
|
|
|
- this.level = hls.loadLevel;
|
|
|
- this._hasEnoughToStart = !!skipSeekToStartPosition;
|
|
|
- }
|
|
|
- if (lastCurrentTime > 0 && startPosition === -1 && !skipSeekToStartPosition) {
|
|
|
- this.log(`Override startPosition with lastCurrentTime @${lastCurrentTime.toFixed(3)}`);
|
|
|
- startPosition = lastCurrentTime;
|
|
|
- }
|
|
|
- this.state = State.IDLE;
|
|
|
- this.nextLoadPosition = this.lastCurrentTime = startPosition + this.timelineOffset;
|
|
|
- this.startPosition = skipSeekToStartPosition ? -1 : startPosition;
|
|
|
- this.tick();
|
|
|
- } else {
|
|
|
- this._forceStartLoad = true;
|
|
|
- this.state = State.STOPPED;
|
|
|
- }
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- this._forceStartLoad = false;
|
|
|
- super.stopLoad();
|
|
|
- }
|
|
|
- doTick() {
|
|
|
- switch (this.state) {
|
|
|
- case State.WAITING_LEVEL: {
|
|
|
- const {
|
|
|
- levels,
|
|
|
- level
|
|
|
- } = this;
|
|
|
- const currentLevel = levels == null ? void 0 : levels[level];
|
|
|
- const details = currentLevel == null ? void 0 : currentLevel.details;
|
|
|
- if (details && (!details.live || this.levelLastLoaded === currentLevel && !this.waitForLive(currentLevel))) {
|
|
|
- if (this.waitForCdnTuneIn(details)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- this.state = State.IDLE;
|
|
|
- break;
|
|
|
- } else if (this.hls.nextLoadLevel !== this.level) {
|
|
|
- this.state = State.IDLE;
|
|
|
- break;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case State.FRAG_LOADING_WAITING_RETRY:
|
|
|
- this.checkRetryDate();
|
|
|
- break;
|
|
|
- }
|
|
|
- if (this.state === State.IDLE) {
|
|
|
- this.doTickIdle();
|
|
|
- }
|
|
|
- this.onTickEnd();
|
|
|
- }
|
|
|
- onTickEnd() {
|
|
|
- var _this$media;
|
|
|
- super.onTickEnd();
|
|
|
- if ((_this$media = this.media) != null && _this$media.readyState && this.media.seeking === false) {
|
|
|
- this.lastCurrentTime = this.media.currentTime;
|
|
|
- }
|
|
|
- this.checkFragmentChanged();
|
|
|
- }
|
|
|
- doTickIdle() {
|
|
|
- const {
|
|
|
- hls,
|
|
|
- levelLastLoaded,
|
|
|
- levels,
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (levelLastLoaded === null || !media && !this.primaryPrefetch && (this.startFragRequested || !hls.config.startFragPrefetch)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.altAudio && this.audioOnly) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const level = this.buffering ? hls.nextLoadLevel : hls.loadLevel;
|
|
|
- if (!(levels != null && levels[level])) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const levelInfo = levels[level];
|
|
|
- const bufferInfo = this.getMainFwdBufferInfo();
|
|
|
- if (bufferInfo === null) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const lastDetails = this.getLevelDetails();
|
|
|
- if (lastDetails && this._streamEnded(bufferInfo, lastDetails)) {
|
|
|
- const data = {};
|
|
|
- if (this.altAudio === 2) {
|
|
|
- data.type = "video";
|
|
|
- }
|
|
|
- this.hls.trigger(Events.BUFFER_EOS, data);
|
|
|
- this.state = State.ENDED;
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!this.buffering) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (hls.loadLevel !== level && hls.manualLevel === -1) {
|
|
|
- this.log(`Adapting to level ${level} from level ${this.level}`);
|
|
|
- }
|
|
|
- this.level = hls.nextLoadLevel = level;
|
|
|
- const levelDetails = levelInfo.details;
|
|
|
- if (!levelDetails || this.state === State.WAITING_LEVEL || this.waitForLive(levelInfo)) {
|
|
|
- this.level = level;
|
|
|
- this.state = State.WAITING_LEVEL;
|
|
|
- this.startFragRequested = false;
|
|
|
- return;
|
|
|
- }
|
|
|
- const bufferLen = bufferInfo.len;
|
|
|
- const maxBufLen = this.getMaxBufferLength(levelInfo.maxBitrate);
|
|
|
- if (bufferLen >= maxBufLen) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.backtrackFragment && this.backtrackFragment.start > bufferInfo.end) {
|
|
|
- this.backtrackFragment = null;
|
|
|
- }
|
|
|
- const targetBufferTime = this.backtrackFragment ? this.backtrackFragment.start : bufferInfo.end;
|
|
|
- let frag = this.getNextFragment(targetBufferTime, levelDetails);
|
|
|
- if (this.couldBacktrack && !this.fragPrevious && frag && isMediaFragment(frag) && this.fragmentTracker.getState(frag) !== FragmentState.OK) {
|
|
|
- var _this$backtrackFragme;
|
|
|
- const backtrackSn = ((_this$backtrackFragme = this.backtrackFragment) != null ? _this$backtrackFragme : frag).sn;
|
|
|
- const fragIdx = backtrackSn - levelDetails.startSN;
|
|
|
- const backtrackFrag = levelDetails.fragments[fragIdx - 1];
|
|
|
- if (backtrackFrag && frag.cc === backtrackFrag.cc) {
|
|
|
- frag = backtrackFrag;
|
|
|
- this.fragmentTracker.removeFragment(backtrackFrag);
|
|
|
- }
|
|
|
- } else if (this.backtrackFragment && bufferInfo.len) {
|
|
|
- this.backtrackFragment = null;
|
|
|
- }
|
|
|
- if (frag && this.isLoopLoading(frag, targetBufferTime)) {
|
|
|
- const gapStart = frag.gap;
|
|
|
- if (!gapStart) {
|
|
|
- const type = this.audioOnly && !this.altAudio ? ElementaryStreamTypes.AUDIO : ElementaryStreamTypes.VIDEO;
|
|
|
- const mediaBuffer = (type === ElementaryStreamTypes.VIDEO ? this.videoBuffer : this.mediaBuffer) || this.media;
|
|
|
- if (mediaBuffer) {
|
|
|
- this.afterBufferFlushed(mediaBuffer, type, PlaylistLevelType.MAIN);
|
|
|
- }
|
|
|
- }
|
|
|
- frag = this.getNextFragmentLoopLoading(frag, levelDetails, bufferInfo, PlaylistLevelType.MAIN, maxBufLen);
|
|
|
- }
|
|
|
- if (!frag) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (frag.initSegment && !frag.initSegment.data && !this.bitrateTest) {
|
|
|
- frag = frag.initSegment;
|
|
|
- }
|
|
|
- this.loadFragment(frag, levelInfo, targetBufferTime);
|
|
|
- }
|
|
|
- loadFragment(frag, level, targetBufferTime) {
|
|
|
- const fragState = this.fragmentTracker.getState(frag);
|
|
|
- if (fragState === FragmentState.NOT_LOADED || fragState === FragmentState.PARTIAL) {
|
|
|
- if (!isMediaFragment(frag)) {
|
|
|
- this._loadInitSegment(frag, level);
|
|
|
- } else if (this.bitrateTest) {
|
|
|
- this.log(`Fragment ${frag.sn} of level ${frag.level} is being downloaded to test bitrate and will not be buffered`);
|
|
|
- this._loadBitrateTestFrag(frag, level);
|
|
|
- } else {
|
|
|
- super.loadFragment(frag, level, targetBufferTime);
|
|
|
- }
|
|
|
- } else {
|
|
|
- this.clearTrackerIfNeeded(frag);
|
|
|
- }
|
|
|
- }
|
|
|
- getBufferedFrag(position) {
|
|
|
- return this.fragmentTracker.getBufferedFrag(position, PlaylistLevelType.MAIN);
|
|
|
- }
|
|
|
- followingBufferedFrag(frag) {
|
|
|
- if (frag) {
|
|
|
- return this.getBufferedFrag(frag.end + 0.5);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- /*
|
|
|
- on immediate level switch :
|
|
|
- - pause playback if playing
|
|
|
- - cancel any pending load request
|
|
|
- - and trigger a buffer flush
|
|
|
- */
|
|
|
- immediateLevelSwitch() {
|
|
|
- this.abortCurrentFrag();
|
|
|
- this.flushMainBuffer(0, Number.POSITIVE_INFINITY);
|
|
|
- }
|
|
|
- /**
|
|
|
- * try to switch ASAP without breaking video playback:
|
|
|
- * in order to ensure smooth but quick level switching,
|
|
|
- * we need to find the next flushable buffer range
|
|
|
- * we should take into account new segment fetch time
|
|
|
- */
|
|
|
- nextLevelSwitch() {
|
|
|
- const {
|
|
|
- levels,
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (media != null && media.readyState) {
|
|
|
- let fetchdelay;
|
|
|
- const fragPlayingCurrent = this.getAppendedFrag(media.currentTime);
|
|
|
- if (fragPlayingCurrent && fragPlayingCurrent.start > 1) {
|
|
|
- this.flushMainBuffer(0, fragPlayingCurrent.start - 1);
|
|
|
- }
|
|
|
- const levelDetails = this.getLevelDetails();
|
|
|
- if (levelDetails != null && levelDetails.live) {
|
|
|
- const bufferInfo = this.getMainFwdBufferInfo();
|
|
|
- if (!bufferInfo || bufferInfo.len < levelDetails.targetduration * 2) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!media.paused && levels) {
|
|
|
- const nextLevelId = this.hls.nextLoadLevel;
|
|
|
- const nextLevel = levels[nextLevelId];
|
|
|
- const fragLastKbps = this.fragLastKbps;
|
|
|
- if (fragLastKbps && this.fragCurrent) {
|
|
|
- fetchdelay = this.fragCurrent.duration * nextLevel.maxBitrate / (1e3 * fragLastKbps) + 1;
|
|
|
- } else {
|
|
|
- fetchdelay = 0;
|
|
|
- }
|
|
|
- } else {
|
|
|
- fetchdelay = 0;
|
|
|
- }
|
|
|
- const bufferedFrag = this.getBufferedFrag(media.currentTime + fetchdelay);
|
|
|
- if (bufferedFrag) {
|
|
|
- const nextBufferedFrag = this.followingBufferedFrag(bufferedFrag);
|
|
|
- if (nextBufferedFrag) {
|
|
|
- this.abortCurrentFrag();
|
|
|
- const maxStart = nextBufferedFrag.maxStartPTS ? nextBufferedFrag.maxStartPTS : nextBufferedFrag.start;
|
|
|
- const fragDuration = nextBufferedFrag.duration;
|
|
|
- const startPts = Math.max(bufferedFrag.end, maxStart + Math.min(Math.max(fragDuration - this.config.maxFragLookUpTolerance, fragDuration * (this.couldBacktrack ? 0.5 : 0.125)), fragDuration * (this.couldBacktrack ? 0.75 : 0.25)));
|
|
|
- this.flushMainBuffer(startPts, Number.POSITIVE_INFINITY);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- abortCurrentFrag() {
|
|
|
- const fragCurrent = this.fragCurrent;
|
|
|
- this.fragCurrent = null;
|
|
|
- this.backtrackFragment = null;
|
|
|
- if (fragCurrent) {
|
|
|
- fragCurrent.abortRequests();
|
|
|
- this.fragmentTracker.removeFragment(fragCurrent);
|
|
|
- }
|
|
|
- switch (this.state) {
|
|
|
- case State.KEY_LOADING:
|
|
|
- case State.FRAG_LOADING:
|
|
|
- case State.FRAG_LOADING_WAITING_RETRY:
|
|
|
- case State.PARSING:
|
|
|
- case State.PARSED:
|
|
|
- this.state = State.IDLE;
|
|
|
- break;
|
|
|
- }
|
|
|
- this.nextLoadPosition = this.getLoadPosition();
|
|
|
- }
|
|
|
- flushMainBuffer(startOffset, endOffset) {
|
|
|
- super.flushMainBuffer(startOffset, endOffset, this.altAudio === 2 ? "video" : null);
|
|
|
- }
|
|
|
- onMediaAttached(event, data) {
|
|
|
- super.onMediaAttached(event, data);
|
|
|
- const media = data.media;
|
|
|
- addEventListener(media, "playing", this.onMediaPlaying);
|
|
|
- addEventListener(media, "seeked", this.onMediaSeeked);
|
|
|
- }
|
|
|
- onMediaDetaching(event, data) {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (media) {
|
|
|
- removeEventListener(media, "playing", this.onMediaPlaying);
|
|
|
- removeEventListener(media, "seeked", this.onMediaSeeked);
|
|
|
- }
|
|
|
- this.videoBuffer = null;
|
|
|
- this.fragPlaying = null;
|
|
|
- super.onMediaDetaching(event, data);
|
|
|
- const transferringMedia = !!data.transferMedia;
|
|
|
- if (transferringMedia) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this._hasEnoughToStart = false;
|
|
|
- }
|
|
|
- onManifestLoading() {
|
|
|
- super.onManifestLoading();
|
|
|
- this.log("Trigger BUFFER_RESET");
|
|
|
- this.hls.trigger(Events.BUFFER_RESET, void 0);
|
|
|
- this.couldBacktrack = false;
|
|
|
- this.fragLastKbps = 0;
|
|
|
- this.fragPlaying = this.backtrackFragment = null;
|
|
|
- this.altAudio = 0;
|
|
|
- this.audioOnly = false;
|
|
|
- }
|
|
|
- onManifestParsed(event, data) {
|
|
|
- let aac = false;
|
|
|
- let heaac = false;
|
|
|
- for (let i = 0; i < data.levels.length; i++) {
|
|
|
- const codec = data.levels[i].audioCodec;
|
|
|
- if (codec) {
|
|
|
- aac = aac || codec.indexOf("mp4a.40.2") !== -1;
|
|
|
- heaac = heaac || codec.indexOf("mp4a.40.5") !== -1;
|
|
|
- }
|
|
|
- }
|
|
|
- this.audioCodecSwitch = aac && heaac && !changeTypeSupported();
|
|
|
- if (this.audioCodecSwitch) {
|
|
|
- this.log("Both AAC/HE-AAC audio found in levels; declaring level codec as HE-AAC");
|
|
|
- }
|
|
|
- this.levels = data.levels;
|
|
|
- this.startFragRequested = false;
|
|
|
- }
|
|
|
- onLevelLoading(event, data) {
|
|
|
- const {
|
|
|
- levels
|
|
|
- } = this;
|
|
|
- if (!levels || this.state !== State.IDLE) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const level = data.levelInfo;
|
|
|
- if (!level.details || level.details.live && (this.levelLastLoaded !== level || level.details.expired) || this.waitForCdnTuneIn(level.details)) {
|
|
|
- this.state = State.WAITING_LEVEL;
|
|
|
- }
|
|
|
- }
|
|
|
- onLevelLoaded(event, data) {
|
|
|
- var _curLevel$details;
|
|
|
- const {
|
|
|
- levels,
|
|
|
- startFragRequested
|
|
|
- } = this;
|
|
|
- const newLevelId = data.level;
|
|
|
- const newDetails = data.details;
|
|
|
- const duration = newDetails.totalduration;
|
|
|
- if (!levels) {
|
|
|
- this.warn(`Levels were reset while loading level ${newLevelId}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.log(`Level ${newLevelId} loaded [${newDetails.startSN},${newDetails.endSN}]${newDetails.lastPartSn ? `[part-${newDetails.lastPartSn}-${newDetails.lastPartIndex}]` : ""}, cc [${newDetails.startCC}, ${newDetails.endCC}] duration:${duration}`);
|
|
|
- const curLevel = data.levelInfo;
|
|
|
- const fragCurrent = this.fragCurrent;
|
|
|
- if (fragCurrent && (this.state === State.FRAG_LOADING || this.state === State.FRAG_LOADING_WAITING_RETRY)) {
|
|
|
- if (fragCurrent.level !== data.level && fragCurrent.loader) {
|
|
|
- this.abortCurrentFrag();
|
|
|
- }
|
|
|
- }
|
|
|
- let sliding = 0;
|
|
|
- if (newDetails.live || (_curLevel$details = curLevel.details) != null && _curLevel$details.live) {
|
|
|
- var _this$levelLastLoaded;
|
|
|
- this.checkLiveUpdate(newDetails);
|
|
|
- if (newDetails.deltaUpdateFailed) {
|
|
|
- return;
|
|
|
- }
|
|
|
- sliding = this.alignPlaylists(newDetails, curLevel.details, (_this$levelLastLoaded = this.levelLastLoaded) == null ? void 0 : _this$levelLastLoaded.details);
|
|
|
- }
|
|
|
- curLevel.details = newDetails;
|
|
|
- this.levelLastLoaded = curLevel;
|
|
|
- if (!startFragRequested) {
|
|
|
- this.setStartPosition(newDetails, sliding);
|
|
|
- }
|
|
|
- this.hls.trigger(Events.LEVEL_UPDATED, {
|
|
|
- details: newDetails,
|
|
|
- level: newLevelId
|
|
|
- });
|
|
|
- if (this.state === State.WAITING_LEVEL) {
|
|
|
- if (this.waitForCdnTuneIn(newDetails)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- if (startFragRequested && newDetails.live) {
|
|
|
- this.synchronizeToLiveEdge(newDetails);
|
|
|
- }
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- synchronizeToLiveEdge(levelDetails) {
|
|
|
- const {
|
|
|
- config,
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const liveSyncPosition = this.hls.liveSyncPosition;
|
|
|
- const currentTime = this.getLoadPosition();
|
|
|
- const start = levelDetails.fragmentStart;
|
|
|
- const end = levelDetails.edge;
|
|
|
- const withinSlidingWindow = currentTime >= start - config.maxFragLookUpTolerance && currentTime <= end;
|
|
|
- if (liveSyncPosition !== null && media.duration > liveSyncPosition && (currentTime < liveSyncPosition || !withinSlidingWindow)) {
|
|
|
- const maxLatency = config.liveMaxLatencyDuration !== void 0 ? config.liveMaxLatencyDuration : config.liveMaxLatencyDurationCount * levelDetails.targetduration;
|
|
|
- if (!withinSlidingWindow && media.readyState < 4 || currentTime < end - maxLatency) {
|
|
|
- if (!this._hasEnoughToStart) {
|
|
|
- this.nextLoadPosition = liveSyncPosition;
|
|
|
- }
|
|
|
- if (media.readyState) {
|
|
|
- this.warn(`Playback: ${currentTime.toFixed(3)} is located too far from the end of live sliding playlist: ${end}, reset currentTime to : ${liveSyncPosition.toFixed(3)}`);
|
|
|
- if (this.config.liveSyncMode === "buffered") {
|
|
|
- var _bufferInfo$buffered;
|
|
|
- const bufferInfo = BufferHelper.bufferInfo(media, liveSyncPosition, 0);
|
|
|
- if (!((_bufferInfo$buffered = bufferInfo.buffered) != null && _bufferInfo$buffered.length)) {
|
|
|
- media.currentTime = liveSyncPosition;
|
|
|
- return;
|
|
|
- }
|
|
|
- const isLiveSyncInBuffer = bufferInfo.start <= currentTime;
|
|
|
- if (isLiveSyncInBuffer) {
|
|
|
- media.currentTime = liveSyncPosition;
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- nextStart
|
|
|
- } = BufferHelper.bufferedInfo(bufferInfo.buffered, currentTime, 0);
|
|
|
- if (nextStart) {
|
|
|
- media.currentTime = nextStart;
|
|
|
- }
|
|
|
- } else {
|
|
|
- media.currentTime = liveSyncPosition;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- _handleFragmentLoadProgress(data) {
|
|
|
- var _frag$initSegment;
|
|
|
- const frag = data.frag;
|
|
|
- const {
|
|
|
- part,
|
|
|
- payload
|
|
|
- } = data;
|
|
|
- const {
|
|
|
- levels
|
|
|
- } = this;
|
|
|
- if (!levels) {
|
|
|
- this.warn(`Levels were reset while fragment load was in progress. Fragment ${frag.sn} of level ${frag.level} will not be buffered`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentLevel = levels[frag.level];
|
|
|
- if (!currentLevel) {
|
|
|
- this.warn(`Level ${frag.level} not found on progress`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const details = currentLevel.details;
|
|
|
- if (!details) {
|
|
|
- this.warn(`Dropping fragment ${frag.sn} of level ${frag.level} after level details were reset`);
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- return;
|
|
|
- }
|
|
|
- const videoCodec = currentLevel.videoCodec;
|
|
|
- const accurateTimeOffset = details.PTSKnown || !details.live;
|
|
|
- const initSegmentData = (_frag$initSegment = frag.initSegment) == null ? void 0 : _frag$initSegment.data;
|
|
|
- const audioCodec = this._getAudioCodec(currentLevel);
|
|
|
- const transmuxer = this.transmuxer = this.transmuxer || new TransmuxerInterface(this.hls, PlaylistLevelType.MAIN, this._handleTransmuxComplete.bind(this), this._handleTransmuxerFlush.bind(this));
|
|
|
- const partIndex = part ? part.index : -1;
|
|
|
- const partial = partIndex !== -1;
|
|
|
- const chunkMeta = new ChunkMetadata(frag.level, frag.sn, frag.stats.chunkCount, payload.byteLength, partIndex, partial);
|
|
|
- const initPTS = this.initPTS[frag.cc];
|
|
|
- transmuxer.push(payload, initSegmentData, audioCodec, videoCodec, frag, part, details.totalduration, accurateTimeOffset, chunkMeta, initPTS);
|
|
|
- }
|
|
|
- onAudioTrackSwitching(event, data) {
|
|
|
- const hls = this.hls;
|
|
|
- const fromAltAudio = this.altAudio === 2;
|
|
|
- const altAudio = useAlternateAudio(data.url, hls);
|
|
|
- if (!altAudio) {
|
|
|
- if (this.mediaBuffer !== this.media) {
|
|
|
- this.log("Switching on main audio, use media.buffered to schedule main fragment loading");
|
|
|
- this.mediaBuffer = this.media;
|
|
|
- const fragCurrent = this.fragCurrent;
|
|
|
- if (fragCurrent) {
|
|
|
- this.log("Switching to main audio track, cancel main fragment load");
|
|
|
- fragCurrent.abortRequests();
|
|
|
- this.fragmentTracker.removeFragment(fragCurrent);
|
|
|
- }
|
|
|
- this.resetTransmuxer();
|
|
|
- this.resetLoadingState();
|
|
|
- } else if (this.audioOnly) {
|
|
|
- this.resetTransmuxer();
|
|
|
- }
|
|
|
- if (fromAltAudio) {
|
|
|
- this.fragmentTracker.removeAllFragments();
|
|
|
- hls.once(Events.BUFFER_FLUSHED, () => {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.hls.trigger(Events.AUDIO_TRACK_SWITCHED, data);
|
|
|
- });
|
|
|
- hls.trigger(Events.BUFFER_FLUSHING, {
|
|
|
- startOffset: 0,
|
|
|
- endOffset: Number.POSITIVE_INFINITY,
|
|
|
- type: null
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- hls.trigger(Events.AUDIO_TRACK_SWITCHED, data);
|
|
|
- } else {
|
|
|
- this.altAudio = 1;
|
|
|
- }
|
|
|
- }
|
|
|
- onAudioTrackSwitched(event, data) {
|
|
|
- const altAudio = useAlternateAudio(data.url, this.hls);
|
|
|
- if (altAudio) {
|
|
|
- const videoBuffer = this.videoBuffer;
|
|
|
- if (videoBuffer && this.mediaBuffer !== videoBuffer) {
|
|
|
- this.log("Switching on alternate audio, use video.buffered to schedule main fragment loading");
|
|
|
- this.mediaBuffer = videoBuffer;
|
|
|
- }
|
|
|
- }
|
|
|
- this.altAudio = altAudio ? 2 : 0;
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- onBufferCreated(event, data) {
|
|
|
- const tracks = data.tracks;
|
|
|
- let mediaTrack;
|
|
|
- let name;
|
|
|
- let alternate = false;
|
|
|
- for (const type in tracks) {
|
|
|
- const track = tracks[type];
|
|
|
- if (track.id === "main") {
|
|
|
- name = type;
|
|
|
- mediaTrack = track;
|
|
|
- if (type === "video") {
|
|
|
- const videoTrack = tracks[type];
|
|
|
- if (videoTrack) {
|
|
|
- this.videoBuffer = videoTrack.buffer;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- alternate = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (alternate && mediaTrack) {
|
|
|
- this.log(`Alternate track found, use ${name}.buffered to schedule main fragment loading`);
|
|
|
- this.mediaBuffer = mediaTrack.buffer;
|
|
|
- } else {
|
|
|
- this.mediaBuffer = this.media;
|
|
|
- }
|
|
|
- }
|
|
|
- onFragBuffered(event, data) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part
|
|
|
- } = data;
|
|
|
- const bufferedMainFragment = frag.type === PlaylistLevelType.MAIN;
|
|
|
- if (bufferedMainFragment) {
|
|
|
- if (this.fragContextChanged(frag)) {
|
|
|
- this.warn(`Fragment ${frag.sn}${part ? " p: " + part.index : ""} of level ${frag.level} finished buffering, but was aborted. state: ${this.state}`);
|
|
|
- if (this.state === State.PARSED) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- const stats = part ? part.stats : frag.stats;
|
|
|
- this.fragLastKbps = Math.round(8 * stats.total / (stats.buffering.end - stats.loading.first));
|
|
|
- if (isMediaFragment(frag)) {
|
|
|
- this.fragPrevious = frag;
|
|
|
- }
|
|
|
- this.fragBufferedComplete(frag, part);
|
|
|
- }
|
|
|
- const media = this.media;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!this._hasEnoughToStart && BufferHelper.getBuffered(media).length) {
|
|
|
- this._hasEnoughToStart = true;
|
|
|
- this.seekToStartPos();
|
|
|
- }
|
|
|
- if (bufferedMainFragment) {
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- }
|
|
|
- get hasEnoughToStart() {
|
|
|
- return this._hasEnoughToStart;
|
|
|
- }
|
|
|
- onError(event, data) {
|
|
|
- var _data$context;
|
|
|
- if (data.fatal) {
|
|
|
- this.state = State.ERROR;
|
|
|
- return;
|
|
|
- }
|
|
|
- switch (data.details) {
|
|
|
- case ErrorDetails.FRAG_GAP:
|
|
|
- case ErrorDetails.FRAG_PARSING_ERROR:
|
|
|
- case ErrorDetails.FRAG_DECRYPT_ERROR:
|
|
|
- case ErrorDetails.FRAG_LOAD_ERROR:
|
|
|
- case ErrorDetails.FRAG_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.KEY_LOAD_ERROR:
|
|
|
- case ErrorDetails.KEY_LOAD_TIMEOUT:
|
|
|
- this.onFragmentOrKeyLoadError(PlaylistLevelType.MAIN, data);
|
|
|
- break;
|
|
|
- case ErrorDetails.LEVEL_LOAD_ERROR:
|
|
|
- case ErrorDetails.LEVEL_LOAD_TIMEOUT:
|
|
|
- case ErrorDetails.LEVEL_PARSING_ERROR:
|
|
|
- if (!data.levelRetry && this.state === State.WAITING_LEVEL && ((_data$context = data.context) == null ? void 0 : _data$context.type) === PlaylistContextType.LEVEL) {
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- break;
|
|
|
- case ErrorDetails.BUFFER_ADD_CODEC_ERROR:
|
|
|
- case ErrorDetails.BUFFER_APPEND_ERROR:
|
|
|
- if (data.parent !== "main") {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.reduceLengthAndFlushBuffer(data)) {
|
|
|
- this.resetLoadingState();
|
|
|
- }
|
|
|
- break;
|
|
|
- case ErrorDetails.BUFFER_FULL_ERROR:
|
|
|
- if (data.parent !== "main") {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this.reduceLengthAndFlushBuffer(data)) {
|
|
|
- const isAssetPlayer = !this.config.interstitialsController && this.config.assetPlayerId;
|
|
|
- if (isAssetPlayer) {
|
|
|
- this._hasEnoughToStart = true;
|
|
|
- } else {
|
|
|
- this.flushMainBuffer(0, Number.POSITIVE_INFINITY);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- case ErrorDetails.INTERNAL_EXCEPTION:
|
|
|
- this.recoverWorkerError(data);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- onFragLoadEmergencyAborted() {
|
|
|
- this.state = State.IDLE;
|
|
|
- if (!this._hasEnoughToStart) {
|
|
|
- this.startFragRequested = false;
|
|
|
- this.nextLoadPosition = this.lastCurrentTime;
|
|
|
- }
|
|
|
- this.tickImmediate();
|
|
|
- }
|
|
|
- onBufferFlushed(event, {
|
|
|
- type
|
|
|
- }) {
|
|
|
- if (type !== ElementaryStreamTypes.AUDIO || !this.altAudio) {
|
|
|
- const mediaBuffer = (type === ElementaryStreamTypes.VIDEO ? this.videoBuffer : this.mediaBuffer) || this.media;
|
|
|
- if (mediaBuffer) {
|
|
|
- this.afterBufferFlushed(mediaBuffer, type, PlaylistLevelType.MAIN);
|
|
|
- this.tick();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- onLevelsUpdated(event, data) {
|
|
|
- if (this.level > -1 && this.fragCurrent) {
|
|
|
- this.level = this.fragCurrent.level;
|
|
|
- if (this.level === -1) {
|
|
|
- this.resetWhenMissingContext(this.fragCurrent);
|
|
|
- }
|
|
|
- }
|
|
|
- this.levels = data.levels;
|
|
|
- }
|
|
|
- swapAudioCodec() {
|
|
|
- this.audioCodecSwap = !this.audioCodecSwap;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Seeks to the set startPosition if not equal to the mediaElement's current time.
|
|
|
- */
|
|
|
- seekToStartPos() {
|
|
|
- const {
|
|
|
- media
|
|
|
- } = this;
|
|
|
- if (!media) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const currentTime = media.currentTime;
|
|
|
- let startPosition = this.startPosition;
|
|
|
- if (startPosition >= 0 && currentTime < startPosition) {
|
|
|
- if (media.seeking) {
|
|
|
- this.log(`could not seek to ${startPosition}, already seeking at ${currentTime}`);
|
|
|
- return;
|
|
|
- }
|
|
|
- const timelineOffset = this.timelineOffset;
|
|
|
- if (timelineOffset && startPosition) {
|
|
|
- startPosition += timelineOffset;
|
|
|
- }
|
|
|
- const details = this.getLevelDetails();
|
|
|
- const buffered = BufferHelper.getBuffered(media);
|
|
|
- const bufferStart = buffered.length ? buffered.start(0) : 0;
|
|
|
- const delta = bufferStart - startPosition;
|
|
|
- const skipTolerance = Math.max(this.config.maxBufferHole, this.config.maxFragLookUpTolerance);
|
|
|
- if (this.config.startOnSegmentBoundary || delta > 0 && (delta < skipTolerance || this.loadingParts && delta < 2 * ((details == null ? void 0 : details.partTarget) || 0))) {
|
|
|
- this.log(`adjusting start position by ${delta} to match buffer start`);
|
|
|
- startPosition += delta;
|
|
|
- this.startPosition = startPosition;
|
|
|
- }
|
|
|
- if (currentTime < startPosition) {
|
|
|
- this.log(`seek to target start position ${startPosition} from current time ${currentTime} buffer start ${bufferStart}`);
|
|
|
- media.currentTime = startPosition;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- _getAudioCodec(currentLevel) {
|
|
|
- let audioCodec = this.config.defaultAudioCodec || currentLevel.audioCodec;
|
|
|
- if (this.audioCodecSwap && audioCodec) {
|
|
|
- this.log("Swapping audio codec");
|
|
|
- if (audioCodec.indexOf("mp4a.40.5") !== -1) {
|
|
|
- audioCodec = "mp4a.40.2";
|
|
|
- } else {
|
|
|
- audioCodec = "mp4a.40.5";
|
|
|
- }
|
|
|
- }
|
|
|
- return audioCodec;
|
|
|
- }
|
|
|
- _loadBitrateTestFrag(fragment, level) {
|
|
|
- fragment.bitrateTest = true;
|
|
|
- this._doFragLoad(fragment, level).then((data) => {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- const frag = data == null ? void 0 : data.frag;
|
|
|
- if (!frag || this.fragContextChanged(frag)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- level.fragmentError = 0;
|
|
|
- this.state = State.IDLE;
|
|
|
- this.startFragRequested = false;
|
|
|
- this.bitrateTest = false;
|
|
|
- const stats = frag.stats;
|
|
|
- stats.parsing.start = stats.parsing.end = stats.buffering.start = stats.buffering.end = self.performance.now();
|
|
|
- hls.trigger(Events.FRAG_LOADED, data);
|
|
|
- frag.bitrateTest = false;
|
|
|
- }).catch((reason) => {
|
|
|
- if (this.state === State.STOPPED || this.state === State.ERROR) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.warn(reason);
|
|
|
- this.resetFragmentLoading(fragment);
|
|
|
- });
|
|
|
- }
|
|
|
- _handleTransmuxComplete(transmuxResult) {
|
|
|
- const id = this.playlistType;
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- const {
|
|
|
- remuxResult,
|
|
|
- chunkMeta
|
|
|
- } = transmuxResult;
|
|
|
- const context = this.getCurrentContext(chunkMeta);
|
|
|
- if (!context) {
|
|
|
- this.resetWhenMissingContext(chunkMeta);
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- frag,
|
|
|
- part,
|
|
|
- level
|
|
|
- } = context;
|
|
|
- const {
|
|
|
- video,
|
|
|
- text,
|
|
|
- id3,
|
|
|
- initSegment
|
|
|
- } = remuxResult;
|
|
|
- const {
|
|
|
- details
|
|
|
- } = level;
|
|
|
- const audio = this.altAudio ? void 0 : remuxResult.audio;
|
|
|
- if (this.fragContextChanged(frag)) {
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.state = State.PARSING;
|
|
|
- if (initSegment) {
|
|
|
- const tracks = initSegment.tracks;
|
|
|
- if (tracks) {
|
|
|
- const mapFragment = frag.initSegment || frag;
|
|
|
- if (this.unhandledEncryptionError(initSegment, frag)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this._bufferInitSegment(level, tracks, mapFragment, chunkMeta);
|
|
|
- hls.trigger(Events.FRAG_PARSING_INIT_SEGMENT, {
|
|
|
- frag: mapFragment,
|
|
|
- id,
|
|
|
- tracks
|
|
|
- });
|
|
|
- }
|
|
|
- const baseTime = initSegment.initPTS;
|
|
|
- const timescale = initSegment.timescale;
|
|
|
- const initPTS = this.initPTS[frag.cc];
|
|
|
- if (isFiniteNumber(baseTime) && (!initPTS || initPTS.baseTime !== baseTime || initPTS.timescale !== timescale)) {
|
|
|
- const trackId = initSegment.trackId;
|
|
|
- this.initPTS[frag.cc] = {
|
|
|
- baseTime,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- };
|
|
|
- hls.trigger(Events.INIT_PTS_FOUND, {
|
|
|
- frag,
|
|
|
- id,
|
|
|
- initPTS: baseTime,
|
|
|
- timescale,
|
|
|
- trackId
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- if (video && details) {
|
|
|
- if (audio && video.type === "audiovideo") {
|
|
|
- this.logMuxedErr(frag);
|
|
|
- }
|
|
|
- const prevFrag = details.fragments[frag.sn - 1 - details.startSN];
|
|
|
- const isFirstFragment = frag.sn === details.startSN;
|
|
|
- const isFirstInDiscontinuity = !prevFrag || frag.cc > prevFrag.cc;
|
|
|
- if (remuxResult.independent !== false) {
|
|
|
- const {
|
|
|
- startPTS,
|
|
|
- endPTS,
|
|
|
- startDTS,
|
|
|
- endDTS
|
|
|
- } = video;
|
|
|
- if (part) {
|
|
|
- part.elementaryStreams[video.type] = {
|
|
|
- startPTS,
|
|
|
- endPTS,
|
|
|
- startDTS,
|
|
|
- endDTS
|
|
|
- };
|
|
|
- } else {
|
|
|
- if (video.firstKeyFrame && video.independent && chunkMeta.id === 1 && !isFirstInDiscontinuity) {
|
|
|
- this.couldBacktrack = true;
|
|
|
- }
|
|
|
- if (video.dropped && video.independent) {
|
|
|
- const bufferInfo = this.getMainFwdBufferInfo();
|
|
|
- const targetBufferTime = (bufferInfo ? bufferInfo.end : this.getLoadPosition()) + this.config.maxBufferHole;
|
|
|
- const startTime = video.firstKeyFramePTS ? video.firstKeyFramePTS : startPTS;
|
|
|
- if (!isFirstFragment && targetBufferTime < startTime - this.config.maxBufferHole && !isFirstInDiscontinuity) {
|
|
|
- this.backtrack(frag);
|
|
|
- return;
|
|
|
- } else if (isFirstInDiscontinuity) {
|
|
|
- frag.gap = true;
|
|
|
- }
|
|
|
- frag.setElementaryStreamInfo(video.type, frag.start, endPTS, frag.start, endDTS, true);
|
|
|
- } else if (isFirstFragment && startPTS - (details.appliedTimelineOffset || 0) > MAX_START_GAP_JUMP) {
|
|
|
- frag.gap = true;
|
|
|
- }
|
|
|
- }
|
|
|
- frag.setElementaryStreamInfo(video.type, startPTS, endPTS, startDTS, endDTS);
|
|
|
- if (this.backtrackFragment) {
|
|
|
- this.backtrackFragment = frag;
|
|
|
- }
|
|
|
- this.bufferFragmentData(video, frag, part, chunkMeta, isFirstFragment || isFirstInDiscontinuity);
|
|
|
- } else if (isFirstFragment || isFirstInDiscontinuity) {
|
|
|
- frag.gap = true;
|
|
|
- } else {
|
|
|
- this.backtrack(frag);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- if (audio) {
|
|
|
- const {
|
|
|
- startPTS,
|
|
|
- endPTS,
|
|
|
- startDTS,
|
|
|
- endDTS
|
|
|
- } = audio;
|
|
|
- if (part) {
|
|
|
- part.elementaryStreams[ElementaryStreamTypes.AUDIO] = {
|
|
|
- startPTS,
|
|
|
- endPTS,
|
|
|
- startDTS,
|
|
|
- endDTS
|
|
|
- };
|
|
|
- }
|
|
|
- frag.setElementaryStreamInfo(ElementaryStreamTypes.AUDIO, startPTS, endPTS, startDTS, endDTS);
|
|
|
- this.bufferFragmentData(audio, frag, part, chunkMeta);
|
|
|
- }
|
|
|
- if (details && id3 != null && id3.samples.length) {
|
|
|
- const emittedID3 = {
|
|
|
- id,
|
|
|
- frag,
|
|
|
- details,
|
|
|
- samples: id3.samples
|
|
|
- };
|
|
|
- hls.trigger(Events.FRAG_PARSING_METADATA, emittedID3);
|
|
|
- }
|
|
|
- if (details && text) {
|
|
|
- const emittedText = {
|
|
|
- id,
|
|
|
- frag,
|
|
|
- details,
|
|
|
- samples: text.samples
|
|
|
- };
|
|
|
- hls.trigger(Events.FRAG_PARSING_USERDATA, emittedText);
|
|
|
- }
|
|
|
- }
|
|
|
- logMuxedErr(frag) {
|
|
|
- this.warn(`${isMediaFragment(frag) ? "Media" : "Init"} segment with muxed audiovideo where only video expected: ${frag.url}`);
|
|
|
- }
|
|
|
- _bufferInitSegment(currentLevel, tracks, frag, chunkMeta) {
|
|
|
- if (this.state !== State.PARSING) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.audioOnly = !!tracks.audio && !tracks.video;
|
|
|
- if (this.altAudio && !this.audioOnly) {
|
|
|
- delete tracks.audio;
|
|
|
- if (tracks.audiovideo) {
|
|
|
- this.logMuxedErr(frag);
|
|
|
- }
|
|
|
- }
|
|
|
- const {
|
|
|
- audio,
|
|
|
- video,
|
|
|
- audiovideo
|
|
|
- } = tracks;
|
|
|
- if (audio) {
|
|
|
- const levelCodec = currentLevel.audioCodec;
|
|
|
- let audioCodec = pickMostCompleteCodecName(audio.codec, levelCodec);
|
|
|
- if (audioCodec === "mp4a") {
|
|
|
- audioCodec = "mp4a.40.5";
|
|
|
- }
|
|
|
- const ua = navigator.userAgent.toLowerCase();
|
|
|
- if (this.audioCodecSwitch) {
|
|
|
- if (audioCodec) {
|
|
|
- if (audioCodec.indexOf("mp4a.40.5") !== -1) {
|
|
|
- audioCodec = "mp4a.40.2";
|
|
|
- } else {
|
|
|
- audioCodec = "mp4a.40.5";
|
|
|
- }
|
|
|
- }
|
|
|
- const audioMetadata = audio.metadata;
|
|
|
- if (audioMetadata && "channelCount" in audioMetadata && (audioMetadata.channelCount || 1) !== 1 && ua.indexOf("firefox") === -1) {
|
|
|
- audioCodec = "mp4a.40.5";
|
|
|
- }
|
|
|
- }
|
|
|
- if (audioCodec && audioCodec.indexOf("mp4a.40.5") !== -1 && ua.indexOf("android") !== -1 && audio.container !== "audio/mpeg") {
|
|
|
- audioCodec = "mp4a.40.2";
|
|
|
- this.log(`Android: force audio codec to ${audioCodec}`);
|
|
|
- }
|
|
|
- if (levelCodec && levelCodec !== audioCodec) {
|
|
|
- this.log(`Swapping manifest audio codec "${levelCodec}" for "${audioCodec}"`);
|
|
|
- }
|
|
|
- audio.levelCodec = audioCodec;
|
|
|
- audio.id = PlaylistLevelType.MAIN;
|
|
|
- this.log(`Init audio buffer, container:${audio.container}, codecs[selected/level/parsed]=[${audioCodec || ""}/${levelCodec || ""}/${audio.codec}]`);
|
|
|
- delete tracks.audiovideo;
|
|
|
- }
|
|
|
- if (video) {
|
|
|
- video.levelCodec = currentLevel.videoCodec;
|
|
|
- video.id = PlaylistLevelType.MAIN;
|
|
|
- const parsedVideoCodec = video.codec;
|
|
|
- if ((parsedVideoCodec == null ? void 0 : parsedVideoCodec.length) === 4) {
|
|
|
- switch (parsedVideoCodec) {
|
|
|
- case "hvc1":
|
|
|
- case "hev1":
|
|
|
- video.codec = "hvc1.1.6.L120.90";
|
|
|
- break;
|
|
|
- case "av01":
|
|
|
- video.codec = "av01.0.04M.08";
|
|
|
- break;
|
|
|
- case "avc1":
|
|
|
- video.codec = "avc1.42e01e";
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- this.log(`Init video buffer, container:${video.container}, codecs[level/parsed]=[${currentLevel.videoCodec || ""}/${parsedVideoCodec}]${video.codec !== parsedVideoCodec ? " parsed-corrected=" + video.codec : ""}${video.supplemental ? " supplemental=" + video.supplemental : ""}`);
|
|
|
- delete tracks.audiovideo;
|
|
|
- }
|
|
|
- if (audiovideo) {
|
|
|
- this.log(`Init audiovideo buffer, container:${audiovideo.container}, codecs[level/parsed]=[${currentLevel.codecs}/${audiovideo.codec}]`);
|
|
|
- delete tracks.video;
|
|
|
- delete tracks.audio;
|
|
|
- }
|
|
|
- const trackTypes = Object.keys(tracks);
|
|
|
- if (trackTypes.length) {
|
|
|
- this.hls.trigger(Events.BUFFER_CODECS, tracks);
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- trackTypes.forEach((trackName) => {
|
|
|
- const track = tracks[trackName];
|
|
|
- const initSegment = track.initSegment;
|
|
|
- if (initSegment != null && initSegment.byteLength) {
|
|
|
- this.hls.trigger(Events.BUFFER_APPENDING, {
|
|
|
- type: trackName,
|
|
|
- data: initSegment,
|
|
|
- frag,
|
|
|
- part: null,
|
|
|
- chunkMeta,
|
|
|
- parent: frag.type
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- this.tickImmediate();
|
|
|
- }
|
|
|
- getMainFwdBufferInfo() {
|
|
|
- const bufferOutput = this.mediaBuffer && this.altAudio === 2 ? this.mediaBuffer : this.media;
|
|
|
- return this.getFwdBufferInfo(bufferOutput, PlaylistLevelType.MAIN);
|
|
|
- }
|
|
|
- get maxBufferLength() {
|
|
|
- const {
|
|
|
- levels,
|
|
|
- level
|
|
|
- } = this;
|
|
|
- const levelInfo = levels == null ? void 0 : levels[level];
|
|
|
- if (!levelInfo) {
|
|
|
- return this.config.maxBufferLength;
|
|
|
- }
|
|
|
- return this.getMaxBufferLength(levelInfo.maxBitrate);
|
|
|
- }
|
|
|
- backtrack(frag) {
|
|
|
- this.couldBacktrack = true;
|
|
|
- this.backtrackFragment = frag;
|
|
|
- this.resetTransmuxer();
|
|
|
- this.flushBufferGap(frag);
|
|
|
- this.fragmentTracker.removeFragment(frag);
|
|
|
- this.fragPrevious = null;
|
|
|
- this.nextLoadPosition = frag.start;
|
|
|
- this.state = State.IDLE;
|
|
|
- }
|
|
|
- checkFragmentChanged() {
|
|
|
- const video = this.media;
|
|
|
- let fragPlayingCurrent = null;
|
|
|
- if (video && video.readyState > 1 && video.seeking === false) {
|
|
|
- const currentTime = video.currentTime;
|
|
|
- if (BufferHelper.isBuffered(video, currentTime)) {
|
|
|
- fragPlayingCurrent = this.getAppendedFrag(currentTime);
|
|
|
- } else if (BufferHelper.isBuffered(video, currentTime + 0.1)) {
|
|
|
- fragPlayingCurrent = this.getAppendedFrag(currentTime + 0.1);
|
|
|
- }
|
|
|
- if (fragPlayingCurrent) {
|
|
|
- this.backtrackFragment = null;
|
|
|
- const fragPlaying = this.fragPlaying;
|
|
|
- const fragCurrentLevel = fragPlayingCurrent.level;
|
|
|
- if (!fragPlaying || fragPlayingCurrent.sn !== fragPlaying.sn || fragPlaying.level !== fragCurrentLevel) {
|
|
|
- this.fragPlaying = fragPlayingCurrent;
|
|
|
- this.hls.trigger(Events.FRAG_CHANGED, {
|
|
|
- frag: fragPlayingCurrent
|
|
|
- });
|
|
|
- if (!fragPlaying || fragPlaying.level !== fragCurrentLevel) {
|
|
|
- this.hls.trigger(Events.LEVEL_SWITCHED, {
|
|
|
- level: fragCurrentLevel
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- get nextLevel() {
|
|
|
- const frag = this.nextBufferedFrag;
|
|
|
- if (frag) {
|
|
|
- return frag.level;
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- get currentFrag() {
|
|
|
- var _this$media2;
|
|
|
- if (this.fragPlaying) {
|
|
|
- return this.fragPlaying;
|
|
|
- }
|
|
|
- const currentTime = ((_this$media2 = this.media) == null ? void 0 : _this$media2.currentTime) || this.lastCurrentTime;
|
|
|
- if (isFiniteNumber(currentTime)) {
|
|
|
- return this.getAppendedFrag(currentTime);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- get currentProgramDateTime() {
|
|
|
- var _this$media3;
|
|
|
- const currentTime = ((_this$media3 = this.media) == null ? void 0 : _this$media3.currentTime) || this.lastCurrentTime;
|
|
|
- if (isFiniteNumber(currentTime)) {
|
|
|
- const details = this.getLevelDetails();
|
|
|
- const frag = this.currentFrag || (details ? findFragmentByPTS(null, details.fragments, currentTime) : null);
|
|
|
- if (frag) {
|
|
|
- const programDateTime = frag.programDateTime;
|
|
|
- if (programDateTime !== null) {
|
|
|
- const epocMs = programDateTime + (currentTime - frag.start) * 1e3;
|
|
|
- return new Date(epocMs);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- get currentLevel() {
|
|
|
- const frag = this.currentFrag;
|
|
|
- if (frag) {
|
|
|
- return frag.level;
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- get nextBufferedFrag() {
|
|
|
- const frag = this.currentFrag;
|
|
|
- if (frag) {
|
|
|
- return this.followingBufferedFrag(frag);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- get forceStartLoad() {
|
|
|
- return this._forceStartLoad;
|
|
|
- }
|
|
|
-};
|
|
|
-var KeyLoader = class extends Logger {
|
|
|
- constructor(config, logger2) {
|
|
|
- super("key-loader", logger2);
|
|
|
- this.config = void 0;
|
|
|
- this.keyIdToKeyInfo = {};
|
|
|
- this.emeController = null;
|
|
|
- this.config = config;
|
|
|
- }
|
|
|
- abort(type) {
|
|
|
- for (const id in this.keyIdToKeyInfo) {
|
|
|
- const loader = this.keyIdToKeyInfo[id].loader;
|
|
|
- if (loader) {
|
|
|
- var _loader$context;
|
|
|
- if (type && type !== ((_loader$context = loader.context) == null ? void 0 : _loader$context.frag.type)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- loader.abort();
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- detach() {
|
|
|
- for (const id in this.keyIdToKeyInfo) {
|
|
|
- const keyInfo = this.keyIdToKeyInfo[id];
|
|
|
- if (keyInfo.mediaKeySessionContext || keyInfo.decryptdata.isCommonEncryption) {
|
|
|
- delete this.keyIdToKeyInfo[id];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.detach();
|
|
|
- for (const id in this.keyIdToKeyInfo) {
|
|
|
- const loader = this.keyIdToKeyInfo[id].loader;
|
|
|
- if (loader) {
|
|
|
- loader.destroy();
|
|
|
- }
|
|
|
- }
|
|
|
- this.keyIdToKeyInfo = {};
|
|
|
- }
|
|
|
- createKeyLoadError(frag, details = ErrorDetails.KEY_LOAD_ERROR, error, networkDetails, response) {
|
|
|
- return new LoadError({
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details,
|
|
|
- fatal: false,
|
|
|
- frag,
|
|
|
- response,
|
|
|
- error,
|
|
|
- networkDetails
|
|
|
- });
|
|
|
- }
|
|
|
- loadClear(loadingFrag, encryptedFragments, startFragRequested) {
|
|
|
- if (this.emeController && this.config.emeEnabled && !this.emeController.getSelectedKeySystemFormats().length) {
|
|
|
- if (encryptedFragments.length) {
|
|
|
- for (let i = 0, l = encryptedFragments.length; i < l; i++) {
|
|
|
- const frag = encryptedFragments[i];
|
|
|
- if (loadingFrag.cc <= frag.cc && (!isMediaFragment(loadingFrag) || !isMediaFragment(frag) || loadingFrag.sn < frag.sn) || !startFragRequested && i == l - 1) {
|
|
|
- return this.emeController.selectKeySystemFormat(frag).then((keySystemFormat) => {
|
|
|
- if (!this.emeController) {
|
|
|
- return;
|
|
|
- }
|
|
|
- frag.setKeyFormat(keySystemFormat);
|
|
|
- const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
|
|
|
- if (keySystem) {
|
|
|
- return this.emeController.getKeySystemAccess([keySystem]);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (this.config.requireKeySystemAccessOnStart) {
|
|
|
- const keySystemsInConfig = getKeySystemsForConfig(this.config);
|
|
|
- if (keySystemsInConfig.length) {
|
|
|
- return this.emeController.getKeySystemAccess(keySystemsInConfig);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- load(frag) {
|
|
|
- if (!frag.decryptdata && frag.encrypted && this.emeController && this.config.emeEnabled) {
|
|
|
- return this.emeController.selectKeySystemFormat(frag).then((keySystemFormat) => {
|
|
|
- return this.loadInternal(frag, keySystemFormat);
|
|
|
- });
|
|
|
- }
|
|
|
- return this.loadInternal(frag);
|
|
|
- }
|
|
|
- loadInternal(frag, keySystemFormat) {
|
|
|
- var _keyInfo, _keyInfo2;
|
|
|
- if (keySystemFormat) {
|
|
|
- frag.setKeyFormat(keySystemFormat);
|
|
|
- }
|
|
|
- const decryptdata = frag.decryptdata;
|
|
|
- if (!decryptdata) {
|
|
|
- const error = new Error(keySystemFormat ? `Expected frag.decryptdata to be defined after setting format ${keySystemFormat}` : `Missing decryption data on fragment in onKeyLoading (emeEnabled with controller: ${this.emeController && this.config.emeEnabled})`);
|
|
|
- return Promise.reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_ERROR, error));
|
|
|
- }
|
|
|
- const uri = decryptdata.uri;
|
|
|
- if (!uri) {
|
|
|
- return Promise.reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_ERROR, new Error(`Invalid key URI: "${uri}"`)));
|
|
|
- }
|
|
|
- const id = getKeyId(decryptdata);
|
|
|
- let keyInfo = this.keyIdToKeyInfo[id];
|
|
|
- if ((_keyInfo = keyInfo) != null && _keyInfo.decryptdata.key) {
|
|
|
- decryptdata.key = keyInfo.decryptdata.key;
|
|
|
- return Promise.resolve({
|
|
|
- frag,
|
|
|
- keyInfo
|
|
|
- });
|
|
|
- }
|
|
|
- if (this.emeController && (_keyInfo2 = keyInfo) != null && _keyInfo2.keyLoadPromise) {
|
|
|
- const keyStatus = this.emeController.getKeyStatus(keyInfo.decryptdata);
|
|
|
- switch (keyStatus) {
|
|
|
- case "usable":
|
|
|
- case "usable-in-future":
|
|
|
- return keyInfo.keyLoadPromise.then((keyLoadedData) => {
|
|
|
- const {
|
|
|
- keyInfo: keyInfo2
|
|
|
- } = keyLoadedData;
|
|
|
- decryptdata.key = keyInfo2.decryptdata.key;
|
|
|
- return {
|
|
|
- frag,
|
|
|
- keyInfo: keyInfo2
|
|
|
- };
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- this.log(`${this.keyIdToKeyInfo[id] ? "Rel" : "L"}oading${decryptdata.keyId ? " keyId: " + arrayToHex(decryptdata.keyId) : ""} URI: ${decryptdata.uri} from ${frag.type} ${frag.level}`);
|
|
|
- keyInfo = this.keyIdToKeyInfo[id] = {
|
|
|
- decryptdata,
|
|
|
- keyLoadPromise: null,
|
|
|
- loader: null,
|
|
|
- mediaKeySessionContext: null
|
|
|
- };
|
|
|
- switch (decryptdata.method) {
|
|
|
- case "SAMPLE-AES":
|
|
|
- case "SAMPLE-AES-CENC":
|
|
|
- case "SAMPLE-AES-CTR":
|
|
|
- if (decryptdata.keyFormat === "identity") {
|
|
|
- return this.loadKeyHTTP(keyInfo, frag);
|
|
|
- }
|
|
|
- return this.loadKeyEME(keyInfo, frag);
|
|
|
- case "AES-128":
|
|
|
- case "AES-256":
|
|
|
- case "AES-256-CTR":
|
|
|
- return this.loadKeyHTTP(keyInfo, frag);
|
|
|
- default:
|
|
|
- return Promise.reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_ERROR, new Error(`Key supplied with unsupported METHOD: "${decryptdata.method}"`)));
|
|
|
- }
|
|
|
- }
|
|
|
- loadKeyEME(keyInfo, frag) {
|
|
|
- const keyLoadedData = {
|
|
|
- frag,
|
|
|
- keyInfo
|
|
|
- };
|
|
|
- if (this.emeController && this.config.emeEnabled) {
|
|
|
- var _frag$initSegment;
|
|
|
- if (!keyInfo.decryptdata.keyId && (_frag$initSegment = frag.initSegment) != null && _frag$initSegment.data) {
|
|
|
- const keyIds = parseKeyIdsFromTenc(frag.initSegment.data);
|
|
|
- if (keyIds.length) {
|
|
|
- const keyId = keyIds[0];
|
|
|
- if (keyId.some((b) => b !== 0)) {
|
|
|
- this.log(`Using keyId found in init segment ${arrayToHex(keyId)}`);
|
|
|
- keyInfo.decryptdata.keyId = keyId;
|
|
|
- LevelKey.setKeyIdForUri(keyInfo.decryptdata.uri, keyId);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const keySessionContextPromise = this.emeController.loadKey(keyLoadedData);
|
|
|
- return (keyInfo.keyLoadPromise = keySessionContextPromise.then((keySessionContext) => {
|
|
|
- keyInfo.mediaKeySessionContext = keySessionContext;
|
|
|
- return keyLoadedData;
|
|
|
- })).catch((error) => {
|
|
|
- keyInfo.keyLoadPromise = null;
|
|
|
- if ("data" in error) {
|
|
|
- error.data.frag = frag;
|
|
|
- }
|
|
|
- throw error;
|
|
|
- });
|
|
|
- }
|
|
|
- return Promise.resolve(keyLoadedData);
|
|
|
- }
|
|
|
- loadKeyHTTP(keyInfo, frag) {
|
|
|
- const config = this.config;
|
|
|
- const Loader = config.loader;
|
|
|
- const keyLoader = new Loader(config);
|
|
|
- frag.keyLoader = keyInfo.loader = keyLoader;
|
|
|
- return keyInfo.keyLoadPromise = new Promise((resolve, reject) => {
|
|
|
- const loaderContext = {
|
|
|
- keyInfo,
|
|
|
- frag,
|
|
|
- responseType: "arraybuffer",
|
|
|
- url: keyInfo.decryptdata.uri
|
|
|
- };
|
|
|
- const loadPolicy = config.keyLoadPolicy.default;
|
|
|
- const loaderConfig = {
|
|
|
- loadPolicy,
|
|
|
- timeout: loadPolicy.maxLoadTimeMs,
|
|
|
- maxRetry: 0,
|
|
|
- retryDelay: 0,
|
|
|
- maxRetryDelay: 0
|
|
|
- };
|
|
|
- const loaderCallbacks = {
|
|
|
- onSuccess: (response, stats, context, networkDetails) => {
|
|
|
- const {
|
|
|
- frag: frag2,
|
|
|
- keyInfo: keyInfo2
|
|
|
- } = context;
|
|
|
- const id = getKeyId(keyInfo2.decryptdata);
|
|
|
- if (!frag2.decryptdata || keyInfo2 !== this.keyIdToKeyInfo[id]) {
|
|
|
- return reject(this.createKeyLoadError(frag2, ErrorDetails.KEY_LOAD_ERROR, new Error("after key load, decryptdata unset or changed"), networkDetails));
|
|
|
- }
|
|
|
- keyInfo2.decryptdata.key = frag2.decryptdata.key = new Uint8Array(response.data);
|
|
|
- frag2.keyLoader = null;
|
|
|
- keyInfo2.loader = null;
|
|
|
- resolve({
|
|
|
- frag: frag2,
|
|
|
- keyInfo: keyInfo2
|
|
|
- });
|
|
|
- },
|
|
|
- onError: (response, context, networkDetails, stats) => {
|
|
|
- this.resetLoader(context);
|
|
|
- reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_ERROR, new Error(`HTTP Error ${response.code} loading key ${response.text}`), networkDetails, _objectSpread2({
|
|
|
- url: loaderContext.url,
|
|
|
- data: void 0
|
|
|
- }, response)));
|
|
|
- },
|
|
|
- onTimeout: (stats, context, networkDetails) => {
|
|
|
- this.resetLoader(context);
|
|
|
- reject(this.createKeyLoadError(frag, ErrorDetails.KEY_LOAD_TIMEOUT, new Error("key loading timed out"), networkDetails));
|
|
|
- },
|
|
|
- onAbort: (stats, context, networkDetails) => {
|
|
|
- this.resetLoader(context);
|
|
|
- reject(this.createKeyLoadError(frag, ErrorDetails.INTERNAL_ABORTED, new Error("key loading aborted"), networkDetails));
|
|
|
- }
|
|
|
- };
|
|
|
- keyLoader.load(loaderContext, loaderConfig, loaderCallbacks);
|
|
|
- });
|
|
|
- }
|
|
|
- resetLoader(context) {
|
|
|
- const {
|
|
|
- frag,
|
|
|
- keyInfo,
|
|
|
- url: uri
|
|
|
- } = context;
|
|
|
- const loader = keyInfo.loader;
|
|
|
- if (frag.keyLoader === loader) {
|
|
|
- frag.keyLoader = null;
|
|
|
- keyInfo.loader = null;
|
|
|
- }
|
|
|
- const id = getKeyId(keyInfo.decryptdata) || uri;
|
|
|
- delete this.keyIdToKeyInfo[id];
|
|
|
- if (loader) {
|
|
|
- loader.destroy();
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-function getKeyId(decryptdata) {
|
|
|
- if (decryptdata.keyFormat !== KeySystemFormats.FAIRPLAY) {
|
|
|
- const keyId = decryptdata.keyId;
|
|
|
- if (keyId) {
|
|
|
- return arrayToHex(keyId);
|
|
|
- }
|
|
|
- }
|
|
|
- return decryptdata.uri;
|
|
|
-}
|
|
|
-function mapContextToLevelType(context) {
|
|
|
- const {
|
|
|
- type
|
|
|
- } = context;
|
|
|
- switch (type) {
|
|
|
- case PlaylistContextType.AUDIO_TRACK:
|
|
|
- return PlaylistLevelType.AUDIO;
|
|
|
- case PlaylistContextType.SUBTITLE_TRACK:
|
|
|
- return PlaylistLevelType.SUBTITLE;
|
|
|
- default:
|
|
|
- return PlaylistLevelType.MAIN;
|
|
|
- }
|
|
|
-}
|
|
|
-function getResponseUrl(response, context) {
|
|
|
- let url = response.url;
|
|
|
- if (url === void 0 || url.indexOf("data:") === 0) {
|
|
|
- url = context.url;
|
|
|
- }
|
|
|
- return url;
|
|
|
-}
|
|
|
-var PlaylistLoader = class {
|
|
|
- constructor(hls) {
|
|
|
- this.hls = void 0;
|
|
|
- this.loaders = /* @__PURE__ */ Object.create(null);
|
|
|
- this.variableList = null;
|
|
|
- this.onManifestLoaded = this.checkAutostartLoad;
|
|
|
- this.hls = hls;
|
|
|
- this.registerListeners();
|
|
|
- }
|
|
|
- startLoad(startPosition) {
|
|
|
- }
|
|
|
- stopLoad() {
|
|
|
- this.destroyInternalLoaders();
|
|
|
- }
|
|
|
- registerListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.on(Events.LEVEL_LOADING, this.onLevelLoading, this);
|
|
|
- hls.on(Events.AUDIO_TRACK_LOADING, this.onAudioTrackLoading, this);
|
|
|
- hls.on(Events.SUBTITLE_TRACK_LOADING, this.onSubtitleTrackLoading, this);
|
|
|
- hls.on(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- }
|
|
|
- unregisterListeners() {
|
|
|
- const {
|
|
|
- hls
|
|
|
- } = this;
|
|
|
- hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
|
|
|
- hls.off(Events.LEVEL_LOADING, this.onLevelLoading, this);
|
|
|
- hls.off(Events.AUDIO_TRACK_LOADING, this.onAudioTrackLoading, this);
|
|
|
- hls.off(Events.SUBTITLE_TRACK_LOADING, this.onSubtitleTrackLoading, this);
|
|
|
- hls.off(Events.LEVELS_UPDATED, this.onLevelsUpdated, this);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Returns defaults or configured loader-type overloads (pLoader and loader config params)
|
|
|
- */
|
|
|
- createInternalLoader(context) {
|
|
|
- const config = this.hls.config;
|
|
|
- const PLoader = config.pLoader;
|
|
|
- const Loader = config.loader;
|
|
|
- const InternalLoader = PLoader || Loader;
|
|
|
- const loader = new InternalLoader(config);
|
|
|
- this.loaders[context.type] = loader;
|
|
|
- return loader;
|
|
|
- }
|
|
|
- getInternalLoader(context) {
|
|
|
- return this.loaders[context.type];
|
|
|
- }
|
|
|
- resetInternalLoader(contextType) {
|
|
|
- if (this.loaders[contextType]) {
|
|
|
- delete this.loaders[contextType];
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Call `destroy` on all internal loader instances mapped (one per context type)
|
|
|
- */
|
|
|
- destroyInternalLoaders() {
|
|
|
- for (const contextType in this.loaders) {
|
|
|
- const loader = this.loaders[contextType];
|
|
|
- if (loader) {
|
|
|
- loader.destroy();
|
|
|
- }
|
|
|
- this.resetInternalLoader(contextType);
|
|
|
- }
|
|
|
- }
|
|
|
- destroy() {
|
|
|
- this.variableList = null;
|
|
|
- this.unregisterListeners();
|
|
|
- this.destroyInternalLoaders();
|
|
|
- }
|
|
|
- onManifestLoading(event, data) {
|
|
|
- const {
|
|
|
- url
|
|
|
- } = data;
|
|
|
- this.variableList = null;
|
|
|
- this.load({
|
|
|
- id: null,
|
|
|
- level: 0,
|
|
|
- responseType: "text",
|
|
|
- type: PlaylistContextType.MANIFEST,
|
|
|
- url,
|
|
|
- deliveryDirectives: null,
|
|
|
- levelOrTrack: null
|
|
|
- });
|
|
|
- }
|
|
|
- onLevelLoading(event, data) {
|
|
|
- const {
|
|
|
- id,
|
|
|
- level,
|
|
|
- pathwayId,
|
|
|
- url,
|
|
|
- deliveryDirectives,
|
|
|
- levelInfo
|
|
|
- } = data;
|
|
|
- this.load({
|
|
|
- id,
|
|
|
- level,
|
|
|
- pathwayId,
|
|
|
- responseType: "text",
|
|
|
- type: PlaylistContextType.LEVEL,
|
|
|
- url,
|
|
|
- deliveryDirectives,
|
|
|
- levelOrTrack: levelInfo
|
|
|
- });
|
|
|
- }
|
|
|
- onAudioTrackLoading(event, data) {
|
|
|
- const {
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- url,
|
|
|
- deliveryDirectives,
|
|
|
- track
|
|
|
- } = data;
|
|
|
- this.load({
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- level: null,
|
|
|
- responseType: "text",
|
|
|
- type: PlaylistContextType.AUDIO_TRACK,
|
|
|
- url,
|
|
|
- deliveryDirectives,
|
|
|
- levelOrTrack: track
|
|
|
- });
|
|
|
- }
|
|
|
- onSubtitleTrackLoading(event, data) {
|
|
|
- const {
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- url,
|
|
|
- deliveryDirectives,
|
|
|
- track
|
|
|
- } = data;
|
|
|
- this.load({
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- level: null,
|
|
|
- responseType: "text",
|
|
|
- type: PlaylistContextType.SUBTITLE_TRACK,
|
|
|
- url,
|
|
|
- deliveryDirectives,
|
|
|
- levelOrTrack: track
|
|
|
- });
|
|
|
- }
|
|
|
- onLevelsUpdated(event, data) {
|
|
|
- const loader = this.loaders[PlaylistContextType.LEVEL];
|
|
|
- if (loader) {
|
|
|
- const context = loader.context;
|
|
|
- if (context && !data.levels.some((lvl) => lvl === context.levelOrTrack)) {
|
|
|
- loader.abort();
|
|
|
- delete this.loaders[PlaylistContextType.LEVEL];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- load(context) {
|
|
|
- var _context$deliveryDire;
|
|
|
- const config = this.hls.config;
|
|
|
- let loader = this.getInternalLoader(context);
|
|
|
- if (loader) {
|
|
|
- const logger2 = this.hls.logger;
|
|
|
- const loaderContext = loader.context;
|
|
|
- if (loaderContext && loaderContext.levelOrTrack === context.levelOrTrack && (loaderContext.url === context.url || loaderContext.deliveryDirectives && !context.deliveryDirectives)) {
|
|
|
- if (loaderContext.url === context.url) {
|
|
|
- logger2.log(`[playlist-loader]: ignore ${context.url} ongoing request`);
|
|
|
- } else {
|
|
|
- logger2.log(`[playlist-loader]: ignore ${context.url} in favor of ${loaderContext.url}`);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- logger2.log(`[playlist-loader]: aborting previous loader for type: ${context.type}`);
|
|
|
- loader.abort();
|
|
|
- }
|
|
|
- let loadPolicy;
|
|
|
- if (context.type === PlaylistContextType.MANIFEST) {
|
|
|
- loadPolicy = config.manifestLoadPolicy.default;
|
|
|
- } else {
|
|
|
- loadPolicy = _extends({}, config.playlistLoadPolicy.default, {
|
|
|
- timeoutRetry: null,
|
|
|
- errorRetry: null
|
|
|
- });
|
|
|
- }
|
|
|
- loader = this.createInternalLoader(context);
|
|
|
- if (isFiniteNumber((_context$deliveryDire = context.deliveryDirectives) == null ? void 0 : _context$deliveryDire.part)) {
|
|
|
- let levelDetails;
|
|
|
- if (context.type === PlaylistContextType.LEVEL && context.level !== null) {
|
|
|
- levelDetails = this.hls.levels[context.level].details;
|
|
|
- } else if (context.type === PlaylistContextType.AUDIO_TRACK && context.id !== null) {
|
|
|
- levelDetails = this.hls.audioTracks[context.id].details;
|
|
|
- } else if (context.type === PlaylistContextType.SUBTITLE_TRACK && context.id !== null) {
|
|
|
- levelDetails = this.hls.subtitleTracks[context.id].details;
|
|
|
- }
|
|
|
- if (levelDetails) {
|
|
|
- const partTarget = levelDetails.partTarget;
|
|
|
- const targetDuration = levelDetails.targetduration;
|
|
|
- if (partTarget && targetDuration) {
|
|
|
- const maxLowLatencyPlaylistRefresh = Math.max(partTarget * 3, targetDuration * 0.8) * 1e3;
|
|
|
- loadPolicy = _extends({}, loadPolicy, {
|
|
|
- maxTimeToFirstByteMs: Math.min(maxLowLatencyPlaylistRefresh, loadPolicy.maxTimeToFirstByteMs),
|
|
|
- maxLoadTimeMs: Math.min(maxLowLatencyPlaylistRefresh, loadPolicy.maxTimeToFirstByteMs)
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- const legacyRetryCompatibility = loadPolicy.errorRetry || loadPolicy.timeoutRetry || {};
|
|
|
- const loaderConfig = {
|
|
|
- loadPolicy,
|
|
|
- timeout: loadPolicy.maxLoadTimeMs,
|
|
|
- maxRetry: legacyRetryCompatibility.maxNumRetry || 0,
|
|
|
- retryDelay: legacyRetryCompatibility.retryDelayMs || 0,
|
|
|
- maxRetryDelay: legacyRetryCompatibility.maxRetryDelayMs || 0
|
|
|
- };
|
|
|
- const loaderCallbacks = {
|
|
|
- onSuccess: (response, stats, context2, networkDetails) => {
|
|
|
- const loader2 = this.getInternalLoader(context2);
|
|
|
- this.resetInternalLoader(context2.type);
|
|
|
- const string = response.data;
|
|
|
- stats.parsing.start = performance.now();
|
|
|
- if (M3U8Parser.isMediaPlaylist(string) || context2.type !== PlaylistContextType.MANIFEST) {
|
|
|
- this.handleTrackOrLevelPlaylist(response, stats, context2, networkDetails || null, loader2);
|
|
|
- } else {
|
|
|
- this.handleMasterPlaylist(response, stats, context2, networkDetails);
|
|
|
- }
|
|
|
- },
|
|
|
- onError: (response, context2, networkDetails, stats) => {
|
|
|
- this.handleNetworkError(context2, networkDetails, false, response, stats);
|
|
|
- },
|
|
|
- onTimeout: (stats, context2, networkDetails) => {
|
|
|
- this.handleNetworkError(context2, networkDetails, true, void 0, stats);
|
|
|
- }
|
|
|
- };
|
|
|
- loader.load(context, loaderConfig, loaderCallbacks);
|
|
|
- }
|
|
|
- checkAutostartLoad() {
|
|
|
- if (!this.hls) {
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- config: {
|
|
|
- autoStartLoad,
|
|
|
- startPosition
|
|
|
- },
|
|
|
- forceStartLoad
|
|
|
- } = this.hls;
|
|
|
- if (autoStartLoad || forceStartLoad) {
|
|
|
- this.hls.logger.log(`${autoStartLoad ? "auto" : "force"} startLoad with configured startPosition ${startPosition}`);
|
|
|
- this.hls.startLoad(startPosition);
|
|
|
- }
|
|
|
- }
|
|
|
- handleMasterPlaylist(response, stats, context, networkDetails) {
|
|
|
- const hls = this.hls;
|
|
|
- const string = response.data;
|
|
|
- const url = getResponseUrl(response, context);
|
|
|
- const parsedResult = M3U8Parser.parseMasterPlaylist(string, url);
|
|
|
- if (parsedResult.playlistParsingError) {
|
|
|
- stats.parsing.end = performance.now();
|
|
|
- this.handleManifestParsingError(response, context, parsedResult.playlistParsingError, networkDetails, stats);
|
|
|
- return;
|
|
|
- }
|
|
|
- const {
|
|
|
- contentSteering,
|
|
|
- levels,
|
|
|
- sessionData,
|
|
|
- sessionKeys,
|
|
|
- startTimeOffset,
|
|
|
- variableList
|
|
|
- } = parsedResult;
|
|
|
- this.variableList = variableList;
|
|
|
- levels.forEach((levelParsed) => {
|
|
|
- const {
|
|
|
- unknownCodecs
|
|
|
- } = levelParsed;
|
|
|
- if (unknownCodecs) {
|
|
|
- const {
|
|
|
- preferManagedMediaSource
|
|
|
- } = this.hls.config;
|
|
|
- let {
|
|
|
- audioCodec,
|
|
|
- videoCodec
|
|
|
- } = levelParsed;
|
|
|
- for (let i = unknownCodecs.length; i--; ) {
|
|
|
- const unknownCodec = unknownCodecs[i];
|
|
|
- if (areCodecsMediaSourceSupported(unknownCodec, "audio", preferManagedMediaSource)) {
|
|
|
- levelParsed.audioCodec = audioCodec = audioCodec ? `${audioCodec},${unknownCodec}` : unknownCodec;
|
|
|
- sampleEntryCodesISO.audio[audioCodec.substring(0, 4)] = 2;
|
|
|
- unknownCodecs.splice(i, 1);
|
|
|
- } else if (areCodecsMediaSourceSupported(unknownCodec, "video", preferManagedMediaSource)) {
|
|
|
- levelParsed.videoCodec = videoCodec = videoCodec ? `${videoCodec},${unknownCodec}` : unknownCodec;
|
|
|
- sampleEntryCodesISO.video[videoCodec.substring(0, 4)] = 2;
|
|
|
- unknownCodecs.splice(i, 1);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- const {
|
|
|
- AUDIO: audioTracks = [],
|
|
|
- SUBTITLES: subtitles,
|
|
|
- "CLOSED-CAPTIONS": captions
|
|
|
- } = M3U8Parser.parseMasterPlaylistMedia(string, url, parsedResult);
|
|
|
- if (audioTracks.length) {
|
|
|
- const embeddedAudioFound = audioTracks.some((audioTrack) => !audioTrack.url);
|
|
|
- if (!embeddedAudioFound && levels[0].audioCodec && !levels[0].attrs.AUDIO) {
|
|
|
- this.hls.logger.log("[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one");
|
|
|
- audioTracks.unshift({
|
|
|
- type: "main",
|
|
|
- name: "main",
|
|
|
- groupId: "main",
|
|
|
- default: false,
|
|
|
- autoselect: false,
|
|
|
- forced: false,
|
|
|
- id: -1,
|
|
|
- attrs: new AttrList({}),
|
|
|
- bitrate: 0,
|
|
|
- url: ""
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- hls.trigger(Events.MANIFEST_LOADED, {
|
|
|
- levels,
|
|
|
- audioTracks,
|
|
|
- subtitles,
|
|
|
- captions,
|
|
|
- contentSteering,
|
|
|
- url,
|
|
|
- stats,
|
|
|
- networkDetails,
|
|
|
- sessionData,
|
|
|
- sessionKeys,
|
|
|
- startTimeOffset,
|
|
|
- variableList
|
|
|
- });
|
|
|
- }
|
|
|
- handleTrackOrLevelPlaylist(response, stats, context, networkDetails, loader) {
|
|
|
- const hls = this.hls;
|
|
|
- const {
|
|
|
- id,
|
|
|
- level,
|
|
|
- type
|
|
|
- } = context;
|
|
|
- const url = getResponseUrl(response, context);
|
|
|
- const levelId = isFiniteNumber(level) ? level : isFiniteNumber(id) ? id : 0;
|
|
|
- const levelType = mapContextToLevelType(context);
|
|
|
- const levelDetails = M3U8Parser.parseLevelPlaylist(response.data, url, levelId, levelType, 0, this.variableList);
|
|
|
- if (type === PlaylistContextType.MANIFEST) {
|
|
|
- const singleLevel = {
|
|
|
- attrs: new AttrList({}),
|
|
|
- bitrate: 0,
|
|
|
- details: levelDetails,
|
|
|
- name: "",
|
|
|
- url
|
|
|
- };
|
|
|
- levelDetails.requestScheduled = stats.loading.start + computeReloadInterval(levelDetails, 0);
|
|
|
- hls.trigger(Events.MANIFEST_LOADED, {
|
|
|
- levels: [singleLevel],
|
|
|
- audioTracks: [],
|
|
|
- url,
|
|
|
- stats,
|
|
|
- networkDetails,
|
|
|
- sessionData: null,
|
|
|
- sessionKeys: null,
|
|
|
- contentSteering: null,
|
|
|
- startTimeOffset: null,
|
|
|
- variableList: null
|
|
|
- });
|
|
|
- }
|
|
|
- stats.parsing.end = performance.now();
|
|
|
- context.levelDetails = levelDetails;
|
|
|
- this.handlePlaylistLoaded(levelDetails, response, stats, context, networkDetails, loader);
|
|
|
- }
|
|
|
- handleManifestParsingError(response, context, error, networkDetails, stats) {
|
|
|
- this.hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.MANIFEST_PARSING_ERROR,
|
|
|
- fatal: context.type === PlaylistContextType.MANIFEST,
|
|
|
- url: response.url,
|
|
|
- err: error,
|
|
|
- error,
|
|
|
- reason: error.message,
|
|
|
- response,
|
|
|
- context,
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- });
|
|
|
- }
|
|
|
- handleNetworkError(context, networkDetails, timeout = false, response, stats) {
|
|
|
- let message = `A network ${timeout ? "timeout" : "error" + (response ? " (status " + response.code + ")" : "")} occurred while loading ${context.type}`;
|
|
|
- if (context.type === PlaylistContextType.LEVEL) {
|
|
|
- message += `: ${context.level} id: ${context.id}`;
|
|
|
- } else if (context.type === PlaylistContextType.AUDIO_TRACK || context.type === PlaylistContextType.SUBTITLE_TRACK) {
|
|
|
- message += ` id: ${context.id} group-id: "${context.groupId}"`;
|
|
|
- }
|
|
|
- const error = new Error(message);
|
|
|
- this.hls.logger.warn(`[playlist-loader]: ${message}`);
|
|
|
- let details = ErrorDetails.UNKNOWN;
|
|
|
- let fatal = false;
|
|
|
- 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;
|
|
|
- case PlaylistContextType.SUBTITLE_TRACK:
|
|
|
- details = timeout ? ErrorDetails.SUBTITLE_TRACK_LOAD_TIMEOUT : ErrorDetails.SUBTITLE_LOAD_ERROR;
|
|
|
- fatal = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- if (loader) {
|
|
|
- this.resetInternalLoader(context.type);
|
|
|
- }
|
|
|
- const errorData = {
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details,
|
|
|
- fatal,
|
|
|
- url: context.url,
|
|
|
- loader,
|
|
|
- context,
|
|
|
- error,
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- };
|
|
|
- if (response) {
|
|
|
- const url = (networkDetails == null ? void 0 : networkDetails.url) || context.url;
|
|
|
- errorData.response = _objectSpread2({
|
|
|
- url,
|
|
|
- data: void 0
|
|
|
- }, response);
|
|
|
- }
|
|
|
- this.hls.trigger(Events.ERROR, errorData);
|
|
|
- }
|
|
|
- handlePlaylistLoaded(levelDetails, response, stats, context, networkDetails, loader) {
|
|
|
- const hls = this.hls;
|
|
|
- const {
|
|
|
- type,
|
|
|
- level,
|
|
|
- levelOrTrack,
|
|
|
- id,
|
|
|
- groupId,
|
|
|
- deliveryDirectives
|
|
|
- } = context;
|
|
|
- const url = getResponseUrl(response, context);
|
|
|
- const parent = mapContextToLevelType(context);
|
|
|
- let levelIndex = typeof context.level === "number" && parent === PlaylistLevelType.MAIN ? level : void 0;
|
|
|
- const error = levelDetails.playlistParsingError;
|
|
|
- if (error) {
|
|
|
- this.hls.logger.warn(`${error} ${levelDetails.url}`);
|
|
|
- if (!hls.config.ignorePlaylistParsingErrors) {
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.LEVEL_PARSING_ERROR,
|
|
|
- fatal: false,
|
|
|
- url,
|
|
|
- error,
|
|
|
- reason: error.message,
|
|
|
- response,
|
|
|
- context,
|
|
|
- level: levelIndex,
|
|
|
- parent,
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- levelDetails.playlistParsingError = null;
|
|
|
- }
|
|
|
- if (!levelDetails.fragments.length) {
|
|
|
- const _error = levelDetails.playlistParsingError = new Error("No Segments found in Playlist");
|
|
|
- hls.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.NETWORK_ERROR,
|
|
|
- details: ErrorDetails.LEVEL_EMPTY_ERROR,
|
|
|
- fatal: false,
|
|
|
- url,
|
|
|
- error: _error,
|
|
|
- reason: _error.message,
|
|
|
- response,
|
|
|
- context,
|
|
|
- level: levelIndex,
|
|
|
- parent,
|
|
|
- networkDetails,
|
|
|
- stats
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- if (levelDetails.live && loader) {
|
|
|
- if (loader.getCacheAge) {
|
|
|
- levelDetails.ageHeader = loader.getCacheAge() || 0;
|
|
|
- }
|
|
|
- if (!loader.getCacheAge || isNaN(levelDetails.ageHeader)) {
|
|
|
- levelDetails.ageHeader = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- switch (type) {
|
|
|
- case PlaylistContextType.MANIFEST:
|
|
|
- case PlaylistContextType.LEVEL:
|
|
|
- if (levelIndex) {
|
|
|
- if (!levelOrTrack) {
|
|
|
- levelIndex = 0;
|
|
|
- } else {
|
|
|
- if (levelOrTrack !== hls.levels[levelIndex]) {
|
|
|
- const updatedIndex = hls.levels.indexOf(levelOrTrack);
|
|
|
- if (updatedIndex > -1) {
|
|
|
- levelIndex = updatedIndex;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- hls.trigger(Events.LEVEL_LOADED, {
|
|
|
- details: levelDetails,
|
|
|
- levelInfo: levelOrTrack || hls.levels[0],
|
|
|
- level: levelIndex || 0,
|
|
|
- id: id || 0,
|
|
|
- stats,
|
|
|
- networkDetails,
|
|
|
- deliveryDirectives,
|
|
|
- withoutMultiVariant: type === PlaylistContextType.MANIFEST
|
|
|
- });
|
|
|
- break;
|
|
|
- case PlaylistContextType.AUDIO_TRACK:
|
|
|
- hls.trigger(Events.AUDIO_TRACK_LOADED, {
|
|
|
- details: levelDetails,
|
|
|
- track: levelOrTrack,
|
|
|
- id: id || 0,
|
|
|
- groupId: groupId || "",
|
|
|
- stats,
|
|
|
- networkDetails,
|
|
|
- deliveryDirectives
|
|
|
- });
|
|
|
- break;
|
|
|
- case PlaylistContextType.SUBTITLE_TRACK:
|
|
|
- hls.trigger(Events.SUBTITLE_TRACK_LOADED, {
|
|
|
- details: levelDetails,
|
|
|
- track: levelOrTrack,
|
|
|
- id: id || 0,
|
|
|
- groupId: groupId || "",
|
|
|
- stats,
|
|
|
- networkDetails,
|
|
|
- deliveryDirectives
|
|
|
- });
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-};
|
|
|
-var Hls = class _Hls {
|
|
|
- /**
|
|
|
- * Get the video-dev/hls.js package version.
|
|
|
- */
|
|
|
- static get version() {
|
|
|
- return version;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Check if the required MediaSource Extensions are available.
|
|
|
- */
|
|
|
- static isMSESupported() {
|
|
|
- return isMSESupported();
|
|
|
- }
|
|
|
- /**
|
|
|
- * Check if MediaSource Extensions are available and isTypeSupported checks pass for any baseline codecs.
|
|
|
- */
|
|
|
- static isSupported() {
|
|
|
- return isSupported();
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get the MediaSource global used for MSE playback (ManagedMediaSource, MediaSource, or WebKitMediaSource).
|
|
|
- */
|
|
|
- static getMediaSource() {
|
|
|
- return getMediaSource();
|
|
|
- }
|
|
|
- static get Events() {
|
|
|
- return Events;
|
|
|
- }
|
|
|
- static get MetadataSchema() {
|
|
|
- return MetadataSchema;
|
|
|
- }
|
|
|
- static get ErrorTypes() {
|
|
|
- return ErrorTypes;
|
|
|
- }
|
|
|
- static get ErrorDetails() {
|
|
|
- return ErrorDetails;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get the default configuration applied to new instances.
|
|
|
- */
|
|
|
- static get DefaultConfig() {
|
|
|
- if (!_Hls.defaultConfig) {
|
|
|
- return hlsDefaultConfig;
|
|
|
- }
|
|
|
- return _Hls.defaultConfig;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Replace the default configuration applied to new instances.
|
|
|
- */
|
|
|
- static set DefaultConfig(defaultConfig) {
|
|
|
- _Hls.defaultConfig = defaultConfig;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Creates an instance of an HLS client that can attach to exactly one `HTMLMediaElement`.
|
|
|
- * @param userConfig - Configuration options applied over `Hls.DefaultConfig`
|
|
|
- */
|
|
|
- constructor(userConfig = {}) {
|
|
|
- this.config = void 0;
|
|
|
- this.userConfig = void 0;
|
|
|
- this.logger = void 0;
|
|
|
- this.coreComponents = void 0;
|
|
|
- this.networkControllers = void 0;
|
|
|
- this._emitter = new EventEmitter();
|
|
|
- this._autoLevelCapping = -1;
|
|
|
- this._maxHdcpLevel = null;
|
|
|
- this.abrController = void 0;
|
|
|
- this.bufferController = void 0;
|
|
|
- this.capLevelController = void 0;
|
|
|
- this.latencyController = void 0;
|
|
|
- this.levelController = void 0;
|
|
|
- this.streamController = void 0;
|
|
|
- this.audioStreamController = void 0;
|
|
|
- this.subtititleStreamController = void 0;
|
|
|
- this.audioTrackController = void 0;
|
|
|
- this.subtitleTrackController = void 0;
|
|
|
- this.interstitialsController = void 0;
|
|
|
- this.gapController = void 0;
|
|
|
- this.emeController = void 0;
|
|
|
- this.cmcdController = void 0;
|
|
|
- this._media = null;
|
|
|
- this._url = null;
|
|
|
- this._sessionId = void 0;
|
|
|
- this.triggeringException = void 0;
|
|
|
- this.started = false;
|
|
|
- const logger2 = this.logger = enableLogs(userConfig.debug || false, "Hls instance", userConfig.assetPlayerId);
|
|
|
- const config = this.config = mergeConfig(_Hls.DefaultConfig, userConfig, logger2);
|
|
|
- this.userConfig = userConfig;
|
|
|
- if (config.progressive) {
|
|
|
- enableStreamingMode(config, logger2);
|
|
|
- }
|
|
|
- const {
|
|
|
- abrController: _AbrController,
|
|
|
- bufferController: _BufferController,
|
|
|
- capLevelController: _CapLevelController,
|
|
|
- errorController: _ErrorController,
|
|
|
- fpsController: _FpsController
|
|
|
- } = config;
|
|
|
- const errorController = new _ErrorController(this);
|
|
|
- const abrController = this.abrController = new _AbrController(this);
|
|
|
- const fragmentTracker = new FragmentTracker(this);
|
|
|
- const _InterstitialsController = config.interstitialsController;
|
|
|
- const interstitialsController = _InterstitialsController ? this.interstitialsController = new _InterstitialsController(this, _Hls) : null;
|
|
|
- const bufferController = this.bufferController = new _BufferController(this, fragmentTracker);
|
|
|
- const capLevelController = this.capLevelController = new _CapLevelController(this);
|
|
|
- const fpsController = new _FpsController(this);
|
|
|
- const playListLoader = new PlaylistLoader(this);
|
|
|
- const _ContentSteeringController = config.contentSteeringController;
|
|
|
- const contentSteering = _ContentSteeringController ? new _ContentSteeringController(this) : null;
|
|
|
- const levelController = this.levelController = new LevelController(this, contentSteering);
|
|
|
- const id3TrackController = new ID3TrackController(this);
|
|
|
- const keyLoader = new KeyLoader(this.config, this.logger);
|
|
|
- const streamController = this.streamController = new StreamController(this, fragmentTracker, keyLoader);
|
|
|
- const gapController = this.gapController = new GapController(this, fragmentTracker);
|
|
|
- capLevelController.setStreamController(streamController);
|
|
|
- fpsController.setStreamController(streamController);
|
|
|
- const networkControllers = [playListLoader, levelController, streamController];
|
|
|
- if (interstitialsController) {
|
|
|
- networkControllers.splice(1, 0, interstitialsController);
|
|
|
- }
|
|
|
- if (contentSteering) {
|
|
|
- networkControllers.splice(1, 0, contentSteering);
|
|
|
- }
|
|
|
- this.networkControllers = networkControllers;
|
|
|
- const coreComponents = [abrController, bufferController, gapController, capLevelController, fpsController, id3TrackController, fragmentTracker];
|
|
|
- this.audioTrackController = this.createController(config.audioTrackController, networkControllers);
|
|
|
- const AudioStreamControllerClass = config.audioStreamController;
|
|
|
- if (AudioStreamControllerClass) {
|
|
|
- networkControllers.push(this.audioStreamController = new AudioStreamControllerClass(this, fragmentTracker, keyLoader));
|
|
|
- }
|
|
|
- this.subtitleTrackController = this.createController(config.subtitleTrackController, networkControllers);
|
|
|
- const SubtitleStreamControllerClass = config.subtitleStreamController;
|
|
|
- if (SubtitleStreamControllerClass) {
|
|
|
- networkControllers.push(this.subtititleStreamController = new SubtitleStreamControllerClass(this, fragmentTracker, keyLoader));
|
|
|
- }
|
|
|
- this.createController(config.timelineController, coreComponents);
|
|
|
- keyLoader.emeController = this.emeController = this.createController(config.emeController, coreComponents);
|
|
|
- this.cmcdController = this.createController(config.cmcdController, coreComponents);
|
|
|
- this.latencyController = this.createController(LatencyController, coreComponents);
|
|
|
- this.coreComponents = coreComponents;
|
|
|
- networkControllers.push(errorController);
|
|
|
- const onErrorOut = errorController.onErrorOut;
|
|
|
- if (typeof onErrorOut === "function") {
|
|
|
- this.on(Events.ERROR, onErrorOut, errorController);
|
|
|
- }
|
|
|
- this.on(Events.MANIFEST_LOADED, playListLoader.onManifestLoaded, playListLoader);
|
|
|
- }
|
|
|
- createController(ControllerClass, components) {
|
|
|
- if (ControllerClass) {
|
|
|
- const controllerInstance = new ControllerClass(this);
|
|
|
- if (components) {
|
|
|
- components.push(controllerInstance);
|
|
|
- }
|
|
|
- return controllerInstance;
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- // Delegate the EventEmitter through the public API of Hls.js
|
|
|
- on(event, listener, context = this) {
|
|
|
- this._emitter.on(event, listener, context);
|
|
|
- }
|
|
|
- once(event, listener, context = this) {
|
|
|
- this._emitter.once(event, listener, context);
|
|
|
- }
|
|
|
- removeAllListeners(event) {
|
|
|
- this._emitter.removeAllListeners(event);
|
|
|
- }
|
|
|
- off(event, listener, context = this, once) {
|
|
|
- this._emitter.off(event, listener, context, once);
|
|
|
- }
|
|
|
- listeners(event) {
|
|
|
- return this._emitter.listeners(event);
|
|
|
- }
|
|
|
- emit(event, name, eventObject) {
|
|
|
- return this._emitter.emit(event, name, eventObject);
|
|
|
- }
|
|
|
- trigger(event, eventObject) {
|
|
|
- if (this.config.debug) {
|
|
|
- return this.emit(event, event, eventObject);
|
|
|
- } else {
|
|
|
- try {
|
|
|
- return this.emit(event, event, eventObject);
|
|
|
- } catch (error) {
|
|
|
- this.logger.error("An internal error happened while handling event " + event + '. Error message: "' + error.message + '". Here is a stacktrace:', error);
|
|
|
- if (!this.triggeringException) {
|
|
|
- this.triggeringException = true;
|
|
|
- const fatal = event === Events.ERROR;
|
|
|
- this.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.INTERNAL_EXCEPTION,
|
|
|
- fatal,
|
|
|
- event,
|
|
|
- error
|
|
|
- });
|
|
|
- this.triggeringException = false;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- listenerCount(event) {
|
|
|
- return this._emitter.listenerCount(event);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Dispose of the instance
|
|
|
- */
|
|
|
- destroy() {
|
|
|
- this.logger.log("destroy");
|
|
|
- this.trigger(Events.DESTROYING, void 0);
|
|
|
- this.detachMedia();
|
|
|
- this.removeAllListeners();
|
|
|
- this._autoLevelCapping = -1;
|
|
|
- this._url = null;
|
|
|
- this.networkControllers.forEach((component) => component.destroy());
|
|
|
- this.networkControllers.length = 0;
|
|
|
- this.coreComponents.forEach((component) => component.destroy());
|
|
|
- this.coreComponents.length = 0;
|
|
|
- const config = this.config;
|
|
|
- config.xhrSetup = config.fetchSetup = void 0;
|
|
|
- this.userConfig = null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Attaches Hls.js to a media element
|
|
|
- */
|
|
|
- attachMedia(data) {
|
|
|
- if (!data || "media" in data && !data.media) {
|
|
|
- const error = new Error(`attachMedia failed: invalid argument (${data})`);
|
|
|
- this.trigger(Events.ERROR, {
|
|
|
- type: ErrorTypes.OTHER_ERROR,
|
|
|
- details: ErrorDetails.ATTACH_MEDIA_ERROR,
|
|
|
- fatal: true,
|
|
|
- error
|
|
|
- });
|
|
|
- return;
|
|
|
- }
|
|
|
- this.logger.log(`attachMedia`);
|
|
|
- if (this._media) {
|
|
|
- this.logger.warn(`media must be detached before attaching`);
|
|
|
- this.detachMedia();
|
|
|
- }
|
|
|
- const attachMediaSource = "media" in data;
|
|
|
- const media = attachMediaSource ? data.media : data;
|
|
|
- const attachingData = attachMediaSource ? data : {
|
|
|
- media
|
|
|
- };
|
|
|
- this._media = media;
|
|
|
- this.trigger(Events.MEDIA_ATTACHING, attachingData);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Detach Hls.js from the media
|
|
|
- */
|
|
|
- detachMedia() {
|
|
|
- this.logger.log("detachMedia");
|
|
|
- this.trigger(Events.MEDIA_DETACHING, {});
|
|
|
- this._media = null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Detach HTMLMediaElement, MediaSource, and SourceBuffers without reset, for attaching to another instance
|
|
|
- */
|
|
|
- transferMedia() {
|
|
|
- this._media = null;
|
|
|
- const transferMedia = this.bufferController.transferMedia();
|
|
|
- this.trigger(Events.MEDIA_DETACHING, {
|
|
|
- transferMedia
|
|
|
- });
|
|
|
- return transferMedia;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Set the source URL. Can be relative or absolute.
|
|
|
- */
|
|
|
- loadSource(url) {
|
|
|
- this.stopLoad();
|
|
|
- const media = this.media;
|
|
|
- const loadedSource = this._url;
|
|
|
- const loadingSource = this._url = urlToolkitExports.buildAbsoluteURL(self.location.href, url, {
|
|
|
- alwaysNormalize: true
|
|
|
- });
|
|
|
- this._autoLevelCapping = -1;
|
|
|
- this._maxHdcpLevel = null;
|
|
|
- this.logger.log(`loadSource:${loadingSource}`);
|
|
|
- if (media && loadedSource && (loadedSource !== loadingSource || this.bufferController.hasSourceTypes())) {
|
|
|
- this.detachMedia();
|
|
|
- this.attachMedia(media);
|
|
|
- }
|
|
|
- this.trigger(Events.MANIFEST_LOADING, {
|
|
|
- url
|
|
|
- });
|
|
|
- }
|
|
|
- /**
|
|
|
- * Gets the currently loaded URL
|
|
|
- */
|
|
|
- get url() {
|
|
|
- return this._url;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Whether or not enough has been buffered to seek to start position or use `media.currentTime` to determine next load position
|
|
|
- */
|
|
|
- get hasEnoughToStart() {
|
|
|
- return this.streamController.hasEnoughToStart;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get the startPosition set on startLoad(position) or on autostart with config.startPosition
|
|
|
- */
|
|
|
- get startPosition() {
|
|
|
- return this.streamController.startPositionValue;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Start loading data from the stream source.
|
|
|
- * Depending on default config, client starts loading automatically when a source is set.
|
|
|
- *
|
|
|
- * @param startPosition - Set the start position to stream from.
|
|
|
- * Defaults to -1 (None: starts from earliest point)
|
|
|
- */
|
|
|
- startLoad(startPosition = -1, skipSeekToStartPosition) {
|
|
|
- this.logger.log(`startLoad(${startPosition + (skipSeekToStartPosition ? ", <skip seek to start>" : "")})`);
|
|
|
- this.started = true;
|
|
|
- this.resumeBuffering();
|
|
|
- for (let i = 0; i < this.networkControllers.length; i++) {
|
|
|
- this.networkControllers[i].startLoad(startPosition, skipSeekToStartPosition);
|
|
|
- if (!this.started || !this.networkControllers) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Stop loading of any stream data.
|
|
|
- */
|
|
|
- stopLoad() {
|
|
|
- this.logger.log("stopLoad");
|
|
|
- this.started = false;
|
|
|
- for (let i = 0; i < this.networkControllers.length; i++) {
|
|
|
- this.networkControllers[i].stopLoad();
|
|
|
- if (this.started || !this.networkControllers) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Returns whether loading, toggled with `startLoad()` and `stopLoad()`, is active or not`.
|
|
|
- */
|
|
|
- get loadingEnabled() {
|
|
|
- return this.started;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Returns state of fragment loading toggled by calling `pauseBuffering()` and `resumeBuffering()`.
|
|
|
- */
|
|
|
- get bufferingEnabled() {
|
|
|
- return this.streamController.bufferingEnabled;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Resumes stream controller segment loading after `pauseBuffering` has been called.
|
|
|
- */
|
|
|
- resumeBuffering() {
|
|
|
- if (!this.bufferingEnabled) {
|
|
|
- this.logger.log(`resume buffering`);
|
|
|
- this.networkControllers.forEach((controller) => {
|
|
|
- if (controller.resumeBuffering) {
|
|
|
- controller.resumeBuffering();
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Prevents stream controller from loading new segments until `resumeBuffering` is called.
|
|
|
- * This allows for media buffering to be paused without interupting playlist loading.
|
|
|
- */
|
|
|
- pauseBuffering() {
|
|
|
- if (this.bufferingEnabled) {
|
|
|
- this.logger.log(`pause buffering`);
|
|
|
- this.networkControllers.forEach((controller) => {
|
|
|
- if (controller.pauseBuffering) {
|
|
|
- controller.pauseBuffering();
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- get inFlightFragments() {
|
|
|
- const inFlightData = {
|
|
|
- [PlaylistLevelType.MAIN]: this.streamController.inFlightFrag
|
|
|
- };
|
|
|
- if (this.audioStreamController) {
|
|
|
- inFlightData[PlaylistLevelType.AUDIO] = this.audioStreamController.inFlightFrag;
|
|
|
- }
|
|
|
- if (this.subtititleStreamController) {
|
|
|
- inFlightData[PlaylistLevelType.SUBTITLE] = this.subtititleStreamController.inFlightFrag;
|
|
|
- }
|
|
|
- return inFlightData;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
|
|
|
- */
|
|
|
- swapAudioCodec() {
|
|
|
- this.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() {
|
|
|
- this.logger.log("recoverMediaError");
|
|
|
- const media = this._media;
|
|
|
- const time = media == null ? void 0 : media.currentTime;
|
|
|
- this.detachMedia();
|
|
|
- if (media) {
|
|
|
- this.attachMedia(media);
|
|
|
- if (time) {
|
|
|
- this.startLoad(time);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- removeLevel(levelIndex) {
|
|
|
- this.levelController.removeLevel(levelIndex);
|
|
|
- }
|
|
|
- /**
|
|
|
- * @returns a UUID for this player instance
|
|
|
- */
|
|
|
- get sessionId() {
|
|
|
- let _sessionId = this._sessionId;
|
|
|
- if (!_sessionId) {
|
|
|
- _sessionId = this._sessionId = uuid();
|
|
|
- }
|
|
|
- return _sessionId;
|
|
|
- }
|
|
|
- /**
|
|
|
- * @returns an array of levels (variants) sorted by HDCP-LEVEL, RESOLUTION (height), FRAME-RATE, CODECS, VIDEO-RANGE, and BANDWIDTH
|
|
|
- */
|
|
|
- get levels() {
|
|
|
- const levels = this.levelController.levels;
|
|
|
- return levels ? levels : [];
|
|
|
- }
|
|
|
- /**
|
|
|
- * @returns LevelDetails of last loaded level (variant) or `null` prior to loading a media playlist.
|
|
|
- */
|
|
|
- get latestLevelDetails() {
|
|
|
- return this.streamController.getLevelDetails() || null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * @returns Level object of selected level (variant) or `null` prior to selecting a level or once the level is removed.
|
|
|
- */
|
|
|
- get loadLevelObj() {
|
|
|
- return this.levelController.loadLevelObj;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Index of quality level (variant) currently played
|
|
|
- */
|
|
|
- get currentLevel() {
|
|
|
- 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. Set to -1 for automatic level selection.
|
|
|
- */
|
|
|
- set currentLevel(newLevel) {
|
|
|
- this.logger.log(`set currentLevel:${newLevel}`);
|
|
|
- this.levelController.manualLevel = newLevel;
|
|
|
- this.streamController.immediateLevelSwitch();
|
|
|
- }
|
|
|
- /**
|
|
|
- * Index of next quality level loaded as scheduled by stream controller.
|
|
|
- */
|
|
|
- get nextLevel() {
|
|
|
- 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).
|
|
|
- * @param newLevel - Pass -1 for automatic level selection
|
|
|
- */
|
|
|
- set nextLevel(newLevel) {
|
|
|
- this.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
|
|
|
- */
|
|
|
- get loadLevel() {
|
|
|
- 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.
|
|
|
- * @param newLevel - Pass -1 for automatic level selection
|
|
|
- */
|
|
|
- set loadLevel(newLevel) {
|
|
|
- this.logger.log(`set loadLevel:${newLevel}`);
|
|
|
- this.levelController.manualLevel = newLevel;
|
|
|
- }
|
|
|
- /**
|
|
|
- * get next quality level loaded
|
|
|
- */
|
|
|
- get nextLoadLevel() {
|
|
|
- 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).
|
|
|
- */
|
|
|
- set nextLoadLevel(level) {
|
|
|
- this.levelController.nextLoadLevel = level;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Return "first level": like a default level, if not set,
|
|
|
- * falls back to index of first level referenced in manifest
|
|
|
- */
|
|
|
- get firstLevel() {
|
|
|
- return Math.max(this.levelController.firstLevel, this.minAutoLevel);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Sets "first-level", see getter.
|
|
|
- */
|
|
|
- set firstLevel(newLevel) {
|
|
|
- this.logger.log(`set firstLevel:${newLevel}`);
|
|
|
- this.levelController.firstLevel = newLevel;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Return the desired start level for the first fragment that will be loaded.
|
|
|
- * The default value of -1 indicates automatic start level selection.
|
|
|
- * Setting hls.nextAutoLevel without setting a startLevel will result in
|
|
|
- * the nextAutoLevel value being used for one fragment load.
|
|
|
- */
|
|
|
- get startLevel() {
|
|
|
- const startLevel = this.levelController.startLevel;
|
|
|
- if (startLevel === -1 && this.abrController.forcedAutoLevel > -1) {
|
|
|
- return this.abrController.forcedAutoLevel;
|
|
|
- }
|
|
|
- return 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)
|
|
|
- */
|
|
|
- set startLevel(newLevel) {
|
|
|
- this.logger.log(`set startLevel:${newLevel}`);
|
|
|
- if (newLevel !== -1) {
|
|
|
- newLevel = Math.max(newLevel, this.minAutoLevel);
|
|
|
- }
|
|
|
- this.levelController.startLevel = newLevel;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Whether level capping is enabled.
|
|
|
- * Default value is set via `config.capLevelToPlayerSize`.
|
|
|
- */
|
|
|
- get capLevelToPlayerSize() {
|
|
|
- return this.config.capLevelToPlayerSize;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Enables or disables level capping. If disabled after previously enabled, `nextLevelSwitch` will be immediately called.
|
|
|
- */
|
|
|
- set capLevelToPlayerSize(shouldStartCapping) {
|
|
|
- const newCapLevelToPlayerSize = !!shouldStartCapping;
|
|
|
- if (newCapLevelToPlayerSize !== this.config.capLevelToPlayerSize) {
|
|
|
- if (newCapLevelToPlayerSize) {
|
|
|
- this.capLevelController.startCapping();
|
|
|
- } else {
|
|
|
- this.capLevelController.stopCapping();
|
|
|
- this.autoLevelCapping = -1;
|
|
|
- this.streamController.nextLevelSwitch();
|
|
|
- }
|
|
|
- this.config.capLevelToPlayerSize = newCapLevelToPlayerSize;
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
|
|
- */
|
|
|
- get autoLevelCapping() {
|
|
|
- return this._autoLevelCapping;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Returns the current bandwidth estimate in bits per second, when available. Otherwise, `NaN` is returned.
|
|
|
- */
|
|
|
- get bandwidthEstimate() {
|
|
|
- const {
|
|
|
- bwEstimator
|
|
|
- } = this.abrController;
|
|
|
- if (!bwEstimator) {
|
|
|
- return NaN;
|
|
|
- }
|
|
|
- return bwEstimator.getEstimate();
|
|
|
- }
|
|
|
- set bandwidthEstimate(abrEwmaDefaultEstimate) {
|
|
|
- this.abrController.resetEstimator(abrEwmaDefaultEstimate);
|
|
|
- }
|
|
|
- get abrEwmaDefaultEstimate() {
|
|
|
- const {
|
|
|
- bwEstimator
|
|
|
- } = this.abrController;
|
|
|
- if (!bwEstimator) {
|
|
|
- return NaN;
|
|
|
- }
|
|
|
- return bwEstimator.defaultEstimate;
|
|
|
- }
|
|
|
- /**
|
|
|
- * get time to first byte estimate
|
|
|
- * @type {number}
|
|
|
- */
|
|
|
- get ttfbEstimate() {
|
|
|
- const {
|
|
|
- bwEstimator
|
|
|
- } = this.abrController;
|
|
|
- if (!bwEstimator) {
|
|
|
- return NaN;
|
|
|
- }
|
|
|
- return bwEstimator.getEstimateTTFB();
|
|
|
- }
|
|
|
- /**
|
|
|
- * Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
|
|
- */
|
|
|
- set autoLevelCapping(newLevel) {
|
|
|
- if (this._autoLevelCapping !== newLevel) {
|
|
|
- this.logger.log(`set autoLevelCapping:${newLevel}`);
|
|
|
- this._autoLevelCapping = newLevel;
|
|
|
- this.levelController.checkMaxAutoUpdated();
|
|
|
- }
|
|
|
- }
|
|
|
- get maxHdcpLevel() {
|
|
|
- return this._maxHdcpLevel;
|
|
|
- }
|
|
|
- set maxHdcpLevel(value) {
|
|
|
- if (isHdcpLevel(value) && this._maxHdcpLevel !== value) {
|
|
|
- this._maxHdcpLevel = value;
|
|
|
- this.levelController.checkMaxAutoUpdated();
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * True when automatic level selection enabled
|
|
|
- */
|
|
|
- get autoLevelEnabled() {
|
|
|
- return this.levelController.manualLevel === -1;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Level set manually (if any)
|
|
|
- */
|
|
|
- get manualLevel() {
|
|
|
- return this.levelController.manualLevel;
|
|
|
- }
|
|
|
- /**
|
|
|
- * min level selectable in auto mode according to config.minAutoBitrate
|
|
|
- */
|
|
|
- get minAutoLevel() {
|
|
|
- const {
|
|
|
- levels,
|
|
|
- config: {
|
|
|
- minAutoBitrate
|
|
|
- }
|
|
|
- } = this;
|
|
|
- if (!levels)
|
|
|
- return 0;
|
|
|
- const len = levels.length;
|
|
|
- for (let i = 0; i < len; i++) {
|
|
|
- if (levels[i].maxBitrate >= minAutoBitrate) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- /**
|
|
|
- * max level selectable in auto mode according to autoLevelCapping
|
|
|
- */
|
|
|
- get maxAutoLevel() {
|
|
|
- const {
|
|
|
- levels,
|
|
|
- autoLevelCapping,
|
|
|
- maxHdcpLevel
|
|
|
- } = this;
|
|
|
- let maxAutoLevel;
|
|
|
- if (autoLevelCapping === -1 && levels != null && levels.length) {
|
|
|
- maxAutoLevel = levels.length - 1;
|
|
|
- } else {
|
|
|
- maxAutoLevel = autoLevelCapping;
|
|
|
- }
|
|
|
- if (maxHdcpLevel) {
|
|
|
- for (let i = maxAutoLevel; i--; ) {
|
|
|
- const hdcpLevel = levels[i].attrs["HDCP-LEVEL"];
|
|
|
- if (hdcpLevel && hdcpLevel <= maxHdcpLevel) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return maxAutoLevel;
|
|
|
- }
|
|
|
- get firstAutoLevel() {
|
|
|
- return this.abrController.firstAutoLevel;
|
|
|
- }
|
|
|
- /**
|
|
|
- * next automatically selected quality level
|
|
|
- */
|
|
|
- get nextAutoLevel() {
|
|
|
- return this.abrController.nextAutoLevel;
|
|
|
- }
|
|
|
- /**
|
|
|
- * 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 successful frag loading at forced level,
|
|
|
- * this value will be resetted to -1 by ABR controller.
|
|
|
- */
|
|
|
- set nextAutoLevel(nextLevel) {
|
|
|
- this.abrController.nextAutoLevel = nextLevel;
|
|
|
- }
|
|
|
- /**
|
|
|
- * get the datetime value relative to media.currentTime for the active level Program Date Time if present
|
|
|
- */
|
|
|
- get playingDate() {
|
|
|
- return this.streamController.currentProgramDateTime;
|
|
|
- }
|
|
|
- get mainForwardBufferInfo() {
|
|
|
- return this.streamController.getMainFwdBufferInfo();
|
|
|
- }
|
|
|
- get maxBufferLength() {
|
|
|
- return this.streamController.maxBufferLength;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Find and select the best matching audio track, making a level switch when a Group change is necessary.
|
|
|
- * Updates `hls.config.audioPreference`. Returns the selected track, or null when no matching track is found.
|
|
|
- */
|
|
|
- setAudioOption(audioOption) {
|
|
|
- var _this$audioTrackContr;
|
|
|
- return ((_this$audioTrackContr = this.audioTrackController) == null ? void 0 : _this$audioTrackContr.setAudioOption(audioOption)) || null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Find and select the best matching subtitle track, making a level switch when a Group change is necessary.
|
|
|
- * Updates `hls.config.subtitlePreference`. Returns the selected track, or null when no matching track is found.
|
|
|
- */
|
|
|
- setSubtitleOption(subtitleOption) {
|
|
|
- var _this$subtitleTrackCo;
|
|
|
- return ((_this$subtitleTrackCo = this.subtitleTrackController) == null ? void 0 : _this$subtitleTrackCo.setSubtitleOption(subtitleOption)) || null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get the complete list of audio tracks across all media groups
|
|
|
- */
|
|
|
- get allAudioTracks() {
|
|
|
- const audioTrackController = this.audioTrackController;
|
|
|
- return audioTrackController ? audioTrackController.allAudioTracks : [];
|
|
|
- }
|
|
|
- /**
|
|
|
- * Get the list of selectable audio tracks
|
|
|
- */
|
|
|
- get audioTracks() {
|
|
|
- const audioTrackController = this.audioTrackController;
|
|
|
- return audioTrackController ? audioTrackController.audioTracks : [];
|
|
|
- }
|
|
|
- /**
|
|
|
- * index of the selected audio track (index in audio track lists)
|
|
|
- */
|
|
|
- get audioTrack() {
|
|
|
- const audioTrackController = this.audioTrackController;
|
|
|
- return audioTrackController ? audioTrackController.audioTrack : -1;
|
|
|
- }
|
|
|
- /**
|
|
|
- * selects an audio track, based on its index in audio track lists
|
|
|
- */
|
|
|
- set audioTrack(audioTrackId) {
|
|
|
- const audioTrackController = this.audioTrackController;
|
|
|
- if (audioTrackController) {
|
|
|
- audioTrackController.audioTrack = audioTrackId;
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * get the complete list of subtitle tracks across all media groups
|
|
|
- */
|
|
|
- get allSubtitleTracks() {
|
|
|
- const subtitleTrackController = this.subtitleTrackController;
|
|
|
- return subtitleTrackController ? subtitleTrackController.allSubtitleTracks : [];
|
|
|
- }
|
|
|
- /**
|
|
|
- * get alternate subtitle tracks list from playlist
|
|
|
- */
|
|
|
- get subtitleTracks() {
|
|
|
- const subtitleTrackController = this.subtitleTrackController;
|
|
|
- return subtitleTrackController ? subtitleTrackController.subtitleTracks : [];
|
|
|
- }
|
|
|
- /**
|
|
|
- * index of the selected subtitle track (index in subtitle track lists)
|
|
|
- */
|
|
|
- get subtitleTrack() {
|
|
|
- const subtitleTrackController = this.subtitleTrackController;
|
|
|
- return subtitleTrackController ? subtitleTrackController.subtitleTrack : -1;
|
|
|
- }
|
|
|
- get media() {
|
|
|
- return this._media;
|
|
|
- }
|
|
|
- /**
|
|
|
- * select an subtitle track, based on its index in subtitle track lists
|
|
|
- */
|
|
|
- set subtitleTrack(subtitleTrackId) {
|
|
|
- const subtitleTrackController = this.subtitleTrackController;
|
|
|
- if (subtitleTrackController) {
|
|
|
- subtitleTrackController.subtitleTrack = subtitleTrackId;
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Whether subtitle display is enabled or not
|
|
|
- */
|
|
|
- get subtitleDisplay() {
|
|
|
- const subtitleTrackController = this.subtitleTrackController;
|
|
|
- return subtitleTrackController ? subtitleTrackController.subtitleDisplay : false;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Enable/disable subtitle display rendering
|
|
|
- */
|
|
|
- set subtitleDisplay(value) {
|
|
|
- const subtitleTrackController = this.subtitleTrackController;
|
|
|
- if (subtitleTrackController) {
|
|
|
- subtitleTrackController.subtitleDisplay = value;
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * get mode for Low-Latency HLS loading
|
|
|
- */
|
|
|
- get lowLatencyMode() {
|
|
|
- return this.config.lowLatencyMode;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Enable/disable Low-Latency HLS part playlist and segment loading, and start live streams at playlist PART-HOLD-BACK rather than HOLD-BACK.
|
|
|
- */
|
|
|
- set lowLatencyMode(mode) {
|
|
|
- this.config.lowLatencyMode = mode;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Position (in seconds) of live sync point (ie edge of live position minus safety delay defined by ```hls.config.liveSyncDuration```)
|
|
|
- * @returns null prior to loading live Playlist
|
|
|
- */
|
|
|
- get liveSyncPosition() {
|
|
|
- return this.latencyController.liveSyncPosition;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Estimated position (in seconds) of live edge (ie edge of live playlist plus time sync playlist advanced)
|
|
|
- * @returns 0 before first playlist is loaded
|
|
|
- */
|
|
|
- get latency() {
|
|
|
- return this.latencyController.latency;
|
|
|
- }
|
|
|
- /**
|
|
|
- * maximum distance from the edge before the player seeks forward to ```hls.liveSyncPosition```
|
|
|
- * configured using ```liveMaxLatencyDurationCount``` (multiple of target duration) or ```liveMaxLatencyDuration```
|
|
|
- * @returns 0 before first playlist is loaded
|
|
|
- */
|
|
|
- get maxLatency() {
|
|
|
- return this.latencyController.maxLatency;
|
|
|
- }
|
|
|
- /**
|
|
|
- * target distance from the edge as calculated by the latency controller
|
|
|
- */
|
|
|
- get targetLatency() {
|
|
|
- return this.latencyController.targetLatency;
|
|
|
- }
|
|
|
- set targetLatency(latency) {
|
|
|
- this.latencyController.targetLatency = latency;
|
|
|
- }
|
|
|
- /**
|
|
|
- * the rate at which the edge of the current live playlist is advancing or 1 if there is none
|
|
|
- */
|
|
|
- get drift() {
|
|
|
- return this.latencyController.drift;
|
|
|
- }
|
|
|
- /**
|
|
|
- * set to true when startLoad is called before MANIFEST_PARSED event
|
|
|
- */
|
|
|
- get forceStartLoad() {
|
|
|
- return this.streamController.forceStartLoad;
|
|
|
- }
|
|
|
- /**
|
|
|
- * ContentSteering pathways getter
|
|
|
- */
|
|
|
- get pathways() {
|
|
|
- return this.levelController.pathways;
|
|
|
- }
|
|
|
- /**
|
|
|
- * ContentSteering pathwayPriority getter/setter
|
|
|
- */
|
|
|
- get pathwayPriority() {
|
|
|
- return this.levelController.pathwayPriority;
|
|
|
- }
|
|
|
- set pathwayPriority(pathwayPriority) {
|
|
|
- this.levelController.pathwayPriority = pathwayPriority;
|
|
|
- }
|
|
|
- /**
|
|
|
- * returns true when all SourceBuffers are buffered to the end
|
|
|
- */
|
|
|
- get bufferedToEnd() {
|
|
|
- var _this$bufferControlle;
|
|
|
- return !!((_this$bufferControlle = this.bufferController) != null && _this$bufferControlle.bufferedToEnd);
|
|
|
- }
|
|
|
- /**
|
|
|
- * returns Interstitials Program Manager
|
|
|
- */
|
|
|
- get interstitialsManager() {
|
|
|
- var _this$interstitialsCo;
|
|
|
- return ((_this$interstitialsCo = this.interstitialsController) == null ? void 0 : _this$interstitialsCo.interstitialsManager) || null;
|
|
|
- }
|
|
|
- /**
|
|
|
- * returns mediaCapabilities.decodingInfo for a variant/rendition
|
|
|
- */
|
|
|
- getMediaDecodingInfo(level, audioTracks = this.allAudioTracks) {
|
|
|
- const audioTracksByGroup = getAudioTracksByGroup(audioTracks);
|
|
|
- return getMediaDecodingInfoPromise(level, audioTracksByGroup, navigator.mediaCapabilities);
|
|
|
- }
|
|
|
-};
|
|
|
-Hls.defaultConfig = void 0;
|
|
|
-export {
|
|
|
- AbrController,
|
|
|
- AttrList,
|
|
|
- AudioStreamController,
|
|
|
- AudioTrackController,
|
|
|
- BasePlaylistController,
|
|
|
- BaseSegment,
|
|
|
- BaseStreamController,
|
|
|
- BufferController,
|
|
|
- CMCDController,
|
|
|
- CapLevelController,
|
|
|
- ChunkMetadata,
|
|
|
- ContentSteeringController,
|
|
|
- Cues,
|
|
|
- DateRange,
|
|
|
- EMEController,
|
|
|
- ErrorActionFlags,
|
|
|
- ErrorController,
|
|
|
- ErrorDetails,
|
|
|
- ErrorTypes,
|
|
|
- Events,
|
|
|
- FPSController,
|
|
|
- FetchLoader,
|
|
|
- Fragment,
|
|
|
- Hls,
|
|
|
- HlsSkip,
|
|
|
- HlsUrlParameters,
|
|
|
- KeySystemFormats,
|
|
|
- KeySystems,
|
|
|
- Level,
|
|
|
- LevelDetails,
|
|
|
- LevelKey,
|
|
|
- LoadStats,
|
|
|
- M3U8Parser,
|
|
|
- MetadataSchema,
|
|
|
- NetworkErrorAction,
|
|
|
- Part,
|
|
|
- PlaylistLevelType,
|
|
|
- SubtitleStreamController,
|
|
|
- SubtitleTrackController,
|
|
|
- TimelineController,
|
|
|
- XhrLoader,
|
|
|
- Hls as default,
|
|
|
- fetchSupported,
|
|
|
- getMediaSource,
|
|
|
- isMSESupported,
|
|
|
- isSupported,
|
|
|
- requestMediaKeySystemAccess
|
|
|
-};
|
|
|
-//# sourceMappingURL=hls__js.js.map
|
chenyixian
