hls.js 1.5.17 → 1.5.19

package/dist/hls.js

@@ -552,7 +552,7 @@
       // Some browsers don't allow to use bind on console object anyway
       // fallback to default if needed
       try {
-        exportedLogger.log("Debug logs enabled for \"" + id + "\" in hls.js version " + "1.5.17");
+        exportedLogger.log("Debug logs enabled for \"" + id + "\" in hls.js version " + "1.5.19");
       } catch (e) {
         exportedLogger = fakeLogger;
       }
@@ -1378,6 +1378,27 @@
     };
     return [baseConfig];
   }
+  function parsePlayReadyWRM(keyBytes) {
+    var keyBytesUtf16 = new Uint16Array(keyBytes.buffer, keyBytes.byteOffset, keyBytes.byteLength / 2);
+    var keyByteStr = String.fromCharCode.apply(null, Array.from(keyBytesUtf16));
+
+    // Parse Playready WRMHeader XML
+    var xmlKeyBytes = keyByteStr.substring(keyByteStr.indexOf('<'), keyByteStr.length);
+    var parser = new DOMParser();
+    var xmlDoc = parser.parseFromString(xmlKeyBytes, 'text/xml');
+    var keyData = xmlDoc.getElementsByTagName('KID')[0];
+    if (keyData) {
+      var keyId = keyData.childNodes[0] ? keyData.childNodes[0].nodeValue : keyData.getAttribute('VALUE');
+      if (keyId) {
+        var keyIdArray = base64Decode(keyId).subarray(0, 16);
+        // KID value in PRO is a base64-encoded little endian GUID interpretation of UUID
+        // KID value in ‘tenc’ is a big endian UUID GUID interpretation of UUID
+        changeEndianness(keyIdArray);
+        return keyIdArray;
+      }
+    }
+    return null;
+  }
 
   function sliceUint8(array, start, end) {
     // @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
@@ -3011,6 +3032,8 @@
       if (keyBytes) {
         switch (this.keyFormat) {
           case KeySystemFormats.WIDEVINE:
+            // Setting `pssh` on this LevelKey/DecryptData allows HLS.js to generate a session using
+            // the playlist-key before the "encrypted" event. (Comment out to only use "encrypted" path.)
             this.pssh = keyBytes;
             // In case of widevine keyID is embedded in PSSH box. Read Key ID.
             if (keyBytes.length >= 22) {
@@ -3020,25 +3043,11 @@
           case KeySystemFormats.PLAYREADY:
             {
               var PlayReadyKeySystemUUID = new Uint8Array([0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86, 0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95]);
+
+              // Setting `pssh` on this LevelKey/DecryptData allows HLS.js to generate a session using
+              // the playlist-key before the "encrypted" event. (Comment out to only use "encrypted" path.)
               this.pssh = mp4pssh(PlayReadyKeySystemUUID, null, keyBytes);
-              var keyBytesUtf16 = new Uint16Array(keyBytes.buffer, keyBytes.byteOffset, keyBytes.byteLength / 2);
-              var keyByteStr = String.fromCharCode.apply(null, Array.from(keyBytesUtf16));
-
-              // Parse Playready WRMHeader XML
-              var xmlKeyBytes = keyByteStr.substring(keyByteStr.indexOf('<'), keyByteStr.length);
-              var parser = new DOMParser();
-              var xmlDoc = parser.parseFromString(xmlKeyBytes, 'text/xml');
-              var keyData = xmlDoc.getElementsByTagName('KID')[0];
-              if (keyData) {
-                var keyId = keyData.childNodes[0] ? keyData.childNodes[0].nodeValue : keyData.getAttribute('VALUE');
-                if (keyId) {
-                  var keyIdArray = base64Decode(keyId).subarray(0, 16);
-                  // KID value in PRO is a base64-encoded little endian GUID interpretation of UUID
-                  // KID value in ‘tenc’ is a big endian UUID GUID interpretation of UUID
-                  changeEndianness(keyIdArray);
-                  this.keyId = keyIdArray;
-                }
-              }
+              this.keyId = parsePlayReadyWRM(keyBytes);
               break;
             }
           default:
@@ -3057,15 +3066,15 @@
 
       // Default behavior: assign a new keyId for each uri
       if (!this.keyId || this.keyId.byteLength !== 16) {
-        var _keyId = keyUriToKeyIdMap[this.uri];
-        if (!_keyId) {
+        var keyId = keyUriToKeyIdMap[this.uri];
+        if (!keyId) {
           var val = Object.keys(keyUriToKeyIdMap).length % Number.MAX_SAFE_INTEGER;
-          _keyId = new Uint8Array(16);
-          var dv = new DataView(_keyId.buffer, 12, 4); // Just set the last 4 bytes
+          keyId = new Uint8Array(16);
+          var dv = new DataView(keyId.buffer, 12, 4); // Just set the last 4 bytes
           dv.setUint32(0, val);
-          keyUriToKeyIdMap[this.uri] = _keyId;
+          keyUriToKeyIdMap[this.uri] = keyId;
         }
-        this.keyId = _keyId;
+        this.keyId = keyId;
       }
       return this;
     };
@@ -5543,15 +5552,16 @@
       delete oldDetails.fragmentHint.endPTS;
     }
     // check if old/new playlists have fragments in common
-    // loop through overlapping SN and update startPTS , cc, and duration if any found
-    var ccOffset = 0;
+    // loop through overlapping SN and update startPTS, cc, and duration if any found
     var PTSFrag;
-    mapFragmentIntersection(oldDetails, newDetails, function (oldFrag, newFrag) {
-      if (oldFrag.relurl) {
-        // Do not compare CC if the old fragment has no url. This is a level.fragmentHint used by LL-HLS parts.
-        // It maybe be off by 1 if it was created before any parts or discontinuity tags were appended to the end
-        // of the playlist.
-        ccOffset = oldFrag.cc - newFrag.cc;
+    mapFragmentIntersection(oldDetails, newDetails, function (oldFrag, newFrag, newFragIndex, newFragments) {
+      if (newDetails.skippedSegments) {
+        if (newFrag.cc !== oldFrag.cc) {
+          var ccOffset = oldFrag.cc - newFrag.cc;
+          for (var _i = newFragIndex; _i < newFragments.length; _i++) {
+            newFragments[_i].cc += ccOffset;
+          }
+        }
       }
       if (isFiniteNumber(oldFrag.startPTS) && isFiniteNumber(oldFrag.endPTS)) {
         newFrag.start = newFrag.startPTS = oldFrag.startPTS;
@@ -5576,8 +5586,9 @@
         currentInitSegment = oldFrag.initSegment;
       }
     });
+    var newFragments = newDetails.fragments;
     if (currentInitSegment) {
-      var fragmentsToCheck = newDetails.fragmentHint ? newDetails.fragments.concat(newDetails.fragmentHint) : newDetails.fragments;
+      var fragmentsToCheck = newDetails.fragmentHint ? newFragments.concat(newDetails.fragmentHint) : newFragments;
       fragmentsToCheck.forEach(function (frag) {
         var _currentInitSegment;
         if (frag && (!frag.initSegment || frag.initSegment.relurl === ((_currentInitSegment = currentInitSegment) == null ? void 0 : _currentInitSegment.relurl))) {
@@ -5586,29 +5597,22 @@
       });
     }
     if (newDetails.skippedSegments) {
-      newDetails.deltaUpdateFailed = newDetails.fragments.some(function (frag) {
+      newDetails.deltaUpdateFailed = newFragments.some(function (frag) {
         return !frag;
       });
       if (newDetails.deltaUpdateFailed) {
         logger.warn('[level-helper] Previous playlist missing segments skipped in delta playlist');
-        for (var _i = newDetails.skippedSegments; _i--;) {
-          newDetails.fragments.shift();
+        for (var _i2 = newDetails.skippedSegments; _i2--;) {
+          newFragments.shift();
+        }
+        newDetails.startSN = newFragments[0].sn;
+      } else {
+        if (newDetails.canSkipDateRanges) {
+          newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails.dateRanges, newDetails.recentlyRemovedDateranges);
         }
-        newDetails.startSN = newDetails.fragments[0].sn;
-        newDetails.startCC = newDetails.fragments[0].cc;
-      } else if (newDetails.canSkipDateRanges) {
-        newDetails.dateRanges = mergeDateRanges(oldDetails.dateRanges, newDetails.dateRanges, newDetails.recentlyRemovedDateranges);
-      }
-    }
-    var newFragments = newDetails.fragments;
-    if (ccOffset) {
-      logger.warn('discontinuity sliding from playlist, take drift into account');
-      for (var _i2 = 0; _i2 < newFragments.length; _i2++) {
-        newFragments[_i2].cc += ccOffset;
       }
-    }
-    if (newDetails.skippedSegments) {
       newDetails.startCC = newDetails.fragments[0].cc;
+      newDetails.endCC = newFragments[newFragments.length - 1].cc;
     }
 
     // Merge parts
@@ -5692,7 +5696,7 @@
         _newFrag = newDetails.fragments[i] = _oldFrag;
       }
       if (_oldFrag && _newFrag) {
-        intersectionFn(_oldFrag, _newFrag);
+        intersectionFn(_oldFrag, _newFrag, i, newFrags);
       }
     }
   }
@@ -9542,6 +9546,7 @@
       _this.startFragRequested = false;
       _this.decrypter = void 0;
       _this.initPTS = [];
+      _this.buffering = true;
       _this.onvseeking = null;
       _this.onvended = null;
       _this.logPrefix = '';
@@ -9584,6 +9589,12 @@
       this.clearNextTick();
       this.state = State.STOPPED;
     };
+    _proto.pauseBuffering = function pauseBuffering() {
+      this.buffering = false;
+    };
+    _proto.resumeBuffering = function resumeBuffering() {
+      this.buffering = true;
+    };
     _proto._streamEnded = function _streamEnded(bufferInfo, levelDetails) {
       // If playlist is live, there is another buffered range after the current range, nothing buffered, media is detached,
       // of nothing loading/loaded return false
@@ -14030,19 +14041,23 @@
       this.videoTrackConfig = undefined;
     };
     _proto.getVideoStartPts = function getVideoStartPts(videoSamples) {
+      // Get the minimum PTS value relative to the first sample's PTS, normalized for 33-bit wrapping
       var rolloverDetected = false;
+      var firstPts = videoSamples[0].pts;
       var startPTS = videoSamples.reduce(function (minPTS, sample) {
-        var delta = sample.pts - minPTS;
+        var pts = sample.pts;
+        var delta = pts - minPTS;
         if (delta < -4294967296) {
           // 2^32, see PTSNormalize for reasoning, but we're hitting a rollover here, and we don't want that to impact the timeOffset calculation
           rolloverDetected = true;
-          return normalizePts(minPTS, sample.pts);
-        } else if (delta > 0) {
+          pts = normalizePts(pts, firstPts);
+          delta = pts - minPTS;
+        }
+        if (delta > 0) {
           return minPTS;
-        } else {
-          return sample.pts;
         }
-      }, videoSamples[0].pts);
+        return pts;
+      }, firstPts);
       if (rolloverDetected) {
         logger.debug('PTS rollover detected');
       }
@@ -16487,12 +16502,13 @@
         trackId = this.trackId;
       var config = hls.config;
 
-      // 1. if video not attached AND
+      // 1. if buffering is suspended
+      // 2. if video not attached AND
       //    start fragment already requested OR start frag prefetch not enabled
-      // 2. if tracks or track not loaded and selected
+      // 3. if tracks or track not loaded and selected
       // then exit loop
       // => if media not attached but start frag prefetch is enabled and start frag not requested yet, we will not exit loop
-      if (!media && (this.startFragRequested || !config.startFragPrefetch) || !(levels != null && levels[trackId])) {
+      if (!this.buffering || !media && (this.startFragRequested || !config.startFragPrefetch) || !(levels != null && levels[trackId])) {
         return;
       }
       var levelInfo = levels[trackId];
@@ -18529,6 +18545,7 @@
         _this2.resetBuffer(type);
       });
       this._initSourceBuffer();
+      this.hls.resumeBuffering();
     };
     _proto.resetBuffer = function resetBuffer(type) {
       var sb = this.sourceBuffer[type];
@@ -22585,6 +22602,7 @@
    */
   var EMEController = /*#__PURE__*/function () {
     function EMEController(hls) {
+      var _this = this;
       this.hls = void 0;
       this.config = void 0;
       this.media = null;
@@ -22594,12 +22612,161 @@
       this.mediaKeySessions = [];
       this.keyIdToKeySessionPromise = {};
       this.setMediaKeysQueue = EMEController.CDMCleanupPromise ? [EMEController.CDMCleanupPromise] : [];
-      this.onMediaEncrypted = this._onMediaEncrypted.bind(this);
-      this.onWaitingForKey = this._onWaitingForKey.bind(this);
       this.debug = logger.debug.bind(logger, LOGGER_PREFIX);
       this.log = logger.log.bind(logger, LOGGER_PREFIX);
       this.warn = logger.warn.bind(logger, LOGGER_PREFIX);
       this.error = logger.error.bind(logger, LOGGER_PREFIX);
+      this.onMediaEncrypted = function (event) {
+        var initDataType = event.initDataType,
+          initData = event.initData;
+        var logMessage = "\"" + event.type + "\" event: init data type: \"" + initDataType + "\"";
+        _this.debug(logMessage);
+
+        // Ignore event when initData is null
+        if (initData === null) {
+          return;
+        }
+        if (!_this.keyFormatPromise) {
+          var keySystems = Object.keys(_this.keySystemAccessPromises);
+          if (!keySystems.length) {
+            keySystems = getKeySystemsForConfig(_this.config);
+          }
+          var keyFormats = keySystems.map(keySystemDomainToKeySystemFormat).filter(function (k) {
+            return !!k;
+          });
+          _this.keyFormatPromise = _this.getKeyFormatPromise(keyFormats);
+        }
+        _this.keyFormatPromise.then(function (keySystemFormat) {
+          var keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
+          var keyId;
+          var keySystemDomain;
+          if (initDataType === 'sinf') {
+            if (keySystem !== KeySystems.FAIRPLAY) {
+              _this.warn("Ignoring unexpected \"" + event.type + "\" event with init data type: \"" + initDataType + "\" for selected key-system " + keySystem);
+              return;
+            }
+            // Match sinf keyId to playlist skd://keyId=
+            var json = bin2str(new Uint8Array(initData));
+            try {
+              var sinf = base64Decode(JSON.parse(json).sinf);
+              var tenc = parseSinf(sinf);
+              if (!tenc) {
+                throw new Error("'schm' box missing or not cbcs/cenc with schi > tenc");
+              }
+              keyId = tenc.subarray(8, 24);
+              keySystemDomain = KeySystems.FAIRPLAY;
+            } catch (error) {
+              _this.warn(logMessage + " Failed to parse sinf: " + error);
+              return;
+            }
+          } else {
+            if (keySystem !== KeySystems.WIDEVINE && keySystem !== KeySystems.PLAYREADY) {
+              _this.warn("Ignoring unexpected \"" + event.type + "\" event with init data type: \"" + initDataType + "\" for selected key-system " + keySystem);
+              return;
+            }
+            // Support Widevine/PlayReady clear-lead key-session creation (otherwise depend on playlist keys)
+            var psshResults = parseMultiPssh(initData);
+            var psshInfos = psshResults.filter(function (pssh) {
+              return !!pssh.systemId && keySystemIdToKeySystemDomain(pssh.systemId) === keySystem;
+            });
+            if (psshInfos.length > 1) {
+              _this.warn(logMessage + " Using first of " + psshInfos.length + " pssh found for selected key-system " + keySystem);
+            }
+            var psshInfo = psshInfos[0];
+            if (!psshInfo) {
+              if (psshResults.length === 0 || psshResults.some(function (pssh) {
+                return !pssh.systemId;
+              })) {
+                _this.warn(logMessage + " contains incomplete or invalid pssh data");
+              } else {
+                _this.log("ignoring " + logMessage + " for " + psshResults.map(function (pssh) {
+                  return keySystemIdToKeySystemDomain(pssh.systemId);
+                }).join(',') + " pssh data in favor of playlist keys");
+              }
+              return;
+            }
+            keySystemDomain = keySystemIdToKeySystemDomain(psshInfo.systemId);
+            if (psshInfo.version === 0 && psshInfo.data) {
+              if (keySystemDomain === KeySystems.WIDEVINE) {
+                var offset = psshInfo.data.length - 22;
+                keyId = psshInfo.data.subarray(offset, offset + 16);
+              } else if (keySystemDomain === KeySystems.PLAYREADY) {
+                keyId = parsePlayReadyWRM(psshInfo.data);
+              }
+            }
+          }
+          if (!keySystemDomain || !keyId) {
+            _this.log("Unable to handle " + logMessage + " with key-system " + keySystem);
+            return;
+          }
+          var keyIdHex = Hex.hexDump(keyId);
+          var keyIdToKeySessionPromise = _this.keyIdToKeySessionPromise,
+            mediaKeySessions = _this.mediaKeySessions;
+          var keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex];
+          var _loop = function _loop() {
+              // Match playlist key
+              var keyContext = mediaKeySessions[i];
+              var decryptdata = keyContext.decryptdata;
+              if (!decryptdata.keyId) {
+                return 0; // continue
+              }
+              var oldKeyIdHex = Hex.hexDump(decryptdata.keyId);
+              if (keyIdHex === oldKeyIdHex || decryptdata.uri.replace(/-/g, '').indexOf(keyIdHex) !== -1) {
+                keySessionContextPromise = keyIdToKeySessionPromise[oldKeyIdHex];
+                if (decryptdata.pssh) {
+                  return 1; // break
+                }
+                delete keyIdToKeySessionPromise[oldKeyIdHex];
+                decryptdata.pssh = new Uint8Array(initData);
+                decryptdata.keyId = keyId;
+                keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = keySessionContextPromise.then(function () {
+                  return _this.generateRequestWithPreferredKeySession(keyContext, initDataType, initData, 'encrypted-event-key-match');
+                });
+                keySessionContextPromise.catch(function (error) {
+                  return _this.handleError(error);
+                });
+                return 1; // break
+              }
+            },
+            _ret;
+          for (var i = 0; i < mediaKeySessions.length; i++) {
+            _ret = _loop();
+            if (_ret === 0) continue;
+            if (_ret === 1) break;
+          }
+          if (!keySessionContextPromise) {
+            if (keySystemDomain !== keySystem) {
+              _this.log("Ignoring \"" + logMessage + "\" with " + keySystemDomain + " init data for selected key-system " + keySystem);
+              return;
+            }
+            // "Clear-lead" (misc key not encountered in playlist)
+            keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = _this.getKeySystemSelectionPromise([keySystemDomain]).then(function (_ref) {
+              var _keySystemToKeySystem;
+              var keySystem = _ref.keySystem,
+                mediaKeys = _ref.mediaKeys;
+              _this.throwIfDestroyed();
+              var decryptdata = new LevelKey('ISO-23001-7', keyIdHex, (_keySystemToKeySystem = keySystemDomainToKeySystemFormat(keySystem)) != null ? _keySystemToKeySystem : '');
+              decryptdata.pssh = new Uint8Array(initData);
+              decryptdata.keyId = keyId;
+              return _this.attemptSetMediaKeys(keySystem, mediaKeys).then(function () {
+                _this.throwIfDestroyed();
+                var keySessionContext = _this.createMediaKeySessionContext({
+                  decryptdata: decryptdata,
+                  keySystem: keySystem,
+                  mediaKeys: mediaKeys
+                });
+                return _this.generateRequestWithPreferredKeySession(keySessionContext, initDataType, initData, 'encrypted-event-no-match');
+              });
+            });
+            keySessionContextPromise.catch(function (error) {
+              return _this.handleError(error);
+            });
+          }
+        });
+      };
+      this.onWaitingForKey = function (event) {
+        _this.log("\"" + event.type + "\" event");
+      };
       this.hls = hls;
       this.config = hls.config;
       this.registerListeners();
@@ -22614,9 +22781,9 @@
       config.licenseXhrSetup = config.licenseResponseCallback = undefined;
       config.drmSystems = config.drmSystemOptions = {};
       // @ts-ignore
-      this.hls = this.onMediaEncrypted = this.onWaitingForKey = this.keyIdToKeySessionPromise = null;
+      this.hls = this.config = this.keyIdToKeySessionPromise = null;
       // @ts-ignore
-      this.config = null;
+      this.onMediaEncrypted = this.onWaitingForKey = null;
     };
     _proto.registerListeners = function registerListeners() {
       this.hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
@@ -22643,7 +22810,13 @@
       if (keySystem === KeySystems.WIDEVINE && widevineLicenseUrl) {
         return widevineLicenseUrl;
       }
-      throw new Error("no license server URL configured for key-system \"" + keySystem + "\"");
+    };
+    _proto.getLicenseServerUrlOrThrow = function getLicenseServerUrlOrThrow(keySystem) {
+      var url = this.getLicenseServerUrl(keySystem);
+      if (url === undefined) {
+        throw new Error("no license server URL configured for key-system \"" + keySystem + "\"");
+      }
+      return url;
     };
     _proto.getServerCertificateUrl = function getServerCertificateUrl(keySystem) {
       var drmSystems = this.config.drmSystems;
@@ -22655,7 +22828,7 @@
       }
     };
     _proto.attemptKeySystemAccess = function attemptKeySystemAccess(keySystemsToAttempt) {
-      var _this = this;
+      var _this2 = this;
       var levels = this.hls.levels;
       var uniqueCodec = function uniqueCodec(value, i, a) {
         return !!value && a.indexOf(value) === i;
@@ -22672,7 +22845,7 @@
       return new Promise(function (resolve, reject) {
         var attempt = function attempt(keySystems) {
           var keySystem = keySystems.shift();
-          _this.getMediaKeysPromise(keySystem, audioCodecs, videoCodecs).then(function (mediaKeys) {
+          _this2.getMediaKeysPromise(keySystem, audioCodecs, videoCodecs).then(function (mediaKeys) {
             return resolve({
               keySystem: keySystem,
               mediaKeys: mediaKeys
@@ -22707,7 +22880,7 @@
       return requestMediaKeySystemAccessFunc(keySystem, supportedConfigurations);
     };
     _proto.getMediaKeysPromise = function getMediaKeysPromise(keySystem, audioCodecs, videoCodecs) {
-      var _this2 = this;
+      var _this3 = this;
       // This can throw, but is caught in event handler callpath
       var mediaKeySystemConfigs = getSupportedMediaKeySystemConfigurations(keySystem, audioCodecs, videoCodecs, this.config.drmSystemOptions);
       var keySystemAccessPromises = this.keySystemAccessPromises[keySystem];
@@ -22719,23 +22892,23 @@
           keySystemAccess: keySystemAccess
         };
         keySystemAccess.catch(function (error) {
-          _this2.log("Failed to obtain access to key-system \"" + keySystem + "\": " + error);
+          _this3.log("Failed to obtain access to key-system \"" + keySystem + "\": " + error);
         });
         return keySystemAccess.then(function (mediaKeySystemAccess) {
-          _this2.log("Access for key-system \"" + mediaKeySystemAccess.keySystem + "\" obtained");
-          var certificateRequest = _this2.fetchServerCertificate(keySystem);
-          _this2.log("Create media-keys for \"" + keySystem + "\"");
+          _this3.log("Access for key-system \"" + mediaKeySystemAccess.keySystem + "\" obtained");
+          var certificateRequest = _this3.fetchServerCertificate(keySystem);
+          _this3.log("Create media-keys for \"" + keySystem + "\"");
           _keySystemAccessPromises.mediaKeys = mediaKeySystemAccess.createMediaKeys().then(function (mediaKeys) {
-            _this2.log("Media-keys created for \"" + keySystem + "\"");
+            _this3.log("Media-keys created for \"" + keySystem + "\"");
             return certificateRequest.then(function (certificate) {
               if (certificate) {
-                return _this2.setMediaKeysServerCertificate(mediaKeys, keySystem, certificate);
+                return _this3.setMediaKeysServerCertificate(mediaKeys, keySystem, certificate);
               }
               return mediaKeys;
             });
           });
           _keySystemAccessPromises.mediaKeys.catch(function (error) {
-            _this2.error("Failed to create media-keys for \"" + keySystem + "\"}: " + error);
+            _this3.error("Failed to create media-keys for \"" + keySystem + "\"}: " + error);
           });
           return _keySystemAccessPromises.mediaKeys;
         });
@@ -22744,10 +22917,10 @@
         return keySystemAccessPromises.mediaKeys;
       });
     };
-    _proto.createMediaKeySessionContext = function createMediaKeySessionContext(_ref) {
-      var decryptdata = _ref.decryptdata,
-        keySystem = _ref.keySystem,
-        mediaKeys = _ref.mediaKeys;
+    _proto.createMediaKeySessionContext = function createMediaKeySessionContext(_ref2) {
+      var decryptdata = _ref2.decryptdata,
+        keySystem = _ref2.keySystem,
+        mediaKeys = _ref2.mediaKeys;
       this.log("Creating key-system session \"" + keySystem + "\" keyId: " + Hex.hexDump(decryptdata.keyId || []));
       var mediaKeysSession = mediaKeys.createSession();
       var mediaKeySessionContext = {
@@ -22796,14 +22969,14 @@
       return this.keyFormatPromise;
     };
     _proto.getKeyFormatPromise = function getKeyFormatPromise(keyFormats) {
-      var _this3 = this;
+      var _this4 = this;
       return new Promise(function (resolve, reject) {
-        var keySystemsInConfig = getKeySystemsForConfig(_this3.config);
+        var keySystemsInConfig = getKeySystemsForConfig(_this4.config);
         var keySystemsToAttempt = keyFormats.map(keySystemFormatToKeySystemDomain).filter(function (value) {
           return !!value && keySystemsInConfig.indexOf(value) !== -1;
         });
-        return _this3.getKeySystemSelectionPromise(keySystemsToAttempt).then(function (_ref2) {
-          var keySystem = _ref2.keySystem;
+        return _this4.getKeySystemSelectionPromise(keySystemsToAttempt).then(function (_ref3) {
+          var keySystem = _ref3.keySystem;
           var keySystemFormat = keySystemDomainToKeySystemFormat(keySystem);
           if (keySystemFormat) {
             resolve(keySystemFormat);
@@ -22814,31 +22987,31 @@
       });
     };
     _proto.loadKey = function loadKey(data) {
-      var _this4 = this;
+      var _this5 = this;
       var decryptdata = data.keyInfo.decryptdata;
       var keyId = this.getKeyIdString(decryptdata);
       var keyDetails = "(keyId: " + keyId + " format: \"" + decryptdata.keyFormat + "\" method: " + decryptdata.method + " uri: " + decryptdata.uri + ")";
       this.log("Starting session for key " + keyDetails);
       var keySessionContextPromise = this.keyIdToKeySessionPromise[keyId];
       if (!keySessionContextPromise) {
-        keySessionContextPromise = this.keyIdToKeySessionPromise[keyId] = this.getKeySystemForKeyPromise(decryptdata).then(function (_ref3) {
-          var keySystem = _ref3.keySystem,
-            mediaKeys = _ref3.mediaKeys;
-          _this4.throwIfDestroyed();
-          _this4.log("Handle encrypted media sn: " + data.frag.sn + " " + data.frag.type + ": " + data.frag.level + " using key " + keyDetails);
-          return _this4.attemptSetMediaKeys(keySystem, mediaKeys).then(function () {
-            _this4.throwIfDestroyed();
-            var keySessionContext = _this4.createMediaKeySessionContext({
+        keySessionContextPromise = this.keyIdToKeySessionPromise[keyId] = this.getKeySystemForKeyPromise(decryptdata).then(function (_ref4) {
+          var keySystem = _ref4.keySystem,
+            mediaKeys = _ref4.mediaKeys;
+          _this5.throwIfDestroyed();
+          _this5.log("Handle encrypted media sn: " + data.frag.sn + " " + data.frag.type + ": " + data.frag.level + " using key " + keyDetails);
+          return _this5.attemptSetMediaKeys(keySystem, mediaKeys).then(function () {
+            _this5.throwIfDestroyed();
+            var keySessionContext = _this5.createMediaKeySessionContext({
               keySystem: keySystem,
               mediaKeys: mediaKeys,
               decryptdata: decryptdata
             });
             var scheme = 'cenc';
-            return _this4.generateRequestWithPreferredKeySession(keySessionContext, scheme, decryptdata.pssh, 'playlist-key');
+            return _this5.generateRequestWithPreferredKeySession(keySessionContext, scheme, decryptdata.pssh, 'playlist-key');
           });
         });
         keySessionContextPromise.catch(function (error) {
-          return _this4.handleError(error);
+          return _this5.handleError(error);
         });
       }
       return keySessionContextPromise;
@@ -22889,121 +23062,6 @@
       }
       return this.attemptKeySystemAccess(keySystemsToAttempt);
     };
-    _proto._onMediaEncrypted = function _onMediaEncrypted(event) {
-      var _this5 = this;
-      var initDataType = event.initDataType,
-        initData = event.initData;
-      var logMessage = "\"" + event.type + "\" event: init data type: \"" + initDataType + "\"";
-      this.debug(logMessage);
-
-      // Ignore event when initData is null
-      if (initData === null) {
-        return;
-      }
-      var keyId;
-      var keySystemDomain;
-      if (initDataType === 'sinf' && this.config.drmSystems[KeySystems.FAIRPLAY]) {
-        // Match sinf keyId to playlist skd://keyId=
-        var json = bin2str(new Uint8Array(initData));
-        try {
-          var sinf = base64Decode(JSON.parse(json).sinf);
-          var tenc = parseSinf(new Uint8Array(sinf));
-          if (!tenc) {
-            throw new Error("'schm' box missing or not cbcs/cenc with schi > tenc");
-          }
-          keyId = tenc.subarray(8, 24);
-          keySystemDomain = KeySystems.FAIRPLAY;
-        } catch (error) {
-          this.warn(logMessage + " Failed to parse sinf: " + error);
-          return;
-        }
-      } else {
-        // Support Widevine clear-lead key-session creation (otherwise depend on playlist keys)
-        var psshResults = parseMultiPssh(initData);
-        var psshInfo = psshResults.filter(function (pssh) {
-          return pssh.systemId === KeySystemIds.WIDEVINE;
-        })[0];
-        if (!psshInfo) {
-          if (psshResults.length === 0 || psshResults.some(function (pssh) {
-            return !pssh.systemId;
-          })) {
-            this.warn(logMessage + " contains incomplete or invalid pssh data");
-          } else {
-            this.log("ignoring " + logMessage + " for " + psshResults.map(function (pssh) {
-              return keySystemIdToKeySystemDomain(pssh.systemId);
-            }).join(',') + " pssh data in favor of playlist keys");
-          }
-          return;
-        }
-        keySystemDomain = keySystemIdToKeySystemDomain(psshInfo.systemId);
-        if (psshInfo.version === 0 && psshInfo.data) {
-          var offset = psshInfo.data.length - 22;
-          keyId = psshInfo.data.subarray(offset, offset + 16);
-        }
-      }
-      if (!keySystemDomain || !keyId) {
-        return;
-      }
-      var keyIdHex = Hex.hexDump(keyId);
-      var keyIdToKeySessionPromise = this.keyIdToKeySessionPromise,
-        mediaKeySessions = this.mediaKeySessions;
-      var keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex];
-      var _loop = function _loop() {
-          // Match playlist key
-          var keyContext = mediaKeySessions[i];
-          var decryptdata = keyContext.decryptdata;
-          if (!decryptdata.keyId) {
-            return 0; // continue
-          }
-          var oldKeyIdHex = Hex.hexDump(decryptdata.keyId);
-          if (keyIdHex === oldKeyIdHex || decryptdata.uri.replace(/-/g, '').indexOf(keyIdHex) !== -1) {
-            keySessionContextPromise = keyIdToKeySessionPromise[oldKeyIdHex];
-            if (decryptdata.pssh) {
-              return 1; // break
-            }
-            delete keyIdToKeySessionPromise[oldKeyIdHex];
-            decryptdata.pssh = new Uint8Array(initData);
-            decryptdata.keyId = keyId;
-            keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = keySessionContextPromise.then(function () {
-              return _this5.generateRequestWithPreferredKeySession(keyContext, initDataType, initData, 'encrypted-event-key-match');
-            });
-            return 1; // break
-          }
-        },
-        _ret;
-      for (var i = 0; i < mediaKeySessions.length; i++) {
-        _ret = _loop();
-        if (_ret === 0) continue;
-        if (_ret === 1) break;
-      }
-      if (!keySessionContextPromise) {
-        // Clear-lead key (not encountered in playlist)
-        keySessionContextPromise = keyIdToKeySessionPromise[keyIdHex] = this.getKeySystemSelectionPromise([keySystemDomain]).then(function (_ref4) {
-          var _keySystemToKeySystem;
-          var keySystem = _ref4.keySystem,
-            mediaKeys = _ref4.mediaKeys;
-          _this5.throwIfDestroyed();
-          var decryptdata = new LevelKey('ISO-23001-7', keyIdHex, (_keySystemToKeySystem = keySystemDomainToKeySystemFormat(keySystem)) != null ? _keySystemToKeySystem : '');
-          decryptdata.pssh = new Uint8Array(initData);
-          decryptdata.keyId = keyId;
-          return _this5.attemptSetMediaKeys(keySystem, mediaKeys).then(function () {
-            _this5.throwIfDestroyed();
-            var keySessionContext = _this5.createMediaKeySessionContext({
-              decryptdata: decryptdata,
-              keySystem: keySystem,
-              mediaKeys: mediaKeys
-            });
-            return _this5.generateRequestWithPreferredKeySession(keySessionContext, initDataType, initData, 'encrypted-event-no-match');
-          });
-        });
-      }
-      keySessionContextPromise.catch(function (error) {
-        return _this5.handleError(error);
-      });
-    };
-    _proto._onWaitingForKey = function _onWaitingForKey(event) {
-      this.log("\"" + event.type + "\" event");
-    };
     _proto.attemptSetMediaKeys = function attemptSetMediaKeys(keySystem, mediaKeys) {
       var _this6 = this;
       var queue = this.setMediaKeysQueue.slice();
@@ -23306,7 +23364,7 @@
       var _this12 = this;
       var keyLoadPolicy = this.config.keyLoadPolicy.default;
       return new Promise(function (resolve, reject) {
-        var url = _this12.getLicenseServerUrl(keySessionContext.keySystem);
+        var url = _this12.getLicenseServerUrlOrThrow(keySessionContext.keySystem);
         _this12.log("Sending license request to URL: " + url);
         var xhr = new XMLHttpRequest();
         xhr.responseType = 'arraybuffer';
@@ -23375,6 +23433,8 @@
 
       // keep reference of media
       this.media = media;
+      media.removeEventListener('encrypted', this.onMediaEncrypted);
+      media.removeEventListener('waitingforkey', this.onWaitingForKey);
       media.addEventListener('encrypted', this.onMediaEncrypted);
       media.addEventListener('waitingforkey', this.onWaitingForKey);
     };
@@ -25370,47 +25430,51 @@
           xhr.onprogress = null;
           var _status = xhr.status;
           // http status between 200 to 299 are all successful
-          var useResponse = xhr.responseType !== 'text';
-          if (_status >= 200 && _status < 300 && (useResponse && xhr.response || xhr.responseText !== null)) {
-            stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
-            var data = useResponse ? xhr.response : xhr.responseText;
-            var len = xhr.responseType === 'arraybuffer' ? data.byteLength : data.length;
-            stats.loaded = stats.total = len;
-            stats.bwEstimate = stats.total * 8000 / (stats.loading.end - stats.loading.first);
-            if (!this.callbacks) {
-              return;
-            }
-            var onProgress = this.callbacks.onProgress;
-            if (onProgress) {
-              onProgress(stats, context, data, xhr);
-            }
-            if (!this.callbacks) {
+          var useResponseText = xhr.responseType === 'text' ? xhr.responseText : null;
+          if (_status >= 200 && _status < 300) {
+            var data = useResponseText != null ? useResponseText : xhr.response;
+            if (data != null) {
+              stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
+              var len = xhr.responseType === 'arraybuffer' ? data.byteLength : data.length;
+              stats.loaded = stats.total = len;
+              stats.bwEstimate = stats.total * 8000 / (stats.loading.end - stats.loading.first);
+              if (!this.callbacks) {
+                return;
+              }
+              var onProgress = this.callbacks.onProgress;
+              if (onProgress) {
+                onProgress(stats, context, data, xhr);
+              }
+              if (!this.callbacks) {
+                return;
+              }
+              var _response = {
+                url: xhr.responseURL,
+                data: data,
+                code: _status
+              };
+              this.callbacks.onSuccess(_response, stats, context, xhr);
               return;
             }
-            var response = {
-              url: xhr.responseURL,
-              data: data,
-              code: _status
-            };
-            this.callbacks.onSuccess(response, stats, context, xhr);
+          }
+
+          // Handle bad status or nullish response
+          var retryConfig = config.loadPolicy.errorRetry;
+          var retryCount = stats.retry;
+          // if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
+          var response = {
+            url: context.url,
+            data: undefined,
+            code: _status
+          };
+          if (shouldRetry(retryConfig, retryCount, false, response)) {
+            this.retry(retryConfig);
           } else {
-            var retryConfig = config.loadPolicy.errorRetry;
-            var retryCount = stats.retry;
-            // if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
-            var _response = {
-              url: context.url,
-              data: undefined,
-              code: _status
-            };
-            if (shouldRetry(retryConfig, retryCount, false, _response)) {
-              this.retry(retryConfig);
-            } else {
-              logger.error(_status + " while loading " + context.url);
-              this.callbacks.onError({
-                code: _status,
-                text: xhr.statusText
-              }, context, xhr, stats);
-            }
+            logger.error(_status + " while loading " + context.url);
+            this.callbacks.onError({
+              code: _status,
+              text: xhr.statusText
+            }, context, xhr, stats);
           }
         }
       }
@@ -26790,7 +26854,7 @@
     };
     _proto.load = function load(frag) {
       var _this2 = this;
-      if (!frag.decryptdata && frag.encrypted && this.emeController) {
+      if (!frag.decryptdata && frag.encrypted && this.emeController && this.config.emeEnabled) {
         // Multiple keys, but none selected, resolve in eme-controller
         return this.emeController.selectKeySystemFormat(frag).then(function (keySystemFormat) {
           return _this2.loadInternal(frag, keySystemFormat);
@@ -27472,7 +27536,7 @@
       if (this.altAudio && this.audioOnly) {
         return;
       }
-      var level = hls.nextLoadLevel;
+      var level = this.buffering ? hls.nextLoadLevel : hls.loadLevel;
       if (!(levels != null && levels[level])) {
         return;
       }
@@ -27494,6 +27558,9 @@
         this.state = State.ENDED;
         return;
       }
+      if (!this.buffering) {
+        return;
+      }
 
       // set next load level : this will trigger a playlist load if needed
       if (hls.loadLevel !== level && hls.manualLevel === -1) {
@@ -28702,9 +28769,13 @@
       }
       logger.log("startLoad(" + startPosition + ")");
       this.started = true;
-      this.networkControllers.forEach(function (controller) {
-        controller.startLoad(startPosition);
-      });
+      this.resumeBuffering();
+      for (var i = 0; i < this.networkControllers.length; i++) {
+        this.networkControllers[i].startLoad(startPosition);
+        if (!this.started || !this.networkControllers) {
+          break;
+        }
+      }
     }
 
     /**
@@ -28713,32 +28784,35 @@
     _proto.stopLoad = function stopLoad() {
       logger.log('stopLoad');
       this.started = false;
-      this.networkControllers.forEach(function (controller) {
-        controller.stopLoad();
-      });
+      for (var i = 0; i < this.networkControllers.length; i++) {
+        this.networkControllers[i].stopLoad();
+        if (this.started || !this.networkControllers) {
+          break;
+        }
+      }
     }
 
     /**
-     * Resumes stream controller segment loading if previously started.
+     * Resumes stream controller segment loading after `pauseBuffering` has been called.
      */;
     _proto.resumeBuffering = function resumeBuffering() {
-      if (this.started) {
-        this.networkControllers.forEach(function (controller) {
-          if ('fragmentLoader' in controller) {
-            controller.startLoad(-1);
-          }
-        });
-      }
+      logger.log("resume buffering");
+      this.networkControllers.forEach(function (controller) {
+        if (controller.resumeBuffering) {
+          controller.resumeBuffering();
+        }
+      });
     }
 
     /**
-     * Stops stream controller segment loading without changing 'started' state like stopLoad().
+     * Prevents stream controller from loading new segments until `resumeBuffering` is called.
      * This allows for media buffering to be paused without interupting playlist loading.
      */;
     _proto.pauseBuffering = function pauseBuffering() {
+      logger.log("pause buffering");
       this.networkControllers.forEach(function (controller) {
-        if ('fragmentLoader' in controller) {
-          controller.stopLoad();
+        if (controller.pauseBuffering) {
+          controller.pauseBuffering();
         }
       });
     }
@@ -29295,7 +29369,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.17";
+        return "1.5.19";
       }
     }, {
       key: "Events",