hls.js 1.5.13-0.canary.10411 → 1.5.13

package/src/utils/attr-list.ts

@@ -1,8 +1,3 @@
-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;
 
@@ -10,15 +5,9 @@ const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 export class AttrList {
   [key: string]: any;
 
-  constructor(
-    attrs: string | Record<string, any>,
-    parsed?: Pick<
-      ParsedMultivariantPlaylist | LevelDetails,
-      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
-    >,
-  ) {
+  constructor(attrs: string | Record<string, any>) {
     if (typeof attrs === 'string') {
-      attrs = AttrList.parseAttrList(attrs, parsed);
+      attrs = AttrList.parseAttrList(attrs);
     }
     Object.assign(this, attrs);
   }
@@ -74,20 +63,6 @@ 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';
   }
@@ -109,83 +84,21 @@ export class AttrList {
     };
   }
 
-  static parseAttrList(
-    input: string,
-    parsed?: Pick<
-      ParsedMultivariantPlaylist | LevelDetails,
-      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
-    >,
-  ): Record<string, string> {
-    let match: RegExpExecArray | null;
+  static parseAttrList(input: string): Record<string, any> {
+    let match;
     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];
-      const quotedString =
+
+      if (
         value.indexOf(quote) === 0 &&
-        value.lastIndexOf(quote) === value.length - 1;
-      let hexadecimalSequence = false;
-      if (quotedString) {
+        value.lastIndexOf(quote) === value.length - 1
+      ) {
         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/buffer-helper.ts

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

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

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

package/src/utils/codecs.ts

@@ -147,15 +147,12 @@ 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++) {
@@ -168,18 +165,13 @@ 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|mp4a\.40\.34/i;
+const AUDIO_CODEC_REGEXP = /flac|opus/i;
 export function getCodecCompatibleName(
   codec: string,
   preferManagedMediaSource = true,
@@ -193,7 +185,7 @@ export function getCodecCompatibleName(
 }
 
 export function pickMostCompleteCodecName(
-  parsedCodec: string | undefined,
+  parsedCodec: string,
   levelCodec: string | undefined,
 ): string | undefined {
   // Parsing of mp4a codecs strings in mp4-tools from media is incomplete as of d8c6c7a
@@ -221,24 +213,3 @@ 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/fetch-loader.ts

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

package/src/utils/hdr.ts

@@ -49,13 +49,16 @@ export function getVideoSelectionOptions(
   if (videoPreference) {
     allowedVideoRanges =
       videoPreference.allowedVideoRanges || VideoRangeValues.slice(0);
-    const allowAutoPreferHDR =
-      allowedVideoRanges.join('') !== 'SDR' && !videoPreference.videoCodec;
     preferHDR =
       videoPreference.preferHDR !== undefined
         ? videoPreference.preferHDR
-        : allowAutoPreferHDR && isHdrSupported();
-    if (!preferHDR) {
+        : isHdrSupported();
+
+    if (preferHDR) {
+      allowedVideoRanges = allowedVideoRanges.filter(
+        (range: VideoRange) => range !== 'SDR',
+      );
+    } else {
       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 '@svta/common-media-library/utils/utf8ArrayToStr';
+import { utf8ArrayToStr } from '../demux/id3';
 import {
   RationalTimestamp,
   toTimescaleFromScale,

package/src/utils/keysystem-util.ts

@@ -1,5 +1,4 @@
 import { base64Decode } from './numeric-encoding-utils';
-import { strToUtf8array } from './utf8-utils';
 
 function getKeyIdBytes(str: string): Uint8Array {
   const keyIdbytes = strToUtf8array(str).subarray(0, 16);
@@ -41,3 +40,9 @@ 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,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(