hls.js 1.6.3-0.canary.11253 → 1.6.3-0.canary.11255

package/dist/hls.mjs

@@ -523,7 +523,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.3-0.canary.11253"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.3-0.canary.11255"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -4113,7 +4113,6 @@ function findFragmentByPDT(fragments, PDTValue, maxFragLookUpTolerance) {
   if (PDTValue >= (endPDT || 0)) {
     return null;
   }
-  maxFragLookUpTolerance = maxFragLookUpTolerance || 0;
   for (let seg = 0; seg < fragments.length; ++seg) {
     const frag = fragments[seg];
     if (pdtWithinToleranceTest(PDTValue, maxFragLookUpTolerance, frag)) {
@@ -4224,40 +4223,34 @@ function pdtWithinToleranceTest(pdtBufferEnd, maxFragLookUpTolerance, candidate)
   const endProgramDateTime = candidate.endProgramDateTime || 0;
   return endProgramDateTime - candidateLookupTolerance > pdtBufferEnd;
 }
-function findFragWithCC(fragments, cc) {
-  return BinarySearch.search(fragments, candidate => {
-    if (candidate.cc < cc) {
-      return 1;
-    } else if (candidate.cc > cc) {
-      return -1;
-    } else {
-      return 0;
-    }
-  });
-}
-function findNearestWithCC(details, cc, fragment) {
+function findNearestWithCC(details, cc, pos) {
   if (details) {
     if (details.startCC <= cc && details.endCC >= cc) {
-      const start = fragment.start;
-      const end = fragment.end;
       let fragments = details.fragments;
-      if (!fragment.relurl) {
-        const {
-          fragmentHint
-        } = details;
-        if (fragmentHint) {
-          fragments = fragments.concat(fragmentHint);
+      const {
+        fragmentHint
+      } = details;
+      if (fragmentHint) {
+        fragments = fragments.concat(fragmentHint);
+      }
+      let closest;
+      BinarySearch.search(fragments, candidate => {
+        if (candidate.cc < cc) {
+          return 1;
         }
-      }
-      return BinarySearch.search(fragments, candidate => {
-        if (candidate.cc < cc || candidate.end <= start) {
+        if (candidate.cc > cc) {
+          return -1;
+        }
+        closest = candidate;
+        if (candidate.end <= pos) {
           return 1;
-        } else if (candidate.cc > cc || candidate.start >= end) {
+        }
+        if (candidate.start > pos) {
           return -1;
-        } else {
-          return 0;
         }
+        return 0;
       });
+      return closest || null;
     }
   }
   return null;
@@ -8908,8 +8901,11 @@ class BaseStreamController extends TaskLoop {
       if (this.fragCurrent === null) {
         keyLoadingPromise = Promise.reject(new Error(`frag load aborted, context changed in KEY_LOADING`));
       }
-    } else if (!frag.encrypted && details.encryptedFragments.length) {
-      this.keyLoader.loadClear(frag, details.encryptedFragments);
+    } else if (!frag.encrypted) {
+      keyLoadingPromise = this.keyLoader.loadClear(frag, details.encryptedFragments);
+      if (keyLoadingPromise) {
+        this.log(`[eme] blocking frag load until media-keys acquired`);
+      }
     }
     const fragPrevious = this.fragPrevious;
     if (isMediaFragment(frag) && (!fragPrevious || frag.sn !== fragPrevious.sn)) {
@@ -9264,7 +9260,7 @@ class BaseStreamController extends TaskLoop {
           this.log(`LL-Part loading ON for initial live fragment`);
           this.loadingParts = true;
         }
-        frag = this.getInitialLiveFragment(levelDetails, fragments);
+        frag = this.getInitialLiveFragment(levelDetails);
         const mainStart = this.hls.startPosition;
         const liveSyncPosition = this.hls.liveSyncPosition;
         const startPosition = frag ? (mainStart !== -1 && mainStart >= start ? mainStart : liveSyncPosition) || frag.start : pos;
@@ -9404,7 +9400,8 @@ class BaseStreamController extends TaskLoop {
    "sliding" of the playlist, which is its offset from the start of playback. After sliding we can compute the real
    start and end times for each fragment in the playlist (after which this method will not need to be called).
   */
-  getInitialLiveFragment(levelDetails, fragments) {
+  getInitialLiveFragment(levelDetails) {
+    const fragments = levelDetails.fragments;
     const fragPrevious = this.fragPrevious;
     let frag = null;
     if (fragPrevious) {
@@ -9427,7 +9424,7 @@ class BaseStreamController extends TaskLoop {
         // It's important to stay within the continuity range if available; otherwise the fragments in the playlist
         // will have the wrong start times
         if (!frag) {
-          frag = findFragWithCC(fragments, fragPrevious.cc);
+          frag = findNearestWithCC(levelDetails, fragPrevious.cc, fragPrevious.end);
           if (frag) {
             this.log(`Live playlist, switching playlist, load frag with same CC: ${frag.sn}`);
           }
@@ -10237,7 +10234,7 @@ function requireEventemitter3 () {
 var eventemitter3Exports = requireEventemitter3();
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version = "1.6.3-0.canary.11253";
+const version = "1.6.3-0.canary.11255";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -16528,23 +16525,46 @@ class AudioStreamController extends BaseStreamController {
       if (this.state === State.WAITING_INIT_PTS) {
         const waitingData = this.waitingData;
         if (!waitingData && !this.loadingParts || waitingData && waitingData.frag.cc !== cc) {
-          this.nextLoadPosition = this.findSyncFrag(frag).start;
+          this.syncWithAnchor(frag, waitingData == null ? void 0 : waitingData.frag);
         }
-        this.tick();
       } else if (!this.hls.hasEnoughToStart && inFlightFrag && inFlightFrag.cc !== cc) {
-        this.startFragRequested = false;
-        this.nextLoadPosition = this.findSyncFrag(frag).start;
         inFlightFrag.abortRequests();
-        this.resetLoadingState();
+        this.syncWithAnchor(frag, inFlightFrag);
       } else if (this.state === State.IDLE) {
         this.tick();
       }
     }
   }
-  findSyncFrag(mainFrag) {
+  getLoadPosition() {
+    if (!this.startFragRequested && this.nextLoadPosition >= 0) {
+      return this.nextLoadPosition;
+    }
+    return super.getLoadPosition();
+  }
+  syncWithAnchor(mainAnchor, waitingToAppend) {
+    var _this$mainFragLoading;
+    // Drop waiting fragment if videoTrackCC has changed since waitingFragment was set and initPTS was not found
+    const mainFragLoading = ((_this$mainFragLoading = this.mainFragLoading) == null ? void 0 : _this$mainFragLoading.frag) || null;
+    if (waitingToAppend) {
+      if ((mainFragLoading == null ? void 0 : mainFragLoading.cc) === waitingToAppend.cc) {
+        // Wait for loading frag to complete and INIT_PTS_FOUND
+        return;
+      }
+    }
+    const targetDiscontinuity = (mainFragLoading || mainAnchor).cc;
     const trackDetails = this.getLevelDetails();
-    const cc = mainFrag.cc;
-    return findNearestWithCC(trackDetails, cc, mainFrag) || trackDetails && findFragWithCC(trackDetails.fragments, cc) || mainFrag;
+    const pos = this.getLoadPosition();
+    const syncFrag = findNearestWithCC(trackDetails, targetDiscontinuity, pos);
+    // Only stop waiting for audioFrag.cc if an audio segment of the same discontinuity domain (cc) is found
+    if (syncFrag) {
+      this.log(`Waiting fragment cc (${waitingToAppend == null ? void 0 : waitingToAppend.cc}) cancelled because video is at cc ${mainAnchor.cc}`);
+      this.startFragRequested = false;
+      this.nextLoadPosition = syncFrag.start;
+      this.resetLoadingState();
+      if (this.state === State.IDLE) {
+        this.doTickIdle();
+      }
+    }
   }
   startLoad(startPosition, skipSeekToStartPosition) {
     if (!this.levels) {
@@ -16631,10 +16651,7 @@ class AudioStreamController extends BaseStreamController {
                 super._handleFragmentLoadComplete(data);
               }
             } else if (mainAnchor && mainAnchor.cc !== waitingData.frag.cc) {
-              // Drop waiting fragment if videoTrackCC has changed since waitingFragment was set and initPTS was not found
-              this.log(`Waiting fragment cc (${frag.cc}) cancelled because video is at cc ${mainAnchor.cc}`);
-              this.nextLoadPosition = this.findSyncFrag(mainAnchor).start;
-              this.clearWaitingFragment();
+              this.syncWithAnchor(mainAnchor, waitingData.frag);
             }
           } else {
             this.state = State.IDLE;
@@ -16643,22 +16660,12 @@ class AudioStreamController extends BaseStreamController {
     }
     this.onTickEnd();
   }
-  clearWaitingFragment() {
+  resetLoadingState() {
     const waitingData = this.waitingData;
     if (waitingData) {
-      if (!this.hls.hasEnoughToStart) {
-        // Load overlapping fragment on start when discontinuity start times are not aligned
-        this.startFragRequested = false;
-      }
       this.fragmentTracker.removeFragment(waitingData.frag);
       this.waitingData = null;
-      if (this.state !== State.STOPPED) {
-        this.state = State.IDLE;
-      }
     }
-  }
-  resetLoadingState() {
-    this.clearWaitingFragment();
     super.resetLoadingState();
   }
   onTickEnd() {
@@ -16672,7 +16679,7 @@ class AudioStreamController extends BaseStreamController {
     this.lastCurrentTime = media.currentTime;
   }
   doTickIdle() {
-    var _this$mainFragLoading;
+    var _this$mainFragLoading2;
     const {
       hls,
       levels,
@@ -16746,7 +16753,7 @@ class AudioStreamController extends BaseStreamController {
     }
 
     // Request audio segments up to one fragment ahead of main stream-controller
-    let mainFragLoading = ((_this$mainFragLoading = this.mainFragLoading) == null ? void 0 : _this$mainFragLoading.frag) || null;
+    let mainFragLoading = ((_this$mainFragLoading2 = this.mainFragLoading) == null ? void 0 : _this$mainFragLoading2.frag) || null;
     if (!this.audioOnly && this.startFragRequested && mainFragLoading && isMediaFragment(frag) && !frag.endList && (!trackDetails.live || !this.loadingParts && targetBufferTime < this.hls.liveSyncPosition)) {
       if (this.fragmentTracker.getState(mainFragLoading) === FragmentState.OK) {
         this.mainFragLoading = mainFragLoading = null;
@@ -21828,6 +21835,7 @@ class EMEController extends Logger {
         this.log(`Create media-keys for "${keySystem}"`);
         _keySystemAccessPromises.mediaKeys = mediaKeySystemAccess.createMediaKeys().then(mediaKeys => {
           this.log(`Media-keys created for "${keySystem}"`);
+          _keySystemAccessPromises.hasMediaKeys = true;
           return certificateRequest.then(certificate => {
             if (certificate) {
               return this.setMediaKeysServerCertificate(mediaKeys, keySystem, certificate);
@@ -21888,18 +21896,26 @@ class EMEController extends Logger {
       } (data length: ${data ? data.byteLength : data})`);
     return keySession.update(data);
   }
-  selectKeySystemFormat(frag) {
-    const keyFormats = Object.keys(frag.levelkeys || {});
-    if (!this.keyFormatPromise) {
-      this.log(`Selecting key-system from fragment (sn: ${frag.sn} ${frag.type}: ${frag.level}) key formats ${keyFormats.join(', ')}`);
-      this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
-    }
-    return this.keyFormatPromise;
+  getSelectedKeySystemFormats() {
+    return Object.keys(this.keySystemAccessPromises).map(keySystem => ({
+      keySystem,
+      hasMediaKeys: this.keySystemAccessPromises[keySystem].hasMediaKeys
+    })).filter(({
+      hasMediaKeys
+    }) => !!hasMediaKeys).map(({
+      keySystem
+    }) => keySystemDomainToKeySystemFormat(keySystem)).filter(keySystem => !!keySystem);
+  }
+  getKeySystemAccess(keySystemsToAttempt) {
+    return this.getKeySystemSelectionPromise(keySystemsToAttempt).then(({
+      keySystem,
+      mediaKeys
+    }) => {
+      return this.attemptSetMediaKeys(keySystem, mediaKeys);
+    });
   }
-  getKeyFormatPromise(keyFormats) {
+  selectKeySystem(keySystemsToAttempt) {
     return new Promise((resolve, reject) => {
-      const keySystemsInConfig = getKeySystemsForConfig(this.config);
-      const keySystemsToAttempt = keyFormats.map(keySystemFormatToKeySystemDomain).filter(value => !!value && keySystemsInConfig.indexOf(value) !== -1);
       return this.getKeySystemSelectionPromise(keySystemsToAttempt).then(({
         keySystem
       }) => {
@@ -21912,6 +21928,19 @@ class EMEController extends Logger {
       }).catch(reject);
     });
   }
+  selectKeySystemFormat(frag) {
+    const keyFormats = Object.keys(frag.levelkeys || {});
+    if (!this.keyFormatPromise) {
+      this.log(`Selecting key-system from fragment (sn: ${frag.sn} ${frag.type}: ${frag.level}) key formats ${keyFormats.join(', ')}`);
+      this.keyFormatPromise = this.getKeyFormatPromise(keyFormats);
+    }
+    return this.keyFormatPromise;
+  }
+  getKeyFormatPromise(keyFormats) {
+    const keySystemsInConfig = getKeySystemsForConfig(this.config);
+    const keySystemsToAttempt = keyFormats.map(keySystemFormatToKeySystemDomain).filter(value => !!value && keySystemsInConfig.indexOf(value) !== -1);
+    return this.selectKeySystem(keySystemsToAttempt);
+  }
   loadKey(data) {
     const decryptdata = data.keyInfo.decryptdata;
     const keyId = this.getKeyIdString(decryptdata);
@@ -26061,8 +26090,7 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
     var _this$schedule$items4, _this$detachedData5;
     const {
       interstitial,
-      assetItem,
-      assetId
+      assetItem
     } = player;
     const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);
     const item = (_this$schedule$items4 = this.schedule.items) == null ? void 0 : _this$schedule$items4[scheduleIndex];
@@ -30293,6 +30321,8 @@ const hlsDefaultConfig = _objectSpread2(_objectSpread2({
   // used by eme-controller
   requestMediaKeySystemAccessFunc: requestMediaKeySystemAccess ,
   // used by eme-controller
+  requireKeySystemAccessOnStart: false,
+  // used by eme-controller
   testBandwidth: true,
   progressive: false,
   lowLatencyMode: true,
@@ -33683,22 +33713,35 @@ class KeyLoader {
     });
   }
   loadClear(loadingFrag, encryptedFragments) {
-    if (this.emeController && this.config.emeEnabled) {
-      // access key-system with nearest key on start (loaidng frag is unencrypted)
-      const {
-        sn,
-        cc
-      } = loadingFrag;
-      for (let i = 0; i < encryptedFragments.length; i++) {
-        const frag = encryptedFragments[i];
-        if (cc <= frag.cc && (sn === 'initSegment' || frag.sn === 'initSegment' || sn < frag.sn)) {
-          this.emeController.selectKeySystemFormat(frag).then(keySystemFormat => {
-            frag.setKeyFormat(keySystemFormat);
-          });
-          break;
+    if (this.emeController && this.config.emeEnabled && !this.emeController.getSelectedKeySystemFormats().length) {
+      // access key-system with nearest key on start (loading frag is unencrypted)
+      if (encryptedFragments.length) {
+        const {
+          sn,
+          cc
+        } = loadingFrag;
+        for (let i = 0; i < encryptedFragments.length; i++) {
+          const frag = encryptedFragments[i];
+          if (cc <= frag.cc && (sn === 'initSegment' || frag.sn === 'initSegment' || sn < frag.sn)) {
+            return this.emeController.selectKeySystemFormat(frag).then(keySystemFormat => {
+              frag.setKeyFormat(keySystemFormat);
+              if (this.emeController && this.config.requireKeySystemAccessOnStart) {
+                const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
+                if (keySystem) {
+                  return this.emeController.getKeySystemAccess([keySystem]);
+                }
+              }
+            });
+          }
+        }
+      } else if (this.config.requireKeySystemAccessOnStart) {
+        const keySystemsInConfig = getKeySystemsForConfig(this.config);
+        if (keySystemsInConfig.length) {
+          return this.emeController.getKeySystemAccess(keySystemsInConfig);
         }
       }
     }
+    return null;
   }
   load(frag) {
     if (!frag.decryptdata && frag.encrypted && this.emeController && this.config.emeEnabled) {