feat: Use ll-hls query directives and support skipping segments

src/manifest.js

@@ -2,6 +2,7 @@ import videojs from 'video.js';
 import window from 'global/window';
 import { Parser as M3u8Parser } from 'm3u8-parser';
 import { resolveUrl } from './resolve-url';
+import { getLastParts } from './playlist.js';
 
 const { log } = videojs;
 
@@ -92,6 +93,21 @@ export const parseManifest = ({
     manifest.targetDuration = targetDuration;
   }
 
+  const parts = getLastParts(manifest);
+
+  if (parts.length && !manifest.partTargetDuration) {
+    let partTargetDuration = (manifest.targetDuration / parts.length);
+
+    if (manifest.segments && manifest.segments.length) {
+      partTargetDuration = parts.reduce((acc, p) => Math.max(acc, p.duration), 0);
+    }
+
+    if (onwarn) {
+      onwarn(`manifest has no partTargetDuration defaulting to ${partTargetDuration}`);
+    }
+    manifest.partTargetDuration = partTargetDuration;
+  }
+
   return manifest;
 };
 

src/playlist-loader.js

@@ -15,6 +15,7 @@ import {
   masterForMedia,
   setupMediaPlaylist
 } from './manifest';
+import {getKnownPartCount} from './playlist.js';
 
 const { mergeOptions, EventTarget } = videojs;
 
@@ -34,6 +35,12 @@ export const updateSegment = (a, b) => {
 
   const result = mergeOptions(a, b);
 
+  // if only the old segment has preload hints
+  // and the new one does not, remove preload hints.
+  if (a.preloadHints && !b.preloadHints) {
+    delete result.preloadHints;
+  }
+
   // if only the old segment has parts
   // then the parts are no longer valid
   if (a.parts && !b.parts) {
@@ -49,6 +56,18 @@ export const updateSegment = (a, b) => {
     }
   }
 
+  // set skipped to false for segments that have
+  // have had information merged from the old segment.
+  if (!a.skipped && b.skipped) {
+    result.skipped = false;
+  }
+
+  // set preload to false for segments that have
+  // had information added in the new segment.
+  if (a.preload && !b.preload) {
+    result.preload = false;
+  }
+
   return result;
 };
 
@@ -69,15 +88,30 @@ export const updateSegment = (a, b) => {
  */
 export const updateSegments = (original, update, offset) => {
   const oldSegments = original.slice();
-  const result = update.slice();
+  const newSegments = update.slice();
 
   offset = offset || 0;
-  const length = Math.min(original.length, update.length + offset);
+  const result = [];
+
+  let currentMap;
+
+  for (let newIndex = 0; newIndex < newSegments.length; newIndex++) {
+    const oldSegment = oldSegments[newIndex + offset];
+    const newSegment = newSegments[newIndex];
 
-  for (let i = offset; i < length; i++) {
-    const newIndex = i - offset;
+    if (oldSegment) {
+      currentMap = oldSegment.map || currentMap;
 
-    result[newIndex] = updateSegment(oldSegments[i], result[newIndex]);
+      result.push(updateSegment(oldSegment, newSegment));
+    } else {
+      // carry over map to new segment if it is missing
+      if (currentMap && !newSegment.map) {
+        newSegment.map = currentMap;
+      }
+
+      result.push(newSegment);
+
+    }
   }
   return result;
 };
@@ -115,12 +149,27 @@ export const resolveSegmentUris = (segment, baseUri) => {
 
 const getAllSegments = function(media) {
   const segments = media.segments || [];
+  const preloadSegment = media.preloadSegment;
 
   // 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);
+  if (preloadSegment && preloadSegment.parts && preloadSegment.parts.length) {
+    // if preloadHints has a MAP that means that the
+    // init segment is going to change. We cannot use any of the parts
+    // from this preload segment.
+    if (preloadSegment.preloadHints) {
+      for (let i = 0; i < preloadSegment.preloadHints.length; i++) {
+        if (preloadSegment.preloadHints[i].type === 'MAP') {
+          return segments;
+        }
+      }
+    }
+    // set the duration for our preload segment to target duration.
+    preloadSegment.duration = media.targetDuration;
+    preloadSegment.preload = true;
+
+    segments.push(preloadSegment);
   }
 
   return segments;
@@ -146,28 +195,41 @@ export const isPlaylistUnchanged = (a, b) => a === b ||
   * master playlist with the updated media playlist merged in, or
   * null if the merge produced no change.
   */
-export const updateMaster = (master, media, unchangedCheck = isPlaylistUnchanged) => {
+export const updateMaster = (master, newMedia, unchangedCheck = isPlaylistUnchanged) => {
   const result = mergeOptions(master, {});
-  const playlist = result.playlists[media.id];
+  const oldMedia = result.playlists[newMedia.id];
 
-  if (!playlist) {
+  if (!oldMedia) {
     return null;
   }
 
-  if (unchangedCheck(playlist, media)) {
+  if (unchangedCheck(oldMedia, newMedia)) {
     return null;
   }
 
-  const mergedPlaylist = mergeOptions(playlist, media);
+  newMedia.segments = getAllSegments(newMedia);
 
-  media.segments = getAllSegments(media);
+  const mergedPlaylist = mergeOptions(oldMedia, newMedia);
+
+  // always use the new medias preload segment.
+  if (mergedPlaylist.preloadSegment && !newMedia.preloadSegment) {
+    delete mergedPlaylist.preloadSegment;
+  }
 
   // if the update could overlap existing segment information, merge the two segment lists
-  if (playlist.segments) {
+  if (oldMedia.segments) {
+    if (newMedia.skip) {
+      newMedia.segments = newMedia.segments || [];
+      // add back in objects for skipped segments, so that we merge
+      // old properties into this new segment
+      for (let i = 0; i < newMedia.skip.skippedSegments; i++) {
+        newMedia.segments.unshift({skipped: true});
+      }
+    }
     mergedPlaylist.segments = updateSegments(
-      playlist.segments,
-      media.segments,
-      media.mediaSequence - playlist.mediaSequence
+      oldMedia.segments,
+      newMedia.segments,
+      newMedia.mediaSequence - oldMedia.mediaSequence
     );
   }
 
@@ -180,13 +242,13 @@ export const updateMaster = (master, media, unchangedCheck = isPlaylistUnchanged
   // that is referenced by index, and one by URI. The index reference may no longer be
   // necessary.
   for (let i = 0; i < result.playlists.length; i++) {
-    if (result.playlists[i].id === media.id) {
+    if (result.playlists[i].id === newMedia.id) {
       result.playlists[i] = mergedPlaylist;
     }
   }
-  result.playlists[media.id] = mergedPlaylist;
+  result.playlists[newMedia.id] = mergedPlaylist;
   // URI reference added for backwards compatibility
-  result.playlists[media.uri] = mergedPlaylist;
+  result.playlists[newMedia.uri] = mergedPlaylist;
 
   return result;
 };
@@ -255,11 +317,60 @@ export default class PlaylistLoader extends EventTarget {
         // only refresh the media playlist if no other activity is going on
         return;
       }
+      const media = this.media();
+
+      let uri = resolveUrl(this.master.uri, media.uri);
+
+      if (this.experimentalLLHLS) {
+        const query = [];
+
+        if (media.serverControl && media.serverControl.canBlockReload) {
+          const {preloadSegment} = media;
+          // next msn is a zero based value, length is not.
+          let nextMSN = media.mediaSequence + media.segments.length;
+
+          if (preloadSegment) {
+            const parts = preloadSegment.parts || [];
+            // _HLS_part is a zero based index
+            const nextPart = getKnownPartCount(media) - 1;
+
+            // if nextPart is > -1 and not equal to just the
+            // length of parts, then we know we had part preload hints
+            // and we need to add the _HLS_part= query
+            if (nextPart > -1 && nextPart !== (parts.length - 1)) {
+              // add existing parts to our preload hints
+              query.push(`_HLS_part=${nextPart}`);
+            }
+
+            // if we are requesting a nextPart or preload segment was added
+            // to our segment list. We are requesting a part of the preload segment
+            // or the full preload segment. Either way we need to go down by 1
+            // in nextMSN
+            if (nextPart > -1 || parts.length) {
+              nextMSN--;
+            }
+          }
+
+          // add _HLS_msn= infront of any _HLS_part query
+          query.unshift(`_HLS_msn=${nextMSN}`);
+        }
+
+        if (media.serverControl && media.serverControl.canSkipUntil) {
+          // add _HLS_skip= infront of all other queries.
+          query.unshift('_HLS_skip=' + (media.serverControl.canSkipDateranges ? 'v2' : 'YES'));
+        }
 
+        query.forEach(function(str, i) {
+          const symbol = i === 0 ? '?' : '&';
+
+          uri += `${symbol}${str}`;
+        });
+
+      }
       this.state = 'HAVE_CURRENT_METADATA';
 
       this.request = this.vhs_.xhr({
-        uri: resolveUrl(this.master.uri, this.media().uri),
+        uri,
         withCredentials: this.withCredentials
       }, (error, req) => {
         // disposed
@@ -304,6 +415,17 @@ export default class PlaylistLoader extends EventTarget {
     this.trigger('error');
   }
 
+  parseManifest_({url, manifestString}) {
+    return parseManifest({
+      onwarn: ({message}) => this.logger_(`m3u8-parser warn for ${url}: ${message}`),
+      oninfo: ({message}) => this.logger_(`m3u8-parser info for ${url}: ${message}`),
+      manifestString,
+      customTagParsers: this.customTagParsers,
+      customTagMappers: this.customTagMappers,
+      experimentalLLHLS: this.experimentalLLHLS
+    });
+  }
+
   /**
    * Update the playlist loader's state in response to a new or updated playlist.
    *
@@ -321,13 +443,9 @@ export default class PlaylistLoader extends EventTarget {
     this.request = null;
     this.state = 'HAVE_METADATA';
 
-    const playlist = playlistObject || parseManifest({
-      onwarn: ({message}) => this.logger_(`m3u8-parser warn for ${id}: ${message}`),
-      oninfo: ({message}) => this.logger_(`m3u8-parser info for ${id}: ${message}`),
-      manifestString: playlistString,
-      customTagParsers: this.customTagParsers,
-      customTagMappers: this.customTagMappers,
-      experimentalLLHLS: this.experimentalLLHLS
+    const playlist = playlistObject || this.parseManifest_({
+      url,
+      manifestString: playlistString
     });
 
     playlist.lastRequest = Date.now();
@@ -632,11 +750,9 @@ export default class PlaylistLoader extends EventTarget {
 
       this.src = resolveManifestRedirect(this.handleManifestRedirects, this.src, req);
 
-      const manifest = parseManifest({
+      const manifest = this.parseManifest_({
         manifestString: req.responseText,
-        customTagParsers: this.customTagParsers,
-        customTagMappers: this.customTagMappers,
-        experimentalLLHLS: this.experimentalLLHLS
+        url: this.src
       });
 
       this.setupInitialPlaylist(manifest);

src/playlist.js

@@ -29,6 +29,24 @@ const getPartsAndSegments = (playlist) => (playlist.segments || []).reduce((acc,
   return acc;
 }, []);
 
+export const getLastParts = (media) => {
+  const lastSegment = media.segments && media.segments.length && media.segments[media.segments.length - 1];
+
+  return lastSegment && lastSegment.parts || [];
+};
+
+export const getKnownPartCount = ({preloadSegment}) => {
+  if (!preloadSegment) {
+    return;
+  }
+  const {parts, preloadHints} = preloadSegment;
+  let partCount = (preloadHints || [])
+    .reduce((acc, hint) => acc + (hint.type === 'PART' ? 1 : 0), 0);
+
+  partCount += (parts && parts.length) ? parts.length : 0;
+
+  return partCount;
+};
 /**
  * Get the number of seconds to delay from the end of a
  * live playlist.
@@ -47,8 +65,7 @@ export const liveEdgeDelay = (master, media) => {
     return master.suggestedPresentationDelay;
   }
 
-  const lastSegment = media.segments && media.segments.length && media.segments[media.segments.length - 1];
-  const hasParts = lastSegment && lastSegment.parts && lastSegment.parts.length;
+  const hasParts = getLastParts(media).length > 0;
 
   // look for "part" delays from ll-hls first
   if (hasParts && media.serverControl && media.serverControl.partHoldBack) {

src/segment-loader.js

@@ -24,6 +24,7 @@ import shallowEqual from './util/shallow-equal.js';
 import { QUOTA_EXCEEDED_ERR } from './error-codes';
 import { timeRangesToArray } from './ranges';
 import {lastBufferedEnd} from './ranges.js';
+import {getKnownPartCount} from './playlist.js';
 
 /**
  * The segment loader has no recourse except to fetch a segment in the
@@ -135,11 +136,7 @@ const segmentInfoString = (segmentInfo) => {
   const {
     startOfSegment,
     duration,
-    segment: {
-      start,
-      end,
-      parts
-    },
+    segment,
     playlist: {
       mediaSequence: seq,
       id,
@@ -158,11 +155,13 @@ const segmentInfoString = (segmentInfo) => {
   } else if (segmentInfo.isSyncRequest) {
     selection = 'getSyncSegmentCandidate (isSyncRequest)';
   }
-
+  const {start, end} = segment;
+  const hasPartIndex = typeof partIndex === 'number';
   const name = segmentInfo.segment.uri ? 'segment' : 'pre-segment';
+  const totalParts = hasPartIndex ? getKnownPartCount({preloadSegment: segment}) - 1 : 0;
 
   return `${name} [${index}/${segmentLen}]` +
-    (partIndex ? ` part [${partIndex}/${parts.length - 1}]` : '') +
+    (hasPartIndex ? ` part [${partIndex}/${totalParts}]` : '') +
     ` mediaSequenceNumber [${seq}/${seq + segmentLen}]` +
     ` start/end [${start} => ${end}]` +
     ` startOfSegment [${startOfSegment}]` +