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

package/src/utils/buffer-helper.ts

@@ -35,19 +35,13 @@ export class BufferHelper {
    * Return true if `media`'s buffered include `position`
    */
   static isBuffered(media: Bufferable, position: number): boolean {
-    try {
-      if (media) {
-        const buffered = BufferHelper.getBuffered(media);
-        for (let i = 0; i < buffered.length; i++) {
-          if (position >= buffered.start(i) && position <= buffered.end(i)) {
-            return true;
-          }
+    if (media) {
+      const buffered = BufferHelper.getBuffered(media);
+      for (let i = buffered.length; i--; ) {
+        if (position >= buffered.start(i) && position <= buffered.end(i)) {
+          return true;
         }
       }
-    } catch (error) {
-      // this is to catch
-      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
-      // This SourceBuffer has been removed from the parent media source
     }
     return false;
   }
@@ -57,21 +51,15 @@ export class BufferHelper {
     pos: number,
     maxHoleDuration: number,
   ): BufferInfo {
-    try {
-      if (media) {
-        const vbuffered = BufferHelper.getBuffered(media);
+    if (media) {
+      const vbuffered = BufferHelper.getBuffered(media);
+      if (vbuffered.length) {
         const buffered: BufferTimeRange[] = [];
-        let i: number;
-        for (i = 0; i < vbuffered.length; i++) {
+        for (let i = 0; i < vbuffered.length; i++) {
           buffered.push({ start: vbuffered.start(i), end: vbuffered.end(i) });
         }
-
-        return this.bufferedInfo(buffered, pos, maxHoleDuration);
+        return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
       }
-    } catch (error) {
-      // this is to catch
-      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
-      // This SourceBuffer has been removed from the parent media source
     }
     return { len: 0, start: pos, end: pos, nextStart: undefined };
   }
@@ -88,14 +76,7 @@ export class BufferHelper {
   } {
     pos = Math.max(0, pos);
     // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
-    buffered.sort(function (a, b) {
-      const diff = a.start - b.start;
-      if (diff) {
-        return diff;
-      } else {
-        return b.end - a.end;
-      }
-    });
+    buffered.sort((a, b) => a.start - b.start || b.end - a.end);
 
     let buffered2: BufferTimeRange[] = [];
     if (maxHoleDuration) {
@@ -164,7 +145,7 @@ export class BufferHelper {
    */
   static getBuffered(media: Bufferable): TimeRanges {
     try {
-      return media.buffered;
+      return media.buffered || noopBuffered;
     } catch (e) {
       logger.log('failed to get media.buffered', e);
       return noopBuffered;

package/src/utils/cea-608-parser.ts

@@ -1331,9 +1331,7 @@ class Cea608Parser {
     if (charCodes) {
       this.logger.log(
         VerboseLevel.DEBUG,
-        () =>
-          'Char codes =  ' +
-          numArrayToHexArray(charCodes as number[]).join(','),
+        () => 'Char codes =  ' + numArrayToHexArray(charCodes).join(','),
       );
     }
     return charCodes;

package/src/utils/codecs.ts

@@ -147,12 +147,15 @@ function getCodecCompatibleNameLower(
     return CODEC_COMPATIBLE_NAMES[lowerCaseCodec]!;
   }
 
-  // Idealy fLaC and Opus would be first (spec-compliant) but
-  // some browsers will report that fLaC is supported then fail.
-  // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
   const codecsToCheck = {
+    // Idealy fLaC and Opus would be first (spec-compliant) but
+    // some browsers will report that fLaC is supported then fail.
+    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
     flac: ['flac', 'fLaC', 'FLAC'],
     opus: ['opus', 'Opus'],
+    // Replace audio codec info if browser does not support mp4a.40.34,
+    // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
+    'mp4a.40.34': ['mp3'],
   }[lowerCaseCodec];
 
   for (let i = 0; i < codecsToCheck.length; i++) {
@@ -165,13 +168,18 @@ function getCodecCompatibleNameLower(
     ) {
       CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
       return codecsToCheck[i];
+    } else if (
+      codecsToCheck[i] === 'mp3' &&
+      getMediaSource(preferManagedMediaSource)?.isTypeSupported('audio/mpeg')
+    ) {
+      return '';
     }
   }
 
   return lowerCaseCodec;
 }
 
-const AUDIO_CODEC_REGEXP = /flac|opus/i;
+const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
 export function getCodecCompatibleName(
   codec: string,
   preferManagedMediaSource = true,
@@ -185,7 +193,7 @@ export function getCodecCompatibleName(
 }
 
 export function pickMostCompleteCodecName(
-  parsedCodec: string,
+  parsedCodec: string | undefined,
   levelCodec: string | undefined,
 ): string | undefined {
   // Parsing of mp4a codecs strings in mp4-tools from media is incomplete as of d8c6c7a
@@ -213,3 +221,24 @@ export function convertAVC1ToAVCOTI(codec: string) {
   }
   return codecs.join(',');
 }
+
+export interface TypeSupported {
+  mpeg: boolean;
+  mp3: boolean;
+  ac3: boolean;
+}
+
+export function getM2TSSupportedAudioTypes(
+  preferManagedMediaSource: boolean,
+): TypeSupported {
+  const MediaSource = getMediaSource(preferManagedMediaSource) || {
+    isTypeSupported: () => false,
+  };
+  return {
+    mpeg: MediaSource.isTypeSupported('audio/mpeg'),
+    mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
+    ac3: __USE_M2TS_ADVANCED_CODECS__
+      ? MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"')
+      : false,
+  };
+}

package/src/utils/encryption-methods-util.ts

@@ -0,0 +1,21 @@
+import { DecrypterAesMode } from '../crypt/decrypter-aes-mode';
+
+export function isFullSegmentEncryption(method: string): boolean {
+  return (
+    method === 'AES-128' || method === 'AES-256' || method === 'AES-256-CTR'
+  );
+}
+
+export function getAesModeFromFullSegmentMethod(
+  method: string,
+): DecrypterAesMode {
+  switch (method) {
+    case 'AES-128':
+    case 'AES-256':
+      return DecrypterAesMode.cbc;
+    case 'AES-256-CTR':
+      return DecrypterAesMode.ctr;
+    default:
+      throw new Error(`invalid full segment method ${method}`);
+  }
+}

package/src/utils/fetch-loader.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   LoaderCallbacks,
   LoaderContext,
   Loader,

package/src/utils/hash.ts

@@ -0,0 +1,10 @@
+// From https://github.com/darkskyapp/string-hash
+export function hash(text: string) {
+  let hash = 5381;
+  let i = text.length;
+  while (i) {
+    hash = (hash * 33) ^ text.charCodeAt(--i);
+  }
+
+  return (hash >>> 0).toString();
+}

package/src/utils/hdr.ts

@@ -49,16 +49,13 @@ export function getVideoSelectionOptions(
   if (videoPreference) {
     allowedVideoRanges =
       videoPreference.allowedVideoRanges || VideoRangeValues.slice(0);
+    const allowAutoPreferHDR =
+      allowedVideoRanges.join('') !== 'SDR' && !videoPreference.videoCodec;
     preferHDR =
       videoPreference.preferHDR !== undefined
         ? videoPreference.preferHDR
-        : isHdrSupported();
-
-    if (preferHDR) {
-      allowedVideoRanges = allowedVideoRanges.filter(
-        (range: VideoRange) => range !== 'SDR',
-      );
-    } else {
+        : allowAutoPreferHDR && isHdrSupported();
+    if (!preferHDR) {
       allowedVideoRanges = ['SDR'];
     }
   }

package/src/utils/imsc1-ttml-parser.ts

@@ -1,7 +1,7 @@
 import { findBox } from './mp4-tools';
 import { parseTimeStamp } from './vttparser';
 import VTTCue from './vttcue';
-import { utf8ArrayToStr } from '../demux/id3';
+import { utf8ArrayToStr } from '@svta/common-media-library/utils/utf8ArrayToStr';
 import {
   RationalTimestamp,
   toTimescaleFromScale,

package/src/utils/keysystem-util.ts

@@ -1,4 +1,5 @@
 import { base64Decode } from './numeric-encoding-utils';
+import { strToUtf8array } from './utf8-utils';
 
 function getKeyIdBytes(str: string): Uint8Array {
   const keyIdbytes = strToUtf8array(str).subarray(0, 16);
@@ -40,9 +41,3 @@ export function convertDataUriToArrayBytes(uri: string): Uint8Array | null {
   }
   return keydata;
 }
-
-export function strToUtf8array(str: string): Uint8Array {
-  return Uint8Array.from(unescape(encodeURIComponent(str)), (c) =>
-    c.charCodeAt(0),
-  );
-}

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;
     }
@@ -433,38 +461,37 @@ export function computeReloadInterval(
 }
 
 export function getFragmentWithSN(
-  level: Level,
+  details: LevelDetails | undefined,
   sn: number,
   fragCurrent: Fragment | null,
-): Fragment | null {
-  if (!level?.details) {
+): MediaFragment | null {
+  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;
 }
 
 export function getPartWith(
-  level: Level,
+  details: LevelDetails | undefined,
   sn: number,
   partIndex: number,
 ): Part | null {
-  if (!level?.details) {
+  if (!details) {
     return null;
   }
-  return findPart(level.details?.partList, sn, partIndex);
+  return findPart(details.partList, sn, partIndex);
 }
 
 export function findPart(

package/src/utils/logger.ts

@@ -11,6 +11,25 @@ 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 = {
@@ -22,7 +41,9 @@ const fakeLogger: ILogger = {
   error: noop,
 };
 
-let exportedLogger: ILogger = fakeLogger;
+function createLogger() {
+  return Object.assign({}, fakeLogger);
+}
 
 // let lastCallTime;
 // function formatMsgWithTimeInfo(type, msg) {
@@ -33,33 +54,37 @@ let exportedLogger: ILogger = fakeLogger;
 //   return msg;
 // }
 
-function consolePrintFn(type: string): ILogFunction {
+function consolePrintFn(type: string, id: string | undefined): ILogFunction {
   const func: ILogFunction = self.console[type];
-  if (func) {
-    return func.bind(self.console, `[${type}] >`);
-  }
-  return noop;
+  return func
+    ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`)
+    : noop;
 }
 
-function exportLoggerFunctions(
-  debugConfig: boolean | ILogger,
-  ...functions: string[]
-): void {
-  functions.forEach(function (type) {
-    exportedLogger[type] = debugConfig[type]
-      ? debugConfig[type].bind(debugConfig)
-      : consolePrintFn(type);
-  });
+function getLoggerFn(
+  key: string,
+  debugConfig: boolean | Partial<ILogger>,
+  id?: string,
+): ILogFunction {
+  return debugConfig[key]
+    ? debugConfig[key].bind(debugConfig)
+    : consolePrintFn(key, id);
 }
 
-export function enableLogs(debugConfig: boolean | ILogger, id: string): void {
+const exportedLogger: ILogger = createLogger();
+
+export function enableLogs(
+  debugConfig: boolean | ILogger,
+  context: string,
+  id?: string | undefined,
+): ILogger {
   // check that console is available
+  const newLogger = createLogger();
   if (
     (typeof console === 'object' && debugConfig === true) ||
     typeof debugConfig === 'object'
   ) {
-    exportLoggerFunctions(
-      debugConfig,
+    const keys: (keyof ILogger)[] = [
       // Remove out from list here to hard-disable a log-level
       // 'trace',
       'debug',
@@ -67,19 +92,29 @@ export function enableLogs(debugConfig: boolean | ILogger, id: string): void {
       '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 {
-      exportedLogger.log(
-        `Debug logs enabled for "${id}" in hls.js version ${__VERSION__}`,
+      newLogger.log(
+        `Debug logs enabled for "${context}" in hls.js version ${__VERSION__}`,
       );
     } catch (e) {
-      exportedLogger = fakeLogger;
+      /* log fn threw an exception. All logger methods are no-ops. */
+      return createLogger();
     }
+    // global exported logger uses the same functions as new logger without `id`
+    keys.forEach((key) => {
+      exportedLogger[key] = getLoggerFn(key, debugConfig);
+    });
   } else {
-    exportedLogger = fakeLogger;
+    // Reset global exported logger
+    Object.assign(exportedLogger, newLogger);
   }
+  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 '../demux/id3';
+import { utf8ArrayToStr } from '@svta/common-media-library/utils/utf8ArrayToStr';
 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 > 12) {
+      if (esdsBox && esdsBox.length > 7) {
         let i = 4;
         // ES Descriptor tag
         if (esdsBox[i++] !== 0x03) {
@@ -478,7 +478,9 @@ 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) {}
+  while (bytes[i++] & 0x80 && i < limit) {
+    /* do nothing */
+  }
   return i;
 }