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

@@ -49,6 +49,12 @@ export const updateSegment = (a, b) => {
     }
   }
 
+  // set skipped to false for segments that have
+  // had information merged into them.
+  if (!a.skipped && b.skipped) {
+    result.skipped = false;
+  }
+
   return result;
 };
 
@@ -69,15 +75,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 i = offset; i < length; i++) {
-    const newIndex = i - offset;
+  for (let newIndex = 0; newIndex < newSegments.length; newIndex++) {
+    const oldSegment = oldSegments[newIndex + offset];
+    const newSegment = newSegments[newIndex];
 
-    result[newIndex] = updateSegment(oldSegments[i], result[newIndex]);
+    if (oldSegment) {
+      currentMap = oldSegment.map || currentMap;
+
+      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 +136,22 @@ export const resolveSegmentUris = (segment, baseUri) => {
 
 const getAllSegments = function(media) {
   const segments = media.segments || [];
+  const preloadSegment = 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
+    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;
 
-  // 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);
+    segments.push(preloadSegment);
   }
 
   return segments;
@@ -146,28 +177,36 @@ 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);
 
   // 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 +219,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 +294,48 @@ 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.canSkipUntil) {
+          query.push('_HLS_skip=' + (media.serverControl.canSkipDateranges ? 'v2' : 'YES'));
+        }
 
+        if (media.serverControl && media.serverControl.canBlockReload) {
+          const preloadSegment = media.preloadSegment;
+          // next msn will be for preload segment, if we have a preload segment.
+          let nextMSN = media.mediaSequence + media.segments.length;
+          let nextPart;
+
+          if (preloadSegment && preloadSegment.parts && preloadSegment.parts.length) {
+            nextPart = preloadSegment.parts.length + 1;
+            nextMSN--;
+          } else {
+            nextMSN++;
+          }
+
+          query.push(`_HLS_msn=${nextMSN}`);
+
+          if (nextPart) {
+            query.push(`_HLS_part=${nextPart}`);
+          }
+        }
+
+        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 +380,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 +408,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 +715,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);
@@ -677,7 +758,7 @@ export default class PlaylistLoader extends EventTarget {
       manifest.playlists.forEach((playlist) => {
         playlist.segments = getAllSegments(playlist);
 
-        playlist.segments.forEach((segment) => {
+        playlist.segments.forEach(function(segment) {
           resolveSegmentUris(segment, playlist.resolvedUri);
         });
       });

src/playlist.js

@@ -29,6 +29,12 @@ 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 || [];
+};
+
 /**
  * Get the number of seconds to delay from the end of a
  * live playlist.
@@ -47,8 +53,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) {