feat: use serverControl and preloadSegment llhls features behind a flag #1078
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -9,6 +9,96 @@ import {TIME_FUDGE_FACTOR} from './ranges.js'; | |
|
|
||
| const {createTimeRange} = videojs; | ||
|
|
||
| /** | ||
| * A function to get a combined list of parts and segments with durations | ||
| * and indexes. | ||
| * | ||
| * @param {Playlist} playlist the playlist to get the list for. | ||
| * | ||
| * @return {Array} The part/segment list. | ||
| */ | ||
| const getPartsAndSegments = (playlist) => (playlist.segments || []).reduce((acc, segment, si) => { | ||
| if (segment.parts) { | ||
| segment.parts.forEach(function(part, pi) { | ||
| acc.push({duration: part.duration, segmentIndex: si, partIndex: pi}); | ||
|
|
||
brandonocasey marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| }); | ||
| } else { | ||
| acc.push({duration: segment.duration, segmentIndex: si, partIndex: null}); | ||
| } | ||
| return acc; | ||
| }, []); | ||
|
|
||
| const sumLastThreeDurations = function(partsAndSegments) { | ||
| // get the last three part/segment durations | ||
| let lastThreeDurations = 0; | ||
|
|
||
| if (partsAndSegments.length >= 3) { | ||
| for (let i = partsAndSegments.length - 1; i > partsAndSegments.length - 4; i--) { | ||
| // segment missing a duration, we cannot calculate | ||
| if (!partsAndSegments[i].duration) { | ||
| lastThreeDurations = 0; | ||
| break; | ||
| } | ||
| lastThreeDurations += partsAndSegments[i].duration; | ||
| } | ||
| } | ||
|
|
||
| return lastThreeDurations; | ||
| }; | ||
|
|
||
| /** | ||
| * Get the number of seconds to delay from the end of a | ||
| * live playlist. | ||
| * | ||
| * @param {Playlist} master the master playlist | ||
| * @param {Playlist} media the media playlist | ||
| * @return {number} the hold back in seconds. | ||
| */ | ||
| export const liveEdgeDelay = (master, media) => { | ||
| if (media.endList) { | ||
| return 0; | ||
| } | ||
|
|
||
| const partsAndSegments = getPartsAndSegments(media); | ||
| const hasParts = partsAndSegments.length && | ||
| typeof partsAndSegments[partsAndSegments.length - 1].partIndex === 'number'; | ||
| // by default we use the last three durations of segments if | ||
| // part target duration or target duration isn't found. | ||
| // see: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-4.4.3.8 | ||
|
There was a problem hiding this comment. I may be missing something, but I don't think that section of the spec, if referring to There was a problem hiding this comment. Yes we use three segment durations in case target durations are not available for whatever reason. There was a problem hiding this comment. I'm wondering if it's worth it to add the logic for this here if those are required attributes. It adds logic to the code that we shouldn't really encounter, and if we were to, then it's something that should be resolved by the creator of the stream, since target duration is always required (https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-4.4.3.1) and part target duration is required when parts are used (https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-4.4.3.7). I think if we're trying to account for missing target durations we should do that at a higher level, when we first parse the manifest. It would help to simplify the code. There was a problem hiding this comment. ok I will remove the last three durations logic. There was a problem hiding this comment. What about just default to 10s target duration in case somehow it isn't set or whatever? While I agree that bad streams are bad, we should still try to play as much as possible and having a default, if bad value, is worth it. Plus, it should make things simpler than trying to figure out segment duration and using that for target duation. There was a problem hiding this comment. I think having a sort of default may be appropriate (along with a warning). We should probably add it at the point where we first parse the stream (i.e., in the loaders).
brandonocasey marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| const lastThreeDurations = sumLastThreeDurations(partsAndSegments); | ||
|
|
||
| // dash suggestedPresentationDelay trumps everything | ||
| if (master && master.suggestedPresentationDelay) { | ||
| return master.suggestedPresentationDelay; | ||
|
Comment on lines
+44
to
+46
There was a problem hiding this comment. Might be worth pulling this up to short circuit the rest of the function. |
||
| // look for "part" delays from ll-hls first | ||
| } else if (hasParts && media.serverControl && media.serverControl.partHoldBack) { | ||
| return media.serverControl.partHoldBack; | ||
|
There was a problem hiding this comment. Same with this, might be easier to read if exiting before going through other logic and calculations. |
||
| } else if (hasParts && media.partTargetDuration) { | ||
| return media.partTargetDuration * 3; | ||
| } else if (hasParts && lastThreeDurations) { | ||
| return lastThreeDurations; | ||
|
|
||
| // finally look for full segment delays | ||
| } else if (media.serverControl && media.serverControl.holdBack) { | ||
| return media.serverControl.holdBack; | ||
| } else if (media.targetDuration) { | ||
brandonocasey marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| // TODO: this should probably be targetDuration * 3 | ||
| // but we use this for backwards compatability. | ||
|
There was a problem hiding this comment. Probably worth adding to next major to change this. |
||
| const lastPartSegment = partsAndSegments[partsAndSegments.length - 1]; | ||
| const lastPartDuration = lastPartSegment && lastPartSegment.duration || media.targetDuration; | ||
|
|
||
| return lastPartDuration + media.targetDuration * 2; | ||
| // we shouldn't ever end up using lastThreeDurations as targetDuration | ||
| // is usually required, but if we somehow get here, with a missing | ||
| // targetDuration we should handle it | ||
| } else if (lastThreeDurations) { | ||
| return lastThreeDurations; | ||
| } | ||
|
|
||
| return 0; | ||
| }; | ||
|
|
||
| /** | ||
| * walk backward until we find a duration we can use | ||
| * or return a failure | ||
|
|
@@ -233,31 +323,29 @@ export const sumDurations = function(playlist, startIndex, endIndex) { | |
| * @function safeLiveIndex | ||
| */ | ||
| export const safeLiveIndex = function(playlist, liveEdgePadding) { | ||
| const partsAndSegments = getPartsAndSegments(playlist); | ||
|
|
||
| if (!partsAndSegments.length) { | ||
| return 0; | ||
| } | ||
|
|
||
| if (typeof liveEdgePadding !== 'number') { | ||
| liveEdgePadding = liveEdgeDelay(null, playlist); | ||
| } | ||
|
|
||
| let i = partsAndSegments.length; | ||
| let distanceFromEnd = 0; | ||
|
|
||
| while (i--) { | ||
| distanceFromEnd += partsAndSegments[i].duration; | ||
|
|
||
| if (distanceFromEnd >= liveEdgePadding) { | ||
| return partsAndSegments[i].segmentIndex; | ||
| } | ||
| } | ||
|
|
||
| // there is nowhere in the playlist that is a safe distance from live. | ||
| return 0; | ||
| }; | ||
|
|
||
| /** | ||
|
|
@@ -347,31 +435,34 @@ export const getMediaInfoForTime = function( | |
| startIndex, | ||
| startTime | ||
| ) { | ||
|
|
||
| const partsAndSegments = getPartsAndSegments(playlist); | ||
| let time = currentTime - startTime; | ||
|
|
||
| if (time < 0) { | ||
| // Walk backward from startIndex in the playlist, adding durations | ||
| // until we find a segment that contains `time` and return it | ||
| if (startIndex > 0) { | ||
| for (let i = startIndex - 1; i >= 0; i--) { | ||
| const segment = partsAndSegments[i]; | ||
|
|
||
| time += (segment.duration + TIME_FUDGE_FACTOR); | ||
|
|
||
| if (time > 0) { | ||
| return { | ||
| mediaIndex: segment.segmentIndex, | ||
| startTime: startTime - sumDurations(playlist, startIndex, segment.segmentIndex), | ||
| partIndex: segment.partIndex | ||
| }; | ||
| } | ||
| } | ||
| } | ||
|
|
||
| // We were unable to find a good segment within the playlist | ||
| // so select the first segment | ||
| return { | ||
| mediaIndex: partsAndSegments[0] && partsAndSegments[0].segmentIndex || 0, | ||
| partIndex: partsAndSegments[0] && partsAndSegments[0].partIndex || null, | ||
| startTime: currentTime | ||
| }; | ||
| } | ||
|
|
@@ -380,11 +471,11 @@ export const getMediaInfoForTime = function( | |
| // adding target durations. If we "run out of time" before getting to | ||
| // the first segment, return the first segment | ||
| if (startIndex < 0) { | ||
| for (let i = startIndex; i < 0; i++) { | ||
| time -= playlist.targetDuration; | ||
| if (time < 0) { | ||
| return { | ||
| mediaIndex: partsAndSegments[0].segmentIndex, | ||
| startTime: currentTime | ||
| }; | ||
| } | ||
|
|
@@ -394,20 +485,24 @@ export const getMediaInfoForTime = function( | |
|
|
||
| // Walk forward from startIndex in the playlist, subtracting durations | ||
| // until we find a segment that contains `time` and return it | ||
| for (let i = startIndex; i < partsAndSegments.length; i++) { | ||
| const partSegment = partsAndSegments[i]; | ||
|
|
||
| time -= partSegment.duration + TIME_FUDGE_FACTOR; | ||
|
|
||
| if (time < 0) { | ||
| return { | ||
| mediaIndex: partSegment.segmentIndex, | ||
| startTime: startTime + sumDurations(playlist, startIndex, partSegment.segmentIndex), | ||
| partIndex: partSegment.partIndex | ||
| }; | ||
| } | ||
| } | ||
|
|
||
| // We are out of possible candidates so load the last one... | ||
| return { | ||
| mediaIndex: partsAndSegments[partsAndSegments.length - 1].segmentIndex, | ||
| partIndex: partsAndSegments[partsAndSegments.length - 1].partIndex, | ||
| startTime: currentTime | ||
| }; | ||
| }; | ||
|
|
@@ -543,6 +638,7 @@ export const isLowestEnabledRendition = (master, media) => { | |
|
|
||
| // exports | ||
| export default { | ||
| liveEdgeDelay, | ||
| duration, | ||
| seekable, | ||
| safeLiveIndex, | ||
|
|
||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
use partTargetDuration or targetDuration