hls.js 1.5.13 → 1.5.14-0.canary.10417

package/src/loader/fragment.ts

@@ -90,6 +90,10 @@ export class BaseSegment {
   }
 }
 
+export interface MediaFragment extends Fragment {
+  sn: number;
+}
+
 /**
  * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
  */
@@ -123,9 +127,9 @@ export class Fragment extends BaseSegment {
   // The ending Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
   public endPTS?: number;
   // The starting Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
-  public startDTS!: number;
+  public startDTS?: number;
   // The ending Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
-  public endDTS!: number;
+  public endDTS?: number;
   // The start time of the fragment, as listed in the manifest. Updated after transmux complete.
   public start: number = 0;
   // Set by `updateFragPTSDTS` in level-helper
@@ -274,13 +278,13 @@ export class Part extends BaseSegment {
   public readonly gap: boolean = false;
   public readonly independent: boolean = false;
   public readonly relurl: string;
-  public readonly fragment: Fragment;
+  public readonly fragment: MediaFragment;
   public readonly index: number;
   public stats: LoadStats = new LoadStats();
 
   constructor(
     partAttrs: AttrList,
-    frag: Fragment,
+    frag: MediaFragment,
     baseurl: string,
     index: number,
     previous?: Part,

package/src/loader/key-loader.ts

@@ -1,5 +1,5 @@
 import { ErrorTypes, ErrorDetails } from '../errors';
-import {
+import type {
   LoaderStats,
   LoaderResponse,
   LoaderConfiguration,
@@ -194,6 +194,8 @@ export default class KeyLoader implements ComponentAPI {
         }
         return this.loadKeyEME(keyInfo, frag);
       case 'AES-128':
+      case 'AES-256':
+      case 'AES-256-CTR':
         return this.loadKeyHTTP(keyInfo, frag);
       default:
         return Promise.reject(

package/src/loader/level-details.ts

@@ -1,7 +1,6 @@
-import { Part } from './fragment';
-import type { Fragment } from './fragment';
-import type { AttrList } from '../utils/attr-list';
+import type { Fragment, MediaFragment, Part } from './fragment';
 import type { DateRange } from './date-range';
+import type { AttrList } from '../utils/attr-list';
 import type { VariableMap } from '../types/level';
 
 const DEFAULT_TARGET_DURATION = 10;
@@ -15,10 +14,11 @@ export class LevelDetails {
   public averagetargetduration?: number;
   public endCC: number = 0;
   public endSN: number = 0;
-  public fragments: Fragment[];
-  public fragmentHint?: Fragment;
+  public fragments: MediaFragment[];
+  public fragmentHint?: MediaFragment;
   public partList: Part[] | null = null;
   public dateRanges: Record<string, DateRange>;
+  public dateRangeTagCount: number = 0;
   public live: boolean = true;
   public ageHeader: number = 0;
   public advancedDateTime?: number;
@@ -148,7 +148,7 @@ export class LevelDetails {
 
   get lastPartSn(): number {
     if (this.partList?.length) {
-      return this.partList[this.partList.length - 1].fragment.sn as number;
+      return this.partList[this.partList.length - 1].fragment.sn;
     }
     return this.endSN;
   }

package/src/loader/level-key.ts

@@ -2,6 +2,7 @@ import {
   changeEndianness,
   convertDataUriToArrayBytes,
 } from '../utils/keysystem-util';
+import { isFullSegmentEncryption } from '../utils/encryption-methods-util';
 import { KeySystemFormats } from '../utils/mediakeys-helper';
 import { mp4pssh } from '../utils/mp4-tools';
 import { logger } from '../utils/logger';
@@ -51,13 +52,14 @@ export class LevelKey implements DecryptData {
     this.keyFormatVersions = formatversions;
     this.iv = iv;
     this.encrypted = method ? method !== 'NONE' : false;
-    this.isCommonEncryption = this.encrypted && method !== 'AES-128';
+    this.isCommonEncryption =
+      this.encrypted && !isFullSegmentEncryption(method);
   }
 
   public isSupported(): boolean {
     // If it's Segment encryption or No encryption, just select that key system
     if (this.method) {
-      if (this.method === 'AES-128' || this.method === 'NONE') {
+      if (isFullSegmentEncryption(this.method) || this.method === 'NONE') {
         return true;
       }
       if (this.keyFormat === 'identity') {
@@ -88,16 +90,15 @@ export class LevelKey implements DecryptData {
       return null;
     }
 
-    if (this.method === 'AES-128' && this.uri && !this.iv) {
+    if (isFullSegmentEncryption(this.method) && this.uri && !this.iv) {
       if (typeof sn !== 'number') {
         // We are fetching decryption data for a initialization segment
-        // If the segment was encrypted with AES-128
+        // If the segment was encrypted with AES-128/256
         // It must have an IV defined. We cannot substitute the Segment Number in.
-        if (this.method === 'AES-128' && !this.iv) {
-          logger.warn(
-            `missing IV for initialization segment with method="${this.method}" - compliance issue`,
-          );
-        }
+        logger.warn(
+          `missing IV for initialization segment with method="${this.method}" - compliance issue`,
+        );
+
         // Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
         sn = 0;
       }

package/src/loader/m3u8-parser.ts

@@ -1,6 +1,6 @@
 import { buildAbsoluteURL } from 'url-toolkit';
 import { DateRange } from './date-range';
-import { Fragment, Part } from './fragment';
+import { Fragment, MediaFragment, Part } from './fragment';
 import { LevelDetails } from './level-details';
 import { LevelKey } from './level-key';
 import { AttrList } from '../utils/attr-list';
@@ -10,7 +10,6 @@ import {
   hasVariableReferences,
   importVariableDefinition,
   substituteVariables,
-  substituteVariablesInAttributes,
 } from '../utils/variable-substitution';
 import { isCodecType } from '../utils/codecs';
 import type { CodecType } from '../utils/codecs';
@@ -120,21 +119,7 @@ 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]) 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 attrs = new AttrList(result[1], parsed) as LevelAttributes;
         const uri = __USE_VARIABLE_SUBSTITUTION__
           ? substituteVariables(parsed, result[2])
           : result[2];
@@ -166,15 +151,7 @@ export default class M3U8Parser {
         switch (tag) {
           case 'SESSION-DATA': {
             // #EXT-X-SESSION-DATA
-            const sessionAttrs = new AttrList(attributes);
-            if (__USE_VARIABLE_SUBSTITUTION__) {
-              substituteVariablesInAttributes(parsed, sessionAttrs, [
-                'DATA-ID',
-                'LANGUAGE',
-                'VALUE',
-                'URI',
-              ]);
-            }
+            const sessionAttrs = new AttrList(attributes, parsed);
             const dataId = sessionAttrs['DATA-ID'];
             if (dataId) {
               if (parsed.sessionData === null) {
@@ -202,26 +179,14 @@ export default class M3U8Parser {
           case 'DEFINE': {
             // #EXT-X-DEFINE
             if (__USE_VARIABLE_SUBSTITUTION__) {
-              const variableAttributes = new AttrList(attributes);
-              substituteVariablesInAttributes(parsed, variableAttributes, [
-                'NAME',
-                'VALUE',
-                'QUERYPARAM',
-              ]);
+              const variableAttributes = new AttrList(attributes, parsed);
               addVariableDefinition(parsed, variableAttributes, baseurl);
             }
             break;
           }
           case 'CONTENT-STEERING': {
             // #EXT-X-CONTENT-STEERING
-            const contentSteeringAttributes = new AttrList(attributes);
-            if (__USE_VARIABLE_SUBSTITUTION__) {
-              substituteVariablesInAttributes(
-                parsed,
-                contentSteeringAttributes,
-                ['SERVER-URI', 'PATHWAY-ID'],
-              );
-            }
+            const contentSteeringAttributes = new AttrList(attributes, parsed);
             parsed.contentSteering = {
               uri: M3U8Parser.resolve(
                 contentSteeringAttributes['SERVER-URI'],
@@ -278,26 +243,13 @@ 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]) as MediaAttributes;
+      const attrs = new AttrList(result[1], parsed) 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;
@@ -355,6 +307,7 @@ 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;
@@ -420,7 +373,11 @@ export default class M3U8Parser {
           frag.relurl = __USE_VARIABLE_SUBSTITUTION__
             ? substituteVariables(level, uri)
             : uri;
-          assignProgramDateTime(frag, prevFrag);
+          assignProgramDateTime(
+            frag as MediaFragment,
+            prevFrag as MediaFragment,
+            programDateTimes,
+          );
           prevFrag = frag;
           totalduration += frag.duration;
           currentSN++;
@@ -468,19 +425,19 @@ export default class M3U8Parser {
             currentSN = level.startSN = parseInt(value1);
             break;
           case 'SKIP': {
-            const skipAttrs = new AttrList(value1);
-            if (__USE_VARIABLE_SUBSTITUTION__) {
-              substituteVariablesInAttributes(level, skipAttrs, [
-                'RECENTLY-REMOVED-DATERANGES',
-              ]);
+            if (level.skippedSegments) {
+              level.playlistParsingError = new Error(
+                `#EXT-X-SKIP MUST NOT appear more than once in a Playlist`,
+              );
             }
+            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.unshift(null);
+                fragments.push(null);
               }
               currentSN += skippedSegments;
             }
@@ -488,8 +445,9 @@ export default class M3U8Parser {
               'RECENTLY-REMOVED-DATERANGES',
             );
             if (recentlyRemovedDateranges) {
-              level.recentlyRemovedDateranges =
-                recentlyRemovedDateranges.split('\t');
+              level.recentlyRemovedDateranges = (
+                level.recentlyRemovedDateranges || []
+              ).concat(recentlyRemovedDateranges.split('\t'));
             }
             break;
           }
@@ -522,27 +480,13 @@ export default class M3U8Parser {
             frag.tagList.push([tag, value1]);
             break;
           case 'DATERANGE': {
-            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 dateRangeAttr = new AttrList(value1, level);
             const dateRange = new DateRange(
               dateRangeAttr,
               level.dateRanges[dateRangeAttr.ID],
+              level.dateRangeTagCount,
             );
+            level.dateRangeTagCount++;
             if (dateRange.isValid || level.skippedSegments) {
               level.dateRanges[dateRange.id] = dateRange;
             } else {
@@ -554,13 +498,7 @@ export default class M3U8Parser {
           }
           case 'DEFINE': {
             if (__USE_VARIABLE_SUBSTITUTION__) {
-              const variableAttributes = new AttrList(value1);
-              substituteVariablesInAttributes(level, variableAttributes, [
-                'NAME',
-                'VALUE',
-                'IMPORT',
-                'QUERYPARAM',
-              ]);
+              const variableAttributes = new AttrList(value1, level);
               if ('IMPORT' in variableAttributes) {
                 importVariableDefinition(
                   level,
@@ -600,13 +538,7 @@ export default class M3U8Parser {
             level.startTimeOffset = parseStartTimeOffset(value1);
             break;
           case 'MAP': {
-            const mapAttrs = new AttrList(value1);
-            if (__USE_VARIABLE_SUBSTITUTION__) {
-              substituteVariablesInAttributes(level, mapAttrs, [
-                'BYTERANGE',
-                'URI',
-              ]);
-            }
+            const mapAttrs = new AttrList(value1, level);
             if (frag.duration) {
               // Initial segment tag is after segment duration tag.
               //   #EXTINF: 6.0
@@ -635,6 +567,7 @@ export default class M3U8Parser {
               currentInitSegment = frag;
               createNextFrag = true;
             }
+            currentInitSegment.cc = discontinuityCounter;
             break;
           }
           case 'SERVER-CONTROL': {
@@ -667,16 +600,10 @@ export default class M3U8Parser {
             const previousFragmentPart =
               currentPart > 0 ? partList[partList.length - 1] : undefined;
             const index = currentPart++;
-            const partAttrs = new AttrList(value1);
-            if (__USE_VARIABLE_SUBSTITUTION__) {
-              substituteVariablesInAttributes(level, partAttrs, [
-                'BYTERANGE',
-                'URI',
-              ]);
-            }
+            const partAttrs = new AttrList(value1, level);
             const part = new Part(
               partAttrs,
-              frag,
+              frag as MediaFragment,
               baseurl,
               index,
               previousFragmentPart,
@@ -686,20 +613,12 @@ export default class M3U8Parser {
             break;
           }
           case 'PRELOAD-HINT': {
-            const preloadHintAttrs = new AttrList(value1);
-            if (__USE_VARIABLE_SUBSTITUTION__) {
-              substituteVariablesInAttributes(level, preloadHintAttrs, ['URI']);
-            }
+            const preloadHintAttrs = new AttrList(value1, level);
             level.preloadHint = preloadHintAttrs;
             break;
           }
           case 'RENDITION-REPORT': {
-            const renditionReportAttrs = new AttrList(value1);
-            if (__USE_VARIABLE_SUBSTITUTION__) {
-              substituteVariablesInAttributes(level, renditionReportAttrs, [
-                'URI',
-              ]);
-            }
+            const renditionReportAttrs = new AttrList(value1, level);
             level.renditionReports = level.renditionReports || [];
             level.renditionReports.push(renditionReportAttrs);
             break;
@@ -714,12 +633,16 @@ export default class M3U8Parser {
       fragments.pop();
       totalduration -= prevFrag.duration;
       if (level.partList) {
-        level.fragmentHint = prevFrag;
+        level.fragmentHint = prevFrag as MediaFragment;
       }
     } else if (level.partList) {
-      assignProgramDateTime(frag, prevFrag);
+      assignProgramDateTime(
+        frag as MediaFragment,
+        prevFrag as MediaFragment,
+        programDateTimes,
+      );
       frag.cc = discontinuityCounter;
-      level.fragmentHint = frag;
+      level.fragmentHint = frag as MediaFragment;
       if (levelkeys) {
         setFragLevelKeys(frag, levelkeys, level);
       }
@@ -738,6 +661,21 @@ 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;
@@ -746,23 +684,83 @@ export default class M3U8Parser {
       totalduration += level.fragmentHint.duration;
     }
     level.totalduration = totalduration;
+    if (programDateTimes.length && level.dateRangeTagCount && firstFragment) {
+      mapDateRanges(programDateTimes, level);
+    }
+
     level.endCC = discontinuityCounter;
 
-    /**
-     * 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);
+    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;
+      }
     }
+  }
+}
 
-    return level;
+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 -1;
 }
 
 function parseKey(
@@ -771,16 +769,7 @@ function parseKey(
   parsed: ParsedMultivariantPlaylist | LevelDetails,
 ): LevelKey {
   // https://tools.ietf.org/html/rfc8216#section-4.3.2.4
-  const keyAttrs = new AttrList(keyTagAttributes);
-  if (__USE_VARIABLE_SUBSTITUTION__) {
-    substituteVariablesInAttributes(parsed, keyAttrs, [
-      'KEYFORMAT',
-      'KEYFORMATVERSIONS',
-      'URI',
-      'IV',
-      'URI',
-    ]);
-  }
+  const keyAttrs = new AttrList(keyTagAttributes, parsed);
   const decryptmethod = keyAttrs.METHOD ?? '';
   const decrypturi = keyAttrs.URI;
   const decryptiv = keyAttrs.hexadecimalInteger('IV');
@@ -864,17 +853,22 @@ function backfillProgramDateTimes(
   }
 }
 
-function assignProgramDateTime(frag, prevFrag) {
+export function assignProgramDateTime(
+  frag: MediaFragment,
+  prevFrag: MediaFragment | null,
+  programDateTimes: MediaFragment[],
+) {
   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,7 +8,6 @@
 
 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 {
@@ -221,10 +220,10 @@ class PlaylistLoader implements NetworkComponentAPI {
         loaderContext.level === context.level
       ) {
         // same URL can't overlap
-        logger.trace('[playlist-loader]: playlist request ongoing');
+        this.hls.logger.trace('[playlist-loader]: playlist request ongoing');
         return;
       }
-      logger.log(
+      this.hls.logger.log(
         `[playlist-loader]: aborting previous loader for type: ${context.type}`,
       );
       loader.abort();
@@ -408,7 +407,7 @@ class PlaylistLoader implements NetworkComponentAPI {
         levels[0].audioCodec &&
         !levels[0].attrs.AUDIO
       ) {
-        logger.log(
+        this.hls.logger.log(
           '[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one',
         );
         audioTracks.unshift({
@@ -453,7 +452,6 @@ 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)
@@ -465,7 +463,7 @@ class PlaylistLoader implements NetworkComponentAPI {
       url,
       levelId,
       levelType,
-      levelUrlId,
+      0,
       this.variableList,
     );
 
@@ -555,7 +553,7 @@ class PlaylistLoader implements NetworkComponentAPI {
       message += ` id: ${context.id} group-id: "${context.groupId}"`;
     }
     const error = new Error(message);
-    logger.warn(`[playlist-loader]: ${message}`);
+    this.hls.logger.warn(`[playlist-loader]: ${message}`);
     let details = ErrorDetails.UNKNOWN;
     let fatal = false;