mirror of https://bitbucket.org/ausocean/av.git
Merge branch 'master' into m3u-packages
This commit is contained in:
Trek H
commit
be0e2c81b8
|
|
@ -10,7 +10,7 @@ var has = Object.prototype.hasOwnProperty
|
||||||
* @constructor
|
* @constructor
|
||||||
* @private
|
* @private
|
||||||
*/
|
*/
|
||||||
function Events() { }
|
function Events() {}
|
||||||
|
|
||||||
//
|
//
|
||||||
// We try to not inherit from `Object.prototype`. In some engines creating an
|
// We try to not inherit from `Object.prototype`. In some engines creating an
|
||||||
|
|
@ -185,7 +185,7 @@ EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
|
||||||
case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), 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++) {
|
for (i = 1, args = new Array(len -1); i < len; i++) {
|
||||||
args[i - 1] = arguments[i];
|
args[i - 1] = arguments[i];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -203,7 +203,7 @@ EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
|
||||||
case 3: listeners[i].fn.call(listeners[i].context, a1, a2); 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;
|
case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
|
||||||
default:
|
default:
|
||||||
if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
|
if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
|
||||||
args[j - 1] = arguments[j];
|
args[j - 1] = arguments[j];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -328,4 +328,9 @@ EventEmitter.prefixed = prefix;
|
||||||
//
|
//
|
||||||
EventEmitter.EventEmitter = EventEmitter;
|
EventEmitter.EventEmitter = EventEmitter;
|
||||||
|
|
||||||
export default EventEmitter;
|
//
|
||||||
|
// Expose the module.
|
||||||
|
//
|
||||||
|
if ('undefined' !== typeof module) {
|
||||||
|
module.exports = EventEmitter;
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,468 @@
|
||||||
|
/*
|
||||||
|
* Level Controller
|
||||||
|
*/
|
||||||
|
|
||||||
|
import Event from '../events';
|
||||||
|
import EventHandler from '../event-handler';
|
||||||
|
import { logger } from '../utils/logger';
|
||||||
|
import { ErrorTypes, ErrorDetails } from '../errors';
|
||||||
|
import { isCodecSupportedInMp4 } from '../utils/codecs';
|
||||||
|
import { addGroupId, computeReloadInterval } from './level-helper';
|
||||||
|
|
||||||
|
const { performance } = window;
|
||||||
|
let chromeOrFirefox;
|
||||||
|
|
||||||
|
export default class LevelController extends EventHandler {
|
||||||
|
constructor (hls) {
|
||||||
|
super(hls,
|
||||||
|
Event.MANIFEST_LOADED,
|
||||||
|
Event.LEVEL_LOADED,
|
||||||
|
Event.AUDIO_TRACK_SWITCHED,
|
||||||
|
Event.FRAG_LOADED,
|
||||||
|
Event.ERROR);
|
||||||
|
|
||||||
|
this.canload = false;
|
||||||
|
this.currentLevelIndex = null;
|
||||||
|
this.manualLevelIndex = -1;
|
||||||
|
this.timer = null;
|
||||||
|
|
||||||
|
chromeOrFirefox = /chrome|firefox/.test(navigator.userAgent.toLowerCase());
|
||||||
|
}
|
||||||
|
|
||||||
|
onHandlerDestroying () {
|
||||||
|
this.clearTimer();
|
||||||
|
this.manualLevelIndex = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
clearTimer () {
|
||||||
|
if (this.timer !== null) {
|
||||||
|
clearTimeout(this.timer);
|
||||||
|
this.timer = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
startLoad () {
|
||||||
|
let levels = this._levels;
|
||||||
|
|
||||||
|
this.canload = true;
|
||||||
|
this.levelRetryCount = 0;
|
||||||
|
|
||||||
|
// clean up live level details to force reload them, and reset load errors
|
||||||
|
if (levels) {
|
||||||
|
levels.forEach(level => {
|
||||||
|
level.loadError = 0;
|
||||||
|
const levelDetails = level.details;
|
||||||
|
if (levelDetails && levelDetails.live) {
|
||||||
|
level.details = undefined;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
// speed up live playlist refresh if timer exists
|
||||||
|
if (this.timer !== null) {
|
||||||
|
this.loadLevel();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
stopLoad () {
|
||||||
|
this.canload = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
onManifestLoaded (data) {
|
||||||
|
let levels = [];
|
||||||
|
let audioTracks = [];
|
||||||
|
let bitrateStart;
|
||||||
|
let levelSet = {};
|
||||||
|
let levelFromSet = null;
|
||||||
|
let videoCodecFound = false;
|
||||||
|
let audioCodecFound = false;
|
||||||
|
|
||||||
|
// regroup redundant levels together
|
||||||
|
data.levels.forEach(level => {
|
||||||
|
const attributes = level.attrs;
|
||||||
|
level.loadError = 0;
|
||||||
|
level.fragmentError = false;
|
||||||
|
|
||||||
|
videoCodecFound = videoCodecFound || !!level.videoCodec;
|
||||||
|
audioCodecFound = audioCodecFound || !!level.audioCodec;
|
||||||
|
|
||||||
|
// erase audio codec info if browser does not support mp4a.40.34.
|
||||||
|
// demuxer will autodetect codec and fallback to mpeg/audio
|
||||||
|
if (chromeOrFirefox && level.audioCodec && level.audioCodec.indexOf('mp4a.40.34') !== -1) {
|
||||||
|
level.audioCodec = undefined;
|
||||||
|
}
|
||||||
|
|
||||||
|
levelFromSet = levelSet[level.bitrate]; // FIXME: we would also have to match the resolution here
|
||||||
|
|
||||||
|
if (!levelFromSet) {
|
||||||
|
level.url = [level.url];
|
||||||
|
level.urlId = 0;
|
||||||
|
levelSet[level.bitrate] = level;
|
||||||
|
levels.push(level);
|
||||||
|
} else {
|
||||||
|
levelFromSet.url.push(level.url);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (attributes) {
|
||||||
|
if (attributes.AUDIO) {
|
||||||
|
audioCodecFound = true;
|
||||||
|
addGroupId(levelFromSet || level, 'audio', attributes.AUDIO);
|
||||||
|
}
|
||||||
|
if (attributes.SUBTITLES) {
|
||||||
|
addGroupId(levelFromSet || level, 'text', attributes.SUBTITLES);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
// remove audio-only level if we also have levels with audio+video codecs signalled
|
||||||
|
if (videoCodecFound && audioCodecFound) {
|
||||||
|
levels = levels.filter(({ videoCodec }) => !!videoCodec);
|
||||||
|
}
|
||||||
|
|
||||||
|
// only keep levels with supported audio/video codecs
|
||||||
|
levels = levels.filter(({ audioCodec, videoCodec }) => {
|
||||||
|
return (!audioCodec || isCodecSupportedInMp4(audioCodec, 'audio')) && (!videoCodec || isCodecSupportedInMp4(videoCodec, 'video'));
|
||||||
|
});
|
||||||
|
|
||||||
|
if (data.audioTracks) {
|
||||||
|
audioTracks = data.audioTracks.filter(track => !track.audioCodec || isCodecSupportedInMp4(track.audioCodec, 'audio'));
|
||||||
|
// Reassign id's after filtering since they're used as array indices
|
||||||
|
audioTracks.forEach((track, index) => {
|
||||||
|
track.id = index;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
if (levels.length > 0) {
|
||||||
|
// start bitrate is the first bitrate of the manifest
|
||||||
|
bitrateStart = levels[0].bitrate;
|
||||||
|
// sort level on bitrate
|
||||||
|
levels.sort((a, b) => a.bitrate - b.bitrate);
|
||||||
|
this._levels = levels;
|
||||||
|
// find index of first level in sorted levels
|
||||||
|
for (let i = 0; i < levels.length; i++) {
|
||||||
|
if (levels[i].bitrate === bitrateStart) {
|
||||||
|
this._firstLevel = i;
|
||||||
|
logger.log(`manifest loaded,${levels.length} level(s) found, first bitrate:${bitrateStart}`);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Audio is only alternate if manifest include a URI along with the audio group tag
|
||||||
|
this.hls.trigger(Event.MANIFEST_PARSED, {
|
||||||
|
levels,
|
||||||
|
audioTracks,
|
||||||
|
firstLevel: this._firstLevel,
|
||||||
|
stats: data.stats,
|
||||||
|
audio: audioCodecFound,
|
||||||
|
video: videoCodecFound,
|
||||||
|
altAudio: audioTracks.some(t => !!t.url)
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
this.hls.trigger(Event.ERROR, {
|
||||||
|
type: ErrorTypes.MEDIA_ERROR,
|
||||||
|
details: ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR,
|
||||||
|
fatal: true,
|
||||||
|
url: this.hls.url,
|
||||||
|
reason: 'no level with compatible codecs found in manifest'
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
get levels () {
|
||||||
|
return this._levels;
|
||||||
|
}
|
||||||
|
|
||||||
|
get level () {
|
||||||
|
return this.currentLevelIndex;
|
||||||
|
}
|
||||||
|
|
||||||
|
set level (newLevel) {
|
||||||
|
let levels = this._levels;
|
||||||
|
if (levels) {
|
||||||
|
newLevel = Math.min(newLevel, levels.length - 1);
|
||||||
|
if (this.currentLevelIndex !== newLevel || !levels[newLevel].details) {
|
||||||
|
this.setLevelInternal(newLevel);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
setLevelInternal (newLevel) {
|
||||||
|
const levels = this._levels;
|
||||||
|
const hls = this.hls;
|
||||||
|
// check if level idx is valid
|
||||||
|
if (newLevel >= 0 && newLevel < levels.length) {
|
||||||
|
// stopping live reloading timer if any
|
||||||
|
this.clearTimer();
|
||||||
|
if (this.currentLevelIndex !== newLevel) {
|
||||||
|
logger.log(`switching to level ${newLevel}`);
|
||||||
|
this.currentLevelIndex = newLevel;
|
||||||
|
const levelProperties = levels[newLevel];
|
||||||
|
levelProperties.level = newLevel;
|
||||||
|
hls.trigger(Event.LEVEL_SWITCHING, levelProperties);
|
||||||
|
}
|
||||||
|
const level = levels[newLevel];
|
||||||
|
const levelDetails = level.details;
|
||||||
|
|
||||||
|
// check if we need to load playlist for this level
|
||||||
|
if (!levelDetails || levelDetails.live) {
|
||||||
|
// level not retrieved yet, or live playlist we need to (re)load it
|
||||||
|
let urlId = level.urlId;
|
||||||
|
hls.trigger(Event.LEVEL_LOADING, { url: level.url[urlId], level: newLevel, id: urlId });
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// invalid level id given, trigger error
|
||||||
|
hls.trigger(Event.ERROR, {
|
||||||
|
type: ErrorTypes.OTHER_ERROR,
|
||||||
|
details: ErrorDetails.LEVEL_SWITCH_ERROR,
|
||||||
|
level: newLevel,
|
||||||
|
fatal: false,
|
||||||
|
reason: 'invalid level idx'
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
get manualLevel () {
|
||||||
|
return this.manualLevelIndex;
|
||||||
|
}
|
||||||
|
|
||||||
|
set manualLevel (newLevel) {
|
||||||
|
this.manualLevelIndex = newLevel;
|
||||||
|
if (this._startLevel === undefined) {
|
||||||
|
this._startLevel = newLevel;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (newLevel !== -1) {
|
||||||
|
this.level = newLevel;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
get firstLevel () {
|
||||||
|
return this._firstLevel;
|
||||||
|
}
|
||||||
|
|
||||||
|
set firstLevel (newLevel) {
|
||||||
|
this._firstLevel = newLevel;
|
||||||
|
}
|
||||||
|
|
||||||
|
get startLevel () {
|
||||||
|
// hls.startLevel takes precedence over config.startLevel
|
||||||
|
// if none of these values are defined, fallback on this._firstLevel (first quality level appearing in variant manifest)
|
||||||
|
if (this._startLevel === undefined) {
|
||||||
|
let configStartLevel = this.hls.config.startLevel;
|
||||||
|
if (configStartLevel !== undefined) {
|
||||||
|
return configStartLevel;
|
||||||
|
} else {
|
||||||
|
return this._firstLevel;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
return this._startLevel;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
set startLevel (newLevel) {
|
||||||
|
this._startLevel = newLevel;
|
||||||
|
}
|
||||||
|
|
||||||
|
onError (data) {
|
||||||
|
if (data.fatal) {
|
||||||
|
if (data.type === ErrorTypes.NETWORK_ERROR) {
|
||||||
|
this.clearTimer();
|
||||||
|
}
|
||||||
|
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let levelError = false, fragmentError = false;
|
||||||
|
let levelIndex;
|
||||||
|
|
||||||
|
// try to recover not fatal errors
|
||||||
|
switch (data.details) {
|
||||||
|
case ErrorDetails.FRAG_LOAD_ERROR:
|
||||||
|
case ErrorDetails.FRAG_LOAD_TIMEOUT:
|
||||||
|
case ErrorDetails.KEY_LOAD_ERROR:
|
||||||
|
case ErrorDetails.KEY_LOAD_TIMEOUT:
|
||||||
|
levelIndex = data.frag.level;
|
||||||
|
fragmentError = true;
|
||||||
|
break;
|
||||||
|
case ErrorDetails.LEVEL_LOAD_ERROR:
|
||||||
|
case ErrorDetails.LEVEL_LOAD_TIMEOUT:
|
||||||
|
levelIndex = data.context.level;
|
||||||
|
levelError = true;
|
||||||
|
break;
|
||||||
|
case ErrorDetails.REMUX_ALLOC_ERROR:
|
||||||
|
levelIndex = data.level;
|
||||||
|
levelError = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (levelIndex !== undefined) {
|
||||||
|
this.recoverLevel(data, levelIndex, levelError, fragmentError);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Switch to a redundant stream if any available.
|
||||||
|
* If redundant stream is not available, emergency switch down if ABR mode is enabled.
|
||||||
|
*
|
||||||
|
* @param {Object} errorEvent
|
||||||
|
* @param {Number} levelIndex current level index
|
||||||
|
* @param {Boolean} levelError
|
||||||
|
* @param {Boolean} fragmentError
|
||||||
|
*/
|
||||||
|
// FIXME Find a better abstraction where fragment/level retry management is well decoupled
|
||||||
|
recoverLevel (errorEvent, levelIndex, levelError, fragmentError) {
|
||||||
|
let { config } = this.hls;
|
||||||
|
let { details: errorDetails } = errorEvent;
|
||||||
|
let level = this._levels[levelIndex];
|
||||||
|
let redundantLevels, delay, nextLevel;
|
||||||
|
|
||||||
|
level.loadError++;
|
||||||
|
level.fragmentError = fragmentError;
|
||||||
|
|
||||||
|
if (levelError) {
|
||||||
|
if ((this.levelRetryCount + 1) <= config.levelLoadingMaxRetry) {
|
||||||
|
// exponential backoff capped to max retry timeout
|
||||||
|
delay = Math.min(Math.pow(2, this.levelRetryCount) * config.levelLoadingRetryDelay, config.levelLoadingMaxRetryTimeout);
|
||||||
|
// Schedule level reload
|
||||||
|
this.timer = setTimeout(() => this.loadLevel(), delay);
|
||||||
|
// boolean used to inform stream controller not to switch back to IDLE on non fatal error
|
||||||
|
errorEvent.levelRetry = true;
|
||||||
|
this.levelRetryCount++;
|
||||||
|
logger.warn(`level controller, ${errorDetails}, retry in ${delay} ms, current retry count is ${this.levelRetryCount}`);
|
||||||
|
} else {
|
||||||
|
logger.error(`level controller, cannot recover from ${errorDetails} error`);
|
||||||
|
this.currentLevelIndex = null;
|
||||||
|
// stopping live reloading timer if any
|
||||||
|
this.clearTimer();
|
||||||
|
// switch error to fatal
|
||||||
|
errorEvent.fatal = true;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Try any redundant streams if available for both errors: level and fragment
|
||||||
|
// If level.loadError reaches redundantLevels it means that we tried them all, no hope => let's switch down
|
||||||
|
if (levelError || fragmentError) {
|
||||||
|
redundantLevels = level.url.length;
|
||||||
|
|
||||||
|
if (redundantLevels > 1 && level.loadError < redundantLevels) {
|
||||||
|
level.urlId = (level.urlId + 1) % redundantLevels;
|
||||||
|
level.details = undefined;
|
||||||
|
|
||||||
|
logger.warn(`level controller, ${errorDetails} for level ${levelIndex}: switching to redundant URL-id ${level.urlId}`);
|
||||||
|
|
||||||
|
// console.log('Current audio track group ID:', this.hls.audioTracks[this.hls.audioTrack].groupId);
|
||||||
|
// console.log('New video quality level audio group id:', level.attrs.AUDIO);
|
||||||
|
} else {
|
||||||
|
// Search for available level
|
||||||
|
if (this.manualLevelIndex === -1) {
|
||||||
|
// When lowest level has been reached, let's start hunt from the top
|
||||||
|
nextLevel = (levelIndex === 0) ? this._levels.length - 1 : levelIndex - 1;
|
||||||
|
logger.warn(`level controller, ${errorDetails}: switch to ${nextLevel}`);
|
||||||
|
this.hls.nextAutoLevel = this.currentLevelIndex = nextLevel;
|
||||||
|
} else if (fragmentError) {
|
||||||
|
// Allow fragment retry as long as configuration allows.
|
||||||
|
// reset this._level so that another call to set level() will trigger again a frag load
|
||||||
|
logger.warn(`level controller, ${errorDetails}: reload a fragment`);
|
||||||
|
this.currentLevelIndex = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// reset errors on the successful load of a fragment
|
||||||
|
onFragLoaded ({ frag }) {
|
||||||
|
if (frag !== undefined && frag.type === 'main') {
|
||||||
|
const level = this._levels[frag.level];
|
||||||
|
if (level !== undefined) {
|
||||||
|
level.fragmentError = false;
|
||||||
|
level.loadError = 0;
|
||||||
|
this.levelRetryCount = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
onLevelLoaded (data) {
|
||||||
|
const { level, details } = data;
|
||||||
|
// only process level loaded events matching with expected level
|
||||||
|
if (level !== this.currentLevelIndex) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
const curLevel = this._levels[level];
|
||||||
|
// reset level load error counter on successful level loaded only if there is no issues with fragments
|
||||||
|
if (!curLevel.fragmentError) {
|
||||||
|
curLevel.loadError = 0;
|
||||||
|
this.levelRetryCount = 0;
|
||||||
|
}
|
||||||
|
// if current playlist is a live playlist, arm a timer to reload it
|
||||||
|
if (details.live) {
|
||||||
|
const reloadInterval = computeReloadInterval(curLevel.details, details, data.stats.trequest);
|
||||||
|
logger.log(`live playlist, reload in ${Math.round(reloadInterval)} ms`);
|
||||||
|
this.timer = setTimeout(() => this.loadLevel(), reloadInterval);
|
||||||
|
} else {
|
||||||
|
this.clearTimer();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
onAudioTrackSwitched (data) {
|
||||||
|
const audioGroupId = this.hls.audioTracks[data.id].groupId;
|
||||||
|
|
||||||
|
const currentLevel = this.hls.levels[this.currentLevelIndex];
|
||||||
|
if (!currentLevel) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (currentLevel.audioGroupIds) {
|
||||||
|
let urlId = -1;
|
||||||
|
|
||||||
|
for (let i = 0; i < currentLevel.audioGroupIds.length; i++) {
|
||||||
|
if (currentLevel.audioGroupIds[i] === audioGroupId) {
|
||||||
|
urlId = i;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (urlId !== currentLevel.urlId) {
|
||||||
|
currentLevel.urlId = urlId;
|
||||||
|
this.startLoad();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
loadLevel () {
|
||||||
|
logger.debug('call to loadLevel');
|
||||||
|
|
||||||
|
if (this.currentLevelIndex !== null && this.canload) {
|
||||||
|
const levelObject = this._levels[this.currentLevelIndex];
|
||||||
|
|
||||||
|
if (typeof levelObject === 'object' &&
|
||||||
|
levelObject.url.length > 0) {
|
||||||
|
const level = this.currentLevelIndex;
|
||||||
|
const id = levelObject.urlId;
|
||||||
|
const url = levelObject.url[id];
|
||||||
|
|
||||||
|
logger.log(`Attempt loading level index ${level} with URL-id ${id}`);
|
||||||
|
|
||||||
|
// console.log('Current audio track group ID:', this.hls.audioTracks[this.hls.audioTrack].groupId);
|
||||||
|
// console.log('New video quality level audio group id:', levelObject.attrs.AUDIO, level);
|
||||||
|
|
||||||
|
this.hls.trigger(Event.LEVEL_LOADING, { url, level, id });
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,229 @@
|
||||||
|
/**
|
||||||
|
* @module LevelHelper
|
||||||
|
*
|
||||||
|
* Providing methods dealing with playlist sliding and drift
|
||||||
|
*
|
||||||
|
* TODO: Create an actual `Level` class/model that deals with all this logic in an object-oriented-manner.
|
||||||
|
*
|
||||||
|
* */
|
||||||
|
|
||||||
|
import { logger } from '../utils/logger';
|
||||||
|
|
||||||
|
export function addGroupId (level, type, id) {
|
||||||
|
switch (type) {
|
||||||
|
case 'audio':
|
||||||
|
if (!level.audioGroupIds) {
|
||||||
|
level.audioGroupIds = [];
|
||||||
|
}
|
||||||
|
level.audioGroupIds.push(id);
|
||||||
|
break;
|
||||||
|
case 'text':
|
||||||
|
if (!level.textGroupIds) {
|
||||||
|
level.textGroupIds = [];
|
||||||
|
}
|
||||||
|
level.textGroupIds.push(id);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
export function updatePTS (fragments, fromIdx, toIdx) {
|
||||||
|
let fragFrom = fragments[fromIdx], fragTo = fragments[toIdx], fragToPTS = fragTo.startPTS;
|
||||||
|
// if we know startPTS[toIdx]
|
||||||
|
if (Number.isFinite(fragToPTS)) {
|
||||||
|
// update fragment duration.
|
||||||
|
// it helps to fix drifts between playlist reported duration and fragment real duration
|
||||||
|
if (toIdx > fromIdx) {
|
||||||
|
fragFrom.duration = fragToPTS - fragFrom.start;
|
||||||
|
if (fragFrom.duration < 0) {
|
||||||
|
logger.warn(`negative duration computed for frag ${fragFrom.sn},level ${fragFrom.level}, there should be some duration drift between playlist and fragment!`);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
fragTo.duration = fragFrom.start - fragToPTS;
|
||||||
|
if (fragTo.duration < 0) {
|
||||||
|
logger.warn(`negative duration computed for frag ${fragTo.sn},level ${fragTo.level}, there should be some duration drift between playlist and fragment!`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// we dont know startPTS[toIdx]
|
||||||
|
if (toIdx > fromIdx) {
|
||||||
|
fragTo.start = fragFrom.start + fragFrom.duration;
|
||||||
|
} else {
|
||||||
|
fragTo.start = Math.max(fragFrom.start - fragTo.duration, 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
export function updateFragPTSDTS (details, frag, startPTS, endPTS, startDTS, endDTS) {
|
||||||
|
// update frag PTS/DTS
|
||||||
|
let maxStartPTS = startPTS;
|
||||||
|
if (Number.isFinite(frag.startPTS)) {
|
||||||
|
// delta PTS between audio and video
|
||||||
|
let deltaPTS = Math.abs(frag.startPTS - startPTS);
|
||||||
|
if (!Number.isFinite(frag.deltaPTS)) {
|
||||||
|
frag.deltaPTS = deltaPTS;
|
||||||
|
} else {
|
||||||
|
frag.deltaPTS = Math.max(deltaPTS, frag.deltaPTS);
|
||||||
|
}
|
||||||
|
|
||||||
|
maxStartPTS = Math.max(startPTS, frag.startPTS);
|
||||||
|
startPTS = Math.min(startPTS, frag.startPTS);
|
||||||
|
endPTS = Math.max(endPTS, frag.endPTS);
|
||||||
|
startDTS = Math.min(startDTS, frag.startDTS);
|
||||||
|
endDTS = Math.max(endDTS, frag.endDTS);
|
||||||
|
}
|
||||||
|
|
||||||
|
const drift = startPTS - frag.start;
|
||||||
|
frag.start = frag.startPTS = startPTS;
|
||||||
|
frag.maxStartPTS = maxStartPTS;
|
||||||
|
frag.endPTS = endPTS;
|
||||||
|
frag.startDTS = startDTS;
|
||||||
|
frag.endDTS = endDTS;
|
||||||
|
frag.duration = endPTS - startPTS;
|
||||||
|
|
||||||
|
const sn = frag.sn;
|
||||||
|
// exit if sn out of range
|
||||||
|
if (!details || sn < details.startSN || sn > details.endSN) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
let fragIdx, fragments, i;
|
||||||
|
fragIdx = sn - details.startSN;
|
||||||
|
fragments = details.fragments;
|
||||||
|
// update frag reference in fragments array
|
||||||
|
// rationale is that fragments array might not contain this frag object.
|
||||||
|
// this will happen if playlist has been refreshed between frag loading and call to updateFragPTSDTS()
|
||||||
|
// if we don't update frag, we won't be able to propagate PTS info on the playlist
|
||||||
|
// resulting in invalid sliding computation
|
||||||
|
fragments[fragIdx] = frag;
|
||||||
|
// adjust fragment PTS/duration from seqnum-1 to frag 0
|
||||||
|
for (i = fragIdx; i > 0; i--) {
|
||||||
|
updatePTS(fragments, i, i - 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
// adjust fragment PTS/duration from seqnum to last frag
|
||||||
|
for (i = fragIdx; i < fragments.length - 1; i++) {
|
||||||
|
updatePTS(fragments, i, i + 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
details.PTSKnown = true;
|
||||||
|
return drift;
|
||||||
|
}
|
||||||
|
|
||||||
|
export function mergeDetails (oldDetails, newDetails) {
|
||||||
|
// potentially retrieve cached initsegment
|
||||||
|
if (newDetails.initSegment && oldDetails.initSegment) {
|
||||||
|
newDetails.initSegment = oldDetails.initSegment;
|
||||||
|
}
|
||||||
|
|
||||||
|
// check if old/new playlists have fragments in common
|
||||||
|
// loop through overlapping SN and update startPTS , cc, and duration if any found
|
||||||
|
let ccOffset = 0;
|
||||||
|
let PTSFrag;
|
||||||
|
mapFragmentIntersection(oldDetails, newDetails, (oldFrag, newFrag) => {
|
||||||
|
ccOffset = oldFrag.cc - newFrag.cc;
|
||||||
|
if (Number.isFinite(oldFrag.startPTS)) {
|
||||||
|
newFrag.start = newFrag.startPTS = oldFrag.startPTS;
|
||||||
|
newFrag.endPTS = oldFrag.endPTS;
|
||||||
|
newFrag.duration = oldFrag.duration;
|
||||||
|
newFrag.backtracked = oldFrag.backtracked;
|
||||||
|
newFrag.dropped = oldFrag.dropped;
|
||||||
|
PTSFrag = newFrag;
|
||||||
|
}
|
||||||
|
// PTS is known when there are overlapping segments
|
||||||
|
newDetails.PTSKnown = true;
|
||||||
|
});
|
||||||
|
|
||||||
|
if (!newDetails.PTSKnown) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ccOffset) {
|
||||||
|
logger.log('discontinuity sliding from playlist, take drift into account');
|
||||||
|
const newFragments = newDetails.fragments;
|
||||||
|
for (let i = 0; i < newFragments.length; i++) {
|
||||||
|
newFragments[i].cc += ccOffset;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// if at least one fragment contains PTS info, recompute PTS information for all fragments
|
||||||
|
if (PTSFrag) {
|
||||||
|
updateFragPTSDTS(newDetails, PTSFrag, PTSFrag.startPTS, PTSFrag.endPTS, PTSFrag.startDTS, PTSFrag.endDTS);
|
||||||
|
} else {
|
||||||
|
// ensure that delta is within oldFragments range
|
||||||
|
// also adjust sliding in case delta is 0 (we could have old=[50-60] and new=old=[50-61])
|
||||||
|
// in that case we also need to adjust start offset of all fragments
|
||||||
|
adjustSliding(oldDetails, newDetails);
|
||||||
|
}
|
||||||
|
// if we are here, it means we have fragments overlapping between
|
||||||
|
// old and new level. reliable PTS info is thus relying on old level
|
||||||
|
newDetails.PTSKnown = oldDetails.PTSKnown;
|
||||||
|
}
|
||||||
|
|
||||||
|
export function mergeSubtitlePlaylists (oldPlaylist, newPlaylist, referenceStart = 0) {
|
||||||
|
let lastIndex = -1;
|
||||||
|
mapFragmentIntersection(oldPlaylist, newPlaylist, (oldFrag, newFrag, index) => {
|
||||||
|
newFrag.start = oldFrag.start;
|
||||||
|
lastIndex = index;
|
||||||
|
});
|
||||||
|
|
||||||
|
const frags = newPlaylist.fragments;
|
||||||
|
if (lastIndex < 0) {
|
||||||
|
frags.forEach(frag => {
|
||||||
|
frag.start += referenceStart;
|
||||||
|
});
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (let i = lastIndex + 1; i < frags.length; i++) {
|
||||||
|
frags[i].start = (frags[i - 1].start + frags[i - 1].duration);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
export function mapFragmentIntersection (oldPlaylist, newPlaylist, intersectionFn) {
|
||||||
|
if (!oldPlaylist || !newPlaylist) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
const start = Math.max(oldPlaylist.startSN, newPlaylist.startSN) - newPlaylist.startSN;
|
||||||
|
const end = Math.min(oldPlaylist.endSN, newPlaylist.endSN) - newPlaylist.startSN;
|
||||||
|
const delta = newPlaylist.startSN - oldPlaylist.startSN;
|
||||||
|
|
||||||
|
for (let i = start; i <= end; i++) {
|
||||||
|
const oldFrag = oldPlaylist.fragments[delta + i];
|
||||||
|
const newFrag = newPlaylist.fragments[i];
|
||||||
|
if (!oldFrag || !newFrag) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
intersectionFn(oldFrag, newFrag, i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
export function adjustSliding (oldPlaylist, newPlaylist) {
|
||||||
|
const delta = newPlaylist.startSN - oldPlaylist.startSN;
|
||||||
|
const oldFragments = oldPlaylist.fragments;
|
||||||
|
const newFragments = newPlaylist.fragments;
|
||||||
|
|
||||||
|
if (delta < 0 || delta > oldFragments.length) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
for (let i = 0; i < newFragments.length; i++) {
|
||||||
|
newFragments[i].start += oldFragments[delta].start;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
export function computeReloadInterval (currentPlaylist, newPlaylist, lastRequestTime) {
|
||||||
|
let reloadInterval = 1000 * (newPlaylist.averagetargetduration ? newPlaylist.averagetargetduration : newPlaylist.targetduration);
|
||||||
|
const minReloadInterval = reloadInterval / 2;
|
||||||
|
if (currentPlaylist && newPlaylist.endSN === currentPlaylist.endSN) {
|
||||||
|
// follow HLS Spec, If the client reloads a Playlist file and finds that it has not
|
||||||
|
// changed then it MUST wait for a period of one-half the target
|
||||||
|
// duration before retrying.
|
||||||
|
reloadInterval = minReloadInterval;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (lastRequestTime) {
|
||||||
|
reloadInterval = Math.max(minReloadInterval, reloadInterval - (window.performance.now() - lastRequestTime));
|
||||||
|
}
|
||||||
|
// in any case, don't reload more than half of target duration
|
||||||
|
return Math.round(reloadInterval);
|
||||||
|
}
|
||||||
|
|
@ -1,18 +1,22 @@
|
||||||
// see https://tools.ietf.org/html/rfc1808
|
// see https://tools.ietf.org/html/rfc1808
|
||||||
|
|
||||||
var URL_REGEX = /^((?:[a-zA-Z0-9+\-.]+:)?)(\/\/[^\/?#]*)?((?:[^\/\?#]*\/)*.*?)??(;.*?)?(\?.*?)?(#.*?)?$/;
|
/* jshint ignore:start */
|
||||||
var FIRST_SEGMENT_REGEX = /^([^\/?#]*)(.*)$/;
|
(function(root) {
|
||||||
var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
|
/* jshint ignore:end */
|
||||||
var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/).*?(?=\/)/g;
|
|
||||||
|
|
||||||
var URLToolkit = { // jshint ignore:line
|
var URL_REGEX = /^((?:[a-zA-Z0-9+\-.]+:)?)(\/\/[^\/?#]*)?((?:[^\/\?#]*\/)*.*?)??(;.*?)?(\?.*?)?(#.*?)?$/;
|
||||||
|
var FIRST_SEGMENT_REGEX = /^([^\/?#]*)(.*)$/;
|
||||||
|
var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
|
||||||
|
var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/).*?(?=\/)/g;
|
||||||
|
|
||||||
|
var URLToolkit = { // jshint ignore:line
|
||||||
// If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
|
// If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
|
||||||
// E.g
|
// E.g
|
||||||
// With opts.alwaysNormalize = false (default, spec compliant)
|
// With opts.alwaysNormalize = false (default, spec compliant)
|
||||||
// http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
|
// http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
|
||||||
// With opts.alwaysNormalize = true (not spec compliant)
|
// With opts.alwaysNormalize = true (not spec compliant)
|
||||||
// http://a.com/b/cd + /e/f/../g => http://a.com/e/g
|
// http://a.com/b/cd + /e/f/../g => http://a.com/e/g
|
||||||
buildAbsoluteURL: function (baseURL, relativeURL, opts) {
|
buildAbsoluteURL: function(baseURL, relativeURL, opts) {
|
||||||
opts = opts || {};
|
opts = opts || {};
|
||||||
// remove any remaining space and CRLF
|
// remove any remaining space and CRLF
|
||||||
baseURL = baseURL.trim();
|
baseURL = baseURL.trim();
|
||||||
|
|
@ -108,7 +112,7 @@ var URLToolkit = { // jshint ignore:line
|
||||||
}
|
}
|
||||||
return URLToolkit.buildURLFromParts(builtParts);
|
return URLToolkit.buildURLFromParts(builtParts);
|
||||||
},
|
},
|
||||||
parseURL: function (url) {
|
parseURL: function(url) {
|
||||||
var parts = URL_REGEX.exec(url);
|
var parts = URL_REGEX.exec(url);
|
||||||
if (!parts) {
|
if (!parts) {
|
||||||
return null;
|
return null;
|
||||||
|
|
@ -122,7 +126,7 @@ var URLToolkit = { // jshint ignore:line
|
||||||
fragment: parts[6] || ''
|
fragment: parts[6] || ''
|
||||||
};
|
};
|
||||||
},
|
},
|
||||||
normalizePath: function (path) {
|
normalizePath: function(path) {
|
||||||
// The following operations are
|
// The following operations are
|
||||||
// then applied, in order, to the new path:
|
// then applied, in order, to the new path:
|
||||||
// 6a) All occurrences of "./", where "." is a complete path
|
// 6a) All occurrences of "./", where "." is a complete path
|
||||||
|
|
@ -138,12 +142,22 @@ var URLToolkit = { // jshint ignore:line
|
||||||
// 6d) If the path ends with "<segment>/..", where <segment> is a
|
// 6d) If the path ends with "<segment>/..", where <segment> is a
|
||||||
// complete path segment not equal to "..", that
|
// complete path segment not equal to "..", that
|
||||||
// "<segment>/.." is removed.
|
// "<segment>/.." is removed.
|
||||||
while (path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length) { } // jshint ignore:line
|
while (path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length) {} // jshint ignore:line
|
||||||
return path.split('').reverse().join('');
|
return path.split('').reverse().join('');
|
||||||
},
|
},
|
||||||
buildURLFromParts: function (parts) {
|
buildURLFromParts: function(parts) {
|
||||||
return parts.scheme + parts.netLoc + parts.path + parts.params + parts.query + parts.fragment;
|
return parts.scheme + parts.netLoc + parts.path + parts.params + parts.query + parts.fragment;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
export default URLToolkit;
|
/* jshint ignore:start */
|
||||||
|
if(typeof exports === 'object' && typeof module === 'object')
|
||||||
|
module.exports = URLToolkit;
|
||||||
|
else if(typeof define === 'function' && define.amd)
|
||||||
|
define([], function() { return URLToolkit; });
|
||||||
|
else if(typeof exports === 'object')
|
||||||
|
exports["URLToolkit"] = URLToolkit;
|
||||||
|
else
|
||||||
|
root["URLToolkit"] = URLToolkit;
|
||||||
|
})(this);
|
||||||
|
/* jshint ignore:end */
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue