hls.js 1.5.14-0.canary.10559 → 1.5.15

package/src/loader/m3u8-parser.ts

@@ -1,6 +1,6 @@
 import { buildAbsoluteURL } from 'url-toolkit';
 import { DateRange } from './date-range';
-import { Fragment, MediaFragment, Part } from './fragment';
+import { Fragment, Part } from './fragment';
 import { LevelDetails } from './level-details';
 import { LevelKey } from './level-key';
 import { AttrList } from '../utils/attr-list';
@@ -10,6 +10,7 @@ import {
   hasVariableReferences,
   importVariableDefinition,
   substituteVariables,
+  substituteVariablesInAttributes,
 } from '../utils/variable-substitution';
 import { isCodecType } from '../utils/codecs';
 import type { CodecType } from '../utils/codecs';
@@ -119,7 +120,21 @@ export default class M3U8Parser {
     while ((result = MASTER_PLAYLIST_REGEX.exec(string)) != null) {
       if (result[1]) {
         // '#EXT-X-STREAM-INF' is found, parse level tag  in group 1
-        const attrs = new AttrList(result[1], parsed) as LevelAttributes;
+        const attrs = new AttrList(result[1]) as LevelAttributes;
+        if (__USE_VARIABLE_SUBSTITUTION__) {
+          substituteVariablesInAttributes(parsed, attrs, [
+            'CODECS',
+            'SUPPLEMENTAL-CODECS',
+            'ALLOWED-CPC',
+            'PATHWAY-ID',
+            'STABLE-VARIANT-ID',
+            'AUDIO',
+            'VIDEO',
+            'SUBTITLES',
+            'CLOSED-CAPTIONS',
+            'NAME',
+          ]);
+        }
         const uri = __USE_VARIABLE_SUBSTITUTION__
           ? substituteVariables(parsed, result[2])
           : result[2];
@@ -151,7 +166,15 @@ export default class M3U8Parser {
         switch (tag) {
           case 'SESSION-DATA': {
             // #EXT-X-SESSION-DATA
-            const sessionAttrs = new AttrList(attributes, parsed);
+            const sessionAttrs = new AttrList(attributes);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(parsed, sessionAttrs, [
+                'DATA-ID',
+                'LANGUAGE',
+                'VALUE',
+                'URI',
+              ]);
+            }
             const dataId = sessionAttrs['DATA-ID'];
             if (dataId) {
               if (parsed.sessionData === null) {
@@ -179,14 +202,26 @@ export default class M3U8Parser {
           case 'DEFINE': {
             // #EXT-X-DEFINE
             if (__USE_VARIABLE_SUBSTITUTION__) {
-              const variableAttributes = new AttrList(attributes, parsed);
+              const variableAttributes = new AttrList(attributes);
+              substituteVariablesInAttributes(parsed, variableAttributes, [
+                'NAME',
+                'VALUE',
+                'QUERYPARAM',
+              ]);
               addVariableDefinition(parsed, variableAttributes, baseurl);
             }
             break;
           }
           case 'CONTENT-STEERING': {
             // #EXT-X-CONTENT-STEERING
-            const contentSteeringAttributes = new AttrList(attributes, parsed);
+            const contentSteeringAttributes = new AttrList(attributes);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(
+                parsed,
+                contentSteeringAttributes,
+                ['SERVER-URI', 'PATHWAY-ID'],
+              );
+            }
             parsed.contentSteering = {
               uri: M3U8Parser.resolve(
                 contentSteeringAttributes['SERVER-URI'],
@@ -243,13 +278,26 @@ export default class M3U8Parser {
     let id = 0;
     MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0;
     while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) {
-      const attrs = new AttrList(result[1], parsed) as MediaAttributes;
+      const attrs = new AttrList(result[1]) as MediaAttributes;
       const type = attrs.TYPE;
       if (type) {
         const groups: (typeof groupsByType)[keyof typeof groupsByType] =
           groupsByType[type];
         const medias: MediaPlaylist[] = results[type] || [];
         results[type] = medias;
+        if (__USE_VARIABLE_SUBSTITUTION__) {
+          substituteVariablesInAttributes(parsed, attrs, [
+            'URI',
+            'GROUP-ID',
+            'LANGUAGE',
+            'ASSOC-LANGUAGE',
+            'STABLE-RENDITION-ID',
+            'NAME',
+            'INSTREAM-ID',
+            'CHARACTERISTICS',
+            'CHANNELS',
+          ]);
+        }
         const lang = attrs.LANGUAGE;
         const assocLang = attrs['ASSOC-LANGUAGE'];
         const channels = attrs.CHANNELS;
@@ -307,7 +355,6 @@ export default class M3U8Parser {
   ): LevelDetails {
     const level = new LevelDetails(baseurl);
     const fragments: M3U8ParserFragments = level.fragments;
-    const programDateTimes: MediaFragment[] = [];
     // The most recent init segment seen (applies to all subsequent segments)
     let currentInitSegment: Fragment | null = null;
     let currentSN = 0;
@@ -373,11 +420,7 @@ export default class M3U8Parser {
           frag.relurl = __USE_VARIABLE_SUBSTITUTION__
             ? substituteVariables(level, uri)
             : uri;
-          assignProgramDateTime(
-            frag as MediaFragment,
-            prevFrag as MediaFragment,
-            programDateTimes,
-          );
+          assignProgramDateTime(frag, prevFrag);
           prevFrag = frag;
           totalduration += frag.duration;
           currentSN++;
@@ -425,19 +468,19 @@ export default class M3U8Parser {
             currentSN = level.startSN = parseInt(value1);
             break;
           case 'SKIP': {
-            if (level.skippedSegments) {
-              level.playlistParsingError = new Error(
-                `#EXT-X-SKIP MUST NOT appear more than once in a Playlist`,
-              );
+            const skipAttrs = new AttrList(value1);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(level, skipAttrs, [
+                'RECENTLY-REMOVED-DATERANGES',
+              ]);
             }
-            const skipAttrs = new AttrList(value1, level);
             const skippedSegments =
               skipAttrs.decimalInteger('SKIPPED-SEGMENTS');
             if (Number.isFinite(skippedSegments)) {
-              level.skippedSegments += skippedSegments;
+              level.skippedSegments = skippedSegments;
               // This will result in fragments[] containing undefined values, which we will fill in with `mergeDetails`
               for (let i = skippedSegments; i--; ) {
-                fragments.push(null);
+                fragments.unshift(null);
               }
               currentSN += skippedSegments;
             }
@@ -445,9 +488,8 @@ export default class M3U8Parser {
               'RECENTLY-REMOVED-DATERANGES',
             );
             if (recentlyRemovedDateranges) {
-              level.recentlyRemovedDateranges = (
-                level.recentlyRemovedDateranges || []
-              ).concat(recentlyRemovedDateranges.split('\t'));
+              level.recentlyRemovedDateranges =
+                recentlyRemovedDateranges.split('\t');
             }
             break;
           }
@@ -480,13 +522,27 @@ export default class M3U8Parser {
             frag.tagList.push([tag, value1]);
             break;
           case 'DATERANGE': {
-            const dateRangeAttr = new AttrList(value1, level);
+            const dateRangeAttr = new AttrList(value1);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(level, dateRangeAttr, [
+                'ID',
+                'CLASS',
+                'START-DATE',
+                'END-DATE',
+                'SCTE35-CMD',
+                'SCTE35-OUT',
+                'SCTE35-IN',
+              ]);
+              substituteVariablesInAttributes(
+                level,
+                dateRangeAttr,
+                dateRangeAttr.clientAttrs,
+              );
+            }
             const dateRange = new DateRange(
               dateRangeAttr,
               level.dateRanges[dateRangeAttr.ID],
-              level.dateRangeTagCount,
             );
-            level.dateRangeTagCount++;
             if (dateRange.isValid || level.skippedSegments) {
               level.dateRanges[dateRange.id] = dateRange;
             } else {
@@ -498,7 +554,13 @@ export default class M3U8Parser {
           }
           case 'DEFINE': {
             if (__USE_VARIABLE_SUBSTITUTION__) {
-              const variableAttributes = new AttrList(value1, level);
+              const variableAttributes = new AttrList(value1);
+              substituteVariablesInAttributes(level, variableAttributes, [
+                'NAME',
+                'VALUE',
+                'IMPORT',
+                'QUERYPARAM',
+              ]);
               if ('IMPORT' in variableAttributes) {
                 importVariableDefinition(
                   level,
@@ -538,7 +600,13 @@ export default class M3U8Parser {
             level.startTimeOffset = parseStartTimeOffset(value1);
             break;
           case 'MAP': {
-            const mapAttrs = new AttrList(value1, level);
+            const mapAttrs = new AttrList(value1);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(level, mapAttrs, [
+                'BYTERANGE',
+                'URI',
+              ]);
+            }
             if (frag.duration) {
               // Initial segment tag is after segment duration tag.
               //   #EXTINF: 6.0
@@ -567,7 +635,6 @@ export default class M3U8Parser {
               currentInitSegment = frag;
               createNextFrag = true;
             }
-            currentInitSegment.cc = discontinuityCounter;
             break;
           }
           case 'SERVER-CONTROL': {
@@ -600,10 +667,16 @@ export default class M3U8Parser {
             const previousFragmentPart =
               currentPart > 0 ? partList[partList.length - 1] : undefined;
             const index = currentPart++;
-            const partAttrs = new AttrList(value1, level);
+            const partAttrs = new AttrList(value1);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(level, partAttrs, [
+                'BYTERANGE',
+                'URI',
+              ]);
+            }
             const part = new Part(
               partAttrs,
-              frag as MediaFragment,
+              frag,
               baseurl,
               index,
               previousFragmentPart,
@@ -613,12 +686,20 @@ export default class M3U8Parser {
             break;
           }
           case 'PRELOAD-HINT': {
-            const preloadHintAttrs = new AttrList(value1, level);
+            const preloadHintAttrs = new AttrList(value1);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(level, preloadHintAttrs, ['URI']);
+            }
             level.preloadHint = preloadHintAttrs;
             break;
           }
           case 'RENDITION-REPORT': {
-            const renditionReportAttrs = new AttrList(value1, level);
+            const renditionReportAttrs = new AttrList(value1);
+            if (__USE_VARIABLE_SUBSTITUTION__) {
+              substituteVariablesInAttributes(level, renditionReportAttrs, [
+                'URI',
+              ]);
+            }
             level.renditionReports = level.renditionReports || [];
             level.renditionReports.push(renditionReportAttrs);
             break;
@@ -633,16 +714,12 @@ export default class M3U8Parser {
       fragments.pop();
       totalduration -= prevFrag.duration;
       if (level.partList) {
-        level.fragmentHint = prevFrag as MediaFragment;
+        level.fragmentHint = prevFrag;
       }
     } else if (level.partList) {
-      assignProgramDateTime(
-        frag as MediaFragment,
-        prevFrag as MediaFragment,
-        programDateTimes,
-      );
+      assignProgramDateTime(frag, prevFrag);
       frag.cc = discontinuityCounter;
-      level.fragmentHint = frag as MediaFragment;
+      level.fragmentHint = frag;
       if (levelkeys) {
         setFragLevelKeys(frag, levelkeys, level);
       }
@@ -661,21 +738,6 @@ export default class M3U8Parser {
       if (firstFragment) {
         level.startCC = firstFragment.cc;
       }
-      /**
-       * Backfill any missing PDT values
-       * "If the first EXT-X-PROGRAM-DATE-TIME tag in a Playlist appears after
-       * one or more Media Segment URIs, the client SHOULD extrapolate
-       * backward from that tag (using EXTINF durations and/or media
-       * timestamps) to associate dates with those segments."
-       * We have already extrapolated forward, but all fragments up to the first instance of PDT do not have their PDTs
-       * computed.
-       */
-      if (firstPdtIndex > 0) {
-        backfillProgramDateTimes(fragments, firstPdtIndex);
-        if (firstFragment) {
-          programDateTimes.unshift(firstFragment as MediaFragment);
-        }
-      }
     } else {
       level.endSN = 0;
       level.startCC = 0;
@@ -684,83 +746,23 @@ export default class M3U8Parser {
       totalduration += level.fragmentHint.duration;
     }
     level.totalduration = totalduration;
-    if (programDateTimes.length && level.dateRangeTagCount && firstFragment) {
-      mapDateRanges(programDateTimes, level);
-    }
-
     level.endCC = discontinuityCounter;
 
-    return level;
-  }
-}
-
-export function mapDateRanges(
-  programDateTimes: MediaFragment[],
-  details: LevelDetails,
-) {
-  // Make sure DateRanges are mapped to a ProgramDateTime tag that applies a date to a segment that overlaps with its start date
-  const programDateTimeCount = programDateTimes.length;
-  const lastProgramDateTime = programDateTimes[programDateTimeCount - 1];
-  const playlistEnd = details.live ? Infinity : details.totalduration;
-  const dateRangeIds = Object.keys(details.dateRanges);
-  for (let i = dateRangeIds.length; i--; ) {
-    const dateRange = details.dateRanges[dateRangeIds[i]];
-    const startDateTime = dateRange.startDate.getTime();
-    dateRange.tagAnchor = lastProgramDateTime;
-    for (let j = programDateTimeCount; j--; ) {
-      const fragIndex = findFragmentWithStartDate(
-        details,
-        startDateTime,
-        programDateTimes,
-        j,
-        playlistEnd,
-      );
-      if (fragIndex !== -1) {
-        dateRange.tagAnchor = details.fragments[fragIndex];
-        break;
-      }
+    /**
+     * Backfill any missing PDT values
+     * "If the first EXT-X-PROGRAM-DATE-TIME tag in a Playlist appears after
+     * one or more Media Segment URIs, the client SHOULD extrapolate
+     * backward from that tag (using EXTINF durations and/or media
+     * timestamps) to associate dates with those segments."
+     * We have already extrapolated forward, but all fragments up to the first instance of PDT do not have their PDTs
+     * computed.
+     */
+    if (firstPdtIndex > 0) {
+      backfillProgramDateTimes(fragments, firstPdtIndex);
     }
-  }
-}
 
-function findFragmentWithStartDate(
-  details: LevelDetails,
-  startDateTime: number,
-  programDateTimes: MediaFragment[],
-  index: number,
-  endTime: number,
-): number {
-  const pdtFragment = programDateTimes[index];
-  if (pdtFragment) {
-    // find matching range between PDT tags
-    const durationBetweenPdt =
-      (programDateTimes[index + 1]?.start || endTime) - pdtFragment.start;
-    const pdtStart = pdtFragment.programDateTime as number;
-    if (
-      (startDateTime >= pdtStart || index === 0) &&
-      startDateTime <= pdtStart + durationBetweenPdt * 1000
-    ) {
-      // map to fragment with date-time range
-      const startIndex = programDateTimes[index].sn - details.startSN;
-      const fragments = details.fragments;
-      if (fragments.length > programDateTimes.length) {
-        const endSegment =
-          programDateTimes[index + 1] || fragments[fragments.length - 1];
-        const endIndex = endSegment.sn - details.startSN;
-        for (let i = endIndex; i > startIndex; i--) {
-          const fragStartDateTime = fragments[i].programDateTime as number;
-          if (
-            startDateTime >= fragStartDateTime &&
-            startDateTime < fragStartDateTime + fragments[i].duration * 1000
-          ) {
-            return i;
-          }
-        }
-      }
-      return startIndex;
-    }
+    return level;
   }
-  return -1;
 }
 
 function parseKey(
@@ -769,7 +771,16 @@ function parseKey(
   parsed: ParsedMultivariantPlaylist | LevelDetails,
 ): LevelKey {
   // https://tools.ietf.org/html/rfc8216#section-4.3.2.4
-  const keyAttrs = new AttrList(keyTagAttributes, parsed);
+  const keyAttrs = new AttrList(keyTagAttributes);
+  if (__USE_VARIABLE_SUBSTITUTION__) {
+    substituteVariablesInAttributes(parsed, keyAttrs, [
+      'KEYFORMAT',
+      'KEYFORMATVERSIONS',
+      'URI',
+      'IV',
+      'URI',
+    ]);
+  }
   const decryptmethod = keyAttrs.METHOD ?? '';
   const decrypturi = keyAttrs.URI;
   const decryptiv = keyAttrs.hexadecimalInteger('IV');
@@ -853,22 +864,17 @@ function backfillProgramDateTimes(
   }
 }
 
-export function assignProgramDateTime(
-  frag: MediaFragment,
-  prevFrag: MediaFragment | null,
-  programDateTimes: MediaFragment[],
-) {
+function assignProgramDateTime(frag, prevFrag) {
   if (frag.rawProgramDateTime) {
     frag.programDateTime = Date.parse(frag.rawProgramDateTime);
-    if (!Number.isFinite(frag.programDateTime)) {
-      frag.programDateTime = null;
-      frag.rawProgramDateTime = null;
-      return;
-    }
-    programDateTimes.push(frag);
   } else if (prevFrag?.programDateTime) {
     frag.programDateTime = prevFrag.endProgramDateTime;
   }
+
+  if (!Number.isFinite(frag.programDateTime)) {
+    frag.programDateTime = null;
+    frag.rawProgramDateTime = null;
+  }
 }
 
 function setInitSegment(

package/src/loader/playlist-loader.ts

@@ -8,6 +8,7 @@
 
 import { Events } from '../events';
 import { ErrorDetails, ErrorTypes } from '../errors';
+import { logger } from '../utils/logger';
 import M3U8Parser from './m3u8-parser';
 import type { LevelParsed, VariableMap } from '../types/level';
 import type {
@@ -220,10 +221,10 @@ class PlaylistLoader implements NetworkComponentAPI {
         loaderContext.level === context.level
       ) {
         // same URL can't overlap
-        this.hls.logger.trace('[playlist-loader]: playlist request ongoing');
+        logger.trace('[playlist-loader]: playlist request ongoing');
         return;
       }
-      this.hls.logger.log(
+      logger.log(
         `[playlist-loader]: aborting previous loader for type: ${context.type}`,
       );
       loader.abort();
@@ -407,7 +408,7 @@ class PlaylistLoader implements NetworkComponentAPI {
         levels[0].audioCodec &&
         !levels[0].attrs.AUDIO
       ) {
-        this.hls.logger.log(
+        logger.log(
           '[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one',
         );
         audioTracks.unshift({
@@ -452,6 +453,7 @@ class PlaylistLoader implements NetworkComponentAPI {
     const { id, level, type } = context;
 
     const url = getResponseUrl(response, context);
+    const levelUrlId = 0;
     const levelId = Number.isFinite(level as number)
       ? (level as number)
       : Number.isFinite(id as number)
@@ -463,7 +465,7 @@ class PlaylistLoader implements NetworkComponentAPI {
       url,
       levelId,
       levelType,
-      0,
+      levelUrlId,
       this.variableList,
     );
 
@@ -553,7 +555,7 @@ class PlaylistLoader implements NetworkComponentAPI {
       message += ` id: ${context.id} group-id: "${context.groupId}"`;
     }
     const error = new Error(message);
-    this.hls.logger.warn(`[playlist-loader]: ${message}`);
+    logger.warn(`[playlist-loader]: ${message}`);
     let details = ErrorDetails.UNKNOWN;
     let fatal = false;