hls.js 1.5.12-0.canary.10338 → 1.5.12-0.canary.10341

package/src/types/fragment-tracker.ts

@@ -1,9 +1,9 @@
-import type { Fragment } from '../loader/fragment';
+import type { MediaFragment } from '../loader/fragment';
 import type { SourceBufferName } from './buffer';
 import type { FragLoadedData } from './events';
 
 export interface FragmentEntity {
-  body: Fragment;
+  body: MediaFragment;
   // appendedPTS is the latest buffered presentation time within the fragment's time range.
   // It is used to determine: which fragment is appended at any given position, and hls.currentLevel.
   appendedPTS: number | null;

package/src/utils/attr-list.ts

@@ -1,3 +1,8 @@
+import type { LevelDetails } from '../loader/level-details';
+import type { ParsedMultivariantPlaylist } from '../loader/m3u8-parser';
+import { logger } from './logger';
+import { substituteVariables } from './variable-substitution';
+
 const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
 const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 
@@ -5,9 +10,15 @@ const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 export class AttrList {
   [key: string]: any;
 
-  constructor(attrs: string | Record<string, any>) {
+  constructor(
+    attrs: string | Record<string, any>,
+    parsed?: Pick<
+      ParsedMultivariantPlaylist | LevelDetails,
+      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
+    >,
+  ) {
     if (typeof attrs === 'string') {
-      attrs = AttrList.parseAttrList(attrs);
+      attrs = AttrList.parseAttrList(attrs, parsed);
     }
     Object.assign(this, attrs);
   }
@@ -63,6 +74,20 @@ export class AttrList {
     return this[attrName];
   }
 
+  enumeratedStringList<T extends { [key: string]: boolean }>(
+    attrName: string,
+    dict: T,
+  ): { [key in keyof T]: boolean } {
+    const attrValue = this[attrName];
+    return (attrValue ? attrValue.split(/[ ,]+/) : []).reduce(
+      (result: { [key in keyof T]: boolean }, identifier: string) => {
+        result[identifier.toLowerCase() as keyof T] = true;
+        return result;
+      },
+      dict,
+    );
+  }
+
   bool(attrName: string): boolean {
     return this[attrName] === 'YES';
   }
@@ -84,21 +109,83 @@ export class AttrList {
     };
   }
 
-  static parseAttrList(input: string): Record<string, any> {
-    let match;
+  static parseAttrList(
+    input: string,
+    parsed?: Pick<
+      ParsedMultivariantPlaylist | LevelDetails,
+      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
+    >,
+  ): Record<string, string> {
+    let match: RegExpExecArray | null;
     const attrs = {};
     const quote = '"';
     ATTR_LIST_REGEX.lastIndex = 0;
     while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
+      const name = match[1].trim();
       let value = match[2];
-
-      if (
+      const quotedString =
         value.indexOf(quote) === 0 &&
-        value.lastIndexOf(quote) === value.length - 1
-      ) {
+        value.lastIndexOf(quote) === value.length - 1;
+      let hexadecimalSequence = false;
+      if (quotedString) {
         value = value.slice(1, -1);
+      } else {
+        switch (name) {
+          case 'IV':
+          case 'SCTE35-CMD':
+          case 'SCTE35-IN':
+          case 'SCTE35-OUT':
+            hexadecimalSequence = true;
+        }
+      }
+      if (parsed && (quotedString || hexadecimalSequence)) {
+        if (__USE_VARIABLE_SUBSTITUTION__) {
+          value = substituteVariables(parsed, value);
+        }
+      } else if (!hexadecimalSequence && !quotedString) {
+        switch (name) {
+          case 'CLOSED-CAPTIONS':
+            if (value === 'NONE') {
+              break;
+            }
+          // falls through
+          case 'ALLOWED-CPC':
+          case 'CLASS':
+          case 'ASSOC-LANGUAGE':
+          case 'AUDIO':
+          case 'BYTERANGE':
+          case 'CHANNELS':
+          case 'CHARACTERISTICS':
+          case 'CODECS':
+          case 'DATA-ID':
+          case 'END-DATE':
+          case 'GROUP-ID':
+          case 'ID':
+          case 'IMPORT':
+          case 'INSTREAM-ID':
+          case 'KEYFORMAT':
+          case 'KEYFORMATVERSIONS':
+          case 'LANGUAGE':
+          case 'NAME':
+          case 'PATHWAY-ID':
+          case 'QUERYPARAM':
+          case 'RECENTLY-REMOVED-DATERANGES':
+          case 'SERVER-URI':
+          case 'STABLE-RENDITION-ID':
+          case 'STABLE-VARIANT-ID':
+          case 'START-DATE':
+          case 'SUBTITLES':
+          case 'SUPPLEMENTAL-CODECS':
+          case 'URI':
+          case 'VALUE':
+          case 'VIDEO':
+          case 'X-ASSET-LIST':
+          case 'X-ASSET-URI':
+            // Since we are not checking tag:attribute combination, just warn rather than ignoring attribute
+            logger.warn(`${input}: attribute ${name} is missing quotes`);
+          // continue;
+        }
       }
-      const name = match[1].trim();
       attrs[name] = value;
     }
     return attrs;

package/src/utils/level-helper.ts

@@ -3,16 +3,17 @@
  */
 
 import { logger } from './logger';
-import { Fragment, Part } from '../loader/fragment';
-import { LevelDetails } from '../loader/level-details';
-import type { Level } from '../types/level';
 import { DateRange } from '../loader/date-range';
+import { assignProgramDateTime, mapDateRanges } from '../loader/m3u8-parser';
+import type { Fragment, MediaFragment, Part } from '../loader/fragment';
+import type { LevelDetails } from '../loader/level-details';
+import type { Level } from '../types/level';
 
 type FragmentIntersection = (oldFrag: Fragment, newFrag: Fragment) => void;
 type PartIntersection = (oldPart: Part, newPart: Part) => void;
 
 export function updatePTS(
-  fragments: Fragment[],
+  fragments: MediaFragment[],
   fromIdx: number,
   toIdx: number,
 ): void {
@@ -21,7 +22,7 @@ export function updatePTS(
   updateFromToPTS(fragFrom, fragTo);
 }
 
-function updateFromToPTS(fragFrom: Fragment, fragTo: Fragment) {
+function updateFromToPTS(fragFrom: MediaFragment, fragTo: MediaFragment) {
   const fragToPTS = fragTo.startPTS as number;
   // if we know startPTS[toIdx]
   if (Number.isFinite(fragToPTS)) {
@@ -55,7 +56,7 @@ function updateFromToPTS(fragFrom: Fragment, fragTo: Fragment) {
 
 export function updateFragPTSDTS(
   details: LevelDetails | undefined,
-  frag: Fragment,
+  frag: MediaFragment,
   startPTS: number,
   endPTS: number,
   startDTS: number,
@@ -82,11 +83,11 @@ export function updateFragPTSDTS(
 
     maxStartPTS = Math.max(startPTS, fragStartPts);
     startPTS = Math.min(startPTS, fragStartPts);
-    startDTS = Math.min(startDTS, frag.startDTS);
+    startDTS = Math.min(startDTS, frag.startDTS as number);
 
     minEndPTS = Math.min(endPTS, fragEndPts);
     endPTS = Math.max(endPTS, fragEndPts);
-    endDTS = Math.max(endDTS, frag.endDTS);
+    endDTS = Math.max(endDTS, frag.endDTS as number);
   }
 
   const drift = startPTS - frag.start;
@@ -101,7 +102,7 @@ export function updateFragPTSDTS(
   frag.minEndPTS = minEndPTS;
   frag.endDTS = endDTS;
 
-  const sn = frag.sn as number; // 'initSegment'
+  const sn = frag.sn;
   // exit if sn out of range
   if (!details || sn < details.startSN || sn > details.endSN) {
     return 0;
@@ -196,10 +197,10 @@ export function mergeDetails(
     },
   );
 
+  const fragmentsToCheck = newDetails.fragmentHint
+    ? newDetails.fragments.concat(newDetails.fragmentHint)
+    : newDetails.fragments;
   if (currentInitSegment) {
-    const fragmentsToCheck = newDetails.fragmentHint
-      ? newDetails.fragments.concat(newDetails.fragmentHint)
-      : newDetails.fragments;
     fragmentsToCheck.forEach((frag) => {
       if (
         frag &&
@@ -220,14 +221,30 @@ export function mergeDetails(
       for (let i = newDetails.skippedSegments; i--; ) {
         newDetails.fragments.shift();
       }
-      newDetails.startSN = newDetails.fragments[0].sn as number;
+      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,
+    } else {
+      if (newDetails.canSkipDateRanges) {
+        newDetails.dateRanges = mergeDateRanges(
+          oldDetails.dateRanges,
+          newDetails,
+        );
+      }
+      const programDateTimes = oldDetails.fragments.filter(
+        (frag) => frag.rawProgramDateTime,
       );
+      if (oldDetails.hasProgramDateTime && !newDetails.hasProgramDateTime) {
+        for (let i = 1; i < fragmentsToCheck.length; i++) {
+          if (fragmentsToCheck[i].programDateTime === null) {
+            assignProgramDateTime(
+              fragmentsToCheck[i],
+              fragmentsToCheck[i - 1],
+              programDateTimes,
+            );
+          }
+        }
+      }
+      mapDateRanges(programDateTimes, newDetails);
     }
   }
 
@@ -293,27 +310,38 @@ export function mergeDetails(
 
 function mergeDateRanges(
   oldDateRanges: Record<string, DateRange>,
-  deltaDateRanges: Record<string, DateRange>,
-  recentlyRemovedDateranges: string[] | undefined,
+  newDetails: LevelDetails,
 ): Record<string, DateRange> {
+  const { dateRanges: deltaDateRanges, recentlyRemovedDateranges } = newDetails;
   const dateRanges = Object.assign({}, oldDateRanges);
   if (recentlyRemovedDateranges) {
     recentlyRemovedDateranges.forEach((id) => {
       delete dateRanges[id];
     });
   }
-  Object.keys(deltaDateRanges).forEach((id) => {
-    const dateRange = new DateRange(deltaDateRanges[id].attr, dateRanges[id]);
-    if (dateRange.isValid) {
-      dateRanges[id] = dateRange;
-    } else {
-      logger.warn(
-        `Ignoring invalid Playlist Delta Update DATERANGE tag: "${JSON.stringify(
-          deltaDateRanges[id].attr,
-        )}"`,
+  const mergeIds = Object.keys(dateRanges);
+  const mergeCount = mergeIds.length;
+  if (mergeCount) {
+    Object.keys(deltaDateRanges).forEach((id) => {
+      const mergedDateRange = dateRanges[id];
+      const dateRange = new DateRange(
+        deltaDateRanges[id].attr,
+        mergedDateRange,
       );
-    }
-  });
+      if (dateRange.isValid) {
+        dateRanges[id] = dateRange;
+        if (!mergedDateRange) {
+          dateRange.tagOrder += mergeCount;
+        }
+      } else {
+        logger.warn(
+          `Ignoring invalid Playlist Delta Update DATERANGE tag: "${JSON.stringify(
+            deltaDateRanges[id].attr,
+          )}"`,
+        );
+      }
+    });
+  }
   return dateRanges;
 }
 
@@ -366,7 +394,7 @@ export function mapFragmentIntersection(
   for (let i = start; i <= end; i++) {
     const oldFrag = oldFrags[delta + i];
     let newFrag = newFrags[i];
-    if (skippedSegments && !newFrag && i < skippedSegments) {
+    if (skippedSegments && !newFrag && oldFrag) {
       // Fill in skipped segments in delta playlist
       newFrag = newDetails.fragments[i] = oldFrag;
     }
@@ -436,22 +464,22 @@ export function getFragmentWithSN(
   level: Level,
   sn: number,
   fragCurrent: Fragment | null,
-): Fragment | null {
-  if (!level?.details) {
+): MediaFragment | null {
+  const details = level?.details;
+  if (!details) {
     return null;
   }
-  const levelDetails = level.details;
-  let fragment: Fragment | undefined =
-    levelDetails.fragments[sn - levelDetails.startSN];
+  let fragment: MediaFragment | undefined =
+    details.fragments[sn - details.startSN];
   if (fragment) {
     return fragment;
   }
-  fragment = levelDetails.fragmentHint;
+  fragment = details.fragmentHint;
   if (fragment && fragment.sn === sn) {
     return fragment;
   }
-  if (sn < levelDetails.startSN && fragCurrent && fragCurrent.sn === sn) {
-    return fragCurrent;
+  if (sn < details.startSN && fragCurrent && fragCurrent.sn === sn) {
+    return fragCurrent as MediaFragment;
   }
   return null;
 }

package/src/utils/variable-substitution.ts

@@ -9,25 +9,6 @@ export function hasVariableReferences(str: string): boolean {
   return VARIABLE_REPLACEMENT_REGEX.test(str);
 }
 
-export function substituteVariablesInAttributes(
-  parsed: Pick<
-    ParsedMultivariantPlaylist | LevelDetails,
-    'variableList' | 'hasVariableRefs' | 'playlistParsingError'
-  >,
-  attr: AttrList,
-  attributeNames: string[],
-) {
-  if (parsed.variableList !== null || parsed.hasVariableRefs) {
-    for (let i = attributeNames.length; i--; ) {
-      const name = attributeNames[i];
-      const value = attr[name];
-      if (value) {
-        attr[name] = substituteVariables(parsed, value);
-      }
-    }
-  }
-}
-
 export function substituteVariables(
   parsed: Pick<
     ParsedMultivariantPlaylist | LevelDetails,