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

package/dist/hls.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.11352"}`);
+      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();
@@ -2630,9 +2630,9 @@ function getUnsupportedResult(error, configurations) {
     error
   };
 }
-const SUPPORTED_INFO_CACHE = {};
 function requiresMediaCapabilitiesDecodingInfo(level, audioTracksByGroup, currentVideoRange, currentFrameRate, currentBw, audioPreference) {
   // Only test support when configuration is exceeds minimum options
+  const videoCodecs = level.videoCodec;
   const audioGroups = level.audioCodec ? level.audioGroups : null;
   const audioCodecPreference = audioPreference == null ? void 0 : audioPreference.audioCodec;
   const channelsPreference = audioPreference == null ? void 0 : audioPreference.channels;
@@ -2663,69 +2663,47 @@ function requiresMediaCapabilitiesDecodingInfo(level, audioTracksByGroup, curren
       return true;
     }
   }
-  return level.videoCodec !== undefined && (level.width > 1920 && level.height > 1088 || level.height > 1920 && level.width > 1088 || level.frameRate > Math.max(currentFrameRate, 30) || level.videoRange !== 'SDR' && level.videoRange !== currentVideoRange || level.bitrate > Math.max(currentBw, 8e6)) || !!audioChannels && isFiniteNumber(maxChannels) && Object.keys(audioChannels).some(channels => parseInt(channels) > maxChannels);
+  return videoCodecs !== undefined && (
+  // Force media capabilities check for HEVC to avoid failure on Windows
+  videoCodecs.split(',').some(videoCodec => isHEVC(videoCodec)) || level.width > 1920 && level.height > 1088 || level.height > 1920 && level.width > 1088 || level.frameRate > Math.max(currentFrameRate, 30) || level.videoRange !== 'SDR' && level.videoRange !== currentVideoRange || level.bitrate > Math.max(currentBw, 8e6)) || !!audioChannels && isFiniteNumber(maxChannels) && Object.keys(audioChannels).some(channels => parseInt(channels) > maxChannels);
 }
-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];
+    }
+    if (audioCount) {
+      configuration.audio = audioDecodeList[i % audioCount];
+      const audioBitrate = configuration.audio.bitrate;
+      if (configuration.video && audioBitrate) {
+        configuration.video.bitrate -= audioBitrate;
+      }
     }
-    const videoCodecsArray = videoCodecs.split(',');
+    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,
@@ -2737,22 +2715,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;
 }
 
 const HdcpLevels = ['NONE', 'TYPE-0', 'TYPE-1', null];
@@ -3345,6 +3391,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
@@ -3555,13 +3602,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();
@@ -3922,7 +3970,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) {
@@ -3930,9 +3978,8 @@ class AbrController extends Logger {
       }
       if (config.useMediaCapabilities && !levelInfo.supportedResult && !levelInfo.supportedPromise) {
         const mediaCapabilities = navigator.mediaCapabilities;
-        if (typeof (mediaCapabilities == null ? void 0 : mediaCapabilities.decodingInfo) === 'function' && (requiresMediaCapabilitiesDecodingInfo(levelInfo, audioTracksByGroup, currentVideoRange, currentFrameRate, currentBw, audioPreference) || isHEVC(levelInfo.videoCodec)) // Force media capabilities check for HEVC to avoid failure on Windows
-        ) {
-          levelInfo.supportedPromise = getMediaDecodingInfoPromise(levelInfo, audioTracksByGroup, mediaCapabilities);
+        if (typeof (mediaCapabilities == null ? void 0 : mediaCapabilities.decodingInfo) === 'function' && requiresMediaCapabilitiesDecodingInfo(levelInfo, audioTracksByGroup, currentVideoRange, currentFrameRate, currentBw, audioPreference)) {
+          levelInfo.supportedPromise = getMediaDecodingInfoPromise(levelInfo, audioTracksByGroup, mediaCapabilities, this.supportedCache);
           levelInfo.supportedPromise.then(decodingInfo => {
             if (!this.hls) {
               return;
@@ -3951,6 +3998,8 @@ class AbrController extends Logger {
                   this.hls.nextLoadLevel = 0;
                 }
               }
+            } else if (decodingInfo.decodingInfoResults.some(info => info.smooth === false || info.powerEfficient === false)) {
+              this.log(`MediaCapabilities decodingInfo for level ${index} not smooth or powerEfficient: ${stringify(decodingInfo)}`);
             }
           });
         } else {
@@ -3960,7 +4009,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;
@@ -10218,7 +10267,7 @@ function requireEventemitter3 () {
 var eventemitter3Exports = requireEventemitter3();
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-const version = "1.6.6-0.canary.11352";
+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