feat: use serverControl and preloadSegment llhls features behind a flag

src/master-playlist-controller.js

@@ -1303,7 +1303,7 @@ export class MasterPlaylistController extends videojs.EventTarget {
     const mainSeekable = Vhs.Playlist.seekable(
       media,
       expired,
-      Vhs.Playlist.getHoldBack(master, media)
+      Vhs.Playlist.liveEdgeDelay(master, media)
     );
 
     if (mainSeekable.length === 0) {
@@ -1321,7 +1321,7 @@ export class MasterPlaylistController extends videojs.EventTarget {
       audioSeekable = Vhs.Playlist.seekable(
         media,
         expired,
-        Vhs.Playlist.getHoldBack(master, media)
+        Vhs.Playlist.liveEdgeDelay(master, media)
       );
 
       if (audioSeekable.length === 0) {

src/playlist-loader.js

@@ -113,6 +113,19 @@ export const resolveSegmentUris = (segment, baseUri) => {
   }
 };
 
+const getAllSegments = function(media) {
+  const segments = media.segments || [];
+
+  // a preloadSegment with only preloadHints is not currently
+  // a usable segment, only include a preloadSegment that has
+  // parts.
+  if (media.preloadSegment && media.preloadSegment.parts) {
+    segments.push(media.preloadSegment);
+  }
+
+  return segments;
+};
+
 // consider the playlist unchanged if the playlist object is the same or
 // the number of segments is equal, the media sequence number is unchanged,
 // and this playlist hasn't become the end of the playlist
@@ -147,14 +160,7 @@ export const updateMaster = (master, media, unchangedCheck = isPlaylistUnchanged
 
   const mergedPlaylist = mergeOptions(playlist, media);
 
-  media.segments = media.segments || [];
-
-  // a preloadSegment with only preloadHints is not currently
-  // a usable segment, only include a preloadSegment that has
-  // parts.
-  if (media.preloadSegment && media.preloadSegment.parts) {
-    media.segments.push(media.preloadSegment);
-  }
+  media.segments = getAllSegments(media);
 
   // if the update could overlap existing segment information, merge the two segment lists
   if (playlist.segments) {
@@ -197,7 +203,7 @@ export const updateMaster = (master, media, unchangedCheck = isPlaylistUnchanged
  */
 export const refreshDelay = (media, update) => {
   const lastSegment = media.segments[media.segments.length - 1];
-  const lastPart = lastSegment && lastSegment.parts && lastSegment.parts[lastSegment.parts - 1];
+  const lastPart = lastSegment && lastSegment.parts && lastSegment.parts[lastSegment.parts.length - 1];
   const lastDuration = lastPart && lastPart.duration || lastSegment && lastSegment.duration;
 
   if (update && lastDuration) {
@@ -669,11 +675,7 @@ export default class PlaylistLoader extends EventTarget {
       // then resolve URIs in advance, as they are usually done after a playlist request,
       // which may not happen if the playlist is resolved.
       manifest.playlists.forEach((playlist) => {
-        playlist.segments = playlist.segments || [];
-
-        if (playlist.preloadSegment && playlist.preloadSegment.parts) {
-          playlist.segments.push(playlist.preloadSegment);
-        }
+        playlist.segments = getAllSegments(playlist);
 
         playlist.segments.forEach((segment) => {
           resolveSegmentUris(segment, playlist.resolvedUri);

src/playlist.js

@@ -17,7 +17,7 @@ const {createTimeRange} = videojs;
  *
  * @return {Array} The part/segment list.
  */
-const getPartSegments = (playlist) => (playlist.segments || []).reduce((acc, segment, si) => {
+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});
@@ -30,34 +30,39 @@ const getPartSegments = (playlist) => (playlist.segments || []).reduce((acc, seg
 }, []);
 
 /**
- * Get the number of seconds to hold back from the end of a
+ * 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 getHoldBack = (master, media) => {
+export const liveEdgeDelay = (master, media) => {
   if (media.endList) {
     return 0;
   }
 
-  const partSegments = getPartSegments(media);
-  const hasParts = partSegments.length &&
-    typeof partSegments[partSegments.length - 1].partIndex === 'number';
+  const partsAndSegments = getPartsAndSegments(media);
+  const hasParts = partsAndSegments.length &&
+    typeof partsAndSegments[partsAndSegments.length - 1].partIndex === 'number';
 
+  // get the last three part/segment durations
   let lastThreeDurations = 0;
 
-  if (partSegments.length >= 3) {
-    for (let i = 0; i < 3; i++) {
-      lastThreeDurations += partSegments[partSegments.length - 1 - i].duration;
+  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;
     }
   }
 
   // dash suggestedPresentationDelay trumps everything
   if (master && master.suggestedPresentationDelay) {
     return master.suggestedPresentationDelay;
-
   // look for "part" delays from ll-hls first
   } else if (hasParts && media.serverControl && media.serverControl.partHoldBack) {
     return media.serverControl.partHoldBack;
@@ -72,10 +77,13 @@ export const getHoldBack = (master, media) => {
   } else if (media.targetDuration) {
     // TODO: this should probably be targetDuration * 3
     // but we use this for backwards compatability.
-    const lastPartSegment = partSegments[partSegments.length - 1];
+    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;
   }
@@ -307,24 +315,24 @@ export const sumDurations = function(playlist, startIndex, endIndex) {
  * @function safeLiveIndex
  */
 export const safeLiveIndex = function(playlist, liveEdgePadding) {
-  const partSegments = getPartSegments(playlist);
+  const partsAndSegments = getPartsAndSegments(playlist);
 
-  if (!partSegments.length) {
+  if (!partsAndSegments.length) {
     return 0;
   }
 
   if (typeof liveEdgePadding !== 'number') {
-    liveEdgePadding = getHoldBack(null, playlist);
+    liveEdgePadding = liveEdgeDelay(null, playlist);
   }
 
-  let i = partSegments.length;
+  let i = partsAndSegments.length;
   let distanceFromEnd = 0;
 
   while (i--) {
-    distanceFromEnd += partSegments[i].duration;
+    distanceFromEnd += partsAndSegments[i].duration;
 
     if (distanceFromEnd >= liveEdgePadding) {
-      return partSegments[i].segmentIndex;
+      return partsAndSegments[i].segmentIndex;
     }
   }
 
@@ -420,15 +428,15 @@ export const getMediaInfoForTime = function(
   startTime
 ) {
 
-  const partSegments = getPartSegments(playlist);
+  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 = partSegments[i];
+        const segment = partsAndSegments[i];
 
         time += (segment.duration + TIME_FUDGE_FACTOR);
 
@@ -445,8 +453,8 @@ export const getMediaInfoForTime = function(
     // We were unable to find a good segment within the playlist
     // so select the first segment
     return {
-      mediaIndex: partSegments[0] && partSegments[0].segmentIndex || 0,
-      partIndex: partSegments[0] && partSegments[0].partIndex || null,
+      mediaIndex: partsAndSegments[0] && partsAndSegments[0].segmentIndex || 0,
+      partIndex: partsAndSegments[0] && partsAndSegments[0].partIndex || null,
       startTime: currentTime
     };
   }
@@ -459,7 +467,7 @@ export const getMediaInfoForTime = function(
       time -= playlist.targetDuration;
       if (time < 0) {
         return {
-          mediaIndex: partSegments[0].segmentIndex,
+          mediaIndex: partsAndSegments[0].segmentIndex,
           startTime: currentTime
         };
       }
@@ -469,8 +477,8 @@ 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 < partSegments.length; i++) {
-    const partSegment = partSegments[i];
+  for (let i = startIndex; i < partsAndSegments.length; i++) {
+    const partSegment = partsAndSegments[i];
 
     time -= partSegment.duration + TIME_FUDGE_FACTOR;
 
@@ -485,8 +493,8 @@ export const getMediaInfoForTime = function(
 
   // We are out of possible candidates so load the last one...
   return {
-    mediaIndex: partSegments[partSegments.length - 1].segmentIndex,
-    partIndex: partSegments[partSegments.length - 1].partIndex,
+    mediaIndex: partsAndSegments[partsAndSegments.length - 1].segmentIndex,
+    partIndex: partsAndSegments[partsAndSegments.length - 1].partIndex,
     startTime: currentTime
   };
 };
@@ -622,7 +630,7 @@ export const isLowestEnabledRendition = (master, media) => {
 
 // exports
 export default {
-  getHoldBack,
+  liveEdgeDelay,
   duration,
   seekable,
   safeLiveIndex,

src/segment-loader.js

@@ -112,7 +112,7 @@ const segmentInfoString = (segmentInfo) => {
   return [
     `${name} [${index}/${segments.length - 1}]`,
     (partIndex ? `part [${partIndex}/${parts.length - 1}]` : ''),
-    `msn [${seq}/${seq + segments.length - 1}]`,
+    `mediaSequenceNumber [${seq}/${seq + segments.length - 1}]`,
     `playlist [${id}]`,
     `start/end [${start} => ${end}]`,
     `timeline [${timeline}]`

test/playlist.test.js

@@ -575,7 +575,7 @@ QUnit.test('safeLiveIndex accounts for liveEdgePadding in simple case', function
 
   assert.equal(
     Playlist.safeLiveIndex(playlist, 0), 5,
-    'returns 6 when liveEdgePadding is 0 and duration is 6'
+    'returns 5 when liveEdgePadding is 0 and duration is 6'
   );
 });
 
@@ -651,11 +651,11 @@ QUnit.test('safeLiveIndex accounts for liveEdgePadding in non-simple case', func
 
   assert.equal(
     Playlist.safeLiveIndex(playlist, 0), 5,
-    'returns 6 when liveEdgePadding is 0'
+    'returns 5 when liveEdgePadding is 0'
   );
 });
 
-QUnit.test('getHoldBack works as expected', function(assert) {
+QUnit.test('liveEdgeDelay works as expected', function(assert) {
   const media = {
     endList: true,
     targetDuration: 5,
@@ -665,13 +665,17 @@ QUnit.test('getHoldBack works as expected', function(assert) {
       partHoldBack: 2
     },
     segments: [
-      {duration: 4},
       {duration: 3},
       {duration: 4, parts: [
         {duration: 1},
+        {duration: 0.5}
+      ]},
+      {duration: 3, parts: [
         {duration: 1},
+        {duration: 0.5}
+      ]},
+      {duration: 4, parts: [
         {duration: 1},
-        {duration: 0.5},
         {duration: 0.5}
       ]}
     ]
@@ -681,66 +685,80 @@ QUnit.test('getHoldBack works as expected', function(assert) {
   };
 
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     0,
     'returns 0 with endlist'
   );
 
   delete media.endList;
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     master.suggestedPresentationDelay,
     'uses suggestedPresentationDelay'
   );
 
   delete master.suggestedPresentationDelay;
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     media.serverControl.partHoldBack,
     'uses part hold back'
   );
 
   media.serverControl.partHoldBack = null;
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     media.partTargetDuration * 3,
     'uses part target duration * 3'
   );
 
   media.partTargetDuration = null;
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     2,
     'uses last three part durations'
   );
 
-  media.segments[media.segments.length - 1].parts = null;
+  media.segments = media.segments.map((s) => {
+    s.parts = null;
+    return s;
+  });
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     media.serverControl.holdBack,
     'uses hold back'
   );
 
   media.serverControl.holdBack = null;
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     (media.targetDuration * 2) + media.segments[media.segments.length - 1].duration,
     'uses (targetDuration * 2) + last segment duration'
   );
 
   media.targetDuration = null;
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     11,
     'uses last three segment durations'
   );
 
+  media.segments = media.segments.map((s) => {
+    s.duration = null;
+    return s;
+  });
+
+  assert.equal(
+    Playlist.liveEdgeDelay(master, media),
+    0,
+    'no segment durations live delay can be calculated'
+  );
+
   media.segments.length = 0;
 
   assert.equal(
-    Playlist.getHoldBack(master, media),
+    Playlist.liveEdgeDelay(master, media),
     0,
-    'no possible holdback can be calculated'
+    'no segments live delay can be calculated'
   );
 });