hls.js 1.5.14-0.canary.10427 → 1.5.14-0.canary.10431

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

@@ -442,7 +442,9 @@ export default class BaseStreamController
         }
 
         if ('payload' in data) {
-          this.log(`Loaded fragment ${frag.sn} of level ${frag.level}`);
+          this.log(
+            `Loaded ${frag.type} sn: ${frag.sn} of ${this.playlistLabel()} ${frag.level}`,
+          );
           this.hls.trigger(Events.FRAG_LOADED, data);
         }
 
@@ -629,11 +631,7 @@ export default class BaseStreamController
     this.log(
       `Buffered ${frag.type} sn: ${frag.sn}${
         part ? ' part: ' + part.index : ''
-      } of ${
-        this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'
-      } ${frag.level} (frag:[${(frag.startPTS ?? NaN).toFixed(3)}-${(
-        frag.endPTS ?? NaN
-      ).toFixed(3)}] > buffer:${
+      } of ${this.fragInfo(frag)} > buffer:${
         media
           ? TimeRanges.toString(BufferHelper.getBuffered(media))
           : '(detached)'
@@ -718,9 +716,7 @@ export default class BaseStreamController
     let keyLoadingPromise: Promise<KeyLoadedData | void> | null = null;
     if (frag.encrypted && !frag.decryptdata?.key) {
       this.log(
-        `Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${
-          this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'
-        } ${frag.level}`,
+        `Loading key for ${frag.sn} of [${details.startSN}-${details.endSN}], ${this.playlistLabel()} ${frag.level}`,
       );
       this.state = State.KEY_LOADING;
       this.fragCurrent = frag;
@@ -773,9 +769,7 @@ export default class BaseStreamController
               frag.cc
             } of playlist [${details.startSN}-${
               details.endSN
-            }] parts [0-${partIndex}-${partList.length - 1}] ${
-              this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'
-            }: ${frag.level}, target: ${parseFloat(
+            }] parts [0-${partIndex}-${partList.length - 1}] ${this.playlistLabel()}: ${frag.level}, target: ${parseFloat(
               targetBufferTime.toFixed(3),
             )}`,
           );
@@ -843,10 +837,8 @@ export default class BaseStreamController
     }
 
     this.log(
-      `Loading fragment ${frag.sn} cc: ${frag.cc} ${
-        details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : ''
-      }${this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${
-        frag.level
+      `Loading ${frag.type} sn: ${frag.sn} of ${this.fragInfo(frag, false)}) cc: ${frag.cc} ${
+        details ? '[' + details.startSN + '-' + details.endSN + ']' : ''
       }, target: ${parseFloat(targetBufferTime.toFixed(3))}`,
     );
     // Don't update nextLoadPosition for fragments which are not buffered
@@ -1920,9 +1912,24 @@ export default class BaseStreamController
       // For this error fallthrough. Marking parsed will allow advancing to next fragment.
     }
     this.state = State.PARSED;
+    this.log(
+      `Parsed ${frag.type} sn: ${frag.sn}${
+        part ? ' part: ' + part.index : ''
+      } of ${this.fragInfo(frag)})`,
+    );
     this.hls.trigger(Events.FRAG_PARSED, { frag, part });
   }
 
+  private playlistLabel() {
+    return this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track';
+  }
+
+  private fragInfo(frag: Fragment, pts: boolean = true): string {
+    return `${this.playlistLabel()} ${frag.level} (frag:[${((pts ? frag.startPTS : frag.start) ?? NaN).toFixed(3)}-${(
+      (pts ? frag.endPTS : frag.end) ?? NaN
+    ).toFixed(3)}]`;
+  }
+
   protected resetTransmuxer() {
     if (this.transmuxer) {
       this.transmuxer.destroy();

package/src/utils/discontinuities.ts

@@ -17,14 +17,13 @@ export function findFirstFragWithCC(
 }
 
 export function shouldAlignOnDiscontinuities(
-  lastFrag: Fragment | null,
-  switchDetails: LevelDetails | undefined,
+  refDetails: LevelDetails | undefined,
   details: LevelDetails,
-): switchDetails is LevelDetails & boolean {
-  if (switchDetails) {
+): refDetails is LevelDetails & boolean {
+  if (refDetails) {
     if (
-      details.endCC > details.startCC ||
-      (lastFrag && lastFrag.cc < details.startCC)
+      details.startCC < refDetails.endCC &&
+      details.endCC > refDetails.startCC
     ) {
       return true;
     }
@@ -32,29 +31,6 @@ export function shouldAlignOnDiscontinuities(
   return false;
 }
 
-// Find the first frag in the previous level which matches the CC of the first frag of the new level
-export function findDiscontinuousReferenceFrag(
-  prevDetails: LevelDetails,
-  curDetails: LevelDetails,
-) {
-  const prevFrags = prevDetails.fragments;
-  const curFrags = curDetails.fragments;
-
-  if (!curFrags.length || !prevFrags.length) {
-    logger.log('No fragments to align');
-    return;
-  }
-
-  const prevStartFrag = findFirstFragWithCC(prevFrags, curFrags[0].cc);
-
-  if (!prevStartFrag || (prevStartFrag && !prevStartFrag.startPTS)) {
-    logger.log('No frag in previous level to align on');
-    return;
-  }
-
-  return prevStartFrag;
-}
-
 function adjustFragmentStart(frag: Fragment, sliding: number) {
   if (frag) {
     const start = frag.start + sliding;
@@ -94,7 +70,7 @@ export function alignStream(
   if (!switchDetails) {
     return;
   }
-  alignDiscontinuities(lastFrag, details, switchDetails);
+  alignDiscontinuities(details, switchDetails);
   if (!details.alignedSliding && switchDetails) {
     // If the PTS wasn't figured out via discontinuity sequence that means there was no CC increase within the level.
     // Aligning via Program Date Time should therefore be reliable, since PDT should be the same within the same
@@ -110,29 +86,27 @@ export function alignStream(
 }
 
 /**
- * Computes the PTS if a new level's fragments using the PTS of a fragment in the last level which shares the same
- * discontinuity sequence.
- * @param lastFrag - The last Fragment which shares the same discontinuity sequence
+ * Ajust the start of fragments in `details` by the difference in time between fragments of the latest
+ * shared discontinuity sequence change.
  * @param lastLevel - The details of the last loaded level
  * @param details - The details of the new level
  */
-function alignDiscontinuities(
-  lastFrag: Fragment | null,
+export function alignDiscontinuities(
   details: LevelDetails,
-  switchDetails: LevelDetails | undefined,
+  refDetails: LevelDetails | undefined,
 ) {
-  if (shouldAlignOnDiscontinuities(lastFrag, switchDetails, details)) {
-    const referenceFrag = findDiscontinuousReferenceFrag(
-      switchDetails,
-      details,
-    );
-    if (referenceFrag && Number.isFinite(referenceFrag.start)) {
-      logger.log(
-        `Adjusting PTS using last level due to CC increase within current level ${details.url}`,
-      );
-      adjustSlidingStart(referenceFrag.start, details);
-    }
+  if (!shouldAlignOnDiscontinuities(refDetails, details)) {
+    return;
   }
+  const targetCC = Math.min(refDetails.endCC, details.endCC);
+  const refFrag = findFirstFragWithCC(refDetails.fragments, targetCC);
+  const frag = findFirstFragWithCC(details.fragments, targetCC);
+  if (!refFrag || !frag) {
+    return;
+  }
+  logger.log(`Aligning playlist at start of dicontinuity sequence ${targetCC}`);
+  const delta = refFrag.start - frag.start;
+  adjustSlidingStart(delta, details);
 }
 
 /**