hls.js 1.6.6-0.canary.11351 → 1.6.6-0.canary.11353

package/dist/hls.light.mjs

@@ -523,7 +523,7 @@ function enableLogs(debugConfig, context, 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 ${"1.6.6-0.canary.11351"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.6.6-0.canary.11353"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -560,6 +560,22 @@ function requireEmptyEs() {
 var emptyEsExports = requireEmptyEs();
 var Cues = /*@__PURE__*/getDefaultExportFromCjs(emptyEsExports);
 
+function getMediaSource(preferManagedMediaSource = true) {
+  if (typeof self === 'undefined') return undefined;
+  const mms = (preferManagedMediaSource || !self.MediaSource) && self.ManagedMediaSource;
+  return mms || self.MediaSource || self.WebKitMediaSource;
+}
+function isManagedMediaSource(source) {
+  return typeof self !== 'undefined' && source === self.ManagedMediaSource;
+}
+function isCompatibleTrackChange(currentTracks, requiredTracks) {
+  const trackNames = Object.keys(currentTracks);
+  const requiredTrackNames = Object.keys(requiredTracks);
+  const trackCount = trackNames.length;
+  const requiredTrackCount = requiredTrackNames.length;
+  return !trackCount || !requiredTrackCount || trackCount === requiredTrackCount && !trackNames.some(name => requiredTrackNames.indexOf(name) === -1);
+}
+
 // http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
 // http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
 /* utf.js - UTF-8 <=> UTF-16 convertion
@@ -2252,22 +2268,6 @@ function parseEmsg(data) {
   };
 }
 
-function getMediaSource(preferManagedMediaSource = true) {
-  if (typeof self === 'undefined') return undefined;
-  const mms = (preferManagedMediaSource || !self.MediaSource) && self.ManagedMediaSource;
-  return mms || self.MediaSource || self.WebKitMediaSource;
-}
-function isManagedMediaSource(source) {
-  return typeof self !== 'undefined' && source === self.ManagedMediaSource;
-}
-function isCompatibleTrackChange(currentTracks, requiredTracks) {
-  const trackNames = Object.keys(currentTracks);
-  const requiredTrackNames = Object.keys(requiredTracks);
-  const trackCount = trackNames.length;
-  const requiredTrackCount = requiredTrackNames.length;
-  return !trackCount || !requiredTrackCount || trackCount === requiredTrackCount && !trackNames.some(name => requiredTrackNames.indexOf(name) === -1);
-}
-
 const userAgentHevcSupportIsInaccurate = () => {
   return /\(Windows.+Firefox\//i.test(navigator.userAgent);
 };
@@ -2958,6 +2958,7 @@ class AbrController extends Logger {
     this.partCurrent = null;
     this.bitrateTestDelay = 0;
     this.rebufferNotice = -1;
+    this.supportedCache = {};
     this.bwEstimator = void 0;
     /*
         This method monitors the download rate of the current fragment, and will downswitch if that fragment will not load
@@ -3168,13 +3169,14 @@ class AbrController extends Logger {
     this.unregisterListeners();
     this.clearTimer();
     // @ts-ignore
-    this.hls = this._abandonRulesCheck = null;
+    this.hls = this._abandonRulesCheck = this.supportedCache = null;
     this.fragCurrent = this.partCurrent = null;
   }
   onManifestLoading(event, data) {
     this.lastLoadedFragLevel = -1;
     this.firstSelection = -1;
     this.lastLevelLoadSec = 0;
+    this.supportedCache = {};
     this.fragCurrent = this.partCurrent = null;
     this.onLevelsUpdated();
     this.clearTimer();
@@ -3535,7 +3537,7 @@ class AbrController extends Logger {
     const ttfbEstimateSec = this.bwEstimator.getEstimateTTFB() / 1000;
     const levelsSkipped = [];
     for (let i = maxAutoLevel; i >= minAutoLevel; i--) {
-      var _levelInfo$supportedR;
+      var _levelInfo$supportedR, _levelInfo$supportedR2;
       const levelInfo = levels[i];
       const upSwitch = i > selectionBaseLevel;
       if (!levelInfo) {
@@ -3544,7 +3546,7 @@ class AbrController extends Logger {
 
       // skip candidates which change codec-family or video-range,
       // and which decrease or increase frame-rate for up and down-switch respectfully
-      if (currentCodecSet && levelInfo.codecSet !== currentCodecSet || currentVideoRange && levelInfo.videoRange !== currentVideoRange || upSwitch && currentFrameRate > levelInfo.frameRate || !upSwitch && currentFrameRate > 0 && currentFrameRate < levelInfo.frameRate || levelInfo.supportedResult && !((_levelInfo$supportedR = levelInfo.supportedResult.decodingInfoResults) != null && _levelInfo$supportedR[0].smooth)) {
+      if (currentCodecSet && levelInfo.codecSet !== currentCodecSet || currentVideoRange && levelInfo.videoRange !== currentVideoRange || upSwitch && currentFrameRate > levelInfo.frameRate || !upSwitch && currentFrameRate > 0 && currentFrameRate < levelInfo.frameRate || (_levelInfo$supportedR = levelInfo.supportedResult) != null && (_levelInfo$supportedR2 = _levelInfo$supportedR.decodingInfoResults) != null && _levelInfo$supportedR2.some(info => info.smooth === false)) {
         if (!firstSelection || i !== minStartIndex) {
           levelsSkipped.push(i);
           continue;
@@ -10393,11 +10395,13 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => key === 'initSeg
     this.updateDuration();
   }
   updateDuration() {
-    const durationAndRange = this.getDurationAndRange();
-    if (!durationAndRange) {
-      return;
-    }
-    this.blockUntilOpen(() => this.updateMediaSource(durationAndRange));
+    this.blockUntilOpen(() => {
+      const durationAndRange = this.getDurationAndRange();
+      if (!durationAndRange) {
+        return;
+      }
+      this.updateMediaSource(durationAndRange);
+    });
   }
   onError(event, data) {
     if (data.details === ErrorDetails.BUFFER_APPEND_ERROR && data.frag) {
@@ -19887,7 +19891,7 @@ function assignTrackIdsByGroup(tracks) {
   });
 }
 
-const version = "1.6.6-0.canary.11351";
+const version = "1.6.6-0.canary.11353";
 
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
@@ -22440,68 +22444,43 @@ function getUnsupportedResult(error, configurations) {
     error
   };
 }
-const SUPPORTED_INFO_CACHE = {};
-function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilities) {
+function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilities, cache = {}) {
   const videoCodecs = level.videoCodec;
-  const audioCodecs = level.audioCodec;
-  if (!videoCodecs && !audioCodecs || !mediaCapabilities) {
+  if (!videoCodecs && !level.audioCodec || !mediaCapabilities) {
     return Promise.resolve(SUPPORTED_INFO_DEFAULT);
   }
   const configurations = [];
-  if (videoCodecs) {
-    const baseVideoConfiguration = {
-      width: level.width,
-      height: level.height,
-      bitrate: Math.ceil(Math.max(level.bitrate * 0.9, level.averageBitrate)),
-      // Assume a framerate of 30fps since MediaCapabilities will not accept Level default of 0.
-      framerate: level.frameRate || 30
+  const videoDecodeList = makeVideoConfigurations(level);
+  const videoCount = videoDecodeList.length;
+  const audioDecodeList = makeAudioConfigurations(level, audioTracksByGroup, videoCount > 0);
+  const audioCount = audioDecodeList.length;
+  for (let i = videoCount || 1 * audioCount || 1; i--;) {
+    const configuration = {
+      type: 'media-source'
     };
-    const videoRange = level.videoRange;
-    if (videoRange !== 'SDR') {
-      baseVideoConfiguration.transferFunction = videoRange.toLowerCase();
+    if (videoCount) {
+      configuration.video = videoDecodeList[i % videoCount];
     }
-    const videoCodecsArray = videoCodecs.split(',');
+    if (audioCount) {
+      configuration.audio = audioDecodeList[i % audioCount];
+      const audioBitrate = configuration.audio.bitrate;
+      if (configuration.video && audioBitrate) {
+        configuration.video.bitrate -= audioBitrate;
+      }
+    }
+    configurations.push(configuration);
+  }
+  if (videoCodecs) {
     // Override Windows Firefox HEVC MediaCapabilities result (https://github.com/video-dev/hls.js/issues/7046)
     const ua = navigator.userAgent;
-    if (videoCodecsArray.some(videoCodec => isHEVC(videoCodec)) && userAgentHevcSupportIsInaccurate()) {
-      return Promise.resolve(getUnsupportedResult(new Error(`Overriding Windows Firefox HEVC MediaCapabilities result based on user-agent sting: (${ua})`), configurations));
+    if (videoCodecs.split(',').some(videoCodec => isHEVC(videoCodec)) && userAgentHevcSupportIsInaccurate()) {
+      return Promise.resolve(getUnsupportedResult(new Error(`Overriding Windows Firefox HEVC MediaCapabilities result based on user-agent string: (${ua})`), configurations));
     }
-    configurations.push.apply(configurations, videoCodecsArray.map(videoCodec => ({
-      type: 'media-source',
-      video: _objectSpread2(_objectSpread2({}, baseVideoConfiguration), {}, {
-        contentType: mimeTypeForCodec(fillInMissingAV01Params(videoCodec), 'video')
-      })
-    })));
-  }
-  if (audioCodecs && level.audioGroups) {
-    level.audioGroups.forEach(audioGroupId => {
-      var _audioTracksByGroup$g;
-      if (!audioGroupId) {
-        return;
-      }
-      (_audioTracksByGroup$g = audioTracksByGroup.groups[audioGroupId]) == null ? void 0 : _audioTracksByGroup$g.tracks.forEach(audioTrack => {
-        if (audioTrack.groupId === audioGroupId) {
-          const channels = audioTrack.channels || '';
-          const channelsNumber = parseFloat(channels);
-          if (isFiniteNumber(channelsNumber) && channelsNumber > 2) {
-            configurations.push.apply(configurations, audioCodecs.split(',').map(audioCodec => ({
-              type: 'media-source',
-              audio: {
-                contentType: mimeTypeForCodec(audioCodec, 'audio'),
-                channels: '' + channelsNumber
-                // spatialRendering:
-                //   audioCodec === 'ec-3' && channels.indexOf('JOC'),
-              }
-            })));
-          }
-        }
-      });
-    });
   }
   return Promise.all(configurations.map(configuration => {
     // Cache MediaCapabilities promises
     const decodingInfoKey = getMediaDecodingInfoKey(configuration);
-    return SUPPORTED_INFO_CACHE[decodingInfoKey] || (SUPPORTED_INFO_CACHE[decodingInfoKey] = mediaCapabilities.decodingInfo(configuration));
+    return cache[decodingInfoKey] || (cache[decodingInfoKey] = mediaCapabilities.decodingInfo(configuration));
   })).then(decodingInfoResults => ({
     supported: !decodingInfoResults.some(info => !info.supported),
     configurations,
@@ -22513,22 +22492,90 @@ function getMediaDecodingInfoPromise(level, audioTracksByGroup, mediaCapabilitie
     error
   }));
 }
+function makeVideoConfigurations(level) {
+  var _level$videoCodec;
+  const videoCodecs = (_level$videoCodec = level.videoCodec) == null ? void 0 : _level$videoCodec.split(',');
+  const bitrate = getVariantDecodingBitrate(level);
+  const width = level.width || 640;
+  const height = level.height || 480;
+  // Assume a framerate of 30fps since MediaCapabilities will not accept Level default of 0.
+  const framerate = level.frameRate || 30;
+  const videoRange = level.videoRange.toLowerCase();
+  return videoCodecs ? videoCodecs.map(videoCodec => {
+    const videoConfiguration = {
+      contentType: mimeTypeForCodec(fillInMissingAV01Params(videoCodec), 'video'),
+      width,
+      height,
+      bitrate,
+      framerate
+    };
+    if (videoRange !== 'sdr') {
+      videoConfiguration.transferFunction = videoRange;
+    }
+    return videoConfiguration;
+  }) : [];
+}
+function makeAudioConfigurations(level, audioTracksByGroup, hasVideo) {
+  var _level$audioCodec;
+  const audioCodecs = (_level$audioCodec = level.audioCodec) == null ? void 0 : _level$audioCodec.split(',');
+  const combinedBitrate = getVariantDecodingBitrate(level);
+  if (audioCodecs && level.audioGroups) {
+    return level.audioGroups.reduce((configurations, audioGroupId) => {
+      var _audioTracksByGroup$g;
+      const tracks = audioGroupId ? (_audioTracksByGroup$g = audioTracksByGroup.groups[audioGroupId]) == null ? void 0 : _audioTracksByGroup$g.tracks : null;
+      if (tracks) {
+        return tracks.reduce((configs, audioTrack) => {
+          if (audioTrack.groupId === audioGroupId) {
+            const channelsNumber = parseFloat(audioTrack.channels || '');
+            audioCodecs.forEach(audioCodec => {
+              const audioConfiguration = {
+                contentType: mimeTypeForCodec(audioCodec, 'audio'),
+                bitrate: hasVideo ? estimatedAudioBitrate(audioCodec, combinedBitrate) : combinedBitrate
+              };
+              if (channelsNumber) {
+                audioConfiguration.channels = '' + channelsNumber;
+              }
+              configs.push(audioConfiguration);
+            });
+          }
+          return configs;
+        }, configurations);
+      }
+      return configurations;
+    }, []);
+  }
+  return [];
+}
+function estimatedAudioBitrate(audioCodec, levelBitrate) {
+  if (levelBitrate <= 1) {
+    return 1;
+  }
+  let audioBitrate = 128000;
+  if (audioCodec === 'ec-3') {
+    audioBitrate = 768000;
+  } else if (audioCodec === 'ac-3') {
+    audioBitrate = 640000;
+  }
+  return Math.min(levelBitrate / 2, audioBitrate); // Don't exceed some % of level bitrate
+}
+function getVariantDecodingBitrate(level) {
+  return Math.ceil(Math.max(level.bitrate * 0.9, level.averageBitrate) / 1000) * 1000 || 1;
+}
 function getMediaDecodingInfoKey(config) {
+  let key = '';
   const {
     audio,
     video
   } = config;
-  const mediaConfig = video || audio;
-  if (mediaConfig) {
-    const codec = getCodecsForMimeType(mediaConfig.contentType);
-    if (video) {
-      return `r${video.height}x${video.width}f${Math.ceil(video.framerate)}${video.transferFunction || 'sd'}_${codec}_${Math.ceil(video.bitrate / 1e5)}`;
-    }
-    if (audio) {
-      return `c${audio.channels}${audio.spatialRendering ? 's' : 'n'}_${codec}`;
-    }
+  if (video) {
+    const codec = getCodecsForMimeType(video.contentType);
+    key += `${codec}_r${video.height}x${video.width}f${Math.ceil(video.framerate)}${video.transferFunction || 'sd'}_${Math.ceil(video.bitrate / 1e5)}`;
+  }
+  if (audio) {
+    const codec = getCodecsForMimeType(audio.contentType);
+    key += `${video ? '_' : ''}${codec}_c${audio.channels}`;
   }
-  return '';
+  return key;
 }
 
 /**