mirror of https://bitbucket.org/ausocean/av.git
Merge branch 'master' into m3u-packages
This commit is contained in:
Trek H
commit
be0e2c81b8
|
|
@ -328,4 +328,9 @@ EventEmitter.prefixed = prefix;
|
|||
//
|
||||
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,5 +1,9 @@
|
|||
// see https://tools.ietf.org/html/rfc1808
|
||||
|
||||
/* jshint ignore:start */
|
||||
(function(root) {
|
||||
/* jshint ignore:end */
|
||||
|
||||
var URL_REGEX = /^((?:[a-zA-Z0-9+\-.]+:)?)(\/\/[^\/?#]*)?((?:[^\/\?#]*\/)*.*?)??(;.*?)?(\?.*?)?(#.*?)?$/;
|
||||
var FIRST_SEGMENT_REGEX = /^([^\/?#]*)(.*)$/;
|
||||
var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
|
||||
|
|
@ -146,4 +150,14 @@ var URLToolkit = { // jshint ignore:line
|
|||
}
|
||||
};
|
||||
|
||||
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