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

package/src/controller/audio-stream-controller.ts

@@ -1,5 +1,5 @@
 import BaseStreamController, { State } from './base-stream-controller';
-import { findFragWithCC, findNearestWithCC } from './fragment-finders';
+import { findNearestWithCC } from './fragment-finders';
 import { FragmentState } from './fragment-tracker';
 import ChunkCache from '../demux/chunk-cache';
 import TransmuxerInterface from '../demux/transmuxer-interface';
@@ -161,32 +161,56 @@ class AudioStreamController
           (!waitingData && !this.loadingParts) ||
           (waitingData && waitingData.frag.cc !== cc)
         ) {
-          this.nextLoadPosition = this.findSyncFrag(frag).start;
+          this.syncWithAnchor(frag, 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();
       }
     }
   }
 
-  private findSyncFrag(mainFrag: MediaFragment): MediaFragment {
+  protected getLoadPosition(): number {
+    if (!this.startFragRequested && this.nextLoadPosition >= 0) {
+      return this.nextLoadPosition;
+    }
+    return super.getLoadPosition();
+  }
+
+  private syncWithAnchor(
+    mainAnchor: MediaFragment,
+    waitingToAppend: Fragment | undefined,
+  ) {
+    // Drop waiting fragment if videoTrackCC has changed since waitingFragment was set and initPTS was not found
+    const mainFragLoading = this.mainFragLoading?.frag || null;
+    if (waitingToAppend) {
+      if (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?.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: number, skipSeekToStartPosition?: boolean) {
@@ -265,12 +289,7 @@ class AudioStreamController
               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;
@@ -281,23 +300,12 @@ class AudioStreamController
     this.onTickEnd();
   }
 
-  clearWaitingFragment() {
+  protected 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;
-      }
     }
-  }
-
-  protected resetLoadingState() {
-    this.clearWaitingFragment();
     super.resetLoadingState();
   }
 

package/src/controller/base-stream-controller.ts

@@ -2,7 +2,7 @@ import { ErrorActionFlags, NetworkErrorAction } from './error-controller';
 import {
   findFragmentByPDT,
   findFragmentByPTS,
-  findFragWithCC,
+  findNearestWithCC,
 } from './fragment-finders';
 import { FragmentState } from './fragment-tracker';
 import Decrypter from '../crypt/decrypter';
@@ -31,6 +31,7 @@ import {
   getPartWith,
   updateFragPTSDTS,
 } from '../utils/level-helper';
+import { getKeySystemsForConfig } from '../utils/mediakeys-helper';
 import { appendUint8Array } from '../utils/mp4-tools';
 import TimeRanges from '../utils/time-ranges';
 import type { FragmentTracker } from './fragment-tracker';
@@ -809,8 +810,14 @@ export default class BaseStreamController
           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;
@@ -1298,7 +1305,7 @@ export default class BaseStreamController
           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
@@ -1506,8 +1513,8 @@ export default class BaseStreamController
   */
   protected getInitialLiveFragment(
     levelDetails: LevelDetails,
-    fragments: MediaFragment[],
   ): MediaFragment | null {
+    const fragments = levelDetails.fragments;
     const fragPrevious = this.fragPrevious;
     let frag: MediaFragment | null = null;
     if (fragPrevious) {
@@ -1543,7 +1550,11 @@ export default class BaseStreamController
         // 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}`,

package/src/controller/eme-controller.ts

@@ -52,6 +52,7 @@ interface KeySystemAccessPromises {
   keySystemAccess: Promise<MediaKeySystemAccess>;
   mediaKeys?: Promise<MediaKeys>;
   certificate?: Promise<BufferSource | void>;
+  hasMediaKeys?: boolean;
 }
 
 export interface MediaKeySessionContext {
@@ -285,6 +286,7 @@ class EMEController extends Logger implements ComponentAPI {
           .createMediaKeys()
           .then((mediaKeys) => {
             this.log(`Media-keys created for "${keySystem}"`);
+            keySystemAccessPromises.hasMediaKeys = true;
             return certificateRequest.then((certificate) => {
               if (certificate) {
                 return this.setMediaKeysServerCertificate(
@@ -384,29 +386,29 @@ class EMEController extends Logger implements ComponentAPI {
     return keySession.update(data);
   }
 
-  public selectKeySystemFormat(frag: Fragment): Promise<KeySystemFormats> {
-    const keyFormats = Object.keys(frag.levelkeys || {}) as KeySystemFormats[];
-    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;
+  public getSelectedKeySystemFormats(): KeySystemFormats[] {
+    return (Object.keys(this.keySystemAccessPromises) as KeySystems[])
+      .map((keySystem) => ({
+        keySystem,
+        hasMediaKeys: this.keySystemAccessPromises[keySystem].hasMediaKeys,
+      }))
+      .filter(({ hasMediaKeys }) => !!hasMediaKeys)
+      .map(({ keySystem }) => keySystemToKeySystemFormat(keySystem))
+      .filter((keySystem): keySystem is KeySystemFormats => !!keySystem);
   }
 
-  private getKeyFormatPromise(
-    keyFormats: KeySystemFormats[],
+  public getKeySystemAccess(keySystemsToAttempt: KeySystems[]): Promise<void> {
+    return this.getKeySystemSelectionPromise(keySystemsToAttempt).then(
+      ({ keySystem, mediaKeys }) => {
+        return this.attemptSetMediaKeys(keySystem, mediaKeys);
+      },
+    );
+  }
+
+  public selectKeySystem(
+    keySystemsToAttempt: KeySystems[],
   ): Promise<KeySystemFormats> {
     return new Promise((resolve, reject) => {
-      const keySystemsInConfig = getKeySystemsForConfig(this.config);
-      const keySystemsToAttempt = keyFormats
-        .map(keySystemFormatToKeySystemDomain)
-        .filter(
-          (value) => !!value && keySystemsInConfig.indexOf(value) !== -1,
-        ) as any as KeySystems[];
       return this.getKeySystemSelectionPromise(keySystemsToAttempt)
         .then(({ keySystem }) => {
           const keySystemFormat = keySystemToKeySystemFormat(keySystem);
@@ -422,6 +424,32 @@ class EMEController extends Logger implements ComponentAPI {
     });
   }
 
+  public selectKeySystemFormat(frag: Fragment): Promise<KeySystemFormats> {
+    const keyFormats = Object.keys(frag.levelkeys || {}) as KeySystemFormats[];
+    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;
+  }
+
+  private getKeyFormatPromise(
+    keyFormats: KeySystemFormats[],
+  ): Promise<KeySystemFormats> {
+    const keySystemsInConfig = getKeySystemsForConfig(this.config);
+    const keySystemsToAttempt = keyFormats
+      .map(keySystemFormatToKeySystemDomain)
+      .filter(
+        (value) => !!value && keySystemsInConfig.indexOf(value) !== -1,
+      ) as any as KeySystems[];
+
+    return this.selectKeySystem(keySystemsToAttempt);
+  }
+
   public loadKey(data: KeyLoadedData): Promise<MediaKeySessionContext> {
     const decryptdata = data.keyInfo.decryptdata;
 

package/src/controller/fragment-finders.ts

@@ -33,7 +33,6 @@ export function findFragmentByPDT(
     return null;
   }
 
-  maxFragLookUpTolerance = maxFragLookUpTolerance || 0;
   for (let seg = 0; seg < fragments.length; ++seg) {
     const frag = fragments[seg];
     if (pdtWithinToleranceTest(PDTValue, maxFragLookUpTolerance, frag)) {
@@ -225,28 +224,33 @@ export function findFragWithCC(
 export function findNearestWithCC(
   details: LevelDetails | undefined,
   cc: number,
-  fragment: MediaFragment,
+  pos: number,
 ): MediaFragment | null {
   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);
       }
-      return BinarySearch.search(fragments, (candidate) => {
-        if (candidate.cc < cc || candidate.end <= start) {
+      let closest: MediaFragment | undefined;
+      BinarySearch.search(fragments, (candidate) => {
+        if (candidate.cc < cc) {
+          return 1;
+        }
+        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;

package/src/controller/interstitials-controller.ts

@@ -2437,7 +2437,7 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
   }
 
   private bufferAssetPlayer(player: HlsAssetPlayer, media: HTMLMediaElement) {
-    const { interstitial, assetItem, assetId } = player;
+    const { interstitial, assetItem } = player;
     const scheduleIndex = this.schedule.findEventIndex(interstitial.identifier);
     const item = this.schedule.items?.[scheduleIndex];
     if (!item) {

package/src/loader/key-loader.ts

@@ -1,7 +1,11 @@
 import { LoadError } from './fragment-loader';
 import { ErrorDetails, ErrorTypes } from '../errors';
-import type { HlsConfig } from '../config';
+import {
+  getKeySystemsForConfig,
+  keySystemFormatToKeySystemDomain,
+} from '../utils/mediakeys-helper';
 import type { LevelKey } from './level-key';
+import type { HlsConfig } from '../config';
 import type EMEController from '../controller/eme-controller';
 import type { MediaKeySessionContext } from '../controller/eme-controller';
 import type { Fragment } from '../loader/fragment';
@@ -90,25 +94,46 @@ export default class KeyLoader implements ComponentAPI {
   loadClear(
     loadingFrag: Fragment,
     encryptedFragments: Fragment[],
-  ): void | Promise<void> {
-    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;
+  ): null | Promise<void> {
+    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: Fragment): Promise<KeyLoadedData> {