hls.js 1.5.14-0.canary.10517 → 1.5.14

package/src/utils/level-helper.ts

@@ -3,17 +3,16 @@
  */
 
 import { logger } from './logger';
-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 { Fragment, Part } from '../loader/fragment';
+import { LevelDetails } from '../loader/level-details';
 import type { Level } from '../types/level';
+import { DateRange } from '../loader/date-range';
 
 type FragmentIntersection = (oldFrag: Fragment, newFrag: Fragment) => void;
 type PartIntersection = (oldPart: Part, newPart: Part) => void;
 
 export function updatePTS(
-  fragments: MediaFragment[],
+  fragments: Fragment[],
   fromIdx: number,
   toIdx: number,
 ): void {
@@ -22,7 +21,7 @@ export function updatePTS(
   updateFromToPTS(fragFrom, fragTo);
 }
 
-function updateFromToPTS(fragFrom: MediaFragment, fragTo: MediaFragment) {
+function updateFromToPTS(fragFrom: Fragment, fragTo: Fragment) {
   const fragToPTS = fragTo.startPTS as number;
   // if we know startPTS[toIdx]
   if (Number.isFinite(fragToPTS)) {
@@ -56,7 +55,7 @@ function updateFromToPTS(fragFrom: MediaFragment, fragTo: MediaFragment) {
 
 export function updateFragPTSDTS(
   details: LevelDetails | undefined,
-  frag: MediaFragment,
+  frag: Fragment,
   startPTS: number,
   endPTS: number,
   startDTS: number,
@@ -83,11 +82,11 @@ export function updateFragPTSDTS(
 
     maxStartPTS = Math.max(startPTS, fragStartPts);
     startPTS = Math.min(startPTS, fragStartPts);
-    startDTS = Math.min(startDTS, frag.startDTS as number);
+    startDTS = Math.min(startDTS, frag.startDTS);
 
     minEndPTS = Math.min(endPTS, fragEndPts);
     endPTS = Math.max(endPTS, fragEndPts);
-    endDTS = Math.max(endDTS, frag.endDTS as number);
+    endDTS = Math.max(endDTS, frag.endDTS);
   }
 
   const drift = startPTS - frag.start;
@@ -102,7 +101,7 @@ export function updateFragPTSDTS(
   frag.minEndPTS = minEndPTS;
   frag.endDTS = endDTS;
 
-  const sn = frag.sn;
+  const sn = frag.sn as number; // 'initSegment'
   // exit if sn out of range
   if (!details || sn < details.startSN || sn > details.endSN) {
     return 0;
@@ -197,10 +196,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 &&
@@ -221,30 +220,14 @@ export function mergeDetails(
       for (let i = newDetails.skippedSegments; i--; ) {
         newDetails.fragments.shift();
       }
-      newDetails.startSN = newDetails.fragments[0].sn;
+      newDetails.startSN = newDetails.fragments[0].sn as number;
       newDetails.startCC = newDetails.fragments[0].cc;
-    } else {
-      if (newDetails.canSkipDateRanges) {
-        newDetails.dateRanges = mergeDateRanges(
-          oldDetails.dateRanges,
-          newDetails,
-        );
-      }
-      const programDateTimes = oldDetails.fragments.filter(
-        (frag) => frag.rawProgramDateTime,
+    } else if (newDetails.canSkipDateRanges) {
+      newDetails.dateRanges = mergeDateRanges(
+        oldDetails.dateRanges,
+        newDetails.dateRanges,
+        newDetails.recentlyRemovedDateranges,
       );
-      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);
     }
   }
 
@@ -310,38 +293,27 @@ export function mergeDetails(
 
 function mergeDateRanges(
   oldDateRanges: Record<string, DateRange>,
-  newDetails: LevelDetails,
+  deltaDateRanges: Record<string, DateRange>,
+  recentlyRemovedDateranges: string[] | undefined,
 ): Record<string, DateRange> {
-  const { dateRanges: deltaDateRanges, recentlyRemovedDateranges } = newDetails;
   const dateRanges = Object.assign({}, oldDateRanges);
   if (recentlyRemovedDateranges) {
     recentlyRemovedDateranges.forEach((id) => {
       delete dateRanges[id];
     });
   }
-  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,
+  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,
+        )}"`,
       );
-      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;
 }
 
@@ -394,7 +366,7 @@ export function mapFragmentIntersection(
   for (let i = start; i <= end; i++) {
     const oldFrag = oldFrags[delta + i];
     let newFrag = newFrags[i];
-    if (skippedSegments && !newFrag && oldFrag) {
+    if (skippedSegments && !newFrag && i < skippedSegments) {
       // Fill in skipped segments in delta playlist
       newFrag = newDetails.fragments[i] = oldFrag;
     }
@@ -461,37 +433,38 @@ export function computeReloadInterval(
 }
 
 export function getFragmentWithSN(
-  details: LevelDetails | undefined,
+  level: Level,
   sn: number,
   fragCurrent: Fragment | null,
-): MediaFragment | null {
-  if (!details) {
+): Fragment | null {
+  if (!level?.details) {
     return null;
   }
-  let fragment: MediaFragment | undefined =
-    details.fragments[sn - details.startSN];
+  const levelDetails = level.details;
+  let fragment: Fragment | undefined =
+    levelDetails.fragments[sn - levelDetails.startSN];
   if (fragment) {
     return fragment;
   }
-  fragment = details.fragmentHint;
+  fragment = levelDetails.fragmentHint;
   if (fragment && fragment.sn === sn) {
     return fragment;
   }
-  if (sn < details.startSN && fragCurrent && fragCurrent.sn === sn) {
-    return fragCurrent as MediaFragment;
+  if (sn < levelDetails.startSN && fragCurrent && fragCurrent.sn === sn) {
+    return fragCurrent;
   }
   return null;
 }
 
 export function getPartWith(
-  details: LevelDetails | undefined,
+  level: Level,
   sn: number,
   partIndex: number,
 ): Part | null {
-  if (!details) {
+  if (!level?.details) {
     return null;
   }
-  return findPart(details.partList, sn, partIndex);
+  return findPart(level.details?.partList, sn, partIndex);
 }
 
 export function findPart(

package/src/utils/logger.ts

@@ -11,25 +11,6 @@ export interface ILogger {
   error: ILogFunction;
 }
 
-export class Logger implements ILogger {
-  trace: ILogFunction;
-  debug: ILogFunction;
-  log: ILogFunction;
-  warn: ILogFunction;
-  info: ILogFunction;
-  error: ILogFunction;
-
-  constructor(label: string, logger: ILogger) {
-    const lb = `[${label}]:`;
-    this.trace = noop;
-    this.debug = logger.debug.bind(null, lb);
-    this.log = logger.log.bind(null, lb);
-    this.warn = logger.warn.bind(null, lb);
-    this.info = logger.info.bind(null, lb);
-    this.error = logger.error.bind(null, lb);
-  }
-}
-
 const noop: ILogFunction = function () {};
 
 const fakeLogger: ILogger = {
@@ -41,9 +22,7 @@ const fakeLogger: ILogger = {
   error: noop,
 };
 
-function createLogger() {
-  return Object.assign({}, fakeLogger);
-}
+let exportedLogger: ILogger = fakeLogger;
 
 // let lastCallTime;
 // function formatMsgWithTimeInfo(type, msg) {
@@ -54,37 +33,33 @@ function createLogger() {
 //   return msg;
 // }
 
-function consolePrintFn(type: string, id: string | undefined): ILogFunction {
+function consolePrintFn(type: string): ILogFunction {
   const func: ILogFunction = self.console[type];
-  return func
-    ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`)
-    : noop;
+  if (func) {
+    return func.bind(self.console, `[${type}] >`);
+  }
+  return noop;
 }
 
-function getLoggerFn(
-  key: string,
-  debugConfig: boolean | Partial<ILogger>,
-  id?: string,
-): ILogFunction {
-  return debugConfig[key]
-    ? debugConfig[key].bind(debugConfig)
-    : consolePrintFn(key, id);
+function exportLoggerFunctions(
+  debugConfig: boolean | ILogger,
+  ...functions: string[]
+): void {
+  functions.forEach(function (type) {
+    exportedLogger[type] = debugConfig[type]
+      ? debugConfig[type].bind(debugConfig)
+      : consolePrintFn(type);
+  });
 }
 
-const exportedLogger: ILogger = createLogger();
-
-export function enableLogs(
-  debugConfig: boolean | ILogger,
-  context: string,
-  id?: string | undefined,
-): ILogger {
+export function enableLogs(debugConfig: boolean | ILogger, id: string): void {
   // check that console is available
-  const newLogger = createLogger();
   if (
     (typeof console === 'object' && debugConfig === true) ||
     typeof debugConfig === 'object'
   ) {
-    const keys: (keyof ILogger)[] = [
+    exportLoggerFunctions(
+      debugConfig,
       // Remove out from list here to hard-disable a log-level
       // 'trace',
       'debug',
@@ -92,29 +67,19 @@ export function enableLogs(
       'info',
       'warn',
       'error',
-    ];
-    keys.forEach((key) => {
-      newLogger[key] = getLoggerFn(key, debugConfig, id);
-    });
+    );
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(
-        `Debug logs enabled for "${context}" in hls.js version ${__VERSION__}`,
+      exportedLogger.log(
+        `Debug logs enabled for "${id}" in hls.js version ${__VERSION__}`,
       );
     } catch (e) {
-      /* log fn threw an exception. All logger methods are no-ops. */
-      return createLogger();
+      exportedLogger = fakeLogger;
     }
-    // global exported logger uses the same functions as new logger without `id`
-    keys.forEach((key) => {
-      exportedLogger[key] = getLoggerFn(key, debugConfig);
-    });
   } else {
-    // Reset global exported logger
-    Object.assign(exportedLogger, newLogger);
+    exportedLogger = fakeLogger;
   }
-  return newLogger;
 }
 
 export const logger: ILogger = exportedLogger;

package/src/utils/mp4-tools.ts

@@ -1,6 +1,6 @@
 import { ElementaryStreamTypes } from '../loader/fragment';
 import { sliceUint8 } from './typed-array';
-import { utf8ArrayToStr } from '@svta/common-media-library/utils/utf8ArrayToStr';
+import { utf8ArrayToStr } from '../demux/id3';
 import { logger } from '../utils/logger';
 import Hex from './hex';
 import type { PassthroughTrack, UserdataSample } from '../types/demuxer';
@@ -327,7 +327,7 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
     case 'mp4a': {
       const codecBox = findBox(sampleEntries, [fourCC])[0];
       const esdsBox = findBox(codecBox.subarray(28), ['esds'])[0];
-      if (esdsBox && esdsBox.length > 7) {
+      if (esdsBox && esdsBox.length > 12) {
         let i = 4;
         // ES Descriptor tag
         if (esdsBox[i++] !== 0x03) {
@@ -478,9 +478,7 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
 
 function skipBERInteger(bytes: Uint8Array, i: number): number {
   const limit = i + 5;
-  while (bytes[i++] & 0x80 && i < limit) {
-    /* do nothing */
-  }
+  while (bytes[i++] & 0x80 && i < limit) {}
   return i;
 }
 

package/src/utils/rendition-helper.ts

@@ -13,7 +13,6 @@ export type CodecSetTier = {
   minBitrate: number;
   minHeight: number;
   minFramerate: number;
-  minIndex: number;
   maxScore: number;
   videoRanges: Record<string, number>;
   channels: Record<string, number>;
@@ -33,7 +32,6 @@ type StartParameters = {
   preferHDR: boolean;
   minFramerate: number;
   minBitrate: number;
-  minIndex: number;
 };
 
 export function getStartCodecTier(
@@ -46,15 +44,13 @@ export function getStartCodecTier(
   const codecSets = Object.keys(codecTiers);
   const channelsPreference = audioPreference?.channels;
   const audioCodecPreference = audioPreference?.audioCodec;
-  const videoCodecPreference = videoPreference?.videoCodec;
   const preferStereo = channelsPreference && parseInt(channelsPreference) === 2;
   // Use first level set to determine stereo, and minimum resolution and framerate
-  let hasStereo = false;
+  let hasStereo = true;
   let hasCurrentVideoRange = false;
   let minHeight = Infinity;
   let minFramerate = Infinity;
   let minBitrate = Infinity;
-  let minIndex = Infinity;
   let selectedScore = 0;
   let videoRanges: Array<VideoRange> = [];
 
@@ -65,7 +61,7 @@ export function getStartCodecTier(
 
   for (let i = codecSets.length; i--; ) {
     const tier = codecTiers[codecSets[i]];
-    hasStereo ||= tier.channels[2] > 0;
+    hasStereo = tier.channels[2] > 0;
     minHeight = Math.min(minHeight, tier.minHeight);
     minFramerate = Math.min(minFramerate, tier.minFramerate);
     minBitrate = Math.min(minBitrate, tier.minBitrate);
@@ -74,6 +70,7 @@ export function getStartCodecTier(
     );
     if (matchingVideoRanges.length > 0) {
       hasCurrentVideoRange = true;
+      videoRanges = matchingVideoRanges;
     }
   }
   minHeight = Number.isFinite(minHeight) ? minHeight : 0;
@@ -85,8 +82,8 @@ export function getStartCodecTier(
   // If there are no variants with matching preference, set currentVideoRange to undefined
   if (!hasCurrentVideoRange) {
     currentVideoRange = undefined;
+    videoRanges = [];
   }
-  const hasMultipleSets = codecSets.length > 1;
   const codecSet = codecSets.reduce(
     (selected: string | undefined, candidate: string) => {
       // Remove candiates which do not meet bitrate, default audio, stereo or channels preference, 1080p or lower, 30fps or lower, or SDR/HDR selection if present
@@ -94,99 +91,80 @@ export function getStartCodecTier(
       if (candidate === selected) {
         return selected;
       }
-      videoRanges = hasCurrentVideoRange
-        ? allowedVideoRanges.filter(
-            (range) => candidateTier.videoRanges[range] > 0,
-          )
-        : [];
-      if (hasMultipleSets) {
-        if (candidateTier.minBitrate > currentBw) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`,
-          );
-          return selected;
-        }
-        if (!candidateTier.hasDefaultAudio) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `no renditions with default or auto-select sound found`,
-          );
-          return selected;
-        }
-        if (
-          audioCodecPreference &&
-          candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0
-        ) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `audio codec preference "${audioCodecPreference}" not found`,
-          );
-          return selected;
-        }
-        if (channelsPreference && !preferStereo) {
-          if (!candidateTier.channels[channelsPreference]) {
-            logStartCodecCandidateIgnored(
-              candidate,
-              `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(
-                candidateTier.channels,
-              )})`,
-            );
-            return selected;
-          }
-        } else if (
-          (!audioCodecPreference || preferStereo) &&
-          hasStereo &&
-          candidateTier.channels['2'] === 0
-        ) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `no renditions with stereo sound found`,
-          );
-          return selected;
-        }
-        if (candidateTier.minHeight > maxHeight) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`,
-          );
-          return selected;
-        }
-        if (candidateTier.minFramerate > maxFramerate) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`,
-          );
-          return selected;
-        }
-        if (
-          !videoRanges.some((range) => candidateTier.videoRanges[range] > 0)
-        ) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `no variants with VIDEO-RANGE of ${JSON.stringify(
-              videoRanges,
-            )} found`,
-          );
-          return selected;
-        }
-        if (
-          videoCodecPreference &&
-          candidate.indexOf(videoCodecPreference.substring(0, 4)) % 5 !== 0
-        ) {
-          logStartCodecCandidateIgnored(
-            candidate,
-            `video codec preference "${videoCodecPreference}" not found`,
-          );
-          return selected;
-        }
-        if (candidateTier.maxScore < selectedScore) {
+      if (candidateTier.minBitrate > currentBw) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `min bitrate of ${candidateTier.minBitrate} > current estimate of ${currentBw}`,
+        );
+        return selected;
+      }
+      if (!candidateTier.hasDefaultAudio) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `no renditions with default or auto-select sound found`,
+        );
+        return selected;
+      }
+      if (
+        audioCodecPreference &&
+        candidate.indexOf(audioCodecPreference.substring(0, 4)) % 5 !== 0
+      ) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `audio codec preference "${audioCodecPreference}" not found`,
+        );
+        return selected;
+      }
+      if (channelsPreference && !preferStereo) {
+        if (!candidateTier.channels[channelsPreference]) {
           logStartCodecCandidateIgnored(
             candidate,
-            `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`,
+            `no renditions with ${channelsPreference} channel sound found (channels options: ${Object.keys(
+              candidateTier.channels,
+            )})`,
           );
           return selected;
         }
+      } else if (
+        (!audioCodecPreference || preferStereo) &&
+        hasStereo &&
+        candidateTier.channels['2'] === 0
+      ) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `no renditions with stereo sound found`,
+        );
+        return selected;
+      }
+      if (candidateTier.minHeight > maxHeight) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `min resolution of ${candidateTier.minHeight} > maximum of ${maxHeight}`,
+        );
+        return selected;
+      }
+      if (candidateTier.minFramerate > maxFramerate) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `min framerate of ${candidateTier.minFramerate} > maximum of ${maxFramerate}`,
+        );
+        return selected;
+      }
+      if (!videoRanges.some((range) => candidateTier.videoRanges[range] > 0)) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `no variants with VIDEO-RANGE of ${JSON.stringify(
+            videoRanges,
+          )} found`,
+        );
+        return selected;
+      }
+      if (candidateTier.maxScore < selectedScore) {
+        logStartCodecCandidateIgnored(
+          candidate,
+          `max score of ${candidateTier.maxScore} < selected max of ${selectedScore}`,
+        );
+        return selected;
       }
       // Remove candiates with less preferred codecs or more errors
       if (
@@ -197,7 +175,6 @@ export function getStartCodecTier(
       ) {
         return selected;
       }
-      minIndex = candidateTier.minIndex;
       selectedScore = candidateTier.maxScore;
       return candidate;
     },
@@ -209,7 +186,6 @@ export function getStartCodecTier(
     preferHDR,
     minFramerate,
     minBitrate,
-    minIndex,
   };
 }
 
@@ -267,7 +243,7 @@ export function getCodecTiers(
 ): Record<string, CodecSetTier> {
   return levels
     .slice(minAutoLevel, maxAutoLevel + 1)
-    .reduce((tiers: Record<string, CodecSetTier>, level, index) => {
+    .reduce((tiers: Record<string, CodecSetTier>, level) => {
       if (!level.codecSet) {
         return tiers;
       }
@@ -278,7 +254,6 @@ export function getCodecTiers(
           minBitrate: Infinity,
           minHeight: Infinity,
           minFramerate: Infinity,
-          minIndex: index,
           maxScore: 0,
           videoRanges: { SDR: 0 },
           channels: { '2': 0 },
@@ -290,7 +265,6 @@ export function getCodecTiers(
       const lesserWidthOrHeight = Math.min(level.height, level.width);
       tier.minHeight = Math.min(tier.minHeight, lesserWidthOrHeight);
       tier.minFramerate = Math.min(tier.minFramerate, level.frameRate);
-      tier.minIndex = Math.min(tier.minIndex, index);
       tier.maxScore = Math.max(tier.maxScore, level.score);
       tier.fragmentError += level.fragmentError;
       tier.videoRanges[level.videoRange] =

package/src/utils/variable-substitution.ts

@@ -9,6 +9,25 @@ 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,