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

package/src/types/events.ts

@@ -1,4 +1,7 @@
-import type { Fragment, MediaFragment, Part } from '../loader/fragment';
+// eslint-disable-next-line import/no-duplicates
+import type { Fragment } from '../loader/fragment';
+// eslint-disable-next-line import/no-duplicates
+import type { Part } from '../loader/fragment';
 import type { LevelDetails } from '../loader/level-details';
 import type {
   HdcpLevel,
@@ -39,10 +42,6 @@ export interface MediaAttachedData {
   mediaSource?: MediaSource;
 }
 
-export interface MediaEndedData {
-  stalled: boolean;
-}
-
 export interface BufferCodecsData {
   video?: Track;
   audio?: Track;
@@ -192,18 +191,6 @@ export interface LevelUpdatedData {
   level: number;
 }
 
-export interface AudioTrackUpdatedData {
-  details: LevelDetails;
-  id: number;
-  groupId: string;
-}
-
-export interface SubtitleTrackUpdatedData {
-  details: LevelDetails;
-  id: number;
-  groupId: string;
-}
-
 export interface LevelPTSUpdatedData {
   details: LevelDetails;
   level: Level;
@@ -329,8 +316,8 @@ export interface NonNativeTextTracksData {
 }
 
 export interface InitPTSFoundData {
-  id: PlaylistLevelType;
-  frag: MediaFragment;
+  id: string;
+  frag: Fragment;
   initPTS: number;
   timescale: number;
 }

package/src/types/fragment-tracker.ts

@@ -1,9 +1,9 @@
-import type { MediaFragment } from '../loader/fragment';
+import type { Fragment } from '../loader/fragment';
 import type { SourceBufferName } from './buffer';
 import type { FragLoadedData } from './events';
 
 export interface FragmentEntity {
-  body: MediaFragment;
+  body: Fragment;
   // appendedPTS is the latest buffered presentation time within the fragment's time range.
   // It is used to determine: which fragment is appended at any given position, and hls.currentLevel.
   appendedPTS: number | null;

package/src/types/general.ts

@@ -0,0 +1,6 @@
+/**
+ * Make specific properties in T required
+ */
+export type RequiredProperties<T, K extends keyof T> = T & {
+  [P in K]-?: T[P];
+};

package/src/types/media-playlist.ts

@@ -1,7 +1,6 @@
 import type { AttrList } from '../utils/attr-list';
 import type { LevelDetails } from '../loader/level-details';
-import type { Level, VideoRange } from './level';
-import type { PlaylistLevelType } from './loader';
+import type { VideoRange } from './level';
 
 export type AudioPlaylistType = 'AUDIO';
 
@@ -11,16 +10,9 @@ export type SubtitlePlaylistType = 'SUBTITLES' | 'CLOSED-CAPTIONS';
 
 export type MediaPlaylistType = MainPlaylistType | SubtitlePlaylistType;
 
-export type MediaSelection = {
-  [PlaylistLevelType.MAIN]: Level;
-  [PlaylistLevelType.AUDIO]?: MediaPlaylist;
-  [PlaylistLevelType.SUBTITLE]?: MediaPlaylist;
-};
-
 export type VideoSelectionOption = {
   preferHDR?: boolean;
   allowedVideoRanges?: Array<VideoRange>;
-  videoCodec?: string;
 };
 
 export type AudioSelectionOption = {

package/src/types/remuxer.ts

@@ -1,5 +1,5 @@
 import type { TrackSet } from './track';
-import type {
+import {
   DemuxedAudioTrack,
   DemuxedMetadataTrack,
   DemuxedUserdataTrack,

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/discontinuities.ts

@@ -17,13 +17,14 @@ export function findFirstFragWithCC(
 }
 
 export function shouldAlignOnDiscontinuities(
-  refDetails: LevelDetails | undefined,
+  lastFrag: Fragment | null,
+  switchDetails: LevelDetails | undefined,
   details: LevelDetails,
-): refDetails is LevelDetails & boolean {
-  if (refDetails) {
+): switchDetails is LevelDetails & boolean {
+  if (switchDetails) {
     if (
-      details.startCC < refDetails.endCC &&
-      details.endCC > refDetails.startCC
+      details.endCC > details.startCC ||
+      (lastFrag && lastFrag.cc < details.startCC)
     ) {
       return true;
     }
@@ -31,6 +32,29 @@ export function shouldAlignOnDiscontinuities(
   return false;
 }
 
+// Find the first frag in the previous level which matches the CC of the first frag of the new level
+export function findDiscontinuousReferenceFrag(
+  prevDetails: LevelDetails,
+  curDetails: LevelDetails,
+) {
+  const prevFrags = prevDetails.fragments;
+  const curFrags = curDetails.fragments;
+
+  if (!curFrags.length || !prevFrags.length) {
+    logger.log('No fragments to align');
+    return;
+  }
+
+  const prevStartFrag = findFirstFragWithCC(prevFrags, curFrags[0].cc);
+
+  if (!prevStartFrag || (prevStartFrag && !prevStartFrag.startPTS)) {
+    logger.log('No frag in previous level to align on');
+    return;
+  }
+
+  return prevStartFrag;
+}
+
 function adjustFragmentStart(frag: Fragment, sliding: number) {
   if (frag) {
     const start = frag.start + sliding;
@@ -70,7 +94,7 @@ export function alignStream(
   if (!switchDetails) {
     return;
   }
-  alignDiscontinuities(details, switchDetails);
+  alignDiscontinuities(lastFrag, details, switchDetails);
   if (!details.alignedSliding && switchDetails) {
     // If the PTS wasn't figured out via discontinuity sequence that means there was no CC increase within the level.
     // Aligning via Program Date Time should therefore be reliable, since PDT should be the same within the same
@@ -86,27 +110,29 @@ export function alignStream(
 }
 
 /**
- * Ajust the start of fragments in `details` by the difference in time between fragments of the latest
- * shared discontinuity sequence change.
+ * Computes the PTS if a new level's fragments using the PTS of a fragment in the last level which shares the same
+ * discontinuity sequence.
+ * @param lastFrag - The last Fragment which shares the same discontinuity sequence
  * @param lastLevel - The details of the last loaded level
  * @param details - The details of the new level
  */
-export function alignDiscontinuities(
+function alignDiscontinuities(
+  lastFrag: Fragment | null,
   details: LevelDetails,
-  refDetails: LevelDetails | undefined,
+  switchDetails: LevelDetails | undefined,
 ) {
-  if (!shouldAlignOnDiscontinuities(refDetails, details)) {
-    return;
-  }
-  const targetCC = Math.min(refDetails.endCC, details.endCC);
-  const refFrag = findFirstFragWithCC(refDetails.fragments, targetCC);
-  const frag = findFirstFragWithCC(details.fragments, targetCC);
-  if (!refFrag || !frag) {
-    return;
+  if (shouldAlignOnDiscontinuities(lastFrag, switchDetails, details)) {
+    const referenceFrag = findDiscontinuousReferenceFrag(
+      switchDetails,
+      details,
+    );
+    if (referenceFrag && Number.isFinite(referenceFrag.start)) {
+      logger.log(
+        `Adjusting PTS using last level due to CC increase within current level ${details.url}`,
+      );
+      adjustSlidingStart(referenceFrag.start, details);
+    }
   }
-  logger.log(`Aligning playlist at start of dicontinuity sequence ${targetCC}`);
-  const delta = refFrag.start - frag.start;
-  adjustSlidingStart(delta, details);
 }
 
 /**

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),
+  );
+}